--- /srv/rebuilderd/tmp/rebuilderdjgXLhS/inputs/libjs-openlayers_2.13.1+ds2-11_all.deb +++ /srv/rebuilderd/tmp/rebuilderdjgXLhS/out/libjs-openlayers_2.13.1+ds2-11_all.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2025-03-06 18:35:30.000000 debian-binary │ -rw-r--r-- 0 0 0 3684 2025-03-06 18:35:30.000000 control.tar.xz │ --rw-r--r-- 0 0 0 710500 2025-03-06 18:35:30.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 715604 2025-03-06 18:35:30.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./md5sums │ │ │ ├── ./md5sums │ │ │ │┄ Files differ ├── data.tar.xz │ ├── data.tar │ │ ├── ./usr/share/javascript/openlayers/OpenLayers.js │ │ │ ├── js-beautify {} │ │ │ │ @@ -52,37 +52,14 @@ │ │ │ │ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS │ │ │ │ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN │ │ │ │ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) │ │ │ │ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE │ │ │ │ * POSSIBILITY OF SUCH DAMAGE. │ │ │ │ */ │ │ │ │ /* ====================================================================== │ │ │ │ - Rico/license.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @license Apache 2 │ │ │ │ - * │ │ │ │ - * 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-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -540,14 +517,37 @@ │ │ │ │ OpenLayers.Util.extend(OpenLayers.Console, console); │ │ │ │ break; │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ })(); │ │ │ │ /* ====================================================================== │ │ │ │ + Rico/license.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @license Apache 2 │ │ │ │ + * │ │ │ │ + * 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/BaseTypes.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -5083,1449 +5083,1086 @@ │ │ │ │ return this._hasString(this.options.corners, "all", "bottom", "bl", "br"); │ │ │ │ }, │ │ │ │ _hasSingleTextChild: function(el) { │ │ │ │ return el.childNodes.length == 1 && el.childNodes[0].nodeType == 3; │ │ │ │ } │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Feature.js │ │ │ │ + OpenLayers/Popup.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Feature │ │ │ │ - * Features are combinations of geography and attributes. The OpenLayers.Feature │ │ │ │ - * class specifically combines a marker and a lonlat. │ │ │ │ + * 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.Feature = OpenLayers.Class({ │ │ │ │ +OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {} │ │ │ │ + * Property: events │ │ │ │ + * {} custom event manager │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + events: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ + /** Property: id │ │ │ │ + * {String} the unique identifier assigned to this popup. │ │ │ │ */ │ │ │ │ - id: null, │ │ │ │ + id: "", │ │ │ │ │ │ │ │ /** │ │ │ │ * Property: lonlat │ │ │ │ - * {} │ │ │ │ + * {} the position of this popup on the map │ │ │ │ */ │ │ │ │ lonlat: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: data │ │ │ │ - * {Object} │ │ │ │ + * Property: div │ │ │ │ + * {DOMElement} the div that contains this popup. │ │ │ │ */ │ │ │ │ - data: null, │ │ │ │ + div: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: marker │ │ │ │ - * {} │ │ │ │ + * Property: contentSize │ │ │ │ + * {} the width and height of the content. │ │ │ │ */ │ │ │ │ - marker: null, │ │ │ │ + contentSize: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: popupClass │ │ │ │ - * {} The class which will be used to instantiate │ │ │ │ - * a new Popup. Default is . │ │ │ │ + /** │ │ │ │ + * Property: size │ │ │ │ + * {} the width and height of the popup. │ │ │ │ */ │ │ │ │ - popupClass: null, │ │ │ │ + size: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: popup │ │ │ │ - * {} │ │ │ │ + * Property: contentHTML │ │ │ │ + * {String} An HTML string for this popup to display. │ │ │ │ */ │ │ │ │ - popup: null, │ │ │ │ + contentHTML: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Feature │ │ │ │ - * Constructor for features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {} │ │ │ │ - * lonlat - {} │ │ │ │ - * data - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} │ │ │ │ + * Property: backgroundColor │ │ │ │ + * {String} the background color used by the popup. │ │ │ │ */ │ │ │ │ - initialize: function(layer, lonlat, data) { │ │ │ │ - this.layer = layer; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - this.data = (data != null) ? data : {}; │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ + backgroundColor: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ + * Property: opacity │ │ │ │ + * {float} the opacity of this popup (between 0.0 and 1.0) │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - │ │ │ │ - //remove the popup from the map │ │ │ │ - if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.layer.map.removePopup(this.popup); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // remove the marker from the layer │ │ │ │ - if (this.layer != null && this.marker != null) { │ │ │ │ - this.layer.removeMarker(this.marker); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.layer = null; │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.data = null; │ │ │ │ - if (this.marker != null) { │ │ │ │ - this.destroyMarker(this.marker); │ │ │ │ - this.marker = null; │ │ │ │ - } │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.destroyPopup(this.popup); │ │ │ │ - this.popup = null; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + opacity: "", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onScreen │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the feature is currently visible on screen │ │ │ │ - * (based on its 'lonlat' property) │ │ │ │ + /** │ │ │ │ + * Property: border │ │ │ │ + * {String} the border size of the popup. (eg 2px) │ │ │ │ */ │ │ │ │ - onScreen: function() { │ │ │ │ - │ │ │ │ - var onScreen = false; │ │ │ │ - if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsLonLat(this.lonlat); │ │ │ │ - } │ │ │ │ - return onScreen; │ │ │ │ - }, │ │ │ │ + border: "", │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Property: contentDiv │ │ │ │ + * {DOMElement} a reference to the element that holds the content of │ │ │ │ + * the div. │ │ │ │ + */ │ │ │ │ + contentDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createMarker │ │ │ │ - * Based on the data associated with the Feature, create and return a marker object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} A Marker Object created from the 'lonlat' and 'icon' properties │ │ │ │ - * set in this.data. If no 'lonlat' is set, returns null. If no │ │ │ │ - * 'icon' is set, OpenLayers.Marker() will load the default image. │ │ │ │ - * │ │ │ │ - * Note - this.marker is set to return value │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Property: groupDiv │ │ │ │ + * {DOMElement} First and only child of 'div'. The group Div contains the │ │ │ │ + * 'contentDiv' and the 'closeDiv'. │ │ │ │ */ │ │ │ │ - createMarker: function() { │ │ │ │ + groupDiv: null, │ │ │ │ │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon); │ │ │ │ - } │ │ │ │ - return this.marker; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: closeDiv │ │ │ │ + * {DOMElement} the optional closer image │ │ │ │ + */ │ │ │ │ + closeDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroyMarker │ │ │ │ - * Destroys marker. │ │ │ │ - * If user overrides the createMarker() function, s/he should be able │ │ │ │ - * to also specify an alternative function for destroying it │ │ │ │ + /** │ │ │ │ + * APIProperty: autoSize │ │ │ │ + * {Boolean} Resize the popup to auto-fit the contents. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - destroyMarker: function() { │ │ │ │ - this.marker.destroy(); │ │ │ │ - }, │ │ │ │ + autoSize: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createPopup │ │ │ │ - * Creates a popup object created from the 'lonlat', 'popupSize', │ │ │ │ - * and 'popupContentHTML' properties set in this.data. It uses │ │ │ │ - * this.marker.icon as default anchor. │ │ │ │ - * │ │ │ │ - * If no 'lonlat' is set, returns null. │ │ │ │ - * If no this.marker has been created, no anchor is sent. │ │ │ │ - * │ │ │ │ - * Note - the returned popup object is 'owned' by the feature, so you │ │ │ │ - * cannot use the popup's destroy method to discard the popup. │ │ │ │ - * Instead, you must use the feature's destroyPopup │ │ │ │ - * │ │ │ │ - * Note - this.popup is set to return value │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * closeBox - {Boolean} create popup with closebox or not │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} Returns the created popup, which is also set │ │ │ │ - * as 'popup' property of this feature. Will be of whatever type │ │ │ │ - * specified by this feature's 'popupClass' property, but must be │ │ │ │ - * of type . │ │ │ │ - * │ │ │ │ + * APIProperty: minSize │ │ │ │ + * {} Minimum size allowed for the popup's contents. │ │ │ │ */ │ │ │ │ - createPopup: function(closeBox) { │ │ │ │ - │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - if (!this.popup) { │ │ │ │ - var anchor = (this.marker) ? this.marker.icon : null; │ │ │ │ - var popupClass = this.popupClass ? │ │ │ │ - this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ - this.popup = new popupClass(this.id + "_popup", │ │ │ │ - this.lonlat, │ │ │ │ - this.data.popupSize, │ │ │ │ - this.data.popupContentHTML, │ │ │ │ - anchor, │ │ │ │ - closeBox); │ │ │ │ - } │ │ │ │ - if (this.data.overflow != null) { │ │ │ │ - this.popup.contentDiv.style.overflow = this.data.overflow; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.popup.feature = this; │ │ │ │ - } │ │ │ │ - return this.popup; │ │ │ │ - }, │ │ │ │ - │ │ │ │ + minSize: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroyPopup │ │ │ │ - * Destroys the popup created via createPopup. │ │ │ │ - * │ │ │ │ - * As with the marker, if user overrides the createPopup() function, s/he │ │ │ │ - * should also be able to override the destruction │ │ │ │ + * APIProperty: maxSize │ │ │ │ + * {} Maximum size allowed for the popup's contents. │ │ │ │ */ │ │ │ │ - destroyPopup: function() { │ │ │ │ - if (this.popup) { │ │ │ │ - this.popup.feature = null; │ │ │ │ - this.popup.destroy(); │ │ │ │ - this.popup = null; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Feature" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Feature/Vector.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -// TRASH THIS │ │ │ │ -OpenLayers.State = { │ │ │ │ - /** states */ │ │ │ │ - UNKNOWN: 'Unknown', │ │ │ │ - INSERT: 'Insert', │ │ │ │ - UPDATE: 'Update', │ │ │ │ - DELETE: 'Delete' │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Feature.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Feature.Vector │ │ │ │ - * Vector features use the OpenLayers.Geometry classes as geometry description. │ │ │ │ - * They have an 'attributes' property, which is the data object, and a 'style' │ │ │ │ - * property, the default values of which are defined in the │ │ │ │ - * objects. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - │ │ │ │ - */ │ │ │ │ -OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ + maxSize: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: fid │ │ │ │ - * {String} │ │ │ │ + * Property: displayClass │ │ │ │ + * {String} The CSS class of the popup. │ │ │ │ */ │ │ │ │ - fid: null, │ │ │ │ + displayClass: "olPopup", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: geometry │ │ │ │ - * {} │ │ │ │ + * Property: contentDisplayClass │ │ │ │ + * {String} The CSS class of the popup content div. │ │ │ │ */ │ │ │ │ - geometry: null, │ │ │ │ + contentDisplayClass: "olPopupContent", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: attributes │ │ │ │ - * {Object} This object holds arbitrary, serializable properties that │ │ │ │ - * describe the feature. │ │ │ │ - */ │ │ │ │ - attributes: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: bounds │ │ │ │ - * {} The box bounding that feature's geometry, that │ │ │ │ - * property can be set by an object when │ │ │ │ - * deserializing the feature, so in most cases it represents an │ │ │ │ - * information set by the server. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - bounds: null, │ │ │ │ + padding: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: state │ │ │ │ - * {String} │ │ │ │ + * Property: disableFirefoxOverflowHack │ │ │ │ + * {Boolean} The hack for overflow in Firefox causes all elements │ │ │ │ + * to be re-drawn, which causes Flash elements to be │ │ │ │ + * re-initialized, which is troublesome. │ │ │ │ + * With this property the hack can be disabled. │ │ │ │ */ │ │ │ │ - state: null, │ │ │ │ + disableFirefoxOverflowHack: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: style │ │ │ │ - * {Object} │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - style: null, │ │ │ │ + fixPadding: function() { │ │ │ │ + if (typeof this.padding == "number") { │ │ │ │ + this.padding = new OpenLayers.Bounds( │ │ │ │ + this.padding, this.padding, this.padding, this.padding │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} If this property is set it will be taken into account by │ │ │ │ - * {} when upadting or deleting the feature. │ │ │ │ + * APIProperty: panMapIfOutOfView │ │ │ │ + * {Boolean} When drawn, pan map such that the entire popup is visible in │ │ │ │ + * the current viewport (if necessary). │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + panMapIfOutOfView: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: renderIntent │ │ │ │ - * {String} rendering intent currently being used │ │ │ │ + * APIProperty: keepInMap │ │ │ │ + * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ + * contrain the popup such that it always fits in the available map │ │ │ │ + * space. By default, this is not set on the base class. If you are │ │ │ │ + * creating popups that are near map edges and not allowing pannning, │ │ │ │ + * and especially if you have a popup which has a │ │ │ │ + * fixedRelativePosition, setting this to false may be a smart thing to │ │ │ │ + * do. Subclasses may want to override this setting. │ │ │ │ + * │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - renderIntent: "default", │ │ │ │ + keepInMap: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: modified │ │ │ │ - * {Object} An object with the originals of the geometry and attributes of │ │ │ │ - * the feature, if they were changed. Currently this property is only read │ │ │ │ - * by , and written by │ │ │ │ - * , which sets the geometry property. │ │ │ │ - * Applications can set the originals of modified attributes in the │ │ │ │ - * attributes property. Note that applications have to check if this │ │ │ │ - * object and the attributes property is already created before using it. │ │ │ │ - * After a change made with ModifyFeature, this object could look like │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * { │ │ │ │ - * geometry: >Object │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * When an application has made changes to feature attributes, it could │ │ │ │ - * have set the attributes to something like this: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * { │ │ │ │ - * attributes: { │ │ │ │ - * myAttribute: "original" │ │ │ │ - * } │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Note that only checks for truthy values in │ │ │ │ - * *modified.geometry* and the attribute names in *modified.attributes*, │ │ │ │ - * but it is recommended to set the original values (and not just true) as │ │ │ │ - * attribute value, so applications could use this information to undo │ │ │ │ - * changes. │ │ │ │ + * APIProperty: closeOnMove │ │ │ │ + * {Boolean} When map pans, close the popup. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - modified: null, │ │ │ │ + closeOnMove: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Feature.Vector │ │ │ │ - * Create a vector feature. │ │ │ │ + * 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: │ │ │ │ - * geometry - {} The geometry that this feature │ │ │ │ - * represents. │ │ │ │ - * attributes - {Object} An optional object that will be mapped to the │ │ │ │ - * property. │ │ │ │ - * style - {Object} An optional style object. │ │ │ │ + * 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. │ │ │ │ + * contentSize - {} The size of the content. │ │ │ │ + * contentHTML - {String} An HTML string 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(geometry, attributes, style) { │ │ │ │ - OpenLayers.Feature.prototype.initialize.apply(this, │ │ │ │ - [null, null, attributes]); │ │ │ │ - this.lonlat = null; │ │ │ │ - this.geometry = geometry ? geometry : null; │ │ │ │ - this.state = null; │ │ │ │ - this.attributes = {}; │ │ │ │ - if (attributes) { │ │ │ │ - this.attributes = OpenLayers.Util.extend(this.attributes, │ │ │ │ - attributes); │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ + if (id == null) { │ │ │ │ + id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ } │ │ │ │ - this.style = style ? style : null; │ │ │ │ + │ │ │ │ + this.id = id; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + │ │ │ │ + this.contentSize = (contentSize != null) ? contentSize : │ │ │ │ + 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 = this.displayClass; │ │ │ │ + │ │ │ │ + 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.contentSize.clone(), │ │ │ │ + null, "relative"); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass; │ │ │ │ + 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() { │ │ │ │ - if (this.layer) { │ │ │ │ - this.layer.removeFeatures(this); │ │ │ │ - this.layer = null; │ │ │ │ + │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.size = null; │ │ │ │ + this.contentHTML = null; │ │ │ │ + │ │ │ │ + this.backgroundColor = null; │ │ │ │ + this.opacity = null; │ │ │ │ + this.border = null; │ │ │ │ + │ │ │ │ + if (this.closeOnMove && this.map) { │ │ │ │ + this.map.events.unregister("movestart", this, this.hide); │ │ │ │ } │ │ │ │ │ │ │ │ - this.geometry = null; │ │ │ │ - this.modified = null; │ │ │ │ - OpenLayers.Feature.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - * Create a clone of this vector feature. Does not set any non-standard │ │ │ │ - * properties. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} An exact clone of this vector feature. │ │ │ │ - */ │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Feature.Vector( │ │ │ │ - this.geometry ? this.geometry.clone() : null, │ │ │ │ - this.attributes, │ │ │ │ - this.style); │ │ │ │ + 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: onScreen │ │ │ │ - * Determine whether the feature is within the map viewport. This method │ │ │ │ - * tests for an intersection between the geometry and the viewport │ │ │ │ - * bounds. If a more effecient but less precise geometry bounds │ │ │ │ - * intersection is desired, call the method with the boundsOnly │ │ │ │ - * parameter true. │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * Constructs the elements that make up the popup. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * boundsOnly - {Boolean} Only test whether a feature's bounds intersects │ │ │ │ - * the viewport bounds. Default is false. If false, the feature's │ │ │ │ - * geometry must intersect the viewport for onScreen to return true. │ │ │ │ + * px - {} the position the popup in pixels. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The feature is currently visible on screen (optionally │ │ │ │ - * based on its bounds if boundsOnly is true). │ │ │ │ + * {DOMElement} Reference to a div that contains the drawn popup │ │ │ │ */ │ │ │ │ - onScreen: function(boundsOnly) { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.layer && this.layer.map) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - if (boundsOnly) { │ │ │ │ - var featureBounds = this.geometry.getBounds(); │ │ │ │ - onScreen = screenBounds.intersectsBounds(featureBounds); │ │ │ │ - } else { │ │ │ │ - var screenPoly = screenBounds.toGeometry(); │ │ │ │ - onScreen = screenPoly.intersects(this.geometry); │ │ │ │ + draw: function(px) { │ │ │ │ + if (px == null) { │ │ │ │ + if ((this.lonlat != null) && (this.map != null)) { │ │ │ │ + px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ } │ │ │ │ } │ │ │ │ - return onScreen; │ │ │ │ + │ │ │ │ + // this assumes that this.map already exists, which is okay because │ │ │ │ + // this.draw is only called once the popup has been added to the map. │ │ │ │ + if (this.closeOnMove) { │ │ │ │ + this.map.events.register("movestart", this, this.hide); │ │ │ │ + } │ │ │ │ + │ │ │ │ + //listen to movestart, moveend to disable overflow (FF bug) │ │ │ │ + if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == '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.size) { │ │ │ │ + this.setSize(this.contentSize); │ │ │ │ + } │ │ │ │ + this.setBackgroundColor(); │ │ │ │ + this.setOpacity(); │ │ │ │ + this.setBorder(); │ │ │ │ + this.setContentHTML(); │ │ │ │ + │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView(); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getVisibility │ │ │ │ - * Determine whether the feature is displayed or not. It may not displayed │ │ │ │ - * because: │ │ │ │ - * - its style display property is set to 'none', │ │ │ │ - * - it doesn't belong to any layer, │ │ │ │ - * - the styleMap creates a symbolizer with display property set to 'none' │ │ │ │ - * for it, │ │ │ │ - * - the layer which it belongs to is not visible. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The feature is currently displayed. │ │ │ │ + /** │ │ │ │ + * Method: updatePosition │ │ │ │ + * if the popup has a lonlat and its map members set, │ │ │ │ + * then have it move itself to its proper position │ │ │ │ */ │ │ │ │ - getVisibility: function() { │ │ │ │ - return !(this.style && this.style.display == 'none' || │ │ │ │ - !this.layer || │ │ │ │ - this.layer && this.layer.styleMap && │ │ │ │ - this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == 'none' || │ │ │ │ - this.layer && !this.layer.getVisibility()); │ │ │ │ + updatePosition: function() { │ │ │ │ + if ((this.lonlat) && (this.map)) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + if (px) { │ │ │ │ + this.moveTo(px); │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createMarker │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * create markers │ │ │ │ + * Method: moveTo │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {} For now just returns null │ │ │ │ + * Parameters: │ │ │ │ + * px - {} the top and left position of the popup div. │ │ │ │ */ │ │ │ │ - createMarker: function() { │ │ │ │ - return null; │ │ │ │ + moveTo: function(px) { │ │ │ │ + if ((px != null) && (this.div != null)) { │ │ │ │ + this.div.style.left = px.x + "px"; │ │ │ │ + this.div.style.top = px.y + "px"; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroyMarker │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * delete markers │ │ │ │ - * │ │ │ │ - * If user overrides the createMarker() function, s/he should be able │ │ │ │ - * to also specify an alternative function for destroying it │ │ │ │ + * Method: visible │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Boolean indicating whether or not the popup is visible │ │ │ │ */ │ │ │ │ - destroyMarker: function() { │ │ │ │ - // pass │ │ │ │ + visible: function() { │ │ │ │ + return OpenLayers.Element.visible(this.div); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createPopup │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * create popups │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} For now just returns null │ │ │ │ + * Method: toggle │ │ │ │ + * Toggles visibility of the popup. │ │ │ │ */ │ │ │ │ - createPopup: function() { │ │ │ │ - return null; │ │ │ │ + toggle: function() { │ │ │ │ + if (this.visible()) { │ │ │ │ + this.hide(); │ │ │ │ + } else { │ │ │ │ + this.show(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: atPoint │ │ │ │ - * Determins whether the feature intersects with the specified location. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * lonlat - {|Object} OpenLayers.LonLat or an │ │ │ │ - * object with a 'lon' and 'lat' properties. │ │ │ │ - * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ - * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the feature is at the specified location │ │ │ │ + * Method: show │ │ │ │ + * Makes the popup visible. │ │ │ │ */ │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - if (this.geometry) { │ │ │ │ - atPoint = this.geometry.atPoint(lonlat, toleranceLon, │ │ │ │ - toleranceLat); │ │ │ │ + show: function() { │ │ │ │ + this.div.style.display = ''; │ │ │ │ + │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView(); │ │ │ │ } │ │ │ │ - return atPoint; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroyPopup │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * delete popups │ │ │ │ + * Method: hide │ │ │ │ + * Makes the popup invisible. │ │ │ │ */ │ │ │ │ - destroyPopup: function() { │ │ │ │ - // pass │ │ │ │ + hide: function() { │ │ │ │ + this.div.style.display = 'none'; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: move │ │ │ │ - * Moves the feature and redraws it at its new location │ │ │ │ + * Method: setSize │ │ │ │ + * Used to adjust the size of the popup. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * location - { or } the │ │ │ │ - * location to which to move the feature. │ │ │ │ + * contentSize - {} the new size for the popup's │ │ │ │ + * contents div (in pixels). │ │ │ │ */ │ │ │ │ - move: function(location) { │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + this.size = contentSize.clone(); │ │ │ │ │ │ │ │ - if (!this.layer || !this.geometry.move) { │ │ │ │ - //do nothing if no layer or immoveable geometry │ │ │ │ - return undefined; │ │ │ │ + // 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; │ │ │ │ } │ │ │ │ │ │ │ │ - var pixel; │ │ │ │ - if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ - pixel = this.layer.getViewPortPxFromLonLat(location); │ │ │ │ - } else { │ │ │ │ - pixel = location; │ │ │ │ + //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.BROWSER_NAME == "msie") { │ │ │ │ + this.contentSize.w += │ │ │ │ + contentDivPadding.left + contentDivPadding.right; │ │ │ │ + this.contentSize.h += │ │ │ │ + contentDivPadding.bottom + contentDivPadding.top; │ │ │ │ } │ │ │ │ │ │ │ │ - var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ - var res = this.layer.map.getResolution(); │ │ │ │ - this.geometry.move(res * (pixel.x - lastPixel.x), │ │ │ │ - res * (lastPixel.y - pixel.y)); │ │ │ │ - this.layer.drawFeature(this); │ │ │ │ - return lastPixel; │ │ │ │ + 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: toState │ │ │ │ - * Sets the new state │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * state - {String} │ │ │ │ + * APIMethod: updateSize │ │ │ │ + * Auto size the popup so that it precisely fits its contents (as │ │ │ │ + * determined by this.contentDiv.innerHTML). Popup size will, of │ │ │ │ + * course, be limited by the available space on the current map │ │ │ │ */ │ │ │ │ - toState: function(state) { │ │ │ │ - if (state == OpenLayers.State.UPDATE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.INSERT) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.DELETE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - // the feature should be destroyed │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ - this.state = state; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ -}); │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Feature.Vector.style │ │ │ │ - * OpenLayers features can have a number of style attributes. The 'default' │ │ │ │ - * style will typically be used if no other style is specified. These │ │ │ │ - * styles correspond for the most part, to the styling properties defined │ │ │ │ - * by the SVG standard. │ │ │ │ - * Information on fill properties: http://www.w3.org/TR/SVG/painting.html#FillProperties │ │ │ │ - * Information on stroke properties: http://www.w3.org/TR/SVG/painting.html#StrokeProperties │ │ │ │ - * │ │ │ │ - * Symbolizer properties: │ │ │ │ - * fill - {Boolean} Set to false if no fill is desired. │ │ │ │ - * fillColor - {String} Hex fill color. Default is "#ee9900". │ │ │ │ - * fillOpacity - {Number} Fill opacity (0-1). Default is 0.4 │ │ │ │ - * stroke - {Boolean} Set to false if no stroke is desired. │ │ │ │ - * strokeColor - {String} Hex stroke color. Default is "#ee9900". │ │ │ │ - * strokeOpacity - {Number} Stroke opacity (0-1). Default is 1. │ │ │ │ - * strokeWidth - {Number} Pixel stroke width. Default is 1. │ │ │ │ - * strokeLinecap - {String} Stroke cap type. Default is "round". [butt | round | square] │ │ │ │ - * strokeDashstyle - {String} Stroke dash style. Default is "solid". [dot | dash | dashdot | longdash | longdashdot | solid] │ │ │ │ - * graphic - {Boolean} Set to false if no graphic is desired. │ │ │ │ - * pointRadius - {Number} Pixel point radius. Default is 6. │ │ │ │ - * pointerEvents - {String} Default is "visiblePainted". │ │ │ │ - * cursor - {String} Default is "". │ │ │ │ - * externalGraphic - {String} Url to an external graphic that will be used for rendering points. │ │ │ │ - * graphicWidth - {Number} Pixel width for sizing an external graphic. │ │ │ │ - * graphicHeight - {Number} Pixel height for sizing an external graphic. │ │ │ │ - * graphicOpacity - {Number} Opacity (0-1) for an external graphic. │ │ │ │ - * graphicXOffset - {Number} Pixel offset along the positive x axis for displacing an external graphic. │ │ │ │ - * graphicYOffset - {Number} Pixel offset along the positive y axis for displacing an external graphic. │ │ │ │ - * rotation - {Number} For point symbolizers, this is the rotation of a graphic in the clockwise direction about its center point (or any point off center as specified by graphicXOffset and graphicYOffset). │ │ │ │ - * graphicZIndex - {Number} The integer z-index value to use in rendering. │ │ │ │ - * graphicName - {String} Named graphic to use when rendering points. Supported values include "circle" (default), │ │ │ │ - * "square", "star", "x", "cross", "triangle". │ │ │ │ - * graphicTitle - {String} Tooltip when hovering over a feature. *deprecated*, use title instead │ │ │ │ - * title - {String} Tooltip when hovering over a feature. Not supported by the canvas renderer. │ │ │ │ - * backgroundGraphic - {String} Url to a graphic to be used as the background under an externalGraphic. │ │ │ │ - * backgroundGraphicZIndex - {Number} The integer z-index value to use in rendering the background graphic. │ │ │ │ - * backgroundXOffset - {Number} The x offset (in pixels) for the background graphic. │ │ │ │ - * backgroundYOffset - {Number} The y offset (in pixels) for the background graphic. │ │ │ │ - * backgroundHeight - {Number} The height of the background graphic. If not provided, the graphicHeight will be used. │ │ │ │ - * backgroundWidth - {Number} The width of the background width. If not provided, the graphicWidth will be used. │ │ │ │ - * label - {String} The text for an optional label. For browsers that use the canvas renderer, this requires either │ │ │ │ - * fillText or mozDrawText to be available. │ │ │ │ - * labelAlign - {String} Label alignment. This specifies the insertion point relative to the text. It is a string │ │ │ │ - * composed of two characters. The first character is for the horizontal alignment, the second for the vertical │ │ │ │ - * alignment. Valid values for horizontal alignment: "l"=left, "c"=center, "r"=right. Valid values for vertical │ │ │ │ - * alignment: "t"=top, "m"=middle, "b"=bottom. Example values: "lt", "cm", "rb". Default is "cm". │ │ │ │ - * labelXOffset - {Number} Pixel offset along the positive x axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ - * labelYOffset - {Number} Pixel offset along the positive y axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ - * labelSelect - {Boolean} If set to true, labels will be selectable using SelectFeature or similar controls. │ │ │ │ - * Default is false. │ │ │ │ - * labelOutlineColor - {String} The color of the label outline. Default is 'white'. Only supported by the canvas & SVG renderers. │ │ │ │ - * labelOutlineWidth - {Number} The width of the label outline. Default is 3, set to 0 or null to disable. Only supported by the SVG renderers. │ │ │ │ - * labelOutlineOpacity - {Number} The opacity (0-1) of the label outline. Default is fontOpacity. Only supported by the canvas & SVG renderers. │ │ │ │ - * fontColor - {String} The font color for the label, to be provided like CSS. │ │ │ │ - * fontOpacity - {Number} Opacity (0-1) for the label │ │ │ │ - * fontFamily - {String} The font family for the label, to be provided like in CSS. │ │ │ │ - * fontSize - {String} The font size for the label, to be provided like in CSS. │ │ │ │ - * fontStyle - {String} The font style for the label, to be provided like in CSS. │ │ │ │ - * fontWeight - {String} The font weight for the label, to be provided like in CSS. │ │ │ │ - * display - {String} Symbolizers will have no effect if display is set to "none". All other values have no effect. │ │ │ │ - */ │ │ │ │ -OpenLayers.Feature.Vector.style = { │ │ │ │ - 'default': { │ │ │ │ - fillColor: "#ee9900", │ │ │ │ - fillOpacity: 0.4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: 0.8, │ │ │ │ - strokeColor: "#ee9900", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: 0.2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - 'select': { │ │ │ │ - fillColor: "blue", │ │ │ │ - fillOpacity: 0.4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: 0.8, │ │ │ │ - strokeColor: "blue", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: 0.2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "pointer", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ + updateSize: function() { │ │ │ │ │ │ │ │ - }, │ │ │ │ - 'temporary': { │ │ │ │ - fillColor: "#66cccc", │ │ │ │ - fillOpacity: 0.2, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: 0.8, │ │ │ │ - strokeColor: "#66cccc", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: 0.2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ + // determine actual render dimensions of the contents by putting its │ │ │ │ + // contents into a fake contentDiv (for the CSS) and then measuring it │ │ │ │ + var preparedHTML = "
" + │ │ │ │ + this.contentDiv.innerHTML + │ │ │ │ + "
"; │ │ │ │ │ │ │ │ - }, │ │ │ │ - 'delete': { │ │ │ │ - display: "none" │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Style.js │ │ │ │ - ====================================================================== */ │ │ │ │ + var containerElement = (this.map) ? this.map.div : document.body; │ │ │ │ + var realSize = OpenLayers.Util.getRenderedDimensions( │ │ │ │ + preparedHTML, null, { │ │ │ │ + displayClass: this.displayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + } │ │ │ │ + ); │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + // 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; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - */ │ │ │ │ + } else { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Style │ │ │ │ - * This class represents a UserStyle obtained │ │ │ │ - * from a SLD, containing styling rules. │ │ │ │ - */ │ │ │ │ -OpenLayers.Style = OpenLayers.Class({ │ │ │ │ + // make a new 'size' object with the clipped dimensions │ │ │ │ + // set or null if not clipped. │ │ │ │ + var fixedSize = { │ │ │ │ + w: (safeSize.w < realSize.w) ? safeSize.w : null, │ │ │ │ + h: (safeSize.h < realSize.h) ? safeSize.h : null │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique id for this session. │ │ │ │ - */ │ │ │ │ - id: 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( │ │ │ │ + preparedHTML, fixedSize, { │ │ │ │ + displayClass: this.contentDisplayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + } │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - name: null, │ │ │ │ + //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; │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: title │ │ │ │ - * {String} Title of this style (set if included in SLD) │ │ │ │ - */ │ │ │ │ - title: null, │ │ │ │ + newSize = this.getSafeContentSize(clippedSize); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.setSize(newSize); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: description │ │ │ │ - * {String} Description of this style (set if abstract is included in SLD) │ │ │ │ + * Method: setBackgroundColor │ │ │ │ + * Sets the background color of the popup. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * color - {String} the background color. eg "#FFBBBB" │ │ │ │ */ │ │ │ │ - description: null, │ │ │ │ + setBackgroundColor: function(color) { │ │ │ │ + if (color != undefined) { │ │ │ │ + this.backgroundColor = color; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: layerName │ │ │ │ - * {} name of the layer that this style belongs to, usually │ │ │ │ - * according to the NamedLayer attribute of an SLD document. │ │ │ │ - */ │ │ │ │ - layerName: null, │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.backgroundColor = this.backgroundColor; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: isDefault │ │ │ │ - * {Boolean} │ │ │ │ + * Method: setOpacity │ │ │ │ + * Sets the opacity of the popup. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ */ │ │ │ │ - isDefault: false, │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + if (opacity != undefined) { │ │ │ │ + this.opacity = opacity; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: rules │ │ │ │ - * {Array()} │ │ │ │ - */ │ │ │ │ - rules: null, │ │ │ │ + if (this.div != null) { │ │ │ │ + // for Mozilla and Safari │ │ │ │ + this.div.style.opacity = this.opacity; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: context │ │ │ │ - * {Object} An optional object with properties that symbolizers' property │ │ │ │ - * values should be evaluated against. If no context is specified, │ │ │ │ - * feature.attributes will be used │ │ │ │ - */ │ │ │ │ - context: null, │ │ │ │ + // for IE │ │ │ │ + this.div.style.filter = 'alpha(opacity=' + this.opacity * 100 + ')'; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultStyle │ │ │ │ - * {Object} hash of style properties to use as default for merging │ │ │ │ - * rule-based style symbolizers onto. If no rules are defined, │ │ │ │ - * createSymbolizer will return this style. If is set to │ │ │ │ - * true, the defaultStyle will only be taken into account if there are │ │ │ │ - * rules defined. │ │ │ │ + * Method: setBorder │ │ │ │ + * Sets the border style of the popup. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * border - {String} The border style value. eg 2px │ │ │ │ */ │ │ │ │ - defaultStyle: null, │ │ │ │ + setBorder: function(border) { │ │ │ │ + if (border != undefined) { │ │ │ │ + this.border = border; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: defaultsPerSymbolizer │ │ │ │ - * {Boolean} If set to true, the will extend the symbolizer │ │ │ │ - * of every rule. Properties of the will also be used to set │ │ │ │ - * missing symbolizer properties if the symbolizer has stroke, fill or │ │ │ │ - * graphic set to true. Default is false. │ │ │ │ - */ │ │ │ │ - defaultsPerSymbolizer: false, │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.border = this.border; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: propertyStyles │ │ │ │ - * {Hash of Boolean} cache of style properties that need to be parsed for │ │ │ │ - * propertyNames. Property names are keys, values won't be used. │ │ │ │ - */ │ │ │ │ - propertyStyles: null, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Style │ │ │ │ - * Creates a UserStyle. │ │ │ │ + * Method: setContentHTML │ │ │ │ + * Allows the user to set the HTML content of the popup. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * style - {Object} Optional hash of style properties that will be │ │ │ │ - * used as default style for this style object. This style │ │ │ │ - * applies if no rules are specified. Symbolizers defined in │ │ │ │ - * rules will extend this default style. │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * style. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * rules - {Array()} List of rules to be added to the │ │ │ │ - * style. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} │ │ │ │ + * contentHTML - {String} HTML for the div. │ │ │ │ */ │ │ │ │ - initialize: function(style, options) { │ │ │ │ + setContentHTML: function(contentHTML) { │ │ │ │ │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.rules = []; │ │ │ │ - if (options && options.rules) { │ │ │ │ - this.addRules(options.rules); │ │ │ │ + if (contentHTML != null) { │ │ │ │ + this.contentHTML = contentHTML; │ │ │ │ } │ │ │ │ │ │ │ │ - // use the default style from OpenLayers.Feature.Vector if no style │ │ │ │ - // was given in the constructor │ │ │ │ - this.setDefaultStyle(style || │ │ │ │ - OpenLayers.Feature.Vector.style["default"]); │ │ │ │ + if ((this.contentDiv != null) && │ │ │ │ + (this.contentHTML != null) && │ │ │ │ + (this.contentHTML != this.contentDiv.innerHTML)) { │ │ │ │ │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ + this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ - this.rules[i].destroy(); │ │ │ │ - this.rules[i] = null; │ │ │ │ + if (this.autoSize) { │ │ │ │ + │ │ │ │ + //if popup has images, listen for when they finish │ │ │ │ + // loading and resize accordingly │ │ │ │ + this.registerImageListeners(); │ │ │ │ + │ │ │ │ + //auto size the popup to its current contents │ │ │ │ + this.updateSize(); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.rules = null; │ │ │ │ - this.defaultStyle = null; │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createSymbolizer │ │ │ │ - * creates a style by applying all feature-dependent rules to the base │ │ │ │ - * style. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {} feature to evaluate rules for │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} symbolizer hash │ │ │ │ + * Method: registerImageListeners │ │ │ │ + * Called when an image contained by the popup loaded. this function │ │ │ │ + * updates the popup size, then unregisters the image load listener. │ │ │ │ */ │ │ │ │ - createSymbolizer: function(feature) { │ │ │ │ - var style = this.defaultsPerSymbolizer ? {} : this.createLiterals( │ │ │ │ - OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ - │ │ │ │ - var rules = this.rules; │ │ │ │ - │ │ │ │ - var rule, context; │ │ │ │ - var elseRules = []; │ │ │ │ - var appliedRules = false; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - rule = rules[i]; │ │ │ │ - // does the rule apply? │ │ │ │ - var applies = rule.evaluate(feature); │ │ │ │ + registerImageListeners: function() { │ │ │ │ │ │ │ │ - if (applies) { │ │ │ │ - if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ - elseRules.push(rule); │ │ │ │ - } else { │ │ │ │ - appliedRules = true; │ │ │ │ - this.applySymbolizer(rule, style, feature); │ │ │ │ - } │ │ │ │ + // As the images load, this function will call updateSize() to │ │ │ │ + // resize the popup to fit the content div (which presumably is now │ │ │ │ + // bigger than when the image was not loaded). │ │ │ │ + // │ │ │ │ + // If the 'panMapIfOutOfView' property is set, we will pan the newly │ │ │ │ + // resized popup back into view. │ │ │ │ + // │ │ │ │ + // Note that this function, when called, will have 'popup' and │ │ │ │ + // 'img' properties in the context. │ │ │ │ + // │ │ │ │ + var onImgLoad = function() { │ │ │ │ + if (this.popup.id === null) { // this.popup has been destroyed! │ │ │ │ + return; │ │ │ │ } │ │ │ │ - } │ │ │ │ + this.popup.updateSize(); │ │ │ │ │ │ │ │ - // if no other rules apply, apply the rules with else filters │ │ │ │ - if (appliedRules == false && elseRules.length > 0) { │ │ │ │ - appliedRules = true; │ │ │ │ - for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ - this.applySymbolizer(elseRules[i], style, feature); │ │ │ │ + if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ + this.popup.panIntoView(); │ │ │ │ } │ │ │ │ - } │ │ │ │ │ │ │ │ - // don't display if there were rules but none applied │ │ │ │ - if (rules.length > 0 && appliedRules == false) { │ │ │ │ - style.display = "none"; │ │ │ │ - } │ │ │ │ + OpenLayers.Event.stopObserving( │ │ │ │ + this.img, "load", this.img._onImgLoad │ │ │ │ + ); │ │ │ │ │ │ │ │ - if (style.label != null && typeof style.label !== "string") { │ │ │ │ - style.label = String(style.label); │ │ │ │ - } │ │ │ │ + }; │ │ │ │ │ │ │ │ - return style; │ │ │ │ - }, │ │ │ │ + //cycle through the images and if their size is 0x0, that means that │ │ │ │ + // they haven't been loaded yet, so we attach the listener, which │ │ │ │ + // will fire when the images finish loading and will resize the │ │ │ │ + // popup accordingly to its new size. │ │ │ │ + var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ + for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ + var img = images[i]; │ │ │ │ + if (img.width == 0 || img.height == 0) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: applySymbolizer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * rule - {} │ │ │ │ - * style - {Object} │ │ │ │ - * feature - {} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} A style with new symbolizer applied. │ │ │ │ - */ │ │ │ │ - applySymbolizer: function(rule, style, feature) { │ │ │ │ - var symbolizerPrefix = feature.geometry ? │ │ │ │ - this.getSymbolizerPrefix(feature.geometry) : │ │ │ │ - OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ + var context = { │ │ │ │ + 'popup': this, │ │ │ │ + 'img': img │ │ │ │ + }; │ │ │ │ │ │ │ │ - var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ + //expando this function to the image itself before registering │ │ │ │ + // it. This way we can easily and properly unregister it. │ │ │ │ + img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ │ │ │ │ - if (this.defaultsPerSymbolizer === true) { │ │ │ │ - var defaults = this.defaultStyle; │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: defaults.pointRadius │ │ │ │ - }); │ │ │ │ - if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - strokeWidth: defaults.strokeWidth, │ │ │ │ - strokeColor: defaults.strokeColor, │ │ │ │ - strokeOpacity: defaults.strokeOpacity, │ │ │ │ - strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ - strokeLinecap: defaults.strokeLinecap │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - fillColor: defaults.fillColor, │ │ │ │ - fillOpacity: defaults.fillOpacity │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: this.defaultStyle.pointRadius, │ │ │ │ - externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ - graphicName: this.defaultStyle.graphicName, │ │ │ │ - graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ - graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ - graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ - graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ - graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ - }); │ │ │ │ + OpenLayers.Event.observe(img, 'load', img._onImgLoad); │ │ │ │ } │ │ │ │ } │ │ │ │ - │ │ │ │ - // merge the style with the current style │ │ │ │ - return this.createLiterals( │ │ │ │ - OpenLayers.Util.extend(style, symbolizer), feature); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createLiterals │ │ │ │ - * creates literals for all style properties that have an entry in │ │ │ │ - * . │ │ │ │ + * APIMethod: getSafeContentSize │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * style - {Object} style to create literals for. Will be modified │ │ │ │ - * inline. │ │ │ │ - * feature - {Object} │ │ │ │ + * size - {} Desired size to make the popup. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} the modified style │ │ │ │ + * {} 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). │ │ │ │ */ │ │ │ │ - createLiterals: function(style, feature) { │ │ │ │ - var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ - OpenLayers.Util.extend(context, this.context); │ │ │ │ + getSafeContentSize: function(size) { │ │ │ │ │ │ │ │ - for (var i in this.propertyStyles) { │ │ │ │ - style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i); │ │ │ │ + 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; │ │ │ │ } │ │ │ │ - return style; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: findPropertyStyles │ │ │ │ - * Looks into all rules for this style and the defaultStyle to collect │ │ │ │ - * all the style hash property names containing ${...} strings that have │ │ │ │ - * to be replaced using the createLiteral method before returning them. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} hash of property names that need createLiteral parsing. The │ │ │ │ - * name of the property is the key, and the value is true; │ │ │ │ - */ │ │ │ │ - findPropertyStyles: function() { │ │ │ │ - var propertyStyles = {}; │ │ │ │ + // 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)); │ │ │ │ + } │ │ │ │ │ │ │ │ - // check the default style │ │ │ │ - var style = this.defaultStyle; │ │ │ │ - this.addPropertyStyles(propertyStyles, style); │ │ │ │ + // 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)); │ │ │ │ + } │ │ │ │ │ │ │ │ - // walk through all rules to check for properties in their symbolizer │ │ │ │ - var rules = this.rules; │ │ │ │ - var symbolizer, value; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - symbolizer = rules[i].symbolizer; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - value = symbolizer[key]; │ │ │ │ - if (typeof value == "object") { │ │ │ │ - // symbolizer key is "Point", "Line" or "Polygon" │ │ │ │ - this.addPropertyStyles(propertyStyles, value); │ │ │ │ - } else { │ │ │ │ - // symbolizer is a hash of style properties │ │ │ │ - this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ - break; │ │ │ │ + //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) { │ │ │ │ + │ │ │ │ + var extraX = 0, │ │ │ │ + extraY = 0; │ │ │ │ + if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ + var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ + switch (this.relativePosition) { │ │ │ │ + case "tr": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "tl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "bl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + case "br": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ + │ │ │ │ + var maxY = this.map.size.h - │ │ │ │ + this.map.paddingForPopups.top - │ │ │ │ + this.map.paddingForPopups.bottom - │ │ │ │ + hPadding - extraY; │ │ │ │ + │ │ │ │ + var maxX = this.map.size.w - │ │ │ │ + this.map.paddingForPopups.left - │ │ │ │ + this.map.paddingForPopups.right - │ │ │ │ + wPadding - extraX; │ │ │ │ + │ │ │ │ + safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ + safeContentSize.h = Math.min(safeContentSize.h, maxY); │ │ │ │ } │ │ │ │ - return propertyStyles; │ │ │ │ + │ │ │ │ + return safeContentSize; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addPropertyStyles │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * propertyStyles - {Object} hash to add new property styles to. Will be │ │ │ │ - * modified inline │ │ │ │ - * symbolizer - {Object} search this symbolizer for property styles │ │ │ │ - * │ │ │ │ + * 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: │ │ │ │ - * {Object} propertyStyles hash │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ - var property; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - property = symbolizer[key]; │ │ │ │ - if (typeof property == "string" && │ │ │ │ - property.match(/\$\{\w+\}/)) { │ │ │ │ - propertyStyles[key] = true; │ │ │ │ + getContentDivPadding: function() { │ │ │ │ + │ │ │ │ + //use cached value if we have it │ │ │ │ + var contentDivPadding = this._contentDivPadding; │ │ │ │ + if (!contentDivPadding) { │ │ │ │ + │ │ │ │ + if (this.div.parentNode == null) { │ │ │ │ + //make the div invisible and add it to the page │ │ │ │ + this.div.style.display = "none"; │ │ │ │ + document.body.appendChild(this.div); │ │ │ │ } │ │ │ │ - } │ │ │ │ - return propertyStyles; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: addRules │ │ │ │ - * Adds rules to this style. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * rules - {Array()} │ │ │ │ - */ │ │ │ │ - addRules: function(rules) { │ │ │ │ - Array.prototype.push.apply(this.rules, rules); │ │ │ │ - this.propertyStyles = this.findPropertyStyles(); │ │ │ │ - }, │ │ │ │ + //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") │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setDefaultStyle │ │ │ │ - * Sets the default style for this style object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * style - {Object} Hash of style properties │ │ │ │ - */ │ │ │ │ - setDefaultStyle: function(style) { │ │ │ │ - this.defaultStyle = style; │ │ │ │ - this.propertyStyles = this.findPropertyStyles(); │ │ │ │ - }, │ │ │ │ + //cache the value │ │ │ │ + this._contentDivPadding = contentDivPadding; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getSymbolizerPrefix │ │ │ │ - * Returns the correct symbolizer prefix according to the │ │ │ │ - * geometry type of the passed geometry │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} key of the according symbolizer │ │ │ │ - */ │ │ │ │ - getSymbolizerPrefix: function(geometry) { │ │ │ │ - var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ - for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ - if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ - return prefixes[i]; │ │ │ │ + if (this.div.parentNode == document.body) { │ │ │ │ + //remove the div from the page and make it visible again │ │ │ │ + document.body.removeChild(this.div); │ │ │ │ + this.div.style.display = ""; │ │ │ │ } │ │ │ │ } │ │ │ │ + return contentDivPadding; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this style. │ │ │ │ + * Method: addCloseBox │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {} Clone of this style. │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The callback to be called when the close button │ │ │ │ + * is clicked. │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - // clone rules │ │ │ │ - if (this.rules) { │ │ │ │ - options.rules = []; │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ - options.rules.push(this.rules[i].clone()); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // clone context │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - //clone default style │ │ │ │ - var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ - return new OpenLayers.Style(defaultStyle, options); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Style" │ │ │ │ -}); │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: createLiteral │ │ │ │ - * converts a style value holding a combination of PropertyName and Literal │ │ │ │ - * into a Literal, taking the property values from the passed features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * value - {String} value to parse. If this string contains a construct like │ │ │ │ - * "foo ${bar}", then "foo " will be taken as literal, and "${bar}" │ │ │ │ - * will be replaced by the value of the "bar" attribute of the passed │ │ │ │ - * feature. │ │ │ │ - * context - {Object} context to take attribute values from │ │ │ │ - * feature - {} optional feature to pass to │ │ │ │ - * for evaluating functions in the │ │ │ │ - * context. │ │ │ │ - * property - {String} optional, name of the property for which the literal is │ │ │ │ - * being created for evaluating functions in the context. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} the parsed value. In the example of the value parameter above, the │ │ │ │ - * result would be "foo valueOfBar", assuming that the passed feature has an │ │ │ │ - * attribute named "bar" with the value "valueOfBar". │ │ │ │ - */ │ │ │ │ -OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ - if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ - value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ - value = (isNaN(value) || !value) ? value : parseFloat(value); │ │ │ │ - } │ │ │ │ - return value; │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Style.SYMBOLIZER_PREFIXES │ │ │ │ - * {Array} prefixes of the sld symbolizers. These are the │ │ │ │ - * same as the main geometry types │ │ │ │ - */ │ │ │ │ -OpenLayers.Style.SYMBOLIZER_PREFIXES = ['Point', 'Line', 'Polygon', 'Text', │ │ │ │ - 'Raster' │ │ │ │ -]; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Rule.js │ │ │ │ - ====================================================================== */ │ │ │ │ + addCloseBox: function(callback) { │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + this.closeDiv = OpenLayers.Util.createDiv( │ │ │ │ + this.id + "_close", null, { │ │ │ │ + w: 17, │ │ │ │ + h: 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(); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Style.js │ │ │ │ - */ │ │ │ │ + this.closeDiv.style.right = contentDivPadding.right + "px"; │ │ │ │ + this.closeDiv.style.top = contentDivPadding.top + "px"; │ │ │ │ + this.groupDiv.appendChild(this.closeDiv); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Rule │ │ │ │ - * This class represents an SLD Rule, as being used for rule-based SLD styling. │ │ │ │ - */ │ │ │ │ -OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ + var closePopup = callback || function(e) { │ │ │ │ + this.hide(); │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ + }; │ │ │ │ + OpenLayers.Event.observe(this.closeDiv, "touchend", │ │ │ │ + OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ + OpenLayers.Event.observe(this.closeDiv, "click", │ │ │ │ + OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique id for this session. │ │ │ │ + * Method: panIntoView │ │ │ │ + * Pans the map such that the popup is totaly viewable (if necessary) │ │ │ │ */ │ │ │ │ - id: null, │ │ │ │ + panIntoView: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} name of this rule │ │ │ │ - */ │ │ │ │ - name: null, │ │ │ │ + var mapSize = this.map.getSize(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: title │ │ │ │ - * {String} Title of this rule (set if included in SLD) │ │ │ │ - */ │ │ │ │ - title: null, │ │ │ │ + //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(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: description │ │ │ │ - * {String} Description of this rule (set if abstract is included in SLD) │ │ │ │ - */ │ │ │ │ - description: null, │ │ │ │ + //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; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: context │ │ │ │ - * {Object} An optional object with properties that the rule should be │ │ │ │ - * evaluated against. If no context is specified, feature.attributes will │ │ │ │ - * be used. │ │ │ │ - */ │ │ │ │ - context: null, │ │ │ │ + //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; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: filter │ │ │ │ - * {} Optional filter for the rule. │ │ │ │ - */ │ │ │ │ - filter: null, │ │ │ │ + var dx = origTL.x - newTL.x; │ │ │ │ + var dy = origTL.y - newTL.y; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: elseFilter │ │ │ │ - * {Boolean} Determines whether this rule is only to be applied only if │ │ │ │ - * no other rules match (ElseFilter according to the SLD specification). │ │ │ │ - * Default is false. For instances of OpenLayers.Rule, if elseFilter is │ │ │ │ - * false, the rule will always apply. For subclasses, the else property is │ │ │ │ - * ignored. │ │ │ │ - */ │ │ │ │ - elseFilter: false, │ │ │ │ + this.map.pan(dx, dy); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: symbolizer │ │ │ │ - * {Object} Symbolizer or hash of symbolizers for this rule. If hash of │ │ │ │ - * symbolizers, keys are one or more of ["Point", "Line", "Polygon"]. The │ │ │ │ - * latter if useful if it is required to style e.g. vertices of a line │ │ │ │ - * with a point symbolizer. Note, however, that this is not implemented │ │ │ │ - * yet in OpenLayers, but it is the way how symbolizers are defined in │ │ │ │ - * SLD. │ │ │ │ + /** │ │ │ │ + * 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. The same procedure is needed for │ │ │ │ + * touchmove and touchend events. │ │ │ │ + * │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - symbolizer: null, │ │ │ │ + registerEvents: function() { │ │ │ │ + this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: symbolizers │ │ │ │ - * {Array} Collection of symbolizers associated with this rule. If │ │ │ │ - * provided at construction, the symbolizers array has precedence │ │ │ │ - * over the deprecated symbolizer property. Note that multiple │ │ │ │ - * symbolizers are not currently supported by the vector renderers. │ │ │ │ - * Rules with multiple symbolizers are currently only useful for │ │ │ │ - * maintaining elements in an SLD document. │ │ │ │ - */ │ │ │ │ - symbolizers: null, │ │ │ │ + function onTouchstart(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ + } │ │ │ │ + this.events.on({ │ │ │ │ + "mousedown": this.onmousedown, │ │ │ │ + "mousemove": this.onmousemove, │ │ │ │ + "mouseup": this.onmouseup, │ │ │ │ + "click": this.onclick, │ │ │ │ + "mouseout": this.onmouseout, │ │ │ │ + "dblclick": this.ondblclick, │ │ │ │ + "touchstart": onTouchstart, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: minScaleDenominator │ │ │ │ - * {Number} or {String} minimum scale at which to draw the feature. │ │ │ │ - * In the case of a String, this can be a combination of text and │ │ │ │ - * propertyNames in the form "literal ${propertyName}" │ │ │ │ - */ │ │ │ │ - minScaleDenominator: null, │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: maxScaleDenominator │ │ │ │ - * {Number} or {String} maximum scale at which to draw the feature. │ │ │ │ - * In the case of a String, this can be a combination of text and │ │ │ │ - * propertyNames in the form "literal ${propertyName}" │ │ │ │ + /** │ │ │ │ + * 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} │ │ │ │ */ │ │ │ │ - maxScaleDenominator: null, │ │ │ │ + onmousedown: function(evt) { │ │ │ │ + this.mousedown = true; │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Rule │ │ │ │ - * Creates a Rule. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * rule │ │ │ │ + * 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) │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {} │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.symbolizer = {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - delete this.symbolizer; │ │ │ │ + onmousemove: function(evt) { │ │ │ │ + if (this.mousedown) { │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ } │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ + * 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} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i in this.symbolizer) { │ │ │ │ - this.symbolizer[i] = null; │ │ │ │ + onmouseup: function(evt) { │ │ │ │ + if (this.mousedown) { │ │ │ │ + this.mousedown = false; │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ } │ │ │ │ - this.symbolizer = null; │ │ │ │ - delete this.symbolizers; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: evaluate │ │ │ │ - * evaluates this rule for a specific feature │ │ │ │ + * Method: onclick │ │ │ │ + * Ignore clicks, but allowing default browser handling │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {} feature to apply the rule to. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} true if the rule applies, false if it does not. │ │ │ │ - * This rule is the default rule and always returns true. │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - evaluate: function(feature) { │ │ │ │ - var context = this.getContext(feature); │ │ │ │ - var applies = true; │ │ │ │ - │ │ │ │ - if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ - var scale = feature.layer.map.getScale(); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // check if within minScale/maxScale bounds │ │ │ │ - if (this.minScaleDenominator) { │ │ │ │ - applies = scale >= OpenLayers.Style.createLiteral( │ │ │ │ - this.minScaleDenominator, context); │ │ │ │ - } │ │ │ │ - if (applies && this.maxScaleDenominator) { │ │ │ │ - applies = scale < OpenLayers.Style.createLiteral( │ │ │ │ - this.maxScaleDenominator, context); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // check if optional filter applies │ │ │ │ - if (applies && this.filter) { │ │ │ │ - // feature id filters get the feature, others get the context │ │ │ │ - if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ - applies = this.filter.evaluate(feature); │ │ │ │ - } else { │ │ │ │ - applies = this.filter.evaluate(context); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - return applies; │ │ │ │ + onclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getContext │ │ │ │ - * Gets the context for evaluating this rule │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ * │ │ │ │ - * Paramters: │ │ │ │ - * feature - {} feature to take the context from if │ │ │ │ - * none is specified. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - getContext: function(feature) { │ │ │ │ - var context = this.context; │ │ │ │ - if (!context) { │ │ │ │ - context = feature.attributes || feature.data; │ │ │ │ - } │ │ │ │ - if (typeof this.context == "function") { │ │ │ │ - context = this.context(feature); │ │ │ │ - } │ │ │ │ - return context; │ │ │ │ + onmouseout: function(evt) { │ │ │ │ + this.mousedown = false; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this rule. │ │ │ │ + /** │ │ │ │ + * Method: ondblclick │ │ │ │ + * Ignore double-clicks, but allowing default browser handling │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {} Clone of this rule. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - // clone symbolizers │ │ │ │ - var len = this.symbolizers.length; │ │ │ │ - options.symbolizers = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - options.symbolizers[i] = this.symbolizers[i].clone(); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // clone symbolizer │ │ │ │ - options.symbolizer = {}; │ │ │ │ - var value, type; │ │ │ │ - for (var key in this.symbolizer) { │ │ │ │ - value = this.symbolizer[key]; │ │ │ │ - type = typeof value; │ │ │ │ - if (type === "object") { │ │ │ │ - options.symbolizer[key] = OpenLayers.Util.extend({}, value); │ │ │ │ - } else if (type === "string") { │ │ │ │ - options.symbolizer[key] = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // clone filter │ │ │ │ - options.filter = this.filter && this.filter.clone(); │ │ │ │ - // clone context │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - return new OpenLayers.Rule(options); │ │ │ │ + ondblclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Rule" │ │ │ │ + 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/Util/vendorPrefix.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ @@ -6660,485 +6297,14 @@ │ │ │ │ │ │ │ │ // used for testing │ │ │ │ cssCache: cssCache, │ │ │ │ jsCache: jsCache │ │ │ │ }; │ │ │ │ }()); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Animation.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - * @requires OpenLayers/Util/vendorPrefix.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Animation │ │ │ │ - * A collection of utility functions for executing methods that repaint a │ │ │ │ - * portion of the browser window. These methods take advantage of the │ │ │ │ - * browser's scheduled repaints where requestAnimationFrame is available. │ │ │ │ - */ │ │ │ │ -OpenLayers.Animation = (function(window) { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: isNative │ │ │ │ - * {Boolean} true if a native requestAnimationFrame function is available │ │ │ │ - */ │ │ │ │ - var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ - var isNative = !!(requestAnimationFrame); │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: requestFrame │ │ │ │ - * Schedule a function to be called at the next available animation frame. │ │ │ │ - * Uses the native method where available. Where requestAnimationFrame is │ │ │ │ - * not available, setTimeout will be called with a 16ms delay. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The function to be called at the next animation frame. │ │ │ │ - * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ - */ │ │ │ │ - var requestFrame = (function() { │ │ │ │ - var request = window[requestAnimationFrame] || │ │ │ │ - function(callback, element) { │ │ │ │ - window.setTimeout(callback, 16); │ │ │ │ - }; │ │ │ │ - // bind to window to avoid illegal invocation of native function │ │ │ │ - return function(callback, element) { │ │ │ │ - request.apply(window, [callback, element]); │ │ │ │ - }; │ │ │ │ - })(); │ │ │ │ - │ │ │ │ - // private variables for animation loops │ │ │ │ - var counter = 0; │ │ │ │ - var loops = {}; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: start │ │ │ │ - * Executes a method with in series for some │ │ │ │ - * duration. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The function to be called at the next animation frame. │ │ │ │ - * duration - {Number} Optional duration for the loop. If not provided, the │ │ │ │ - * animation loop will execute indefinitely. │ │ │ │ - * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} Identifier for the animation loop. Used to stop animations with │ │ │ │ - * . │ │ │ │ - */ │ │ │ │ - function start(callback, duration, element) { │ │ │ │ - duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ - var id = ++counter; │ │ │ │ - var start = +new Date; │ │ │ │ - loops[id] = function() { │ │ │ │ - if (loops[id] && +new Date - start <= duration) { │ │ │ │ - callback(); │ │ │ │ - if (loops[id]) { │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - delete loops[id]; │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - return id; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: stop │ │ │ │ - * Terminates an animation loop started with . │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {Number} Identifier returned from . │ │ │ │ - */ │ │ │ │ - function stop(id) { │ │ │ │ - delete loops[id]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - isNative: isNative, │ │ │ │ - requestFrame: requestFrame, │ │ │ │ - start: start, │ │ │ │ - stop: stop │ │ │ │ - }; │ │ │ │ - │ │ │ │ -})(window); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Tween.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Animation.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Tween │ │ │ │ - */ │ │ │ │ -OpenLayers.Tween = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: minFrameRate │ │ │ │ - * {Number} The minimum framerate for animations in frames per second. After │ │ │ │ - * each step, the time spent in the animation is compared to the calculated │ │ │ │ - * time at this frame rate. If the animation runs longer than the calculated │ │ │ │ - * time, the next step is skipped. Default is 30. │ │ │ │ - */ │ │ │ │ - minFrameRate: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: startTime │ │ │ │ - * {Number} The timestamp of the first execution step. Used for skipping │ │ │ │ - * frames │ │ │ │ - */ │ │ │ │ - startTime: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: animationId │ │ │ │ - * {int} Loop id returned by OpenLayers.Animation.start │ │ │ │ - */ │ │ │ │ - animationId: 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 (callbacks (start, eachStep, done), │ │ │ │ - * minFrameRate) │ │ │ │ - */ │ │ │ │ - start: function(begin, finish, duration, options) { │ │ │ │ - this.playing = true; │ │ │ │ - this.begin = begin; │ │ │ │ - this.finish = finish; │ │ │ │ - this.duration = duration; │ │ │ │ - this.callbacks = options.callbacks; │ │ │ │ - this.minFrameRate = options.minFrameRate || 30; │ │ │ │ - this.time = 0; │ │ │ │ - this.startTime = new Date().getTime(); │ │ │ │ - OpenLayers.Animation.stop(this.animationId); │ │ │ │ - this.animationId = null; │ │ │ │ - if (this.callbacks && this.callbacks.start) { │ │ │ │ - this.callbacks.start.call(this, this.begin); │ │ │ │ - } │ │ │ │ - this.animationId = OpenLayers.Animation.start( │ │ │ │ - OpenLayers.Function.bind(this.play, this) │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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); │ │ │ │ - } │ │ │ │ - OpenLayers.Animation.stop(this.animationId); │ │ │ │ - this.animationId = 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)) { │ │ │ │ - throw new TypeError('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) { │ │ │ │ - // skip frames if frame rate drops below threshold │ │ │ │ - if ((new Date().getTime() - this.startTime) / this.time <= 1000 / this.minFrameRate) { │ │ │ │ - this.callbacks.eachStep.call(this, value); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.time > this.duration) { │ │ │ │ - this.stop(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} │ │ │ │ - */ │ │ │ │ - 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" │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Events.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -8307,14 +7473,485 @@ │ │ │ │ │ │ │ │ OpenLayers.Event.observe(element, 'MSPointerUp', cb); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Events" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ + OpenLayers/Animation.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + * @requires OpenLayers/Util/vendorPrefix.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Animation │ │ │ │ + * A collection of utility functions for executing methods that repaint a │ │ │ │ + * portion of the browser window. These methods take advantage of the │ │ │ │ + * browser's scheduled repaints where requestAnimationFrame is available. │ │ │ │ + */ │ │ │ │ +OpenLayers.Animation = (function(window) { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: isNative │ │ │ │ + * {Boolean} true if a native requestAnimationFrame function is available │ │ │ │ + */ │ │ │ │ + var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ + var isNative = !!(requestAnimationFrame); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: requestFrame │ │ │ │ + * Schedule a function to be called at the next available animation frame. │ │ │ │ + * Uses the native method where available. Where requestAnimationFrame is │ │ │ │ + * not available, setTimeout will be called with a 16ms delay. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The function to be called at the next animation frame. │ │ │ │ + * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ + */ │ │ │ │ + var requestFrame = (function() { │ │ │ │ + var request = window[requestAnimationFrame] || │ │ │ │ + function(callback, element) { │ │ │ │ + window.setTimeout(callback, 16); │ │ │ │ + }; │ │ │ │ + // bind to window to avoid illegal invocation of native function │ │ │ │ + return function(callback, element) { │ │ │ │ + request.apply(window, [callback, element]); │ │ │ │ + }; │ │ │ │ + })(); │ │ │ │ + │ │ │ │ + // private variables for animation loops │ │ │ │ + var counter = 0; │ │ │ │ + var loops = {}; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: start │ │ │ │ + * Executes a method with in series for some │ │ │ │ + * duration. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The function to be called at the next animation frame. │ │ │ │ + * duration - {Number} Optional duration for the loop. If not provided, the │ │ │ │ + * animation loop will execute indefinitely. │ │ │ │ + * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} Identifier for the animation loop. Used to stop animations with │ │ │ │ + * . │ │ │ │ + */ │ │ │ │ + function start(callback, duration, element) { │ │ │ │ + duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ + var id = ++counter; │ │ │ │ + var start = +new Date; │ │ │ │ + loops[id] = function() { │ │ │ │ + if (loops[id] && +new Date - start <= duration) { │ │ │ │ + callback(); │ │ │ │ + if (loops[id]) { │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + delete loops[id]; │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + return id; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: stop │ │ │ │ + * Terminates an animation loop started with . │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {Number} Identifier returned from . │ │ │ │ + */ │ │ │ │ + function stop(id) { │ │ │ │ + delete loops[id]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return { │ │ │ │ + isNative: isNative, │ │ │ │ + requestFrame: requestFrame, │ │ │ │ + start: start, │ │ │ │ + stop: stop │ │ │ │ + }; │ │ │ │ + │ │ │ │ +})(window); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Tween.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Animation.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Tween │ │ │ │ + */ │ │ │ │ +OpenLayers.Tween = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: minFrameRate │ │ │ │ + * {Number} The minimum framerate for animations in frames per second. After │ │ │ │ + * each step, the time spent in the animation is compared to the calculated │ │ │ │ + * time at this frame rate. If the animation runs longer than the calculated │ │ │ │ + * time, the next step is skipped. Default is 30. │ │ │ │ + */ │ │ │ │ + minFrameRate: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: startTime │ │ │ │ + * {Number} The timestamp of the first execution step. Used for skipping │ │ │ │ + * frames │ │ │ │ + */ │ │ │ │ + startTime: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: animationId │ │ │ │ + * {int} Loop id returned by OpenLayers.Animation.start │ │ │ │ + */ │ │ │ │ + animationId: 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 (callbacks (start, eachStep, done), │ │ │ │ + * minFrameRate) │ │ │ │ + */ │ │ │ │ + start: function(begin, finish, duration, options) { │ │ │ │ + this.playing = true; │ │ │ │ + this.begin = begin; │ │ │ │ + this.finish = finish; │ │ │ │ + this.duration = duration; │ │ │ │ + this.callbacks = options.callbacks; │ │ │ │ + this.minFrameRate = options.minFrameRate || 30; │ │ │ │ + this.time = 0; │ │ │ │ + this.startTime = new Date().getTime(); │ │ │ │ + OpenLayers.Animation.stop(this.animationId); │ │ │ │ + this.animationId = null; │ │ │ │ + if (this.callbacks && this.callbacks.start) { │ │ │ │ + this.callbacks.start.call(this, this.begin); │ │ │ │ + } │ │ │ │ + this.animationId = OpenLayers.Animation.start( │ │ │ │ + OpenLayers.Function.bind(this.play, this) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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); │ │ │ │ + } │ │ │ │ + OpenLayers.Animation.stop(this.animationId); │ │ │ │ + this.animationId = 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)) { │ │ │ │ + throw new TypeError('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) { │ │ │ │ + // skip frames if frame rate drops below threshold │ │ │ │ + if ((new Date().getTime() - this.startTime) / this.time <= 1000 / this.minFrameRate) { │ │ │ │ + this.callbacks.eachStep.call(this, value); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.time > this.duration) { │ │ │ │ + this.stop(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + 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" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ OpenLayers/Projection.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -12933,248 +12570,265 @@ │ │ │ │ } │ │ │ │ return bounds; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/HTTPRequest.js │ │ │ │ + OpenLayers/Icon.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.HTTPRequest │ │ │ │ + * 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. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.HTTPRequest = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ +OpenLayers.Icon = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: URL_HASH_FACTOR │ │ │ │ - * {Float} Used to hash URL param strings for multi-WMS server selection. │ │ │ │ - * Set to the Golden Ratio per Knuth's recommendation. │ │ │ │ + * Property: url │ │ │ │ + * {String} image url │ │ │ │ */ │ │ │ │ - URL_HASH_FACTOR: (Math.sqrt(5) - 1) / 2, │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: url │ │ │ │ - * {Array(String) or String} This is either an array of url strings or │ │ │ │ - * a single url string. │ │ │ │ + * Property: size │ │ │ │ + * {|Object} An OpenLayers.Size or │ │ │ │ + * an object with a 'w' and 'h' properties. │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + size: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: params │ │ │ │ - * {Object} Hashtable of key/value parameters │ │ │ │ + * Property: offset │ │ │ │ + * {|Object} distance in pixels to offset the │ │ │ │ + * image when being rendered. An OpenLayers.Pixel or an object │ │ │ │ + * with a 'x' and 'y' properties. │ │ │ │ */ │ │ │ │ - params: null, │ │ │ │ + offset: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: reproject │ │ │ │ - * *Deprecated*. See http://docs.openlayers.org/library/spherical_mercator.html │ │ │ │ - * for information on the replacement for this functionality. │ │ │ │ - * {Boolean} Whether layer should reproject itself based on base layer │ │ │ │ - * locations. This allows reprojection onto commercial layers. │ │ │ │ - * Default is false: Most layers can't reproject, but layers │ │ │ │ - * which can create non-square geographic pixels can, like WMS. │ │ │ │ - * │ │ │ │ + * Property: calculateOffset │ │ │ │ + * {Function} Function to calculate the offset (based on the size) │ │ │ │ */ │ │ │ │ - reproject: false, │ │ │ │ + calculateOffset: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.HTTPRequest │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * url - {Array(String) or String} │ │ │ │ - * params - {Object} │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ + /** │ │ │ │ + * Property: imageDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.prototype.initialize.apply(this, [name, options]); │ │ │ │ - this.url = url; │ │ │ │ - if (!this.params) { │ │ │ │ - this.params = OpenLayers.Util.extend({}, params); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + imageDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + /** │ │ │ │ + * Property: px │ │ │ │ + * {|Object} An OpenLayers.Pixel or an object │ │ │ │ + * with a 'x' and 'y' properties. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.url = null; │ │ │ │ - this.params = null; │ │ │ │ - OpenLayers.Layer.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + px: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} An exact clone of this │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Icon │ │ │ │ + * Creates an icon, which is an image tag in a div. │ │ │ │ + * │ │ │ │ + * url - {String} │ │ │ │ + * size - {|Object} An OpenLayers.Size or an │ │ │ │ + * object with a 'w' and 'h' │ │ │ │ + * properties. │ │ │ │ + * offset - {|Object} An OpenLayers.Pixel or an │ │ │ │ + * object with a 'x' and 'y' │ │ │ │ + * properties. │ │ │ │ + * calculateOffset - {Function} │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.HTTPRequest(this.name, │ │ │ │ - this.url, │ │ │ │ - this.params, │ │ │ │ - this.getOptions()); │ │ │ │ - } │ │ │ │ + initialize: function(url, size, offset, calculateOffset) { │ │ │ │ + this.url = url; │ │ │ │ + this.size = size || { │ │ │ │ + w: 20, │ │ │ │ + h: 20 │ │ │ │ + }; │ │ │ │ + this.offset = offset || { │ │ │ │ + x: -(this.size.w / 2), │ │ │ │ + y: -(this.size.h / 2) │ │ │ │ + }; │ │ │ │ + this.calculateOffset = calculateOffset; │ │ │ │ │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]); │ │ │ │ + var id = OpenLayers.Util.createUniqueID("OL_Icon_"); │ │ │ │ + this.imageDiv = OpenLayers.Util.createAlphaImageDiv(id); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Nullify references and remove event listeners to prevent circular │ │ │ │ + * references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + // erase any drawn elements │ │ │ │ + this.erase(); │ │ │ │ │ │ │ │ - return obj; │ │ │ │ + OpenLayers.Event.stopObservingElement(this.imageDiv.firstChild); │ │ │ │ + this.imageDiv.innerHTML = ""; │ │ │ │ + this.imageDiv = null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setUrl │ │ │ │ + * Method: clone │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * newUrl - {String} │ │ │ │ + * Returns: │ │ │ │ + * {} A fresh copy of the icon. │ │ │ │ */ │ │ │ │ - setUrl: function(newUrl) { │ │ │ │ - this.url = newUrl; │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Icon(this.url, │ │ │ │ + this.size, │ │ │ │ + this.offset, │ │ │ │ + this.calculateOffset); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: mergeNewParams │ │ │ │ + * Method: setSize │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * newParams - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * redrawn: {Boolean} whether the layer was actually redrawn. │ │ │ │ + * size - {|Object} An OpenLayers.Size or │ │ │ │ + * an object with a 'w' and 'h' properties. │ │ │ │ */ │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - this.params = OpenLayers.Util.extend(this.params, newParams); │ │ │ │ - var ret = this.redraw(); │ │ │ │ - if (this.map != null) { │ │ │ │ - this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "params" │ │ │ │ - }); │ │ │ │ + setSize: function(size) { │ │ │ │ + if (size != null) { │ │ │ │ + this.size = size; │ │ │ │ } │ │ │ │ - return ret; │ │ │ │ + this.draw(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: redraw │ │ │ │ - * Redraws the layer. Returns true if the layer was redrawn, false if not. │ │ │ │ - * │ │ │ │ + * Method: setUrl │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * force - {Boolean} Force redraw by adding random parameter. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The layer was redrawn. │ │ │ │ + * url - {String} │ │ │ │ */ │ │ │ │ - redraw: function(force) { │ │ │ │ - if (force) { │ │ │ │ - return this.mergeNewParams({ │ │ │ │ - "_olSalt": Math.random() │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - return OpenLayers.Layer.prototype.redraw.apply(this, []); │ │ │ │ + setUrl: function(url) { │ │ │ │ + if (url != null) { │ │ │ │ + this.url = url; │ │ │ │ } │ │ │ │ + this.draw(); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: selectUrl │ │ │ │ - * selectUrl() implements the standard floating-point multiplicative │ │ │ │ - * hash function described by Knuth, and hashes the contents of the │ │ │ │ - * given param string into a float between 0 and 1. This float is then │ │ │ │ - * scaled to the size of the provided urls array, and used to select │ │ │ │ - * a URL. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * Move the div to the given pixel. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * paramString - {String} │ │ │ │ - * urls - {Array(String)} │ │ │ │ + * px - {|Object} An OpenLayers.Pixel or an │ │ │ │ + * object with a 'x' and 'y' properties. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} An entry from the urls array, deterministically selected based │ │ │ │ - * on the paramString. │ │ │ │ + * {DOMElement} A new DOM Image of this icon set at the location passed-in │ │ │ │ */ │ │ │ │ - selectUrl: function(paramString, urls) { │ │ │ │ - var product = 1; │ │ │ │ - for (var i = 0, len = paramString.length; i < len; i++) { │ │ │ │ - product *= paramString.charCodeAt(i) * this.URL_HASH_FACTOR; │ │ │ │ - product -= Math.floor(product); │ │ │ │ + draw: function(px) { │ │ │ │ + OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + this.size, │ │ │ │ + this.url, │ │ │ │ + "absolute"); │ │ │ │ + this.moveTo(px); │ │ │ │ + return this.imageDiv; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: erase │ │ │ │ + * Erase the underlying image element. │ │ │ │ + */ │ │ │ │ + erase: function() { │ │ │ │ + if (this.imageDiv != null && this.imageDiv.parentNode != null) { │ │ │ │ + OpenLayers.Element.remove(this.imageDiv); │ │ │ │ } │ │ │ │ - return urls[Math.floor(product * urls.length)]; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getFullRequestString │ │ │ │ - * Combine url with layer's params and these newParams. │ │ │ │ - * │ │ │ │ - * does checking on the serverPath variable, allowing for cases when it │ │ │ │ - * is supplied with trailing ? or &, as well as cases where not. │ │ │ │ - * │ │ │ │ - * return in formatted string like this: │ │ │ │ - * "server?key1=value1&key2=value2&key3=value3" │ │ │ │ - * │ │ │ │ - * WARNING: The altUrl parameter is deprecated and will be removed in 3.0. │ │ │ │ + * Method: setOpacity │ │ │ │ + * Change the icon's opacity │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * newParams - {Object} │ │ │ │ - * altUrl - {String} Use this as the url instead of the layer's url │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} │ │ │ │ + * opacity - {float} │ │ │ │ */ │ │ │ │ - getFullRequestString: function(newParams, altUrl) { │ │ │ │ - │ │ │ │ - // if not altUrl passed in, use layer's url │ │ │ │ - var url = altUrl || this.url; │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, null, │ │ │ │ + null, null, null, null, opacity); │ │ │ │ │ │ │ │ - // create a new params hashtable with all the layer params and the │ │ │ │ - // new params together. then convert to string │ │ │ │ - var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ - allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ - var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // if url is not a string, it should be an array of strings, │ │ │ │ - // in which case we will deterministically select one of them in │ │ │ │ - // order to evenly distribute requests to different urls. │ │ │ │ - // │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(paramsString, url); │ │ │ │ + /** │ │ │ │ + * Method: moveTo │ │ │ │ + * move icon to passed in px. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {|Object} the pixel position to move to. │ │ │ │ + * An OpenLayers.Pixel or an object with a 'x' and 'y' properties. │ │ │ │ + */ │ │ │ │ + moveTo: function(px) { │ │ │ │ + //if no px passed in, use stored location │ │ │ │ + if (px != null) { │ │ │ │ + this.px = px; │ │ │ │ } │ │ │ │ │ │ │ │ - // ignore parameters that are already in the url search string │ │ │ │ - var urlParams = │ │ │ │ - OpenLayers.Util.upperCaseObject(OpenLayers.Util.getParameters(url)); │ │ │ │ - for (var key in allParams) { │ │ │ │ - if (key.toUpperCase() in urlParams) { │ │ │ │ - delete allParams[key]; │ │ │ │ + if (this.imageDiv != null) { │ │ │ │ + if (this.px == null) { │ │ │ │ + this.display(false); │ │ │ │ + } else { │ │ │ │ + if (this.calculateOffset) { │ │ │ │ + this.offset = this.calculateOffset(this.size); │ │ │ │ + } │ │ │ │ + OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, { │ │ │ │ + x: this.px.x + this.offset.x, │ │ │ │ + y: this.px.y + this.offset.y │ │ │ │ + }); │ │ │ │ } │ │ │ │ } │ │ │ │ - paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + }, │ │ │ │ │ │ │ │ - return OpenLayers.Util.urlAppend(url, paramsString); │ │ │ │ + /** │ │ │ │ + * Method: display │ │ │ │ + * Hide or show the icon │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * display - {Boolean} │ │ │ │ + */ │ │ │ │ + display: function(display) { │ │ │ │ + this.imageDiv.style.display = (display) ? "" : "none"; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.HTTPRequest" │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: isDrawn │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the icon is drawn. │ │ │ │ + */ │ │ │ │ + isDrawn: function() { │ │ │ │ + // nodeType 11 for ie, whose nodes *always* have a parentNode │ │ │ │ + // (of type document fragment) │ │ │ │ + var isDrawn = (this.imageDiv && this.imageDiv.parentNode && │ │ │ │ + (this.imageDiv.parentNode.nodeType != 11)); │ │ │ │ + │ │ │ │ + return isDrawn; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Icon" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Tile.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -13468,3100 +13122,4314 @@ │ │ │ │ clear: function(draw) { │ │ │ │ // to be extended by subclasses │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Tile" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Tile/Image.js │ │ │ │ + OpenLayers/Kinetic.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Tile.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ * @requires OpenLayers/Animation.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Tile.Image │ │ │ │ - * Instances of OpenLayers.Tile.Image are used to manage the image tiles │ │ │ │ - * used by various layers. Create a new image tile with the │ │ │ │ - * constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - │ │ │ │ - */ │ │ │ │ -OpenLayers.Tile.Image = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ +OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {} An events object that handles all │ │ │ │ - * events on the tile. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * tile.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to the events): │ │ │ │ - * beforeload - Triggered before an image is prepared for loading, when the │ │ │ │ - * url for the image is known already. Listeners may call on │ │ │ │ - * the tile instance. If they do so, that image will be used and no new │ │ │ │ - * one will be created. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} The URL of the image being requested. No default. Filled in by │ │ │ │ - * layer.getURL() function. May be modified by loadstart listeners. │ │ │ │ - */ │ │ │ │ - url: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: imgDiv │ │ │ │ - * {HTMLImageElement} The image for this tile. │ │ │ │ + * Property: threshold │ │ │ │ + * In most cases changing the threshold isn't needed. │ │ │ │ + * In px/ms, default to 0. │ │ │ │ */ │ │ │ │ - imgDiv: null, │ │ │ │ + threshold: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: frame │ │ │ │ - * {DOMElement} The image element is appended to the frame. Any gutter on │ │ │ │ - * the image will be hidden behind the frame. If no gutter is set, │ │ │ │ - * this will be null. │ │ │ │ - */ │ │ │ │ - frame: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: imageReloadAttempts │ │ │ │ - * {Integer} Attempts to load the image. │ │ │ │ + * Property: deceleration │ │ │ │ + * {Float} the deseleration in px/ms², default to 0.0035. │ │ │ │ */ │ │ │ │ - imageReloadAttempts: null, │ │ │ │ + deceleration: 0.0035, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layerAlphaHack │ │ │ │ - * {Boolean} True if the png alpha hack needs to be applied on the layer's div. │ │ │ │ + * Property: nbPoints │ │ │ │ + * {Integer} the number of points we use to calculate the kinetic │ │ │ │ + * initial values. │ │ │ │ */ │ │ │ │ - layerAlphaHack: null, │ │ │ │ + nbPoints: 100, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: asyncRequestId │ │ │ │ - * {Integer} ID of an request to see if request is still valid. This is a │ │ │ │ - * number which increments by 1 for each asynchronous request. │ │ │ │ + * Property: delay │ │ │ │ + * {Float} time to consider to calculate the kinetic initial values. │ │ │ │ + * In ms, default to 200. │ │ │ │ */ │ │ │ │ - asyncRequestId: null, │ │ │ │ + delay: 200, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxGetUrlLength │ │ │ │ - * {Number} If set, requests that would result in GET urls with more │ │ │ │ - * characters than the number provided will be made using form-encoded │ │ │ │ - * HTTP POST. It is good practice to avoid urls that are longer than 2048 │ │ │ │ - * characters. │ │ │ │ - * │ │ │ │ - * Caution: │ │ │ │ - * Older versions of Gecko based browsers (e.g. Firefox < 3.5) and most │ │ │ │ - * Opera versions do not fully support this option. On all browsers, │ │ │ │ - * transition effects are not supported if POST requests are used. │ │ │ │ + * Property: points │ │ │ │ + * List of points use to calculate the kinetic initial values. │ │ │ │ */ │ │ │ │ - maxGetUrlLength: null, │ │ │ │ + points: undefined, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: canvasContext │ │ │ │ - * {CanvasRenderingContext2D} A canvas context associated with │ │ │ │ - * the tile image. │ │ │ │ + * Property: timerId │ │ │ │ + * ID of the timer. │ │ │ │ */ │ │ │ │ - canvasContext: null, │ │ │ │ + timerId: undefined, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: crossOriginKeyword │ │ │ │ - * The value of the crossorigin keyword to use when loading images. This is │ │ │ │ - * only relevant when using for tiles from remote │ │ │ │ - * origins and should be set to either 'anonymous' or 'use-credentials' │ │ │ │ - * for servers that send Access-Control-Allow-Origin headers with their │ │ │ │ - * tiles. │ │ │ │ - */ │ │ │ │ - crossOriginKeyword: null, │ │ │ │ - │ │ │ │ - /** TBD 3.0 - reorder the parameters to the init function to remove │ │ │ │ - * URL. the getUrl() function on the layer gets called on │ │ │ │ - * each draw(), so no need to specify it here. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Tile.Image │ │ │ │ - * Constructor for a new instance. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Kinetic │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * layer - {} layer that the tile will go in. │ │ │ │ - * position - {} │ │ │ │ - * bounds - {} │ │ │ │ - * url - {} Deprecated. Remove me in 3.0. │ │ │ │ - * size - {} │ │ │ │ * options - {Object} │ │ │ │ */ │ │ │ │ - initialize: function(layer, position, bounds, url, size, options) { │ │ │ │ - OpenLayers.Tile.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ - this.url = url; //deprecated remove me │ │ │ │ - │ │ │ │ - this.layerAlphaHack = this.layer.alpha && OpenLayers.Util.alphaHack(); │ │ │ │ - │ │ │ │ - if (this.maxGetUrlLength != null || this.layer.gutter || this.layerAlphaHack) { │ │ │ │ - // only create frame if it's needed │ │ │ │ - this.frame = document.createElement("div"); │ │ │ │ - this.frame.style.position = "absolute"; │ │ │ │ - this.frame.style.overflow = "hidden"; │ │ │ │ - } │ │ │ │ - if (this.maxGetUrlLength != null) { │ │ │ │ - OpenLayers.Util.extend(this, OpenLayers.Tile.Image.IFrame); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.imgDiv) { │ │ │ │ - this.clear(); │ │ │ │ - this.imgDiv = null; │ │ │ │ - this.frame = null; │ │ │ │ - } │ │ │ │ - // don't handle async requests any more │ │ │ │ - this.asyncRequestId = null; │ │ │ │ - OpenLayers.Tile.prototype.destroy.apply(this, arguments); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * Check that a tile should be drawn, and draw it. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Was a tile drawn? Or null if a beforedraw listener returned │ │ │ │ - * false. │ │ │ │ + * Method: begin │ │ │ │ + * Begins the dragging. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - var shouldDraw = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ - if (shouldDraw) { │ │ │ │ - // The layer's reproject option is deprecated. │ │ │ │ - if (this.layer != this.layer.map.baseLayer && this.layer.reproject) { │ │ │ │ - // getBoundsFromBaseLayer is defined in deprecated.js. │ │ │ │ - this.bounds = this.getBoundsFromBaseLayer(this.position); │ │ │ │ - } │ │ │ │ - if (this.isLoading) { │ │ │ │ - //if we're already loading, send 'reload' instead of 'loadstart'. │ │ │ │ - this._loadEvent = "reload"; │ │ │ │ - } else { │ │ │ │ - this.isLoading = true; │ │ │ │ - this._loadEvent = "loadstart"; │ │ │ │ - } │ │ │ │ - this.renderTile(); │ │ │ │ - this.positionTile(); │ │ │ │ - } else if (shouldDraw === false) { │ │ │ │ - this.unload(); │ │ │ │ - } │ │ │ │ - return shouldDraw; │ │ │ │ + begin: function() { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = undefined; │ │ │ │ + this.points = []; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: renderTile │ │ │ │ - * Internal function to actually initialize the image tile, │ │ │ │ - * position it correctly, and set its url. │ │ │ │ + * Method: update │ │ │ │ + * Updates during the dragging. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {} The new position. │ │ │ │ */ │ │ │ │ - renderTile: function() { │ │ │ │ - if (this.layer.async) { │ │ │ │ - // Asynchronous image requests call the asynchronous getURL method │ │ │ │ - // on the layer to fetch an image that covers 'this.bounds'. │ │ │ │ - var id = this.asyncRequestId = (this.asyncRequestId || 0) + 1; │ │ │ │ - this.layer.getURLasync(this.bounds, function(url) { │ │ │ │ - if (id == this.asyncRequestId) { │ │ │ │ - this.url = url; │ │ │ │ - this.initImage(); │ │ │ │ - } │ │ │ │ - }, this); │ │ │ │ - } else { │ │ │ │ - // synchronous image requests get the url immediately. │ │ │ │ - this.url = this.layer.getURL(this.bounds); │ │ │ │ - this.initImage(); │ │ │ │ + update: function(xy) { │ │ │ │ + this.points.unshift({ │ │ │ │ + xy: xy, │ │ │ │ + tick: new Date().getTime() │ │ │ │ + }); │ │ │ │ + if (this.points.length > this.nbPoints) { │ │ │ │ + this.points.pop(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: positionTile │ │ │ │ - * Using the properties currenty set on the layer, position the tile correctly. │ │ │ │ - * This method is used both by the async and non-async versions of the Tile.Image │ │ │ │ - * code. │ │ │ │ - */ │ │ │ │ - positionTile: function() { │ │ │ │ - var style = this.getTile().style, │ │ │ │ - size = this.frame ? this.size : │ │ │ │ - this.layer.getImageSize(this.bounds), │ │ │ │ - ratio = 1; │ │ │ │ - if (this.layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ - ratio = this.layer.getServerResolution() / this.layer.map.getResolution(); │ │ │ │ - } │ │ │ │ - style.left = this.position.x + "px"; │ │ │ │ - style.top = this.position.y + "px"; │ │ │ │ - style.width = Math.round(ratio * size.w) + "px"; │ │ │ │ - style.height = Math.round(ratio * size.h) + "px"; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clear │ │ │ │ - * Remove the tile from the DOM, clear it of any image related data so that │ │ │ │ - * it can be reused in a new location. │ │ │ │ + * Method: end │ │ │ │ + * Ends the dragging, start the kinetic. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {} The last position. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with two properties: "speed", and "theta". The │ │ │ │ + * "speed" and "theta" values are to be passed to the move │ │ │ │ + * function when starting the animation. │ │ │ │ */ │ │ │ │ - clear: function() { │ │ │ │ - OpenLayers.Tile.prototype.clear.apply(this, arguments); │ │ │ │ - var img = this.imgDiv; │ │ │ │ - if (img) { │ │ │ │ - var tile = this.getTile(); │ │ │ │ - if (tile.parentNode === this.layer.div) { │ │ │ │ - this.layer.div.removeChild(tile); │ │ │ │ - } │ │ │ │ - this.setImgSrc(); │ │ │ │ - if (this.layerAlphaHack === true) { │ │ │ │ - img.style.filter = ""; │ │ │ │ + end: function(xy) { │ │ │ │ + var last, now = new Date().getTime(); │ │ │ │ + for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ + point = this.points[i]; │ │ │ │ + if (now - point.tick > this.delay) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ - OpenLayers.Element.removeClass(img, "olImageLoadError"); │ │ │ │ + last = point; │ │ │ │ } │ │ │ │ - this.canvasContext = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getImage │ │ │ │ - * Returns or creates and returns the tile image. │ │ │ │ - */ │ │ │ │ - getImage: function() { │ │ │ │ - if (!this.imgDiv) { │ │ │ │ - this.imgDiv = OpenLayers.Tile.Image.IMAGE.cloneNode(false); │ │ │ │ - │ │ │ │ - var style = this.imgDiv.style; │ │ │ │ - if (this.frame) { │ │ │ │ - var left = 0, │ │ │ │ - top = 0; │ │ │ │ - if (this.layer.gutter) { │ │ │ │ - left = this.layer.gutter / this.layer.tileSize.w * 100; │ │ │ │ - top = this.layer.gutter / this.layer.tileSize.h * 100; │ │ │ │ - } │ │ │ │ - style.left = -left + "%"; │ │ │ │ - style.top = -top + "%"; │ │ │ │ - style.width = (2 * left + 100) + "%"; │ │ │ │ - style.height = (2 * top + 100) + "%"; │ │ │ │ - } │ │ │ │ - style.visibility = "hidden"; │ │ │ │ - style.opacity = 0; │ │ │ │ - if (this.layer.opacity < 1) { │ │ │ │ - style.filter = 'alpha(opacity=' + │ │ │ │ - (this.layer.opacity * 100) + │ │ │ │ - ')'; │ │ │ │ - } │ │ │ │ - style.position = "absolute"; │ │ │ │ - if (this.layerAlphaHack) { │ │ │ │ - // move the image out of sight │ │ │ │ - style.paddingTop = style.height; │ │ │ │ - style.height = "0"; │ │ │ │ - style.width = "100%"; │ │ │ │ - } │ │ │ │ - if (this.frame) { │ │ │ │ - this.frame.appendChild(this.imgDiv); │ │ │ │ - } │ │ │ │ + if (!last) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ - │ │ │ │ - return this.imgDiv; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setImage │ │ │ │ - * Sets the image element for this tile. This method should only be called │ │ │ │ - * from beforeload listeners. │ │ │ │ - * │ │ │ │ - * Parameters │ │ │ │ - * img - {HTMLImageElement} The image to use for this tile. │ │ │ │ - */ │ │ │ │ - setImage: function(img) { │ │ │ │ - this.imgDiv = img; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: initImage │ │ │ │ - * Creates the content for the frame on the tile. │ │ │ │ - */ │ │ │ │ - initImage: function() { │ │ │ │ - if (!this.url && !this.imgDiv) { │ │ │ │ - // fast path out - if there is no tile url and no previous image │ │ │ │ - this.isLoading = false; │ │ │ │ + var time = new Date().getTime() - last.tick; │ │ │ │ + var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + │ │ │ │ + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ + var speed = dist / time; │ │ │ │ + if (speed == 0 || speed < this.threshold) { │ │ │ │ return; │ │ │ │ } │ │ │ │ - this.events.triggerEvent('beforeload'); │ │ │ │ - this.layer.div.appendChild(this.getTile()); │ │ │ │ - this.events.triggerEvent(this._loadEvent); │ │ │ │ - var img = this.getImage(); │ │ │ │ - var src = img.getAttribute('src') || ''; │ │ │ │ - if (this.url && OpenLayers.Util.isEquivalentUrl(src, this.url)) { │ │ │ │ - this._loadTimeout = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(this.onImageLoad, this), 0 │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.stopLoading(); │ │ │ │ - if (this.crossOriginKeyword) { │ │ │ │ - img.removeAttribute("crossorigin"); │ │ │ │ - } │ │ │ │ - OpenLayers.Event.observe(img, "load", │ │ │ │ - OpenLayers.Function.bind(this.onImageLoad, this) │ │ │ │ - ); │ │ │ │ - OpenLayers.Event.observe(img, "error", │ │ │ │ - OpenLayers.Function.bind(this.onImageError, this) │ │ │ │ - ); │ │ │ │ - this.imageReloadAttempts = 0; │ │ │ │ - this.setImgSrc(this.url); │ │ │ │ + var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ + if (last.xy.x <= xy.x) { │ │ │ │ + theta = Math.PI - theta; │ │ │ │ } │ │ │ │ + return { │ │ │ │ + speed: speed, │ │ │ │ + theta: theta │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setImgSrc │ │ │ │ - * Sets the source for the tile image │ │ │ │ + * Method: move │ │ │ │ + * Launch the kinetic move pan. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * url - {String} or undefined to hide the image │ │ │ │ + * info - {Object} An object with two properties, "speed", and "theta". │ │ │ │ + * These values are those returned from the "end" call. │ │ │ │ + * callback - {Function} Function called on every step of the animation, │ │ │ │ + * receives x, y (values to pan), end (is the last point). │ │ │ │ */ │ │ │ │ - setImgSrc: function(url) { │ │ │ │ - var img = this.imgDiv; │ │ │ │ - if (url) { │ │ │ │ - img.style.visibility = 'hidden'; │ │ │ │ - img.style.opacity = 0; │ │ │ │ - // don't set crossOrigin if the url is a data URL │ │ │ │ - if (this.crossOriginKeyword) { │ │ │ │ - if (url.substr(0, 5) !== 'data:') { │ │ │ │ - img.setAttribute("crossorigin", this.crossOriginKeyword); │ │ │ │ - } else { │ │ │ │ - img.removeAttribute("crossorigin"); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - img.src = url; │ │ │ │ - } else { │ │ │ │ - // Remove reference to the image, and leave it to the browser's │ │ │ │ - // caching and garbage collection. │ │ │ │ - this.stopLoading(); │ │ │ │ - this.imgDiv = null; │ │ │ │ - if (img.parentNode) { │ │ │ │ - img.parentNode.removeChild(img); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + move: function(info, callback) { │ │ │ │ + var v0 = info.speed; │ │ │ │ + var fx = Math.cos(info.theta); │ │ │ │ + var fy = -Math.sin(info.theta); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getTile │ │ │ │ - * Get the tile's markup. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The tile's markup │ │ │ │ - */ │ │ │ │ - getTile: function() { │ │ │ │ - return this.frame ? this.frame : this.getImage(); │ │ │ │ - }, │ │ │ │ + var initialTime = new Date().getTime(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createBackBuffer │ │ │ │ - * Create a backbuffer for this tile. A backbuffer isn't exactly a clone │ │ │ │ - * of the tile's markup, because we want to avoid the reloading of the │ │ │ │ - * image. So we clone the frame, and steal the image from the tile. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The markup, or undefined if the tile has no image │ │ │ │ - * or if it's currently loading. │ │ │ │ - */ │ │ │ │ - createBackBuffer: function() { │ │ │ │ - if (!this.imgDiv || this.isLoading) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var backBuffer; │ │ │ │ - if (this.frame) { │ │ │ │ - backBuffer = this.frame.cloneNode(false); │ │ │ │ - backBuffer.appendChild(this.imgDiv); │ │ │ │ - } else { │ │ │ │ - backBuffer = this.imgDiv; │ │ │ │ - } │ │ │ │ - this.imgDiv = null; │ │ │ │ - return backBuffer; │ │ │ │ - }, │ │ │ │ + var lastX = 0; │ │ │ │ + var lastY = 0; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onImageLoad │ │ │ │ - * Handler for the image onload event │ │ │ │ - */ │ │ │ │ - onImageLoad: function() { │ │ │ │ - var img = this.imgDiv; │ │ │ │ - this.stopLoading(); │ │ │ │ - img.style.visibility = 'inherit'; │ │ │ │ - img.style.opacity = this.layer.opacity; │ │ │ │ - this.isLoading = false; │ │ │ │ - this.canvasContext = null; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ + var timerCallback = function() { │ │ │ │ + if (this.timerId == null) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ │ │ │ │ - if (this.layerAlphaHack === true) { │ │ │ │ - img.style.filter = │ │ │ │ - "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + │ │ │ │ - img.src + "', sizingMethod='scale')"; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + var t = new Date().getTime() - initialTime; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onImageError │ │ │ │ - * Handler for the image onerror event │ │ │ │ - */ │ │ │ │ - onImageError: function() { │ │ │ │ - var img = this.imgDiv; │ │ │ │ - if (img.src != null) { │ │ │ │ - this.imageReloadAttempts++; │ │ │ │ - if (this.imageReloadAttempts <= OpenLayers.IMAGE_RELOAD_ATTEMPTS) { │ │ │ │ - this.setImgSrc(this.layer.getURL(this.bounds)); │ │ │ │ - } else { │ │ │ │ - OpenLayers.Element.addClass(img, "olImageLoadError"); │ │ │ │ - this.events.triggerEvent("loaderror"); │ │ │ │ - this.onImageLoad(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t; │ │ │ │ + var x = p * fx; │ │ │ │ + var y = p * fy; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: stopLoading │ │ │ │ - * Stops a loading sequence so won't be executed. │ │ │ │ - */ │ │ │ │ - stopLoading: function() { │ │ │ │ - OpenLayers.Event.stopObservingElement(this.imgDiv); │ │ │ │ - window.clearTimeout(this._loadTimeout); │ │ │ │ - delete this._loadTimeout; │ │ │ │ - }, │ │ │ │ + var args = {}; │ │ │ │ + args.end = false; │ │ │ │ + var v = -this.deceleration * t + v0; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getCanvasContext │ │ │ │ - * Returns a canvas context associated with the tile image (with │ │ │ │ - * the image drawn on it). │ │ │ │ - * Returns undefined if the browser does not support canvas, if │ │ │ │ - * the tile has no image or if it's currently loading. │ │ │ │ - * │ │ │ │ - * The function returns a canvas context instance but the │ │ │ │ - * underlying canvas is still available in the 'canvas' property: │ │ │ │ - * (code) │ │ │ │ - * var context = tile.getCanvasContext(); │ │ │ │ - * if (context) { │ │ │ │ - * var data = context.canvas.toDataURL('image/jpeg'); │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - getCanvasContext: function() { │ │ │ │ - if (OpenLayers.CANVAS_SUPPORTED && this.imgDiv && !this.isLoading) { │ │ │ │ - if (!this.canvasContext) { │ │ │ │ - var canvas = document.createElement("canvas"); │ │ │ │ - canvas.width = this.size.w; │ │ │ │ - canvas.height = this.size.h; │ │ │ │ - this.canvasContext = canvas.getContext("2d"); │ │ │ │ - this.canvasContext.drawImage(this.imgDiv, 0, 0); │ │ │ │ + if (v <= 0) { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + args.end = true; │ │ │ │ } │ │ │ │ - return this.canvasContext; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Tile.Image" │ │ │ │ │ │ │ │ -}); │ │ │ │ + args.x = x - lastX; │ │ │ │ + args.y = y - lastY; │ │ │ │ + lastX = x; │ │ │ │ + lastY = y; │ │ │ │ + callback(args.x, args.y, args.end); │ │ │ │ + }; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Tile.Image.IMAGE │ │ │ │ - * {HTMLImageElement} The image for a tile. │ │ │ │ - */ │ │ │ │ -OpenLayers.Tile.Image.IMAGE = (function() { │ │ │ │ - var img = new Image(); │ │ │ │ - img.className = "olTileImage"; │ │ │ │ - // avoid image gallery menu in IE6 │ │ │ │ - img.galleryImg = "no"; │ │ │ │ - return img; │ │ │ │ -}()); │ │ │ │ + this.timerId = OpenLayers.Animation.start( │ │ │ │ + OpenLayers.Function.bind(timerCallback, this) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Grid.js │ │ │ │ + OpenLayers/Feature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/HTTPRequest.js │ │ │ │ - * @requires OpenLayers/Tile/Image.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.Grid │ │ │ │ - * Base class for layers that use a lattice of tiles. Create a new grid │ │ │ │ - * layer with the constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - │ │ │ │ + * Class: OpenLayers.Feature │ │ │ │ + * Features are combinations of geography and attributes. The OpenLayers.Feature │ │ │ │ + * class specifically combines a marker and a lonlat. │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, { │ │ │ │ +OpenLayers.Feature = OpenLayers.Class({ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: tileSize │ │ │ │ - * {} │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - tileSize: null, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: tileOriginCorner │ │ │ │ - * {String} If the property is not provided, the tile origin │ │ │ │ - * will be derived from the layer's . The corner of the │ │ │ │ - * used is determined by this property. Acceptable values │ │ │ │ - * are "tl" (top left), "tr" (top right), "bl" (bottom left), and "br" │ │ │ │ - * (bottom right). Default is "bl". │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - tileOriginCorner: "bl", │ │ │ │ + id: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: tileOrigin │ │ │ │ - * {} Optional origin for aligning the grid of tiles. │ │ │ │ - * If provided, requests for tiles at all resolutions will be aligned │ │ │ │ - * with this location (no tiles shall overlap this location). If │ │ │ │ - * not provided, the grid of tiles will be aligned with the layer's │ │ │ │ - * . Default is ``null``. │ │ │ │ + /** │ │ │ │ + * Property: lonlat │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - tileOrigin: null, │ │ │ │ + lonlat: null, │ │ │ │ │ │ │ │ - /** APIProperty: tileOptions │ │ │ │ - * {Object} optional configuration options for instances │ │ │ │ - * created by this Layer, if supported by the tile class. │ │ │ │ + /** │ │ │ │ + * Property: data │ │ │ │ + * {Object} │ │ │ │ */ │ │ │ │ - tileOptions: null, │ │ │ │ + data: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: tileClass │ │ │ │ - * {} The tile class to use for this layer. │ │ │ │ - * Defaults is OpenLayers.Tile.Image. │ │ │ │ + /** │ │ │ │ + * Property: marker │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - tileClass: OpenLayers.Tile.Image, │ │ │ │ + marker: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: grid │ │ │ │ - * {Array(Array())} This is an array of rows, each row is │ │ │ │ - * an array of tiles. │ │ │ │ + * APIProperty: popupClass │ │ │ │ + * {} The class which will be used to instantiate │ │ │ │ + * a new Popup. Default is . │ │ │ │ */ │ │ │ │ - grid: null, │ │ │ │ + popupClass: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: singleTile │ │ │ │ - * {Boolean} Moves the layer into single-tile mode, meaning that one tile │ │ │ │ - * will be loaded. The tile's size will be determined by the 'ratio' │ │ │ │ - * property. When the tile is dragged such that it does not cover the │ │ │ │ - * entire viewport, it is reloaded. │ │ │ │ + /** │ │ │ │ + * Property: popup │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - singleTile: false, │ │ │ │ + popup: null, │ │ │ │ │ │ │ │ - /** APIProperty: ratio │ │ │ │ - * {Float} Used only when in single-tile mode, this specifies the │ │ │ │ - * ratio of the size of the single tile to the size of the map. │ │ │ │ - * Default value is 1.5. │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Feature │ │ │ │ + * Constructor for features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {} │ │ │ │ + * lonlat - {} │ │ │ │ + * data - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - ratio: 1.5, │ │ │ │ + initialize: function(layer, lonlat, data) { │ │ │ │ + this.layer = layer; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + this.data = (data != null) ? data : {}; │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: buffer │ │ │ │ - * {Integer} Used only when in gridded mode, this specifies the number of │ │ │ │ - * extra rows and colums of tiles on each side which will │ │ │ │ - * surround the minimum grid tiles to cover the map. │ │ │ │ - * For very slow loading layers, a larger value may increase │ │ │ │ - * performance somewhat when dragging, but will increase bandwidth │ │ │ │ - * use significantly. │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ */ │ │ │ │ - buffer: 0, │ │ │ │ + destroy: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: transitionEffect │ │ │ │ - * {String} The transition effect to use when the map is zoomed. │ │ │ │ - * Two posible values: │ │ │ │ - * │ │ │ │ - * "resize" - Existing tiles are resized on zoom to provide a visual │ │ │ │ - * effect of the zoom having taken place immediately. As the │ │ │ │ - * new tiles become available, they are drawn on top of the │ │ │ │ - * resized tiles (this is the default setting). │ │ │ │ - * "map-resize" - Existing tiles are resized on zoom and placed below the │ │ │ │ - * base layer. New tiles for the base layer will cover existing tiles. │ │ │ │ - * This setting is recommended when having an overlay duplicated during │ │ │ │ - * the transition is undesirable (e.g. street labels or big transparent │ │ │ │ - * fills). │ │ │ │ - * null - No transition effect. │ │ │ │ - * │ │ │ │ - * Using "resize" on non-opaque layers can cause undesired visual │ │ │ │ - * effects. Set transitionEffect to null in this case. │ │ │ │ - */ │ │ │ │ - transitionEffect: "resize", │ │ │ │ + //remove the popup from the map │ │ │ │ + if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.layer.map.removePopup(this.popup); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // remove the marker from the layer │ │ │ │ + if (this.layer != null && this.marker != null) { │ │ │ │ + this.layer.removeMarker(this.marker); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: numLoadingTiles │ │ │ │ - * {Integer} How many tiles are still loading? │ │ │ │ - */ │ │ │ │ - numLoadingTiles: 0, │ │ │ │ + this.layer = null; │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.data = null; │ │ │ │ + if (this.marker != null) { │ │ │ │ + this.destroyMarker(this.marker); │ │ │ │ + this.marker = null; │ │ │ │ + } │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.destroyPopup(this.popup); │ │ │ │ + this.popup = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: serverResolutions │ │ │ │ - * {Array(Number}} This property is documented in subclasses as │ │ │ │ - * an API property. │ │ │ │ + * Method: onScreen │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the feature is currently visible on screen │ │ │ │ + * (based on its 'lonlat' property) │ │ │ │ */ │ │ │ │ - serverResolutions: null, │ │ │ │ + onScreen: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: loading │ │ │ │ - * {Boolean} Indicates if tiles are being loaded. │ │ │ │ - */ │ │ │ │ - loading: false, │ │ │ │ + var onScreen = false; │ │ │ │ + if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsLonLat(this.lonlat); │ │ │ │ + } │ │ │ │ + return onScreen; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: backBuffer │ │ │ │ - * {DOMElement} The back buffer. │ │ │ │ - */ │ │ │ │ - backBuffer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: gridResolution │ │ │ │ - * {Number} The resolution of the current grid. Used for backbuffer and │ │ │ │ - * client zoom. This property is updated every time the grid is │ │ │ │ - * initialized. │ │ │ │ + * Method: createMarker │ │ │ │ + * Based on the data associated with the Feature, create and return a marker object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} A Marker Object created from the 'lonlat' and 'icon' properties │ │ │ │ + * set in this.data. If no 'lonlat' is set, returns null. If no │ │ │ │ + * 'icon' is set, OpenLayers.Marker() will load the default image. │ │ │ │ + * │ │ │ │ + * Note - this.marker is set to return value │ │ │ │ + * │ │ │ │ */ │ │ │ │ - gridResolution: null, │ │ │ │ + createMarker: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: backBufferResolution │ │ │ │ - * {Number} The resolution of the current back buffer. This property is │ │ │ │ - * updated each time a back buffer is created. │ │ │ │ - */ │ │ │ │ - backBufferResolution: null, │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon); │ │ │ │ + } │ │ │ │ + return this.marker; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: backBufferLonLat │ │ │ │ - * {Object} The top-left corner of the current back buffer. Includes lon │ │ │ │ - * and lat properties. This object is updated each time a back buffer │ │ │ │ - * is created. │ │ │ │ + * Method: destroyMarker │ │ │ │ + * Destroys marker. │ │ │ │ + * If user overrides the createMarker() function, s/he should be able │ │ │ │ + * to also specify an alternative function for destroying it │ │ │ │ */ │ │ │ │ - backBufferLonLat: null, │ │ │ │ + destroyMarker: function() { │ │ │ │ + this.marker.destroy(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: backBufferTimerId │ │ │ │ - * {Number} The id of the back buffer timer. This timer is used to │ │ │ │ - * delay the removal of the back buffer, thereby preventing │ │ │ │ - * flash effects caused by tile animation. │ │ │ │ - */ │ │ │ │ - backBufferTimerId: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: removeBackBufferDelay │ │ │ │ - * {Number} Delay for removing the backbuffer when all tiles have finished │ │ │ │ - * loading. Can be set to 0 when no css opacity transitions for the │ │ │ │ - * olTileImage class are used. Default is 0 for layers, │ │ │ │ - * 2500 for tiled layers. See for more information on │ │ │ │ - * tile animation. │ │ │ │ - */ │ │ │ │ - removeBackBufferDelay: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: className │ │ │ │ - * {String} Name of the class added to the layer div. If not set in the │ │ │ │ - * options passed to the constructor then className defaults to │ │ │ │ - * "olLayerGridSingleTile" for single tile layers (see ), │ │ │ │ - * and "olLayerGrid" for non single tile layers. │ │ │ │ - * │ │ │ │ - * Note: │ │ │ │ + * Method: createPopup │ │ │ │ + * Creates a popup object created from the 'lonlat', 'popupSize', │ │ │ │ + * and 'popupContentHTML' properties set in this.data. It uses │ │ │ │ + * this.marker.icon as default anchor. │ │ │ │ + * │ │ │ │ + * If no 'lonlat' is set, returns null. │ │ │ │ + * If no this.marker has been created, no anchor is sent. │ │ │ │ * │ │ │ │ - * The displaying of tiles is not animated by default for single tile │ │ │ │ - * layers - OpenLayers' default theme (style.css) includes this: │ │ │ │ - * (code) │ │ │ │ - * .olLayerGrid .olTileImage { │ │ │ │ - * -webkit-transition: opacity 0.2s linear; │ │ │ │ - * -moz-transition: opacity 0.2s linear; │ │ │ │ - * -o-transition: opacity 0.2s linear; │ │ │ │ - * transition: opacity 0.2s linear; │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * To animate tile displaying for any grid layer the following │ │ │ │ - * CSS rule can be used: │ │ │ │ - * (code) │ │ │ │ - * .olTileImage { │ │ │ │ - * -webkit-transition: opacity 0.2s linear; │ │ │ │ - * -moz-transition: opacity 0.2s linear; │ │ │ │ - * -o-transition: opacity 0.2s linear; │ │ │ │ - * transition: opacity 0.2s linear; │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * In that case, to avoid flash effects, │ │ │ │ - * should not be zero. │ │ │ │ + * Note - the returned popup object is 'owned' by the feature, so you │ │ │ │ + * cannot use the popup's destroy method to discard the popup. │ │ │ │ + * Instead, you must use the feature's destroyPopup │ │ │ │ + * │ │ │ │ + * Note - this.popup is set to return value │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * closeBox - {Boolean} create popup with closebox or not │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} Returns the created popup, which is also set │ │ │ │ + * as 'popup' property of this feature. Will be of whatever type │ │ │ │ + * specified by this feature's 'popupClass' property, but must be │ │ │ │ + * of type . │ │ │ │ + * │ │ │ │ */ │ │ │ │ - className: null, │ │ │ │ + createPopup: function(closeBox) { │ │ │ │ + │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + if (!this.popup) { │ │ │ │ + var anchor = (this.marker) ? this.marker.icon : null; │ │ │ │ + var popupClass = this.popupClass ? │ │ │ │ + this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ + this.popup = new popupClass(this.id + "_popup", │ │ │ │ + this.lonlat, │ │ │ │ + this.data.popupSize, │ │ │ │ + this.data.popupContentHTML, │ │ │ │ + anchor, │ │ │ │ + closeBox); │ │ │ │ + } │ │ │ │ + if (this.data.overflow != null) { │ │ │ │ + this.popup.contentDiv.style.overflow = this.data.overflow; │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.popup.feature = this; │ │ │ │ + } │ │ │ │ + return this.popup; │ │ │ │ + }, │ │ │ │ + │ │ │ │ │ │ │ │ /** │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * layer.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 layer.events.object. │ │ │ │ - * element - {DOMElement} A reference to layer.events.element. │ │ │ │ + * Method: destroyPopup │ │ │ │ + * Destroys the popup created via createPopup. │ │ │ │ * │ │ │ │ - * Supported event types: │ │ │ │ - * addtile - Triggered when a tile is added to this layer. Listeners receive │ │ │ │ - * an object as first argument, which has a tile property that │ │ │ │ - * references the tile that has been added. │ │ │ │ - * tileloadstart - Triggered when a tile starts loading. Listeners receive │ │ │ │ - * an object as first argument, which has a tile property that │ │ │ │ - * references the tile that starts loading. │ │ │ │ - * tileloaded - Triggered when each new tile is │ │ │ │ - * loaded, as a means of progress update to listeners. │ │ │ │ - * listeners can access 'numLoadingTiles' if they wish to keep │ │ │ │ - * track of the loading progress. Listeners are called with an object │ │ │ │ - * with a 'tile' property as first argument, making the loaded tile │ │ │ │ - * available to the listener, and an 'aborted' property, which will be │ │ │ │ - * true when loading was aborted and no tile data is available. │ │ │ │ - * tileerror - Triggered before the tileloaded event (i.e. when the tile is │ │ │ │ - * still hidden) if a tile failed to load. Listeners receive an object │ │ │ │ - * as first argument, which has a tile property that references the │ │ │ │ - * tile that could not be loaded. │ │ │ │ - * retile - Triggered when the layer recreates its tile grid. │ │ │ │ + * As with the marker, if user overrides the createPopup() function, s/he │ │ │ │ + * should also be able to override the destruction │ │ │ │ */ │ │ │ │ + destroyPopup: function() { │ │ │ │ + if (this.popup) { │ │ │ │ + this.popup.feature = null; │ │ │ │ + this.popup.destroy(); │ │ │ │ + this.popup = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: gridLayout │ │ │ │ - * {Object} Object containing properties tilelon, tilelat, startcol, │ │ │ │ - * startrow │ │ │ │ - */ │ │ │ │ - gridLayout: null, │ │ │ │ + CLASS_NAME: "OpenLayers.Feature" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: rowSign │ │ │ │ - * {Number} 1 for grids starting at the top, -1 for grids starting at the │ │ │ │ - * bottom. This is used for several grid index and offset calculations. │ │ │ │ - */ │ │ │ │ - rowSign: null, │ │ │ │ +// XMLHttpRequest.js Copyright (C) 2010 Sergey Ilinsky (http://www.ilinsky.com) │ │ │ │ +// │ │ │ │ +// 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. │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: transitionendEvents │ │ │ │ - * {Array} Event names for transitionend │ │ │ │ - */ │ │ │ │ - transitionendEvents: [ │ │ │ │ - 'transitionend', 'webkitTransitionEnd', 'otransitionend', │ │ │ │ - 'oTransitionEnd' │ │ │ │ - ], │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.Grid │ │ │ │ - * Create a new grid layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * url - {String} │ │ │ │ - * params - {Object} │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.initialize.apply(this, │ │ │ │ - arguments); │ │ │ │ - this.grid = []; │ │ │ │ - this._removeBackBuffer = OpenLayers.Function.bind(this.removeBackBuffer, this); │ │ │ │ +(function() { │ │ │ │ │ │ │ │ - this.initProperties(); │ │ │ │ + // Save reference to earlier defined object implementation (if any) │ │ │ │ + var oXMLHttpRequest = window.XMLHttpRequest; │ │ │ │ │ │ │ │ - this.rowSign = this.tileOriginCorner.substr(0, 1) === "t" ? 1 : -1; │ │ │ │ - }, │ │ │ │ + // Define on browser type │ │ │ │ + var bGecko = !!window.controllers, │ │ │ │ + bIE = window.document.all && !window.opera, │ │ │ │ + bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: initProperties │ │ │ │ - * Set any properties that depend on the value of singleTile. │ │ │ │ - * Currently sets removeBackBufferDelay and className │ │ │ │ - */ │ │ │ │ - initProperties: function() { │ │ │ │ - if (this.options.removeBackBufferDelay === undefined) { │ │ │ │ - this.removeBackBufferDelay = this.singleTile ? 0 : 2500; │ │ │ │ - } │ │ │ │ + // Enables "XMLHttpRequest()" call next to "new XMLHttpReques()" │ │ │ │ + function fXMLHttpRequest() { │ │ │ │ + this._object = oXMLHttpRequest && !bIE7 ? new oXMLHttpRequest : new window.ActiveXObject("Microsoft.XMLHTTP"); │ │ │ │ + this._listeners = []; │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (this.options.className === undefined) { │ │ │ │ - this.className = this.singleTile ? 'olLayerGridSingleTile' : │ │ │ │ - 'olLayerGrid'; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + // Constructor │ │ │ │ + function cXMLHttpRequest() { │ │ │ │ + return new fXMLHttpRequest; │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype = fXMLHttpRequest.prototype; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {} The map. │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.setMap.call(this, map); │ │ │ │ - OpenLayers.Element.addClass(this.div, this.className); │ │ │ │ - }, │ │ │ │ + // BUGFIX: Firefox with Firebug installed would break pages if not executed │ │ │ │ + if (bGecko && oXMLHttpRequest.wrapped) │ │ │ │ + cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeMap │ │ │ │ - * Called when the layer is removed from the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {} The map. │ │ │ │ - */ │ │ │ │ - removeMap: function(map) { │ │ │ │ - this.removeBackBuffer(); │ │ │ │ - }, │ │ │ │ + // Constants │ │ │ │ + cXMLHttpRequest.UNSENT = 0; │ │ │ │ + cXMLHttpRequest.OPENED = 1; │ │ │ │ + cXMLHttpRequest.HEADERS_RECEIVED = 2; │ │ │ │ + cXMLHttpRequest.LOADING = 3; │ │ │ │ + cXMLHttpRequest.DONE = 4; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Deconstruct the layer and clear the grid. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.removeBackBuffer(); │ │ │ │ - this.clearGrid(); │ │ │ │ + // Public Properties │ │ │ │ + cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + cXMLHttpRequest.prototype.responseText = ''; │ │ │ │ + cXMLHttpRequest.prototype.responseXML = null; │ │ │ │ + cXMLHttpRequest.prototype.status = 0; │ │ │ │ + cXMLHttpRequest.prototype.statusText = ''; │ │ │ │ │ │ │ │ - this.grid = null; │ │ │ │ - this.tileSize = null; │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + // Priority proposal │ │ │ │ + cXMLHttpRequest.prototype.priority = "NORMAL"; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: mergeNewParams │ │ │ │ - * Refetches tiles with new params merged, keeping a backbuffer. Each │ │ │ │ - * loading new tile will have a css class of '.olTileReplacing'. If a │ │ │ │ - * stylesheet applies a 'display: none' style to that class, any fade-in │ │ │ │ - * transition will not apply, and backbuffers for each tile will be removed │ │ │ │ - * as soon as the tile is loaded. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * newParams - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * redrawn: {Boolean} whether the layer was actually redrawn. │ │ │ │ - */ │ │ │ │ + // Instance-level Events Handlers │ │ │ │ + cXMLHttpRequest.prototype.onreadystatechange = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clearGrid │ │ │ │ - * Go through and remove all tiles from the grid, calling │ │ │ │ - * destroy() on each of them to kill circular references │ │ │ │ - */ │ │ │ │ - clearGrid: function() { │ │ │ │ - if (this.grid) { │ │ │ │ - for (var iRow = 0, len = this.grid.length; iRow < len; iRow++) { │ │ │ │ - var row = this.grid[iRow]; │ │ │ │ - for (var iCol = 0, clen = row.length; iCol < clen; iCol++) { │ │ │ │ - var tile = row[iCol]; │ │ │ │ - this.destroyTile(tile); │ │ │ │ + // Class-level Events Handlers │ │ │ │ + cXMLHttpRequest.onreadystatechange = null; │ │ │ │ + cXMLHttpRequest.onopen = null; │ │ │ │ + cXMLHttpRequest.onsend = null; │ │ │ │ + cXMLHttpRequest.onabort = null; │ │ │ │ + │ │ │ │ + // Public Methods │ │ │ │ + cXMLHttpRequest.prototype.open = function(sMethod, sUrl, bAsync, sUser, sPassword) { │ │ │ │ + // Delete headers, required when object is reused │ │ │ │ + delete this._headers; │ │ │ │ + │ │ │ │ + // When bAsync parameter value is omitted, use true as default │ │ │ │ + if (arguments.length < 3) │ │ │ │ + bAsync = true; │ │ │ │ + │ │ │ │ + // Save async parameter for fixing Gecko bug with missing readystatechange in synchronous requests │ │ │ │ + this._async = bAsync; │ │ │ │ + │ │ │ │ + // Set the onreadystatechange handler │ │ │ │ + var oRequest = this, │ │ │ │ + nState = this.readyState, │ │ │ │ + fOnUnload; │ │ │ │ + │ │ │ │ + // BUGFIX: IE - memory leak on page unload (inter-page leak) │ │ │ │ + if (bIE && bAsync) { │ │ │ │ + fOnUnload = function() { │ │ │ │ + if (nState != cXMLHttpRequest.DONE) { │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + // Safe to abort here since onreadystatechange handler removed │ │ │ │ + oRequest.abort(); │ │ │ │ } │ │ │ │ - } │ │ │ │ - this.grid = []; │ │ │ │ - this.gridResolution = null; │ │ │ │ - this.gridLayout = null; │ │ │ │ + }; │ │ │ │ + window.attachEvent("onunload", fOnUnload); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: addOptions │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * newOptions - {Object} │ │ │ │ - * reinitialize - {Boolean} If set to true, and if resolution options of the │ │ │ │ - * current baseLayer were changed, the map will be recentered to make │ │ │ │ - * sure that it is displayed with a valid resolution, and a │ │ │ │ - * changebaselayer event will be triggered. │ │ │ │ - */ │ │ │ │ - addOptions: function(newOptions, reinitialize) { │ │ │ │ - var singleTileChanged = newOptions.singleTile !== undefined && │ │ │ │ - newOptions.singleTile !== this.singleTile; │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.addOptions.apply(this, arguments); │ │ │ │ - if (this.map && singleTileChanged) { │ │ │ │ - this.initProperties(); │ │ │ │ - this.clearGrid(); │ │ │ │ - this.tileSize = this.options.tileSize; │ │ │ │ - this.setTileSize(); │ │ │ │ - this.moveTo(null, true); │ │ │ │ + // Add method sniffer │ │ │ │ + if (cXMLHttpRequest.onopen) │ │ │ │ + cXMLHttpRequest.onopen.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (arguments.length > 4) │ │ │ │ + this._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ + else │ │ │ │ + if (arguments.length > 3) │ │ │ │ + this._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ + else │ │ │ │ + this._object.open(sMethod, sUrl, bAsync); │ │ │ │ + │ │ │ │ + this.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + fReadyStateChange(this); │ │ │ │ + │ │ │ │ + this._object.onreadystatechange = function() { │ │ │ │ + if (bGecko && !bAsync) │ │ │ │ + return; │ │ │ │ + │ │ │ │ + // Synchronize state │ │ │ │ + oRequest.readyState = oRequest._object.readyState; │ │ │ │ + │ │ │ │ + // │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + │ │ │ │ + // BUGFIX: Firefox fires unnecessary DONE when aborting │ │ │ │ + if (oRequest._aborted) { │ │ │ │ + // Reset readyState to UNSENT │ │ │ │ + oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + │ │ │ │ + // Return now │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ + // Free up queue │ │ │ │ + delete oRequest._data; │ │ │ │ + /* if (bAsync) │ │ │ │ + fQueue_remove(oRequest);*/ │ │ │ │ + // │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + // Uncomment this block if you need a fix for IE cache │ │ │ │ + /* │ │ │ │ + // BUGFIX: IE - cache issue │ │ │ │ + if (!oRequest._object.getResponseHeader("Date")) { │ │ │ │ + // Save object to cache │ │ │ │ + oRequest._cached = oRequest._object; │ │ │ │ + │ │ │ │ + // Instantiate a new transport object │ │ │ │ + cXMLHttpRequest.call(oRequest); │ │ │ │ + │ │ │ │ + // Re-send request │ │ │ │ + if (sUser) { │ │ │ │ + if (sPassword) │ │ │ │ + oRequest._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ + else │ │ │ │ + oRequest._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ + } │ │ │ │ + else │ │ │ │ + oRequest._object.open(sMethod, sUrl, bAsync); │ │ │ │ + oRequest._object.setRequestHeader("If-Modified-Since", oRequest._cached.getResponseHeader("Last-Modified") || new window.Date(0)); │ │ │ │ + // Copy headers set │ │ │ │ + if (oRequest._headers) │ │ │ │ + for (var sHeader in oRequest._headers) │ │ │ │ + if (typeof oRequest._headers[sHeader] == "string") // Some frameworks prototype objects with functions │ │ │ │ + oRequest._object.setRequestHeader(sHeader, oRequest._headers[sHeader]); │ │ │ │ + │ │ │ │ + oRequest._object.onreadystatechange = function() { │ │ │ │ + // Synchronize state │ │ │ │ + oRequest.readyState = oRequest._object.readyState; │ │ │ │ + │ │ │ │ + if (oRequest._aborted) { │ │ │ │ + // │ │ │ │ + oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + │ │ │ │ + // Return │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ + // Clean Object │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + │ │ │ │ + // get cached request │ │ │ │ + if (oRequest.status == 304) │ │ │ │ + oRequest._object = oRequest._cached; │ │ │ │ + │ │ │ │ + // │ │ │ │ + delete oRequest._cached; │ │ │ │ + │ │ │ │ + // │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + │ │ │ │ + // │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + │ │ │ │ + // BUGFIX: IE - memory leak in interrupted │ │ │ │ + if (bIE && bAsync) │ │ │ │ + window.detachEvent("onunload", fOnUnload); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + oRequest._object.send(null); │ │ │ │ + │ │ │ │ + // Return now - wait until re-sent request is finished │ │ │ │ + return; │ │ │ │ + }; │ │ │ │ + */ │ │ │ │ + // BUGFIX: IE - memory leak in interrupted │ │ │ │ + if (bIE && bAsync) │ │ │ │ + window.detachEvent("onunload", fOnUnload); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // BUGFIX: Some browsers (Internet Explorer, Gecko) fire OPEN readystate twice │ │ │ │ + if (nState != oRequest.readyState) │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + │ │ │ │ + nState = oRequest.readyState; │ │ │ │ } │ │ │ │ - }, │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a clone of this layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} Is this ever used? │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} An exact clone of this OpenLayers.Layer.Grid │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ + function fXMLHttpRequest_send(oRequest) { │ │ │ │ + oRequest._object.send(oRequest._data); │ │ │ │ │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Grid(this.name, │ │ │ │ - this.url, │ │ │ │ - this.params, │ │ │ │ - this.getOptions()); │ │ │ │ + // BUGFIX: Gecko - missing readystatechange calls in synchronous requests │ │ │ │ + if (bGecko && !oRequest._async) { │ │ │ │ + oRequest.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + │ │ │ │ + // Synchronize state │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + │ │ │ │ + // Simulate missing states │ │ │ │ + while (oRequest.readyState < cXMLHttpRequest.DONE) { │ │ │ │ + oRequest.readyState++; │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + // Check if we are aborted │ │ │ │ + if (oRequest._aborted) │ │ │ │ + return; │ │ │ │ + } │ │ │ │ } │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.send = function(vData) { │ │ │ │ + // Add method sniffer │ │ │ │ + if (cXMLHttpRequest.onsend) │ │ │ │ + cXMLHttpRequest.onsend.apply(this, arguments); │ │ │ │ │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.HTTPRequest.prototype.clone.apply(this, [obj]); │ │ │ │ + if (!arguments.length) │ │ │ │ + vData = null; │ │ │ │ │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - if (this.tileSize != null) { │ │ │ │ - obj.tileSize = this.tileSize.clone(); │ │ │ │ + // BUGFIX: Safari - fails sending documents created/modified dynamically, so an explicit serialization required │ │ │ │ + // BUGFIX: IE - rewrites any custom mime-type to "text/xml" in case an XMLNode is sent │ │ │ │ + // BUGFIX: Gecko - fails sending Element (this is up to the implementation either to standard) │ │ │ │ + if (vData && vData.nodeType) { │ │ │ │ + vData = window.XMLSerializer ? new window.XMLSerializer().serializeToString(vData) : vData.xml; │ │ │ │ + if (!this._headers["Content-Type"]) │ │ │ │ + this._object.setRequestHeader("Content-Type", "application/xml"); │ │ │ │ } │ │ │ │ │ │ │ │ - // we do not want to copy reference to grid, so we make a new array │ │ │ │ - obj.grid = []; │ │ │ │ - obj.gridResolution = null; │ │ │ │ - // same for backbuffer │ │ │ │ - obj.backBuffer = null; │ │ │ │ - obj.backBufferTimerId = null; │ │ │ │ - obj.loading = false; │ │ │ │ - obj.numLoadingTiles = 0; │ │ │ │ + this._data = vData; │ │ │ │ + /* │ │ │ │ + // Add to queue │ │ │ │ + if (this._async) │ │ │ │ + fQueue_add(this); │ │ │ │ + else*/ │ │ │ │ + fXMLHttpRequest_send(this); │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.abort = function() { │ │ │ │ + // Add method sniffer │ │ │ │ + if (cXMLHttpRequest.onabort) │ │ │ │ + cXMLHttpRequest.onabort.apply(this, arguments); │ │ │ │ │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ + // BUGFIX: Gecko - unnecessary DONE when aborting │ │ │ │ + if (this.readyState > cXMLHttpRequest.UNSENT) │ │ │ │ + this._aborted = true; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveTo │ │ │ │ - * This function is called whenever the map is moved. All the moving │ │ │ │ - * of actual 'tiles' is done by the map, but moveTo's role is to accept │ │ │ │ - * a bounds and make sure the data that that bounds requires is pre-loaded. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {} │ │ │ │ - * zoomChanged - {Boolean} │ │ │ │ - * dragging - {Boolean} │ │ │ │ - */ │ │ │ │ - moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ + this._object.abort(); │ │ │ │ │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments); │ │ │ │ + // BUGFIX: IE - memory leak │ │ │ │ + fCleanTransport(this); │ │ │ │ │ │ │ │ - bounds = bounds || this.map.getExtent(); │ │ │ │ + this.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ │ │ │ │ - if (bounds != null) { │ │ │ │ + delete this._data; │ │ │ │ + /* if (this._async) │ │ │ │ + fQueue_remove(this);*/ │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.getAllResponseHeaders = function() { │ │ │ │ + return this._object.getAllResponseHeaders(); │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.getResponseHeader = function(sName) { │ │ │ │ + return this._object.getResponseHeader(sName); │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) { │ │ │ │ + // BUGFIX: IE - cache issue │ │ │ │ + if (!this._headers) │ │ │ │ + this._headers = {}; │ │ │ │ + this._headers[sName] = sValue; │ │ │ │ │ │ │ │ - // if grid is empty or zoom has changed, we *must* re-tile │ │ │ │ - var forceReTile = !this.grid.length || zoomChanged; │ │ │ │ + return this._object.setRequestHeader(sName, sValue); │ │ │ │ + }; │ │ │ │ │ │ │ │ - // total bounds of the tiles │ │ │ │ - var tilesBounds = this.getTilesBounds(); │ │ │ │ + // EventTarget interface implementation │ │ │ │ + cXMLHttpRequest.prototype.addEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ + return; │ │ │ │ + // Add listener │ │ │ │ + this._listeners.push([sName, fHandler, bUseCapture]); │ │ │ │ + }; │ │ │ │ │ │ │ │ - // the new map resolution │ │ │ │ - var resolution = this.map.getResolution(); │ │ │ │ + cXMLHttpRequest.prototype.removeEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ + break; │ │ │ │ + // Remove listener │ │ │ │ + if (oListener) │ │ │ │ + this._listeners.splice(nIndex, 1); │ │ │ │ + }; │ │ │ │ │ │ │ │ - // the server-supported resolution for the new map resolution │ │ │ │ - var serverResolution = this.getServerResolution(resolution); │ │ │ │ + cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) { │ │ │ │ + var oEventPseudo = { │ │ │ │ + 'type': oEvent.type, │ │ │ │ + 'target': this, │ │ │ │ + 'currentTarget': this, │ │ │ │ + 'eventPhase': 2, │ │ │ │ + 'bubbles': oEvent.bubbles, │ │ │ │ + 'cancelable': oEvent.cancelable, │ │ │ │ + 'timeStamp': oEvent.timeStamp, │ │ │ │ + 'stopPropagation': function() {}, // There is no flow │ │ │ │ + 'preventDefault': function() {}, // There is no default action │ │ │ │ + 'initEvent': function() {} // Original event object should be initialized │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (this.singleTile) { │ │ │ │ + // Execute onreadystatechange │ │ │ │ + if (oEventPseudo.type == "readystatechange" && this.onreadystatechange) │ │ │ │ + (this.onreadystatechange.handleEvent || this.onreadystatechange).apply(this, [oEventPseudo]); │ │ │ │ │ │ │ │ - // We want to redraw whenever even the slightest part of the │ │ │ │ - // current bounds is not contained by our tile. │ │ │ │ - // (thus, we do not specify partial -- its default is false) │ │ │ │ + // Execute listeners │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == oEventPseudo.type && !oListener[2]) │ │ │ │ + (oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]); │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (forceReTile || │ │ │ │ - (!dragging && !tilesBounds.containsBounds(bounds))) { │ │ │ │ + // │ │ │ │ + cXMLHttpRequest.prototype.toString = function() { │ │ │ │ + return '[' + "object" + ' ' + "XMLHttpRequest" + ']'; │ │ │ │ + }; │ │ │ │ │ │ │ │ - // In single tile mode with no transition effect, we insert │ │ │ │ - // a non-scaled backbuffer when the layer is moved. But if │ │ │ │ - // a zoom occurs right after a move, i.e. before the new │ │ │ │ - // image is received, we need to remove the backbuffer, or │ │ │ │ - // an ill-positioned image will be visible during the zoom │ │ │ │ - // transition. │ │ │ │ + cXMLHttpRequest.toString = function() { │ │ │ │ + return '[' + "XMLHttpRequest" + ']'; │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (zoomChanged && this.transitionEffect !== 'resize') { │ │ │ │ - this.removeBackBuffer(); │ │ │ │ - } │ │ │ │ + // Helper function │ │ │ │ + function fReadyStateChange(oRequest) { │ │ │ │ + // Sniffing code │ │ │ │ + if (cXMLHttpRequest.onreadystatechange) │ │ │ │ + cXMLHttpRequest.onreadystatechange.apply(oRequest); │ │ │ │ │ │ │ │ - if (!zoomChanged || this.transitionEffect === 'resize') { │ │ │ │ - this.applyBackBuffer(resolution); │ │ │ │ - } │ │ │ │ + // Fake event │ │ │ │ + oRequest.dispatchEvent({ │ │ │ │ + 'type': "readystatechange", │ │ │ │ + 'bubbles': false, │ │ │ │ + 'cancelable': false, │ │ │ │ + 'timeStamp': new Date + 0 │ │ │ │ + }); │ │ │ │ + }; │ │ │ │ │ │ │ │ - this.initSingleTile(bounds); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ + function fGetDocument(oRequest) { │ │ │ │ + var oDocument = oRequest.responseXML, │ │ │ │ + sResponse = oRequest.responseText; │ │ │ │ + // Try parsing responseText │ │ │ │ + if (bIE && sResponse && oDocument && !oDocument.documentElement && oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)) { │ │ │ │ + oDocument = new window.ActiveXObject("Microsoft.XMLDOM"); │ │ │ │ + oDocument.async = false; │ │ │ │ + oDocument.validateOnParse = false; │ │ │ │ + oDocument.loadXML(sResponse); │ │ │ │ + } │ │ │ │ + // Check if there is no error in document │ │ │ │ + if (oDocument) │ │ │ │ + if ((bIE && oDocument.parseError != 0) || !oDocument.documentElement || (oDocument.documentElement && oDocument.documentElement.tagName == "parsererror")) │ │ │ │ + return null; │ │ │ │ + return oDocument; │ │ │ │ + }; │ │ │ │ │ │ │ │ - // if the bounds have changed such that they are not even │ │ │ │ - // *partially* contained by our tiles (e.g. when user has │ │ │ │ - // programmatically panned to the other side of the earth on │ │ │ │ - // zoom level 18), then moveGriddedTiles could potentially have │ │ │ │ - // to run through thousands of cycles, so we want to reTile │ │ │ │ - // instead (thus, partial true). │ │ │ │ - forceReTile = forceReTile || │ │ │ │ - !tilesBounds.intersectsBounds(bounds, { │ │ │ │ - worldBounds: this.map.baseLayer.wrapDateLine && │ │ │ │ - this.map.getMaxExtent() │ │ │ │ - }); │ │ │ │ + function fSynchronizeValues(oRequest) { │ │ │ │ + try { │ │ │ │ + oRequest.responseText = oRequest._object.responseText; │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.responseXML = fGetDocument(oRequest._object); │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.status = oRequest._object.status; │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.statusText = oRequest._object.statusText; │ │ │ │ + } catch (e) {} │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (forceReTile) { │ │ │ │ - if (zoomChanged && (this.transitionEffect === 'resize' || │ │ │ │ - this.gridResolution === resolution)) { │ │ │ │ - this.applyBackBuffer(resolution); │ │ │ │ + function fCleanTransport(oRequest) { │ │ │ │ + // BUGFIX: IE - memory leak (on-page leak) │ │ │ │ + oRequest._object.onreadystatechange = new window.Function; │ │ │ │ + }; │ │ │ │ + /* │ │ │ │ + // Queue manager │ │ │ │ + var oQueuePending = {"CRITICAL":[],"HIGH":[],"NORMAL":[],"LOW":[],"LOWEST":[]}, │ │ │ │ + aQueueRunning = []; │ │ │ │ + function fQueue_add(oRequest) { │ │ │ │ + oQueuePending[oRequest.priority in oQueuePending ? oRequest.priority : "NORMAL"].push(oRequest); │ │ │ │ + // │ │ │ │ + setTimeout(fQueue_process); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fQueue_remove(oRequest) { │ │ │ │ + for (var nIndex = 0, bFound = false; nIndex < aQueueRunning.length; nIndex++) │ │ │ │ + if (bFound) │ │ │ │ + aQueueRunning[nIndex - 1] = aQueueRunning[nIndex]; │ │ │ │ + else │ │ │ │ + if (aQueueRunning[nIndex] == oRequest) │ │ │ │ + bFound = true; │ │ │ │ + if (bFound) │ │ │ │ + aQueueRunning.length--; │ │ │ │ + // │ │ │ │ + setTimeout(fQueue_process); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fQueue_process() { │ │ │ │ + if (aQueueRunning.length < 6) { │ │ │ │ + for (var sPriority in oQueuePending) { │ │ │ │ + if (oQueuePending[sPriority].length) { │ │ │ │ + var oRequest = oQueuePending[sPriority][0]; │ │ │ │ + oQueuePending[sPriority] = oQueuePending[sPriority].slice(1); │ │ │ │ + // │ │ │ │ + aQueueRunning.push(oRequest); │ │ │ │ + // Send request │ │ │ │ + fXMLHttpRequest_send(oRequest); │ │ │ │ + break; │ │ │ │ } │ │ │ │ - this.initGriddedTiles(bounds); │ │ │ │ - } else { │ │ │ │ - this.moveGriddedTiles(); │ │ │ │ } │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + }; │ │ │ │ + */ │ │ │ │ + // Internet Explorer 5.0 (missing apply) │ │ │ │ + if (!window.Function.prototype.apply) { │ │ │ │ + window.Function.prototype.apply = function(oRequest, oArguments) { │ │ │ │ + if (!oArguments) │ │ │ │ + oArguments = []; │ │ │ │ + oRequest.__func = this; │ │ │ │ + oRequest.__func(oArguments[0], oArguments[1], oArguments[2], oArguments[3], oArguments[4]); │ │ │ │ + delete oRequest.__func; │ │ │ │ + }; │ │ │ │ + }; │ │ │ │ │ │ │ │ + // Register new object with window │ │ │ │ /** │ │ │ │ - * Method: getTileData │ │ │ │ - * Given a map location, retrieve a tile and the pixel offset within that │ │ │ │ - * tile corresponding to the location. If there is not an existing │ │ │ │ - * tile in the grid that covers the given location, null will be │ │ │ │ - * returned. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * loc - {} map location │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Object with the following properties: tile ({}), │ │ │ │ - * i ({Number} x-pixel offset from top left), and j ({Integer} y-pixel │ │ │ │ - * offset from top left). │ │ │ │ + * Class: OpenLayers.Request.XMLHttpRequest │ │ │ │ + * Standard-compliant (W3C) cross-browser implementation of the │ │ │ │ + * XMLHttpRequest object. From │ │ │ │ + * http://code.google.com/p/xmlhttprequest/. │ │ │ │ */ │ │ │ │ - getTileData: function(loc) { │ │ │ │ - var data = null, │ │ │ │ - x = loc.lon, │ │ │ │ - y = loc.lat, │ │ │ │ - numRows = this.grid.length; │ │ │ │ + if (!OpenLayers.Request) { │ │ │ │ + /** │ │ │ │ + * This allows for OpenLayers/Request.js to be included │ │ │ │ + * before or after this script. │ │ │ │ + */ │ │ │ │ + OpenLayers.Request = {}; │ │ │ │ + } │ │ │ │ + OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest; │ │ │ │ +})(); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Request.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - if (this.map && numRows) { │ │ │ │ - var res = this.map.getResolution(), │ │ │ │ - tileWidth = this.tileSize.w, │ │ │ │ - tileHeight = this.tileSize.h, │ │ │ │ - bounds = this.grid[0][0].bounds, │ │ │ │ - left = bounds.left, │ │ │ │ - top = bounds.top; │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - if (x < left) { │ │ │ │ - // deal with multiple worlds │ │ │ │ - if (this.map.baseLayer.wrapDateLine) { │ │ │ │ - var worldWidth = this.map.getMaxExtent().getWidth(); │ │ │ │ - var worldsAway = Math.ceil((left - x) / worldWidth); │ │ │ │ - x += worldWidth * worldsAway; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // tile distance to location (fractional number of tiles); │ │ │ │ - var dtx = (x - left) / (res * tileWidth); │ │ │ │ - var dty = (top - y) / (res * tileHeight); │ │ │ │ - // index of tile in grid │ │ │ │ - var col = Math.floor(dtx); │ │ │ │ - var row = Math.floor(dty); │ │ │ │ - if (row >= 0 && row < numRows) { │ │ │ │ - var tile = this.grid[row][col]; │ │ │ │ - if (tile) { │ │ │ │ - data = { │ │ │ │ - tile: tile, │ │ │ │ - // pixel index within tile │ │ │ │ - i: Math.floor((dtx - col) * tileWidth), │ │ │ │ - j: Math.floor((dty - row) * tileHeight) │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return data; │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * TODO: deprecate me │ │ │ │ + * Use OpenLayers.Request.proxy instead. │ │ │ │ + */ │ │ │ │ +OpenLayers.ProxyHost = ""; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Request │ │ │ │ + * The OpenLayers.Request namespace contains convenience methods for working │ │ │ │ + * with XMLHttpRequests. These methods work with a cross-browser │ │ │ │ + * W3C compliant class. │ │ │ │ + */ │ │ │ │ +if (!OpenLayers.Request) { │ │ │ │ + /** │ │ │ │ + * This allows for OpenLayers/Request/XMLHttpRequest.js to be included │ │ │ │ + * before or after this script. │ │ │ │ + */ │ │ │ │ + OpenLayers.Request = {}; │ │ │ │ +} │ │ │ │ +OpenLayers.Util.extend(OpenLayers.Request, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constant: DEFAULT_CONFIG │ │ │ │ + * {Object} Default configuration for all requests. │ │ │ │ + */ │ │ │ │ + DEFAULT_CONFIG: { │ │ │ │ + method: "GET", │ │ │ │ + url: window.location.href, │ │ │ │ + async: true, │ │ │ │ + user: undefined, │ │ │ │ + password: undefined, │ │ │ │ + params: null, │ │ │ │ + proxy: OpenLayers.ProxyHost, │ │ │ │ + headers: {}, │ │ │ │ + data: null, │ │ │ │ + callback: function() {}, │ │ │ │ + success: null, │ │ │ │ + failure: null, │ │ │ │ + scope: null │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroyTile │ │ │ │ + * Constant: URL_SPLIT_REGEX │ │ │ │ + */ │ │ │ │ + URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {} An events object that handles all │ │ │ │ + * events on the {} object. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * tile - {} │ │ │ │ + * All event listeners will receive an event object with three properties: │ │ │ │ + * request - {} The request object. │ │ │ │ + * config - {Object} The config object sent to the specific request method. │ │ │ │ + * requestUrl - {String} The request url. │ │ │ │ + * │ │ │ │ + * Supported event types: │ │ │ │ + * complete - Triggered when we have a response from the request, if a │ │ │ │ + * listener returns false, no further response processing will take │ │ │ │ + * place. │ │ │ │ + * success - Triggered when the HTTP response has a success code (200-299). │ │ │ │ + * failure - Triggered when the HTTP response does not have a success code. │ │ │ │ */ │ │ │ │ - destroyTile: function(tile) { │ │ │ │ - this.removeTileMonitoringHooks(tile); │ │ │ │ - tile.destroy(); │ │ │ │ - }, │ │ │ │ + events: new OpenLayers.Events(this), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getServerResolution │ │ │ │ - * Return the closest server-supported resolution. │ │ │ │ + * Method: makeSameOrigin │ │ │ │ + * Using the specified proxy, returns a same origin url of the provided url. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resolution - {Number} The base resolution. If undefined the │ │ │ │ - * map resolution is used. │ │ │ │ + * url - {String} An arbitrary url │ │ │ │ + * proxy {String|Function} The proxy to use to make the provided url a │ │ │ │ + * same origin url. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Number} The closest server resolution value. │ │ │ │ + * Returns │ │ │ │ + * {String} the same origin url. If no proxy is provided, the returned url │ │ │ │ + * will be the same as the provided url. │ │ │ │ */ │ │ │ │ - getServerResolution: function(resolution) { │ │ │ │ - var distance = Number.POSITIVE_INFINITY; │ │ │ │ - resolution = resolution || this.map.getResolution(); │ │ │ │ - if (this.serverResolutions && │ │ │ │ - OpenLayers.Util.indexOf(this.serverResolutions, resolution) === -1) { │ │ │ │ - var i, newDistance, newResolution, serverResolution; │ │ │ │ - for (i = this.serverResolutions.length - 1; i >= 0; i--) { │ │ │ │ - newResolution = this.serverResolutions[i]; │ │ │ │ - newDistance = Math.abs(newResolution - resolution); │ │ │ │ - if (newDistance > distance) { │ │ │ │ - break; │ │ │ │ + makeSameOrigin: function(url, proxy) { │ │ │ │ + var sameOrigin = url.indexOf("http") !== 0; │ │ │ │ + var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX); │ │ │ │ + if (urlParts) { │ │ │ │ + var location = window.location; │ │ │ │ + sameOrigin = │ │ │ │ + urlParts[1] == location.protocol && │ │ │ │ + urlParts[3] == location.hostname; │ │ │ │ + var uPort = urlParts[4], │ │ │ │ + lPort = location.port; │ │ │ │ + if (uPort != 80 && uPort != "" || lPort != "80" && lPort != "") { │ │ │ │ + sameOrigin = sameOrigin && uPort == lPort; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!sameOrigin) { │ │ │ │ + if (proxy) { │ │ │ │ + if (typeof proxy == "function") { │ │ │ │ + url = proxy(url); │ │ │ │ + } else { │ │ │ │ + url = proxy + encodeURIComponent(url); │ │ │ │ } │ │ │ │ - distance = newDistance; │ │ │ │ - serverResolution = newResolution; │ │ │ │ } │ │ │ │ - resolution = serverResolution; │ │ │ │ } │ │ │ │ - return resolution; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getServerZoom │ │ │ │ - * Return the zoom value corresponding to the best matching server │ │ │ │ - * resolution, taking into account and . │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} The closest server supported zoom. This is not the map zoom │ │ │ │ - * level, but an index of the server's resolutions array. │ │ │ │ - */ │ │ │ │ - getServerZoom: function() { │ │ │ │ - var resolution = this.getServerResolution(); │ │ │ │ - return this.serverResolutions ? │ │ │ │ - OpenLayers.Util.indexOf(this.serverResolutions, resolution) : │ │ │ │ - this.map.getZoomForResolution(resolution) + (this.zoomOffset || 0); │ │ │ │ + return url; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: applyBackBuffer │ │ │ │ - * Create, insert, scale and position a back buffer for the layer. │ │ │ │ + * APIMethod: issue │ │ │ │ + * Create a new XMLHttpRequest object, open it, set any headers, bind │ │ │ │ + * a callback to done state, and send any data. It is recommended that │ │ │ │ + * you use one , , , , , or . │ │ │ │ + * This method is only documented to provide detail on the configuration │ │ │ │ + * options available to all request methods. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resolution - {Number} The resolution to transition to. │ │ │ │ + * config - {Object} Object containing properties for configuring the │ │ │ │ + * request. Allowed configuration properties are described below. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Allowed config properties: │ │ │ │ + * method - {String} One of GET, POST, PUT, DELETE, HEAD, or │ │ │ │ + * OPTIONS. Default is GET. │ │ │ │ + * url - {String} URL for the request. │ │ │ │ + * async - {Boolean} Open an asynchronous request. Default is true. │ │ │ │ + * user - {String} User for relevant authentication scheme. Set │ │ │ │ + * to null to clear current user. │ │ │ │ + * password - {String} Password for relevant authentication scheme. │ │ │ │ + * Set to null to clear current password. │ │ │ │ + * proxy - {String} Optional proxy. Defaults to │ │ │ │ + * . │ │ │ │ + * params - {Object} Any key:value pairs to be appended to the │ │ │ │ + * url as a query string. Assumes url doesn't already include a query │ │ │ │ + * string or hash. Typically, this is only appropriate for │ │ │ │ + * requests where the query string will be appended to the url. │ │ │ │ + * Parameter values that are arrays will be │ │ │ │ + * concatenated with a comma (note that this goes against form-encoding) │ │ │ │ + * as is done with . │ │ │ │ + * headers - {Object} Object with header:value pairs to be set on │ │ │ │ + * the request. │ │ │ │ + * data - {String | Document} Optional data to send with the request. │ │ │ │ + * Typically, this is only used with and requests. │ │ │ │ + * Make sure to provide the appropriate "Content-Type" header for your │ │ │ │ + * data. For and requests, the content type defaults to │ │ │ │ + * "application-xml". If your data is a different content type, or │ │ │ │ + * if you are using a different HTTP method, set the "Content-Type" │ │ │ │ + * header to match your data type. │ │ │ │ + * callback - {Function} Function to call when request is done. │ │ │ │ + * To determine if the request failed, check request.status (200 │ │ │ │ + * indicates success). │ │ │ │ + * success - {Function} Optional function to call if request status is in │ │ │ │ + * the 200s. This will be called in addition to callback above and │ │ │ │ + * would typically only be used as an alternative. │ │ │ │ + * failure - {Function} Optional function to call if request status is not │ │ │ │ + * in the 200s. This will be called in addition to callback above and │ │ │ │ + * would typically only be used as an alternative. │ │ │ │ + * scope - {Object} If callback is a public method on some object, │ │ │ │ + * set the scope to that object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. To abort the request before a response │ │ │ │ + * is received, call abort() on the request object. │ │ │ │ */ │ │ │ │ - applyBackBuffer: function(resolution) { │ │ │ │ - if (this.backBufferTimerId !== null) { │ │ │ │ - this.removeBackBuffer(); │ │ │ │ - } │ │ │ │ - var backBuffer = this.backBuffer; │ │ │ │ - if (!backBuffer) { │ │ │ │ - backBuffer = this.createBackBuffer(); │ │ │ │ - if (!backBuffer) { │ │ │ │ - return; │ │ │ │ + issue: function(config) { │ │ │ │ + // apply default config - proxy host may have changed │ │ │ │ + var defaultConfig = OpenLayers.Util.extend( │ │ │ │ + this.DEFAULT_CONFIG, { │ │ │ │ + proxy: OpenLayers.ProxyHost │ │ │ │ } │ │ │ │ - if (resolution === this.gridResolution) { │ │ │ │ - this.div.insertBefore(backBuffer, this.div.firstChild); │ │ │ │ - } else { │ │ │ │ - this.map.baseLayer.div.parentNode.insertBefore(backBuffer, this.map.baseLayer.div); │ │ │ │ + ); │ │ │ │ + config = config || {}; │ │ │ │ + config.headers = config.headers || {}; │ │ │ │ + config = OpenLayers.Util.applyDefaults(config, defaultConfig); │ │ │ │ + config.headers = OpenLayers.Util.applyDefaults(config.headers, defaultConfig.headers); │ │ │ │ + // Always set the "X-Requested-With" header to signal that this request │ │ │ │ + // was issued through the XHR-object. Since header keys are case │ │ │ │ + // insensitive and we want to allow overriding of the "X-Requested-With" │ │ │ │ + // header through the user we cannot use applyDefaults, but have to │ │ │ │ + // check manually whether we were called with a "X-Requested-With" │ │ │ │ + // header. │ │ │ │ + var customRequestedWithHeader = false, │ │ │ │ + headerKey; │ │ │ │ + for (headerKey in config.headers) { │ │ │ │ + if (config.headers.hasOwnProperty(headerKey)) { │ │ │ │ + if (headerKey.toLowerCase() === 'x-requested-with') { │ │ │ │ + customRequestedWithHeader = true; │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.backBuffer = backBuffer; │ │ │ │ - │ │ │ │ - // set some information in the instance for subsequent │ │ │ │ - // calls to applyBackBuffer where the same back buffer │ │ │ │ - // is reused │ │ │ │ - var topLeftTileBounds = this.grid[0][0].bounds; │ │ │ │ - this.backBufferLonLat = { │ │ │ │ - lon: topLeftTileBounds.left, │ │ │ │ - lat: topLeftTileBounds.top │ │ │ │ - }; │ │ │ │ - this.backBufferResolution = this.gridResolution; │ │ │ │ + } │ │ │ │ + if (customRequestedWithHeader === false) { │ │ │ │ + // we did not have a custom "X-Requested-With" header │ │ │ │ + config.headers['X-Requested-With'] = 'XMLHttpRequest'; │ │ │ │ } │ │ │ │ │ │ │ │ - var ratio = this.backBufferResolution / resolution; │ │ │ │ - │ │ │ │ - // scale the tiles inside the back buffer │ │ │ │ - var tiles = backBuffer.childNodes, │ │ │ │ - tile; │ │ │ │ - for (var i = tiles.length - 1; i >= 0; --i) { │ │ │ │ - tile = tiles[i]; │ │ │ │ - tile.style.top = ((ratio * tile._i * tile._h) | 0) + 'px'; │ │ │ │ - tile.style.left = ((ratio * tile._j * tile._w) | 0) + 'px'; │ │ │ │ - tile.style.width = Math.round(ratio * tile._w) + 'px'; │ │ │ │ - tile.style.height = Math.round(ratio * tile._h) + 'px'; │ │ │ │ + // create request, open, and set headers │ │ │ │ + var request = new OpenLayers.Request.XMLHttpRequest(); │ │ │ │ + var url = OpenLayers.Util.urlAppend(config.url, │ │ │ │ + OpenLayers.Util.getParameterString(config.params || {})); │ │ │ │ + url = OpenLayers.Request.makeSameOrigin(url, config.proxy); │ │ │ │ + request.open( │ │ │ │ + config.method, url, config.async, config.user, config.password │ │ │ │ + ); │ │ │ │ + for (var header in config.headers) { │ │ │ │ + request.setRequestHeader(header, config.headers[header]); │ │ │ │ } │ │ │ │ │ │ │ │ - // and position it (based on the grid's top-left corner) │ │ │ │ - var position = this.getViewPortPxFromLonLat( │ │ │ │ - this.backBufferLonLat, resolution); │ │ │ │ - var leftOffset = this.map.layerContainerOriginPx.x; │ │ │ │ - var topOffset = this.map.layerContainerOriginPx.y; │ │ │ │ - backBuffer.style.left = Math.round(position.x - leftOffset) + 'px'; │ │ │ │ - backBuffer.style.top = Math.round(position.y - topOffset) + 'px'; │ │ │ │ - }, │ │ │ │ + var events = this.events; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createBackBuffer │ │ │ │ - * Create a back buffer. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The DOM element for the back buffer, undefined if the │ │ │ │ - * grid isn't initialized yet. │ │ │ │ - */ │ │ │ │ - createBackBuffer: function() { │ │ │ │ - var backBuffer; │ │ │ │ - if (this.grid.length > 0) { │ │ │ │ - backBuffer = document.createElement('div'); │ │ │ │ - backBuffer.id = this.div.id + '_bb'; │ │ │ │ - backBuffer.className = 'olBackBuffer'; │ │ │ │ - backBuffer.style.position = 'absolute'; │ │ │ │ - var map = this.map; │ │ │ │ - backBuffer.style.zIndex = this.transitionEffect === 'resize' ? │ │ │ │ - this.getZIndex() - 1 : │ │ │ │ - // 'map-resize': │ │ │ │ - map.Z_INDEX_BASE.BaseLayer - │ │ │ │ - (map.getNumLayers() - map.getLayerIndex(this)); │ │ │ │ - for (var i = 0, lenI = this.grid.length; i < lenI; i++) { │ │ │ │ - for (var j = 0, lenJ = this.grid[i].length; j < lenJ; j++) { │ │ │ │ - var tile = this.grid[i][j], │ │ │ │ - markup = this.grid[i][j].createBackBuffer(); │ │ │ │ - if (markup) { │ │ │ │ - markup._i = i; │ │ │ │ - markup._j = j; │ │ │ │ - markup._w = tile.size.w; │ │ │ │ - markup._h = tile.size.h; │ │ │ │ - markup.id = tile.id + '_bb'; │ │ │ │ - backBuffer.appendChild(markup); │ │ │ │ + // we want to execute runCallbacks with "this" as the │ │ │ │ + // execution scope │ │ │ │ + var self = this; │ │ │ │ + │ │ │ │ + request.onreadystatechange = function() { │ │ │ │ + if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) { │ │ │ │ + var proceed = events.triggerEvent( │ │ │ │ + "complete", { │ │ │ │ + request: request, │ │ │ │ + config: config, │ │ │ │ + requestUrl: url │ │ │ │ } │ │ │ │ + ); │ │ │ │ + if (proceed !== false) { │ │ │ │ + self.runCallbacks({ │ │ │ │ + request: request, │ │ │ │ + config: config, │ │ │ │ + requestUrl: url │ │ │ │ + }); │ │ │ │ } │ │ │ │ } │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // send request (optionally with data) and return │ │ │ │ + // call in a timeout for asynchronous requests so the return is │ │ │ │ + // available before readyState == 4 for cached docs │ │ │ │ + if (config.async === false) { │ │ │ │ + request.send(config.data); │ │ │ │ + } else { │ │ │ │ + window.setTimeout(function() { │ │ │ │ + if (request.readyState !== 0) { // W3C: 0-UNSENT │ │ │ │ + request.send(config.data); │ │ │ │ + } │ │ │ │ + }, 0); │ │ │ │ } │ │ │ │ - return backBuffer; │ │ │ │ + return request; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeBackBuffer │ │ │ │ - * Remove back buffer from DOM. │ │ │ │ + * Method: runCallbacks │ │ │ │ + * Calls the complete, success and failure callbacks. Application │ │ │ │ + * can listen to the "complete" event, have the listener │ │ │ │ + * display a confirm window and always return false, and │ │ │ │ + * execute OpenLayers.Request.runCallbacks if the user │ │ │ │ + * hits "yes" in the confirm window. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Hash containing request, config and requestUrl keys │ │ │ │ */ │ │ │ │ - removeBackBuffer: function() { │ │ │ │ - if (this._transitionElement) { │ │ │ │ - for (var i = this.transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ - OpenLayers.Event.stopObserving(this._transitionElement, │ │ │ │ - this.transitionendEvents[i], this._removeBackBuffer); │ │ │ │ - } │ │ │ │ - delete this._transitionElement; │ │ │ │ + runCallbacks: function(options) { │ │ │ │ + var request = options.request; │ │ │ │ + var config = options.config; │ │ │ │ + │ │ │ │ + // bind callbacks to readyState 4 (done) │ │ │ │ + var complete = (config.scope) ? │ │ │ │ + OpenLayers.Function.bind(config.callback, config.scope) : │ │ │ │ + config.callback; │ │ │ │ + │ │ │ │ + // optional success callback │ │ │ │ + var success; │ │ │ │ + if (config.success) { │ │ │ │ + success = (config.scope) ? │ │ │ │ + OpenLayers.Function.bind(config.success, config.scope) : │ │ │ │ + config.success; │ │ │ │ } │ │ │ │ - if (this.backBuffer) { │ │ │ │ - if (this.backBuffer.parentNode) { │ │ │ │ - this.backBuffer.parentNode.removeChild(this.backBuffer); │ │ │ │ + │ │ │ │ + // optional failure callback │ │ │ │ + var failure; │ │ │ │ + if (config.failure) { │ │ │ │ + failure = (config.scope) ? │ │ │ │ + OpenLayers.Function.bind(config.failure, config.scope) : │ │ │ │ + config.failure; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (OpenLayers.Util.createUrlObject(config.url).protocol == "file:" && │ │ │ │ + request.responseText) { │ │ │ │ + request.status = 200; │ │ │ │ + } │ │ │ │ + complete(request); │ │ │ │ + │ │ │ │ + if (!request.status || (request.status >= 200 && request.status < 300)) { │ │ │ │ + this.events.triggerEvent("success", options); │ │ │ │ + if (success) { │ │ │ │ + success(request); │ │ │ │ } │ │ │ │ - this.backBuffer = null; │ │ │ │ - this.backBufferResolution = null; │ │ │ │ - if (this.backBufferTimerId !== null) { │ │ │ │ - window.clearTimeout(this.backBufferTimerId); │ │ │ │ - this.backBufferTimerId = null; │ │ │ │ + } │ │ │ │ + if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ + this.events.triggerEvent("failure", options); │ │ │ │ + if (failure) { │ │ │ │ + failure(request); │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveByPx │ │ │ │ - * Move the layer based on pixel vector. │ │ │ │ + * APIMethod: GET │ │ │ │ + * Send an HTTP GET request. Additional configuration properties are │ │ │ │ + * documented in the method, with the method property set │ │ │ │ + * to GET. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * dx - {Number} │ │ │ │ - * dy - {Number} │ │ │ │ - */ │ │ │ │ - moveByPx: function(dx, dy) { │ │ │ │ - if (!this.singleTile) { │ │ │ │ - this.moveGriddedTiles(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setTileSize │ │ │ │ - * Check if we are in singleTile mode and if so, set the size as a ratio │ │ │ │ - * of the map size (as specified by the layer's 'ratio' property). │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * size - {} │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - setTileSize: function(size) { │ │ │ │ - if (this.singleTile) { │ │ │ │ - size = this.map.getSize(); │ │ │ │ - size.h = parseInt(size.h * this.ratio, 10); │ │ │ │ - size.w = parseInt(size.w * this.ratio, 10); │ │ │ │ - } │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]); │ │ │ │ + GET: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "GET" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getTilesBounds │ │ │ │ - * Return the bounds of the tile grid. │ │ │ │ + * APIMethod: POST │ │ │ │ + * Send a POST request. Additional configuration properties are │ │ │ │ + * documented in the method, with the method property set │ │ │ │ + * to POST and "Content-Type" header set to "application/xml". │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the method for documentation of allowed properties. The │ │ │ │ + * default "Content-Type" header will be set to "application-xml" if │ │ │ │ + * none is provided. This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {} A Bounds object representing the bounds of all the │ │ │ │ - * currently loaded tiles (including those partially or not at all seen │ │ │ │ - * onscreen). │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - getTilesBounds: function() { │ │ │ │ - var bounds = null; │ │ │ │ - │ │ │ │ - var length = this.grid.length; │ │ │ │ - if (length) { │ │ │ │ - var bottomLeftTileBounds = this.grid[length - 1][0].bounds, │ │ │ │ - width = this.grid[0].length * bottomLeftTileBounds.getWidth(), │ │ │ │ - height = this.grid.length * bottomLeftTileBounds.getHeight(); │ │ │ │ - │ │ │ │ - bounds = new OpenLayers.Bounds(bottomLeftTileBounds.left, │ │ │ │ - bottomLeftTileBounds.bottom, │ │ │ │ - bottomLeftTileBounds.left + width, │ │ │ │ - bottomLeftTileBounds.bottom + height); │ │ │ │ + POST: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "POST" │ │ │ │ + }); │ │ │ │ + // set content type to application/xml if it isn't already set │ │ │ │ + config.headers = config.headers ? config.headers : {}; │ │ │ │ + if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ + config.headers["Content-Type"] = "application/xml"; │ │ │ │ } │ │ │ │ - return bounds; │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: initSingleTile │ │ │ │ + * APIMethod: PUT │ │ │ │ + * Send an HTTP PUT request. Additional configuration properties are │ │ │ │ + * documented in the method, with the method property set │ │ │ │ + * to PUT and "Content-Type" header set to "application/xml". │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the method for documentation of allowed properties. The │ │ │ │ + * default "Content-Type" header will be set to "application-xml" if │ │ │ │ + * none is provided. This object is modified and should not be reused. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {} │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - initSingleTile: function(bounds) { │ │ │ │ - this.events.triggerEvent("retile"); │ │ │ │ - │ │ │ │ - //determine new tile bounds │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var tileWidth = bounds.getWidth() * this.ratio; │ │ │ │ - var tileHeight = bounds.getHeight() * this.ratio; │ │ │ │ - │ │ │ │ - var tileBounds = │ │ │ │ - new OpenLayers.Bounds(center.lon - (tileWidth / 2), │ │ │ │ - center.lat - (tileHeight / 2), │ │ │ │ - center.lon + (tileWidth / 2), │ │ │ │ - center.lat + (tileHeight / 2)); │ │ │ │ - │ │ │ │ - var px = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: tileBounds.left, │ │ │ │ - lat: tileBounds.top │ │ │ │ + PUT: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "PUT" │ │ │ │ }); │ │ │ │ - │ │ │ │ - if (!this.grid.length) { │ │ │ │ - this.grid[0] = []; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var tile = this.grid[0][0]; │ │ │ │ - if (!tile) { │ │ │ │ - tile = this.addTile(tileBounds, px); │ │ │ │ - │ │ │ │ - this.addTileMonitoringHooks(tile); │ │ │ │ - tile.draw(); │ │ │ │ - this.grid[0][0] = tile; │ │ │ │ - } else { │ │ │ │ - tile.moveTo(tileBounds, px); │ │ │ │ + // set content type to application/xml if it isn't already set │ │ │ │ + config.headers = config.headers ? config.headers : {}; │ │ │ │ + if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ + config.headers["Content-Type"] = "application/xml"; │ │ │ │ } │ │ │ │ - │ │ │ │ - //remove all but our single tile │ │ │ │ - this.removeExcessTiles(1, 1); │ │ │ │ - │ │ │ │ - // store the resolution of the grid │ │ │ │ - this.gridResolution = this.getServerResolution(); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: calculateGridLayout │ │ │ │ - * Generate parameters for the grid layout. │ │ │ │ + /** │ │ │ │ + * APIMethod: DELETE │ │ │ │ + * Send an HTTP DELETE request. Additional configuration properties are │ │ │ │ + * documented in the method, with the method property set │ │ │ │ + * to DELETE. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {|Object} OpenLayers.Bounds or an │ │ │ │ - * object with a 'left' and 'top' properties. │ │ │ │ - * origin - {|Object} OpenLayers.LonLat or an │ │ │ │ - * object with a 'lon' and 'lat' properties. │ │ │ │ - * resolution - {Number} │ │ │ │ - * │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Object} Object containing properties tilelon, tilelat, startcol, │ │ │ │ - * startrow │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ - var tilelon = resolution * this.tileSize.w; │ │ │ │ - var tilelat = resolution * this.tileSize.h; │ │ │ │ - │ │ │ │ - var offsetlon = bounds.left - origin.lon; │ │ │ │ - var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ - │ │ │ │ - var rowSign = this.rowSign; │ │ │ │ - │ │ │ │ - var offsetlat = rowSign * (origin.lat - bounds.top + tilelat); │ │ │ │ - var tilerow = Math[~rowSign ? 'floor' : 'ceil'](offsetlat / tilelat) - this.buffer * rowSign; │ │ │ │ - │ │ │ │ - return { │ │ │ │ - tilelon: tilelon, │ │ │ │ - tilelat: tilelat, │ │ │ │ - startcol: tilecol, │ │ │ │ - startrow: tilerow │ │ │ │ - }; │ │ │ │ - │ │ │ │ + DELETE: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "DELETE" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getTileOrigin │ │ │ │ - * Determine the origin for aligning the grid of tiles. If a │ │ │ │ - * property is supplied, that will be returned. Otherwise, the origin │ │ │ │ - * will be derived from the layer's property. In this case, │ │ │ │ - * the tile origin will be the corner of the given by the │ │ │ │ - * property. │ │ │ │ + * APIMethod: HEAD │ │ │ │ + * Send an HTTP HEAD request. Additional configuration properties are │ │ │ │ + * documented in the method, with the method property set │ │ │ │ + * to HEAD. │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {} The tile origin. │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - getTileOrigin: function() { │ │ │ │ - var origin = this.tileOrigin; │ │ │ │ - if (!origin) { │ │ │ │ - var extent = this.getMaxExtent(); │ │ │ │ - var edges = ({ │ │ │ │ - "tl": ["left", "top"], │ │ │ │ - "tr": ["right", "top"], │ │ │ │ - "bl": ["left", "bottom"], │ │ │ │ - "br": ["right", "bottom"] │ │ │ │ - })[this.tileOriginCorner]; │ │ │ │ - origin = new OpenLayers.LonLat(extent[edges[0]], extent[edges[1]]); │ │ │ │ - } │ │ │ │ - return origin; │ │ │ │ + HEAD: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "HEAD" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getTileBoundsForGridIndex │ │ │ │ + * APIMethod: OPTIONS │ │ │ │ + * Send an HTTP OPTIONS request. Additional configuration properties are │ │ │ │ + * documented in the method, with the method property set │ │ │ │ + * to OPTIONS. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * row - {Number} The row of the grid │ │ │ │ - * col - {Number} The column of the grid │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} The bounds for the tile at (row, col) │ │ │ │ - */ │ │ │ │ - getTileBoundsForGridIndex: function(row, col) { │ │ │ │ - var origin = this.getTileOrigin(); │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - var tilelon = tileLayout.tilelon; │ │ │ │ - var tilelat = tileLayout.tilelat; │ │ │ │ - var startcol = tileLayout.startcol; │ │ │ │ - var startrow = tileLayout.startrow; │ │ │ │ - var rowSign = this.rowSign; │ │ │ │ - return new OpenLayers.Bounds( │ │ │ │ - origin.lon + (startcol + col) * tilelon, │ │ │ │ - origin.lat - (startrow + row * rowSign) * tilelat * rowSign, │ │ │ │ - origin.lon + (startcol + col + 1) * tilelon, │ │ │ │ - origin.lat - (startrow + (row - 1) * rowSign) * tilelat * rowSign │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: initGriddedTiles │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {} │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - initGriddedTiles: function(bounds) { │ │ │ │ - this.events.triggerEvent("retile"); │ │ │ │ + OPTIONS: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "OPTIONS" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ + } │ │ │ │ │ │ │ │ - // work out mininum number of rows and columns; this is the number of │ │ │ │ - // tiles required to cover the viewport plus at least one for panning │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Feature/Vector.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - var viewSize = this.map.getSize(); │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - var origin = this.getTileOrigin(); │ │ │ │ - var resolution = this.map.getResolution(), │ │ │ │ - serverResolution = this.getServerResolution(), │ │ │ │ - ratio = resolution / serverResolution, │ │ │ │ - tileSize = { │ │ │ │ - w: this.tileSize.w / ratio, │ │ │ │ - h: this.tileSize.h / ratio │ │ │ │ - }; │ │ │ │ +// TRASH THIS │ │ │ │ +OpenLayers.State = { │ │ │ │ + /** states */ │ │ │ │ + UNKNOWN: 'Unknown', │ │ │ │ + INSERT: 'Insert', │ │ │ │ + UPDATE: 'Update', │ │ │ │ + DELETE: 'Delete' │ │ │ │ +}; │ │ │ │ │ │ │ │ - var minRows = Math.ceil(viewSize.h / tileSize.h) + │ │ │ │ - 2 * this.buffer + 1; │ │ │ │ - var minCols = Math.ceil(viewSize.w / tileSize.w) + │ │ │ │ - 2 * this.buffer + 1; │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Feature.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - var tileLayout = this.calculateGridLayout(bounds, origin, serverResolution); │ │ │ │ - this.gridLayout = tileLayout; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Feature.Vector │ │ │ │ + * Vector features use the OpenLayers.Geometry classes as geometry description. │ │ │ │ + * They have an 'attributes' property, which is the data object, and a 'style' │ │ │ │ + * property, the default values of which are defined in the │ │ │ │ + * objects. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - │ │ │ │ + */ │ │ │ │ +OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ │ │ │ │ - var tilelon = tileLayout.tilelon; │ │ │ │ - var tilelat = tileLayout.tilelat; │ │ │ │ + /** │ │ │ │ + * Property: fid │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + fid: null, │ │ │ │ │ │ │ │ - var layerContainerDivLeft = this.map.layerContainerOriginPx.x; │ │ │ │ - var layerContainerDivTop = this.map.layerContainerOriginPx.y; │ │ │ │ + /** │ │ │ │ + * APIProperty: geometry │ │ │ │ + * {} │ │ │ │ + */ │ │ │ │ + geometry: null, │ │ │ │ │ │ │ │ - var tileBounds = this.getTileBoundsForGridIndex(0, 0); │ │ │ │ - var startPx = this.map.getViewPortPxFromLonLat( │ │ │ │ - new OpenLayers.LonLat(tileBounds.left, tileBounds.top) │ │ │ │ - ); │ │ │ │ - startPx.x = Math.round(startPx.x) - layerContainerDivLeft; │ │ │ │ - startPx.y = Math.round(startPx.y) - layerContainerDivTop; │ │ │ │ + /** │ │ │ │ + * APIProperty: attributes │ │ │ │ + * {Object} This object holds arbitrary, serializable properties that │ │ │ │ + * describe the feature. │ │ │ │ + */ │ │ │ │ + attributes: null, │ │ │ │ │ │ │ │ - var tileData = [], │ │ │ │ - center = this.map.getCenter(); │ │ │ │ + /** │ │ │ │ + * Property: bounds │ │ │ │ + * {} The box bounding that feature's geometry, that │ │ │ │ + * property can be set by an object when │ │ │ │ + * deserializing the feature, so in most cases it represents an │ │ │ │ + * information set by the server. │ │ │ │ + */ │ │ │ │ + bounds: null, │ │ │ │ │ │ │ │ - var rowidx = 0; │ │ │ │ - do { │ │ │ │ - var row = this.grid[rowidx]; │ │ │ │ - if (!row) { │ │ │ │ - row = []; │ │ │ │ - this.grid.push(row); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: state │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + state: null, │ │ │ │ │ │ │ │ - var colidx = 0; │ │ │ │ - do { │ │ │ │ - tileBounds = this.getTileBoundsForGridIndex(rowidx, colidx); │ │ │ │ - var px = startPx.clone(); │ │ │ │ - px.x = px.x + colidx * Math.round(tileSize.w); │ │ │ │ - px.y = px.y + rowidx * Math.round(tileSize.h); │ │ │ │ - var tile = row[colidx]; │ │ │ │ - if (!tile) { │ │ │ │ - tile = this.addTile(tileBounds, px); │ │ │ │ - this.addTileMonitoringHooks(tile); │ │ │ │ - row.push(tile); │ │ │ │ - } else { │ │ │ │ - tile.moveTo(tileBounds, px, false); │ │ │ │ - } │ │ │ │ - var tileCenter = tileBounds.getCenterLonLat(); │ │ │ │ - tileData.push({ │ │ │ │ - tile: tile, │ │ │ │ - distance: Math.pow(tileCenter.lon - center.lon, 2) + │ │ │ │ - Math.pow(tileCenter.lat - center.lat, 2) │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * APIProperty: style │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ + style: null, │ │ │ │ │ │ │ │ - colidx += 1; │ │ │ │ - } while ((tileBounds.right <= bounds.right + tilelon * this.buffer) || │ │ │ │ - colidx < minCols); │ │ │ │ + /** │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} If this property is set it will be taken into account by │ │ │ │ + * {} when upadting or deleting the feature. │ │ │ │ + */ │ │ │ │ + url: null, │ │ │ │ │ │ │ │ - rowidx += 1; │ │ │ │ - } while ((tileBounds.bottom >= bounds.bottom - tilelat * this.buffer) || │ │ │ │ - rowidx < minRows); │ │ │ │ + /** │ │ │ │ + * Property: renderIntent │ │ │ │ + * {String} rendering intent currently being used │ │ │ │ + */ │ │ │ │ + renderIntent: "default", │ │ │ │ │ │ │ │ - //shave off exceess rows and colums │ │ │ │ - this.removeExcessTiles(rowidx, colidx); │ │ │ │ + /** │ │ │ │ + * APIProperty: modified │ │ │ │ + * {Object} An object with the originals of the geometry and attributes of │ │ │ │ + * the feature, if they were changed. Currently this property is only read │ │ │ │ + * by , and written by │ │ │ │ + * , which sets the geometry property. │ │ │ │ + * Applications can set the originals of modified attributes in the │ │ │ │ + * attributes property. Note that applications have to check if this │ │ │ │ + * object and the attributes property is already created before using it. │ │ │ │ + * After a change made with ModifyFeature, this object could look like │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * { │ │ │ │ + * geometry: >Object │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * When an application has made changes to feature attributes, it could │ │ │ │ + * have set the attributes to something like this: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * { │ │ │ │ + * attributes: { │ │ │ │ + * myAttribute: "original" │ │ │ │ + * } │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Note that only checks for truthy values in │ │ │ │ + * *modified.geometry* and the attribute names in *modified.attributes*, │ │ │ │ + * but it is recommended to set the original values (and not just true) as │ │ │ │ + * attribute value, so applications could use this information to undo │ │ │ │ + * changes. │ │ │ │ + */ │ │ │ │ + modified: null, │ │ │ │ │ │ │ │ - var resolution = this.getServerResolution(); │ │ │ │ - // store the resolution of the grid │ │ │ │ - this.gridResolution = resolution; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Feature.Vector │ │ │ │ + * Create a vector feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {} The geometry that this feature │ │ │ │ + * represents. │ │ │ │ + * attributes - {Object} An optional object that will be mapped to the │ │ │ │ + * property. │ │ │ │ + * style - {Object} An optional style object. │ │ │ │ + */ │ │ │ │ + initialize: function(geometry, attributes, style) { │ │ │ │ + OpenLayers.Feature.prototype.initialize.apply(this, │ │ │ │ + [null, null, attributes]); │ │ │ │ + this.lonlat = null; │ │ │ │ + this.geometry = geometry ? geometry : null; │ │ │ │ + this.state = null; │ │ │ │ + this.attributes = {}; │ │ │ │ + if (attributes) { │ │ │ │ + this.attributes = OpenLayers.Util.extend(this.attributes, │ │ │ │ + attributes); │ │ │ │ + } │ │ │ │ + this.style = style ? style : null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - //now actually draw the tiles │ │ │ │ - tileData.sort(function(a, b) { │ │ │ │ - return a.distance - b.distance; │ │ │ │ - }); │ │ │ │ - for (var i = 0, ii = tileData.length; i < ii; ++i) { │ │ │ │ - tileData[i].tile.draw(); │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layer) { │ │ │ │ + this.layer.removeFeatures(this); │ │ │ │ + this.layer = null; │ │ │ │ } │ │ │ │ + │ │ │ │ + this.geometry = null; │ │ │ │ + this.modified = null; │ │ │ │ + OpenLayers.Feature.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getMaxExtent │ │ │ │ - * Get this layer's maximum extent. (Implemented as a getter for │ │ │ │ - * potential specific implementations in sub-classes.) │ │ │ │ + * Method: clone │ │ │ │ + * Create a clone of this vector feature. Does not set any non-standard │ │ │ │ + * properties. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {} │ │ │ │ + * {} An exact clone of this vector feature. │ │ │ │ */ │ │ │ │ - getMaxExtent: function() { │ │ │ │ - return this.maxExtent; │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Feature.Vector( │ │ │ │ + this.geometry ? this.geometry.clone() : null, │ │ │ │ + this.attributes, │ │ │ │ + this.style); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: addTile │ │ │ │ - * Create a tile, initialize it, and add it to the layer div. │ │ │ │ - * │ │ │ │ - * Parameters │ │ │ │ - * bounds - {} │ │ │ │ - * position - {} │ │ │ │ + * Method: onScreen │ │ │ │ + * Determine whether the feature is within the map viewport. This method │ │ │ │ + * tests for an intersection between the geometry and the viewport │ │ │ │ + * bounds. If a more effecient but less precise geometry bounds │ │ │ │ + * intersection is desired, call the method with the boundsOnly │ │ │ │ + * parameter true. │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * boundsOnly - {Boolean} Only test whether a feature's bounds intersects │ │ │ │ + * the viewport bounds. Default is false. If false, the feature's │ │ │ │ + * geometry must intersect the viewport for onScreen to return true. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {} The added OpenLayers.Tile │ │ │ │ + * {Boolean} The feature is currently visible on screen (optionally │ │ │ │ + * based on its bounds if boundsOnly is true). │ │ │ │ */ │ │ │ │ - addTile: function(bounds, position) { │ │ │ │ - var tile = new this.tileClass( │ │ │ │ - this, position, bounds, null, this.tileSize, this.tileOptions │ │ │ │ - ); │ │ │ │ - this.events.triggerEvent("addtile", { │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - return tile; │ │ │ │ + onScreen: function(boundsOnly) { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.layer && this.layer.map) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + if (boundsOnly) { │ │ │ │ + var featureBounds = this.geometry.getBounds(); │ │ │ │ + onScreen = screenBounds.intersectsBounds(featureBounds); │ │ │ │ + } else { │ │ │ │ + var screenPoly = screenBounds.toGeometry(); │ │ │ │ + onScreen = screenPoly.intersects(this.geometry); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return onScreen; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: addTileMonitoringHooks │ │ │ │ - * This function takes a tile as input and adds the appropriate hooks to │ │ │ │ - * the tile so that the layer can keep track of the loading tiles. │ │ │ │ + /** │ │ │ │ + * Method: getVisibility │ │ │ │ + * Determine whether the feature is displayed or not. It may not displayed │ │ │ │ + * because: │ │ │ │ + * - its style display property is set to 'none', │ │ │ │ + * - it doesn't belong to any layer, │ │ │ │ + * - the styleMap creates a symbolizer with display property set to 'none' │ │ │ │ + * for it, │ │ │ │ + * - the layer which it belongs to is not visible. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * tile - {} │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The feature is currently displayed. │ │ │ │ */ │ │ │ │ - addTileMonitoringHooks: function(tile) { │ │ │ │ - │ │ │ │ - var replacingCls = 'olTileReplacing'; │ │ │ │ - │ │ │ │ - tile.onLoadStart = function() { │ │ │ │ - //if that was first tile then trigger a 'loadstart' on the layer │ │ │ │ - if (this.loading === false) { │ │ │ │ - this.loading = true; │ │ │ │ - this.events.triggerEvent("loadstart"); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("tileloadstart", { │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - this.numLoadingTiles++; │ │ │ │ - if (!this.singleTile && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ - OpenLayers.Element.addClass(tile.getTile(), replacingCls); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - tile.onLoadEnd = function(evt) { │ │ │ │ - this.numLoadingTiles--; │ │ │ │ - var aborted = evt.type === 'unload'; │ │ │ │ - this.events.triggerEvent("tileloaded", { │ │ │ │ - tile: tile, │ │ │ │ - aborted: aborted │ │ │ │ - }); │ │ │ │ - if (!this.singleTile && !aborted && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ - var tileDiv = tile.getTile(); │ │ │ │ - if (OpenLayers.Element.getStyle(tileDiv, 'display') === 'none') { │ │ │ │ - var bufferTile = document.getElementById(tile.id + '_bb'); │ │ │ │ - if (bufferTile) { │ │ │ │ - bufferTile.parentNode.removeChild(bufferTile); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Element.removeClass(tileDiv, replacingCls); │ │ │ │ - } │ │ │ │ - //if that was the last tile, then trigger a 'loadend' on the layer │ │ │ │ - if (this.numLoadingTiles === 0) { │ │ │ │ - if (this.backBuffer) { │ │ │ │ - if (this.backBuffer.childNodes.length === 0) { │ │ │ │ - // no tiles transitioning, remove immediately │ │ │ │ - this.removeBackBuffer(); │ │ │ │ - } else { │ │ │ │ - // wait until transition has ended or delay has passed │ │ │ │ - this._transitionElement = aborted ? │ │ │ │ - this.div.lastChild : tile.imgDiv; │ │ │ │ - var transitionendEvents = this.transitionendEvents; │ │ │ │ - for (var i = transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ - OpenLayers.Event.observe(this._transitionElement, │ │ │ │ - transitionendEvents[i], │ │ │ │ - this._removeBackBuffer); │ │ │ │ - } │ │ │ │ - // the removal of the back buffer is delayed to prevent │ │ │ │ - // flash effects due to the animation of tile displaying │ │ │ │ - this.backBufferTimerId = window.setTimeout( │ │ │ │ - this._removeBackBuffer, this.removeBackBufferDelay │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.loading = false; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - tile.onLoadError = function() { │ │ │ │ - this.events.triggerEvent("tileerror", { │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - tile.events.on({ │ │ │ │ - "loadstart": tile.onLoadStart, │ │ │ │ - "loadend": tile.onLoadEnd, │ │ │ │ - "unload": tile.onLoadEnd, │ │ │ │ - "loaderror": tile.onLoadError, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + getVisibility: function() { │ │ │ │ + return !(this.style && this.style.display == 'none' || │ │ │ │ + !this.layer || │ │ │ │ + this.layer && this.layer.styleMap && │ │ │ │ + this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == 'none' || │ │ │ │ + this.layer && !this.layer.getVisibility()); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeTileMonitoringHooks │ │ │ │ - * This function takes a tile as input and removes the tile hooks │ │ │ │ - * that were added in addTileMonitoringHooks() │ │ │ │ + /** │ │ │ │ + * Method: createMarker │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * create markers │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * tile - {} │ │ │ │ + * Returns: │ │ │ │ + * {} For now just returns null │ │ │ │ */ │ │ │ │ - removeTileMonitoringHooks: function(tile) { │ │ │ │ - tile.unload(); │ │ │ │ - tile.events.un({ │ │ │ │ - "loadstart": tile.onLoadStart, │ │ │ │ - "loadend": tile.onLoadEnd, │ │ │ │ - "unload": tile.onLoadEnd, │ │ │ │ - "loaderror": tile.onLoadError, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + createMarker: function() { │ │ │ │ + return null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveGriddedTiles │ │ │ │ + * Method: destroyMarker │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * delete markers │ │ │ │ + * │ │ │ │ + * If user overrides the createMarker() function, s/he should be able │ │ │ │ + * to also specify an alternative function for destroying it │ │ │ │ */ │ │ │ │ - moveGriddedTiles: function() { │ │ │ │ - var buffer = this.buffer + 1; │ │ │ │ - while (true) { │ │ │ │ - var tlTile = this.grid[0][0]; │ │ │ │ - var tlViewPort = { │ │ │ │ - x: tlTile.position.x + │ │ │ │ - this.map.layerContainerOriginPx.x, │ │ │ │ - y: tlTile.position.y + │ │ │ │ - this.map.layerContainerOriginPx.y │ │ │ │ - }; │ │ │ │ - var ratio = this.getServerResolution() / this.map.getResolution(); │ │ │ │ - var tileSize = { │ │ │ │ - w: Math.round(this.tileSize.w * ratio), │ │ │ │ - h: Math.round(this.tileSize.h * ratio) │ │ │ │ - }; │ │ │ │ - if (tlViewPort.x > -tileSize.w * (buffer - 1)) { │ │ │ │ - this.shiftColumn(true, tileSize); │ │ │ │ - } else if (tlViewPort.x < -tileSize.w * buffer) { │ │ │ │ - this.shiftColumn(false, tileSize); │ │ │ │ - } else if (tlViewPort.y > -tileSize.h * (buffer - 1)) { │ │ │ │ - this.shiftRow(true, tileSize); │ │ │ │ - } else if (tlViewPort.y < -tileSize.h * buffer) { │ │ │ │ - this.shiftRow(false, tileSize); │ │ │ │ - } else { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + destroyMarker: function() { │ │ │ │ + // pass │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: shiftRow │ │ │ │ - * Shifty grid work │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * prepend - {Boolean} if true, prepend to beginning. │ │ │ │ - * if false, then append to end │ │ │ │ - * tileSize - {Object} rendered tile size; object with w and h properties │ │ │ │ + * Method: createPopup │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * create popups │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} For now just returns null │ │ │ │ */ │ │ │ │ - shiftRow: function(prepend, tileSize) { │ │ │ │ - var grid = this.grid; │ │ │ │ - var rowIndex = prepend ? 0 : (grid.length - 1); │ │ │ │ - var sign = prepend ? -1 : 1; │ │ │ │ - var rowSign = this.rowSign; │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - tileLayout.startrow += sign * rowSign; │ │ │ │ + createPopup: function() { │ │ │ │ + return null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var modelRow = grid[rowIndex]; │ │ │ │ - var row = grid[prepend ? 'pop' : 'shift'](); │ │ │ │ - for (var i = 0, len = row.length; i < len; i++) { │ │ │ │ - var tile = row[i]; │ │ │ │ - var position = modelRow[i].position.clone(); │ │ │ │ - position.y += tileSize.h * sign; │ │ │ │ - tile.moveTo(this.getTileBoundsForGridIndex(rowIndex, i), position); │ │ │ │ + /** │ │ │ │ + * Method: atPoint │ │ │ │ + * Determins whether the feature intersects with the specified location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lonlat - {|Object} OpenLayers.LonLat or an │ │ │ │ + * object with a 'lon' and 'lat' properties. │ │ │ │ + * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ + * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the feature is at the specified location │ │ │ │ + */ │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + if (this.geometry) { │ │ │ │ + atPoint = this.geometry.atPoint(lonlat, toleranceLon, │ │ │ │ + toleranceLat); │ │ │ │ } │ │ │ │ - grid[prepend ? 'unshift' : 'push'](row); │ │ │ │ + return atPoint; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: shiftColumn │ │ │ │ - * Shift grid work in the other dimension │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * prepend - {Boolean} if true, prepend to beginning. │ │ │ │ - * if false, then append to end │ │ │ │ - * tileSize - {Object} rendered tile size; object with w and h properties │ │ │ │ + * Method: destroyPopup │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * delete popups │ │ │ │ */ │ │ │ │ - shiftColumn: function(prepend, tileSize) { │ │ │ │ - var grid = this.grid; │ │ │ │ - var colIndex = prepend ? 0 : (grid[0].length - 1); │ │ │ │ - var sign = prepend ? -1 : 1; │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - tileLayout.startcol += sign; │ │ │ │ - │ │ │ │ - for (var i = 0, len = grid.length; i < len; i++) { │ │ │ │ - var row = grid[i]; │ │ │ │ - var position = row[colIndex].position.clone(); │ │ │ │ - var tile = row[prepend ? 'pop' : 'shift'](); │ │ │ │ - position.x += tileSize.w * sign; │ │ │ │ - tile.moveTo(this.getTileBoundsForGridIndex(i, colIndex), position); │ │ │ │ - row[prepend ? 'unshift' : 'push'](tile); │ │ │ │ - } │ │ │ │ + destroyPopup: function() { │ │ │ │ + // pass │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeExcessTiles │ │ │ │ - * When the size of the map or the buffer changes, we may need to │ │ │ │ - * remove some excess rows and columns. │ │ │ │ - * │ │ │ │ + * Method: move │ │ │ │ + * Moves the feature and redraws it at its new location │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * rows - {Integer} Maximum number of rows we want our grid to have. │ │ │ │ - * columns - {Integer} Maximum number of columns we want our grid to have. │ │ │ │ + * location - { or } the │ │ │ │ + * location to which to move the feature. │ │ │ │ */ │ │ │ │ - removeExcessTiles: function(rows, columns) { │ │ │ │ - var i, l; │ │ │ │ + move: function(location) { │ │ │ │ │ │ │ │ - // remove extra rows │ │ │ │ - while (this.grid.length > rows) { │ │ │ │ - var row = this.grid.pop(); │ │ │ │ - for (i = 0, l = row.length; i < l; i++) { │ │ │ │ - var tile = row[i]; │ │ │ │ - this.destroyTile(tile); │ │ │ │ - } │ │ │ │ + if (!this.layer || !this.geometry.move) { │ │ │ │ + //do nothing if no layer or immoveable geometry │ │ │ │ + return undefined; │ │ │ │ } │ │ │ │ │ │ │ │ - // remove extra columns │ │ │ │ - for (i = 0, l = this.grid.length; i < l; i++) { │ │ │ │ - while (this.grid[i].length > columns) { │ │ │ │ - var row = this.grid[i]; │ │ │ │ - var tile = row.pop(); │ │ │ │ - this.destroyTile(tile); │ │ │ │ - } │ │ │ │ + var pixel; │ │ │ │ + if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ + pixel = this.layer.getViewPortPxFromLonLat(location); │ │ │ │ + } else { │ │ │ │ + pixel = location; │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onMapResize │ │ │ │ - * For singleTile layers, this will set a new tile size according to the │ │ │ │ - * dimensions of the map pane. │ │ │ │ - */ │ │ │ │ - onMapResize: function() { │ │ │ │ - if (this.singleTile) { │ │ │ │ - this.clearGrid(); │ │ │ │ - this.setTileSize(); │ │ │ │ - } │ │ │ │ + var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ + var res = this.layer.map.getResolution(); │ │ │ │ + this.geometry.move(res * (pixel.x - lastPixel.x), │ │ │ │ + res * (lastPixel.y - pixel.y)); │ │ │ │ + this.layer.drawFeature(this); │ │ │ │ + return lastPixel; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getTileBounds │ │ │ │ - * Returns The tile bounds for a layer given a pixel location. │ │ │ │ + * Method: toState │ │ │ │ + * Sets the new state │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * viewPortPx - {} The location in the viewport. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} Bounds of the tile at the given pixel location. │ │ │ │ + * state - {String} │ │ │ │ */ │ │ │ │ - getTileBounds: function(viewPortPx) { │ │ │ │ - var maxExtent = this.maxExtent; │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ - var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ - var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ - var tileLeft = maxExtent.left + (tileMapWidth * │ │ │ │ - Math.floor((mapPoint.lon - │ │ │ │ - maxExtent.left) / │ │ │ │ - tileMapWidth)); │ │ │ │ - var tileBottom = maxExtent.bottom + (tileMapHeight * │ │ │ │ - Math.floor((mapPoint.lat - │ │ │ │ - maxExtent.bottom) / │ │ │ │ - tileMapHeight)); │ │ │ │ - return new OpenLayers.Bounds(tileLeft, tileBottom, │ │ │ │ - tileLeft + tileMapWidth, │ │ │ │ - tileBottom + tileMapHeight); │ │ │ │ + toState: function(state) { │ │ │ │ + if (state == OpenLayers.State.UPDATE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.INSERT) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.DELETE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + // the feature should be destroyed │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ + this.state = state; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Grid" │ │ │ │ + CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ }); │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Feature.Vector.style │ │ │ │ + * OpenLayers features can have a number of style attributes. The 'default' │ │ │ │ + * style will typically be used if no other style is specified. These │ │ │ │ + * styles correspond for the most part, to the styling properties defined │ │ │ │ + * by the SVG standard. │ │ │ │ + * Information on fill properties: http://www.w3.org/TR/SVG/painting.html#FillProperties │ │ │ │ + * Information on stroke properties: http://www.w3.org/TR/SVG/painting.html#StrokeProperties │ │ │ │ + * │ │ │ │ + * Symbolizer properties: │ │ │ │ + * fill - {Boolean} Set to false if no fill is desired. │ │ │ │ + * fillColor - {String} Hex fill color. Default is "#ee9900". │ │ │ │ + * fillOpacity - {Number} Fill opacity (0-1). Default is 0.4 │ │ │ │ + * stroke - {Boolean} Set to false if no stroke is desired. │ │ │ │ + * strokeColor - {String} Hex stroke color. Default is "#ee9900". │ │ │ │ + * strokeOpacity - {Number} Stroke opacity (0-1). Default is 1. │ │ │ │ + * strokeWidth - {Number} Pixel stroke width. Default is 1. │ │ │ │ + * strokeLinecap - {String} Stroke cap type. Default is "round". [butt | round | square] │ │ │ │ + * strokeDashstyle - {String} Stroke dash style. Default is "solid". [dot | dash | dashdot | longdash | longdashdot | solid] │ │ │ │ + * graphic - {Boolean} Set to false if no graphic is desired. │ │ │ │ + * pointRadius - {Number} Pixel point radius. Default is 6. │ │ │ │ + * pointerEvents - {String} Default is "visiblePainted". │ │ │ │ + * cursor - {String} Default is "". │ │ │ │ + * externalGraphic - {String} Url to an external graphic that will be used for rendering points. │ │ │ │ + * graphicWidth - {Number} Pixel width for sizing an external graphic. │ │ │ │ + * graphicHeight - {Number} Pixel height for sizing an external graphic. │ │ │ │ + * graphicOpacity - {Number} Opacity (0-1) for an external graphic. │ │ │ │ + * graphicXOffset - {Number} Pixel offset along the positive x axis for displacing an external graphic. │ │ │ │ + * graphicYOffset - {Number} Pixel offset along the positive y axis for displacing an external graphic. │ │ │ │ + * rotation - {Number} For point symbolizers, this is the rotation of a graphic in the clockwise direction about its center point (or any point off center as specified by graphicXOffset and graphicYOffset). │ │ │ │ + * graphicZIndex - {Number} The integer z-index value to use in rendering. │ │ │ │ + * graphicName - {String} Named graphic to use when rendering points. Supported values include "circle" (default), │ │ │ │ + * "square", "star", "x", "cross", "triangle". │ │ │ │ + * graphicTitle - {String} Tooltip when hovering over a feature. *deprecated*, use title instead │ │ │ │ + * title - {String} Tooltip when hovering over a feature. Not supported by the canvas renderer. │ │ │ │ + * backgroundGraphic - {String} Url to a graphic to be used as the background under an externalGraphic. │ │ │ │ + * backgroundGraphicZIndex - {Number} The integer z-index value to use in rendering the background graphic. │ │ │ │ + * backgroundXOffset - {Number} The x offset (in pixels) for the background graphic. │ │ │ │ + * backgroundYOffset - {Number} The y offset (in pixels) for the background graphic. │ │ │ │ + * backgroundHeight - {Number} The height of the background graphic. If not provided, the graphicHeight will be used. │ │ │ │ + * backgroundWidth - {Number} The width of the background width. If not provided, the graphicWidth will be used. │ │ │ │ + * label - {String} The text for an optional label. For browsers that use the canvas renderer, this requires either │ │ │ │ + * fillText or mozDrawText to be available. │ │ │ │ + * labelAlign - {String} Label alignment. This specifies the insertion point relative to the text. It is a string │ │ │ │ + * composed of two characters. The first character is for the horizontal alignment, the second for the vertical │ │ │ │ + * alignment. Valid values for horizontal alignment: "l"=left, "c"=center, "r"=right. Valid values for vertical │ │ │ │ + * alignment: "t"=top, "m"=middle, "b"=bottom. Example values: "lt", "cm", "rb". Default is "cm". │ │ │ │ + * labelXOffset - {Number} Pixel offset along the positive x axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ + * labelYOffset - {Number} Pixel offset along the positive y axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ + * labelSelect - {Boolean} If set to true, labels will be selectable using SelectFeature or similar controls. │ │ │ │ + * Default is false. │ │ │ │ + * labelOutlineColor - {String} The color of the label outline. Default is 'white'. Only supported by the canvas & SVG renderers. │ │ │ │ + * labelOutlineWidth - {Number} The width of the label outline. Default is 3, set to 0 or null to disable. Only supported by the SVG renderers. │ │ │ │ + * labelOutlineOpacity - {Number} The opacity (0-1) of the label outline. Default is fontOpacity. Only supported by the canvas & SVG renderers. │ │ │ │ + * fontColor - {String} The font color for the label, to be provided like CSS. │ │ │ │ + * fontOpacity - {Number} Opacity (0-1) for the label │ │ │ │ + * fontFamily - {String} The font family for the label, to be provided like in CSS. │ │ │ │ + * fontSize - {String} The font size for the label, to be provided like in CSS. │ │ │ │ + * fontStyle - {String} The font style for the label, to be provided like in CSS. │ │ │ │ + * fontWeight - {String} The font weight for the label, to be provided like in CSS. │ │ │ │ + * display - {String} Symbolizers will have no effect if display is set to "none". All other values have no effect. │ │ │ │ + */ │ │ │ │ +OpenLayers.Feature.Vector.style = { │ │ │ │ + 'default': { │ │ │ │ + fillColor: "#ee9900", │ │ │ │ + fillOpacity: 0.4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: 0.8, │ │ │ │ + strokeColor: "#ee9900", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: 0.2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + }, │ │ │ │ + 'select': { │ │ │ │ + fillColor: "blue", │ │ │ │ + fillOpacity: 0.4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: 0.8, │ │ │ │ + strokeColor: "blue", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: 0.2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "pointer", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + │ │ │ │ + }, │ │ │ │ + 'temporary': { │ │ │ │ + fillColor: "#66cccc", │ │ │ │ + fillOpacity: 0.2, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: 0.8, │ │ │ │ + strokeColor: "#66cccc", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: 0.2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + │ │ │ │ + }, │ │ │ │ + 'delete': { │ │ │ │ + display: "none" │ │ │ │ + } │ │ │ │ +}; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/TileManager.js │ │ │ │ + OpenLayers/Style.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/BaseTypes.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Element.js │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - * @requires OpenLayers/Tile/Image.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.TileManager │ │ │ │ - * Provides queueing of image requests and caching of image elements. │ │ │ │ - * │ │ │ │ - * Queueing avoids unnecessary image requests while changing zoom levels │ │ │ │ - * quickly, and helps improve dragging performance on mobile devices that show │ │ │ │ - * a lag in dragging when loading of new images starts. and │ │ │ │ - * are the configuration options to control this behavior. │ │ │ │ - * │ │ │ │ - * Caching avoids setting the src on image elements for images that have already │ │ │ │ - * been used. Several maps can share a TileManager instance, in which case each │ │ │ │ - * map gets its own tile queue, but all maps share the same tile cache. │ │ │ │ + * Class: OpenLayers.Style │ │ │ │ + * This class represents a UserStyle obtained │ │ │ │ + * from a SLD, containing styling rules. │ │ │ │ */ │ │ │ │ -OpenLayers.TileManager = OpenLayers.Class({ │ │ │ │ +OpenLayers.Style = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: cacheSize │ │ │ │ - * {Number} Number of image elements to keep referenced in this instance's │ │ │ │ - * cache for fast reuse. Default is 256. │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique id for this session. │ │ │ │ */ │ │ │ │ - cacheSize: 256, │ │ │ │ + id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: tilesPerFrame │ │ │ │ - * {Number} Number of queued tiles to load per frame (see ). │ │ │ │ - * Default is 2. │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - tilesPerFrame: 2, │ │ │ │ + name: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: frameDelay │ │ │ │ - * {Number} Delay between tile loading frames (see ) in │ │ │ │ - * milliseconds. Default is 16. │ │ │ │ + * Property: title │ │ │ │ + * {String} Title of this style (set if included in SLD) │ │ │ │ */ │ │ │ │ - frameDelay: 16, │ │ │ │ + title: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: moveDelay │ │ │ │ - * {Number} Delay in milliseconds after a map's move event before loading │ │ │ │ - * tiles. Default is 100. │ │ │ │ + * Property: description │ │ │ │ + * {String} Description of this style (set if abstract is included in SLD) │ │ │ │ */ │ │ │ │ - moveDelay: 100, │ │ │ │ + description: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomDelay │ │ │ │ - * {Number} Delay in milliseconds after a map's zoomend event before loading │ │ │ │ - * tiles. Default is 200. │ │ │ │ + * APIProperty: layerName │ │ │ │ + * {} name of the layer that this style belongs to, usually │ │ │ │ + * according to the NamedLayer attribute of an SLD document. │ │ │ │ */ │ │ │ │ - zoomDelay: 200, │ │ │ │ + layerName: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: maps │ │ │ │ - * {Array()} The maps to manage tiles on. │ │ │ │ + * APIProperty: isDefault │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - maps: null, │ │ │ │ + isDefault: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: rules │ │ │ │ + * {Array()} │ │ │ │ + */ │ │ │ │ + rules: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: tileQueueId │ │ │ │ - * {Object} The ids of the loop, keyed by map id. │ │ │ │ + * APIProperty: context │ │ │ │ + * {Object} An optional object with properties that symbolizers' property │ │ │ │ + * values should be evaluated against. If no context is specified, │ │ │ │ + * feature.attributes will be used │ │ │ │ */ │ │ │ │ - tileQueueId: null, │ │ │ │ + context: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: tileQueue │ │ │ │ - * {Object(Array())} Tiles queued for drawing, keyed by │ │ │ │ - * map id. │ │ │ │ + * Property: defaultStyle │ │ │ │ + * {Object} hash of style properties to use as default for merging │ │ │ │ + * rule-based style symbolizers onto. If no rules are defined, │ │ │ │ + * createSymbolizer will return this style. If is set to │ │ │ │ + * true, the defaultStyle will only be taken into account if there are │ │ │ │ + * rules defined. │ │ │ │ */ │ │ │ │ - tileQueue: null, │ │ │ │ + defaultStyle: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: tileCache │ │ │ │ - * {Object} Cached image elements, keyed by URL. │ │ │ │ + * Property: defaultsPerSymbolizer │ │ │ │ + * {Boolean} If set to true, the will extend the symbolizer │ │ │ │ + * of every rule. Properties of the will also be used to set │ │ │ │ + * missing symbolizer properties if the symbolizer has stroke, fill or │ │ │ │ + * graphic set to true. Default is false. │ │ │ │ */ │ │ │ │ - tileCache: null, │ │ │ │ + defaultsPerSymbolizer: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: tileCacheIndex │ │ │ │ - * {Array(String)} URLs of cached tiles. First entry is the least recently │ │ │ │ - * used. │ │ │ │ + * Property: propertyStyles │ │ │ │ + * {Hash of Boolean} cache of style properties that need to be parsed for │ │ │ │ + * propertyNames. Property names are keys, values won't be used. │ │ │ │ */ │ │ │ │ - tileCacheIndex: null, │ │ │ │ + propertyStyles: null, │ │ │ │ + │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.TileManager │ │ │ │ - * Constructor for a new instance. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Style │ │ │ │ + * Creates a UserStyle. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Configuration for this instance. │ │ │ │ + * style - {Object} Optional hash of style properties that will be │ │ │ │ + * used as default style for this style object. This style │ │ │ │ + * applies if no rules are specified. Symbolizers defined in │ │ │ │ + * rules will extend this default style. │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * style. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * rules - {Array()} List of rules to be added to the │ │ │ │ + * style. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ + initialize: function(style, options) { │ │ │ │ + │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ - this.maps = []; │ │ │ │ - this.tileQueueId = {}; │ │ │ │ - this.tileQueue = {}; │ │ │ │ - this.tileCache = {}; │ │ │ │ - this.tileCacheIndex = []; │ │ │ │ + this.rules = []; │ │ │ │ + if (options && options.rules) { │ │ │ │ + this.addRules(options.rules); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // use the default style from OpenLayers.Feature.Vector if no style │ │ │ │ + // was given in the constructor │ │ │ │ + this.setDefaultStyle(style || │ │ │ │ + OpenLayers.Feature.Vector.style["default"]); │ │ │ │ + │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: addMap │ │ │ │ - * Binds this instance to a map │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {} │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ */ │ │ │ │ - addMap: function(map) { │ │ │ │ - if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - this.maps.push(map); │ │ │ │ - this.tileQueue[map.id] = []; │ │ │ │ - for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ - this.addLayer({ │ │ │ │ - layer: map.layers[i] │ │ │ │ - }); │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ + this.rules[i].destroy(); │ │ │ │ + this.rules[i] = null; │ │ │ │ } │ │ │ │ - map.events.on({ │ │ │ │ - move: this.move, │ │ │ │ - zoomend: this.zoomEnd, │ │ │ │ - changelayer: this.changeLayer, │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - preremovelayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + this.rules = null; │ │ │ │ + this.defaultStyle = null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeMap │ │ │ │ - * Unbinds this instance from a map │ │ │ │ - * │ │ │ │ + * Method: createSymbolizer │ │ │ │ + * creates a style by applying all feature-dependent rules to the base │ │ │ │ + * style. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * map - {} │ │ │ │ + * feature - {} feature to evaluate rules for │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} symbolizer hash │ │ │ │ */ │ │ │ │ - removeMap: function(map) { │ │ │ │ - if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ - return; │ │ │ │ + createSymbolizer: function(feature) { │ │ │ │ + var style = this.defaultsPerSymbolizer ? {} : this.createLiterals( │ │ │ │ + OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ + │ │ │ │ + var rules = this.rules; │ │ │ │ + │ │ │ │ + var rule, context; │ │ │ │ + var elseRules = []; │ │ │ │ + var appliedRules = false; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + rule = rules[i]; │ │ │ │ + // does the rule apply? │ │ │ │ + var applies = rule.evaluate(feature); │ │ │ │ + │ │ │ │ + if (applies) { │ │ │ │ + if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ + elseRules.push(rule); │ │ │ │ + } else { │ │ │ │ + appliedRules = true; │ │ │ │ + this.applySymbolizer(rule, style, feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ - if (map.layers) { │ │ │ │ - for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: map.layers[i] │ │ │ │ - }); │ │ │ │ + │ │ │ │ + // if no other rules apply, apply the rules with else filters │ │ │ │ + if (appliedRules == false && elseRules.length > 0) { │ │ │ │ + appliedRules = true; │ │ │ │ + for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ + this.applySymbolizer(elseRules[i], style, feature); │ │ │ │ } │ │ │ │ } │ │ │ │ - if (map.events) { │ │ │ │ - map.events.un({ │ │ │ │ - move: this.move, │ │ │ │ - zoomend: this.zoomEnd, │ │ │ │ - changelayer: this.changeLayer, │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - preremovelayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + │ │ │ │ + // don't display if there were rules but none applied │ │ │ │ + if (rules.length > 0 && appliedRules == false) { │ │ │ │ + style.display = "none"; │ │ │ │ } │ │ │ │ - delete this.tileQueue[map.id]; │ │ │ │ - delete this.tileQueueId[map.id]; │ │ │ │ - OpenLayers.Util.removeItem(this.maps, map); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: move │ │ │ │ - * Handles the map's move event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} Listener argument │ │ │ │ - */ │ │ │ │ - move: function(evt) { │ │ │ │ - this.updateTimeout(evt.object, this.moveDelay, true); │ │ │ │ - }, │ │ │ │ + if (style.label != null && typeof style.label !== "string") { │ │ │ │ + style.label = String(style.label); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: zoomEnd │ │ │ │ - * Handles the map's zoomEnd event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} Listener argument │ │ │ │ - */ │ │ │ │ - zoomEnd: function(evt) { │ │ │ │ - this.updateTimeout(evt.object, this.zoomDelay); │ │ │ │ + return style; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: changeLayer │ │ │ │ - * Handles the map's changeLayer event │ │ │ │ + * Method: applySymbolizer │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Listener argument │ │ │ │ - */ │ │ │ │ - changeLayer: function(evt) { │ │ │ │ - if (evt.property === 'visibility' || evt.property === 'params') { │ │ │ │ - this.updateTimeout(evt.object, 0); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: addLayer │ │ │ │ - * Handles the map's addlayer event │ │ │ │ + * rule - {} │ │ │ │ + * style - {Object} │ │ │ │ + * feature - {} │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} The listener argument │ │ │ │ + * Returns: │ │ │ │ + * {Object} A style with new symbolizer applied. │ │ │ │ */ │ │ │ │ - addLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ - layer.events.on({ │ │ │ │ - addtile: this.addTile, │ │ │ │ - retile: this.clearTileQueue, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - var i, j, tile; │ │ │ │ - for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ - for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ - tile = layer.grid[i][j]; │ │ │ │ - this.addTile({ │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - if (tile.url && !tile.imgDiv) { │ │ │ │ - this.manageTileCache({ │ │ │ │ - object: tile │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + applySymbolizer: function(rule, style, feature) { │ │ │ │ + var symbolizerPrefix = feature.geometry ? │ │ │ │ + this.getSymbolizerPrefix(feature.geometry) : │ │ │ │ + OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeLayer │ │ │ │ - * Handles the map's preremovelayer event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} The listener argument │ │ │ │ - */ │ │ │ │ - removeLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ - this.clearTileQueue({ │ │ │ │ - object: layer │ │ │ │ + var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ + │ │ │ │ + if (this.defaultsPerSymbolizer === true) { │ │ │ │ + var defaults = this.defaultStyle; │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: defaults.pointRadius │ │ │ │ }); │ │ │ │ - if (layer.events) { │ │ │ │ - layer.events.un({ │ │ │ │ - addtile: this.addTile, │ │ │ │ - retile: this.clearTileQueue, │ │ │ │ - scope: this │ │ │ │ + if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + strokeWidth: defaults.strokeWidth, │ │ │ │ + strokeColor: defaults.strokeColor, │ │ │ │ + strokeOpacity: defaults.strokeOpacity, │ │ │ │ + strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ + strokeLinecap: defaults.strokeLinecap │ │ │ │ }); │ │ │ │ } │ │ │ │ - if (layer.grid) { │ │ │ │ - var i, j, tile; │ │ │ │ - for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ - for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ - tile = layer.grid[i][j]; │ │ │ │ - this.unloadTile({ │ │ │ │ - object: tile │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + fillColor: defaults.fillColor, │ │ │ │ + fillOpacity: defaults.fillOpacity │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: this.defaultStyle.pointRadius, │ │ │ │ + externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ + graphicName: this.defaultStyle.graphicName, │ │ │ │ + graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ + graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ + graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ + graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ + graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ + }); │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: updateTimeout │ │ │ │ - * Applies the or to the loop, │ │ │ │ - * and schedules more queue processing after if there are still │ │ │ │ - * tiles in the queue. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {} The map to update the timeout for │ │ │ │ - * delay - {Number} The delay to apply │ │ │ │ - * nice - {Boolean} If true, the timeout function will only be created if │ │ │ │ - * the tilequeue is not empty. This is used by the move handler to │ │ │ │ - * avoid impacts on dragging performance. For other events, the tile │ │ │ │ - * queue may not be populated yet, so we need to set the timer │ │ │ │ - * regardless of the queue size. │ │ │ │ - */ │ │ │ │ - updateTimeout: function(map, delay, nice) { │ │ │ │ - window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ - var tileQueue = this.tileQueue[map.id]; │ │ │ │ - if (!nice || tileQueue.length) { │ │ │ │ - this.tileQueueId[map.id] = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(function() { │ │ │ │ - this.drawTilesFromQueue(map); │ │ │ │ - if (tileQueue.length) { │ │ │ │ - this.updateTimeout(map, this.frameDelay); │ │ │ │ - } │ │ │ │ - }, this), delay │ │ │ │ - ); │ │ │ │ - } │ │ │ │ + // merge the style with the current style │ │ │ │ + return this.createLiterals( │ │ │ │ + OpenLayers.Util.extend(style, symbolizer), feature); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addTile │ │ │ │ - * Listener for the layer's addtile event │ │ │ │ - * │ │ │ │ + * Method: createLiterals │ │ │ │ + * creates literals for all style properties that have an entry in │ │ │ │ + * . │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} The listener argument │ │ │ │ + * style - {Object} style to create literals for. Will be modified │ │ │ │ + * inline. │ │ │ │ + * feature - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} the modified style │ │ │ │ */ │ │ │ │ - addTile: function(evt) { │ │ │ │ - if (evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ - evt.tile.events.on({ │ │ │ │ - beforedraw: this.queueTileDraw, │ │ │ │ - beforeload: this.manageTileCache, │ │ │ │ - loadend: this.addToCache, │ │ │ │ - unload: this.unloadTile, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - // Layer has the wrong tile type, so don't handle it any longer │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: evt.tile.layer │ │ │ │ - }); │ │ │ │ + createLiterals: function(style, feature) { │ │ │ │ + var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ + OpenLayers.Util.extend(context, this.context); │ │ │ │ + │ │ │ │ + for (var i in this.propertyStyles) { │ │ │ │ + style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i); │ │ │ │ } │ │ │ │ + return style; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unloadTile │ │ │ │ - * Listener for the tile's unload event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} The listener argument │ │ │ │ + * Method: findPropertyStyles │ │ │ │ + * Looks into all rules for this style and the defaultStyle to collect │ │ │ │ + * all the style hash property names containing ${...} strings that have │ │ │ │ + * to be replaced using the createLiteral method before returning them. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} hash of property names that need createLiteral parsing. The │ │ │ │ + * name of the property is the key, and the value is true; │ │ │ │ */ │ │ │ │ - unloadTile: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - tile.events.un({ │ │ │ │ - beforedraw: this.queueTileDraw, │ │ │ │ - beforeload: this.manageTileCache, │ │ │ │ - loadend: this.addToCache, │ │ │ │ - unload: this.unloadTile, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - OpenLayers.Util.removeItem(this.tileQueue[tile.layer.map.id], tile); │ │ │ │ + findPropertyStyles: function() { │ │ │ │ + var propertyStyles = {}; │ │ │ │ + │ │ │ │ + // check the default style │ │ │ │ + var style = this.defaultStyle; │ │ │ │ + this.addPropertyStyles(propertyStyles, style); │ │ │ │ + │ │ │ │ + // walk through all rules to check for properties in their symbolizer │ │ │ │ + var rules = this.rules; │ │ │ │ + var symbolizer, value; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + symbolizer = rules[i].symbolizer; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + value = symbolizer[key]; │ │ │ │ + if (typeof value == "object") { │ │ │ │ + // symbolizer key is "Point", "Line" or "Polygon" │ │ │ │ + this.addPropertyStyles(propertyStyles, value); │ │ │ │ + } else { │ │ │ │ + // symbolizer is a hash of style properties │ │ │ │ + this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return propertyStyles; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: queueTileDraw │ │ │ │ - * Adds a tile to the queue that will draw it. │ │ │ │ - * │ │ │ │ + * Method: addPropertyStyles │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Listener argument of the tile's beforedraw event │ │ │ │ + * propertyStyles - {Object} hash to add new property styles to. Will be │ │ │ │ + * modified inline │ │ │ │ + * symbolizer - {Object} search this symbolizer for property styles │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} propertyStyles hash │ │ │ │ */ │ │ │ │ - queueTileDraw: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - var queued = false; │ │ │ │ - var layer = tile.layer; │ │ │ │ - var url = layer.getURL(tile.bounds); │ │ │ │ - var img = this.tileCache[url]; │ │ │ │ - if (img && img.className !== 'olTileImage') { │ │ │ │ - // cached image no longer valid, e.g. because we're olTileReplacing │ │ │ │ - delete this.tileCache[url]; │ │ │ │ - OpenLayers.Util.removeItem(this.tileCacheIndex, url); │ │ │ │ - img = null; │ │ │ │ - } │ │ │ │ - // queue only if image with same url not cached already │ │ │ │ - if (layer.url && (layer.async || !img)) { │ │ │ │ - // add to queue only if not in queue already │ │ │ │ - var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ - if (!~OpenLayers.Util.indexOf(tileQueue, tile)) { │ │ │ │ - tileQueue.push(tile); │ │ │ │ + addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ + var property; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + property = symbolizer[key]; │ │ │ │ + if (typeof property == "string" && │ │ │ │ + property.match(/\$\{\w+\}/)) { │ │ │ │ + propertyStyles[key] = true; │ │ │ │ } │ │ │ │ - queued = true; │ │ │ │ } │ │ │ │ - return !queued; │ │ │ │ + return propertyStyles; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: drawTilesFromQueue │ │ │ │ - * Draws tiles from the tileQueue, and unqueues the tiles │ │ │ │ + * APIMethod: addRules │ │ │ │ + * Adds rules to this style. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * rules - {Array()} │ │ │ │ */ │ │ │ │ - drawTilesFromQueue: function(map) { │ │ │ │ - var tileQueue = this.tileQueue[map.id]; │ │ │ │ - var limit = this.tilesPerFrame; │ │ │ │ - var animating = map.zoomTween && map.zoomTween.playing; │ │ │ │ - while (!animating && tileQueue.length && limit) { │ │ │ │ - tileQueue.shift().draw(true); │ │ │ │ - --limit; │ │ │ │ - } │ │ │ │ + addRules: function(rules) { │ │ │ │ + Array.prototype.push.apply(this.rules, rules); │ │ │ │ + this.propertyStyles = this.findPropertyStyles(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: manageTileCache │ │ │ │ - * Adds, updates, removes and fetches cache entries. │ │ │ │ - * │ │ │ │ + * APIMethod: setDefaultStyle │ │ │ │ + * Sets the default style for this style object. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Listener argument of the tile's beforeload event │ │ │ │ + * style - {Object} Hash of style properties │ │ │ │ */ │ │ │ │ - manageTileCache: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - var img = this.tileCache[tile.url]; │ │ │ │ - if (img) { │ │ │ │ - // if image is on its layer's backbuffer, remove it from backbuffer │ │ │ │ - if (img.parentNode && │ │ │ │ - OpenLayers.Element.hasClass(img.parentNode, 'olBackBuffer')) { │ │ │ │ - img.parentNode.removeChild(img); │ │ │ │ - img.id = null; │ │ │ │ - } │ │ │ │ - // only use image from cache if it is not on a layer already │ │ │ │ - if (!img.parentNode) { │ │ │ │ - img.style.visibility = 'hidden'; │ │ │ │ - img.style.opacity = 0; │ │ │ │ - tile.setImage(img); │ │ │ │ - // LRU - move tile to the end of the array to mark it as the most │ │ │ │ - // recently used │ │ │ │ - OpenLayers.Util.removeItem(this.tileCacheIndex, tile.url); │ │ │ │ - this.tileCacheIndex.push(tile.url); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + setDefaultStyle: function(style) { │ │ │ │ + this.defaultStyle = style; │ │ │ │ + this.propertyStyles = this.findPropertyStyles(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addToCache │ │ │ │ - * │ │ │ │ + * Method: getSymbolizerPrefix │ │ │ │ + * Returns the correct symbolizer prefix according to the │ │ │ │ + * geometry type of the passed geometry │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Listener argument for the tile's loadend event │ │ │ │ + * geometry - {} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} key of the according symbolizer │ │ │ │ */ │ │ │ │ - addToCache: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - if (!this.tileCache[tile.url]) { │ │ │ │ - if (!OpenLayers.Element.hasClass(tile.imgDiv, 'olImageLoadError')) { │ │ │ │ - if (this.tileCacheIndex.length >= this.cacheSize) { │ │ │ │ - delete this.tileCache[this.tileCacheIndex[0]]; │ │ │ │ - this.tileCacheIndex.shift(); │ │ │ │ - } │ │ │ │ - this.tileCache[tile.url] = tile.imgDiv; │ │ │ │ - this.tileCacheIndex.push(tile.url); │ │ │ │ + getSymbolizerPrefix: function(geometry) { │ │ │ │ + var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ + for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ + if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ + return prefixes[i]; │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearTileQueue │ │ │ │ - * Clears the tile queue from tiles of a specific layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} Listener argument of the layer's retile event │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this style. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} Clone of this style. │ │ │ │ */ │ │ │ │ - clearTileQueue: function(evt) { │ │ │ │ - var layer = evt.object; │ │ │ │ - var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ - for (var i = tileQueue.length - 1; i >= 0; --i) { │ │ │ │ - if (tileQueue[i].layer === layer) { │ │ │ │ - tileQueue.splice(i, 1); │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + // clone rules │ │ │ │ + if (this.rules) { │ │ │ │ + options.rules = []; │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ + options.rules.push(this.rules[i].clone()); │ │ │ │ } │ │ │ │ } │ │ │ │ + // clone context │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + //clone default style │ │ │ │ + var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ + return new OpenLayers.Style(defaultStyle, options); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = this.maps.length - 1; i >= 0; --i) { │ │ │ │ - this.removeMap(this.maps[i]); │ │ │ │ - } │ │ │ │ - this.maps = null; │ │ │ │ - this.tileQueue = null; │ │ │ │ - this.tileQueueId = null; │ │ │ │ - this.tileCache = null; │ │ │ │ - this.tileCacheIndex = null; │ │ │ │ - this._destroyed = true; │ │ │ │ + CLASS_NAME: "OpenLayers.Style" │ │ │ │ +}); │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: createLiteral │ │ │ │ + * converts a style value holding a combination of PropertyName and Literal │ │ │ │ + * into a Literal, taking the property values from the passed features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * value - {String} value to parse. If this string contains a construct like │ │ │ │ + * "foo ${bar}", then "foo " will be taken as literal, and "${bar}" │ │ │ │ + * will be replaced by the value of the "bar" attribute of the passed │ │ │ │ + * feature. │ │ │ │ + * context - {Object} context to take attribute values from │ │ │ │ + * feature - {} optional feature to pass to │ │ │ │ + * for evaluating functions in the │ │ │ │ + * context. │ │ │ │ + * property - {String} optional, name of the property for which the literal is │ │ │ │ + * being created for evaluating functions in the context. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} the parsed value. In the example of the value parameter above, the │ │ │ │ + * result would be "foo valueOfBar", assuming that the passed feature has an │ │ │ │ + * attribute named "bar" with the value "valueOfBar". │ │ │ │ + */ │ │ │ │ +OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ + if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ + value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ + value = (isNaN(value) || !value) ? value : parseFloat(value); │ │ │ │ } │ │ │ │ + return value; │ │ │ │ +}; │ │ │ │ │ │ │ │ -}); │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Style.SYMBOLIZER_PREFIXES │ │ │ │ + * {Array} prefixes of the sld symbolizers. These are the │ │ │ │ + * same as the main geometry types │ │ │ │ + */ │ │ │ │ +OpenLayers.Style.SYMBOLIZER_PREFIXES = ['Point', 'Line', 'Polygon', 'Text', │ │ │ │ + 'Raster' │ │ │ │ +]; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy.js │ │ │ │ + OpenLayers/Rule.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Style.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy │ │ │ │ - * Abstract vector layer strategy class. Not to be instantiated directly. Use │ │ │ │ - * one of the strategy subclasses instead. │ │ │ │ + * Class: OpenLayers.Rule │ │ │ │ + * This class represents an SLD Rule, as being used for rule-based SLD styling. │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ +OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {} The layer this strategy belongs to. │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique id for this session. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: options │ │ │ │ - * {Object} Any options sent to the constructor. │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} name of this rule │ │ │ │ */ │ │ │ │ - options: null, │ │ │ │ + name: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: active │ │ │ │ - * {Boolean} The control is active. │ │ │ │ + /** │ │ │ │ + * Property: title │ │ │ │ + * {String} Title of this rule (set if included in SLD) │ │ │ │ */ │ │ │ │ - active: null, │ │ │ │ + title: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: autoActivate │ │ │ │ - * {Boolean} The creator of the strategy can set autoActivate to false │ │ │ │ - * to fully control when the protocol is activated and deactivated. │ │ │ │ - * Defaults to true. │ │ │ │ + * Property: description │ │ │ │ + * {String} Description of this rule (set if abstract is included in SLD) │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + description: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: autoDestroy │ │ │ │ - * {Boolean} The creator of the strategy can set autoDestroy to false │ │ │ │ - * to fully control when the strategy is destroyed. Defaults to │ │ │ │ - * true. │ │ │ │ + * Property: context │ │ │ │ + * {Object} An optional object with properties that the rule should be │ │ │ │ + * evaluated against. If no context is specified, feature.attributes will │ │ │ │ + * be used. │ │ │ │ */ │ │ │ │ - autoDestroy: true, │ │ │ │ + context: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy │ │ │ │ - * Abstract class for vector strategies. Create instances of a subclass. │ │ │ │ + * Property: filter │ │ │ │ + * {} Optional filter for the rule. │ │ │ │ + */ │ │ │ │ + filter: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: elseFilter │ │ │ │ + * {Boolean} Determines whether this rule is only to be applied only if │ │ │ │ + * no other rules match (ElseFilter according to the SLD specification). │ │ │ │ + * Default is false. For instances of OpenLayers.Rule, if elseFilter is │ │ │ │ + * false, the rule will always apply. For subclasses, the else property is │ │ │ │ + * ignored. │ │ │ │ + */ │ │ │ │ + elseFilter: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: symbolizer │ │ │ │ + * {Object} Symbolizer or hash of symbolizers for this rule. If hash of │ │ │ │ + * symbolizers, keys are one or more of ["Point", "Line", "Polygon"]. The │ │ │ │ + * latter if useful if it is required to style e.g. vertices of a line │ │ │ │ + * with a point symbolizer. Note, however, that this is not implemented │ │ │ │ + * yet in OpenLayers, but it is the way how symbolizers are defined in │ │ │ │ + * SLD. │ │ │ │ + */ │ │ │ │ + symbolizer: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: symbolizers │ │ │ │ + * {Array} Collection of symbolizers associated with this rule. If │ │ │ │ + * provided at construction, the symbolizers array has precedence │ │ │ │ + * over the deprecated symbolizer property. Note that multiple │ │ │ │ + * symbolizers are not currently supported by the vector renderers. │ │ │ │ + * Rules with multiple symbolizers are currently only useful for │ │ │ │ + * maintaining elements in an SLD document. │ │ │ │ + */ │ │ │ │ + symbolizers: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: minScaleDenominator │ │ │ │ + * {Number} or {String} minimum scale at which to draw the feature. │ │ │ │ + * In the case of a String, this can be a combination of text and │ │ │ │ + * propertyNames in the form "literal ${propertyName}" │ │ │ │ + */ │ │ │ │ + minScaleDenominator: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: maxScaleDenominator │ │ │ │ + * {Number} or {String} maximum scale at which to draw the feature. │ │ │ │ + * In the case of a String, this can be a combination of text and │ │ │ │ + * propertyNames in the form "literal ${propertyName}" │ │ │ │ + */ │ │ │ │ + maxScaleDenominator: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Rule │ │ │ │ + * Creates a Rule. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * rule │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ + this.symbolizer = {}; │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options; │ │ │ │ - // set the active property here, so that user cannot override it │ │ │ │ - this.active = false; │ │ │ │ + if (this.symbolizers) { │ │ │ │ + delete this.symbolizer; │ │ │ │ + } │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * APIMethod: destroy │ │ │ │ - * Clean up the strategy. │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layer = null; │ │ │ │ - this.options = null; │ │ │ │ + for (var i in this.symbolizer) { │ │ │ │ + this.symbolizer[i] = null; │ │ │ │ + } │ │ │ │ + this.symbolizer = null; │ │ │ │ + delete this.symbolizers; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setLayer │ │ │ │ - * Called to set the property. │ │ │ │ - * │ │ │ │ + * APIMethod: evaluate │ │ │ │ + * evaluates this rule for a specific feature │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * layer - {} │ │ │ │ + * feature - {} feature to apply the rule to. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} true if the rule applies, false if it does not. │ │ │ │ + * This rule is the default rule and always returns true. │ │ │ │ */ │ │ │ │ - setLayer: function(layer) { │ │ │ │ - this.layer = layer; │ │ │ │ + evaluate: function(feature) { │ │ │ │ + var context = this.getContext(feature); │ │ │ │ + var applies = true; │ │ │ │ + │ │ │ │ + if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ + var scale = feature.layer.map.getScale(); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // check if within minScale/maxScale bounds │ │ │ │ + if (this.minScaleDenominator) { │ │ │ │ + applies = scale >= OpenLayers.Style.createLiteral( │ │ │ │ + this.minScaleDenominator, context); │ │ │ │ + } │ │ │ │ + if (applies && this.maxScaleDenominator) { │ │ │ │ + applies = scale < OpenLayers.Style.createLiteral( │ │ │ │ + this.maxScaleDenominator, context); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // check if optional filter applies │ │ │ │ + if (applies && this.filter) { │ │ │ │ + // feature id filters get the feature, others get the context │ │ │ │ + if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ + applies = this.filter.evaluate(feature); │ │ │ │ + } else { │ │ │ │ + applies = this.filter.evaluate(context); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return applies; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ - * the strategy was already active. │ │ │ │ + * Method: getContext │ │ │ │ + * Gets the context for evaluating this rule │ │ │ │ + * │ │ │ │ + * Paramters: │ │ │ │ + * feature - {} feature to take the context from if │ │ │ │ + * none is specified. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - this.active = true; │ │ │ │ - return true; │ │ │ │ + getContext: function(feature) { │ │ │ │ + var context = this.context; │ │ │ │ + if (!context) { │ │ │ │ + context = feature.attributes || feature.data; │ │ │ │ } │ │ │ │ - return false; │ │ │ │ + if (typeof this.context == "function") { │ │ │ │ + context = this.context(feature); │ │ │ │ + } │ │ │ │ + return context; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ - * tear-down. │ │ │ │ - * │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this rule. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ - * the strategy was already inactive. │ │ │ │ + * {} Clone of this rule. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.active = false; │ │ │ │ - return true; │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + // clone symbolizers │ │ │ │ + var len = this.symbolizers.length; │ │ │ │ + options.symbolizers = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + options.symbolizers[i] = this.symbolizers[i].clone(); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // clone symbolizer │ │ │ │ + options.symbolizer = {}; │ │ │ │ + var value, type; │ │ │ │ + for (var key in this.symbolizer) { │ │ │ │ + value = this.symbolizer[key]; │ │ │ │ + type = typeof value; │ │ │ │ + if (type === "object") { │ │ │ │ + options.symbolizer[key] = OpenLayers.Util.extend({}, value); │ │ │ │ + } else if (type === "string") { │ │ │ │ + options.symbolizer[key] = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - return false; │ │ │ │ + // clone filter │ │ │ │ + options.filter = this.filter && this.filter.clone(); │ │ │ │ + // clone context │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + return new OpenLayers.Rule(options); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ + CLASS_NAME: "OpenLayers.Rule" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler.js │ │ │ │ + OpenLayers/Symbolizer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler │ │ │ │ - * Base class to construct a higher-level handler for event sequences. All │ │ │ │ - * handlers have activate and deactivate methods. In addition, they have │ │ │ │ - * methods named like browser events. When a handler is activated, any │ │ │ │ - * additional methods named like a browser event is registered as a │ │ │ │ - * listener for the corresponding event. When a handler is deactivated, │ │ │ │ - * those same methods are unregistered as event listeners. │ │ │ │ - * │ │ │ │ - * Handlers also typically have a callbacks object with keys named like │ │ │ │ - * the abstracted events or event sequences that they are in charge of │ │ │ │ - * handling. The controls that wrap handlers define the methods that │ │ │ │ - * correspond to these abstract events - so instead of listening for │ │ │ │ - * individual browser events, they only listen for the abstract events │ │ │ │ - * defined by the handler. │ │ │ │ - * │ │ │ │ - * Handlers are created by controls, which ultimately have the responsibility │ │ │ │ - * of making changes to the the state of the application. Handlers │ │ │ │ - * themselves may make temporary changes, but in general are expected to │ │ │ │ - * return the application in the same state that they found it. │ │ │ │ + * Class: OpenLayers.Symbolizer │ │ │ │ + * Base class representing a symbolizer used for feature rendering. │ │ │ │ */ │ │ │ │ -OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ +OpenLayers.Symbolizer = OpenLayers.Class({ │ │ │ │ + │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ + * APIProperty: zIndex │ │ │ │ + * {Number} The zIndex determines the rendering order for a symbolizer. │ │ │ │ + * Symbolizers with larger zIndex values are rendered over symbolizers │ │ │ │ + * with smaller zIndex values. Default is 0. │ │ │ │ */ │ │ │ │ - id: null, │ │ │ │ + zIndex: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: 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. │ │ │ │ + * Constructor: OpenLayers.Symbolizer │ │ │ │ + * Instances of this class are not useful. See one of the subclasses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * symbolizer. Any documented symbolizer property can be set at │ │ │ │ + * construction. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * A new symbolizer. │ │ │ │ */ │ │ │ │ - control: null, │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Util.extend(this, config); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {} │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Create a copy of this symbolizer. │ │ │ │ + * │ │ │ │ + * Returns a symbolizer of the same type with the same properties. │ │ │ │ */ │ │ │ │ - map: null, │ │ │ │ + clone: function() { │ │ │ │ + var Type = eval(this.CLASS_NAME); │ │ │ │ + return new Type(OpenLayers.Util.extend({}, this)); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer" │ │ │ │ + │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Symbolizer/Point.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Symbolizer.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Symbolizer.Point │ │ │ │ + * A symbolizer used to render point features. │ │ │ │ + */ │ │ │ │ +OpenLayers.Symbolizer.Point = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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) │ │ │ │ + * APIProperty: strokeColor │ │ │ │ + * {String} Color for line stroke. This is a RGB hex value (e.g. "#ff0000" │ │ │ │ + * for red). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - keyMask: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: active │ │ │ │ - * {Boolean} │ │ │ │ + * APIProperty: strokeOpacity │ │ │ │ + * {Number} Stroke opacity (0-1). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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. │ │ │ │ + * APIProperty: strokeWidth │ │ │ │ + * {Number} Pixel stroke width. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - evt: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: touch │ │ │ │ - * {Boolean} Indicates the support of touch events. When touch events are │ │ │ │ - * started touch will be true and all mouse related listeners will do │ │ │ │ - * nothing. │ │ │ │ + * APIProperty: strokeLinecap │ │ │ │ + * {String} Stroke cap type ("butt", "round", or "square"). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - touch: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. If a map property │ │ │ │ - * is present in the options argument it will be used instead. │ │ │ │ - * 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. │ │ │ │ + * Property: strokeDashstyle │ │ │ │ + * {String} Stroke dash style according to the SLD spec. Note that the │ │ │ │ + * OpenLayers values for strokeDashstyle ("dot", "dash", "dashdot", │ │ │ │ + * "longdash", "longdashdot", or "solid") will not work in SLD, but │ │ │ │ + * most SLD patterns will render correctly in OpenLayers. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.control = control; │ │ │ │ - this.callbacks = callbacks; │ │ │ │ │ │ │ │ - var map = this.map || control.map; │ │ │ │ - if (map) { │ │ │ │ - this.setMap(map); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: fillColor │ │ │ │ + * {String} RGB hex fill color (e.g. "#ff0000" for red). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: fillOpacity │ │ │ │ + * {Number} Fill opacity (0-1). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * APIProperty: pointRadius │ │ │ │ + * {Number} Pixel point radius. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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. │ │ │ │ + * APIProperty: externalGraphic │ │ │ │ + * {String} Url to an external graphic that will be used for rendering │ │ │ │ + * points. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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) | │ │ │ │ - (evt.metaKey ? OpenLayers.Handler.MOD_META : 0); │ │ │ │ │ │ │ │ - /* if it differs from the handler object's key mask, │ │ │ │ - bail out of the event handler */ │ │ │ │ - return (keyModifiers == this.keyMask); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: graphicWidth │ │ │ │ + * {Number} Pixel width for sizing an external graphic. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Turn on the handler. Returns false if the handler was already active. │ │ │ │ + * APIProperty: graphicHeight │ │ │ │ + * {Number} Pixel height for sizing an external graphic. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was activated. │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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, len = events.length; i < len; 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. │ │ │ │ + * APIProperty: graphicOpacity │ │ │ │ + * {Number} Opacity (0-1) for an external graphic. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was deactivated. │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.unregister(events[i], this[events[i]]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.touch = false; │ │ │ │ - this.active = false; │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: startTouch │ │ │ │ - * Start touch events, this method must be called by subclasses in │ │ │ │ - * "touchstart" method. When touch events are started will be │ │ │ │ - * true and all mouse related listeners will do nothing. │ │ │ │ + * APIProperty: graphicXOffset │ │ │ │ + * {Number} Pixel offset along the positive x axis for displacing an │ │ │ │ + * external graphic. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - startTouch: function() { │ │ │ │ - if (!this.touch) { │ │ │ │ - this.touch = true; │ │ │ │ - var events = [ │ │ │ │ - "mousedown", "mouseup", "mousemove", "click", "dblclick", │ │ │ │ - "mouseout" │ │ │ │ - ]; │ │ │ │ - for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.unregister(events[i], this[events[i]]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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). │ │ │ │ + * APIProperty: graphicYOffset │ │ │ │ + * {Number} Pixel offset along the positive y axis for displacing an │ │ │ │ + * external graphic. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - callback: function(name, args) { │ │ │ │ - if (name && this.callbacks[name]) { │ │ │ │ - this.callbacks[name].apply(this.control, args); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: register │ │ │ │ - * register an event on the map │ │ │ │ + * APIProperty: rotation │ │ │ │ + * {Number} The rotation of a graphic in the clockwise direction about its │ │ │ │ + * center point (or any point off center as specified by │ │ │ │ + * and ). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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 │ │ │ │ + * APIProperty: graphicName │ │ │ │ + * {String} Named graphic to use when rendering points. Supported values │ │ │ │ + * include "circle", "square", "star", "x", "cross", and "triangle". │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - 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, ctrl, │ │ │ │ - * and meta 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 || handler.evt.metaKey(end). │ │ │ │ + * Constructor: OpenLayers.Symbolizer.Point │ │ │ │ + * Create a symbolizer for rendering points. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} The browser event. │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * symbolizer. Any documented symbolizer property can be set at │ │ │ │ + * construction. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * A new point symbolizer. │ │ │ │ */ │ │ │ │ - setEvent: function(evt) { │ │ │ │ - this.evt = evt; │ │ │ │ - return true; │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * Deconstruct the handler. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - // unregister event listeners │ │ │ │ - this.deactivate(); │ │ │ │ - // eliminate circular references │ │ │ │ - this.control = this.map = null; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Point" │ │ │ │ │ │ │ │ - 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; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Symbolizer/Line.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_SHIFT │ │ │ │ - * If set as the , returns false if Shift is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_SHIFT = 1; │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_CTRL │ │ │ │ - * If set as the , returns false if Ctrl is down. │ │ │ │ + * @requires OpenLayers/Symbolizer.js │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.MOD_CTRL = 2; │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_ALT │ │ │ │ - * If set as the , returns false if Alt is down. │ │ │ │ + * Class: OpenLayers.Symbolizer.Line │ │ │ │ + * A symbolizer used to render line features. │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.MOD_ALT = 4; │ │ │ │ +OpenLayers.Symbolizer.Line = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_META │ │ │ │ - * If set as the , returns false if Cmd is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_META = 8; │ │ │ │ + /** │ │ │ │ + * APIProperty: strokeColor │ │ │ │ + * {String} Color for line stroke. This is a RGB hex value (e.g. "#ff0000" │ │ │ │ + * for red). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: strokeOpacity │ │ │ │ + * {Number} Stroke opacity (0-1). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: strokeWidth │ │ │ │ + * {Number} Pixel stroke width. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: strokeLinecap │ │ │ │ + * {String} Stroke cap type ("butt", "round", or "square"). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: strokeDashstyle │ │ │ │ + * {String} Stroke dash style according to the SLD spec. Note that the │ │ │ │ + * OpenLayers values for strokeDashstyle ("dot", "dash", "dashdot", │ │ │ │ + * "longdash", "longdashdot", or "solid") will not work in SLD, but │ │ │ │ + * most SLD patterns will render correctly in OpenLayers. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Symbolizer.Line │ │ │ │ + * Create a symbolizer for rendering lines. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * symbolizer. Any documented symbolizer property can be set at │ │ │ │ + * construction. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * A new line symbolizer. │ │ │ │ + */ │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Line" │ │ │ │ │ │ │ │ +}); │ │ │ │ │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Geometry.js │ │ │ │ + OpenLayers/Symbolizer/Polygon.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Symbolizer.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Geometry │ │ │ │ - * A Geometry is a description of a geographic object. Create an instance of │ │ │ │ - * this class with the constructor. This is a base class, │ │ │ │ - * typical geometry types are described by subclasses of this class. │ │ │ │ - * │ │ │ │ - * Note that if you use the method, you must │ │ │ │ - * explicitly include the OpenLayers.Format.WKT in your build. │ │ │ │ + * Class: OpenLayers.Symbolizer.Polygon │ │ │ │ + * A symbolizer used to render line features. │ │ │ │ */ │ │ │ │ -OpenLayers.Geometry = OpenLayers.Class({ │ │ │ │ +OpenLayers.Symbolizer.Polygon = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique identifier for this geometry. │ │ │ │ + * APIProperty: strokeColor │ │ │ │ + * {String} Color for line stroke. This is a RGB hex value (e.g. "#ff0000" │ │ │ │ + * for red). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: parent │ │ │ │ - * {}This is set when a Geometry is added as component │ │ │ │ - * of another geometry │ │ │ │ + * APIProperty: strokeOpacity │ │ │ │ + * {Number} Stroke opacity (0-1). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - parent: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: bounds │ │ │ │ - * {} The bounds of this geometry │ │ │ │ + * APIProperty: strokeWidth │ │ │ │ + * {Number} Pixel stroke width. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - bounds: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Geometry │ │ │ │ - * Creates a geometry object. │ │ │ │ + * APIProperty: strokeLinecap │ │ │ │ + * {String} Stroke cap type ("butt", "round", or "square"). │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - initialize: function() { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - * Destroy this geometry. │ │ │ │ + * Property: strokeDashstyle │ │ │ │ + * {String} Stroke dash style according to the SLD spec. Note that the │ │ │ │ + * OpenLayers values for strokeDashstyle ("dot", "dash", "dashdot", │ │ │ │ + * "longdash", "longdashdot", or "solid") will not work in SLD, but │ │ │ │ + * most SLD patterns will render correctly in OpenLayers. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.id = null; │ │ │ │ - this.bounds = null; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a clone of this geometry. Does not set any non-standard │ │ │ │ - * properties of the cloned geometry. │ │ │ │ + * APIProperty: fillColor │ │ │ │ + * {String} RGB hex fill color (e.g. "#ff0000" for red). │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {} An exact clone of this geometry. │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Geometry(); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setBounds │ │ │ │ - * Set the bounds for this Geometry. │ │ │ │ + * APIProperty: fillOpacity │ │ │ │ + * {Number} Fill opacity (0-1). │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {} │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - setBounds: function(bounds) { │ │ │ │ - if (bounds) { │ │ │ │ - this.bounds = bounds.clone(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearBounds │ │ │ │ - * Nullify this components bounds and that of its parent as well. │ │ │ │ + * Constructor: OpenLayers.Symbolizer.Polygon │ │ │ │ + * Create a symbolizer for rendering polygons. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * symbolizer. Any documented symbolizer property can be set at │ │ │ │ + * construction. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * A new polygon symbolizer. │ │ │ │ */ │ │ │ │ - clearBounds: function() { │ │ │ │ - this.bounds = null; │ │ │ │ - if (this.parent) { │ │ │ │ - this.parent.clearBounds(); │ │ │ │ - } │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extendBounds │ │ │ │ - * Extend the existing bounds to include the new bounds. │ │ │ │ - * If geometry's bounds is not yet set, then set a new Bounds. │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Polygon" │ │ │ │ + │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Symbolizer/Text.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Symbolizer.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Symbolizer.Text │ │ │ │ + * A symbolizer used to render text labels for features. │ │ │ │ + */ │ │ │ │ +OpenLayers.Symbolizer.Text = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: label │ │ │ │ + * {String} The text for the label. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * newBounds - {} │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - extendBounds: function(newBounds) { │ │ │ │ - var bounds = this.getBounds(); │ │ │ │ - if (!bounds) { │ │ │ │ - this.setBounds(newBounds); │ │ │ │ - } else { │ │ │ │ - this.bounds.extend(newBounds); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getBounds │ │ │ │ - * Get the bounds for this Geometry. If bounds is not set, it │ │ │ │ - * is calculated again, this makes queries faster. │ │ │ │ + /** │ │ │ │ + * APIProperty: fontFamily │ │ │ │ + * {String} The font family for the label. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {} │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - getBounds: function() { │ │ │ │ - if (this.bounds == null) { │ │ │ │ - this.calculateBounds(); │ │ │ │ - } │ │ │ │ - return this.bounds; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: calculateBounds │ │ │ │ - * Recalculate the bounds for the geometry. │ │ │ │ + * APIProperty: fontSize │ │ │ │ + * {String} The font size for the label. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: fontWeight │ │ │ │ + * {String} The font weight for the label. │ │ │ │ + * │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - calculateBounds: function() { │ │ │ │ - // │ │ │ │ - // This should be overridden by subclasses. │ │ │ │ - // │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: distanceTo │ │ │ │ - * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {} The target geometry. │ │ │ │ - * options - {Object} Optional properties for configuring the distance │ │ │ │ - * calculation. │ │ │ │ - * │ │ │ │ - * Valid options depend on the specific geometry type. │ │ │ │ + * Property: fontStyle │ │ │ │ + * {String} The font style for the label. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Number | Object} The distance between this geometry and the target. │ │ │ │ - * If details is true, the return will be an object with distance, │ │ │ │ - * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ - * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ - * properties represent the coordinates of the closest point on the │ │ │ │ - * target geometry. │ │ │ │ + * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ */ │ │ │ │ - distanceTo: function(geometry, options) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getVertices │ │ │ │ - * Return a list of all points in this geometry. │ │ │ │ + * Constructor: OpenLayers.Symbolizer.Text │ │ │ │ + * Create a symbolizer for rendering text labels. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ - * endpoints. If false, for lines, only vertices that are not │ │ │ │ - * endpoints will be returned. If not provided, all vertices will │ │ │ │ - * be returned. │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * symbolizer. Any documented symbolizer property can be set at │ │ │ │ + * construction. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array} A list of all vertices in the geometry. │ │ │ │ + * A new text symbolizer. │ │ │ │ */ │ │ │ │ - getVertices: function(nodes) {}, │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Text" │ │ │ │ + │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Symbolizer/Raster.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Symbolizer.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Symbolizer.Raster │ │ │ │ + * A symbolizer used to render raster images. │ │ │ │ + */ │ │ │ │ +OpenLayers.Symbolizer.Raster = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: atPoint │ │ │ │ - * Note - This is only an approximation based on the bounds of the │ │ │ │ - * geometry. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Symbolizer.Raster │ │ │ │ + * Create a symbolizer for rendering rasters. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * lonlat - {|Object} OpenLayers.LonLat or an │ │ │ │ - * object with a 'lon' and 'lat' properties. │ │ │ │ - * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ - * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ - * │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * symbolizer. Any documented symbolizer property can be set at │ │ │ │ + * construction. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Whether or not the geometry is at the specified location │ │ │ │ + * A new raster symbolizer. │ │ │ │ */ │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - var bounds = this.getBounds(); │ │ │ │ - if ((bounds != null) && (lonlat != null)) { │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var dX = (toleranceLon != null) ? toleranceLon : 0; │ │ │ │ - var dY = (toleranceLat != null) ? toleranceLat : 0; │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Raster" │ │ │ │ │ │ │ │ - var toleranceBounds = │ │ │ │ - new OpenLayers.Bounds(this.bounds.left - dX, │ │ │ │ - this.bounds.bottom - dY, │ │ │ │ - this.bounds.right + dX, │ │ │ │ - this.bounds.top + dY); │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Style2.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - atPoint = toleranceBounds.containsLonLat(lonlat); │ │ │ │ - } │ │ │ │ - return atPoint; │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Rule.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Point.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Line.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Polygon.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Text.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Raster.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Style2 │ │ │ │ + * This class represents a collection of rules for rendering features. │ │ │ │ + */ │ │ │ │ +OpenLayers.Style2 = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getLength │ │ │ │ - * Calculate the length of this geometry. This method is defined in │ │ │ │ - * subclasses. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The length of the collection by summing its parts │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique id for this session. │ │ │ │ */ │ │ │ │ - getLength: function() { │ │ │ │ - //to be overridden by geometries that actually have a length │ │ │ │ - // │ │ │ │ - return 0.0; │ │ │ │ - }, │ │ │ │ + id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getArea │ │ │ │ - * Calculate the area of this geometry. This method is defined in subclasses. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The area of the collection by summing its parts │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} Style identifier. │ │ │ │ */ │ │ │ │ - getArea: function() { │ │ │ │ - //to be overridden by geometries that actually have an area │ │ │ │ - // │ │ │ │ - return 0.0; │ │ │ │ - }, │ │ │ │ + name: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getCentroid │ │ │ │ - * Calculate the centroid of this geometry. This method is defined in subclasses. │ │ │ │ + * APIProperty: title │ │ │ │ + * {String} Title of this style. │ │ │ │ + */ │ │ │ │ + title: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: description │ │ │ │ + * {String} Description of this style. │ │ │ │ + */ │ │ │ │ + description: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: layerName │ │ │ │ + * {} Name of the layer that this style belongs to, usually │ │ │ │ + * according to the NamedLayer attribute of an SLD document. │ │ │ │ + */ │ │ │ │ + layerName: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isDefault │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + isDefault: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: rules │ │ │ │ + * {Array()} Collection of rendering rules. │ │ │ │ + */ │ │ │ │ + rules: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Style2 │ │ │ │ + * Creates a style representing a collection of rendering rules. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} An object containing properties to be set on the │ │ │ │ + * style. Any documented properties may be set at construction. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {} The centroid of the collection │ │ │ │ + * {} A new style object. │ │ │ │ */ │ │ │ │ - getCentroid: function() { │ │ │ │ - return null; │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Util.extend(this, config); │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ + this.rules[i].destroy(); │ │ │ │ + } │ │ │ │ + delete this.rules; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: toString │ │ │ │ - * Returns a text representation of the geometry. If the WKT format is │ │ │ │ - * included in a build, this will be the Well-Known Text │ │ │ │ - * representation. │ │ │ │ - * │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this style. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} String representation of this geometry. │ │ │ │ + * {} Clone of this style. │ │ │ │ */ │ │ │ │ - toString: function() { │ │ │ │ - var string; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ - string = OpenLayers.Format.WKT.prototype.write( │ │ │ │ - new OpenLayers.Feature.Vector(this) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - string = Object.prototype.toString.call(this); │ │ │ │ + clone: function() { │ │ │ │ + var config = OpenLayers.Util.extend({}, this); │ │ │ │ + // clone rules │ │ │ │ + if (this.rules) { │ │ │ │ + config.rules = []; │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ + config.rules.push(this.rules[i].clone()); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return string; │ │ │ │ + return new OpenLayers.Style2(config); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry" │ │ │ │ + CLASS_NAME: "OpenLayers.Style2" │ │ │ │ }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/StyleMap.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Function: OpenLayers.Geometry.fromWKT │ │ │ │ - * Generate a geometry given a Well-Known Text string. For this method to │ │ │ │ - * work, you must include the OpenLayers.Format.WKT in your build │ │ │ │ - * explicitly. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * wkt - {String} A string representing the geometry in Well-Known Text. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} A geometry of the appropriate class. │ │ │ │ - */ │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Style.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.StyleMap │ │ │ │ + */ │ │ │ │ +OpenLayers.StyleMap = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: styles │ │ │ │ + * {Object} Hash of {}, keyed by names of well known │ │ │ │ + * rendering intents (e.g. "default", "temporary", "select", "delete"). │ │ │ │ + */ │ │ │ │ + styles: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: extendDefault │ │ │ │ + * {Boolean} if true, every render intent will extend the symbolizers │ │ │ │ + * specified for the "default" intent at rendering time. Otherwise, every │ │ │ │ + * rendering intent will be treated as a completely independent style. │ │ │ │ + */ │ │ │ │ + extendDefault: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.StyleMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * style - {Object} Optional. Either a style hash, or a style object, or │ │ │ │ + * a hash of style objects (style hashes) keyed by rendering │ │ │ │ + * intent. If just one style hash or style object is passed, │ │ │ │ + * this will be used for all known render intents (default, │ │ │ │ + * select, temporary) │ │ │ │ + * options - {Object} optional hash of additional options for this │ │ │ │ + * instance │ │ │ │ + */ │ │ │ │ + initialize: function(style, options) { │ │ │ │ + this.styles = { │ │ │ │ + "default": new OpenLayers.Style( │ │ │ │ + OpenLayers.Feature.Vector.style["default"]), │ │ │ │ + "select": new OpenLayers.Style( │ │ │ │ + OpenLayers.Feature.Vector.style["select"]), │ │ │ │ + "temporary": new OpenLayers.Style( │ │ │ │ + OpenLayers.Feature.Vector.style["temporary"]), │ │ │ │ + "delete": new OpenLayers.Style( │ │ │ │ + OpenLayers.Feature.Vector.style["delete"]) │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // take whatever the user passed as style parameter and convert it │ │ │ │ + // into parts of stylemap. │ │ │ │ + if (style instanceof OpenLayers.Style) { │ │ │ │ + // user passed a style object │ │ │ │ + this.styles["default"] = style; │ │ │ │ + this.styles["select"] = style; │ │ │ │ + this.styles["temporary"] = style; │ │ │ │ + this.styles["delete"] = style; │ │ │ │ + } else if (typeof style == "object") { │ │ │ │ + for (var key in style) { │ │ │ │ + if (style[key] instanceof OpenLayers.Style) { │ │ │ │ + // user passed a hash of style objects │ │ │ │ + this.styles[key] = style[key]; │ │ │ │ + } else if (typeof style[key] == "object") { │ │ │ │ + // user passsed a hash of style hashes │ │ │ │ + this.styles[key] = new OpenLayers.Style(style[key]); │ │ │ │ + } else { │ │ │ │ + // user passed a style hash (i.e. symbolizer) │ │ │ │ + this.styles["default"] = new OpenLayers.Style(style); │ │ │ │ + this.styles["select"] = new OpenLayers.Style(style); │ │ │ │ + this.styles["temporary"] = new OpenLayers.Style(style); │ │ │ │ + this.styles["delete"] = new OpenLayers.Style(style); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + for (var key in this.styles) { │ │ │ │ + this.styles[key].destroy(); │ │ │ │ + } │ │ │ │ + this.styles = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createSymbolizer │ │ │ │ + * Creates the symbolizer for a feature for a render intent. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {} The feature to evaluate the rules │ │ │ │ + * of the intended style against. │ │ │ │ + * intent - {String} The intent determines the symbolizer that will be │ │ │ │ + * used to draw the feature. Well known intents are "default" │ │ │ │ + * (for just drawing the features), "select" (for selected │ │ │ │ + * features) and "temporary" (for drawing features). │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} symbolizer hash │ │ │ │ + */ │ │ │ │ + createSymbolizer: function(feature, intent) { │ │ │ │ + if (!feature) { │ │ │ │ + feature = new OpenLayers.Feature.Vector(); │ │ │ │ + } │ │ │ │ + if (!this.styles[intent]) { │ │ │ │ + intent = "default"; │ │ │ │ + } │ │ │ │ + feature.renderIntent = intent; │ │ │ │ + var defaultSymbolizer = {}; │ │ │ │ + if (this.extendDefault && intent != "default") { │ │ │ │ + defaultSymbolizer = this.styles["default"].createSymbolizer(feature); │ │ │ │ + } │ │ │ │ + return OpenLayers.Util.extend(defaultSymbolizer, │ │ │ │ + this.styles[intent].createSymbolizer(feature)); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: addUniqueValueRules │ │ │ │ + * Convenience method to create comparison rules for unique values of a │ │ │ │ + * property. The rules will be added to the style object for a specified │ │ │ │ + * rendering intent. This method is a shortcut for creating something like │ │ │ │ + * the "unique value legends" familiar from well known desktop GIS systems │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * renderIntent - {String} rendering intent to add the rules to │ │ │ │ + * property - {String} values of feature attributes to create the │ │ │ │ + * rules for │ │ │ │ + * symbolizers - {Object} Hash of symbolizers, keyed by the desired │ │ │ │ + * property values │ │ │ │ + * context - {Object} An optional object with properties that │ │ │ │ + * symbolizers' property values should be evaluated │ │ │ │ + * against. If no context is specified, feature.attributes │ │ │ │ + * will be used │ │ │ │ + */ │ │ │ │ + addUniqueValueRules: function(renderIntent, property, symbolizers, context) { │ │ │ │ + var rules = []; │ │ │ │ + for (var value in symbolizers) { │ │ │ │ + rules.push(new OpenLayers.Rule({ │ │ │ │ + symbolizer: symbolizers[value], │ │ │ │ + context: context, │ │ │ │ + filter: new OpenLayers.Filter.Comparison({ │ │ │ │ + type: OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }) │ │ │ │ + })); │ │ │ │ + } │ │ │ │ + this.styles[renderIntent].addRules(rules); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.StyleMap" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Spherical.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Namespace: Spherical │ │ │ │ + * The OpenLayers.Spherical namespace includes utility functions for │ │ │ │ + * calculations on the basis of a spherical earth (ignoring ellipsoidal │ │ │ │ + * effects), which is accurate enough for most purposes. │ │ │ │ + * │ │ │ │ + * Relevant links: │ │ │ │ + * * http://www.movable-type.co.uk/scripts/latlong.html │ │ │ │ + * * http://code.google.com/apis/maps/documentation/javascript/reference.html#spherical │ │ │ │ + */ │ │ │ │ + │ │ │ │ +OpenLayers.Spherical = OpenLayers.Spherical || {}; │ │ │ │ + │ │ │ │ +OpenLayers.Spherical.DEFAULT_RADIUS = 6378137; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * APIFunction: computeDistanceBetween │ │ │ │ + * Computes the distance between two LonLats. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * from - {} or {Object} Starting point. A LonLat or │ │ │ │ + * a JavaScript literal with lon lat properties. │ │ │ │ + * to - {} or {Object} Ending point. A LonLat or a │ │ │ │ + * JavaScript literal with lon lat properties. │ │ │ │ + * radius - {Float} The radius. Optional. Defaults to 6378137 meters. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The distance in meters. │ │ │ │ + */ │ │ │ │ +OpenLayers.Spherical.computeDistanceBetween = function(from, to, radius) { │ │ │ │ + var R = radius || OpenLayers.Spherical.DEFAULT_RADIUS; │ │ │ │ + var sinHalfDeltaLon = Math.sin(Math.PI * (to.lon - from.lon) / 360); │ │ │ │ + var sinHalfDeltaLat = Math.sin(Math.PI * (to.lat - from.lat) / 360); │ │ │ │ + var a = sinHalfDeltaLat * sinHalfDeltaLat + │ │ │ │ + sinHalfDeltaLon * sinHalfDeltaLon * Math.cos(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ + return 2 * R * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); │ │ │ │ +}; │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * APIFunction: computeHeading │ │ │ │ + * Computes the heading from one LonLat to another LonLat. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * from - {} or {Object} Starting point. A LonLat or │ │ │ │ + * a JavaScript literal with lon lat properties. │ │ │ │ + * to - {} or {Object} Ending point. A LonLat or a │ │ │ │ + * JavaScript literal with lon lat properties. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The heading in degrees. │ │ │ │ + */ │ │ │ │ +OpenLayers.Spherical.computeHeading = function(from, to) { │ │ │ │ + var y = Math.sin(Math.PI * (from.lon - to.lon) / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ + var x = Math.cos(Math.PI * from.lat / 180) * Math.sin(Math.PI * to.lat / 180) - │ │ │ │ + Math.sin(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180) * Math.cos(Math.PI * (from.lon - to.lon) / 180); │ │ │ │ + return 180 * Math.atan2(y, x) / Math.PI; │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Protocol.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol │ │ │ │ + * Abstract vector layer protocol class. Not to be instantiated directly. Use │ │ │ │ + * one of the protocol subclasses instead. │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: format │ │ │ │ + * {} The format used by this protocol. │ │ │ │ + */ │ │ │ │ + format: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: options │ │ │ │ + * {Object} Any options sent to the constructor. │ │ │ │ + */ │ │ │ │ + options: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: autoDestroy │ │ │ │ + * {Boolean} The creator of the protocol can set autoDestroy to false │ │ │ │ + * to fully control when the protocol is destroyed. Defaults to │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoDestroy: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultFilter │ │ │ │ + * {} Optional default filter to read requests │ │ │ │ + */ │ │ │ │ + defaultFilter: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Protocol │ │ │ │ + * Abstract class for vector protocols. Create instances of a subclass. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: mergeWithDefaultFilter │ │ │ │ + * Merge filter passed to the read method with the default one │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {} │ │ │ │ + */ │ │ │ │ + mergeWithDefaultFilter: function(filter) { │ │ │ │ + var merged; │ │ │ │ + if (filter && this.defaultFilter) { │ │ │ │ + merged = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.defaultFilter, filter] │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + merged = filter || this.defaultFilter || undefined; │ │ │ │ + } │ │ │ │ + return merged; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.options = null; │ │ │ │ + this.format = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} An │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ + */ │ │ │ │ + read: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.filter = this.mergeWithDefaultFilter(options.filter); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: create │ │ │ │ + * Construct a request for writing newly created features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({})} or │ │ │ │ + * {} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} An │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ + */ │ │ │ │ + create: function() {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: update │ │ │ │ + * Construct a request updating modified features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({})} or │ │ │ │ + * {} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} An │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ + */ │ │ │ │ + update: function() {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: delete │ │ │ │ + * Construct a request deleting a removed feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} An │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ + */ │ │ │ │ + "delete": function() {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: commit │ │ │ │ + * Go over the features and for each take action │ │ │ │ + * based on the feature state. Possible actions are create, │ │ │ │ + * update and delete. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({})} │ │ │ │ + * options - {Object} Object whose possible keys are "create", "update", │ │ │ │ + * "delete", "callback" and "scope", the values referenced by the │ │ │ │ + * first three are objects as passed to the "create", "update", and │ │ │ │ + * "delete" methods, the value referenced by the "callback" key is │ │ │ │ + * a function which is called when the commit operation is complete │ │ │ │ + * using the scope referenced by the "scope" key. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array({})} An array of │ │ │ │ + * objects. │ │ │ │ + */ │ │ │ │ + commit: function() {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: abort │ │ │ │ + * Abort an ongoing request. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {} │ │ │ │ + */ │ │ │ │ + abort: function(response) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createCallback │ │ │ │ + * Returns a function that applies the given public method with resp and │ │ │ │ + * options arguments. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * method - {Function} The method to be applied by the callback. │ │ │ │ + * response - {} The protocol response object. │ │ │ │ + * options - {Object} Options sent to the protocol method │ │ │ │ + */ │ │ │ │ + createCallback: function(method, response, options) { │ │ │ │ + return OpenLayers.Function.bind(function() { │ │ │ │ + method.apply(this, [response, options]); │ │ │ │ + }, this); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol.Response │ │ │ │ + * Protocols return Response objects to their users. │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.Response = OpenLayers.Class({ │ │ │ │ + /** │ │ │ │ + * Property: code │ │ │ │ + * {Number} - OpenLayers.Protocol.Response.SUCCESS or │ │ │ │ + * OpenLayers.Protocol.Response.FAILURE │ │ │ │ + */ │ │ │ │ + code: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: requestType │ │ │ │ + * {String} The type of request this response corresponds to. Either │ │ │ │ + * "create", "read", "update" or "delete". │ │ │ │ + */ │ │ │ │ + requestType: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: last │ │ │ │ + * {Boolean} - true if this is the last response expected in a commit, │ │ │ │ + * false otherwise, defaults to true. │ │ │ │ + */ │ │ │ │ + last: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: features │ │ │ │ + * {Array({})} or {} │ │ │ │ + * The features returned in the response by the server. Depending on the │ │ │ │ + * protocol's read payload, either features or data will be populated. │ │ │ │ + */ │ │ │ │ + features: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: data │ │ │ │ + * {Object} │ │ │ │ + * The data returned in the response by the server. Depending on the │ │ │ │ + * protocol's read payload, either features or data will be populated. │ │ │ │ + */ │ │ │ │ + data: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: reqFeatures │ │ │ │ + * {Array({})} or {} │ │ │ │ + * The features provided by the user and placed in the request by the │ │ │ │ + * protocol. │ │ │ │ + */ │ │ │ │ + reqFeatures: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: priv │ │ │ │ + */ │ │ │ │ + priv: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: error │ │ │ │ + * {Object} The error object in case a service exception was encountered. │ │ │ │ + */ │ │ │ │ + error: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Protocol.Response │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: success │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} - true on success, false otherwise │ │ │ │ + */ │ │ │ │ + success: function() { │ │ │ │ + return this.code > 0; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.Response" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +OpenLayers.Protocol.Response.SUCCESS = 1; │ │ │ │ +OpenLayers.Protocol.Response.FAILURE = 0; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Handler.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Handler │ │ │ │ + * Base class to construct a higher-level handler for event sequences. All │ │ │ │ + * handlers have activate and deactivate methods. In addition, they have │ │ │ │ + * methods named like browser events. When a handler is activated, any │ │ │ │ + * additional methods named like a browser event is registered as a │ │ │ │ + * listener for the corresponding event. When a handler is deactivated, │ │ │ │ + * those same methods are unregistered as event listeners. │ │ │ │ + * │ │ │ │ + * Handlers also typically have a callbacks object with keys named like │ │ │ │ + * the abstracted events or event sequences that they are in charge of │ │ │ │ + * handling. The controls that wrap handlers define the methods that │ │ │ │ + * correspond to these abstract events - so instead of listening for │ │ │ │ + * individual browser events, they only listen for the abstract events │ │ │ │ + * defined by the handler. │ │ │ │ + * │ │ │ │ + * Handlers are created by controls, which ultimately have the responsibility │ │ │ │ + * of making changes to the the state of the application. Handlers │ │ │ │ + * themselves may make temporary changes, but in general are expected to │ │ │ │ + * return the application in the same state that they found it. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + id: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: 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. │ │ │ │ + */ │ │ │ │ + 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, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: touch │ │ │ │ + * {Boolean} Indicates the support of touch events. When touch events are │ │ │ │ + * started touch will be true and all mouse related listeners will do │ │ │ │ + * nothing. │ │ │ │ + */ │ │ │ │ + touch: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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. If a map property │ │ │ │ + * is present in the options argument it will be used instead. │ │ │ │ + * 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; │ │ │ │ + │ │ │ │ + var map = this.map || control.map; │ │ │ │ + if (map) { │ │ │ │ + this.setMap(map); │ │ │ │ + } │ │ │ │ + │ │ │ │ + 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) | │ │ │ │ + (evt.metaKey ? OpenLayers.Handler.MOD_META : 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, len = events.length; i < len; 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, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.unregister(events[i], this[events[i]]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.touch = false; │ │ │ │ + this.active = false; │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: startTouch │ │ │ │ + * Start touch events, this method must be called by subclasses in │ │ │ │ + * "touchstart" method. When touch events are started will be │ │ │ │ + * true and all mouse related listeners will do nothing. │ │ │ │ + */ │ │ │ │ + startTouch: function() { │ │ │ │ + if (!this.touch) { │ │ │ │ + this.touch = true; │ │ │ │ + var events = [ │ │ │ │ + "mousedown", "mouseup", "mousemove", "click", "dblclick", │ │ │ │ + "mouseout" │ │ │ │ + ]; │ │ │ │ + for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.unregister(events[i], this[events[i]]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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, ctrl, │ │ │ │ + * and meta 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 || handler.evt.metaKey(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; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Handler.MOD_META │ │ │ │ + * If set as the , returns false if Cmd is down. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MOD_META = 8; │ │ │ │ + │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Geometry.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Geometry │ │ │ │ + * A Geometry is a description of a geographic object. Create an instance of │ │ │ │ + * this class with the constructor. This is a base class, │ │ │ │ + * typical geometry types are described by subclasses of this class. │ │ │ │ + * │ │ │ │ + * Note that if you use the method, you must │ │ │ │ + * explicitly include the OpenLayers.Format.WKT in your build. │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique identifier for this geometry. │ │ │ │ + */ │ │ │ │ + id: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: parent │ │ │ │ + * {}This is set when a Geometry is added as component │ │ │ │ + * of another geometry │ │ │ │ + */ │ │ │ │ + parent: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: bounds │ │ │ │ + * {} The bounds of this geometry │ │ │ │ + */ │ │ │ │ + bounds: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Geometry │ │ │ │ + * Creates a geometry object. │ │ │ │ + */ │ │ │ │ + initialize: function() { │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Destroy this geometry. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.id = null; │ │ │ │ + this.bounds = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Create a clone of this geometry. Does not set any non-standard │ │ │ │ + * properties of the cloned geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} An exact clone of this geometry. │ │ │ │ + */ │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Geometry(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setBounds │ │ │ │ + * Set the bounds for this Geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {} │ │ │ │ + */ │ │ │ │ + setBounds: function(bounds) { │ │ │ │ + if (bounds) { │ │ │ │ + this.bounds = bounds.clone(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: clearBounds │ │ │ │ + * Nullify this components bounds and that of its parent as well. │ │ │ │ + */ │ │ │ │ + clearBounds: function() { │ │ │ │ + this.bounds = null; │ │ │ │ + if (this.parent) { │ │ │ │ + this.parent.clearBounds(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: extendBounds │ │ │ │ + * Extend the existing bounds to include the new bounds. │ │ │ │ + * If geometry's bounds is not yet set, then set a new Bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * newBounds - {} │ │ │ │ + */ │ │ │ │ + extendBounds: function(newBounds) { │ │ │ │ + var bounds = this.getBounds(); │ │ │ │ + if (!bounds) { │ │ │ │ + this.setBounds(newBounds); │ │ │ │ + } else { │ │ │ │ + this.bounds.extend(newBounds); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getBounds │ │ │ │ + * Get the bounds for this Geometry. If bounds is not set, it │ │ │ │ + * is calculated again, this makes queries faster. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} │ │ │ │ + */ │ │ │ │ + getBounds: function() { │ │ │ │ + if (this.bounds == null) { │ │ │ │ + this.calculateBounds(); │ │ │ │ + } │ │ │ │ + return this.bounds; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: calculateBounds │ │ │ │ + * Recalculate the bounds for the geometry. │ │ │ │ + */ │ │ │ │ + calculateBounds: function() { │ │ │ │ + // │ │ │ │ + // This should be overridden by subclasses. │ │ │ │ + // │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: distanceTo │ │ │ │ + * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {} The target geometry. │ │ │ │ + * options - {Object} Optional properties for configuring the distance │ │ │ │ + * calculation. │ │ │ │ + * │ │ │ │ + * Valid options depend on the specific geometry type. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number | Object} The distance between this geometry and the target. │ │ │ │ + * If details is true, the return will be an object with distance, │ │ │ │ + * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ + * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ + * properties represent the coordinates of the closest point on the │ │ │ │ + * target geometry. │ │ │ │ + */ │ │ │ │ + distanceTo: function(geometry, options) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getVertices │ │ │ │ + * Return a list of all points in this geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ + * endpoints. If false, for lines, only vertices that are not │ │ │ │ + * endpoints will be returned. If not provided, all vertices will │ │ │ │ + * be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} A list of all vertices in the geometry. │ │ │ │ + */ │ │ │ │ + getVertices: function(nodes) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: atPoint │ │ │ │ + * Note - This is only an approximation based on the bounds of the │ │ │ │ + * geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lonlat - {|Object} OpenLayers.LonLat or an │ │ │ │ + * object with a 'lon' and 'lat' properties. │ │ │ │ + * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ + * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the geometry is at the specified location │ │ │ │ + */ │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + var bounds = this.getBounds(); │ │ │ │ + if ((bounds != null) && (lonlat != null)) { │ │ │ │ + │ │ │ │ + var dX = (toleranceLon != null) ? toleranceLon : 0; │ │ │ │ + var dY = (toleranceLat != null) ? toleranceLat : 0; │ │ │ │ + │ │ │ │ + var toleranceBounds = │ │ │ │ + new OpenLayers.Bounds(this.bounds.left - dX, │ │ │ │ + this.bounds.bottom - dY, │ │ │ │ + this.bounds.right + dX, │ │ │ │ + this.bounds.top + dY); │ │ │ │ + │ │ │ │ + atPoint = toleranceBounds.containsLonLat(lonlat); │ │ │ │ + } │ │ │ │ + return atPoint; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getLength │ │ │ │ + * Calculate the length of this geometry. This method is defined in │ │ │ │ + * subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The length of the collection by summing its parts │ │ │ │ + */ │ │ │ │ + getLength: function() { │ │ │ │ + //to be overridden by geometries that actually have a length │ │ │ │ + // │ │ │ │ + return 0.0; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getArea │ │ │ │ + * Calculate the area of this geometry. This method is defined in subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The area of the collection by summing its parts │ │ │ │ + */ │ │ │ │ + getArea: function() { │ │ │ │ + //to be overridden by geometries that actually have an area │ │ │ │ + // │ │ │ │ + return 0.0; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getCentroid │ │ │ │ + * Calculate the centroid of this geometry. This method is defined in subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} The centroid of the collection │ │ │ │ + */ │ │ │ │ + getCentroid: function() { │ │ │ │ + return null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: toString │ │ │ │ + * Returns a text representation of the geometry. If the WKT format is │ │ │ │ + * included in a build, this will be the Well-Known Text │ │ │ │ + * representation. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} String representation of this geometry. │ │ │ │ + */ │ │ │ │ + toString: function() { │ │ │ │ + var string; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ + string = OpenLayers.Format.WKT.prototype.write( │ │ │ │ + new OpenLayers.Feature.Vector(this) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + string = Object.prototype.toString.call(this); │ │ │ │ + } │ │ │ │ + return string; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Geometry.fromWKT │ │ │ │ + * Generate a geometry given a Well-Known Text string. For this method to │ │ │ │ + * work, you must include the OpenLayers.Format.WKT in your build │ │ │ │ + * explicitly. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * wkt - {String} A string representing the geometry in Well-Known Text. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} A geometry of the appropriate class. │ │ │ │ + */ │ │ │ │ OpenLayers.Geometry.fromWKT = function(wkt) { │ │ │ │ var geom; │ │ │ │ if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ var format = OpenLayers.Geometry.fromWKT.format; │ │ │ │ if (!format) { │ │ │ │ format = new OpenLayers.Format.WKT(); │ │ │ │ OpenLayers.Geometry.fromWKT.format = format; │ │ │ │ @@ -16780,642 +17648,14 @@ │ │ │ │ distance: Math.pow(x - x0, 2) + Math.pow(y - y0, 2), │ │ │ │ x: x, │ │ │ │ y: y, │ │ │ │ along: along │ │ │ │ }; │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Icon.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * 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 │ │ │ │ - * {|Object} An OpenLayers.Size or │ │ │ │ - * an object with a 'w' and 'h' properties. │ │ │ │ - */ │ │ │ │ - size: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: offset │ │ │ │ - * {|Object} distance in pixels to offset the │ │ │ │ - * image when being rendered. An OpenLayers.Pixel or an object │ │ │ │ - * with a 'x' and 'y' properties. │ │ │ │ - */ │ │ │ │ - offset: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: calculateOffset │ │ │ │ - * {Function} Function to calculate the offset (based on the size) │ │ │ │ - */ │ │ │ │ - calculateOffset: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: imageDiv │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - imageDiv: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: px │ │ │ │ - * {|Object} An OpenLayers.Pixel or an object │ │ │ │ - * with a 'x' and 'y' properties. │ │ │ │ - */ │ │ │ │ - px: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Icon │ │ │ │ - * Creates an icon, which is an image tag in a div. │ │ │ │ - * │ │ │ │ - * url - {String} │ │ │ │ - * size - {|Object} An OpenLayers.Size or an │ │ │ │ - * object with a 'w' and 'h' │ │ │ │ - * properties. │ │ │ │ - * offset - {|Object} An OpenLayers.Pixel or an │ │ │ │ - * object with a 'x' and 'y' │ │ │ │ - * properties. │ │ │ │ - * calculateOffset - {Function} │ │ │ │ - */ │ │ │ │ - initialize: function(url, size, offset, calculateOffset) { │ │ │ │ - this.url = url; │ │ │ │ - this.size = size || { │ │ │ │ - w: 20, │ │ │ │ - h: 20 │ │ │ │ - }; │ │ │ │ - this.offset = offset || { │ │ │ │ - x: -(this.size.w / 2), │ │ │ │ - y: -(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() { │ │ │ │ - // erase any drawn elements │ │ │ │ - this.erase(); │ │ │ │ - │ │ │ │ - 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 - {|Object} An OpenLayers.Size or │ │ │ │ - * an object with a 'w' and 'h' properties. │ │ │ │ - */ │ │ │ │ - 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 - {|Object} An OpenLayers.Pixel or an │ │ │ │ - * object with a 'x' and 'y' properties. │ │ │ │ - * │ │ │ │ - * 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: erase │ │ │ │ - * Erase the underlying image element. │ │ │ │ - */ │ │ │ │ - erase: function() { │ │ │ │ - if (this.imageDiv != null && this.imageDiv.parentNode != null) { │ │ │ │ - OpenLayers.Element.remove(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 - {|Object} the pixel position to move to. │ │ │ │ - * An OpenLayers.Pixel or an object with a 'x' and 'y' properties. │ │ │ │ - */ │ │ │ │ - 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); │ │ │ │ - } │ │ │ │ - OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, { │ │ │ │ - x: this.px.x + this.offset.x, │ │ │ │ - y: this.px.y + this.offset.y │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: display │ │ │ │ - * Hide or show the icon │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * display - {Boolean} │ │ │ │ - */ │ │ │ │ - display: function(display) { │ │ │ │ - this.imageDiv.style.display = (display) ? "" : "none"; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: isDrawn │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the icon is drawn. │ │ │ │ - */ │ │ │ │ - isDrawn: function() { │ │ │ │ - // nodeType 11 for ie, whose nodes *always* have a parentNode │ │ │ │ - // (of type document fragment) │ │ │ │ - var isDrawn = (this.imageDiv && this.imageDiv.parentNode && │ │ │ │ - (this.imageDiv.parentNode.nodeType != 11)); │ │ │ │ - │ │ │ │ - return isDrawn; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Icon" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control │ │ │ │ - * Controls affect the display or behavior of the map. They allow everything │ │ │ │ - * from panning and zooming to displaying a scale indicator. Controls by │ │ │ │ - * default are added to the map they are contained within however it is │ │ │ │ - * possible to add a control to an external div by passing the div in the │ │ │ │ - * options parameter. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * The following example shows how to add many of the common controls │ │ │ │ - * to a map. │ │ │ │ - * │ │ │ │ - * > var map = new OpenLayers.Map('map', { controls: [] }); │ │ │ │ - * > │ │ │ │ - * > map.addControl(new OpenLayers.Control.PanZoomBar()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false})); │ │ │ │ - * > map.addControl(new OpenLayers.Control.Permalink()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.Permalink('permalink')); │ │ │ │ - * > map.addControl(new OpenLayers.Control.MousePosition()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.OverviewMap()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.KeyboardDefaults()); │ │ │ │ - * │ │ │ │ - * The next code fragment is a quick example of how to intercept │ │ │ │ - * shift-mouse click to display the extent of the bounding box │ │ │ │ - * dragged out by the user. Usually controls are not created │ │ │ │ - * in exactly this manner. See the source for a more complete │ │ │ │ - * example: │ │ │ │ - * │ │ │ │ - * > var control = new OpenLayers.Control(); │ │ │ │ - * > OpenLayers.Util.extend(control, { │ │ │ │ - * > draw: function () { │ │ │ │ - * > // this Handler.Box will intercept the shift-mousedown │ │ │ │ - * > // before Control.MouseDefault gets to see it │ │ │ │ - * > this.box = new OpenLayers.Handler.Box( control, │ │ │ │ - * > {"done": this.notice}, │ │ │ │ - * > {keyMask: OpenLayers.Handler.MOD_SHIFT}); │ │ │ │ - * > this.box.activate(); │ │ │ │ - * > }, │ │ │ │ - * > │ │ │ │ - * > notice: function (bounds) { │ │ │ │ - * > OpenLayers.Console.userError(bounds); │ │ │ │ - * > } │ │ │ │ - * > }); │ │ │ │ - * > map.addControl(control); │ │ │ │ - * │ │ │ │ - */ │ │ │ │ -OpenLayers.Control = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {} this gets set in the addControl() function in │ │ │ │ - * OpenLayers.Map │ │ │ │ - */ │ │ │ │ - map: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: div │ │ │ │ - * {DOMElement} The element that contains the control, if not present the │ │ │ │ - * control is placed inside the map. │ │ │ │ - */ │ │ │ │ - div: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {Number} Controls can have a 'type'. The type determines the type of │ │ │ │ - * interactions which are possible with them when they are placed in an │ │ │ │ - * . │ │ │ │ - */ │ │ │ │ - type: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: allowSelection │ │ │ │ - * {Boolean} By default, controls do not allow selection, because │ │ │ │ - * it may interfere with map dragging. If this is true, OpenLayers │ │ │ │ - * will not prevent selection of the control. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - allowSelection: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: displayClass │ │ │ │ - * {string} This property is used for CSS related to the drawing of the │ │ │ │ - * Control. │ │ │ │ - */ │ │ │ │ - displayClass: "", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: title │ │ │ │ - * {string} This property is used for showing a tooltip over the │ │ │ │ - * Control. │ │ │ │ - */ │ │ │ │ - title: "", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * false. │ │ │ │ - */ │ │ │ │ - autoActivate: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: active │ │ │ │ - * {Boolean} The control is active (read-only). Use and │ │ │ │ - * to change control state. │ │ │ │ - */ │ │ │ │ - active: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the control's handler │ │ │ │ - */ │ │ │ │ - handlerOptions: 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, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * 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. │ │ │ │ - */ │ │ │ │ - events: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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); │ │ │ │ - if (this.eventListeners instanceof Object) { │ │ │ │ - this.events.on(this.eventListeners); │ │ │ │ - } │ │ │ │ - if (this.id == null) { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * The destroy method is used to perform any clean up before the control │ │ │ │ - * is dereferenced. Typically this is where event listeners are removed │ │ │ │ - * to prevent memory leaks. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.events) { │ │ │ │ - if (this.eventListeners) { │ │ │ │ - this.events.un(this.eventListeners); │ │ │ │ - } │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - } │ │ │ │ - this.eventListeners = null; │ │ │ │ - │ │ │ │ - // eliminate circular references │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.destroy(); │ │ │ │ - this.handler = null; │ │ │ │ - } │ │ │ │ - if (this.handlers) { │ │ │ │ - for (var key in this.handlers) { │ │ │ │ - if (this.handlers.hasOwnProperty(key) && │ │ │ │ - typeof this.handlers[key].destroy == "function") { │ │ │ │ - this.handlers[key].destroy(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.handlers = null; │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.removeControl(this); │ │ │ │ - this.map = null; │ │ │ │ - } │ │ │ │ - this.div = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. This is done through an accessor │ │ │ │ - * so that subclasses can override this and take special action once │ │ │ │ - * they have their map variable set. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {} │ │ │ │ - */ │ │ │ │ - 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 = OpenLayers.Function.False; │ │ │ │ - } │ │ │ │ - if (this.title != "") { │ │ │ │ - this.div.title = this.title; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (px != null) { │ │ │ │ - this.position = px.clone(); │ │ │ │ - } │ │ │ │ - this.moveTo(this.position); │ │ │ │ - return this.div; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: moveTo │ │ │ │ - * Sets the left and top style attributes to the passed in pixel │ │ │ │ - * coordinates. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {} │ │ │ │ - */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - if ((px != null) && (this.div != null)) { │ │ │ │ - this.div.style.left = px.x + "px"; │ │ │ │ - this.div.style.top = px.y + "px"; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Explicitly activates a control and it's associated │ │ │ │ - * handler if one has been set. Controls can be │ │ │ │ - * deactivated by calling the deactivate() method. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the control was successfully activated or │ │ │ │ - * false if the control was already active. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.activate(); │ │ │ │ - } │ │ │ │ - this.active = true; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, │ │ │ │ - this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("activate"); │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivates a control and it's associated handler if any. The exact │ │ │ │ - * effect of this depends on the control itself. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the control was effectively deactivated or false │ │ │ │ - * if the control was already inactive. │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate(); │ │ │ │ - } │ │ │ │ - this.active = false; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, │ │ │ │ - this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("deactivate"); │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Control" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_BUTTON │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_TOGGLE │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_TOOL │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Format.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -28672,937 +28912,14 @@ │ │ │ │ "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Format.WPSExecute" │ │ │ │ │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Request/XMLHttpRequest.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -// XMLHttpRequest.js Copyright (C) 2010 Sergey Ilinsky (http://www.ilinsky.com) │ │ │ │ -// │ │ │ │ -// 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. │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -(function() { │ │ │ │ - │ │ │ │ - // Save reference to earlier defined object implementation (if any) │ │ │ │ - var oXMLHttpRequest = window.XMLHttpRequest; │ │ │ │ - │ │ │ │ - // Define on browser type │ │ │ │ - var bGecko = !!window.controllers, │ │ │ │ - bIE = window.document.all && !window.opera, │ │ │ │ - bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/); │ │ │ │ - │ │ │ │ - // Enables "XMLHttpRequest()" call next to "new XMLHttpReques()" │ │ │ │ - function fXMLHttpRequest() { │ │ │ │ - this._object = oXMLHttpRequest && !bIE7 ? new oXMLHttpRequest : new window.ActiveXObject("Microsoft.XMLHTTP"); │ │ │ │ - this._listeners = []; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Constructor │ │ │ │ - function cXMLHttpRequest() { │ │ │ │ - return new fXMLHttpRequest; │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype = fXMLHttpRequest.prototype; │ │ │ │ - │ │ │ │ - // BUGFIX: Firefox with Firebug installed would break pages if not executed │ │ │ │ - if (bGecko && oXMLHttpRequest.wrapped) │ │ │ │ - cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped; │ │ │ │ - │ │ │ │ - // Constants │ │ │ │ - cXMLHttpRequest.UNSENT = 0; │ │ │ │ - cXMLHttpRequest.OPENED = 1; │ │ │ │ - cXMLHttpRequest.HEADERS_RECEIVED = 2; │ │ │ │ - cXMLHttpRequest.LOADING = 3; │ │ │ │ - cXMLHttpRequest.DONE = 4; │ │ │ │ - │ │ │ │ - // Public Properties │ │ │ │ - cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - cXMLHttpRequest.prototype.responseText = ''; │ │ │ │ - cXMLHttpRequest.prototype.responseXML = null; │ │ │ │ - cXMLHttpRequest.prototype.status = 0; │ │ │ │ - cXMLHttpRequest.prototype.statusText = ''; │ │ │ │ - │ │ │ │ - // Priority proposal │ │ │ │ - cXMLHttpRequest.prototype.priority = "NORMAL"; │ │ │ │ - │ │ │ │ - // Instance-level Events Handlers │ │ │ │ - cXMLHttpRequest.prototype.onreadystatechange = null; │ │ │ │ - │ │ │ │ - // Class-level Events Handlers │ │ │ │ - cXMLHttpRequest.onreadystatechange = null; │ │ │ │ - cXMLHttpRequest.onopen = null; │ │ │ │ - cXMLHttpRequest.onsend = null; │ │ │ │ - cXMLHttpRequest.onabort = null; │ │ │ │ - │ │ │ │ - // Public Methods │ │ │ │ - cXMLHttpRequest.prototype.open = function(sMethod, sUrl, bAsync, sUser, sPassword) { │ │ │ │ - // Delete headers, required when object is reused │ │ │ │ - delete this._headers; │ │ │ │ - │ │ │ │ - // When bAsync parameter value is omitted, use true as default │ │ │ │ - if (arguments.length < 3) │ │ │ │ - bAsync = true; │ │ │ │ - │ │ │ │ - // Save async parameter for fixing Gecko bug with missing readystatechange in synchronous requests │ │ │ │ - this._async = bAsync; │ │ │ │ - │ │ │ │ - // Set the onreadystatechange handler │ │ │ │ - var oRequest = this, │ │ │ │ - nState = this.readyState, │ │ │ │ - fOnUnload; │ │ │ │ - │ │ │ │ - // BUGFIX: IE - memory leak on page unload (inter-page leak) │ │ │ │ - if (bIE && bAsync) { │ │ │ │ - fOnUnload = function() { │ │ │ │ - if (nState != cXMLHttpRequest.DONE) { │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - // Safe to abort here since onreadystatechange handler removed │ │ │ │ - oRequest.abort(); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - window.attachEvent("onunload", fOnUnload); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // Add method sniffer │ │ │ │ - if (cXMLHttpRequest.onopen) │ │ │ │ - cXMLHttpRequest.onopen.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (arguments.length > 4) │ │ │ │ - this._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ - else │ │ │ │ - if (arguments.length > 3) │ │ │ │ - this._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ - else │ │ │ │ - this._object.open(sMethod, sUrl, bAsync); │ │ │ │ - │ │ │ │ - this.readyState = cXMLHttpRequest.OPENED; │ │ │ │ - fReadyStateChange(this); │ │ │ │ - │ │ │ │ - this._object.onreadystatechange = function() { │ │ │ │ - if (bGecko && !bAsync) │ │ │ │ - return; │ │ │ │ - │ │ │ │ - // Synchronize state │ │ │ │ - oRequest.readyState = oRequest._object.readyState; │ │ │ │ - │ │ │ │ - // │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ - │ │ │ │ - // BUGFIX: Firefox fires unnecessary DONE when aborting │ │ │ │ - if (oRequest._aborted) { │ │ │ │ - // Reset readyState to UNSENT │ │ │ │ - oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - │ │ │ │ - // Return now │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ - // Free up queue │ │ │ │ - delete oRequest._data; │ │ │ │ - /* if (bAsync) │ │ │ │ - fQueue_remove(oRequest);*/ │ │ │ │ - // │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - // Uncomment this block if you need a fix for IE cache │ │ │ │ - /* │ │ │ │ - // BUGFIX: IE - cache issue │ │ │ │ - if (!oRequest._object.getResponseHeader("Date")) { │ │ │ │ - // Save object to cache │ │ │ │ - oRequest._cached = oRequest._object; │ │ │ │ - │ │ │ │ - // Instantiate a new transport object │ │ │ │ - cXMLHttpRequest.call(oRequest); │ │ │ │ - │ │ │ │ - // Re-send request │ │ │ │ - if (sUser) { │ │ │ │ - if (sPassword) │ │ │ │ - oRequest._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ - else │ │ │ │ - oRequest._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ - } │ │ │ │ - else │ │ │ │ - oRequest._object.open(sMethod, sUrl, bAsync); │ │ │ │ - oRequest._object.setRequestHeader("If-Modified-Since", oRequest._cached.getResponseHeader("Last-Modified") || new window.Date(0)); │ │ │ │ - // Copy headers set │ │ │ │ - if (oRequest._headers) │ │ │ │ - for (var sHeader in oRequest._headers) │ │ │ │ - if (typeof oRequest._headers[sHeader] == "string") // Some frameworks prototype objects with functions │ │ │ │ - oRequest._object.setRequestHeader(sHeader, oRequest._headers[sHeader]); │ │ │ │ - │ │ │ │ - oRequest._object.onreadystatechange = function() { │ │ │ │ - // Synchronize state │ │ │ │ - oRequest.readyState = oRequest._object.readyState; │ │ │ │ - │ │ │ │ - if (oRequest._aborted) { │ │ │ │ - // │ │ │ │ - oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - │ │ │ │ - // Return │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ - // Clean Object │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - │ │ │ │ - // get cached request │ │ │ │ - if (oRequest.status == 304) │ │ │ │ - oRequest._object = oRequest._cached; │ │ │ │ - │ │ │ │ - // │ │ │ │ - delete oRequest._cached; │ │ │ │ - │ │ │ │ - // │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ - │ │ │ │ - // │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ - │ │ │ │ - // BUGFIX: IE - memory leak in interrupted │ │ │ │ - if (bIE && bAsync) │ │ │ │ - window.detachEvent("onunload", fOnUnload); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - oRequest._object.send(null); │ │ │ │ - │ │ │ │ - // Return now - wait until re-sent request is finished │ │ │ │ - return; │ │ │ │ - }; │ │ │ │ - */ │ │ │ │ - // BUGFIX: IE - memory leak in interrupted │ │ │ │ - if (bIE && bAsync) │ │ │ │ - window.detachEvent("onunload", fOnUnload); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // BUGFIX: Some browsers (Internet Explorer, Gecko) fire OPEN readystate twice │ │ │ │ - if (nState != oRequest.readyState) │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ - │ │ │ │ - nState = oRequest.readyState; │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fXMLHttpRequest_send(oRequest) { │ │ │ │ - oRequest._object.send(oRequest._data); │ │ │ │ - │ │ │ │ - // BUGFIX: Gecko - missing readystatechange calls in synchronous requests │ │ │ │ - if (bGecko && !oRequest._async) { │ │ │ │ - oRequest.readyState = cXMLHttpRequest.OPENED; │ │ │ │ - │ │ │ │ - // Synchronize state │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ - │ │ │ │ - // Simulate missing states │ │ │ │ - while (oRequest.readyState < cXMLHttpRequest.DONE) { │ │ │ │ - oRequest.readyState++; │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ - // Check if we are aborted │ │ │ │ - if (oRequest._aborted) │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.send = function(vData) { │ │ │ │ - // Add method sniffer │ │ │ │ - if (cXMLHttpRequest.onsend) │ │ │ │ - cXMLHttpRequest.onsend.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (!arguments.length) │ │ │ │ - vData = null; │ │ │ │ - │ │ │ │ - // BUGFIX: Safari - fails sending documents created/modified dynamically, so an explicit serialization required │ │ │ │ - // BUGFIX: IE - rewrites any custom mime-type to "text/xml" in case an XMLNode is sent │ │ │ │ - // BUGFIX: Gecko - fails sending Element (this is up to the implementation either to standard) │ │ │ │ - if (vData && vData.nodeType) { │ │ │ │ - vData = window.XMLSerializer ? new window.XMLSerializer().serializeToString(vData) : vData.xml; │ │ │ │ - if (!this._headers["Content-Type"]) │ │ │ │ - this._object.setRequestHeader("Content-Type", "application/xml"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this._data = vData; │ │ │ │ - /* │ │ │ │ - // Add to queue │ │ │ │ - if (this._async) │ │ │ │ - fQueue_add(this); │ │ │ │ - else*/ │ │ │ │ - fXMLHttpRequest_send(this); │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.abort = function() { │ │ │ │ - // Add method sniffer │ │ │ │ - if (cXMLHttpRequest.onabort) │ │ │ │ - cXMLHttpRequest.onabort.apply(this, arguments); │ │ │ │ - │ │ │ │ - // BUGFIX: Gecko - unnecessary DONE when aborting │ │ │ │ - if (this.readyState > cXMLHttpRequest.UNSENT) │ │ │ │ - this._aborted = true; │ │ │ │ - │ │ │ │ - this._object.abort(); │ │ │ │ - │ │ │ │ - // BUGFIX: IE - memory leak │ │ │ │ - fCleanTransport(this); │ │ │ │ - │ │ │ │ - this.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - │ │ │ │ - delete this._data; │ │ │ │ - /* if (this._async) │ │ │ │ - fQueue_remove(this);*/ │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.getAllResponseHeaders = function() { │ │ │ │ - return this._object.getAllResponseHeaders(); │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.getResponseHeader = function(sName) { │ │ │ │ - return this._object.getResponseHeader(sName); │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) { │ │ │ │ - // BUGFIX: IE - cache issue │ │ │ │ - if (!this._headers) │ │ │ │ - this._headers = {}; │ │ │ │ - this._headers[sName] = sValue; │ │ │ │ - │ │ │ │ - return this._object.setRequestHeader(sName, sValue); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // EventTarget interface implementation │ │ │ │ - cXMLHttpRequest.prototype.addEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ - return; │ │ │ │ - // Add listener │ │ │ │ - this._listeners.push([sName, fHandler, bUseCapture]); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - cXMLHttpRequest.prototype.removeEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ - break; │ │ │ │ - // Remove listener │ │ │ │ - if (oListener) │ │ │ │ - this._listeners.splice(nIndex, 1); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) { │ │ │ │ - var oEventPseudo = { │ │ │ │ - 'type': oEvent.type, │ │ │ │ - 'target': this, │ │ │ │ - 'currentTarget': this, │ │ │ │ - 'eventPhase': 2, │ │ │ │ - 'bubbles': oEvent.bubbles, │ │ │ │ - 'cancelable': oEvent.cancelable, │ │ │ │ - 'timeStamp': oEvent.timeStamp, │ │ │ │ - 'stopPropagation': function() {}, // There is no flow │ │ │ │ - 'preventDefault': function() {}, // There is no default action │ │ │ │ - 'initEvent': function() {} // Original event object should be initialized │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Execute onreadystatechange │ │ │ │ - if (oEventPseudo.type == "readystatechange" && this.onreadystatechange) │ │ │ │ - (this.onreadystatechange.handleEvent || this.onreadystatechange).apply(this, [oEventPseudo]); │ │ │ │ - │ │ │ │ - // Execute listeners │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == oEventPseudo.type && !oListener[2]) │ │ │ │ - (oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // │ │ │ │ - cXMLHttpRequest.prototype.toString = function() { │ │ │ │ - return '[' + "object" + ' ' + "XMLHttpRequest" + ']'; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - cXMLHttpRequest.toString = function() { │ │ │ │ - return '[' + "XMLHttpRequest" + ']'; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Helper function │ │ │ │ - function fReadyStateChange(oRequest) { │ │ │ │ - // Sniffing code │ │ │ │ - if (cXMLHttpRequest.onreadystatechange) │ │ │ │ - cXMLHttpRequest.onreadystatechange.apply(oRequest); │ │ │ │ - │ │ │ │ - // Fake event │ │ │ │ - oRequest.dispatchEvent({ │ │ │ │ - 'type': "readystatechange", │ │ │ │ - 'bubbles': false, │ │ │ │ - 'cancelable': false, │ │ │ │ - 'timeStamp': new Date + 0 │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fGetDocument(oRequest) { │ │ │ │ - var oDocument = oRequest.responseXML, │ │ │ │ - sResponse = oRequest.responseText; │ │ │ │ - // Try parsing responseText │ │ │ │ - if (bIE && sResponse && oDocument && !oDocument.documentElement && oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)) { │ │ │ │ - oDocument = new window.ActiveXObject("Microsoft.XMLDOM"); │ │ │ │ - oDocument.async = false; │ │ │ │ - oDocument.validateOnParse = false; │ │ │ │ - oDocument.loadXML(sResponse); │ │ │ │ - } │ │ │ │ - // Check if there is no error in document │ │ │ │ - if (oDocument) │ │ │ │ - if ((bIE && oDocument.parseError != 0) || !oDocument.documentElement || (oDocument.documentElement && oDocument.documentElement.tagName == "parsererror")) │ │ │ │ - return null; │ │ │ │ - return oDocument; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fSynchronizeValues(oRequest) { │ │ │ │ - try { │ │ │ │ - oRequest.responseText = oRequest._object.responseText; │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.responseXML = fGetDocument(oRequest._object); │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.status = oRequest._object.status; │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.statusText = oRequest._object.statusText; │ │ │ │ - } catch (e) {} │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fCleanTransport(oRequest) { │ │ │ │ - // BUGFIX: IE - memory leak (on-page leak) │ │ │ │ - oRequest._object.onreadystatechange = new window.Function; │ │ │ │ - }; │ │ │ │ - /* │ │ │ │ - // Queue manager │ │ │ │ - var oQueuePending = {"CRITICAL":[],"HIGH":[],"NORMAL":[],"LOW":[],"LOWEST":[]}, │ │ │ │ - aQueueRunning = []; │ │ │ │ - function fQueue_add(oRequest) { │ │ │ │ - oQueuePending[oRequest.priority in oQueuePending ? oRequest.priority : "NORMAL"].push(oRequest); │ │ │ │ - // │ │ │ │ - setTimeout(fQueue_process); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fQueue_remove(oRequest) { │ │ │ │ - for (var nIndex = 0, bFound = false; nIndex < aQueueRunning.length; nIndex++) │ │ │ │ - if (bFound) │ │ │ │ - aQueueRunning[nIndex - 1] = aQueueRunning[nIndex]; │ │ │ │ - else │ │ │ │ - if (aQueueRunning[nIndex] == oRequest) │ │ │ │ - bFound = true; │ │ │ │ - if (bFound) │ │ │ │ - aQueueRunning.length--; │ │ │ │ - // │ │ │ │ - setTimeout(fQueue_process); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fQueue_process() { │ │ │ │ - if (aQueueRunning.length < 6) { │ │ │ │ - for (var sPriority in oQueuePending) { │ │ │ │ - if (oQueuePending[sPriority].length) { │ │ │ │ - var oRequest = oQueuePending[sPriority][0]; │ │ │ │ - oQueuePending[sPriority] = oQueuePending[sPriority].slice(1); │ │ │ │ - // │ │ │ │ - aQueueRunning.push(oRequest); │ │ │ │ - // Send request │ │ │ │ - fXMLHttpRequest_send(oRequest); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - */ │ │ │ │ - // Internet Explorer 5.0 (missing apply) │ │ │ │ - if (!window.Function.prototype.apply) { │ │ │ │ - window.Function.prototype.apply = function(oRequest, oArguments) { │ │ │ │ - if (!oArguments) │ │ │ │ - oArguments = []; │ │ │ │ - oRequest.__func = this; │ │ │ │ - oRequest.__func(oArguments[0], oArguments[1], oArguments[2], oArguments[3], oArguments[4]); │ │ │ │ - delete oRequest.__func; │ │ │ │ - }; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Register new object with window │ │ │ │ - /** │ │ │ │ - * Class: OpenLayers.Request.XMLHttpRequest │ │ │ │ - * Standard-compliant (W3C) cross-browser implementation of the │ │ │ │ - * XMLHttpRequest object. From │ │ │ │ - * http://code.google.com/p/xmlhttprequest/. │ │ │ │ - */ │ │ │ │ - if (!OpenLayers.Request) { │ │ │ │ - /** │ │ │ │ - * This allows for OpenLayers/Request.js to be included │ │ │ │ - * before or after this script. │ │ │ │ - */ │ │ │ │ - OpenLayers.Request = {}; │ │ │ │ - } │ │ │ │ - OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest; │ │ │ │ -})(); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Request.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * TODO: deprecate me │ │ │ │ - * Use OpenLayers.Request.proxy instead. │ │ │ │ - */ │ │ │ │ -OpenLayers.ProxyHost = ""; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Request │ │ │ │ - * The OpenLayers.Request namespace contains convenience methods for working │ │ │ │ - * with XMLHttpRequests. These methods work with a cross-browser │ │ │ │ - * W3C compliant class. │ │ │ │ - */ │ │ │ │ -if (!OpenLayers.Request) { │ │ │ │ - /** │ │ │ │ - * This allows for OpenLayers/Request/XMLHttpRequest.js to be included │ │ │ │ - * before or after this script. │ │ │ │ - */ │ │ │ │ - OpenLayers.Request = {}; │ │ │ │ -} │ │ │ │ -OpenLayers.Util.extend(OpenLayers.Request, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_CONFIG │ │ │ │ - * {Object} Default configuration for all requests. │ │ │ │ - */ │ │ │ │ - DEFAULT_CONFIG: { │ │ │ │ - method: "GET", │ │ │ │ - url: window.location.href, │ │ │ │ - async: true, │ │ │ │ - user: undefined, │ │ │ │ - password: undefined, │ │ │ │ - params: null, │ │ │ │ - proxy: OpenLayers.ProxyHost, │ │ │ │ - headers: {}, │ │ │ │ - data: null, │ │ │ │ - callback: function() {}, │ │ │ │ - success: null, │ │ │ │ - failure: null, │ │ │ │ - scope: null │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: URL_SPLIT_REGEX │ │ │ │ - */ │ │ │ │ - URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {} An events object that handles all │ │ │ │ - * events on the {} object. │ │ │ │ - * │ │ │ │ - * All event listeners will receive an event object with three properties: │ │ │ │ - * request - {} The request object. │ │ │ │ - * config - {Object} The config object sent to the specific request method. │ │ │ │ - * requestUrl - {String} The request url. │ │ │ │ - * │ │ │ │ - * Supported event types: │ │ │ │ - * complete - Triggered when we have a response from the request, if a │ │ │ │ - * listener returns false, no further response processing will take │ │ │ │ - * place. │ │ │ │ - * success - Triggered when the HTTP response has a success code (200-299). │ │ │ │ - * failure - Triggered when the HTTP response does not have a success code. │ │ │ │ - */ │ │ │ │ - events: new OpenLayers.Events(this), │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: makeSameOrigin │ │ │ │ - * Using the specified proxy, returns a same origin url of the provided url. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * url - {String} An arbitrary url │ │ │ │ - * proxy {String|Function} The proxy to use to make the provided url a │ │ │ │ - * same origin url. │ │ │ │ - * │ │ │ │ - * Returns │ │ │ │ - * {String} the same origin url. If no proxy is provided, the returned url │ │ │ │ - * will be the same as the provided url. │ │ │ │ - */ │ │ │ │ - makeSameOrigin: function(url, proxy) { │ │ │ │ - var sameOrigin = url.indexOf("http") !== 0; │ │ │ │ - var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX); │ │ │ │ - if (urlParts) { │ │ │ │ - var location = window.location; │ │ │ │ - sameOrigin = │ │ │ │ - urlParts[1] == location.protocol && │ │ │ │ - urlParts[3] == location.hostname; │ │ │ │ - var uPort = urlParts[4], │ │ │ │ - lPort = location.port; │ │ │ │ - if (uPort != 80 && uPort != "" || lPort != "80" && lPort != "") { │ │ │ │ - sameOrigin = sameOrigin && uPort == lPort; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!sameOrigin) { │ │ │ │ - if (proxy) { │ │ │ │ - if (typeof proxy == "function") { │ │ │ │ - url = proxy(url); │ │ │ │ - } else { │ │ │ │ - url = proxy + encodeURIComponent(url); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return url; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: issue │ │ │ │ - * Create a new XMLHttpRequest object, open it, set any headers, bind │ │ │ │ - * a callback to done state, and send any data. It is recommended that │ │ │ │ - * you use one , , , , , or . │ │ │ │ - * This method is only documented to provide detail on the configuration │ │ │ │ - * options available to all request methods. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object containing properties for configuring the │ │ │ │ - * request. Allowed configuration properties are described below. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Allowed config properties: │ │ │ │ - * method - {String} One of GET, POST, PUT, DELETE, HEAD, or │ │ │ │ - * OPTIONS. Default is GET. │ │ │ │ - * url - {String} URL for the request. │ │ │ │ - * async - {Boolean} Open an asynchronous request. Default is true. │ │ │ │ - * user - {String} User for relevant authentication scheme. Set │ │ │ │ - * to null to clear current user. │ │ │ │ - * password - {String} Password for relevant authentication scheme. │ │ │ │ - * Set to null to clear current password. │ │ │ │ - * proxy - {String} Optional proxy. Defaults to │ │ │ │ - * . │ │ │ │ - * params - {Object} Any key:value pairs to be appended to the │ │ │ │ - * url as a query string. Assumes url doesn't already include a query │ │ │ │ - * string or hash. Typically, this is only appropriate for │ │ │ │ - * requests where the query string will be appended to the url. │ │ │ │ - * Parameter values that are arrays will be │ │ │ │ - * concatenated with a comma (note that this goes against form-encoding) │ │ │ │ - * as is done with . │ │ │ │ - * headers - {Object} Object with header:value pairs to be set on │ │ │ │ - * the request. │ │ │ │ - * data - {String | Document} Optional data to send with the request. │ │ │ │ - * Typically, this is only used with and requests. │ │ │ │ - * Make sure to provide the appropriate "Content-Type" header for your │ │ │ │ - * data. For and requests, the content type defaults to │ │ │ │ - * "application-xml". If your data is a different content type, or │ │ │ │ - * if you are using a different HTTP method, set the "Content-Type" │ │ │ │ - * header to match your data type. │ │ │ │ - * callback - {Function} Function to call when request is done. │ │ │ │ - * To determine if the request failed, check request.status (200 │ │ │ │ - * indicates success). │ │ │ │ - * success - {Function} Optional function to call if request status is in │ │ │ │ - * the 200s. This will be called in addition to callback above and │ │ │ │ - * would typically only be used as an alternative. │ │ │ │ - * failure - {Function} Optional function to call if request status is not │ │ │ │ - * in the 200s. This will be called in addition to callback above and │ │ │ │ - * would typically only be used as an alternative. │ │ │ │ - * scope - {Object} If callback is a public method on some object, │ │ │ │ - * set the scope to that object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. To abort the request before a response │ │ │ │ - * is received, call abort() on the request object. │ │ │ │ - */ │ │ │ │ - issue: function(config) { │ │ │ │ - // apply default config - proxy host may have changed │ │ │ │ - var defaultConfig = OpenLayers.Util.extend( │ │ │ │ - this.DEFAULT_CONFIG, { │ │ │ │ - proxy: OpenLayers.ProxyHost │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - config = config || {}; │ │ │ │ - config.headers = config.headers || {}; │ │ │ │ - config = OpenLayers.Util.applyDefaults(config, defaultConfig); │ │ │ │ - config.headers = OpenLayers.Util.applyDefaults(config.headers, defaultConfig.headers); │ │ │ │ - // Always set the "X-Requested-With" header to signal that this request │ │ │ │ - // was issued through the XHR-object. Since header keys are case │ │ │ │ - // insensitive and we want to allow overriding of the "X-Requested-With" │ │ │ │ - // header through the user we cannot use applyDefaults, but have to │ │ │ │ - // check manually whether we were called with a "X-Requested-With" │ │ │ │ - // header. │ │ │ │ - var customRequestedWithHeader = false, │ │ │ │ - headerKey; │ │ │ │ - for (headerKey in config.headers) { │ │ │ │ - if (config.headers.hasOwnProperty(headerKey)) { │ │ │ │ - if (headerKey.toLowerCase() === 'x-requested-with') { │ │ │ │ - customRequestedWithHeader = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (customRequestedWithHeader === false) { │ │ │ │ - // we did not have a custom "X-Requested-With" header │ │ │ │ - config.headers['X-Requested-With'] = 'XMLHttpRequest'; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // create request, open, and set headers │ │ │ │ - var request = new OpenLayers.Request.XMLHttpRequest(); │ │ │ │ - var url = OpenLayers.Util.urlAppend(config.url, │ │ │ │ - OpenLayers.Util.getParameterString(config.params || {})); │ │ │ │ - url = OpenLayers.Request.makeSameOrigin(url, config.proxy); │ │ │ │ - request.open( │ │ │ │ - config.method, url, config.async, config.user, config.password │ │ │ │ - ); │ │ │ │ - for (var header in config.headers) { │ │ │ │ - request.setRequestHeader(header, config.headers[header]); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var events = this.events; │ │ │ │ - │ │ │ │ - // we want to execute runCallbacks with "this" as the │ │ │ │ - // execution scope │ │ │ │ - var self = this; │ │ │ │ - │ │ │ │ - request.onreadystatechange = function() { │ │ │ │ - if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) { │ │ │ │ - var proceed = events.triggerEvent( │ │ │ │ - "complete", { │ │ │ │ - request: request, │ │ │ │ - config: config, │ │ │ │ - requestUrl: url │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - if (proceed !== false) { │ │ │ │ - self.runCallbacks({ │ │ │ │ - request: request, │ │ │ │ - config: config, │ │ │ │ - requestUrl: url │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // send request (optionally with data) and return │ │ │ │ - // call in a timeout for asynchronous requests so the return is │ │ │ │ - // available before readyState == 4 for cached docs │ │ │ │ - if (config.async === false) { │ │ │ │ - request.send(config.data); │ │ │ │ - } else { │ │ │ │ - window.setTimeout(function() { │ │ │ │ - if (request.readyState !== 0) { // W3C: 0-UNSENT │ │ │ │ - request.send(config.data); │ │ │ │ - } │ │ │ │ - }, 0); │ │ │ │ - } │ │ │ │ - return request; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: runCallbacks │ │ │ │ - * Calls the complete, success and failure callbacks. Application │ │ │ │ - * can listen to the "complete" event, have the listener │ │ │ │ - * display a confirm window and always return false, and │ │ │ │ - * execute OpenLayers.Request.runCallbacks if the user │ │ │ │ - * hits "yes" in the confirm window. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Hash containing request, config and requestUrl keys │ │ │ │ - */ │ │ │ │ - runCallbacks: function(options) { │ │ │ │ - var request = options.request; │ │ │ │ - var config = options.config; │ │ │ │ - │ │ │ │ - // bind callbacks to readyState 4 (done) │ │ │ │ - var complete = (config.scope) ? │ │ │ │ - OpenLayers.Function.bind(config.callback, config.scope) : │ │ │ │ - config.callback; │ │ │ │ - │ │ │ │ - // optional success callback │ │ │ │ - var success; │ │ │ │ - if (config.success) { │ │ │ │ - success = (config.scope) ? │ │ │ │ - OpenLayers.Function.bind(config.success, config.scope) : │ │ │ │ - config.success; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // optional failure callback │ │ │ │ - var failure; │ │ │ │ - if (config.failure) { │ │ │ │ - failure = (config.scope) ? │ │ │ │ - OpenLayers.Function.bind(config.failure, config.scope) : │ │ │ │ - config.failure; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (OpenLayers.Util.createUrlObject(config.url).protocol == "file:" && │ │ │ │ - request.responseText) { │ │ │ │ - request.status = 200; │ │ │ │ - } │ │ │ │ - complete(request); │ │ │ │ - │ │ │ │ - if (!request.status || (request.status >= 200 && request.status < 300)) { │ │ │ │ - this.events.triggerEvent("success", options); │ │ │ │ - if (success) { │ │ │ │ - success(request); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ - this.events.triggerEvent("failure", options); │ │ │ │ - if (failure) { │ │ │ │ - failure(request); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: GET │ │ │ │ - * Send an HTTP GET request. Additional configuration properties are │ │ │ │ - * documented in the method, with the method property set │ │ │ │ - * to GET. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ - */ │ │ │ │ - GET: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "GET" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: POST │ │ │ │ - * Send a POST request. Additional configuration properties are │ │ │ │ - * documented in the method, with the method property set │ │ │ │ - * to POST and "Content-Type" header set to "application/xml". │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the method for documentation of allowed properties. The │ │ │ │ - * default "Content-Type" header will be set to "application-xml" if │ │ │ │ - * none is provided. This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ - */ │ │ │ │ - POST: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "POST" │ │ │ │ - }); │ │ │ │ - // set content type to application/xml if it isn't already set │ │ │ │ - config.headers = config.headers ? config.headers : {}; │ │ │ │ - if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ - config.headers["Content-Type"] = "application/xml"; │ │ │ │ - } │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: PUT │ │ │ │ - * Send an HTTP PUT request. Additional configuration properties are │ │ │ │ - * documented in the method, with the method property set │ │ │ │ - * to PUT and "Content-Type" header set to "application/xml". │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the method for documentation of allowed properties. The │ │ │ │ - * default "Content-Type" header will be set to "application-xml" if │ │ │ │ - * none is provided. This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ - */ │ │ │ │ - PUT: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "PUT" │ │ │ │ - }); │ │ │ │ - // set content type to application/xml if it isn't already set │ │ │ │ - config.headers = config.headers ? config.headers : {}; │ │ │ │ - if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ - config.headers["Content-Type"] = "application/xml"; │ │ │ │ - } │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: DELETE │ │ │ │ - * Send an HTTP DELETE request. Additional configuration properties are │ │ │ │ - * documented in the method, with the method property set │ │ │ │ - * to DELETE. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ - */ │ │ │ │ - DELETE: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "DELETE" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: HEAD │ │ │ │ - * Send an HTTP HEAD request. Additional configuration properties are │ │ │ │ - * documented in the method, with the method property set │ │ │ │ - * to HEAD. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ - */ │ │ │ │ - HEAD: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "HEAD" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: OPTIONS │ │ │ │ - * Send an HTTP OPTIONS request. Additional configuration properties are │ │ │ │ - * documented in the method, with the method property set │ │ │ │ - * to OPTIONS. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ - */ │ │ │ │ - OPTIONS: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "OPTIONS" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - } │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/WPSProcess.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -30102,374 +29419,763 @@ │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.WPSProcess.ChainLink" │ │ │ │ │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Spherical.js │ │ │ │ + OpenLayers/Marker.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/Icon.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Namespace: Spherical │ │ │ │ - * The OpenLayers.Spherical namespace includes utility functions for │ │ │ │ - * calculations on the basis of a spherical earth (ignoring ellipsoidal │ │ │ │ - * effects), which is accurate enough for most purposes. │ │ │ │ + * Class: OpenLayers.Marker │ │ │ │ + * Instances of OpenLayers.Marker are a combination of a │ │ │ │ + * and an . │ │ │ │ * │ │ │ │ - * Relevant links: │ │ │ │ - * * http://www.movable-type.co.uk/scripts/latlong.html │ │ │ │ - * * http://code.google.com/apis/maps/documentation/javascript/reference.html#spherical │ │ │ │ + * 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(21,25); │ │ │ │ + * var offset = new OpenLayers.Pixel(-(size.w/2), -size.h); │ │ │ │ + * var icon = new OpenLayers.Icon('http://www.openlayers.org/dev/img/marker.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({ │ │ │ │ │ │ │ │ -OpenLayers.Spherical = OpenLayers.Spherical || {}; │ │ │ │ + /** │ │ │ │ + * Property: icon │ │ │ │ + * {} The icon used by this marker. │ │ │ │ + */ │ │ │ │ + icon: null, │ │ │ │ │ │ │ │ -OpenLayers.Spherical.DEFAULT_RADIUS = 6378137; │ │ │ │ + /** │ │ │ │ + * Property: lonlat │ │ │ │ + * {} location of object │ │ │ │ + */ │ │ │ │ + lonlat: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * APIFunction: computeDistanceBetween │ │ │ │ - * Computes the distance between two LonLats. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * from - {} or {Object} Starting point. A LonLat or │ │ │ │ - * a JavaScript literal with lon lat properties. │ │ │ │ - * to - {} or {Object} Ending point. A LonLat or a │ │ │ │ - * JavaScript literal with lon lat properties. │ │ │ │ - * radius - {Float} The radius. Optional. Defaults to 6378137 meters. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The distance in meters. │ │ │ │ - */ │ │ │ │ -OpenLayers.Spherical.computeDistanceBetween = function(from, to, radius) { │ │ │ │ - var R = radius || OpenLayers.Spherical.DEFAULT_RADIUS; │ │ │ │ - var sinHalfDeltaLon = Math.sin(Math.PI * (to.lon - from.lon) / 360); │ │ │ │ - var sinHalfDeltaLat = Math.sin(Math.PI * (to.lat - from.lat) / 360); │ │ │ │ - var a = sinHalfDeltaLat * sinHalfDeltaLat + │ │ │ │ - sinHalfDeltaLon * sinHalfDeltaLon * Math.cos(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ - return 2 * R * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); │ │ │ │ -}; │ │ │ │ + /** │ │ │ │ + * Property: events │ │ │ │ + * {} the event handler. │ │ │ │ + */ │ │ │ │ + events: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: map │ │ │ │ + * {} the map this marker is attached to │ │ │ │ + */ │ │ │ │ + map: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Marker │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lonlat - {} the position of this marker │ │ │ │ + * icon - {} the icon for 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); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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() { │ │ │ │ + // erase any drawn features │ │ │ │ + this.erase(); │ │ │ │ + │ │ │ │ + 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: erase │ │ │ │ + * Erases any drawn elements for this marker. │ │ │ │ + */ │ │ │ │ + erase: function() { │ │ │ │ + if (this.icon != null) { │ │ │ │ + this.icon.erase(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: moveTo │ │ │ │ + * Move the marker to the new location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {|Object} the pixel position to move to. │ │ │ │ + * An OpenLayers.Pixel or an object with a 'x' and 'y' properties. │ │ │ │ + */ │ │ │ │ + moveTo: function(px) { │ │ │ │ + if ((px != null) && (this.icon != null)) { │ │ │ │ + this.icon.moveTo(px); │ │ │ │ + } │ │ │ │ + this.lonlat = this.map.getLonLatFromLayerPx(px); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: isDrawn │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the marker is drawn. │ │ │ │ + */ │ │ │ │ + isDrawn: function() { │ │ │ │ + var isDrawn = (this.icon && this.icon.isDrawn()); │ │ │ │ + return isDrawn; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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) { │ │ │ │ + this.icon.setSize({ │ │ │ │ + w: this.icon.size.w * inflate, │ │ │ │ + h: this.icon.size.h * inflate │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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" │ │ │ │ +}); │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIFunction: computeHeading │ │ │ │ - * Computes the heading from one LonLat to another LonLat. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * from - {} or {Object} Starting point. A LonLat or │ │ │ │ - * a JavaScript literal with lon lat properties. │ │ │ │ - * to - {} or {Object} Ending point. A LonLat or a │ │ │ │ - * JavaScript literal with lon lat properties. │ │ │ │ - * │ │ │ │ + * Function: defaultIcon │ │ │ │ + * Creates a default . │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Float} The heading in degrees. │ │ │ │ + * {} A default OpenLayers.Icon to use for a marker │ │ │ │ */ │ │ │ │ -OpenLayers.Spherical.computeHeading = function(from, to) { │ │ │ │ - var y = Math.sin(Math.PI * (from.lon - to.lon) / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ - var x = Math.cos(Math.PI * from.lat / 180) * Math.sin(Math.PI * to.lat / 180) - │ │ │ │ - Math.sin(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180) * Math.cos(Math.PI * (from.lon - to.lon) / 180); │ │ │ │ - return 180 * Math.atan2(y, x) / Math.PI; │ │ │ │ +OpenLayers.Marker.defaultIcon = function() { │ │ │ │ + return new OpenLayers.Icon(OpenLayers.Util.getImageLocation("marker.png"), { │ │ │ │ + w: 21, │ │ │ │ + h: 25 │ │ │ │ + }, { │ │ │ │ + x: -10.5, │ │ │ │ + y: -25 │ │ │ │ + }); │ │ │ │ }; │ │ │ │ + │ │ │ │ + │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol.js │ │ │ │ + OpenLayers/Control.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol │ │ │ │ - * Abstract vector layer protocol class. Not to be instantiated directly. Use │ │ │ │ - * one of the protocol subclasses instead. │ │ │ │ + * Class: OpenLayers.Control │ │ │ │ + * Controls affect the display or behavior of the map. They allow everything │ │ │ │ + * from panning and zooming to displaying a scale indicator. Controls by │ │ │ │ + * default are added to the map they are contained within however it is │ │ │ │ + * possible to add a control to an external div by passing the div in the │ │ │ │ + * options parameter. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * The following example shows how to add many of the common controls │ │ │ │ + * to a map. │ │ │ │ + * │ │ │ │ + * > var map = new OpenLayers.Map('map', { controls: [] }); │ │ │ │ + * > │ │ │ │ + * > map.addControl(new OpenLayers.Control.PanZoomBar()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false})); │ │ │ │ + * > map.addControl(new OpenLayers.Control.Permalink()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.Permalink('permalink')); │ │ │ │ + * > map.addControl(new OpenLayers.Control.MousePosition()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.OverviewMap()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.KeyboardDefaults()); │ │ │ │ + * │ │ │ │ + * The next code fragment is a quick example of how to intercept │ │ │ │ + * shift-mouse click to display the extent of the bounding box │ │ │ │ + * dragged out by the user. Usually controls are not created │ │ │ │ + * in exactly this manner. See the source for a more complete │ │ │ │ + * example: │ │ │ │ + * │ │ │ │ + * > var control = new OpenLayers.Control(); │ │ │ │ + * > OpenLayers.Util.extend(control, { │ │ │ │ + * > draw: function () { │ │ │ │ + * > // this Handler.Box will intercept the shift-mousedown │ │ │ │ + * > // before Control.MouseDefault gets to see it │ │ │ │ + * > this.box = new OpenLayers.Handler.Box( control, │ │ │ │ + * > {"done": this.notice}, │ │ │ │ + * > {keyMask: OpenLayers.Handler.MOD_SHIFT}); │ │ │ │ + * > this.box.activate(); │ │ │ │ + * > }, │ │ │ │ + * > │ │ │ │ + * > notice: function (bounds) { │ │ │ │ + * > OpenLayers.Console.userError(bounds); │ │ │ │ + * > } │ │ │ │ + * > }); │ │ │ │ + * > map.addControl(control); │ │ │ │ + * │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol = OpenLayers.Class({ │ │ │ │ +OpenLayers.Control = OpenLayers.Class({ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: format │ │ │ │ - * {} The format used by this protocol. │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - format: null, │ │ │ │ + id: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: map │ │ │ │ + * {} this gets set in the addControl() function in │ │ │ │ + * OpenLayers.Map │ │ │ │ + */ │ │ │ │ + map: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: div │ │ │ │ + * {DOMElement} The element that contains the control, if not present the │ │ │ │ + * control is placed inside the map. │ │ │ │ + */ │ │ │ │ + div: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {Number} Controls can have a 'type'. The type determines the type of │ │ │ │ + * interactions which are possible with them when they are placed in an │ │ │ │ + * . │ │ │ │ + */ │ │ │ │ + type: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: allowSelection │ │ │ │ + * {Boolean} By default, 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: options │ │ │ │ - * {Object} Any options sent to the constructor. │ │ │ │ + * APIProperty: title │ │ │ │ + * {string} This property is used for showing a tooltip over the │ │ │ │ + * Control. │ │ │ │ */ │ │ │ │ - options: null, │ │ │ │ + title: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: autoDestroy │ │ │ │ - * {Boolean} The creator of the protocol can set autoDestroy to false │ │ │ │ - * to fully control when the protocol is destroyed. Defaults to │ │ │ │ - * true. │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * false. │ │ │ │ */ │ │ │ │ - autoDestroy: true, │ │ │ │ + autoActivate: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: active │ │ │ │ + * {Boolean} The control is active (read-only). Use and │ │ │ │ + * to change control state. │ │ │ │ + */ │ │ │ │ + active: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultFilter │ │ │ │ - * {} Optional default filter to read requests │ │ │ │ + * Property: handlerOptions │ │ │ │ + * {Object} Used to set non-default properties on the control's handler │ │ │ │ */ │ │ │ │ - defaultFilter: null, │ │ │ │ + handlerOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: handler │ │ │ │ + * {} null │ │ │ │ + */ │ │ │ │ + handler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol │ │ │ │ - * Abstract class for vector protocols. Create instances of a subclass. │ │ │ │ + * 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, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options; │ │ │ │ - }, │ │ │ │ + events: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mergeWithDefaultFilter │ │ │ │ - * Merge filter passed to the read method with the default one │ │ │ │ + * 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: │ │ │ │ - * filter - {} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - mergeWithDefaultFilter: function(filter) { │ │ │ │ - var merged; │ │ │ │ - if (filter && this.defaultFilter) { │ │ │ │ - merged = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.defaultFilter, filter] │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - merged = filter || this.defaultFilter || undefined; │ │ │ │ + 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); │ │ │ │ + if (this.eventListeners instanceof Object) { │ │ │ │ + this.events.on(this.eventListeners); │ │ │ │ + } │ │ │ │ + if (this.id == null) { │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ } │ │ │ │ - return merged; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * 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() { │ │ │ │ - this.options = null; │ │ │ │ - this.format = null; │ │ │ │ + if (this.events) { │ │ │ │ + if (this.eventListeners) { │ │ │ │ + this.events.un(this.eventListeners); │ │ │ │ + } │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ + } │ │ │ │ + this.eventListeners = null; │ │ │ │ + │ │ │ │ + // eliminate circular references │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.destroy(); │ │ │ │ + this.handler = null; │ │ │ │ + } │ │ │ │ + if (this.handlers) { │ │ │ │ + for (var key in this.handlers) { │ │ │ │ + if (this.handlers.hasOwnProperty(key) && │ │ │ │ + typeof this.handlers[key].destroy == "function") { │ │ │ │ + this.handlers[key].destroy(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.handlers = null; │ │ │ │ + } │ │ │ │ + if (this.map) { │ │ │ │ + this.map.removeControl(this); │ │ │ │ + this.map = null; │ │ │ │ + } │ │ │ │ + this.div = null; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new features. │ │ │ │ + /** │ │ │ │ + * 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: │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} An │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * map - {} │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.filter = this.mergeWithDefaultFilter(options.filter); │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.setMap(map); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: create │ │ │ │ - * Construct a request for writing newly created features. │ │ │ │ + * 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: │ │ │ │ - * features - {Array({})} or │ │ │ │ - * {} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ + * px - {} The top-left pixel position of the control │ │ │ │ + * or null. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {} An │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ */ │ │ │ │ - create: function() {}, │ │ │ │ + draw: function(px) { │ │ │ │ + if (this.div == null) { │ │ │ │ + this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ + this.div.className = this.displayClass; │ │ │ │ + if (!this.allowSelection) { │ │ │ │ + this.div.className += " olControlNoSelect"; │ │ │ │ + this.div.setAttribute("unselectable", "on", 0); │ │ │ │ + this.div.onselectstart = OpenLayers.Function.False; │ │ │ │ + } │ │ │ │ + if (this.title != "") { │ │ │ │ + this.div.title = this.title; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (px != null) { │ │ │ │ + this.position = px.clone(); │ │ │ │ + } │ │ │ │ + this.moveTo(this.position); │ │ │ │ + return this.div; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: update │ │ │ │ - * Construct a request updating modified features. │ │ │ │ + * Method: moveTo │ │ │ │ + * Sets the left and top style attributes to the passed in pixel │ │ │ │ + * coordinates. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({})} or │ │ │ │ - * {} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} An │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * px - {} │ │ │ │ */ │ │ │ │ - update: function() {}, │ │ │ │ + moveTo: function(px) { │ │ │ │ + if ((px != null) && (this.div != null)) { │ │ │ │ + this.div.style.left = px.x + "px"; │ │ │ │ + this.div.style.top = px.y + "px"; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: delete │ │ │ │ - * Construct a request deleting a removed feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * │ │ │ │ + * APIMethod: activate │ │ │ │ + * Explicitly activates a control and it's associated │ │ │ │ + * handler if one has been set. Controls can be │ │ │ │ + * deactivated by calling the deactivate() method. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {} An │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * {Boolean} True if the control was successfully activated or │ │ │ │ + * false if the control was already active. │ │ │ │ */ │ │ │ │ - "delete": function() {}, │ │ │ │ + activate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.activate(); │ │ │ │ + } │ │ │ │ + this.active = true; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.addClass( │ │ │ │ + this.map.viewPortDiv, │ │ │ │ + this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("activate"); │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: commit │ │ │ │ - * Go over the features and for each take action │ │ │ │ - * based on the feature state. Possible actions are create, │ │ │ │ - * update and delete. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array({})} │ │ │ │ - * options - {Object} Object whose possible keys are "create", "update", │ │ │ │ - * "delete", "callback" and "scope", the values referenced by the │ │ │ │ - * first three are objects as passed to the "create", "update", and │ │ │ │ - * "delete" methods, the value referenced by the "callback" key is │ │ │ │ - * a function which is called when the commit operation is complete │ │ │ │ - * using the scope referenced by the "scope" key. │ │ │ │ - * │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivates a control and it's associated handler if any. The exact │ │ │ │ + * effect of this depends on the control itself. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Array({})} An array of │ │ │ │ - * objects. │ │ │ │ - */ │ │ │ │ - commit: function() {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: abort │ │ │ │ - * Abort an ongoing request. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * response - {} │ │ │ │ - */ │ │ │ │ - abort: function(response) {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createCallback │ │ │ │ - * Returns a function that applies the given public method with resp and │ │ │ │ - * options arguments. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * method - {Function} The method to be applied by the callback. │ │ │ │ - * response - {} The protocol response object. │ │ │ │ - * options - {Object} Options sent to the protocol method │ │ │ │ + * {Boolean} True if the control was effectively deactivated or false │ │ │ │ + * if the control was already inactive. │ │ │ │ */ │ │ │ │ - createCallback: function(method, response, options) { │ │ │ │ - return OpenLayers.Function.bind(function() { │ │ │ │ - method.apply(this, [response, options]); │ │ │ │ - }, this); │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.deactivate(); │ │ │ │ + } │ │ │ │ + this.active = false; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, │ │ │ │ + this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("deactivate"); │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol" │ │ │ │ + CLASS_NAME: "OpenLayers.Control" │ │ │ │ }); │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol.Response │ │ │ │ - * Protocols return Response objects to their users. │ │ │ │ + * Constant: OpenLayers.Control.TYPE_BUTTON │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.Response = OpenLayers.Class({ │ │ │ │ +OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Control.TYPE_TOGGLE │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Control.TYPE_TOOL │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy │ │ │ │ + * Abstract vector layer strategy class. Not to be instantiated directly. Use │ │ │ │ + * one of the strategy subclasses instead. │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Property: code │ │ │ │ - * {Number} - OpenLayers.Protocol.Response.SUCCESS or │ │ │ │ - * OpenLayers.Protocol.Response.FAILURE │ │ │ │ + * Property: layer │ │ │ │ + * {} The layer this strategy belongs to. │ │ │ │ */ │ │ │ │ - code: null, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: requestType │ │ │ │ - * {String} The type of request this response corresponds to. Either │ │ │ │ - * "create", "read", "update" or "delete". │ │ │ │ + * Property: options │ │ │ │ + * {Object} Any options sent to the constructor. │ │ │ │ */ │ │ │ │ - requestType: null, │ │ │ │ + options: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: last │ │ │ │ - * {Boolean} - true if this is the last response expected in a commit, │ │ │ │ - * false otherwise, defaults to true. │ │ │ │ + /** │ │ │ │ + * Property: active │ │ │ │ + * {Boolean} The control is active. │ │ │ │ */ │ │ │ │ - last: true, │ │ │ │ + active: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: features │ │ │ │ - * {Array({})} or {} │ │ │ │ - * The features returned in the response by the server. Depending on the │ │ │ │ - * protocol's read payload, either features or data will be populated. │ │ │ │ + * Property: autoActivate │ │ │ │ + * {Boolean} The creator of the strategy can set autoActivate to false │ │ │ │ + * to fully control when the protocol is activated and deactivated. │ │ │ │ + * Defaults to true. │ │ │ │ */ │ │ │ │ - features: null, │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: data │ │ │ │ - * {Object} │ │ │ │ - * The data returned in the response by the server. Depending on the │ │ │ │ - * protocol's read payload, either features or data will be populated. │ │ │ │ + * Property: autoDestroy │ │ │ │ + * {Boolean} The creator of the strategy can set autoDestroy to false │ │ │ │ + * to fully control when the strategy is destroyed. Defaults to │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - data: null, │ │ │ │ + autoDestroy: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: reqFeatures │ │ │ │ - * {Array({})} or {} │ │ │ │ - * The features provided by the user and placed in the request by the │ │ │ │ - * protocol. │ │ │ │ + * Constructor: OpenLayers.Strategy │ │ │ │ + * Abstract class for vector strategies. Create instances of a subclass. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - reqFeatures: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ + // set the active property here, so that user cannot override it │ │ │ │ + this.active = false; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: priv │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the strategy. │ │ │ │ */ │ │ │ │ - priv: null, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = null; │ │ │ │ + this.options = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: error │ │ │ │ - * {Object} The error object in case a service exception was encountered. │ │ │ │ + * Method: setLayer │ │ │ │ + * Called to set the property. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {} │ │ │ │ */ │ │ │ │ - error: null, │ │ │ │ + setLayer: function(layer) { │ │ │ │ + this.layer = layer; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.Response │ │ │ │ + * Method: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + this.active = true; │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: success │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} - true on success, false otherwise │ │ │ │ + * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ + * the strategy was already inactive. │ │ │ │ */ │ │ │ │ - success: function() { │ │ │ │ - return this.code > 0; │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.active = false; │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.Response" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ }); │ │ │ │ - │ │ │ │ -OpenLayers.Protocol.Response.SUCCESS = 1; │ │ │ │ -OpenLayers.Protocol.Response.FAILURE = 0; │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Renderer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ @@ -30905,4198 +30611,4536 @@ │ │ │ │ 4, 0 │ │ │ │ ], │ │ │ │ "x": [0, 0, 25, 0, 50, 35, 75, 0, 100, 0, 65, 50, 100, 100, 75, 100, 50, 65, 25, 100, 0, 100, 35, 50, 0, 0], │ │ │ │ "square": [0, 0, 0, 1, 1, 1, 1, 0, 0, 0], │ │ │ │ "triangle": [0, 10, 10, 10, 5, 0, 0, 10] │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Symbolizer.js │ │ │ │ + OpenLayers/Format/WPSDescribeProcess.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Symbolizer │ │ │ │ - * Base class representing a symbolizer used for feature rendering. │ │ │ │ + * Class: OpenLayers.Format.WPSDescribeProcess │ │ │ │ + * Read WPS DescribeProcess responses. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - │ │ │ │ */ │ │ │ │ -OpenLayers.Symbolizer = OpenLayers.Class({ │ │ │ │ +OpenLayers.Format.WPSDescribeProcess = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.0.0 │ │ │ │ + */ │ │ │ │ + VERSION: "1.0.0", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zIndex │ │ │ │ - * {Number} The zIndex determines the rendering order for a symbolizer. │ │ │ │ - * Symbolizers with larger zIndex values are rendered over symbolizers │ │ │ │ - * with smaller zIndex values. Default is 0. │ │ │ │ - */ │ │ │ │ - zIndex: 0, │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Symbolizer │ │ │ │ - * Instances of this class are not useful. See one of the subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * symbolizer. Any documented symbolizer property can be set at │ │ │ │ - * construction. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * A new symbolizer. │ │ │ │ - */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Util.extend(this, config); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsAll.xsd", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a copy of this symbolizer. │ │ │ │ - * │ │ │ │ - * Returns a symbolizer of the same type with the same properties. │ │ │ │ - */ │ │ │ │ - clone: function() { │ │ │ │ - var Type = eval(this.CLASS_NAME); │ │ │ │ - return new Type(OpenLayers.Util.extend({}, this)); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + */ │ │ │ │ + defaultPrefix: "wps", │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer" │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WPSDescribeProcess │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Parse a WPS DescribeProcess and return an object with its information. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var info = {}; │ │ │ │ + this.readNode(data, info); │ │ │ │ + return info; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wps": { │ │ │ │ + "ProcessDescriptions": function(node, obj) { │ │ │ │ + obj.processDescriptions = {}; │ │ │ │ + this.readChildNodes(node, obj.processDescriptions); │ │ │ │ + }, │ │ │ │ + "ProcessDescription": function(node, processDescriptions) { │ │ │ │ + var processVersion = this.getAttributeNS(node, this.namespaces.wps, "processVersion"); │ │ │ │ + var processDescription = { │ │ │ │ + processVersion: processVersion, │ │ │ │ + statusSupported: (node.getAttribute("statusSupported") === "true"), │ │ │ │ + storeSupported: (node.getAttribute("storeSupported") === "true") │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, processDescription); │ │ │ │ + processDescriptions[processDescription.identifier] = processDescription; │ │ │ │ + }, │ │ │ │ + "DataInputs": function(node, processDescription) { │ │ │ │ + processDescription.dataInputs = []; │ │ │ │ + this.readChildNodes(node, processDescription.dataInputs); │ │ │ │ + }, │ │ │ │ + "ProcessOutputs": function(node, processDescription) { │ │ │ │ + processDescription.processOutputs = []; │ │ │ │ + this.readChildNodes(node, processDescription.processOutputs); │ │ │ │ + }, │ │ │ │ + "Output": function(node, processOutputs) { │ │ │ │ + var output = {}; │ │ │ │ + this.readChildNodes(node, output); │ │ │ │ + processOutputs.push(output); │ │ │ │ + }, │ │ │ │ + "ComplexOutput": function(node, output) { │ │ │ │ + output.complexOutput = {}; │ │ │ │ + this.readChildNodes(node, output.complexOutput); │ │ │ │ + }, │ │ │ │ + "LiteralOutput": function(node, output) { │ │ │ │ + output.literalOutput = {}; │ │ │ │ + this.readChildNodes(node, output.literalOutput); │ │ │ │ + }, │ │ │ │ + "Input": function(node, dataInputs) { │ │ │ │ + var input = { │ │ │ │ + maxOccurs: parseInt(node.getAttribute("maxOccurs")), │ │ │ │ + minOccurs: parseInt(node.getAttribute("minOccurs")) │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, input); │ │ │ │ + dataInputs.push(input); │ │ │ │ + }, │ │ │ │ + "BoundingBoxData": function(node, input) { │ │ │ │ + input.boundingBoxData = {}; │ │ │ │ + this.readChildNodes(node, input.boundingBoxData); │ │ │ │ + }, │ │ │ │ + "CRS": function(node, obj) { │ │ │ │ + if (!obj.CRSs) { │ │ │ │ + obj.CRSs = {}; │ │ │ │ + } │ │ │ │ + obj.CRSs[this.getChildValue(node)] = true; │ │ │ │ + }, │ │ │ │ + "LiteralData": function(node, input) { │ │ │ │ + input.literalData = {}; │ │ │ │ + this.readChildNodes(node, input.literalData); │ │ │ │ + }, │ │ │ │ + "ComplexData": function(node, input) { │ │ │ │ + input.complexData = {}; │ │ │ │ + this.readChildNodes(node, input.complexData); │ │ │ │ + }, │ │ │ │ + "Default": function(node, complexData) { │ │ │ │ + complexData["default"] = {}; │ │ │ │ + this.readChildNodes(node, complexData["default"]); │ │ │ │ + }, │ │ │ │ + "Supported": function(node, complexData) { │ │ │ │ + complexData["supported"] = {}; │ │ │ │ + this.readChildNodes(node, complexData["supported"]); │ │ │ │ + }, │ │ │ │ + "Format": function(node, obj) { │ │ │ │ + var format = {}; │ │ │ │ + this.readChildNodes(node, format); │ │ │ │ + if (!obj.formats) { │ │ │ │ + obj.formats = {}; │ │ │ │ + } │ │ │ │ + obj.formats[format.mimeType] = true; │ │ │ │ + }, │ │ │ │ + "MimeType": function(node, format) { │ │ │ │ + format.mimeType = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WPSDescribeProcess" │ │ │ │ │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/StyleMap.js │ │ │ │ + OpenLayers/WPSClient.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Style.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.StyleMap │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/WPSProcess.js │ │ │ │ + * @requires OpenLayers/Format/WPSDescribeProcess.js │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ */ │ │ │ │ -OpenLayers.StyleMap = OpenLayers.Class({ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.WPSClient │ │ │ │ + * High level API for interaction with Web Processing Services (WPS). │ │ │ │ + * An instance is used to create │ │ │ │ + * instances for servers known to the WPSClient. The WPSClient also caches │ │ │ │ + * DescribeProcess responses to reduce the number of requests sent to servers │ │ │ │ + * when processes are created. │ │ │ │ + */ │ │ │ │ +OpenLayers.WPSClient = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: styles │ │ │ │ - * {Object} Hash of {}, keyed by names of well known │ │ │ │ - * rendering intents (e.g. "default", "temporary", "select", "delete"). │ │ │ │ + * Property: servers │ │ │ │ + * {Object} Service metadata, keyed by a local identifier. │ │ │ │ + * │ │ │ │ + * Properties: │ │ │ │ + * url - {String} the url of the server │ │ │ │ + * version - {String} WPS version of the server │ │ │ │ + * processDescription - {Object} Cache of raw DescribeProcess │ │ │ │ + * responses, keyed by process identifier. │ │ │ │ */ │ │ │ │ - styles: null, │ │ │ │ + servers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: extendDefault │ │ │ │ - * {Boolean} if true, every render intent will extend the symbolizers │ │ │ │ - * specified for the "default" intent at rendering time. Otherwise, every │ │ │ │ - * rendering intent will be treated as a completely independent style. │ │ │ │ + * Property: version │ │ │ │ + * {String} The default WPS version to use if none is configured. Default │ │ │ │ + * is '1.0.0'. │ │ │ │ */ │ │ │ │ - extendDefault: true, │ │ │ │ + version: '1.0.0', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.StyleMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * style - {Object} Optional. Either a style hash, or a style object, or │ │ │ │ - * a hash of style objects (style hashes) keyed by rendering │ │ │ │ - * intent. If just one style hash or style object is passed, │ │ │ │ - * this will be used for all known render intents (default, │ │ │ │ - * select, temporary) │ │ │ │ - * options - {Object} optional hash of additional options for this │ │ │ │ - * instance │ │ │ │ + * Property: lazy │ │ │ │ + * {Boolean} Should the DescribeProcess be deferred until a process is │ │ │ │ + * fully configured? Default is false. │ │ │ │ */ │ │ │ │ - initialize: function(style, options) { │ │ │ │ - this.styles = { │ │ │ │ - "default": new OpenLayers.Style( │ │ │ │ - OpenLayers.Feature.Vector.style["default"]), │ │ │ │ - "select": new OpenLayers.Style( │ │ │ │ - OpenLayers.Feature.Vector.style["select"]), │ │ │ │ - "temporary": new OpenLayers.Style( │ │ │ │ - OpenLayers.Feature.Vector.style["temporary"]), │ │ │ │ - "delete": new OpenLayers.Style( │ │ │ │ - OpenLayers.Feature.Vector.style["delete"]) │ │ │ │ - }; │ │ │ │ + lazy: false, │ │ │ │ │ │ │ │ - // take whatever the user passed as style parameter and convert it │ │ │ │ - // into parts of stylemap. │ │ │ │ - if (style instanceof OpenLayers.Style) { │ │ │ │ - // user passed a style object │ │ │ │ - this.styles["default"] = style; │ │ │ │ - this.styles["select"] = style; │ │ │ │ - this.styles["temporary"] = style; │ │ │ │ - this.styles["delete"] = style; │ │ │ │ - } else if (typeof style == "object") { │ │ │ │ - for (var key in style) { │ │ │ │ - if (style[key] instanceof OpenLayers.Style) { │ │ │ │ - // user passed a hash of style objects │ │ │ │ - this.styles[key] = style[key]; │ │ │ │ - } else if (typeof style[key] == "object") { │ │ │ │ - // user passsed a hash of style hashes │ │ │ │ - this.styles[key] = new OpenLayers.Style(style[key]); │ │ │ │ - } else { │ │ │ │ - // user passed a style hash (i.e. symbolizer) │ │ │ │ - this.styles["default"] = new OpenLayers.Style(style); │ │ │ │ - this.styles["select"] = new OpenLayers.Style(style); │ │ │ │ - this.styles["temporary"] = new OpenLayers.Style(style); │ │ │ │ - this.styles["delete"] = new OpenLayers.Style(style); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: events │ │ │ │ + * {} │ │ │ │ + * │ │ │ │ + * Supported event types: │ │ │ │ + * describeprocess - Fires when the process description is available. │ │ │ │ + * Listeners receive an object with a 'raw' property holding the raw │ │ │ │ + * DescribeProcess response, and an 'identifier' property holding the │ │ │ │ + * process identifier of the described process. │ │ │ │ + */ │ │ │ │ + events: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.WPSClient │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Object whose properties will be set on the instance. │ │ │ │ + * │ │ │ │ + * Avaliable options: │ │ │ │ + * servers - {Object} Mandatory. Service metadata, keyed by a local │ │ │ │ + * identifier. Can either be a string with the service url or an │ │ │ │ + * object literal with additional metadata: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * servers: { │ │ │ │ + * local: '/geoserver/wps' │ │ │ │ + * }, { │ │ │ │ + * opengeo: { │ │ │ │ + * url: 'http://demo.opengeo.org/geoserver/wps', │ │ │ │ + * version: '1.0.0' │ │ │ │ + * } │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * lazy - {Boolean} Optional. Set to true if DescribeProcess should not be │ │ │ │ + * requested until a process is fully configured. Default is false. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ + this.events = new OpenLayers.Events(this); │ │ │ │ + this.servers = {}; │ │ │ │ + for (var s in options.servers) { │ │ │ │ + this.servers[s] = typeof options.servers[s] == 'string' ? { │ │ │ │ + url: options.servers[s], │ │ │ │ + version: this.version, │ │ │ │ + processDescription: {} │ │ │ │ + } : options.servers[s]; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * APIMethod: execute │ │ │ │ + * Shortcut to execute a process with a single function call. This is │ │ │ │ + * equivalent to using and then calling execute on the │ │ │ │ + * process. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Options for the execute operation. │ │ │ │ + * │ │ │ │ + * Available options: │ │ │ │ + * server - {String} Mandatory. One of the local identifiers of the │ │ │ │ + * configured servers. │ │ │ │ + * process - {String} Mandatory. A process identifier known to the │ │ │ │ + * server. │ │ │ │ + * inputs - {Object} The inputs for the process, keyed by input identifier. │ │ │ │ + * For spatial data inputs, the value of an input is usually an │ │ │ │ + * , an or an array of │ │ │ │ + * geometries or features. │ │ │ │ + * output - {String} The identifier of an output to parse. Optional. If not │ │ │ │ + * provided, the first output will be parsed. │ │ │ │ + * success - {Function} Callback to call when the process is complete. │ │ │ │ + * This function is called with an outputs object as argument, which │ │ │ │ + * will have a property with the identifier of the requested output │ │ │ │ + * (e.g. 'result'). For processes that generate spatial output, the │ │ │ │ + * value will either be a single or an │ │ │ │ + * array of features. │ │ │ │ + * scope - {Object} Optional scope for the success callback. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var key in this.styles) { │ │ │ │ - this.styles[key].destroy(); │ │ │ │ - } │ │ │ │ - this.styles = null; │ │ │ │ + execute: function(options) { │ │ │ │ + var process = this.getProcess(options.server, options.process); │ │ │ │ + process.execute({ │ │ │ │ + inputs: options.inputs, │ │ │ │ + success: options.success, │ │ │ │ + scope: options.scope │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createSymbolizer │ │ │ │ - * Creates the symbolizer for a feature for a render intent. │ │ │ │ - * │ │ │ │ + * APIMethod: getProcess │ │ │ │ + * Creates an . │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * feature - {} The feature to evaluate the rules │ │ │ │ - * of the intended style against. │ │ │ │ - * intent - {String} The intent determines the symbolizer that will be │ │ │ │ - * used to draw the feature. Well known intents are "default" │ │ │ │ - * (for just drawing the features), "select" (for selected │ │ │ │ - * features) and "temporary" (for drawing features). │ │ │ │ - * │ │ │ │ + * serverID - {String} Local identifier from the servers that this instance │ │ │ │ + * was constructed with. │ │ │ │ + * processID - {String} Process identifier known to the server. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Object} symbolizer hash │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ - createSymbolizer: function(feature, intent) { │ │ │ │ - if (!feature) { │ │ │ │ - feature = new OpenLayers.Feature.Vector(); │ │ │ │ - } │ │ │ │ - if (!this.styles[intent]) { │ │ │ │ - intent = "default"; │ │ │ │ - } │ │ │ │ - feature.renderIntent = intent; │ │ │ │ - var defaultSymbolizer = {}; │ │ │ │ - if (this.extendDefault && intent != "default") { │ │ │ │ - defaultSymbolizer = this.styles["default"].createSymbolizer(feature); │ │ │ │ + getProcess: function(serverID, processID) { │ │ │ │ + var process = new OpenLayers.WPSProcess({ │ │ │ │ + client: this, │ │ │ │ + server: serverID, │ │ │ │ + identifier: processID │ │ │ │ + }); │ │ │ │ + if (!this.lazy) { │ │ │ │ + process.describe(); │ │ │ │ } │ │ │ │ - return OpenLayers.Util.extend(defaultSymbolizer, │ │ │ │ - this.styles[intent].createSymbolizer(feature)); │ │ │ │ + return process; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addUniqueValueRules │ │ │ │ - * Convenience method to create comparison rules for unique values of a │ │ │ │ - * property. The rules will be added to the style object for a specified │ │ │ │ - * rendering intent. This method is a shortcut for creating something like │ │ │ │ - * the "unique value legends" familiar from well known desktop GIS systems │ │ │ │ - * │ │ │ │ + * Method: describeProcess │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * renderIntent - {String} rendering intent to add the rules to │ │ │ │ - * property - {String} values of feature attributes to create the │ │ │ │ - * rules for │ │ │ │ - * symbolizers - {Object} Hash of symbolizers, keyed by the desired │ │ │ │ - * property values │ │ │ │ - * context - {Object} An optional object with properties that │ │ │ │ - * symbolizers' property values should be evaluated │ │ │ │ - * against. If no context is specified, feature.attributes │ │ │ │ - * will be used │ │ │ │ + * serverID - {String} Identifier of the server │ │ │ │ + * processID - {String} Identifier of the requested process │ │ │ │ + * callback - {Function} Callback to call when the description is available │ │ │ │ + * scope - {Object} Optional execution scope for the callback function │ │ │ │ */ │ │ │ │ - addUniqueValueRules: function(renderIntent, property, symbolizers, context) { │ │ │ │ - var rules = []; │ │ │ │ - for (var value in symbolizers) { │ │ │ │ - rules.push(new OpenLayers.Rule({ │ │ │ │ - symbolizer: symbolizers[value], │ │ │ │ - context: context, │ │ │ │ - filter: new OpenLayers.Filter.Comparison({ │ │ │ │ - type: OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }) │ │ │ │ - })); │ │ │ │ + describeProcess: function(serverID, processID, callback, scope) { │ │ │ │ + var server = this.servers[serverID]; │ │ │ │ + if (!server.processDescription[processID]) { │ │ │ │ + if (!(processID in server.processDescription)) { │ │ │ │ + // set to null so we know a describeFeature request is pending │ │ │ │ + server.processDescription[processID] = null; │ │ │ │ + OpenLayers.Request.GET({ │ │ │ │ + url: server.url, │ │ │ │ + params: { │ │ │ │ + SERVICE: 'WPS', │ │ │ │ + VERSION: server.version, │ │ │ │ + REQUEST: 'DescribeProcess', │ │ │ │ + IDENTIFIER: processID │ │ │ │ + }, │ │ │ │ + success: function(response) { │ │ │ │ + server.processDescription[processID] = response.responseText; │ │ │ │ + this.events.triggerEvent('describeprocess', { │ │ │ │ + identifier: processID, │ │ │ │ + raw: response.responseText │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + // pending request │ │ │ │ + this.events.register('describeprocess', this, function describe(evt) { │ │ │ │ + if (evt.identifier === processID) { │ │ │ │ + this.events.unregister('describeprocess', this, describe); │ │ │ │ + callback.call(scope, evt.raw); │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + window.setTimeout(function() { │ │ │ │ + callback.call(scope, server.processDescription[processID]); │ │ │ │ + }, 0); │ │ │ │ } │ │ │ │ - this.styles[renderIntent].addRules(rules); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.StyleMap" │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ + this.servers = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: 'OpenLayers.WPSClient' │ │ │ │ + │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Marker.js │ │ │ │ + OpenLayers/Layer/HTTPRequest.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - * @requires OpenLayers/Icon.js │ │ │ │ + * @requires OpenLayers/Layer.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(21,25); │ │ │ │ - * var offset = new OpenLayers.Pixel(-(size.w/2), -size.h); │ │ │ │ - * var icon = new OpenLayers.Icon('http://www.openlayers.org/dev/img/marker.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. │ │ │ │ + * Class: OpenLayers.Layer.HTTPRequest │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - │ │ │ │ */ │ │ │ │ -OpenLayers.Marker = OpenLayers.Class({ │ │ │ │ +OpenLayers.Layer.HTTPRequest = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: icon │ │ │ │ - * {} The icon used by this marker. │ │ │ │ + * Constant: URL_HASH_FACTOR │ │ │ │ + * {Float} Used to hash URL param strings for multi-WMS server selection. │ │ │ │ + * Set to the Golden Ratio per Knuth's recommendation. │ │ │ │ */ │ │ │ │ - icon: null, │ │ │ │ + URL_HASH_FACTOR: (Math.sqrt(5) - 1) / 2, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: lonlat │ │ │ │ - * {} location of object │ │ │ │ + * Property: url │ │ │ │ + * {Array(String) or String} This is either an array of url strings or │ │ │ │ + * a single url string. │ │ │ │ */ │ │ │ │ - lonlat: null, │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: events │ │ │ │ - * {} the event handler. │ │ │ │ + * Property: params │ │ │ │ + * {Object} Hashtable of key/value parameters │ │ │ │ */ │ │ │ │ - events: null, │ │ │ │ + params: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: map │ │ │ │ - * {} the map this marker is attached to │ │ │ │ + * APIProperty: reproject │ │ │ │ + * *Deprecated*. See http://docs.openlayers.org/library/spherical_mercator.html │ │ │ │ + * for information on the replacement for this functionality. │ │ │ │ + * {Boolean} Whether layer should reproject itself based on base layer │ │ │ │ + * locations. This allows reprojection onto commercial layers. │ │ │ │ + * Default is false: Most layers can't reproject, but layers │ │ │ │ + * which can create non-square geographic pixels can, like WMS. │ │ │ │ + * │ │ │ │ */ │ │ │ │ - map: null, │ │ │ │ + reproject: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Marker │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.HTTPRequest │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * lonlat - {} the position of this marker │ │ │ │ - * icon - {} the icon for this marker │ │ │ │ + * name - {String} │ │ │ │ + * url - {Array(String) or String} │ │ │ │ + * params - {Object} │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.prototype.initialize.apply(this, [name, options]); │ │ │ │ + this.url = url; │ │ │ │ + if (!this.params) { │ │ │ │ + this.params = OpenLayers.Util.extend({}, params); │ │ │ │ } │ │ │ │ - this.events = new OpenLayers.Events(this, this.icon.imageDiv); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * 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() { │ │ │ │ - // erase any drawn features │ │ │ │ - this.erase(); │ │ │ │ - │ │ │ │ - this.map = null; │ │ │ │ - │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - │ │ │ │ - if (this.icon != null) { │ │ │ │ - this.icon.destroy(); │ │ │ │ - this.icon = null; │ │ │ │ - } │ │ │ │ + this.url = null; │ │ │ │ + this.params = null; │ │ │ │ + OpenLayers.Layer.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * Calls draw on the icon, and returns that output. │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * px - {} │ │ │ │ + * obj - {Object} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A new DOM Image with this marker's icon set at the │ │ │ │ - * location passed-in │ │ │ │ + * {} An exact clone of this │ │ │ │ + * │ │ │ │ */ │ │ │ │ - draw: function(px) { │ │ │ │ - return this.icon.draw(px); │ │ │ │ - }, │ │ │ │ + clone: function(obj) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: erase │ │ │ │ - * Erases any drawn elements for this marker. │ │ │ │ - */ │ │ │ │ - erase: function() { │ │ │ │ - if (this.icon != null) { │ │ │ │ - this.icon.erase(); │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.HTTPRequest(this.name, │ │ │ │ + this.url, │ │ │ │ + this.params, │ │ │ │ + this.getOptions()); │ │ │ │ } │ │ │ │ + │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveTo │ │ │ │ - * Move the marker to the new location. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * APIMethod: setUrl │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * px - {|Object} the pixel position to move to. │ │ │ │ - * An OpenLayers.Pixel or an object with a 'x' and 'y' properties. │ │ │ │ + * newUrl - {String} │ │ │ │ */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - if ((px != null) && (this.icon != null)) { │ │ │ │ - this.icon.moveTo(px); │ │ │ │ - } │ │ │ │ - this.lonlat = this.map.getLonLatFromLayerPx(px); │ │ │ │ + setUrl: function(newUrl) { │ │ │ │ + this.url = newUrl; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: isDrawn │ │ │ │ + * APIMethod: mergeNewParams │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * newParams - {Object} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Whether or not the marker is drawn. │ │ │ │ + * redrawn: {Boolean} whether the layer was actually redrawn. │ │ │ │ */ │ │ │ │ - isDrawn: function() { │ │ │ │ - var isDrawn = (this.icon && this.icon.isDrawn()); │ │ │ │ - return isDrawn; │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + this.params = OpenLayers.Util.extend(this.params, newParams); │ │ │ │ + var ret = this.redraw(); │ │ │ │ + if (this.map != null) { │ │ │ │ + this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "params" │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return ret; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onScreen │ │ │ │ + * APIMethod: redraw │ │ │ │ + * Redraws the layer. Returns true if the layer was redrawn, false if not. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * force - {Boolean} Force redraw by adding random parameter. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Whether or not the marker is currently visible on screen. │ │ │ │ + * {Boolean} The layer was redrawn. │ │ │ │ */ │ │ │ │ - onScreen: function() { │ │ │ │ - │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.map) { │ │ │ │ - var screenBounds = this.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsLonLat(this.lonlat); │ │ │ │ + redraw: function(force) { │ │ │ │ + if (force) { │ │ │ │ + return this.mergeNewParams({ │ │ │ │ + "_olSalt": Math.random() │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + return OpenLayers.Layer.prototype.redraw.apply(this, []); │ │ │ │ } │ │ │ │ - return onScreen; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: inflate │ │ │ │ - * Englarges the markers icon by the specified ratio. │ │ │ │ + * Method: selectUrl │ │ │ │ + * selectUrl() implements the standard floating-point multiplicative │ │ │ │ + * hash function described by Knuth, and hashes the contents of the │ │ │ │ + * given param string into a float between 0 and 1. This float is then │ │ │ │ + * scaled to the size of the provided urls array, and used to select │ │ │ │ + * a URL. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * inflate - {float} the ratio to enlarge the marker by (passing 2 │ │ │ │ - * will double the size). │ │ │ │ + * paramString - {String} │ │ │ │ + * urls - {Array(String)} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} An entry from the urls array, deterministically selected based │ │ │ │ + * on the paramString. │ │ │ │ */ │ │ │ │ - inflate: function(inflate) { │ │ │ │ - if (this.icon) { │ │ │ │ - this.icon.setSize({ │ │ │ │ - w: this.icon.size.w * inflate, │ │ │ │ - h: this.icon.size.h * inflate │ │ │ │ - }); │ │ │ │ + selectUrl: function(paramString, urls) { │ │ │ │ + var product = 1; │ │ │ │ + for (var i = 0, len = paramString.length; i < len; i++) { │ │ │ │ + product *= paramString.charCodeAt(i) * this.URL_HASH_FACTOR; │ │ │ │ + product -= Math.floor(product); │ │ │ │ } │ │ │ │ + return urls[Math.floor(product * urls.length)]; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setOpacity │ │ │ │ - * Change the opacity of the marker by changin the opacity of │ │ │ │ - * its icon │ │ │ │ + * Method: getFullRequestString │ │ │ │ + * Combine url with layer's params and these newParams. │ │ │ │ + * │ │ │ │ + * does checking on the serverPath variable, allowing for cases when it │ │ │ │ + * is supplied with trailing ? or &, as well as cases where not. │ │ │ │ + * │ │ │ │ + * return in formatted string like this: │ │ │ │ + * "server?key1=value1&key2=value2&key3=value3" │ │ │ │ * │ │ │ │ + * WARNING: The altUrl parameter is deprecated and will be removed in 3.0. │ │ │ │ + * │ │ │ │ * 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} │ │ │ │ + * newParams - {Object} │ │ │ │ + * altUrl - {String} Use this as the url instead of the layer's url │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - setUrl: function(url) { │ │ │ │ - this.icon.setUrl(url); │ │ │ │ - }, │ │ │ │ + getFullRequestString: function(newParams, altUrl) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: display │ │ │ │ - * Hide or show the icon │ │ │ │ - * │ │ │ │ - * display - {Boolean} │ │ │ │ - */ │ │ │ │ - display: function(display) { │ │ │ │ - this.icon.display(display); │ │ │ │ - }, │ │ │ │ + // if not altUrl passed in, use layer's url │ │ │ │ + var url = altUrl || this.url; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Marker" │ │ │ │ -}); │ │ │ │ + // create a new params hashtable with all the layer params and the │ │ │ │ + // new params together. then convert to string │ │ │ │ + var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ + allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ + var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ │ │ │ │ + // if url is not a string, it should be an array of strings, │ │ │ │ + // in which case we will deterministically select one of them in │ │ │ │ + // order to evenly distribute requests to different urls. │ │ │ │ + // │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(paramsString, url); │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Function: defaultIcon │ │ │ │ - * Creates a default . │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} A default OpenLayers.Icon to use for a marker │ │ │ │ - */ │ │ │ │ -OpenLayers.Marker.defaultIcon = function() { │ │ │ │ - return new OpenLayers.Icon(OpenLayers.Util.getImageLocation("marker.png"), { │ │ │ │ - w: 21, │ │ │ │ - h: 25 │ │ │ │ - }, { │ │ │ │ - x: -10.5, │ │ │ │ - y: -25 │ │ │ │ - }); │ │ │ │ -}; │ │ │ │ + // ignore parameters that are already in the url search string │ │ │ │ + var urlParams = │ │ │ │ + OpenLayers.Util.upperCaseObject(OpenLayers.Util.getParameters(url)); │ │ │ │ + for (var key in allParams) { │ │ │ │ + if (key.toUpperCase() in urlParams) { │ │ │ │ + delete allParams[key]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ │ │ │ │ + return OpenLayers.Util.urlAppend(url, paramsString); │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.HTTPRequest" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Symbolizer/Point.js │ │ │ │ + OpenLayers/Tile/Image.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Symbolizer.js │ │ │ │ + * @requires OpenLayers/Tile.js │ │ │ │ + * @requires OpenLayers/Animation.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Symbolizer.Point │ │ │ │ - * A symbolizer used to render point features. │ │ │ │ + * Class: OpenLayers.Tile.Image │ │ │ │ + * Instances of OpenLayers.Tile.Image are used to manage the image tiles │ │ │ │ + * used by various layers. Create a new image tile with the │ │ │ │ + * constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - │ │ │ │ */ │ │ │ │ -OpenLayers.Symbolizer.Point = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ +OpenLayers.Tile.Image = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeColor │ │ │ │ - * {String} Color for line stroke. This is a RGB hex value (e.g. "#ff0000" │ │ │ │ - * for red). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * APIProperty: events │ │ │ │ + * {} An events object that handles all │ │ │ │ + * events on the tile. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * tile.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to the events): │ │ │ │ + * beforeload - Triggered before an image is prepared for loading, when the │ │ │ │ + * url for the image is known already. Listeners may call on │ │ │ │ + * the tile instance. If they do so, that image will be used and no new │ │ │ │ + * one will be created. │ │ │ │ */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: strokeOpacity │ │ │ │ - * {Number} Stroke opacity (0-1). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} The URL of the image being requested. No default. Filled in by │ │ │ │ + * layer.getURL() function. May be modified by loadstart listeners. │ │ │ │ */ │ │ │ │ + url: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: strokeWidth │ │ │ │ - * {Number} Pixel stroke width. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * Property: imgDiv │ │ │ │ + * {HTMLImageElement} The image for this tile. │ │ │ │ */ │ │ │ │ + imgDiv: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeLinecap │ │ │ │ - * {String} Stroke cap type ("butt", "round", or "square"). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Property: frame │ │ │ │ + * {DOMElement} The image element is appended to the frame. Any gutter on │ │ │ │ + * the image will be hidden behind the frame. If no gutter is set, │ │ │ │ + * this will be null. │ │ │ │ */ │ │ │ │ + frame: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: strokeDashstyle │ │ │ │ - * {String} Stroke dash style according to the SLD spec. Note that the │ │ │ │ - * OpenLayers values for strokeDashstyle ("dot", "dash", "dashdot", │ │ │ │ - * "longdash", "longdashdot", or "solid") will not work in SLD, but │ │ │ │ - * most SLD patterns will render correctly in OpenLayers. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * Property: imageReloadAttempts │ │ │ │ + * {Integer} Attempts to load the image. │ │ │ │ */ │ │ │ │ + imageReloadAttempts: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: fillColor │ │ │ │ - * {String} RGB hex fill color (e.g. "#ff0000" for red). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Property: layerAlphaHack │ │ │ │ + * {Boolean} True if the png alpha hack needs to be applied on the layer's div. │ │ │ │ */ │ │ │ │ + layerAlphaHack: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: fillOpacity │ │ │ │ - * {Number} Fill opacity (0-1). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Property: asyncRequestId │ │ │ │ + * {Integer} ID of an request to see if request is still valid. This is a │ │ │ │ + * number which increments by 1 for each asynchronous request. │ │ │ │ */ │ │ │ │ + asyncRequestId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: pointRadius │ │ │ │ - * {Number} Pixel point radius. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * APIProperty: maxGetUrlLength │ │ │ │ + * {Number} If set, requests that would result in GET urls with more │ │ │ │ + * characters than the number provided will be made using form-encoded │ │ │ │ + * HTTP POST. It is good practice to avoid urls that are longer than 2048 │ │ │ │ + * characters. │ │ │ │ + * │ │ │ │ + * Caution: │ │ │ │ + * Older versions of Gecko based browsers (e.g. Firefox < 3.5) and most │ │ │ │ + * Opera versions do not fully support this option. On all browsers, │ │ │ │ + * transition effects are not supported if POST requests are used. │ │ │ │ */ │ │ │ │ + maxGetUrlLength: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: externalGraphic │ │ │ │ - * {String} Url to an external graphic that will be used for rendering │ │ │ │ - * points. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Property: canvasContext │ │ │ │ + * {CanvasRenderingContext2D} A canvas context associated with │ │ │ │ + * the tile image. │ │ │ │ */ │ │ │ │ + canvasContext: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: graphicWidth │ │ │ │ - * {Number} Pixel width for sizing an external graphic. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * APIProperty: crossOriginKeyword │ │ │ │ + * The value of the crossorigin keyword to use when loading images. This is │ │ │ │ + * only relevant when using for tiles from remote │ │ │ │ + * origins and should be set to either 'anonymous' or 'use-credentials' │ │ │ │ + * for servers that send Access-Control-Allow-Origin headers with their │ │ │ │ + * tiles. │ │ │ │ */ │ │ │ │ + crossOriginKeyword: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: graphicHeight │ │ │ │ - * {Number} Pixel height for sizing an external graphic. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** TBD 3.0 - reorder the parameters to the init function to remove │ │ │ │ + * URL. the getUrl() function on the layer gets called on │ │ │ │ + * each draw(), so no need to specify it here. │ │ │ │ */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: graphicOpacity │ │ │ │ - * {Number} Opacity (0-1) for an external graphic. │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Tile.Image │ │ │ │ + * Constructor for a new instance. │ │ │ │ * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Parameters: │ │ │ │ + * layer - {} layer that the tile will go in. │ │ │ │ + * position - {} │ │ │ │ + * bounds - {} │ │ │ │ + * url - {} Deprecated. Remove me in 3.0. │ │ │ │ + * size - {} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ + initialize: function(layer, position, bounds, url, size, options) { │ │ │ │ + OpenLayers.Tile.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: graphicXOffset │ │ │ │ - * {Number} Pixel offset along the positive x axis for displacing an │ │ │ │ - * external graphic. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ - */ │ │ │ │ + this.url = url; //deprecated remove me │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: graphicYOffset │ │ │ │ - * {Number} Pixel offset along the positive y axis for displacing an │ │ │ │ - * external graphic. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ - */ │ │ │ │ + this.layerAlphaHack = this.layer.alpha && OpenLayers.Util.alphaHack(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: rotation │ │ │ │ - * {Number} The rotation of a graphic in the clockwise direction about its │ │ │ │ - * center point (or any point off center as specified by │ │ │ │ - * and ). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ - */ │ │ │ │ + if (this.maxGetUrlLength != null || this.layer.gutter || this.layerAlphaHack) { │ │ │ │ + // only create frame if it's needed │ │ │ │ + this.frame = document.createElement("div"); │ │ │ │ + this.frame.style.position = "absolute"; │ │ │ │ + this.frame.style.overflow = "hidden"; │ │ │ │ + } │ │ │ │ + if (this.maxGetUrlLength != null) { │ │ │ │ + OpenLayers.Util.extend(this, OpenLayers.Tile.Image.IFrame); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: graphicName │ │ │ │ - * {String} Named graphic to use when rendering points. Supported values │ │ │ │ - * include "circle", "square", "star", "x", "cross", and "triangle". │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.imgDiv) { │ │ │ │ + this.clear(); │ │ │ │ + this.imgDiv = null; │ │ │ │ + this.frame = null; │ │ │ │ + } │ │ │ │ + // don't handle async requests any more │ │ │ │ + this.asyncRequestId = null; │ │ │ │ + OpenLayers.Tile.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Symbolizer.Point │ │ │ │ - * Create a symbolizer for rendering points. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * symbolizer. Any documented symbolizer property can be set at │ │ │ │ - * construction. │ │ │ │ - * │ │ │ │ + * Method: draw │ │ │ │ + * Check that a tile should be drawn, and draw it. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * A new point symbolizer. │ │ │ │ + * {Boolean} Was a tile drawn? Or null if a beforedraw listener returned │ │ │ │ + * false. │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ + draw: function() { │ │ │ │ + var shouldDraw = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ + if (shouldDraw) { │ │ │ │ + // The layer's reproject option is deprecated. │ │ │ │ + if (this.layer != this.layer.map.baseLayer && this.layer.reproject) { │ │ │ │ + // getBoundsFromBaseLayer is defined in deprecated.js. │ │ │ │ + this.bounds = this.getBoundsFromBaseLayer(this.position); │ │ │ │ + } │ │ │ │ + if (this.isLoading) { │ │ │ │ + //if we're already loading, send 'reload' instead of 'loadstart'. │ │ │ │ + this._loadEvent = "reload"; │ │ │ │ + } else { │ │ │ │ + this.isLoading = true; │ │ │ │ + this._loadEvent = "loadstart"; │ │ │ │ + } │ │ │ │ + this.renderTile(); │ │ │ │ + this.positionTile(); │ │ │ │ + } else if (shouldDraw === false) { │ │ │ │ + this.unload(); │ │ │ │ + } │ │ │ │ + return shouldDraw; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Point" │ │ │ │ - │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Symbolizer/Line.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Symbolizer.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Symbolizer.Line │ │ │ │ - * A symbolizer used to render line features. │ │ │ │ - */ │ │ │ │ -OpenLayers.Symbolizer.Line = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: strokeColor │ │ │ │ - * {String} Color for line stroke. This is a RGB hex value (e.g. "#ff0000" │ │ │ │ - * for red). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: renderTile │ │ │ │ + * Internal function to actually initialize the image tile, │ │ │ │ + * position it correctly, and set its url. │ │ │ │ */ │ │ │ │ + renderTile: function() { │ │ │ │ + if (this.layer.async) { │ │ │ │ + // Asynchronous image requests call the asynchronous getURL method │ │ │ │ + // on the layer to fetch an image that covers 'this.bounds'. │ │ │ │ + var id = this.asyncRequestId = (this.asyncRequestId || 0) + 1; │ │ │ │ + this.layer.getURLasync(this.bounds, function(url) { │ │ │ │ + if (id == this.asyncRequestId) { │ │ │ │ + this.url = url; │ │ │ │ + this.initImage(); │ │ │ │ + } │ │ │ │ + }, this); │ │ │ │ + } else { │ │ │ │ + // synchronous image requests get the url immediately. │ │ │ │ + this.url = this.layer.getURL(this.bounds); │ │ │ │ + this.initImage(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeOpacity │ │ │ │ - * {Number} Stroke opacity (0-1). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: positionTile │ │ │ │ + * Using the properties currenty set on the layer, position the tile correctly. │ │ │ │ + * This method is used both by the async and non-async versions of the Tile.Image │ │ │ │ + * code. │ │ │ │ */ │ │ │ │ + positionTile: function() { │ │ │ │ + var style = this.getTile().style, │ │ │ │ + size = this.frame ? this.size : │ │ │ │ + this.layer.getImageSize(this.bounds), │ │ │ │ + ratio = 1; │ │ │ │ + if (this.layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ + ratio = this.layer.getServerResolution() / this.layer.map.getResolution(); │ │ │ │ + } │ │ │ │ + style.left = this.position.x + "px"; │ │ │ │ + style.top = this.position.y + "px"; │ │ │ │ + style.width = Math.round(ratio * size.w) + "px"; │ │ │ │ + style.height = Math.round(ratio * size.h) + "px"; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: strokeWidth │ │ │ │ - * {Number} Pixel stroke width. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * Method: clear │ │ │ │ + * Remove the tile from the DOM, clear it of any image related data so that │ │ │ │ + * it can be reused in a new location. │ │ │ │ */ │ │ │ │ + clear: function() { │ │ │ │ + OpenLayers.Tile.prototype.clear.apply(this, arguments); │ │ │ │ + var img = this.imgDiv; │ │ │ │ + if (img) { │ │ │ │ + var tile = this.getTile(); │ │ │ │ + if (tile.parentNode === this.layer.div) { │ │ │ │ + this.layer.div.removeChild(tile); │ │ │ │ + } │ │ │ │ + this.setImgSrc(); │ │ │ │ + if (this.layerAlphaHack === true) { │ │ │ │ + img.style.filter = ""; │ │ │ │ + } │ │ │ │ + OpenLayers.Element.removeClass(img, "olImageLoadError"); │ │ │ │ + } │ │ │ │ + this.canvasContext = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeLinecap │ │ │ │ - * {String} Stroke cap type ("butt", "round", or "square"). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: getImage │ │ │ │ + * Returns or creates and returns the tile image. │ │ │ │ */ │ │ │ │ + getImage: function() { │ │ │ │ + if (!this.imgDiv) { │ │ │ │ + this.imgDiv = OpenLayers.Tile.Image.IMAGE.cloneNode(false); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: strokeDashstyle │ │ │ │ - * {String} Stroke dash style according to the SLD spec. Note that the │ │ │ │ - * OpenLayers values for strokeDashstyle ("dot", "dash", "dashdot", │ │ │ │ - * "longdash", "longdashdot", or "solid") will not work in SLD, but │ │ │ │ - * most SLD patterns will render correctly in OpenLayers. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ - */ │ │ │ │ + var style = this.imgDiv.style; │ │ │ │ + if (this.frame) { │ │ │ │ + var left = 0, │ │ │ │ + top = 0; │ │ │ │ + if (this.layer.gutter) { │ │ │ │ + left = this.layer.gutter / this.layer.tileSize.w * 100; │ │ │ │ + top = this.layer.gutter / this.layer.tileSize.h * 100; │ │ │ │ + } │ │ │ │ + style.left = -left + "%"; │ │ │ │ + style.top = -top + "%"; │ │ │ │ + style.width = (2 * left + 100) + "%"; │ │ │ │ + style.height = (2 * top + 100) + "%"; │ │ │ │ + } │ │ │ │ + style.visibility = "hidden"; │ │ │ │ + style.opacity = 0; │ │ │ │ + if (this.layer.opacity < 1) { │ │ │ │ + style.filter = 'alpha(opacity=' + │ │ │ │ + (this.layer.opacity * 100) + │ │ │ │ + ')'; │ │ │ │ + } │ │ │ │ + style.position = "absolute"; │ │ │ │ + if (this.layerAlphaHack) { │ │ │ │ + // move the image out of sight │ │ │ │ + style.paddingTop = style.height; │ │ │ │ + style.height = "0"; │ │ │ │ + style.width = "100%"; │ │ │ │ + } │ │ │ │ + if (this.frame) { │ │ │ │ + this.frame.appendChild(this.imgDiv); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.imgDiv; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Symbolizer.Line │ │ │ │ - * Create a symbolizer for rendering lines. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * symbolizer. Any documented symbolizer property can be set at │ │ │ │ - * construction. │ │ │ │ + * APIMethod: setImage │ │ │ │ + * Sets the image element for this tile. This method should only be called │ │ │ │ + * from beforeload listeners. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * A new line symbolizer. │ │ │ │ + * Parameters │ │ │ │ + * img - {HTMLImageElement} The image to use for this tile. │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ + setImage: function(img) { │ │ │ │ + this.imgDiv = img; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Line" │ │ │ │ - │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Symbolizer/Polygon.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Symbolizer.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Symbolizer.Polygon │ │ │ │ - * A symbolizer used to render line features. │ │ │ │ - */ │ │ │ │ -OpenLayers.Symbolizer.Polygon = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: strokeColor │ │ │ │ - * {String} Color for line stroke. This is a RGB hex value (e.g. "#ff0000" │ │ │ │ - * for red). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: initImage │ │ │ │ + * Creates the content for the frame on the tile. │ │ │ │ */ │ │ │ │ + initImage: function() { │ │ │ │ + if (!this.url && !this.imgDiv) { │ │ │ │ + // fast path out - if there is no tile url and no previous image │ │ │ │ + this.isLoading = false; │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + this.events.triggerEvent('beforeload'); │ │ │ │ + this.layer.div.appendChild(this.getTile()); │ │ │ │ + this.events.triggerEvent(this._loadEvent); │ │ │ │ + var img = this.getImage(); │ │ │ │ + var src = img.getAttribute('src') || ''; │ │ │ │ + if (this.url && OpenLayers.Util.isEquivalentUrl(src, this.url)) { │ │ │ │ + this._loadTimeout = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(this.onImageLoad, this), 0 │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.stopLoading(); │ │ │ │ + if (this.crossOriginKeyword) { │ │ │ │ + img.removeAttribute("crossorigin"); │ │ │ │ + } │ │ │ │ + OpenLayers.Event.observe(img, "load", │ │ │ │ + OpenLayers.Function.bind(this.onImageLoad, this) │ │ │ │ + ); │ │ │ │ + OpenLayers.Event.observe(img, "error", │ │ │ │ + OpenLayers.Function.bind(this.onImageError, this) │ │ │ │ + ); │ │ │ │ + this.imageReloadAttempts = 0; │ │ │ │ + this.setImgSrc(this.url); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeOpacity │ │ │ │ - * {Number} Stroke opacity (0-1). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: setImgSrc │ │ │ │ + * Sets the source for the tile image │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * url - {String} or undefined to hide the image │ │ │ │ */ │ │ │ │ + setImgSrc: function(url) { │ │ │ │ + var img = this.imgDiv; │ │ │ │ + if (url) { │ │ │ │ + img.style.visibility = 'hidden'; │ │ │ │ + img.style.opacity = 0; │ │ │ │ + // don't set crossOrigin if the url is a data URL │ │ │ │ + if (this.crossOriginKeyword) { │ │ │ │ + if (url.substr(0, 5) !== 'data:') { │ │ │ │ + img.setAttribute("crossorigin", this.crossOriginKeyword); │ │ │ │ + } else { │ │ │ │ + img.removeAttribute("crossorigin"); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + img.src = url; │ │ │ │ + } else { │ │ │ │ + // Remove reference to the image, and leave it to the browser's │ │ │ │ + // caching and garbage collection. │ │ │ │ + this.stopLoading(); │ │ │ │ + this.imgDiv = null; │ │ │ │ + if (img.parentNode) { │ │ │ │ + img.parentNode.removeChild(img); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeWidth │ │ │ │ - * {Number} Pixel stroke width. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: getTile │ │ │ │ + * Get the tile's markup. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The tile's markup │ │ │ │ */ │ │ │ │ + getTile: function() { │ │ │ │ + return this.frame ? this.frame : this.getImage(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: strokeLinecap │ │ │ │ - * {String} Stroke cap type ("butt", "round", or "square"). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: createBackBuffer │ │ │ │ + * Create a backbuffer for this tile. A backbuffer isn't exactly a clone │ │ │ │ + * of the tile's markup, because we want to avoid the reloading of the │ │ │ │ + * image. So we clone the frame, and steal the image from the tile. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The markup, or undefined if the tile has no image │ │ │ │ + * or if it's currently loading. │ │ │ │ */ │ │ │ │ + createBackBuffer: function() { │ │ │ │ + if (!this.imgDiv || this.isLoading) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var backBuffer; │ │ │ │ + if (this.frame) { │ │ │ │ + backBuffer = this.frame.cloneNode(false); │ │ │ │ + backBuffer.appendChild(this.imgDiv); │ │ │ │ + } else { │ │ │ │ + backBuffer = this.imgDiv; │ │ │ │ + } │ │ │ │ + this.imgDiv = null; │ │ │ │ + return backBuffer; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: strokeDashstyle │ │ │ │ - * {String} Stroke dash style according to the SLD spec. Note that the │ │ │ │ - * OpenLayers values for strokeDashstyle ("dot", "dash", "dashdot", │ │ │ │ - * "longdash", "longdashdot", or "solid") will not work in SLD, but │ │ │ │ - * most SLD patterns will render correctly in OpenLayers. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: onImageLoad │ │ │ │ + * Handler for the image onload event │ │ │ │ */ │ │ │ │ + onImageLoad: function() { │ │ │ │ + var img = this.imgDiv; │ │ │ │ + this.stopLoading(); │ │ │ │ + img.style.visibility = 'inherit'; │ │ │ │ + img.style.opacity = this.layer.opacity; │ │ │ │ + this.isLoading = false; │ │ │ │ + this.canvasContext = null; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + │ │ │ │ + if (this.layerAlphaHack === true) { │ │ │ │ + img.style.filter = │ │ │ │ + "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + │ │ │ │ + img.src + "', sizingMethod='scale')"; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: fillColor │ │ │ │ - * {String} RGB hex fill color (e.g. "#ff0000" for red). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: onImageError │ │ │ │ + * Handler for the image onerror event │ │ │ │ */ │ │ │ │ + onImageError: function() { │ │ │ │ + var img = this.imgDiv; │ │ │ │ + if (img.src != null) { │ │ │ │ + this.imageReloadAttempts++; │ │ │ │ + if (this.imageReloadAttempts <= OpenLayers.IMAGE_RELOAD_ATTEMPTS) { │ │ │ │ + this.setImgSrc(this.layer.getURL(this.bounds)); │ │ │ │ + } else { │ │ │ │ + OpenLayers.Element.addClass(img, "olImageLoadError"); │ │ │ │ + this.events.triggerEvent("loaderror"); │ │ │ │ + this.onImageLoad(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: fillOpacity │ │ │ │ - * {Number} Fill opacity (0-1). │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * Method: stopLoading │ │ │ │ + * Stops a loading sequence so won't be executed. │ │ │ │ */ │ │ │ │ + stopLoading: function() { │ │ │ │ + OpenLayers.Event.stopObservingElement(this.imgDiv); │ │ │ │ + window.clearTimeout(this._loadTimeout); │ │ │ │ + delete this._loadTimeout; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Symbolizer.Polygon │ │ │ │ - * Create a symbolizer for rendering polygons. │ │ │ │ + * APIMethod: getCanvasContext │ │ │ │ + * Returns a canvas context associated with the tile image (with │ │ │ │ + * the image drawn on it). │ │ │ │ + * Returns undefined if the browser does not support canvas, if │ │ │ │ + * the tile has no image or if it's currently loading. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * symbolizer. Any documented symbolizer property can be set at │ │ │ │ - * construction. │ │ │ │ + * The function returns a canvas context instance but the │ │ │ │ + * underlying canvas is still available in the 'canvas' property: │ │ │ │ + * (code) │ │ │ │ + * var context = tile.getCanvasContext(); │ │ │ │ + * if (context) { │ │ │ │ + * var data = context.canvas.toDataURL('image/jpeg'); │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * A new polygon symbolizer. │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ + getCanvasContext: function() { │ │ │ │ + if (OpenLayers.CANVAS_SUPPORTED && this.imgDiv && !this.isLoading) { │ │ │ │ + if (!this.canvasContext) { │ │ │ │ + var canvas = document.createElement("canvas"); │ │ │ │ + canvas.width = this.size.w; │ │ │ │ + canvas.height = this.size.h; │ │ │ │ + this.canvasContext = canvas.getContext("2d"); │ │ │ │ + this.canvasContext.drawImage(this.imgDiv, 0, 0); │ │ │ │ + } │ │ │ │ + return this.canvasContext; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Polygon" │ │ │ │ + CLASS_NAME: "OpenLayers.Tile.Image" │ │ │ │ │ │ │ │ }); │ │ │ │ │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Tile.Image.IMAGE │ │ │ │ + * {HTMLImageElement} The image for a tile. │ │ │ │ + */ │ │ │ │ +OpenLayers.Tile.Image.IMAGE = (function() { │ │ │ │ + var img = new Image(); │ │ │ │ + img.className = "olTileImage"; │ │ │ │ + // avoid image gallery menu in IE6 │ │ │ │ + img.galleryImg = "no"; │ │ │ │ + return img; │ │ │ │ +}()); │ │ │ │ + │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Symbolizer/Text.js │ │ │ │ + OpenLayers/Layer/Grid.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Symbolizer.js │ │ │ │ + * @requires OpenLayers/Layer/HTTPRequest.js │ │ │ │ + * @requires OpenLayers/Tile/Image.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Symbolizer.Text │ │ │ │ - * A symbolizer used to render text labels for features. │ │ │ │ + * Class: OpenLayers.Layer.Grid │ │ │ │ + * Base class for layers that use a lattice of tiles. Create a new grid │ │ │ │ + * layer with the constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - │ │ │ │ */ │ │ │ │ -OpenLayers.Symbolizer.Text = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ +OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: label │ │ │ │ - * {String} The text for the label. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * APIProperty: tileSize │ │ │ │ + * {} │ │ │ │ */ │ │ │ │ + tileSize: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: fontFamily │ │ │ │ - * {String} The font family for the label. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * Property: tileOriginCorner │ │ │ │ + * {String} If the property is not provided, the tile origin │ │ │ │ + * will be derived from the layer's . The corner of the │ │ │ │ + * used is determined by this property. Acceptable values │ │ │ │ + * are "tl" (top left), "tr" (top right), "bl" (bottom left), and "br" │ │ │ │ + * (bottom right). Default is "bl". │ │ │ │ */ │ │ │ │ + tileOriginCorner: "bl", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: fontSize │ │ │ │ - * {String} The font size for the label. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** │ │ │ │ + * APIProperty: tileOrigin │ │ │ │ + * {} Optional origin for aligning the grid of tiles. │ │ │ │ + * If provided, requests for tiles at all resolutions will be aligned │ │ │ │ + * with this location (no tiles shall overlap this location). If │ │ │ │ + * not provided, the grid of tiles will be aligned with the layer's │ │ │ │ + * . Default is ``null``. │ │ │ │ */ │ │ │ │ + tileOrigin: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: fontWeight │ │ │ │ - * {String} The font weight for the label. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + /** APIProperty: tileOptions │ │ │ │ + * {Object} optional configuration options for instances │ │ │ │ + * created by this Layer, if supported by the tile class. │ │ │ │ */ │ │ │ │ + tileOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: fontStyle │ │ │ │ - * {String} The font style for the label. │ │ │ │ - * │ │ │ │ - * No default set here. Use OpenLayers.Renderer.defaultRenderer for defaults. │ │ │ │ + * APIProperty: tileClass │ │ │ │ + * {} The tile class to use for this layer. │ │ │ │ + * Defaults is OpenLayers.Tile.Image. │ │ │ │ */ │ │ │ │ + tileClass: OpenLayers.Tile.Image, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Symbolizer.Text │ │ │ │ - * Create a symbolizer for rendering text labels. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * symbolizer. Any documented symbolizer property can be set at │ │ │ │ - * construction. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * A new text symbolizer. │ │ │ │ + * Property: grid │ │ │ │ + * {Array(Array())} This is an array of rows, each row is │ │ │ │ + * an array of tiles. │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Text" │ │ │ │ - │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Symbolizer/Raster.js │ │ │ │ - ====================================================================== */ │ │ │ │ + grid: null, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: singleTile │ │ │ │ + * {Boolean} Moves the layer into single-tile mode, meaning that one tile │ │ │ │ + * will be loaded. The tile's size will be determined by the 'ratio' │ │ │ │ + * property. When the tile is dragged such that it does not cover the │ │ │ │ + * entire viewport, it is reloaded. │ │ │ │ + */ │ │ │ │ + singleTile: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Symbolizer.js │ │ │ │ - */ │ │ │ │ + /** APIProperty: ratio │ │ │ │ + * {Float} Used only when in single-tile mode, this specifies the │ │ │ │ + * ratio of the size of the single tile to the size of the map. │ │ │ │ + * Default value is 1.5. │ │ │ │ + */ │ │ │ │ + ratio: 1.5, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Symbolizer.Raster │ │ │ │ - * A symbolizer used to render raster images. │ │ │ │ - */ │ │ │ │ -OpenLayers.Symbolizer.Raster = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + /** │ │ │ │ + * APIProperty: buffer │ │ │ │ + * {Integer} Used only when in gridded mode, this specifies the number of │ │ │ │ + * extra rows and colums of tiles on each side which will │ │ │ │ + * surround the minimum grid tiles to cover the map. │ │ │ │ + * For very slow loading layers, a larger value may increase │ │ │ │ + * performance somewhat when dragging, but will increase bandwidth │ │ │ │ + * use significantly. │ │ │ │ + */ │ │ │ │ + buffer: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Symbolizer.Raster │ │ │ │ - * Create a symbolizer for rendering rasters. │ │ │ │ + * APIProperty: transitionEffect │ │ │ │ + * {String} The transition effect to use when the map is zoomed. │ │ │ │ + * Two posible values: │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * symbolizer. Any documented symbolizer property can be set at │ │ │ │ - * construction. │ │ │ │ + * "resize" - Existing tiles are resized on zoom to provide a visual │ │ │ │ + * effect of the zoom having taken place immediately. As the │ │ │ │ + * new tiles become available, they are drawn on top of the │ │ │ │ + * resized tiles (this is the default setting). │ │ │ │ + * "map-resize" - Existing tiles are resized on zoom and placed below the │ │ │ │ + * base layer. New tiles for the base layer will cover existing tiles. │ │ │ │ + * This setting is recommended when having an overlay duplicated during │ │ │ │ + * the transition is undesirable (e.g. street labels or big transparent │ │ │ │ + * fills). │ │ │ │ + * null - No transition effect. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * A new raster symbolizer. │ │ │ │ + * Using "resize" on non-opaque layers can cause undesired visual │ │ │ │ + * effects. Set transitionEffect to null in this case. │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Raster" │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Style2.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Rule.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Point.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Line.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Polygon.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Text.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Raster.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Style2 │ │ │ │ - * This class represents a collection of rules for rendering features. │ │ │ │ - */ │ │ │ │ -OpenLayers.Style2 = OpenLayers.Class({ │ │ │ │ + transitionEffect: "resize", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique id for this session. │ │ │ │ + * APIProperty: numLoadingTiles │ │ │ │ + * {Integer} How many tiles are still loading? │ │ │ │ */ │ │ │ │ - id: null, │ │ │ │ + numLoadingTiles: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} Style identifier. │ │ │ │ + * Property: serverResolutions │ │ │ │ + * {Array(Number}} This property is documented in subclasses as │ │ │ │ + * an API property. │ │ │ │ */ │ │ │ │ - name: null, │ │ │ │ + serverResolutions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: title │ │ │ │ - * {String} Title of this style. │ │ │ │ + * Property: loading │ │ │ │ + * {Boolean} Indicates if tiles are being loaded. │ │ │ │ */ │ │ │ │ - title: null, │ │ │ │ + loading: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: description │ │ │ │ - * {String} Description of this style. │ │ │ │ + * Property: backBuffer │ │ │ │ + * {DOMElement} The back buffer. │ │ │ │ */ │ │ │ │ - description: null, │ │ │ │ + backBuffer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layerName │ │ │ │ - * {} Name of the layer that this style belongs to, usually │ │ │ │ - * according to the NamedLayer attribute of an SLD document. │ │ │ │ + * Property: gridResolution │ │ │ │ + * {Number} The resolution of the current grid. Used for backbuffer and │ │ │ │ + * client zoom. This property is updated every time the grid is │ │ │ │ + * initialized. │ │ │ │ */ │ │ │ │ - layerName: null, │ │ │ │ + gridResolution: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: isDefault │ │ │ │ - * {Boolean} │ │ │ │ + * Property: backBufferResolution │ │ │ │ + * {Number} The resolution of the current back buffer. This property is │ │ │ │ + * updated each time a back buffer is created. │ │ │ │ */ │ │ │ │ - isDefault: false, │ │ │ │ + backBufferResolution: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: rules │ │ │ │ - * {Array()} Collection of rendering rules. │ │ │ │ + /** │ │ │ │ + * Property: backBufferLonLat │ │ │ │ + * {Object} The top-left corner of the current back buffer. Includes lon │ │ │ │ + * and lat properties. This object is updated each time a back buffer │ │ │ │ + * is created. │ │ │ │ */ │ │ │ │ - rules: null, │ │ │ │ + backBufferLonLat: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Style2 │ │ │ │ - * Creates a style representing a collection of rendering rules. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing properties to be set on the │ │ │ │ - * style. Any documented properties may be set at construction. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} A new style object. │ │ │ │ + /** │ │ │ │ + * Property: backBufferTimerId │ │ │ │ + * {Number} The id of the back buffer timer. This timer is used to │ │ │ │ + * delay the removal of the back buffer, thereby preventing │ │ │ │ + * flash effects caused by tile animation. │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Util.extend(this, config); │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ + backBufferTimerId: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ + /** │ │ │ │ + * APIProperty: removeBackBufferDelay │ │ │ │ + * {Number} Delay for removing the backbuffer when all tiles have finished │ │ │ │ + * loading. Can be set to 0 when no css opacity transitions for the │ │ │ │ + * olTileImage class are used. Default is 0 for layers, │ │ │ │ + * 2500 for tiled layers. See for more information on │ │ │ │ + * tile animation. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ - this.rules[i].destroy(); │ │ │ │ - } │ │ │ │ - delete this.rules; │ │ │ │ - }, │ │ │ │ + removeBackBufferDelay: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this style. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} Clone of this style. │ │ │ │ + * APIProperty: className │ │ │ │ + * {String} Name of the class added to the layer div. If not set in the │ │ │ │ + * options passed to the constructor then className defaults to │ │ │ │ + * "olLayerGridSingleTile" for single tile layers (see ), │ │ │ │ + * and "olLayerGrid" for non single tile layers. │ │ │ │ + * │ │ │ │ + * Note: │ │ │ │ + * │ │ │ │ + * The displaying of tiles is not animated by default for single tile │ │ │ │ + * layers - OpenLayers' default theme (style.css) includes this: │ │ │ │ + * (code) │ │ │ │ + * .olLayerGrid .olTileImage { │ │ │ │ + * -webkit-transition: opacity 0.2s linear; │ │ │ │ + * -moz-transition: opacity 0.2s linear; │ │ │ │ + * -o-transition: opacity 0.2s linear; │ │ │ │ + * transition: opacity 0.2s linear; │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * To animate tile displaying for any grid layer the following │ │ │ │ + * CSS rule can be used: │ │ │ │ + * (code) │ │ │ │ + * .olTileImage { │ │ │ │ + * -webkit-transition: opacity 0.2s linear; │ │ │ │ + * -moz-transition: opacity 0.2s linear; │ │ │ │ + * -o-transition: opacity 0.2s linear; │ │ │ │ + * transition: opacity 0.2s linear; │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * In that case, to avoid flash effects, │ │ │ │ + * should not be zero. │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - var config = OpenLayers.Util.extend({}, this); │ │ │ │ - // clone rules │ │ │ │ - if (this.rules) { │ │ │ │ - config.rules = []; │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ - config.rules.push(this.rules[i].clone()); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return new OpenLayers.Style2(config); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Style2" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WPSDescribeProcess.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WPSDescribeProcess │ │ │ │ - * Read WPS DescribeProcess responses. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WPSDescribeProcess = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.0.0 │ │ │ │ - */ │ │ │ │ - VERSION: "1.0.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsAll.xsd", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - */ │ │ │ │ - defaultPrefix: "wps", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WPSDescribeProcess │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Parse a WPS DescribeProcess and return an object with its information. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - var info = {}; │ │ │ │ - this.readNode(data, info); │ │ │ │ - return info; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wps": { │ │ │ │ - "ProcessDescriptions": function(node, obj) { │ │ │ │ - obj.processDescriptions = {}; │ │ │ │ - this.readChildNodes(node, obj.processDescriptions); │ │ │ │ - }, │ │ │ │ - "ProcessDescription": function(node, processDescriptions) { │ │ │ │ - var processVersion = this.getAttributeNS(node, this.namespaces.wps, "processVersion"); │ │ │ │ - var processDescription = { │ │ │ │ - processVersion: processVersion, │ │ │ │ - statusSupported: (node.getAttribute("statusSupported") === "true"), │ │ │ │ - storeSupported: (node.getAttribute("storeSupported") === "true") │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, processDescription); │ │ │ │ - processDescriptions[processDescription.identifier] = processDescription; │ │ │ │ - }, │ │ │ │ - "DataInputs": function(node, processDescription) { │ │ │ │ - processDescription.dataInputs = []; │ │ │ │ - this.readChildNodes(node, processDescription.dataInputs); │ │ │ │ - }, │ │ │ │ - "ProcessOutputs": function(node, processDescription) { │ │ │ │ - processDescription.processOutputs = []; │ │ │ │ - this.readChildNodes(node, processDescription.processOutputs); │ │ │ │ - }, │ │ │ │ - "Output": function(node, processOutputs) { │ │ │ │ - var output = {}; │ │ │ │ - this.readChildNodes(node, output); │ │ │ │ - processOutputs.push(output); │ │ │ │ - }, │ │ │ │ - "ComplexOutput": function(node, output) { │ │ │ │ - output.complexOutput = {}; │ │ │ │ - this.readChildNodes(node, output.complexOutput); │ │ │ │ - }, │ │ │ │ - "LiteralOutput": function(node, output) { │ │ │ │ - output.literalOutput = {}; │ │ │ │ - this.readChildNodes(node, output.literalOutput); │ │ │ │ - }, │ │ │ │ - "Input": function(node, dataInputs) { │ │ │ │ - var input = { │ │ │ │ - maxOccurs: parseInt(node.getAttribute("maxOccurs")), │ │ │ │ - minOccurs: parseInt(node.getAttribute("minOccurs")) │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, input); │ │ │ │ - dataInputs.push(input); │ │ │ │ - }, │ │ │ │ - "BoundingBoxData": function(node, input) { │ │ │ │ - input.boundingBoxData = {}; │ │ │ │ - this.readChildNodes(node, input.boundingBoxData); │ │ │ │ - }, │ │ │ │ - "CRS": function(node, obj) { │ │ │ │ - if (!obj.CRSs) { │ │ │ │ - obj.CRSs = {}; │ │ │ │ - } │ │ │ │ - obj.CRSs[this.getChildValue(node)] = true; │ │ │ │ - }, │ │ │ │ - "LiteralData": function(node, input) { │ │ │ │ - input.literalData = {}; │ │ │ │ - this.readChildNodes(node, input.literalData); │ │ │ │ - }, │ │ │ │ - "ComplexData": function(node, input) { │ │ │ │ - input.complexData = {}; │ │ │ │ - this.readChildNodes(node, input.complexData); │ │ │ │ - }, │ │ │ │ - "Default": function(node, complexData) { │ │ │ │ - complexData["default"] = {}; │ │ │ │ - this.readChildNodes(node, complexData["default"]); │ │ │ │ - }, │ │ │ │ - "Supported": function(node, complexData) { │ │ │ │ - complexData["supported"] = {}; │ │ │ │ - this.readChildNodes(node, complexData["supported"]); │ │ │ │ - }, │ │ │ │ - "Format": function(node, obj) { │ │ │ │ - var format = {}; │ │ │ │ - this.readChildNodes(node, format); │ │ │ │ - if (!obj.formats) { │ │ │ │ - obj.formats = {}; │ │ │ │ - } │ │ │ │ - obj.formats[format.mimeType] = true; │ │ │ │ - }, │ │ │ │ - "MimeType": function(node, format) { │ │ │ │ - format.mimeType = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WPSDescribeProcess" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/WPSClient.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - * @requires OpenLayers/WPSProcess.js │ │ │ │ - * @requires OpenLayers/Format/WPSDescribeProcess.js │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.WPSClient │ │ │ │ - * High level API for interaction with Web Processing Services (WPS). │ │ │ │ - * An instance is used to create │ │ │ │ - * instances for servers known to the WPSClient. The WPSClient also caches │ │ │ │ - * DescribeProcess responses to reduce the number of requests sent to servers │ │ │ │ - * when processes are created. │ │ │ │ - */ │ │ │ │ -OpenLayers.WPSClient = OpenLayers.Class({ │ │ │ │ + className: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: servers │ │ │ │ - * {Object} Service metadata, keyed by a local identifier. │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * layer.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ - * Properties: │ │ │ │ - * url - {String} the url of the server │ │ │ │ - * version - {String} WPS version of the server │ │ │ │ - * processDescription - {Object} Cache of raw DescribeProcess │ │ │ │ - * responses, keyed by process identifier. │ │ │ │ + * 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 layer.events.object. │ │ │ │ + * element - {DOMElement} A reference to layer.events.element. │ │ │ │ + * │ │ │ │ + * Supported event types: │ │ │ │ + * addtile - Triggered when a tile is added to this layer. Listeners receive │ │ │ │ + * an object as first argument, which has a tile property that │ │ │ │ + * references the tile that has been added. │ │ │ │ + * tileloadstart - Triggered when a tile starts loading. Listeners receive │ │ │ │ + * an object as first argument, which has a tile property that │ │ │ │ + * references the tile that starts loading. │ │ │ │ + * tileloaded - Triggered when each new tile is │ │ │ │ + * loaded, as a means of progress update to listeners. │ │ │ │ + * listeners can access 'numLoadingTiles' if they wish to keep │ │ │ │ + * track of the loading progress. Listeners are called with an object │ │ │ │ + * with a 'tile' property as first argument, making the loaded tile │ │ │ │ + * available to the listener, and an 'aborted' property, which will be │ │ │ │ + * true when loading was aborted and no tile data is available. │ │ │ │ + * tileerror - Triggered before the tileloaded event (i.e. when the tile is │ │ │ │ + * still hidden) if a tile failed to load. Listeners receive an object │ │ │ │ + * as first argument, which has a tile property that references the │ │ │ │ + * tile that could not be loaded. │ │ │ │ + * retile - Triggered when the layer recreates its tile grid. │ │ │ │ */ │ │ │ │ - servers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The default WPS version to use if none is configured. Default │ │ │ │ - * is '1.0.0'. │ │ │ │ + * Property: gridLayout │ │ │ │ + * {Object} Object containing properties tilelon, tilelat, startcol, │ │ │ │ + * startrow │ │ │ │ */ │ │ │ │ - version: '1.0.0', │ │ │ │ + gridLayout: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: lazy │ │ │ │ - * {Boolean} Should the DescribeProcess be deferred until a process is │ │ │ │ - * fully configured? Default is false. │ │ │ │ + * Property: rowSign │ │ │ │ + * {Number} 1 for grids starting at the top, -1 for grids starting at the │ │ │ │ + * bottom. This is used for several grid index and offset calculations. │ │ │ │ */ │ │ │ │ - lazy: false, │ │ │ │ + rowSign: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: events │ │ │ │ - * {} │ │ │ │ - * │ │ │ │ - * Supported event types: │ │ │ │ - * describeprocess - Fires when the process description is available. │ │ │ │ - * Listeners receive an object with a 'raw' property holding the raw │ │ │ │ - * DescribeProcess response, and an 'identifier' property holding the │ │ │ │ - * process identifier of the described process. │ │ │ │ + * Property: transitionendEvents │ │ │ │ + * {Array} Event names for transitionend │ │ │ │ */ │ │ │ │ - events: null, │ │ │ │ + transitionendEvents: [ │ │ │ │ + 'transitionend', 'webkitTransitionEnd', 'otransitionend', │ │ │ │ + 'oTransitionEnd' │ │ │ │ + ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.WPSClient │ │ │ │ + * Constructor: OpenLayers.Layer.Grid │ │ │ │ + * Create a new grid layer │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Object whose properties will be set on the instance. │ │ │ │ - * │ │ │ │ - * Avaliable options: │ │ │ │ - * servers - {Object} Mandatory. Service metadata, keyed by a local │ │ │ │ - * identifier. Can either be a string with the service url or an │ │ │ │ - * object literal with additional metadata: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * servers: { │ │ │ │ - * local: '/geoserver/wps' │ │ │ │ - * }, { │ │ │ │ - * opengeo: { │ │ │ │ - * url: 'http://demo.opengeo.org/geoserver/wps', │ │ │ │ - * version: '1.0.0' │ │ │ │ - * } │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * lazy - {Boolean} Optional. Set to true if DescribeProcess should not be │ │ │ │ - * requested until a process is fully configured. Default is false. │ │ │ │ + * name - {String} │ │ │ │ + * url - {String} │ │ │ │ + * params - {Object} │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.events = new OpenLayers.Events(this); │ │ │ │ - this.servers = {}; │ │ │ │ - for (var s in options.servers) { │ │ │ │ - this.servers[s] = typeof options.servers[s] == 'string' ? { │ │ │ │ - url: options.servers[s], │ │ │ │ - version: this.version, │ │ │ │ - processDescription: {} │ │ │ │ - } : options.servers[s]; │ │ │ │ - } │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.initialize.apply(this, │ │ │ │ + arguments); │ │ │ │ + this.grid = []; │ │ │ │ + this._removeBackBuffer = OpenLayers.Function.bind(this.removeBackBuffer, this); │ │ │ │ + │ │ │ │ + this.initProperties(); │ │ │ │ + │ │ │ │ + this.rowSign = this.tileOriginCorner.substr(0, 1) === "t" ? 1 : -1; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: execute │ │ │ │ - * Shortcut to execute a process with a single function call. This is │ │ │ │ - * equivalent to using and then calling execute on the │ │ │ │ - * process. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Options for the execute operation. │ │ │ │ - * │ │ │ │ - * Available options: │ │ │ │ - * server - {String} Mandatory. One of the local identifiers of the │ │ │ │ - * configured servers. │ │ │ │ - * process - {String} Mandatory. A process identifier known to the │ │ │ │ - * server. │ │ │ │ - * inputs - {Object} The inputs for the process, keyed by input identifier. │ │ │ │ - * For spatial data inputs, the value of an input is usually an │ │ │ │ - * , an or an array of │ │ │ │ - * geometries or features. │ │ │ │ - * output - {String} The identifier of an output to parse. Optional. If not │ │ │ │ - * provided, the first output will be parsed. │ │ │ │ - * success - {Function} Callback to call when the process is complete. │ │ │ │ - * This function is called with an outputs object as argument, which │ │ │ │ - * will have a property with the identifier of the requested output │ │ │ │ - * (e.g. 'result'). For processes that generate spatial output, the │ │ │ │ - * value will either be a single or an │ │ │ │ - * array of features. │ │ │ │ - * scope - {Object} Optional scope for the success callback. │ │ │ │ + * Method: initProperties │ │ │ │ + * Set any properties that depend on the value of singleTile. │ │ │ │ + * Currently sets removeBackBufferDelay and className │ │ │ │ */ │ │ │ │ - execute: function(options) { │ │ │ │ - var process = this.getProcess(options.server, options.process); │ │ │ │ - process.execute({ │ │ │ │ - inputs: options.inputs, │ │ │ │ - success: options.success, │ │ │ │ - scope: options.scope │ │ │ │ - }); │ │ │ │ + initProperties: function() { │ │ │ │ + if (this.options.removeBackBufferDelay === undefined) { │ │ │ │ + this.removeBackBufferDelay = this.singleTile ? 0 : 2500; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.options.className === undefined) { │ │ │ │ + this.className = this.singleTile ? 'olLayerGridSingleTile' : │ │ │ │ + 'olLayerGrid'; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getProcess │ │ │ │ - * Creates an . │ │ │ │ + * Method: setMap │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * serverID - {String} Local identifier from the servers that this instance │ │ │ │ - * was constructed with. │ │ │ │ - * processID - {String} Process identifier known to the server. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} │ │ │ │ + * map - {} The map. │ │ │ │ */ │ │ │ │ - getProcess: function(serverID, processID) { │ │ │ │ - var process = new OpenLayers.WPSProcess({ │ │ │ │ - client: this, │ │ │ │ - server: serverID, │ │ │ │ - identifier: processID │ │ │ │ - }); │ │ │ │ - if (!this.lazy) { │ │ │ │ - process.describe(); │ │ │ │ - } │ │ │ │ - return process; │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.setMap.call(this, map); │ │ │ │ + OpenLayers.Element.addClass(this.div, this.className); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: describeProcess │ │ │ │ + * Method: removeMap │ │ │ │ + * Called when the layer is removed from the map. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * serverID - {String} Identifier of the server │ │ │ │ - * processID - {String} Identifier of the requested process │ │ │ │ - * callback - {Function} Callback to call when the description is available │ │ │ │ - * scope - {Object} Optional execution scope for the callback function │ │ │ │ + * map - {} The map. │ │ │ │ */ │ │ │ │ - describeProcess: function(serverID, processID, callback, scope) { │ │ │ │ - var server = this.servers[serverID]; │ │ │ │ - if (!server.processDescription[processID]) { │ │ │ │ - if (!(processID in server.processDescription)) { │ │ │ │ - // set to null so we know a describeFeature request is pending │ │ │ │ - server.processDescription[processID] = null; │ │ │ │ - OpenLayers.Request.GET({ │ │ │ │ - url: server.url, │ │ │ │ - params: { │ │ │ │ - SERVICE: 'WPS', │ │ │ │ - VERSION: server.version, │ │ │ │ - REQUEST: 'DescribeProcess', │ │ │ │ - IDENTIFIER: processID │ │ │ │ - }, │ │ │ │ - success: function(response) { │ │ │ │ - server.processDescription[processID] = response.responseText; │ │ │ │ - this.events.triggerEvent('describeprocess', { │ │ │ │ - identifier: processID, │ │ │ │ - raw: response.responseText │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - // pending request │ │ │ │ - this.events.register('describeprocess', this, function describe(evt) { │ │ │ │ - if (evt.identifier === processID) { │ │ │ │ - this.events.unregister('describeprocess', this, describe); │ │ │ │ - callback.call(scope, evt.raw); │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - window.setTimeout(function() { │ │ │ │ - callback.call(scope, server.processDescription[processID]); │ │ │ │ - }, 0); │ │ │ │ - } │ │ │ │ + removeMap: function(map) { │ │ │ │ + this.removeBackBuffer(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Deconstruct the layer and clear the grid. │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - this.servers = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: 'OpenLayers.WPSClient' │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Popup.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * 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: contentSize │ │ │ │ - * {} the width and height of the content. │ │ │ │ - */ │ │ │ │ - contentSize: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: size │ │ │ │ - * {} the width and height of the popup. │ │ │ │ - */ │ │ │ │ - size: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: contentHTML │ │ │ │ - * {String} An HTML string for this popup to display. │ │ │ │ - */ │ │ │ │ - contentHTML: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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, │ │ │ │ + this.removeBackBuffer(); │ │ │ │ + this.clearGrid(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: autoSize │ │ │ │ - * {Boolean} Resize the popup to auto-fit the contents. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - autoSize: false, │ │ │ │ + this.grid = null; │ │ │ │ + this.tileSize = null; │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: minSize │ │ │ │ - * {} Minimum size allowed for the popup's contents. │ │ │ │ + * APIMethod: mergeNewParams │ │ │ │ + * Refetches tiles with new params merged, keeping a backbuffer. Each │ │ │ │ + * loading new tile will have a css class of '.olTileReplacing'. If a │ │ │ │ + * stylesheet applies a 'display: none' style to that class, any fade-in │ │ │ │ + * transition will not apply, and backbuffers for each tile will be removed │ │ │ │ + * as soon as the tile is loaded. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * newParams - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * redrawn: {Boolean} whether the layer was actually redrawn. │ │ │ │ */ │ │ │ │ - minSize: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxSize │ │ │ │ - * {} Maximum size allowed for the popup's contents. │ │ │ │ - */ │ │ │ │ - maxSize: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: displayClass │ │ │ │ - * {String} The CSS class of the popup. │ │ │ │ + * Method: clearGrid │ │ │ │ + * Go through and remove all tiles from the grid, calling │ │ │ │ + * destroy() on each of them to kill circular references │ │ │ │ */ │ │ │ │ - displayClass: "olPopup", │ │ │ │ + clearGrid: function() { │ │ │ │ + if (this.grid) { │ │ │ │ + for (var iRow = 0, len = this.grid.length; iRow < len; iRow++) { │ │ │ │ + var row = this.grid[iRow]; │ │ │ │ + for (var iCol = 0, clen = row.length; iCol < clen; iCol++) { │ │ │ │ + var tile = row[iCol]; │ │ │ │ + this.destroyTile(tile); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.grid = []; │ │ │ │ + this.gridResolution = null; │ │ │ │ + this.gridLayout = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: contentDisplayClass │ │ │ │ - * {String} The CSS class of the popup content div. │ │ │ │ + /** │ │ │ │ + * APIMethod: addOptions │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * newOptions - {Object} │ │ │ │ + * reinitialize - {Boolean} If set to true, and if resolution options of the │ │ │ │ + * current baseLayer were changed, the map will be recentered to make │ │ │ │ + * sure that it is displayed with a valid resolution, and a │ │ │ │ + * changebaselayer event will be triggered. │ │ │ │ */ │ │ │ │ - contentDisplayClass: "olPopupContent", │ │ │ │ + addOptions: function(newOptions, reinitialize) { │ │ │ │ + var singleTileChanged = newOptions.singleTile !== undefined && │ │ │ │ + newOptions.singleTile !== this.singleTile; │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.addOptions.apply(this, arguments); │ │ │ │ + if (this.map && singleTileChanged) { │ │ │ │ + this.initProperties(); │ │ │ │ + this.clearGrid(); │ │ │ │ + this.tileSize = this.options.tileSize; │ │ │ │ + this.setTileSize(); │ │ │ │ + this.moveTo(null, true); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Create a clone of this layer │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} Is this ever used? │ │ │ │ * │ │ │ │ - * 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. │ │ │ │ + * Returns: │ │ │ │ + * {} An exact clone of this OpenLayers.Layer.Grid │ │ │ │ */ │ │ │ │ - padding: 0, │ │ │ │ + clone: function(obj) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: disableFirefoxOverflowHack │ │ │ │ - * {Boolean} The hack for overflow in Firefox causes all elements │ │ │ │ - * to be re-drawn, which causes Flash elements to be │ │ │ │ - * re-initialized, which is troublesome. │ │ │ │ - * With this property the hack can be disabled. │ │ │ │ - */ │ │ │ │ - disableFirefoxOverflowHack: false, │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Grid(this.name, │ │ │ │ + this.url, │ │ │ │ + this.params, │ │ │ │ + this.getOptions()); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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 │ │ │ │ - ); │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.HTTPRequest.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + if (this.tileSize != null) { │ │ │ │ + obj.tileSize = this.tileSize.clone(); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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, │ │ │ │ + // we do not want to copy reference to grid, so we make a new array │ │ │ │ + obj.grid = []; │ │ │ │ + obj.gridResolution = null; │ │ │ │ + // same for backbuffer │ │ │ │ + obj.backBuffer = null; │ │ │ │ + obj.backBufferTimerId = null; │ │ │ │ + obj.loading = false; │ │ │ │ + obj.numLoadingTiles = 0; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: keepInMap │ │ │ │ - * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ - * contrain the popup such that it always fits in the available map │ │ │ │ - * space. By default, this is not set on the base class. If you are │ │ │ │ - * creating popups that are near map edges and not allowing pannning, │ │ │ │ - * and especially if you have a popup which has a │ │ │ │ - * fixedRelativePosition, setting this to false may be a smart thing to │ │ │ │ - * do. Subclasses may want to override this setting. │ │ │ │ - * │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - keepInMap: false, │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: closeOnMove │ │ │ │ - * {Boolean} When map pans, close the popup. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - closeOnMove: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {} this gets set in Map.js when the popup is added to the map │ │ │ │ + * Method: moveTo │ │ │ │ + * This function is called whenever the map is moved. All the moving │ │ │ │ + * of actual 'tiles' is done by the map, but moveTo's role is to accept │ │ │ │ + * a bounds and make sure the data that that bounds requires is pre-loaded. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {} │ │ │ │ + * zoomChanged - {Boolean} │ │ │ │ + * dragging - {Boolean} │ │ │ │ */ │ │ │ │ - map: null, │ │ │ │ + moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ - * contentSize - {} The size of the content. │ │ │ │ - * contentHTML - {String} An HTML string 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, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ - if (id == null) { │ │ │ │ - id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - } │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments); │ │ │ │ │ │ │ │ - this.id = id; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ + bounds = bounds || this.map.getExtent(); │ │ │ │ │ │ │ │ - this.contentSize = (contentSize != null) ? contentSize : │ │ │ │ - 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; │ │ │ │ + if (bounds != null) { │ │ │ │ │ │ │ │ - this.div = OpenLayers.Util.createDiv(this.id, null, null, │ │ │ │ - null, null, null, "hidden"); │ │ │ │ - this.div.className = this.displayClass; │ │ │ │ + // if grid is empty or zoom has changed, we *must* re-tile │ │ │ │ + var forceReTile = !this.grid.length || zoomChanged; │ │ │ │ │ │ │ │ - var groupDivId = this.id + "_GroupDiv"; │ │ │ │ - this.groupDiv = OpenLayers.Util.createDiv(groupDivId, null, null, │ │ │ │ - null, "relative", null, │ │ │ │ - "hidden"); │ │ │ │ + // total bounds of the tiles │ │ │ │ + var tilesBounds = this.getTilesBounds(); │ │ │ │ │ │ │ │ - var id = this.div.id + "_contentDiv"; │ │ │ │ - this.contentDiv = OpenLayers.Util.createDiv(id, null, this.contentSize.clone(), │ │ │ │ - null, "relative"); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass; │ │ │ │ - this.groupDiv.appendChild(this.contentDiv); │ │ │ │ - this.div.appendChild(this.groupDiv); │ │ │ │ + // the new map resolution │ │ │ │ + var resolution = this.map.getResolution(); │ │ │ │ │ │ │ │ - if (closeBox) { │ │ │ │ - this.addCloseBox(closeBoxCallback); │ │ │ │ - } │ │ │ │ + // the server-supported resolution for the new map resolution │ │ │ │ + var serverResolution = this.getServerResolution(resolution); │ │ │ │ │ │ │ │ - this.registerEvents(); │ │ │ │ - }, │ │ │ │ + if (this.singleTile) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ + // We want to redraw whenever even the slightest part of the │ │ │ │ + // current bounds is not contained by our tile. │ │ │ │ + // (thus, we do not specify partial -- its default is false) │ │ │ │ │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.size = null; │ │ │ │ - this.contentHTML = null; │ │ │ │ + if (forceReTile || │ │ │ │ + (!dragging && !tilesBounds.containsBounds(bounds))) { │ │ │ │ │ │ │ │ - this.backgroundColor = null; │ │ │ │ - this.opacity = null; │ │ │ │ - this.border = null; │ │ │ │ + // In single tile mode with no transition effect, we insert │ │ │ │ + // a non-scaled backbuffer when the layer is moved. But if │ │ │ │ + // a zoom occurs right after a move, i.e. before the new │ │ │ │ + // image is received, we need to remove the backbuffer, or │ │ │ │ + // an ill-positioned image will be visible during the zoom │ │ │ │ + // transition. │ │ │ │ │ │ │ │ - if (this.closeOnMove && this.map) { │ │ │ │ - this.map.events.unregister("movestart", this, this.hide); │ │ │ │ - } │ │ │ │ + if (zoomChanged && this.transitionEffect !== 'resize') { │ │ │ │ + this.removeBackBuffer(); │ │ │ │ + } │ │ │ │ │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ + if (!zoomChanged || this.transitionEffect === 'resize') { │ │ │ │ + this.applyBackBuffer(resolution); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (this.closeDiv) { │ │ │ │ - OpenLayers.Event.stopObservingElement(this.closeDiv); │ │ │ │ - this.groupDiv.removeChild(this.closeDiv); │ │ │ │ - } │ │ │ │ - this.closeDiv = null; │ │ │ │ + this.initSingleTile(bounds); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ │ │ │ │ - this.div.removeChild(this.groupDiv); │ │ │ │ - this.groupDiv = null; │ │ │ │ + // if the bounds have changed such that they are not even │ │ │ │ + // *partially* contained by our tiles (e.g. when user has │ │ │ │ + // programmatically panned to the other side of the earth on │ │ │ │ + // zoom level 18), then moveGriddedTiles could potentially have │ │ │ │ + // to run through thousands of cycles, so we want to reTile │ │ │ │ + // instead (thus, partial true). │ │ │ │ + forceReTile = forceReTile || │ │ │ │ + !tilesBounds.intersectsBounds(bounds, { │ │ │ │ + worldBounds: this.map.baseLayer.wrapDateLine && │ │ │ │ + this.map.getMaxExtent() │ │ │ │ + }); │ │ │ │ │ │ │ │ - if (this.map != null) { │ │ │ │ - this.map.removePopup(this); │ │ │ │ + if (forceReTile) { │ │ │ │ + if (zoomChanged && (this.transitionEffect === 'resize' || │ │ │ │ + this.gridResolution === resolution)) { │ │ │ │ + this.applyBackBuffer(resolution); │ │ │ │ + } │ │ │ │ + this.initGriddedTiles(bounds); │ │ │ │ + } else { │ │ │ │ + this.moveGriddedTiles(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - 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. │ │ │ │ + /** │ │ │ │ + * Method: getTileData │ │ │ │ + * Given a map location, retrieve a tile and the pixel offset within that │ │ │ │ + * tile corresponding to the location. If there is not an existing │ │ │ │ + * tile in the grid that covers the given location, null will be │ │ │ │ + * returned. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * px - {} the position the popup in pixels. │ │ │ │ - * │ │ │ │ + * loc - {} map location │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} Reference to a div that contains the drawn popup │ │ │ │ + * {Object} Object with the following properties: tile ({}), │ │ │ │ + * i ({Number} x-pixel offset from top left), and j ({Integer} y-pixel │ │ │ │ + * offset from top left). │ │ │ │ */ │ │ │ │ - draw: function(px) { │ │ │ │ - if (px == null) { │ │ │ │ - if ((this.lonlat != null) && (this.map != null)) { │ │ │ │ - px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + getTileData: function(loc) { │ │ │ │ + var data = null, │ │ │ │ + x = loc.lon, │ │ │ │ + y = loc.lat, │ │ │ │ + numRows = this.grid.length; │ │ │ │ │ │ │ │ - // this assumes that this.map already exists, which is okay because │ │ │ │ - // this.draw is only called once the popup has been added to the map. │ │ │ │ - if (this.closeOnMove) { │ │ │ │ - this.map.events.register("movestart", this, this.hide); │ │ │ │ - } │ │ │ │ + if (this.map && numRows) { │ │ │ │ + var res = this.map.getResolution(), │ │ │ │ + tileWidth = this.tileSize.w, │ │ │ │ + tileHeight = this.tileSize.h, │ │ │ │ + bounds = this.grid[0][0].bounds, │ │ │ │ + left = bounds.left, │ │ │ │ + top = bounds.top; │ │ │ │ │ │ │ │ - //listen to movestart, moveend to disable overflow (FF bug) │ │ │ │ - if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == '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"; │ │ │ │ + if (x < left) { │ │ │ │ + // deal with multiple worlds │ │ │ │ + if (this.map.baseLayer.wrapDateLine) { │ │ │ │ + var worldWidth = this.map.getMaxExtent().getWidth(); │ │ │ │ + var worldsAway = Math.ceil((left - x) / worldWidth); │ │ │ │ + x += worldWidth * worldsAway; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - this.map.events.register("moveend", this, function() { │ │ │ │ - var oldOverflow = this.contentDiv._oldOverflow; │ │ │ │ - if (oldOverflow) { │ │ │ │ - this.contentDiv.style.overflow = oldOverflow; │ │ │ │ - this.contentDiv._oldOverflow = null; │ │ │ │ + } │ │ │ │ + // tile distance to location (fractional number of tiles); │ │ │ │ + var dtx = (x - left) / (res * tileWidth); │ │ │ │ + var dty = (top - y) / (res * tileHeight); │ │ │ │ + // index of tile in grid │ │ │ │ + var col = Math.floor(dtx); │ │ │ │ + var row = Math.floor(dty); │ │ │ │ + if (row >= 0 && row < numRows) { │ │ │ │ + var tile = this.grid[row][col]; │ │ │ │ + if (tile) { │ │ │ │ + data = { │ │ │ │ + tile: tile, │ │ │ │ + // pixel index within tile │ │ │ │ + i: Math.floor((dtx - col) * tileWidth), │ │ │ │ + j: Math.floor((dty - row) * tileHeight) │ │ │ │ + }; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.moveTo(px); │ │ │ │ - if (!this.autoSize && !this.size) { │ │ │ │ - this.setSize(this.contentSize); │ │ │ │ - } │ │ │ │ - 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); │ │ │ │ } │ │ │ │ } │ │ │ │ + return data; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveTo │ │ │ │ - * │ │ │ │ + * Method: destroyTile │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * px - {} the top and left position of the popup div. │ │ │ │ + * tile - {} │ │ │ │ */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - if ((px != null) && (this.div != null)) { │ │ │ │ - this.div.style.left = px.x + "px"; │ │ │ │ - this.div.style.top = px.y + "px"; │ │ │ │ - } │ │ │ │ + destroyTile: function(tile) { │ │ │ │ + this.removeTileMonitoringHooks(tile); │ │ │ │ + tile.destroy(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: visible │ │ │ │ + * Method: getServerResolution │ │ │ │ + * Return the closest server-supported resolution. │ │ │ │ * │ │ │ │ - * 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. │ │ │ │ + * Parameters: │ │ │ │ + * resolution - {Number} The base resolution. If undefined the │ │ │ │ + * map resolution is used. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} The closest server resolution value. │ │ │ │ */ │ │ │ │ - show: function() { │ │ │ │ - this.div.style.display = ''; │ │ │ │ - │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView(); │ │ │ │ + getServerResolution: function(resolution) { │ │ │ │ + var distance = Number.POSITIVE_INFINITY; │ │ │ │ + resolution = resolution || this.map.getResolution(); │ │ │ │ + if (this.serverResolutions && │ │ │ │ + OpenLayers.Util.indexOf(this.serverResolutions, resolution) === -1) { │ │ │ │ + var i, newDistance, newResolution, serverResolution; │ │ │ │ + for (i = this.serverResolutions.length - 1; i >= 0; i--) { │ │ │ │ + newResolution = this.serverResolutions[i]; │ │ │ │ + newDistance = Math.abs(newResolution - resolution); │ │ │ │ + if (newDistance > distance) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + distance = newDistance; │ │ │ │ + serverResolution = newResolution; │ │ │ │ + } │ │ │ │ + resolution = serverResolution; │ │ │ │ } │ │ │ │ + return resolution; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: hide │ │ │ │ - * Makes the popup invisible. │ │ │ │ + * Method: getServerZoom │ │ │ │ + * Return the zoom value corresponding to the best matching server │ │ │ │ + * resolution, taking into account and . │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} The closest server supported zoom. This is not the map zoom │ │ │ │ + * level, but an index of the server's resolutions array. │ │ │ │ */ │ │ │ │ - hide: function() { │ │ │ │ - this.div.style.display = 'none'; │ │ │ │ + getServerZoom: function() { │ │ │ │ + var resolution = this.getServerResolution(); │ │ │ │ + return this.serverResolutions ? │ │ │ │ + OpenLayers.Util.indexOf(this.serverResolutions, resolution) : │ │ │ │ + this.map.getZoomForResolution(resolution) + (this.zoomOffset || 0); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setSize │ │ │ │ - * Used to adjust the size of the popup. │ │ │ │ + * Method: applyBackBuffer │ │ │ │ + * Create, insert, scale and position a back buffer for the layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * contentSize - {} the new size for the popup's │ │ │ │ - * contents div (in pixels). │ │ │ │ + * resolution - {Number} The resolution to transition to. │ │ │ │ */ │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - this.size = contentSize.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; │ │ │ │ + applyBackBuffer: function(resolution) { │ │ │ │ + if (this.backBufferTimerId !== null) { │ │ │ │ + this.removeBackBuffer(); │ │ │ │ + } │ │ │ │ + var backBuffer = this.backBuffer; │ │ │ │ + if (!backBuffer) { │ │ │ │ + backBuffer = this.createBackBuffer(); │ │ │ │ + if (!backBuffer) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + if (resolution === this.gridResolution) { │ │ │ │ + this.div.insertBefore(backBuffer, this.div.firstChild); │ │ │ │ + } else { │ │ │ │ + this.map.baseLayer.div.parentNode.insertBefore(backBuffer, this.map.baseLayer.div); │ │ │ │ + } │ │ │ │ + this.backBuffer = backBuffer; │ │ │ │ │ │ │ │ - // make extra space for the close div │ │ │ │ - if (this.closeDiv) { │ │ │ │ - var closeDivWidth = parseInt(this.closeDiv.style.width); │ │ │ │ - wPadding += closeDivWidth + contentDivPadding.right; │ │ │ │ + // set some information in the instance for subsequent │ │ │ │ + // calls to applyBackBuffer where the same back buffer │ │ │ │ + // is reused │ │ │ │ + var topLeftTileBounds = this.grid[0][0].bounds; │ │ │ │ + this.backBufferLonLat = { │ │ │ │ + lon: topLeftTileBounds.left, │ │ │ │ + lat: topLeftTileBounds.top │ │ │ │ + }; │ │ │ │ + this.backBufferResolution = this.gridResolution; │ │ │ │ } │ │ │ │ │ │ │ │ - //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; │ │ │ │ + var ratio = this.backBufferResolution / resolution; │ │ │ │ │ │ │ │ - //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.BROWSER_NAME == "msie") { │ │ │ │ - this.contentSize.w += │ │ │ │ - contentDivPadding.left + contentDivPadding.right; │ │ │ │ - this.contentSize.h += │ │ │ │ - contentDivPadding.bottom + contentDivPadding.top; │ │ │ │ + // scale the tiles inside the back buffer │ │ │ │ + var tiles = backBuffer.childNodes, │ │ │ │ + tile; │ │ │ │ + for (var i = tiles.length - 1; i >= 0; --i) { │ │ │ │ + tile = tiles[i]; │ │ │ │ + tile.style.top = ((ratio * tile._i * tile._h) | 0) + 'px'; │ │ │ │ + tile.style.left = ((ratio * tile._j * tile._w) | 0) + 'px'; │ │ │ │ + tile.style.width = Math.round(ratio * tile._w) + 'px'; │ │ │ │ + tile.style.height = Math.round(ratio * tile._h) + 'px'; │ │ │ │ } │ │ │ │ │ │ │ │ - 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"; │ │ │ │ - } │ │ │ │ + // and position it (based on the grid's top-left corner) │ │ │ │ + var position = this.getViewPortPxFromLonLat( │ │ │ │ + this.backBufferLonLat, resolution); │ │ │ │ + var leftOffset = this.map.layerContainerOriginPx.x; │ │ │ │ + var topOffset = this.map.layerContainerOriginPx.y; │ │ │ │ + backBuffer.style.left = Math.round(position.x - leftOffset) + 'px'; │ │ │ │ + backBuffer.style.top = Math.round(position.y - topOffset) + 'px'; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: updateSize │ │ │ │ - * Auto size the popup so that it precisely fits its contents (as │ │ │ │ - * determined by this.contentDiv.innerHTML). Popup size will, of │ │ │ │ - * course, be limited by the available space on the current map │ │ │ │ + * Method: createBackBuffer │ │ │ │ + * Create a back buffer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The DOM element for the back buffer, undefined if the │ │ │ │ + * grid isn't initialized yet. │ │ │ │ */ │ │ │ │ - updateSize: function() { │ │ │ │ - │ │ │ │ - // determine actual render dimensions of the contents by putting its │ │ │ │ - // contents into a fake contentDiv (for the CSS) and then measuring it │ │ │ │ - var preparedHTML = "
" + │ │ │ │ - this.contentDiv.innerHTML + │ │ │ │ - "
"; │ │ │ │ - │ │ │ │ - var containerElement = (this.map) ? this.map.div : document.body; │ │ │ │ - var realSize = OpenLayers.Util.getRenderedDimensions( │ │ │ │ - preparedHTML, null, { │ │ │ │ - displayClass: this.displayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // 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 'size' object with the clipped dimensions │ │ │ │ - // set or null if not clipped. │ │ │ │ - var fixedSize = { │ │ │ │ - w: (safeSize.w < realSize.w) ? safeSize.w : null, │ │ │ │ - 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( │ │ │ │ - preparedHTML, fixedSize, { │ │ │ │ - displayClass: this.contentDisplayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - │ │ │ │ - //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; │ │ │ │ + createBackBuffer: function() { │ │ │ │ + var backBuffer; │ │ │ │ + if (this.grid.length > 0) { │ │ │ │ + backBuffer = document.createElement('div'); │ │ │ │ + backBuffer.id = this.div.id + '_bb'; │ │ │ │ + backBuffer.className = 'olBackBuffer'; │ │ │ │ + backBuffer.style.position = 'absolute'; │ │ │ │ + var map = this.map; │ │ │ │ + backBuffer.style.zIndex = this.transitionEffect === 'resize' ? │ │ │ │ + this.getZIndex() - 1 : │ │ │ │ + // 'map-resize': │ │ │ │ + map.Z_INDEX_BASE.BaseLayer - │ │ │ │ + (map.getNumLayers() - map.getLayerIndex(this)); │ │ │ │ + for (var i = 0, lenI = this.grid.length; i < lenI; i++) { │ │ │ │ + for (var j = 0, lenJ = this.grid[i].length; j < lenJ; j++) { │ │ │ │ + var tile = this.grid[i][j], │ │ │ │ + markup = this.grid[i][j].createBackBuffer(); │ │ │ │ + if (markup) { │ │ │ │ + markup._i = i; │ │ │ │ + markup._j = j; │ │ │ │ + markup._w = tile.size.w; │ │ │ │ + markup._h = tile.size.h; │ │ │ │ + markup.id = tile.id + '_bb'; │ │ │ │ + backBuffer.appendChild(markup); │ │ │ │ } │ │ │ │ } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return backBuffer; │ │ │ │ + }, │ │ │ │ │ │ │ │ - newSize = this.getSafeContentSize(clippedSize); │ │ │ │ + /** │ │ │ │ + * Method: removeBackBuffer │ │ │ │ + * Remove back buffer from DOM. │ │ │ │ + */ │ │ │ │ + removeBackBuffer: function() { │ │ │ │ + if (this._transitionElement) { │ │ │ │ + for (var i = this.transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ + OpenLayers.Event.stopObserving(this._transitionElement, │ │ │ │ + this.transitionendEvents[i], this._removeBackBuffer); │ │ │ │ + } │ │ │ │ + delete this._transitionElement; │ │ │ │ + } │ │ │ │ + if (this.backBuffer) { │ │ │ │ + if (this.backBuffer.parentNode) { │ │ │ │ + this.backBuffer.parentNode.removeChild(this.backBuffer); │ │ │ │ + } │ │ │ │ + this.backBuffer = null; │ │ │ │ + this.backBufferResolution = null; │ │ │ │ + if (this.backBufferTimerId !== null) { │ │ │ │ + window.clearTimeout(this.backBufferTimerId); │ │ │ │ + this.backBufferTimerId = null; │ │ │ │ } │ │ │ │ } │ │ │ │ - this.setSize(newSize); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setBackgroundColor │ │ │ │ - * Sets the background color of the popup. │ │ │ │ + * Method: moveByPx │ │ │ │ + * Move the layer based on pixel vector. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * color - {String} the background color. eg "#FFBBBB" │ │ │ │ + * dx - {Number} │ │ │ │ + * dy - {Number} │ │ │ │ */ │ │ │ │ - setBackgroundColor: function(color) { │ │ │ │ - if (color != undefined) { │ │ │ │ - this.backgroundColor = color; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.backgroundColor = this.backgroundColor; │ │ │ │ + moveByPx: function(dx, dy) { │ │ │ │ + if (!this.singleTile) { │ │ │ │ + this.moveGriddedTiles(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setOpacity │ │ │ │ - * Sets the opacity of the popup. │ │ │ │ + * APIMethod: setTileSize │ │ │ │ + * Check if we are in singleTile mode and if so, set the size as a ratio │ │ │ │ + * of the map size (as specified by the layer's 'ratio' property). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ + * size - {} │ │ │ │ */ │ │ │ │ - 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 + ')'; │ │ │ │ + setTileSize: function(size) { │ │ │ │ + if (this.singleTile) { │ │ │ │ + size = this.map.getSize(); │ │ │ │ + size.h = parseInt(size.h * this.ratio, 10); │ │ │ │ + size.w = parseInt(size.w * this.ratio, 10); │ │ │ │ } │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setBorder │ │ │ │ - * Sets the border style of the popup. │ │ │ │ + * APIMethod: getTilesBounds │ │ │ │ + * Return the bounds of the tile grid. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * border - {String} The border style value. eg 2px │ │ │ │ + * Returns: │ │ │ │ + * {} A Bounds object representing the bounds of all the │ │ │ │ + * currently loaded tiles (including those partially or not at all seen │ │ │ │ + * onscreen). │ │ │ │ */ │ │ │ │ - setBorder: function(border) { │ │ │ │ - if (border != undefined) { │ │ │ │ - this.border = border; │ │ │ │ - } │ │ │ │ + getTilesBounds: function() { │ │ │ │ + var bounds = null; │ │ │ │ │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.border = this.border; │ │ │ │ + var length = this.grid.length; │ │ │ │ + if (length) { │ │ │ │ + var bottomLeftTileBounds = this.grid[length - 1][0].bounds, │ │ │ │ + width = this.grid[0].length * bottomLeftTileBounds.getWidth(), │ │ │ │ + height = this.grid.length * bottomLeftTileBounds.getHeight(); │ │ │ │ + │ │ │ │ + bounds = new OpenLayers.Bounds(bottomLeftTileBounds.left, │ │ │ │ + bottomLeftTileBounds.bottom, │ │ │ │ + bottomLeftTileBounds.left + width, │ │ │ │ + bottomLeftTileBounds.bottom + height); │ │ │ │ } │ │ │ │ + return bounds; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setContentHTML │ │ │ │ - * Allows the user to set the HTML content of the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * contentHTML - {String} HTML for the div. │ │ │ │ + * Method: initSingleTile │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {} │ │ │ │ */ │ │ │ │ - setContentHTML: function(contentHTML) { │ │ │ │ + initSingleTile: function(bounds) { │ │ │ │ + this.events.triggerEvent("retile"); │ │ │ │ │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML; │ │ │ │ - } │ │ │ │ + //determine new tile bounds │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var tileWidth = bounds.getWidth() * this.ratio; │ │ │ │ + var tileHeight = bounds.getHeight() * this.ratio; │ │ │ │ │ │ │ │ - if ((this.contentDiv != null) && │ │ │ │ - (this.contentHTML != null) && │ │ │ │ - (this.contentHTML != this.contentDiv.innerHTML)) { │ │ │ │ + var tileBounds = │ │ │ │ + new OpenLayers.Bounds(center.lon - (tileWidth / 2), │ │ │ │ + center.lat - (tileHeight / 2), │ │ │ │ + center.lon + (tileWidth / 2), │ │ │ │ + center.lat + (tileHeight / 2)); │ │ │ │ │ │ │ │ - this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ + var px = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: tileBounds.left, │ │ │ │ + lat: tileBounds.top │ │ │ │ + }); │ │ │ │ │ │ │ │ - if (this.autoSize) { │ │ │ │ + if (!this.grid.length) { │ │ │ │ + this.grid[0] = []; │ │ │ │ + } │ │ │ │ │ │ │ │ - //if popup has images, listen for when they finish │ │ │ │ - // loading and resize accordingly │ │ │ │ - this.registerImageListeners(); │ │ │ │ + var tile = this.grid[0][0]; │ │ │ │ + if (!tile) { │ │ │ │ + tile = this.addTile(tileBounds, px); │ │ │ │ │ │ │ │ - //auto size the popup to its current contents │ │ │ │ - this.updateSize(); │ │ │ │ - } │ │ │ │ + this.addTileMonitoringHooks(tile); │ │ │ │ + tile.draw(); │ │ │ │ + this.grid[0][0] = tile; │ │ │ │ + } else { │ │ │ │ + tile.moveTo(tileBounds, px); │ │ │ │ } │ │ │ │ │ │ │ │ + //remove all but our single tile │ │ │ │ + this.removeExcessTiles(1, 1); │ │ │ │ + │ │ │ │ + // store the resolution of the grid │ │ │ │ + this.gridResolution = this.getServerResolution(); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: registerImageListeners │ │ │ │ - * Called when an image contained by the popup loaded. this function │ │ │ │ - * updates the popup size, then unregisters the image load listener. │ │ │ │ + /** │ │ │ │ + * Method: calculateGridLayout │ │ │ │ + * Generate parameters for the grid layout. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {|Object} OpenLayers.Bounds or an │ │ │ │ + * object with a 'left' and 'top' properties. │ │ │ │ + * origin - {|Object} OpenLayers.LonLat or an │ │ │ │ + * object with a 'lon' and 'lat' properties. │ │ │ │ + * resolution - {Number} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Object containing properties tilelon, tilelat, startcol, │ │ │ │ + * startrow │ │ │ │ */ │ │ │ │ - registerImageListeners: function() { │ │ │ │ + calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ + var tilelon = resolution * this.tileSize.w; │ │ │ │ + var tilelat = resolution * this.tileSize.h; │ │ │ │ │ │ │ │ - // As the images load, this function will call updateSize() to │ │ │ │ - // resize the popup to fit the content div (which presumably is now │ │ │ │ - // bigger than when the image was not loaded). │ │ │ │ - // │ │ │ │ - // If the 'panMapIfOutOfView' property is set, we will pan the newly │ │ │ │ - // resized popup back into view. │ │ │ │ - // │ │ │ │ - // Note that this function, when called, will have 'popup' and │ │ │ │ - // 'img' properties in the context. │ │ │ │ - // │ │ │ │ - var onImgLoad = function() { │ │ │ │ - if (this.popup.id === null) { // this.popup has been destroyed! │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - this.popup.updateSize(); │ │ │ │ + var offsetlon = bounds.left - origin.lon; │ │ │ │ + var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ │ │ │ │ - if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ - this.popup.panIntoView(); │ │ │ │ - } │ │ │ │ + var rowSign = this.rowSign; │ │ │ │ │ │ │ │ - OpenLayers.Event.stopObserving( │ │ │ │ - this.img, "load", this.img._onImgLoad │ │ │ │ - ); │ │ │ │ + var offsetlat = rowSign * (origin.lat - bounds.top + tilelat); │ │ │ │ + var tilerow = Math[~rowSign ? 'floor' : 'ceil'](offsetlat / tilelat) - this.buffer * rowSign; │ │ │ │ │ │ │ │ + return { │ │ │ │ + tilelon: tilelon, │ │ │ │ + tilelat: tilelat, │ │ │ │ + startcol: tilecol, │ │ │ │ + startrow: tilerow │ │ │ │ }; │ │ │ │ │ │ │ │ - //cycle through the images and if their size is 0x0, that means that │ │ │ │ - // they haven't been loaded yet, so we attach the listener, which │ │ │ │ - // will fire when the images finish loading and will resize the │ │ │ │ - // popup accordingly to its new size. │ │ │ │ - var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ - for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ - var img = images[i]; │ │ │ │ - if (img.width == 0 || img.height == 0) { │ │ │ │ - │ │ │ │ - var context = { │ │ │ │ - 'popup': this, │ │ │ │ - 'img': img │ │ │ │ - }; │ │ │ │ - │ │ │ │ - //expando this function to the image itself before registering │ │ │ │ - // it. This way we can easily and properly unregister it. │ │ │ │ - img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ + }, │ │ │ │ │ │ │ │ - OpenLayers.Event.observe(img, 'load', img._onImgLoad); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: getTileOrigin │ │ │ │ + * Determine the origin for aligning the grid of tiles. If a │ │ │ │ + * property is supplied, that will be returned. Otherwise, the origin │ │ │ │ + * will be derived from the layer's property. In this case, │ │ │ │ + * the tile origin will be the corner of the given by the │ │ │ │ + * property. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} The tile origin. │ │ │ │ + */ │ │ │ │ + getTileOrigin: function() { │ │ │ │ + var origin = this.tileOrigin; │ │ │ │ + if (!origin) { │ │ │ │ + var extent = this.getMaxExtent(); │ │ │ │ + var edges = ({ │ │ │ │ + "tl": ["left", "top"], │ │ │ │ + "tr": ["right", "top"], │ │ │ │ + "bl": ["left", "bottom"], │ │ │ │ + "br": ["right", "bottom"] │ │ │ │ + })[this.tileOriginCorner]; │ │ │ │ + origin = new OpenLayers.LonLat(extent[edges[0]], extent[edges[1]]); │ │ │ │ } │ │ │ │ + return origin; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getSafeContentSize │ │ │ │ - * │ │ │ │ + * Method: getTileBoundsForGridIndex │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * size - {} Desired size to make the popup. │ │ │ │ - * │ │ │ │ + * row - {Number} The row of the grid │ │ │ │ + * col - {Number} The column of the grid │ │ │ │ + * │ │ │ │ * 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). │ │ │ │ + * {} The bounds for the tile at (row, col) │ │ │ │ */ │ │ │ │ - getSafeContentSize: function(size) { │ │ │ │ + getTileBoundsForGridIndex: function(row, col) { │ │ │ │ + var origin = this.getTileOrigin(); │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + var tilelon = tileLayout.tilelon; │ │ │ │ + var tilelat = tileLayout.tilelat; │ │ │ │ + var startcol = tileLayout.startcol; │ │ │ │ + var startrow = tileLayout.startrow; │ │ │ │ + var rowSign = this.rowSign; │ │ │ │ + return new OpenLayers.Bounds( │ │ │ │ + origin.lon + (startcol + col) * tilelon, │ │ │ │ + origin.lat - (startrow + row * rowSign) * tilelat * rowSign, │ │ │ │ + origin.lon + (startcol + col + 1) * tilelon, │ │ │ │ + origin.lat - (startrow + (row - 1) * rowSign) * tilelat * rowSign │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var safeContentSize = size.clone(); │ │ │ │ + /** │ │ │ │ + * Method: initGriddedTiles │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {} │ │ │ │ + */ │ │ │ │ + initGriddedTiles: function(bounds) { │ │ │ │ + this.events.triggerEvent("retile"); │ │ │ │ │ │ │ │ - // 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; │ │ │ │ + // work out mininum number of rows and columns; this is the number of │ │ │ │ + // tiles required to cover the viewport plus at least one for panning │ │ │ │ │ │ │ │ - // take into account the popup's 'padding' property │ │ │ │ - this.fixPadding(); │ │ │ │ - wPadding += this.padding.left + this.padding.right; │ │ │ │ - hPadding += this.padding.top + this.padding.bottom; │ │ │ │ + var viewSize = this.map.getSize(); │ │ │ │ │ │ │ │ - if (this.closeDiv) { │ │ │ │ - var closeDivWidth = parseInt(this.closeDiv.style.width); │ │ │ │ - wPadding += closeDivWidth + contentDivPadding.right; │ │ │ │ - } │ │ │ │ + var origin = this.getTileOrigin(); │ │ │ │ + var resolution = this.map.getResolution(), │ │ │ │ + serverResolution = this.getServerResolution(), │ │ │ │ + ratio = resolution / serverResolution, │ │ │ │ + tileSize = { │ │ │ │ + w: this.tileSize.w / ratio, │ │ │ │ + h: this.tileSize.h / ratio │ │ │ │ + }; │ │ │ │ │ │ │ │ - // 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)); │ │ │ │ - } │ │ │ │ + var minRows = Math.ceil(viewSize.h / tileSize.h) + │ │ │ │ + 2 * this.buffer + 1; │ │ │ │ + var minCols = Math.ceil(viewSize.w / tileSize.w) + │ │ │ │ + 2 * this.buffer + 1; │ │ │ │ │ │ │ │ - // 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)); │ │ │ │ - } │ │ │ │ + var tileLayout = this.calculateGridLayout(bounds, origin, serverResolution); │ │ │ │ + this.gridLayout = tileLayout; │ │ │ │ │ │ │ │ - //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) { │ │ │ │ + var tilelon = tileLayout.tilelon; │ │ │ │ + var tilelat = tileLayout.tilelat; │ │ │ │ │ │ │ │ - var extraX = 0, │ │ │ │ - extraY = 0; │ │ │ │ - if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ - var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ - switch (this.relativePosition) { │ │ │ │ - case "tr": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "tl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "bl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - case "br": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + var layerContainerDivLeft = this.map.layerContainerOriginPx.x; │ │ │ │ + var layerContainerDivTop = this.map.layerContainerOriginPx.y; │ │ │ │ + │ │ │ │ + var tileBounds = this.getTileBoundsForGridIndex(0, 0); │ │ │ │ + var startPx = this.map.getViewPortPxFromLonLat( │ │ │ │ + new OpenLayers.LonLat(tileBounds.left, tileBounds.top) │ │ │ │ + ); │ │ │ │ + startPx.x = Math.round(startPx.x) - layerContainerDivLeft; │ │ │ │ + startPx.y = Math.round(startPx.y) - layerContainerDivTop; │ │ │ │ + │ │ │ │ + var tileData = [], │ │ │ │ + center = this.map.getCenter(); │ │ │ │ + │ │ │ │ + var rowidx = 0; │ │ │ │ + do { │ │ │ │ + var row = this.grid[rowidx]; │ │ │ │ + if (!row) { │ │ │ │ + row = []; │ │ │ │ + this.grid.push(row); │ │ │ │ } │ │ │ │ │ │ │ │ - var maxY = this.map.size.h - │ │ │ │ - this.map.paddingForPopups.top - │ │ │ │ - this.map.paddingForPopups.bottom - │ │ │ │ - hPadding - extraY; │ │ │ │ + var colidx = 0; │ │ │ │ + do { │ │ │ │ + tileBounds = this.getTileBoundsForGridIndex(rowidx, colidx); │ │ │ │ + var px = startPx.clone(); │ │ │ │ + px.x = px.x + colidx * Math.round(tileSize.w); │ │ │ │ + px.y = px.y + rowidx * Math.round(tileSize.h); │ │ │ │ + var tile = row[colidx]; │ │ │ │ + if (!tile) { │ │ │ │ + tile = this.addTile(tileBounds, px); │ │ │ │ + this.addTileMonitoringHooks(tile); │ │ │ │ + row.push(tile); │ │ │ │ + } else { │ │ │ │ + tile.moveTo(tileBounds, px, false); │ │ │ │ + } │ │ │ │ + var tileCenter = tileBounds.getCenterLonLat(); │ │ │ │ + tileData.push({ │ │ │ │ + tile: tile, │ │ │ │ + distance: Math.pow(tileCenter.lon - center.lon, 2) + │ │ │ │ + Math.pow(tileCenter.lat - center.lat, 2) │ │ │ │ + }); │ │ │ │ │ │ │ │ - var maxX = this.map.size.w - │ │ │ │ - this.map.paddingForPopups.left - │ │ │ │ - this.map.paddingForPopups.right - │ │ │ │ - wPadding - extraX; │ │ │ │ + colidx += 1; │ │ │ │ + } while ((tileBounds.right <= bounds.right + tilelon * this.buffer) || │ │ │ │ + colidx < minCols); │ │ │ │ │ │ │ │ - safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ - safeContentSize.h = Math.min(safeContentSize.h, maxY); │ │ │ │ - } │ │ │ │ + rowidx += 1; │ │ │ │ + } while ((tileBounds.bottom >= bounds.bottom - tilelat * this.buffer) || │ │ │ │ + rowidx < minRows); │ │ │ │ │ │ │ │ - return safeContentSize; │ │ │ │ + //shave off exceess rows and colums │ │ │ │ + this.removeExcessTiles(rowidx, colidx); │ │ │ │ + │ │ │ │ + var resolution = this.getServerResolution(); │ │ │ │ + // store the resolution of the grid │ │ │ │ + this.gridResolution = resolution; │ │ │ │ + │ │ │ │ + //now actually draw the tiles │ │ │ │ + tileData.sort(function(a, b) { │ │ │ │ + return a.distance - b.distance; │ │ │ │ + }); │ │ │ │ + for (var i = 0, ii = tileData.length; i < ii; ++i) { │ │ │ │ + tileData[i].tile.draw(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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) │ │ │ │ + * Method: getMaxExtent │ │ │ │ + * Get this layer's maximum extent. (Implemented as a getter for │ │ │ │ + * potential specific implementations in sub-classes.) │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ * {} │ │ │ │ */ │ │ │ │ - getContentDivPadding: function() { │ │ │ │ - │ │ │ │ - //use cached value if we have it │ │ │ │ - var contentDivPadding = this._contentDivPadding; │ │ │ │ - if (!contentDivPadding) { │ │ │ │ - │ │ │ │ - if (this.div.parentNode == null) { │ │ │ │ - //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; │ │ │ │ - │ │ │ │ - if (this.div.parentNode == document.body) { │ │ │ │ - //remove the div from the page and make it visible again │ │ │ │ - document.body.removeChild(this.div); │ │ │ │ - this.div.style.display = ""; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return contentDivPadding; │ │ │ │ + getMaxExtent: function() { │ │ │ │ + return this.maxExtent; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addCloseBox │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The callback to be called when the close button │ │ │ │ - * is clicked. │ │ │ │ + * APIMethod: addTile │ │ │ │ + * Create a tile, initialize it, and add it to the layer div. │ │ │ │ + * │ │ │ │ + * Parameters │ │ │ │ + * bounds - {} │ │ │ │ + * position - {} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} The added OpenLayers.Tile │ │ │ │ */ │ │ │ │ - addCloseBox: function(callback) { │ │ │ │ - │ │ │ │ - this.closeDiv = OpenLayers.Util.createDiv( │ │ │ │ - this.id + "_close", null, { │ │ │ │ - w: 17, │ │ │ │ - h: 17 │ │ │ │ - } │ │ │ │ + addTile: function(bounds, position) { │ │ │ │ + var tile = new this.tileClass( │ │ │ │ + this, position, bounds, null, this.tileSize, this.tileOptions │ │ │ │ ); │ │ │ │ - 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, "touchend", │ │ │ │ - OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ - OpenLayers.Event.observe(this.closeDiv, "click", │ │ │ │ - OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ + this.events.triggerEvent("addtile", { │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + return tile; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: panIntoView │ │ │ │ - * Pans the map such that the popup is totaly viewable (if necessary) │ │ │ │ + /** │ │ │ │ + * Method: addTileMonitoringHooks │ │ │ │ + * This function takes a tile as input and adds the appropriate hooks to │ │ │ │ + * the tile so that the layer can keep track of the loading tiles. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * tile - {} │ │ │ │ */ │ │ │ │ - panIntoView: function() { │ │ │ │ - │ │ │ │ - var mapSize = this.map.getSize(); │ │ │ │ + addTileMonitoringHooks: function(tile) { │ │ │ │ │ │ │ │ - //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(); │ │ │ │ + var replacingCls = 'olTileReplacing'; │ │ │ │ │ │ │ │ - //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; │ │ │ │ - } │ │ │ │ + tile.onLoadStart = function() { │ │ │ │ + //if that was first tile then trigger a 'loadstart' on the layer │ │ │ │ + if (this.loading === false) { │ │ │ │ + this.loading = true; │ │ │ │ + this.events.triggerEvent("loadstart"); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("tileloadstart", { │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + this.numLoadingTiles++; │ │ │ │ + if (!this.singleTile && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ + OpenLayers.Element.addClass(tile.getTile(), replacingCls); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ │ │ │ │ - //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; │ │ │ │ - } │ │ │ │ + tile.onLoadEnd = function(evt) { │ │ │ │ + this.numLoadingTiles--; │ │ │ │ + var aborted = evt.type === 'unload'; │ │ │ │ + this.events.triggerEvent("tileloaded", { │ │ │ │ + tile: tile, │ │ │ │ + aborted: aborted │ │ │ │ + }); │ │ │ │ + if (!this.singleTile && !aborted && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ + var tileDiv = tile.getTile(); │ │ │ │ + if (OpenLayers.Element.getStyle(tileDiv, 'display') === 'none') { │ │ │ │ + var bufferTile = document.getElementById(tile.id + '_bb'); │ │ │ │ + if (bufferTile) { │ │ │ │ + bufferTile.parentNode.removeChild(bufferTile); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Element.removeClass(tileDiv, replacingCls); │ │ │ │ + } │ │ │ │ + //if that was the last tile, then trigger a 'loadend' on the layer │ │ │ │ + if (this.numLoadingTiles === 0) { │ │ │ │ + if (this.backBuffer) { │ │ │ │ + if (this.backBuffer.childNodes.length === 0) { │ │ │ │ + // no tiles transitioning, remove immediately │ │ │ │ + this.removeBackBuffer(); │ │ │ │ + } else { │ │ │ │ + // wait until transition has ended or delay has passed │ │ │ │ + this._transitionElement = aborted ? │ │ │ │ + this.div.lastChild : tile.imgDiv; │ │ │ │ + var transitionendEvents = this.transitionendEvents; │ │ │ │ + for (var i = transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ + OpenLayers.Event.observe(this._transitionElement, │ │ │ │ + transitionendEvents[i], │ │ │ │ + this._removeBackBuffer); │ │ │ │ + } │ │ │ │ + // the removal of the back buffer is delayed to prevent │ │ │ │ + // flash effects due to the animation of tile displaying │ │ │ │ + this.backBufferTimerId = window.setTimeout( │ │ │ │ + this._removeBackBuffer, this.removeBackBufferDelay │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.loading = false; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ │ │ │ │ - var dx = origTL.x - newTL.x; │ │ │ │ - var dy = origTL.y - newTL.y; │ │ │ │ + tile.onLoadError = function() { │ │ │ │ + this.events.triggerEvent("tileerror", { │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + }; │ │ │ │ │ │ │ │ - this.map.pan(dx, dy); │ │ │ │ + tile.events.on({ │ │ │ │ + "loadstart": tile.onLoadStart, │ │ │ │ + "loadend": tile.onLoadEnd, │ │ │ │ + "unload": tile.onLoadEnd, │ │ │ │ + "loaderror": tile.onLoadError, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. The same procedure is needed for │ │ │ │ - * touchmove and touchend events. │ │ │ │ + * Method: removeTileMonitoringHooks │ │ │ │ + * This function takes a tile as input and removes the tile hooks │ │ │ │ + * that were added in addTileMonitoringHooks() │ │ │ │ * │ │ │ │ - * 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. │ │ │ │ + * Parameters: │ │ │ │ + * tile - {} │ │ │ │ */ │ │ │ │ - registerEvents: function() { │ │ │ │ - this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ - │ │ │ │ - function onTouchstart(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ - } │ │ │ │ - this.events.on({ │ │ │ │ - "mousedown": this.onmousedown, │ │ │ │ - "mousemove": this.onmousemove, │ │ │ │ - "mouseup": this.onmouseup, │ │ │ │ - "click": this.onclick, │ │ │ │ - "mouseout": this.onmouseout, │ │ │ │ - "dblclick": this.ondblclick, │ │ │ │ - "touchstart": onTouchstart, │ │ │ │ + removeTileMonitoringHooks: function(tile) { │ │ │ │ + tile.unload(); │ │ │ │ + tile.events.un({ │ │ │ │ + "loadstart": tile.onLoadStart, │ │ │ │ + "loadend": tile.onLoadEnd, │ │ │ │ + "unload": tile.onLoadEnd, │ │ │ │ + "loaderror": tile.onLoadError, │ │ │ │ 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} │ │ │ │ + /** │ │ │ │ + * Method: moveGriddedTiles │ │ │ │ */ │ │ │ │ - onmousedown: function(evt) { │ │ │ │ - this.mousedown = true; │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + moveGriddedTiles: function() { │ │ │ │ + var buffer = this.buffer + 1; │ │ │ │ + while (true) { │ │ │ │ + var tlTile = this.grid[0][0]; │ │ │ │ + var tlViewPort = { │ │ │ │ + x: tlTile.position.x + │ │ │ │ + this.map.layerContainerOriginPx.x, │ │ │ │ + y: tlTile.position.y + │ │ │ │ + this.map.layerContainerOriginPx.y │ │ │ │ + }; │ │ │ │ + var ratio = this.getServerResolution() / this.map.getResolution(); │ │ │ │ + var tileSize = { │ │ │ │ + w: Math.round(this.tileSize.w * ratio), │ │ │ │ + h: Math.round(this.tileSize.h * ratio) │ │ │ │ + }; │ │ │ │ + if (tlViewPort.x > -tileSize.w * (buffer - 1)) { │ │ │ │ + this.shiftColumn(true, tileSize); │ │ │ │ + } else if (tlViewPort.x < -tileSize.w * buffer) { │ │ │ │ + this.shiftColumn(false, tileSize); │ │ │ │ + } else if (tlViewPort.y > -tileSize.h * (buffer - 1)) { │ │ │ │ + this.shiftRow(true, tileSize); │ │ │ │ + } else if (tlViewPort.y < -tileSize.h * buffer) { │ │ │ │ + this.shiftRow(false, tileSize); │ │ │ │ + } else { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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) │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: shiftRow │ │ │ │ + * Shifty grid work │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * prepend - {Boolean} if true, prepend to beginning. │ │ │ │ + * if false, then append to end │ │ │ │ + * tileSize - {Object} rendered tile size; object with w and h properties │ │ │ │ */ │ │ │ │ - onmousemove: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + shiftRow: function(prepend, tileSize) { │ │ │ │ + var grid = this.grid; │ │ │ │ + var rowIndex = prepend ? 0 : (grid.length - 1); │ │ │ │ + var sign = prepend ? -1 : 1; │ │ │ │ + var rowSign = this.rowSign; │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + tileLayout.startrow += sign * rowSign; │ │ │ │ + │ │ │ │ + var modelRow = grid[rowIndex]; │ │ │ │ + var row = grid[prepend ? 'pop' : 'shift'](); │ │ │ │ + for (var i = 0, len = row.length; i < len; i++) { │ │ │ │ + var tile = row[i]; │ │ │ │ + var position = modelRow[i].position.clone(); │ │ │ │ + position.y += tileSize.h * sign; │ │ │ │ + tile.moveTo(this.getTileBoundsForGridIndex(rowIndex, i), position); │ │ │ │ } │ │ │ │ + grid[prepend ? 'unshift' : 'push'](row); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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 │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: shiftColumn │ │ │ │ + * Shift grid work in the other dimension │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * prepend - {Boolean} if true, prepend to beginning. │ │ │ │ + * if false, then append to end │ │ │ │ + * tileSize - {Object} rendered tile size; object with w and h properties │ │ │ │ */ │ │ │ │ - onmouseup: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - this.mousedown = false; │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + shiftColumn: function(prepend, tileSize) { │ │ │ │ + var grid = this.grid; │ │ │ │ + var colIndex = prepend ? 0 : (grid[0].length - 1); │ │ │ │ + var sign = prepend ? -1 : 1; │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + tileLayout.startcol += sign; │ │ │ │ + │ │ │ │ + for (var i = 0, len = grid.length; i < len; i++) { │ │ │ │ + var row = grid[i]; │ │ │ │ + var position = row[colIndex].position.clone(); │ │ │ │ + var tile = row[prepend ? 'pop' : 'shift'](); │ │ │ │ + position.x += tileSize.w * sign; │ │ │ │ + tile.moveTo(this.getTileBoundsForGridIndex(i, colIndex), position); │ │ │ │ + row[prepend ? 'unshift' : 'push'](tile); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onclick │ │ │ │ - * Ignore clicks, but allowing default browser handling │ │ │ │ + * Method: removeExcessTiles │ │ │ │ + * When the size of the map or the buffer changes, we may need to │ │ │ │ + * remove some excess rows and columns. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * rows - {Integer} Maximum number of rows we want our grid to have. │ │ │ │ + * columns - {Integer} Maximum number of columns we want our grid to have. │ │ │ │ */ │ │ │ │ - onclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + removeExcessTiles: function(rows, columns) { │ │ │ │ + var i, l; │ │ │ │ + │ │ │ │ + // remove extra rows │ │ │ │ + while (this.grid.length > rows) { │ │ │ │ + var row = this.grid.pop(); │ │ │ │ + for (i = 0, l = row.length; i < l; i++) { │ │ │ │ + var tile = row[i]; │ │ │ │ + this.destroyTile(tile); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // remove extra columns │ │ │ │ + for (i = 0, l = this.grid.length; i < l; i++) { │ │ │ │ + while (this.grid[i].length > columns) { │ │ │ │ + var row = this.grid[i]; │ │ │ │ + var tile = row.pop(); │ │ │ │ + this.destroyTile(tile); │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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} │ │ │ │ + /** │ │ │ │ + * Method: onMapResize │ │ │ │ + * For singleTile layers, this will set a new tile size according to the │ │ │ │ + * dimensions of the map pane. │ │ │ │ */ │ │ │ │ - onmouseout: function(evt) { │ │ │ │ - this.mousedown = false; │ │ │ │ + onMapResize: function() { │ │ │ │ + if (this.singleTile) { │ │ │ │ + this.clearGrid(); │ │ │ │ + this.setTileSize(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: ondblclick │ │ │ │ - * Ignore double-clicks, but allowing default browser handling │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * APIMethod: getTileBounds │ │ │ │ + * Returns The tile bounds for a layer given a pixel location. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * viewPortPx - {} The location in the viewport. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {} Bounds of the tile at the given pixel location. │ │ │ │ */ │ │ │ │ - ondblclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + getTileBounds: function(viewPortPx) { │ │ │ │ + var maxExtent = this.maxExtent; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ + var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ + var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ + var tileLeft = maxExtent.left + (tileMapWidth * │ │ │ │ + Math.floor((mapPoint.lon - │ │ │ │ + maxExtent.left) / │ │ │ │ + tileMapWidth)); │ │ │ │ + var tileBottom = maxExtent.bottom + (tileMapHeight * │ │ │ │ + Math.floor((mapPoint.lat - │ │ │ │ + maxExtent.bottom) / │ │ │ │ + tileMapHeight)); │ │ │ │ + return new OpenLayers.Bounds(tileLeft, tileBottom, │ │ │ │ + tileLeft + tileMapWidth, │ │ │ │ + tileBottom + tileMapHeight); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Popup" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Grid" │ │ │ │ }); │ │ │ │ - │ │ │ │ -OpenLayers.Popup.WIDTH = 200; │ │ │ │ -OpenLayers.Popup.HEIGHT = 200; │ │ │ │ -OpenLayers.Popup.COLOR = "white"; │ │ │ │ -OpenLayers.Popup.OPACITY = 1; │ │ │ │ -OpenLayers.Popup.BORDER = "0px"; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Kinetic.js │ │ │ │ + OpenLayers/TileManager.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Animation.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/BaseTypes.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Element.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ + * @requires OpenLayers/Tile/Image.js │ │ │ │ */ │ │ │ │ │ │ │ │ -OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.TileManager │ │ │ │ + * Provides queueing of image requests and caching of image elements. │ │ │ │ + * │ │ │ │ + * Queueing avoids unnecessary image requests while changing zoom levels │ │ │ │ + * quickly, and helps improve dragging performance on mobile devices that show │ │ │ │ + * a lag in dragging when loading of new images starts. and │ │ │ │ + * are the configuration options to control this behavior. │ │ │ │ + * │ │ │ │ + * Caching avoids setting the src on image elements for images that have already │ │ │ │ + * been used. Several maps can share a TileManager instance, in which case each │ │ │ │ + * map gets its own tile queue, but all maps share the same tile cache. │ │ │ │ + */ │ │ │ │ +OpenLayers.TileManager = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: threshold │ │ │ │ - * In most cases changing the threshold isn't needed. │ │ │ │ - * In px/ms, default to 0. │ │ │ │ + * APIProperty: cacheSize │ │ │ │ + * {Number} Number of image elements to keep referenced in this instance's │ │ │ │ + * cache for fast reuse. Default is 256. │ │ │ │ */ │ │ │ │ - threshold: 0, │ │ │ │ + cacheSize: 256, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: deceleration │ │ │ │ - * {Float} the deseleration in px/ms², default to 0.0035. │ │ │ │ + * APIProperty: tilesPerFrame │ │ │ │ + * {Number} Number of queued tiles to load per frame (see ). │ │ │ │ + * Default is 2. │ │ │ │ */ │ │ │ │ - deceleration: 0.0035, │ │ │ │ + tilesPerFrame: 2, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: nbPoints │ │ │ │ - * {Integer} the number of points we use to calculate the kinetic │ │ │ │ - * initial values. │ │ │ │ + * APIProperty: frameDelay │ │ │ │ + * {Number} Delay between tile loading frames (see ) in │ │ │ │ + * milliseconds. Default is 16. │ │ │ │ */ │ │ │ │ - nbPoints: 100, │ │ │ │ + frameDelay: 16, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: delay │ │ │ │ - * {Float} time to consider to calculate the kinetic initial values. │ │ │ │ - * In ms, default to 200. │ │ │ │ + * APIProperty: moveDelay │ │ │ │ + * {Number} Delay in milliseconds after a map's move event before loading │ │ │ │ + * tiles. Default is 100. │ │ │ │ */ │ │ │ │ - delay: 200, │ │ │ │ + moveDelay: 100, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: points │ │ │ │ - * List of points use to calculate the kinetic initial values. │ │ │ │ + * APIProperty: zoomDelay │ │ │ │ + * {Number} Delay in milliseconds after a map's zoomend event before loading │ │ │ │ + * tiles. Default is 200. │ │ │ │ */ │ │ │ │ - points: undefined, │ │ │ │ + zoomDelay: 200, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timerId │ │ │ │ - * ID of the timer. │ │ │ │ + * Property: maps │ │ │ │ + * {Array()} The maps to manage tiles on. │ │ │ │ */ │ │ │ │ - timerId: undefined, │ │ │ │ + maps: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Kinetic │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * Property: tileQueueId │ │ │ │ + * {Object} The ids of the loop, keyed by map id. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - }, │ │ │ │ + tileQueueId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: begin │ │ │ │ - * Begins the dragging. │ │ │ │ + * Property: tileQueue │ │ │ │ + * {Object(Array())} Tiles queued for drawing, keyed by │ │ │ │ + * map id. │ │ │ │ */ │ │ │ │ - begin: function() { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = undefined; │ │ │ │ - this.points = []; │ │ │ │ + tileQueue: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tileCache │ │ │ │ + * {Object} Cached image elements, keyed by URL. │ │ │ │ + */ │ │ │ │ + tileCache: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tileCacheIndex │ │ │ │ + * {Array(String)} URLs of cached tiles. First entry is the least recently │ │ │ │ + * used. │ │ │ │ + */ │ │ │ │ + tileCacheIndex: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.TileManager │ │ │ │ + * Constructor for a new instance. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Configuration for this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.maps = []; │ │ │ │ + this.tileQueueId = {}; │ │ │ │ + this.tileQueue = {}; │ │ │ │ + this.tileCache = {}; │ │ │ │ + this.tileCacheIndex = []; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Updates during the dragging. │ │ │ │ + * Method: addMap │ │ │ │ + * Binds this instance to a map │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * xy - {} The new position. │ │ │ │ + * map - {} │ │ │ │ */ │ │ │ │ - update: function(xy) { │ │ │ │ - this.points.unshift({ │ │ │ │ - xy: xy, │ │ │ │ - tick: new Date().getTime() │ │ │ │ - }); │ │ │ │ - if (this.points.length > this.nbPoints) { │ │ │ │ - this.points.pop(); │ │ │ │ + addMap: function(map) { │ │ │ │ + if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + this.maps.push(map); │ │ │ │ + this.tileQueue[map.id] = []; │ │ │ │ + for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ + this.addLayer({ │ │ │ │ + layer: map.layers[i] │ │ │ │ + }); │ │ │ │ } │ │ │ │ + map.events.on({ │ │ │ │ + move: this.move, │ │ │ │ + zoomend: this.zoomEnd, │ │ │ │ + changelayer: this.changeLayer, │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + preremovelayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: end │ │ │ │ - * Ends the dragging, start the kinetic. │ │ │ │ + * Method: removeMap │ │ │ │ + * Unbinds this instance from a map │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * xy - {} The last position. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object with two properties: "speed", and "theta". The │ │ │ │ - * "speed" and "theta" values are to be passed to the move │ │ │ │ - * function when starting the animation. │ │ │ │ + * map - {} │ │ │ │ */ │ │ │ │ - end: function(xy) { │ │ │ │ - var last, now = new Date().getTime(); │ │ │ │ - for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ - point = this.points[i]; │ │ │ │ - if (now - point.tick > this.delay) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - last = point; │ │ │ │ - } │ │ │ │ - if (!last) { │ │ │ │ + removeMap: function(map) { │ │ │ │ + if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ return; │ │ │ │ } │ │ │ │ - var time = new Date().getTime() - last.tick; │ │ │ │ - var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + │ │ │ │ - Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ - var speed = dist / time; │ │ │ │ - if (speed == 0 || speed < this.threshold) { │ │ │ │ - return; │ │ │ │ + window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ + if (map.layers) { │ │ │ │ + for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: map.layers[i] │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ - if (last.xy.x <= xy.x) { │ │ │ │ - theta = Math.PI - theta; │ │ │ │ + if (map.events) { │ │ │ │ + map.events.un({ │ │ │ │ + move: this.move, │ │ │ │ + zoomend: this.zoomEnd, │ │ │ │ + changelayer: this.changeLayer, │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + preremovelayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ - return { │ │ │ │ - speed: speed, │ │ │ │ - theta: theta │ │ │ │ - }; │ │ │ │ + delete this.tileQueue[map.id]; │ │ │ │ + delete this.tileQueueId[map.id]; │ │ │ │ + OpenLayers.Util.removeItem(this.maps, map); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: move │ │ │ │ - * Launch the kinetic move pan. │ │ │ │ + * Handles the map's move event │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * info - {Object} An object with two properties, "speed", and "theta". │ │ │ │ - * These values are those returned from the "end" call. │ │ │ │ - * callback - {Function} Function called on every step of the animation, │ │ │ │ - * receives x, y (values to pan), end (is the last point). │ │ │ │ + * evt - {Object} Listener argument │ │ │ │ */ │ │ │ │ - move: function(info, callback) { │ │ │ │ - var v0 = info.speed; │ │ │ │ - var fx = Math.cos(info.theta); │ │ │ │ - var fy = -Math.sin(info.theta); │ │ │ │ - │ │ │ │ - var initialTime = new Date().getTime(); │ │ │ │ - │ │ │ │ - var lastX = 0; │ │ │ │ - var lastY = 0; │ │ │ │ - │ │ │ │ - var timerCallback = function() { │ │ │ │ - if (this.timerId == null) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var t = new Date().getTime() - initialTime; │ │ │ │ - │ │ │ │ - var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t; │ │ │ │ - var x = p * fx; │ │ │ │ - var y = p * fy; │ │ │ │ - │ │ │ │ - var args = {}; │ │ │ │ - args.end = false; │ │ │ │ - var v = -this.deceleration * t + v0; │ │ │ │ - │ │ │ │ - if (v <= 0) { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - args.end = true; │ │ │ │ - } │ │ │ │ - │ │ │ │ - args.x = x - lastX; │ │ │ │ - args.y = y - lastY; │ │ │ │ - lastX = x; │ │ │ │ - lastY = y; │ │ │ │ - callback(args.x, args.y, args.end); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - this.timerId = OpenLayers.Animation.start( │ │ │ │ - OpenLayers.Function.bind(timerCallback, this) │ │ │ │ - ); │ │ │ │ + move: function(evt) { │ │ │ │ + this.updateTimeout(evt.object, this.moveDelay, true); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/Markers.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.Markers │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.Markers = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} Markers layer is never a base layer. │ │ │ │ - */ │ │ │ │ - isBaseLayer: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: markers │ │ │ │ - * {Array()} internal marker list │ │ │ │ - */ │ │ │ │ - markers: null, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: drawn │ │ │ │ - * {Boolean} internal state of drawing. This is a workaround for the fact │ │ │ │ - * that the map does not call moveTo with a zoomChanged when the map is │ │ │ │ - * first starting up. This lets us catch the case where we have *never* │ │ │ │ - * drawn the layer, and draw it even if the zoom hasn't changed. │ │ │ │ + /** │ │ │ │ + * Method: zoomEnd │ │ │ │ + * Handles the map's zoomEnd event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} Listener argument │ │ │ │ */ │ │ │ │ - drawn: false, │ │ │ │ + zoomEnd: function(evt) { │ │ │ │ + this.updateTimeout(evt.object, this.zoomDelay); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Markers │ │ │ │ - * Create a Markers layer. │ │ │ │ + * Method: changeLayer │ │ │ │ + * Handles the map's changeLayer event │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ + * evt - {Object} Listener argument │ │ │ │ */ │ │ │ │ - initialize: function(name, options) { │ │ │ │ - OpenLayers.Layer.prototype.initialize.apply(this, arguments); │ │ │ │ - this.markers = []; │ │ │ │ + changeLayer: function(evt) { │ │ │ │ + if (evt.property === 'visibility' || evt.property === 'params') { │ │ │ │ + this.updateTimeout(evt.object, 0); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Method: addLayer │ │ │ │ + * Handles the map's addlayer event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} The listener argument │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.clearMarkers(); │ │ │ │ - this.markers = null; │ │ │ │ - OpenLayers.Layer.prototype.destroy.apply(this, arguments); │ │ │ │ + addLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ + layer.events.on({ │ │ │ │ + addtile: this.addTile, │ │ │ │ + retile: this.clearTileQueue, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + var i, j, tile; │ │ │ │ + for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ + for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ + tile = layer.grid[i][j]; │ │ │ │ + this.addTile({ │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + if (tile.url && !tile.imgDiv) { │ │ │ │ + this.manageTileCache({ │ │ │ │ + object: tile │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setOpacity │ │ │ │ - * Sets the opacity for all the markers. │ │ │ │ - * │ │ │ │ + * Method: removeLayer │ │ │ │ + * Handles the map's preremovelayer event │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * opacity - {Float} │ │ │ │ + * evt - {Object} The listener argument │ │ │ │ */ │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - if (opacity != this.opacity) { │ │ │ │ - this.opacity = opacity; │ │ │ │ - for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ - this.markers[i].setOpacity(this.opacity); │ │ │ │ + removeLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ + this.clearTileQueue({ │ │ │ │ + object: layer │ │ │ │ + }); │ │ │ │ + if (layer.events) { │ │ │ │ + layer.events.un({ │ │ │ │ + addtile: this.addTile, │ │ │ │ + retile: this.clearTileQueue, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (layer.grid) { │ │ │ │ + var i, j, tile; │ │ │ │ + for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ + for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ + tile = layer.grid[i][j]; │ │ │ │ + this.unloadTile({ │ │ │ │ + object: tile │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveTo │ │ │ │ + /** │ │ │ │ + * Method: updateTimeout │ │ │ │ + * Applies the or to the loop, │ │ │ │ + * and schedules more queue processing after if there are still │ │ │ │ + * tiles in the queue. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {} │ │ │ │ - * zoomChanged - {Boolean} │ │ │ │ - * dragging - {Boolean} │ │ │ │ + * map - {} The map to update the timeout for │ │ │ │ + * delay - {Number} The delay to apply │ │ │ │ + * nice - {Boolean} If true, the timeout function will only be created if │ │ │ │ + * the tilequeue is not empty. This is used by the move handler to │ │ │ │ + * avoid impacts on dragging performance. For other events, the tile │ │ │ │ + * queue may not be populated yet, so we need to set the timer │ │ │ │ + * regardless of the queue size. │ │ │ │ */ │ │ │ │ - moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ - OpenLayers.Layer.prototype.moveTo.apply(this, arguments); │ │ │ │ + updateTimeout: function(map, delay, nice) { │ │ │ │ + window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ + var tileQueue = this.tileQueue[map.id]; │ │ │ │ + if (!nice || tileQueue.length) { │ │ │ │ + this.tileQueueId[map.id] = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(function() { │ │ │ │ + this.drawTilesFromQueue(map); │ │ │ │ + if (tileQueue.length) { │ │ │ │ + this.updateTimeout(map, this.frameDelay); │ │ │ │ + } │ │ │ │ + }, this), delay │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (zoomChanged || !this.drawn) { │ │ │ │ - for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ - this.drawMarker(this.markers[i]); │ │ │ │ - } │ │ │ │ - this.drawn = true; │ │ │ │ + /** │ │ │ │ + * Method: addTile │ │ │ │ + * Listener for the layer's addtile event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} The listener argument │ │ │ │ + */ │ │ │ │ + addTile: function(evt) { │ │ │ │ + if (evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ + evt.tile.events.on({ │ │ │ │ + beforedraw: this.queueTileDraw, │ │ │ │ + beforeload: this.manageTileCache, │ │ │ │ + loadend: this.addToCache, │ │ │ │ + unload: this.unloadTile, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + // Layer has the wrong tile type, so don't handle it any longer │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: evt.tile.layer │ │ │ │ + }); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: addMarker │ │ │ │ + * Method: unloadTile │ │ │ │ + * Listener for the tile's unload event │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * marker - {} │ │ │ │ + * evt - {Object} The listener argument │ │ │ │ */ │ │ │ │ - addMarker: function(marker) { │ │ │ │ - this.markers.push(marker); │ │ │ │ + unloadTile: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + tile.events.un({ │ │ │ │ + beforedraw: this.queueTileDraw, │ │ │ │ + beforeload: this.manageTileCache, │ │ │ │ + loadend: this.addToCache, │ │ │ │ + unload: this.unloadTile, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + OpenLayers.Util.removeItem(this.tileQueue[tile.layer.map.id], tile); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.opacity < 1) { │ │ │ │ - marker.setOpacity(this.opacity); │ │ │ │ + /** │ │ │ │ + * Method: queueTileDraw │ │ │ │ + * Adds a tile to the queue that will draw it. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} Listener argument of the tile's beforedraw event │ │ │ │ + */ │ │ │ │ + queueTileDraw: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + var queued = false; │ │ │ │ + var layer = tile.layer; │ │ │ │ + var url = layer.getURL(tile.bounds); │ │ │ │ + var img = this.tileCache[url]; │ │ │ │ + if (img && img.className !== 'olTileImage') { │ │ │ │ + // cached image no longer valid, e.g. because we're olTileReplacing │ │ │ │ + delete this.tileCache[url]; │ │ │ │ + OpenLayers.Util.removeItem(this.tileCacheIndex, url); │ │ │ │ + img = null; │ │ │ │ } │ │ │ │ + // queue only if image with same url not cached already │ │ │ │ + if (layer.url && (layer.async || !img)) { │ │ │ │ + // add to queue only if not in queue already │ │ │ │ + var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ + if (!~OpenLayers.Util.indexOf(tileQueue, tile)) { │ │ │ │ + tileQueue.push(tile); │ │ │ │ + } │ │ │ │ + queued = true; │ │ │ │ + } │ │ │ │ + return !queued; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.map && this.map.getExtent()) { │ │ │ │ - marker.map = this.map; │ │ │ │ - this.drawMarker(marker); │ │ │ │ + /** │ │ │ │ + * Method: drawTilesFromQueue │ │ │ │ + * Draws tiles from the tileQueue, and unqueues the tiles │ │ │ │ + */ │ │ │ │ + drawTilesFromQueue: function(map) { │ │ │ │ + var tileQueue = this.tileQueue[map.id]; │ │ │ │ + var limit = this.tilesPerFrame; │ │ │ │ + var animating = map.zoomTween && map.zoomTween.playing; │ │ │ │ + while (!animating && tileQueue.length && limit) { │ │ │ │ + tileQueue.shift().draw(true); │ │ │ │ + --limit; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: removeMarker │ │ │ │ + * Method: manageTileCache │ │ │ │ + * Adds, updates, removes and fetches cache entries. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * marker - {} │ │ │ │ + * evt - {Object} Listener argument of the tile's beforeload event │ │ │ │ */ │ │ │ │ - removeMarker: function(marker) { │ │ │ │ - if (this.markers && this.markers.length) { │ │ │ │ - OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ - marker.erase(); │ │ │ │ + manageTileCache: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + var img = this.tileCache[tile.url]; │ │ │ │ + if (img) { │ │ │ │ + // if image is on its layer's backbuffer, remove it from backbuffer │ │ │ │ + if (img.parentNode && │ │ │ │ + OpenLayers.Element.hasClass(img.parentNode, 'olBackBuffer')) { │ │ │ │ + img.parentNode.removeChild(img); │ │ │ │ + img.id = null; │ │ │ │ + } │ │ │ │ + // only use image from cache if it is not on a layer already │ │ │ │ + if (!img.parentNode) { │ │ │ │ + img.style.visibility = 'hidden'; │ │ │ │ + img.style.opacity = 0; │ │ │ │ + tile.setImage(img); │ │ │ │ + // LRU - move tile to the end of the array to mark it as the most │ │ │ │ + // recently used │ │ │ │ + OpenLayers.Util.removeItem(this.tileCacheIndex, tile.url); │ │ │ │ + this.tileCacheIndex.push(tile.url); │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearMarkers │ │ │ │ - * This method removes all markers from a layer. The markers are not │ │ │ │ - * destroyed by this function, but are removed from the list of markers. │ │ │ │ + * Method: addToCache │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} Listener argument for the tile's loadend event │ │ │ │ */ │ │ │ │ - clearMarkers: function() { │ │ │ │ - if (this.markers != null) { │ │ │ │ - while (this.markers.length > 0) { │ │ │ │ - this.removeMarker(this.markers[0]); │ │ │ │ + addToCache: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + if (!this.tileCache[tile.url]) { │ │ │ │ + if (!OpenLayers.Element.hasClass(tile.imgDiv, 'olImageLoadError')) { │ │ │ │ + if (this.tileCacheIndex.length >= this.cacheSize) { │ │ │ │ + delete this.tileCache[this.tileCacheIndex[0]]; │ │ │ │ + this.tileCacheIndex.shift(); │ │ │ │ + } │ │ │ │ + this.tileCache[tile.url] = tile.imgDiv; │ │ │ │ + this.tileCacheIndex.push(tile.url); │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: drawMarker │ │ │ │ - * Calculate the pixel location for the marker, create it, and │ │ │ │ - * add it to the layer's div │ │ │ │ + /** │ │ │ │ + * Method: clearTileQueue │ │ │ │ + * Clears the tile queue from tiles of a specific layer │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * marker - {} │ │ │ │ + * evt - {Object} Listener argument of the layer's retile event │ │ │ │ */ │ │ │ │ - drawMarker: function(marker) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(marker.lonlat); │ │ │ │ - if (px == null) { │ │ │ │ - marker.display(false); │ │ │ │ - } else { │ │ │ │ - if (!marker.isDrawn()) { │ │ │ │ - var markerImg = marker.draw(px); │ │ │ │ - this.div.appendChild(markerImg); │ │ │ │ - } else if (marker.icon) { │ │ │ │ - marker.icon.moveTo(px); │ │ │ │ + clearTileQueue: function(evt) { │ │ │ │ + var layer = evt.object; │ │ │ │ + var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ + for (var i = tileQueue.length - 1; i >= 0; --i) { │ │ │ │ + if (tileQueue[i].layer === layer) { │ │ │ │ + tileQueue.splice(i, 1); │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getDataExtent │ │ │ │ - * Calculates the max extent which includes all of the markers. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {} │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - getDataExtent: function() { │ │ │ │ - var maxExtent = null; │ │ │ │ - │ │ │ │ - if (this.markers && (this.markers.length > 0)) { │ │ │ │ - var maxExtent = new OpenLayers.Bounds(); │ │ │ │ - for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ - var marker = this.markers[i]; │ │ │ │ - maxExtent.extend(marker.lonlat); │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.maps.length - 1; i >= 0; --i) { │ │ │ │ + this.removeMap(this.maps[i]); │ │ │ │ } │ │ │ │ + this.maps = null; │ │ │ │ + this.tileQueue = null; │ │ │ │ + this.tileQueueId = null; │ │ │ │ + this.tileCache = null; │ │ │ │ + this.tileCacheIndex = null; │ │ │ │ + this._destroyed = true; │ │ │ │ + } │ │ │ │ │ │ │ │ - return maxExtent; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Markers" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/GeoRSS.js │ │ │ │ + OpenLayers/Strategy/Paging.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Markers.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.GeoRSS │ │ │ │ - * Add GeoRSS Point features to your map. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Strategy.Paging │ │ │ │ + * Strategy for vector feature paging │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - │ │ │ │ + * - │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.GeoRSS = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: location │ │ │ │ - * {String} store url of text file │ │ │ │ - */ │ │ │ │ - location: null, │ │ │ │ +OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: features │ │ │ │ - * {Array()} │ │ │ │ + /** │ │ │ │ + * Property: features │ │ │ │ + * {Array()} Cached features. │ │ │ │ */ │ │ │ │ features: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: formatOptions │ │ │ │ - * {Object} Hash of options which should be passed to the format when it is │ │ │ │ - * created. Must be passed in the constructor. │ │ │ │ - */ │ │ │ │ - formatOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: selectedFeature │ │ │ │ - * {} │ │ │ │ - */ │ │ │ │ - selectedFeature: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: icon │ │ │ │ - * {}. This determines the Icon to be used on the map │ │ │ │ - * for this GeoRSS layer. │ │ │ │ + * Property: length │ │ │ │ + * {Integer} Number of features per page. Default is 10. │ │ │ │ */ │ │ │ │ - icon: null, │ │ │ │ + length: 10, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: popupSize │ │ │ │ - * {} This determines the size of GeoRSS popups. If │ │ │ │ - * not provided, defaults to 250px by 120px. │ │ │ │ + * Property: num │ │ │ │ + * {Integer} The currently displayed page number. │ │ │ │ */ │ │ │ │ - popupSize: null, │ │ │ │ + num: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: useFeedTitle │ │ │ │ - * {Boolean} Set layer.name to the first element in the feed. Default is true. │ │ │ │ + /** │ │ │ │ + * Property: paging │ │ │ │ + * {Boolean} The strategy is currently changing pages. │ │ │ │ */ │ │ │ │ - useFeedTitle: true, │ │ │ │ + paging: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.GeoRSS │ │ │ │ - * Create a GeoRSS Layer. │ │ │ │ + * Constructor: OpenLayers.Strategy.Paging │ │ │ │ + * Create a new paging strategy. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * location - {String} │ │ │ │ - * options - {Object} │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - initialize: function(name, location, options) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.initialize.apply(this, [name, options]); │ │ │ │ - this.location = location; │ │ │ │ - this.features = []; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully activated. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - // Warning: Layer.Markers.destroy() must be called prior to calling │ │ │ │ - // clearFeatures() here, otherwise we leak memory. Indeed, if │ │ │ │ - // Layer.Markers.destroy() is called after clearFeatures(), it won't be │ │ │ │ - // able to remove the marker image elements from the layer's div since │ │ │ │ - // the markers will have been destroyed by clearFeatures(). │ │ │ │ - OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ - this.clearFeatures(); │ │ │ │ - this.features = null; │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "beforefeaturesadded": this.cacheFeatures, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: loadRSS │ │ │ │ - * Start the load of the RSS data. Don't do this when we first add the layer, │ │ │ │ - * since we may not be visible at any point, and it would therefore be a waste. │ │ │ │ - */ │ │ │ │ - loadRSS: function() { │ │ │ │ - if (!this.loaded) { │ │ │ │ - this.events.triggerEvent("loadstart"); │ │ │ │ - OpenLayers.Request.GET({ │ │ │ │ - url: this.location, │ │ │ │ - success: this.parseData, │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.layer.events.un({ │ │ │ │ + "beforefeaturesadded": this.cacheFeatures, │ │ │ │ scope: this │ │ │ │ }); │ │ │ │ - this.loaded = true; │ │ │ │ } │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveTo │ │ │ │ - * If layer is visible and RSS has not been loaded, load RSS. │ │ │ │ - * │ │ │ │ + * Method: cacheFeatures │ │ │ │ + * Cache features before they are added to the layer. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {Object} │ │ │ │ - * zoomChanged - {Object} │ │ │ │ - * minor - {Object} │ │ │ │ + * event - {Object} The event that this was listening for. This will come │ │ │ │ + * with a batch of features to be paged. │ │ │ │ */ │ │ │ │ - moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ - if (this.visibility && !this.loaded) { │ │ │ │ - this.loadRSS(); │ │ │ │ + cacheFeatures: function(event) { │ │ │ │ + if (!this.paging) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.features = event.features; │ │ │ │ + this.pageNext(event); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseData │ │ │ │ - * Parse the data returned from the Events call. │ │ │ │ + * Method: clearCache │ │ │ │ + * Clear out the cached features. This destroys features, assuming │ │ │ │ + * nothing else has a reference. │ │ │ │ + */ │ │ │ │ + clearCache: function() { │ │ │ │ + if (this.features) { │ │ │ │ + for (var i = 0; i < this.features.length; ++i) { │ │ │ │ + this.features[i].destroy(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.features = null; │ │ │ │ + this.num = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: pageCount │ │ │ │ + * Get the total count of pages given the current cache of features. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Integer} The page count. │ │ │ │ + */ │ │ │ │ + pageCount: function() { │ │ │ │ + var numFeatures = this.features ? this.features.length : 0; │ │ │ │ + return Math.ceil(numFeatures / this.length); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: pageNum │ │ │ │ + * Get the zero based page number. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Integer} The current page number being displayed. │ │ │ │ + */ │ │ │ │ + pageNum: function() { │ │ │ │ + return this.num; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: pageLength │ │ │ │ + * Gets or sets page length. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * ajaxRequest - {<OpenLayers.Request.XMLHttpRequest>} │ │ │ │ + * newLength - {Integer} Optional length to be set. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Integer} The length of a page (number of features per page). │ │ │ │ */ │ │ │ │ - parseData: function(ajaxRequest) { │ │ │ │ - var doc = ajaxRequest.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read(ajaxRequest.responseText); │ │ │ │ + pageLength: function(newLength) { │ │ │ │ + if (newLength && newLength > 0) { │ │ │ │ + this.length = newLength; │ │ │ │ } │ │ │ │ + return this.length; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.useFeedTitle) { │ │ │ │ - var name = null; │ │ │ │ - try { │ │ │ │ - name = doc.getElementsByTagNameNS('*', 'title')[0].firstChild.nodeValue; │ │ │ │ - } catch (e) { │ │ │ │ - try { │ │ │ │ - name = doc.getElementsByTagName('title')[0].firstChild.nodeValue; │ │ │ │ - } catch (e) {} │ │ │ │ + /** │ │ │ │ + * APIMethod: pageNext │ │ │ │ + * Display the next page of features. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} A new page was displayed. │ │ │ │ + */ │ │ │ │ + pageNext: function(event) { │ │ │ │ + var changed = false; │ │ │ │ + if (this.features) { │ │ │ │ + if (this.num === null) { │ │ │ │ + this.num = -1; │ │ │ │ } │ │ │ │ - if (name) { │ │ │ │ - this.setName(name); │ │ │ │ + var start = (this.num + 1) * this.length; │ │ │ │ + changed = this.page(start, event); │ │ │ │ + } │ │ │ │ + return changed; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: pagePrevious │ │ │ │ + * Display the previous page of features. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} A new page was displayed. │ │ │ │ + */ │ │ │ │ + pagePrevious: function() { │ │ │ │ + var changed = false; │ │ │ │ + if (this.features) { │ │ │ │ + if (this.num === null) { │ │ │ │ + this.num = this.pageCount(); │ │ │ │ } │ │ │ │ + var start = (this.num - 1) * this.length; │ │ │ │ + changed = this.page(start); │ │ │ │ } │ │ │ │ + return changed; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var options = {}; │ │ │ │ + /** │ │ │ │ + * Method: page │ │ │ │ + * Display the page starting at the given index from the cache. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} A new page was displayed. │ │ │ │ + */ │ │ │ │ + page: function(start, event) { │ │ │ │ + var changed = false; │ │ │ │ + if (this.features) { │ │ │ │ + if (start >= 0 && start < this.features.length) { │ │ │ │ + var num = Math.floor(start / this.length); │ │ │ │ + if (num != this.num) { │ │ │ │ + this.paging = true; │ │ │ │ + var features = this.features.slice(start, start + this.length); │ │ │ │ + this.layer.removeFeatures(this.layer.features); │ │ │ │ + this.num = num; │ │ │ │ + // modify the event if any │ │ │ │ + if (event && event.features) { │ │ │ │ + // this.was called by an event listener │ │ │ │ + event.features = features; │ │ │ │ + } else { │ │ │ │ + // this was called directly on the strategy │ │ │ │ + this.layer.addFeatures(features); │ │ │ │ + } │ │ │ │ + this.paging = false; │ │ │ │ + changed = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return changed; │ │ │ │ + }, │ │ │ │ │ │ │ │ - OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Paging" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy/Refresh.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ - options.externalProjection = this.projection; │ │ │ │ - options.internalProjection = this.map.getProjectionObject(); │ │ │ │ - } │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - var format = new OpenLayers.Format.GeoRSS(options); │ │ │ │ - var features = format.read(doc); │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - var data = {}; │ │ │ │ - var feature = features[i]; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Refresh │ │ │ │ + * A strategy that refreshes the layer. By default the strategy waits for a │ │ │ │ + * call to <refresh> before refreshing. By configuring the strategy with │ │ │ │ + * the <interval> option, refreshing can take place automatically. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy.Refresh = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ - // we don't support features with no geometry in the GeoRSS │ │ │ │ - // layer at this time. │ │ │ │ - if (!feature.geometry) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: force │ │ │ │ + * {Boolean} Force a refresh on the layer. Default is false. │ │ │ │ + */ │ │ │ │ + force: false, │ │ │ │ │ │ │ │ - var title = feature.attributes.title ? │ │ │ │ - feature.attributes.title : "Untitled"; │ │ │ │ + /** │ │ │ │ + * Property: interval │ │ │ │ + * {Number} Auto-refresh. Default is 0. If > 0, layer will be refreshed │ │ │ │ + * every N milliseconds. │ │ │ │ + */ │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ - var description = feature.attributes.description ? │ │ │ │ - feature.attributes.description : "No description."; │ │ │ │ + /** │ │ │ │ + * Property: timer │ │ │ │ + * {Number} The id of the timer. │ │ │ │ + */ │ │ │ │ + timer: null, │ │ │ │ │ │ │ │ - var link = feature.attributes.link ? feature.attributes.link : ""; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Strategy.Refresh │ │ │ │ + * Create a new Refresh strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - var location = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (this.layer.visibility === true) { │ │ │ │ + this.start(); │ │ │ │ + } │ │ │ │ + this.layer.events.on({ │ │ │ │ + "visibilitychanged": this.reset, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.stop(); │ │ │ │ + this.layer.events.un({ │ │ │ │ + "visibilitychanged": this.reset, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - data.icon = this.icon == null ? │ │ │ │ - OpenLayers.Marker.defaultIcon() : │ │ │ │ - this.icon.clone(); │ │ │ │ + /** │ │ │ │ + * Method: reset │ │ │ │ + * Start or cancel the refresh interval depending on the visibility of │ │ │ │ + * the layer. │ │ │ │ + */ │ │ │ │ + reset: function() { │ │ │ │ + if (this.layer.visibility === true) { │ │ │ │ + this.start(); │ │ │ │ + } else { │ │ │ │ + this.stop(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - data.popupSize = this.popupSize ? │ │ │ │ - this.popupSize.clone() : │ │ │ │ - new OpenLayers.Size(250, 120); │ │ │ │ + /** │ │ │ │ + * Method: start │ │ │ │ + * Start the refresh interval. │ │ │ │ + */ │ │ │ │ + start: function() { │ │ │ │ + if (this.interval && typeof this.interval === "number" && │ │ │ │ + this.interval > 0) { │ │ │ │ │ │ │ │ - if (title || description) { │ │ │ │ - // we have supplemental data, store them. │ │ │ │ - data.title = title; │ │ │ │ - data.description = description; │ │ │ │ + this.timer = window.setInterval( │ │ │ │ + OpenLayers.Function.bind(this.refresh, this), │ │ │ │ + this.interval); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var contentHTML = '<div class="olLayerGeoRSSClose">[x]</div>'; │ │ │ │ - contentHTML += '<div class="olLayerGeoRSSTitle">'; │ │ │ │ - if (link) { │ │ │ │ - contentHTML += '<a class="link" href="' + link + '" target="_blank">'; │ │ │ │ - } │ │ │ │ - contentHTML += title; │ │ │ │ - if (link) { │ │ │ │ - contentHTML += '</a>'; │ │ │ │ - } │ │ │ │ - contentHTML += '</div>'; │ │ │ │ - contentHTML += '<div style="" class="olLayerGeoRSSDescription">'; │ │ │ │ - contentHTML += description; │ │ │ │ - contentHTML += '</div>'; │ │ │ │ - data['popupContentHTML'] = contentHTML; │ │ │ │ - } │ │ │ │ - var feature = new OpenLayers.Feature(this, location, data); │ │ │ │ - this.features.push(feature); │ │ │ │ - var marker = feature.createMarker(); │ │ │ │ - marker.events.register('click', feature, this.markerClick); │ │ │ │ - this.addMarker(marker); │ │ │ │ + /** │ │ │ │ + * APIMethod: refresh │ │ │ │ + * Tell the strategy to refresh which will refresh the layer. │ │ │ │ + */ │ │ │ │ + refresh: function() { │ │ │ │ + if (this.layer && this.layer.refresh && │ │ │ │ + typeof this.layer.refresh == "function") { │ │ │ │ + │ │ │ │ + this.layer.refresh({ │ │ │ │ + force: this.force │ │ │ │ + }); │ │ │ │ } │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: markerClick │ │ │ │ + * Method: stop │ │ │ │ + * Cancels the refresh interval. │ │ │ │ + */ │ │ │ │ + stop: function() { │ │ │ │ + if (this.timer !== null) { │ │ │ │ + window.clearInterval(this.timer); │ │ │ │ + this.timer = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Refresh" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy/Fixed.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Fixed │ │ │ │ + * A simple strategy that requests features once and never requests new data. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: preload │ │ │ │ + * {Boolean} Load data before layer made visible. Enabling this may result │ │ │ │ + * in considerable overhead if your application loads many data layers │ │ │ │ + * that are not visible by default. Default is false. │ │ │ │ + */ │ │ │ │ + preload: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Strategy.Fixed │ │ │ │ + * Create a new Fixed strategy. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - markerClick: function(evt) { │ │ │ │ - var sameMarkerClicked = (this == this.layer.selectedFeature); │ │ │ │ - this.layer.selectedFeature = (!sameMarkerClicked) ? this : null; │ │ │ │ - for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ - this.layer.map.removePopup(this.layer.map.popups[i]); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + * Activate the strategy: load data or add listener to load when visible │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "refresh": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (this.layer.visibility == true || this.preload) { │ │ │ │ + this.load(); │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (!sameMarkerClicked) { │ │ │ │ - var popup = this.createPopup(); │ │ │ │ - OpenLayers.Event.observe(popup.div, "click", │ │ │ │ - OpenLayers.Function.bind(function() { │ │ │ │ - for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ - this.layer.map.removePopup(this.layer.map.popups[i]); │ │ │ │ - } │ │ │ │ - }, this) │ │ │ │ - ); │ │ │ │ - this.layer.map.addPopup(popup); │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the strategy. Undo what is done in <activate>. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "refresh": this.load, │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearFeatures │ │ │ │ - * Destroy all features in this layer. │ │ │ │ + * Method: load │ │ │ │ + * Tells protocol to load data and unhooks the visibilitychanged event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} options to pass to protocol read. │ │ │ │ */ │ │ │ │ - clearFeatures: function() { │ │ │ │ - if (this.features != null) { │ │ │ │ - while (this.features.length > 0) { │ │ │ │ - var feature = this.features[0]; │ │ │ │ - OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ - feature.destroy(); │ │ │ │ + load: function(options) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.events.triggerEvent("loadstart", { │ │ │ │ + filter: layer.filter │ │ │ │ + }); │ │ │ │ + layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: this.merge, │ │ │ │ + filter: layer.filter, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ + layer.events.un({ │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: merge │ │ │ │ + * Add all features to the layer. │ │ │ │ + * If the layer projection differs from the map projection, features │ │ │ │ + * will be transformed from the layer projection to the map projection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ + * by the protocol. │ │ │ │ + */ │ │ │ │ + merge: function(resp) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.destroyFeatures(); │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = layer.projection; │ │ │ │ + var local = layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + layer.addFeatures(features); │ │ │ │ } │ │ │ │ + layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.GeoRSS" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/XYZ.js │ │ │ │ + OpenLayers/Strategy/BBOX.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.XYZ │ │ │ │ - * The XYZ class is designed to make it easier for people who have tiles │ │ │ │ - * arranged by a standard XYZ grid. │ │ │ │ - * │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.BBOX │ │ │ │ + * A simple strategy that reads new features when the viewport invalidates │ │ │ │ + * some bounds. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.XYZ = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ +OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * Default is true, as this is designed to be a base tile source. │ │ │ │ + * Property: bounds │ │ │ │ + * {<OpenLayers.Bounds>} The current data bounds (in the same projection │ │ │ │ + * as the layer - not always the same projection as the map). │ │ │ │ */ │ │ │ │ - isBaseLayer: true, │ │ │ │ + bounds: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: sphericalMercator │ │ │ │ - * Whether the tile extents should be set to the defaults for │ │ │ │ - * spherical mercator. Useful for things like OpenStreetMap. │ │ │ │ - * Default is false, except for the OSM subclass. │ │ │ │ + /** │ │ │ │ + * Property: resolution │ │ │ │ + * {Float} The current data resolution. │ │ │ │ */ │ │ │ │ - sphericalMercator: false, │ │ │ │ + resolution: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomOffset │ │ │ │ - * {Number} If your cache has more zoom levels than you want to provide │ │ │ │ - * access to with this layer, supply a zoomOffset. This zoom offset │ │ │ │ - * is added to the current map zoom level to determine the level │ │ │ │ - * for a requested tile. For example, if you supply a zoomOffset │ │ │ │ - * of 3, when the map is at the zoom 0, tiles will be requested from │ │ │ │ - * level 3 of your cache. Default is 0 (assumes cache level and map │ │ │ │ - * zoom are equivalent). Using <zoomOffset> is an alternative to │ │ │ │ - * setting <serverResolutions> if you only want to expose a subset │ │ │ │ - * of the server resolutions. │ │ │ │ + * APIProperty: ratio │ │ │ │ + * {Float} The ratio of the data bounds to the viewport bounds (in each │ │ │ │ + * dimension). Default is 2. │ │ │ │ */ │ │ │ │ - zoomOffset: 0, │ │ │ │ + ratio: 2, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: resFactor │ │ │ │ + * {Float} Optional factor used to determine when previously requested │ │ │ │ + * features are invalid. If set, the resFactor will be compared to the │ │ │ │ + * resolution of the previous request to the current map resolution. │ │ │ │ + * If resFactor > (old / new) and 1/resFactor < (old / new). If you │ │ │ │ + * set a resFactor of 1, data will be requested every time the │ │ │ │ + * resolution changes. If you set a resFactor of 3, data will be │ │ │ │ + * requested if the old resolution is 3 times the new, or if the new is │ │ │ │ + * 3 times the old. If the old bounds do not contain the new bounds │ │ │ │ + * new data will always be requested (with or without considering │ │ │ │ + * resFactor). │ │ │ │ + */ │ │ │ │ + resFactor: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: serverResolutions │ │ │ │ - * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ - * property if the map resolutions differ from the server. This │ │ │ │ - * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ - * resolutions that the server supports and that you don't want to │ │ │ │ - * provide with this layer; you can also look at <zoomOffset>, which is │ │ │ │ - * an alternative to <serverResolutions> for that specific purpose. │ │ │ │ - * (b) The map can work with resolutions that aren't supported by │ │ │ │ - * the server, i.e. that aren't in <serverResolutions>. When the │ │ │ │ - * map is displayed in such a resolution data for the closest │ │ │ │ - * server-supported resolution is loaded and the layer div is │ │ │ │ - * stretched as necessary. │ │ │ │ + * Property: response │ │ │ │ + * {<OpenLayers.Protocol.Response>} The protocol response object returned │ │ │ │ + * by the layer protocol. │ │ │ │ */ │ │ │ │ - serverResolutions: null, │ │ │ │ + response: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.XYZ │ │ │ │ + * Constructor: OpenLayers.Strategy.BBOX │ │ │ │ + * Create a new BBOX strategy. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * url - {String} │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - if (options && options.sphericalMercator || this.sphericalMercator) { │ │ │ │ - options = OpenLayers.Util.extend({ │ │ │ │ - projection: "EPSG:900913", │ │ │ │ - numZoomLevels: 19 │ │ │ │ - }, options); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + * Set up strategy with regard to reading new batches of remote data. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully activated. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "moveend": this.update, │ │ │ │ + "refresh": this.update, │ │ │ │ + "visibilitychanged": this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.update(); │ │ │ │ } │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, [ │ │ │ │ - name || this.name, url || this.url, {}, │ │ │ │ - options │ │ │ │ - ]); │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a clone of this layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} Is this ever used? │ │ │ │ + * Method: deactivate │ │ │ │ + * Tear down strategy with regard to reading new batches of remote data. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Layer.XYZ>} An exact clone of this OpenLayers.Layer.XYZ │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.XYZ(this.name, │ │ │ │ - this.url, │ │ │ │ - this.getOptions()); │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "moveend": this.update, │ │ │ │ + "refresh": this.update, │ │ │ │ + "visibilitychanged": this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ + * Callback function called on "moveend" or "refresh" layer events. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will determine │ │ │ │ + * the behaviour of this Strategy │ │ │ │ + * │ │ │ │ + * Valid options include: │ │ │ │ + * force - {Boolean} if true, new data must be unconditionally read. │ │ │ │ + * noAbort - {Boolean} if true, do not abort previous requests. │ │ │ │ + */ │ │ │ │ + update: function(options) { │ │ │ │ + var mapBounds = this.getMapBounds(); │ │ │ │ + if (mapBounds !== null && ((options && options.force) || │ │ │ │ + (this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds)))) { │ │ │ │ + this.calculateBounds(mapBounds); │ │ │ │ + this.resolution = this.layer.map.getResolution(); │ │ │ │ + this.triggerRead(options); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - return obj; │ │ │ │ + /** │ │ │ │ + * Method: getMapBounds │ │ │ │ + * Get the map bounds expressed in the same projection as this layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} Map bounds in the projection of the layer. │ │ │ │ + */ │ │ │ │ + getMapBounds: function() { │ │ │ │ + if (this.layer.map === null) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + var bounds = this.layer.map.getExtent(); │ │ │ │ + if (bounds && !this.layer.projection.equals( │ │ │ │ + this.layer.map.getProjectionObject())) { │ │ │ │ + bounds = bounds.clone().transform( │ │ │ │ + this.layer.map.getProjectionObject(), this.layer.projection │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return bounds; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getURL │ │ │ │ + * Method: invalidBounds │ │ │ │ + * Determine whether the previously requested set of features is invalid. │ │ │ │ + * This occurs when the new map bounds do not contain the previously │ │ │ │ + * requested bounds. In addition, if <resFactor> is set, it will be │ │ │ │ + * considered. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ + * retrieved from the map object if not provided │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - var xyz = this.getXYZ(bounds); │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - var s = '' + xyz.x + xyz.y + xyz.z; │ │ │ │ - url = this.selectUrl(s, url); │ │ │ │ + invalidBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds(); │ │ │ │ + } │ │ │ │ + var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ + if (!invalid && this.resFactor) { │ │ │ │ + var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ + invalid = (ratio >= this.resFactor || ratio <= (1 / this.resFactor)); │ │ │ │ } │ │ │ │ + return invalid; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return OpenLayers.String.format(url, xyz); │ │ │ │ + /** │ │ │ │ + * Method: calculateBounds │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ + * retrieved from the map object if not provided │ │ │ │ + */ │ │ │ │ + calculateBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds(); │ │ │ │ + } │ │ │ │ + var center = mapBounds.getCenterLonLat(); │ │ │ │ + var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ + var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ + this.bounds = new OpenLayers.Bounds( │ │ │ │ + center.lon - (dataWidth / 2), │ │ │ │ + center.lat - (dataHeight / 2), │ │ │ │ + center.lon + (dataWidth / 2), │ │ │ │ + center.lat + (dataHeight / 2) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getXYZ │ │ │ │ - * Calculates x, y and z for the given bounds. │ │ │ │ + * Method: triggerRead │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * options - {Object} Additional options for the protocol's read method │ │ │ │ + * (optional) │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} - an object with x, y and z properties. │ │ │ │ + * {<OpenLayers.Protocol.Response>} The protocol response object │ │ │ │ + * returned by the layer protocol. │ │ │ │ */ │ │ │ │ - getXYZ: function(bounds) { │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.maxExtent.left) / │ │ │ │ - (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((this.maxExtent.top - bounds.top) / │ │ │ │ - (res * this.tileSize.h)); │ │ │ │ - var z = this.getServerZoom(); │ │ │ │ - │ │ │ │ - if (this.wrapDateLine) { │ │ │ │ - var limit = Math.pow(2, z); │ │ │ │ - x = ((x % limit) + limit) % limit; │ │ │ │ + triggerRead: function(options) { │ │ │ │ + if (this.response && !(options && options.noAbort === true)) { │ │ │ │ + this.layer.protocol.abort(this.response); │ │ │ │ + this.layer.events.triggerEvent("loadend"); │ │ │ │ } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - 'x': x, │ │ │ │ - 'y': y, │ │ │ │ - 'z': z │ │ │ │ + var evt = { │ │ │ │ + filter: this.createFilter() │ │ │ │ }; │ │ │ │ + this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ + this.response = this.layer.protocol.read( │ │ │ │ + OpenLayers.Util.applyDefaults({ │ │ │ │ + filter: evt.filter, │ │ │ │ + callback: this.merge, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ }, │ │ │ │ │ │ │ │ - /* APIMethod: setMap │ │ │ │ - * When the layer is added to a map, then we can fetch our origin │ │ │ │ - * (if we don't have one.) │ │ │ │ + /** │ │ │ │ + * Method: createFilter │ │ │ │ + * Creates a spatial BBOX filter. If the layer that this strategy belongs │ │ │ │ + * to has a filter property, this filter will be combined with the BBOX │ │ │ │ + * filter. │ │ │ │ * │ │ │ │ + * Returns │ │ │ │ + * {<OpenLayers.Filter>} The filter object. │ │ │ │ + */ │ │ │ │ + createFilter: function() { │ │ │ │ + var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + value: this.bounds, │ │ │ │ + projection: this.layer.projection │ │ │ │ + }); │ │ │ │ + if (this.layer.filter) { │ │ │ │ + filter = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.layer.filter, filter] │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return filter; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: merge │ │ │ │ + * Given a list of features, determine which ones to add to the layer. │ │ │ │ + * If the layer projection differs from the map projection, features │ │ │ │ + * will be transformed from the layer projection to the map projection. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ + * by the protocol. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ - if (!this.tileOrigin) { │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(this.maxExtent.left, │ │ │ │ - this.maxExtent.bottom); │ │ │ │ + merge: function(resp) { │ │ │ │ + this.layer.destroyFeatures(); │ │ │ │ + if (resp.success()) { │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = this.layer.projection; │ │ │ │ + var local = this.layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.addFeatures(features); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.bounds = null; │ │ │ │ } │ │ │ │ + this.response = null; │ │ │ │ + this.layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/ArcGISCache.js │ │ │ │ + OpenLayers/Strategy/Filter.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/XYZ.js │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Filter.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.ArcGISCache │ │ │ │ - * Layer for accessing cached map tiles from an ArcGIS Server style mapcache. │ │ │ │ - * Tile must already be cached for this layer to access it. This does not require │ │ │ │ - * ArcGIS Server itself. │ │ │ │ - * │ │ │ │ - * A few attempts have been made at this kind of layer before. See │ │ │ │ - * http://trac.osgeo.org/openlayers/ticket/1967 │ │ │ │ - * and │ │ │ │ - * http://trac.osgeo.org/openlayers/browser/sandbox/tschaub/arcgiscache/lib/OpenLayers/Layer/ArcGISCache.js │ │ │ │ - * │ │ │ │ - * Typically the problem encountered is that the tiles seem to "jump around". │ │ │ │ - * This is due to the fact that the actual max extent for the tiles on AGS layers │ │ │ │ - * changes at each zoom level due to the way these caches are constructed. │ │ │ │ - * We have attempted to use the resolutions, tile size, and tile origin │ │ │ │ - * from the cache meta data to make the appropriate changes to the max extent │ │ │ │ - * of the tile to compensate for this behavior. This must be done as zoom levels change │ │ │ │ - * and before tiles are requested, which is why methods from base classes are overridden. │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Filter │ │ │ │ + * Strategy for limiting features that get added to a layer by │ │ │ │ + * evaluating a filter. The strategy maintains a cache of │ │ │ │ + * all features until removeFeatures is called on the layer. │ │ │ │ * │ │ │ │ - * For reference, you can access mapcache meta data in two ways. For accessing a │ │ │ │ - * mapcache through ArcGIS Server, you can simply go to the landing page for the │ │ │ │ - * layer. (ie. http://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer) │ │ │ │ - * For accessing it directly through HTTP, there should always be a conf.xml file │ │ │ │ - * in the root directory. │ │ │ │ - * (ie. http://serverx.esri.com/arcgiscache/DG_County_roads_yesA_backgroundDark/Layers/conf.xml) │ │ │ │ - * │ │ │ │ - *Inherits from: │ │ │ │ - * - <OpenLayers.Layer.XYZ> │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String | Array} The base URL for the layer cache. You can also │ │ │ │ - * provide a list of URL strings for the layer if your cache is │ │ │ │ - * available from multiple origins. This must be set before the layer │ │ │ │ - * is drawn. │ │ │ │ - */ │ │ │ │ - url: null, │ │ │ │ +OpenLayers.Strategy.Filter = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: tileOrigin │ │ │ │ - * {<OpenLayers.LonLat>} The location of the tile origin for the cache. │ │ │ │ - * An ArcGIS cache has it's origin at the upper-left (lowest x value │ │ │ │ - * and highest y value of the coordinate system). The units for the │ │ │ │ - * tile origin should be the same as the units for the cached data. │ │ │ │ + * APIProperty: filter │ │ │ │ + * {<OpenLayers.Filter>} Filter for limiting features sent to the layer. │ │ │ │ + * Use the <setFilter> method to update this filter after construction. │ │ │ │ */ │ │ │ │ - tileOrigin: null, │ │ │ │ + filter: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: tileSize │ │ │ │ - * {<OpenLayers.Size>} This size of each tile. Defaults to 256 by 256 pixels. │ │ │ │ + * Property: cache │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} List of currently cached │ │ │ │ + * features. │ │ │ │ */ │ │ │ │ - tileSize: new OpenLayers.Size(256, 256), │ │ │ │ + cache: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: useAGS │ │ │ │ - * {Boolean} Indicates if we are going to be accessing the ArcGIS Server (AGS) │ │ │ │ - * cache via an AGS MapServer or directly through HTTP. When accessing via │ │ │ │ - * AGS the path structure uses a standard z/y/x structure. But AGS actually │ │ │ │ - * stores the tile images on disk using a hex based folder structure that looks │ │ │ │ - * like "http://example.com/mylayer/L00/R00000000/C00000000.png". Learn more │ │ │ │ - * about this here: │ │ │ │ - * http://blogs.esri.com/Support/blogs/mappingcenter/archive/2010/08/20/Checking-Your-Local-Cache-Folders.aspx │ │ │ │ - * Defaults to true; │ │ │ │ + * Property: caching │ │ │ │ + * {Boolean} The filter is currently caching features. │ │ │ │ */ │ │ │ │ - useArcGISServer: true, │ │ │ │ + caching: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} Image type for the layer. This becomes the filename extension │ │ │ │ - * in tile requests. Default is "png" (generating a url like │ │ │ │ - * "http://example.com/mylayer/L00/R00000000/C00000000.png"). │ │ │ │ + * Constructor: OpenLayers.Strategy.Filter │ │ │ │ + * Create a new filter strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - type: 'png', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: useScales │ │ │ │ - * {Boolean} Optional override to indicate that the layer should use 'scale' information │ │ │ │ - * returned from the server capabilities object instead of 'resolution' information. │ │ │ │ - * This can be important if your tile server uses an unusual DPI for the tiles. │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ + * By default, this strategy automatically activates itself when a layer │ │ │ │ + * is added to a map. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ */ │ │ │ │ - useScales: false, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.cache = []; │ │ │ │ + this.layer.events.on({ │ │ │ │ + "beforefeaturesadded": this.handleAdd, │ │ │ │ + "beforefeaturesremoved": this.handleRemove, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: overrideDPI │ │ │ │ - * {Boolean} Optional override to change the OpenLayers.DOTS_PER_INCH setting based │ │ │ │ - * on the tile information in the server capabilities object. This can be useful │ │ │ │ - * if your server has a non-standard DPI setting on its tiles, and you're only using │ │ │ │ - * tiles with that DPI. This value is used while OpenLayers is calculating resolution │ │ │ │ - * using scales, and is not necessary if you have resolution information. (This is │ │ │ │ - * typically the case) Regardless, this setting can be useful, but is dangerous │ │ │ │ - * because it will impact other layers while calculating resolution. Only use this │ │ │ │ - * if you know what you are doing. (See OpenLayers.Util.getResolutionFromScale) │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the strategy. Clear the feature cache. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ + * the strategy was already inactive. │ │ │ │ */ │ │ │ │ - overrideDPI: false, │ │ │ │ + deactivate: function() { │ │ │ │ + this.cache = null; │ │ │ │ + if (this.layer && this.layer.events) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "beforefeaturesadded": this.handleAdd, │ │ │ │ + "beforefeaturesremoved": this.handleRemove, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return OpenLayers.Strategy.prototype.deactivate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.ArcGISCache │ │ │ │ - * Creates a new instance of this class │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * url - {String} │ │ │ │ - * options - {Object} extra layer options │ │ │ │ + * Method: handleAdd │ │ │ │ */ │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (this.resolutions) { │ │ │ │ - this.serverResolutions = this.resolutions; │ │ │ │ - this.maxExtent = this.getMaxExtentForResolution(this.resolutions[0]); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // this block steps through translating the values from the server layer JSON │ │ │ │ - // capabilities object into values that we can use. This is also a helpful │ │ │ │ - // reference when configuring this layer directly. │ │ │ │ - if (this.layerInfo) { │ │ │ │ - // alias the object │ │ │ │ - var info = this.layerInfo; │ │ │ │ - │ │ │ │ - // build our extents │ │ │ │ - var startingTileExtent = new OpenLayers.Bounds( │ │ │ │ - info.fullExtent.xmin, │ │ │ │ - info.fullExtent.ymin, │ │ │ │ - info.fullExtent.xmax, │ │ │ │ - info.fullExtent.ymax │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // set our projection based on the given spatial reference. │ │ │ │ - // esri uses slightly different IDs, so this may not be comprehensive │ │ │ │ - this.projection = 'EPSG:' + info.spatialReference.wkid; │ │ │ │ - this.sphericalMercator = (info.spatialReference.wkid == 102100); │ │ │ │ - │ │ │ │ - // convert esri units into openlayers units (basic feet or meters only) │ │ │ │ - this.units = (info.units == "esriFeet") ? 'ft' : 'm'; │ │ │ │ - │ │ │ │ - // optional extended section based on whether or not the server returned │ │ │ │ - // specific tile information │ │ │ │ - if (!!info.tileInfo) { │ │ │ │ - // either set the tiles based on rows/columns, or specific width/height │ │ │ │ - this.tileSize = new OpenLayers.Size( │ │ │ │ - info.tileInfo.width || info.tileInfo.cols, │ │ │ │ - info.tileInfo.height || info.tileInfo.rows │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // this must be set when manually configuring this layer │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat( │ │ │ │ - info.tileInfo.origin.x, │ │ │ │ - info.tileInfo.origin.y │ │ │ │ - ); │ │ │ │ - │ │ │ │ - var upperLeft = new OpenLayers.Geometry.Point( │ │ │ │ - startingTileExtent.left, │ │ │ │ - startingTileExtent.top │ │ │ │ - ); │ │ │ │ - │ │ │ │ - var bottomRight = new OpenLayers.Geometry.Point( │ │ │ │ - startingTileExtent.right, │ │ │ │ - startingTileExtent.bottom │ │ │ │ - ); │ │ │ │ - │ │ │ │ - if (this.useScales) { │ │ │ │ - this.scales = []; │ │ │ │ + handleAdd: function(event) { │ │ │ │ + if (!this.caching && this.filter) { │ │ │ │ + var features = event.features; │ │ │ │ + event.features = []; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0, ii = features.length; i < ii; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (this.filter.evaluate(feature)) { │ │ │ │ + event.features.push(feature); │ │ │ │ } else { │ │ │ │ - this.resolutions = []; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.lods = []; │ │ │ │ - for (var key in info.tileInfo.lods) { │ │ │ │ - if (info.tileInfo.lods.hasOwnProperty(key)) { │ │ │ │ - var lod = info.tileInfo.lods[key]; │ │ │ │ - if (this.useScales) { │ │ │ │ - this.scales.push(lod.scale); │ │ │ │ - } else { │ │ │ │ - this.resolutions.push(lod.resolution); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var start = this.getContainingTileCoords(upperLeft, lod.resolution); │ │ │ │ - lod.startTileCol = start.x; │ │ │ │ - lod.startTileRow = start.y; │ │ │ │ - │ │ │ │ - var end = this.getContainingTileCoords(bottomRight, lod.resolution); │ │ │ │ - lod.endTileCol = end.x; │ │ │ │ - lod.endTileRow = end.y; │ │ │ │ - this.lods.push(lod); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.maxExtent = this.calculateMaxExtentWithLOD(this.lods[0]); │ │ │ │ - this.serverResolutions = this.resolutions; │ │ │ │ - if (this.overrideDPI && info.tileInfo.dpi) { │ │ │ │ - // see comment above for 'overrideDPI' │ │ │ │ - OpenLayers.DOTS_PER_INCH = info.tileInfo.dpi; │ │ │ │ + this.cache.push(feature); │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getContainingTileCoords │ │ │ │ - * Calculates the x/y pixel corresponding to the position of the tile │ │ │ │ - * that contains the given point and for the for the given resolution. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * res - {Float} The resolution for which to compute the extent. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position │ │ │ │ - * of the upper left tile for the given resolution. │ │ │ │ + /** │ │ │ │ + * Method: handleRemove │ │ │ │ */ │ │ │ │ - getContainingTileCoords: function(point, res) { │ │ │ │ - return new OpenLayers.Pixel( │ │ │ │ - Math.max(Math.floor((point.x - this.tileOrigin.lon) / (this.tileSize.w * res)), 0), │ │ │ │ - Math.max(Math.floor((this.tileOrigin.lat - point.y) / (this.tileSize.h * res)), 0) │ │ │ │ - ); │ │ │ │ + handleRemove: function(event) { │ │ │ │ + if (!this.caching) { │ │ │ │ + this.cache = []; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: calculateMaxExtentWithLOD │ │ │ │ - * Given a Level of Detail object from the server, this function │ │ │ │ - * calculates the actual max extent │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * lod - {Object} a Level of Detail Object from the server capabilities object │ │ │ │ - representing a particular zoom level │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} The actual extent of the tiles for the given zoom level │ │ │ │ + * APIMethod: setFilter │ │ │ │ + * Update the filter for this strategy. This will re-evaluate │ │ │ │ + * any features on the layer and in the cache. Only features │ │ │ │ + * for which filter.evalute(feature) returns true will be │ │ │ │ + * added to the layer. Others will be cached by the strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {<OpenLayers.Filter>} A filter for evaluating features. │ │ │ │ */ │ │ │ │ - calculateMaxExtentWithLOD: function(lod) { │ │ │ │ - // the max extent we're provided with just overlaps some tiles │ │ │ │ - // our real extent is the bounds of all the tiles we touch │ │ │ │ + setFilter: function(filter) { │ │ │ │ + this.filter = filter; │ │ │ │ + var previousCache = this.cache; │ │ │ │ + this.cache = []; │ │ │ │ + // look through layer for features to remove from layer │ │ │ │ + this.handleAdd({ │ │ │ │ + features: this.layer.features │ │ │ │ + }); │ │ │ │ + // cache now contains features to remove from layer │ │ │ │ + if (this.cache.length > 0) { │ │ │ │ + this.caching = true; │ │ │ │ + this.layer.removeFeatures(this.cache.slice()); │ │ │ │ + this.caching = false; │ │ │ │ + } │ │ │ │ + // now look through previous cache for features to add to layer │ │ │ │ + if (previousCache.length > 0) { │ │ │ │ + var event = { │ │ │ │ + features: previousCache │ │ │ │ + }; │ │ │ │ + this.handleAdd(event); │ │ │ │ + if (event.features.length > 0) { │ │ │ │ + // event has features to add to layer │ │ │ │ + this.caching = true; │ │ │ │ + this.layer.addFeatures(event.features); │ │ │ │ + this.caching = false; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var numTileCols = (lod.endTileCol - lod.startTileCol) + 1; │ │ │ │ - var numTileRows = (lod.endTileRow - lod.startTileRow) + 1; │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Filter" │ │ │ │ │ │ │ │ - var minX = this.tileOrigin.lon + (lod.startTileCol * this.tileSize.w * lod.resolution); │ │ │ │ - var maxX = minX + (numTileCols * this.tileSize.w * lod.resolution); │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy/Save.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - var maxY = this.tileOrigin.lat - (lod.startTileRow * this.tileSize.h * lod.resolution); │ │ │ │ - var minY = maxY - (numTileRows * this.tileSize.h * lod.resolution); │ │ │ │ - return new OpenLayers.Bounds(minX, minY, maxX, maxY); │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: calculateMaxExtentWithExtent │ │ │ │ - * Given a 'suggested' max extent from the server, this function uses │ │ │ │ - * information about the actual tile sizes to determine the actual │ │ │ │ - * extent of the layer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * extent - {<OpenLayers.Bounds>} The 'suggested' extent for the layer │ │ │ │ - * res - {Float} The resolution for which to compute the extent. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} The actual extent of the tiles for the given zoom level │ │ │ │ - */ │ │ │ │ - calculateMaxExtentWithExtent: function(extent, res) { │ │ │ │ - var upperLeft = new OpenLayers.Geometry.Point(extent.left, extent.top); │ │ │ │ - var bottomRight = new OpenLayers.Geometry.Point(extent.right, extent.bottom); │ │ │ │ - var start = this.getContainingTileCoords(upperLeft, res); │ │ │ │ - var end = this.getContainingTileCoords(bottomRight, res); │ │ │ │ - var lod = { │ │ │ │ - resolution: res, │ │ │ │ - startTileCol: start.x, │ │ │ │ - startTileRow: start.y, │ │ │ │ - endTileCol: end.x, │ │ │ │ - endTileRow: end.y │ │ │ │ - }; │ │ │ │ - return this.calculateMaxExtentWithLOD(lod); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getUpperLeftTileCoord │ │ │ │ - * Calculates the x/y pixel corresponding to the position │ │ │ │ - * of the upper left tile for the given resolution. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * res - {Float} The resolution for which to compute the extent. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position │ │ │ │ - * of the upper left tile for the given resolution. │ │ │ │ - */ │ │ │ │ - getUpperLeftTileCoord: function(res) { │ │ │ │ - var upperLeft = new OpenLayers.Geometry.Point( │ │ │ │ - this.maxExtent.left, │ │ │ │ - this.maxExtent.top); │ │ │ │ - return this.getContainingTileCoords(upperLeft, res); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Save │ │ │ │ + * A strategy that commits newly created or modified features. By default │ │ │ │ + * the strategy waits for a call to <save> before persisting changes. By │ │ │ │ + * configuring the strategy with the <auto> option, changes can be saved │ │ │ │ + * automatically. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy.Save = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getLowerRightTileCoord │ │ │ │ - * Calculates the x/y pixel corresponding to the position │ │ │ │ - * of the lower right tile for the given resolution. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * res - {Float} The resolution for which to compute the extent. │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} An events object that handles all │ │ │ │ + * events on the strategy object. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * strategy.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types: │ │ │ │ + * start - Triggered before saving │ │ │ │ + * success - Triggered after a successful transaction │ │ │ │ + * fail - Triggered after a failed transaction │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position │ │ │ │ - * of the lower right tile for the given resolution. │ │ │ │ */ │ │ │ │ - getLowerRightTileCoord: function(res) { │ │ │ │ - var bottomRight = new OpenLayers.Geometry.Point( │ │ │ │ - this.maxExtent.right, │ │ │ │ - this.maxExtent.bottom); │ │ │ │ - return this.getContainingTileCoords(bottomRight, res); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getMaxExtentForResolution │ │ │ │ - * Since the max extent of a set of tiles can change from zoom level │ │ │ │ - * to zoom level, we need to be able to calculate that max extent │ │ │ │ - * for a given resolution. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * res - {Float} The resolution for which to compute the extent. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} The extent for this resolution │ │ │ │ + * Property: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for triggering this protocol │ │ │ │ + * events. │ │ │ │ */ │ │ │ │ - getMaxExtentForResolution: function(res) { │ │ │ │ - var start = this.getUpperLeftTileCoord(res); │ │ │ │ - var end = this.getLowerRightTileCoord(res); │ │ │ │ + events: null, │ │ │ │ │ │ │ │ - var numTileCols = (end.x - start.x) + 1; │ │ │ │ - var numTileRows = (end.y - start.y) + 1; │ │ │ │ + /** │ │ │ │ + * APIProperty: auto │ │ │ │ + * {Boolean | Number} Auto-save. Default is false. If true, features will be │ │ │ │ + * saved immediately after being added to the layer and with each │ │ │ │ + * modification or deletion. If auto is a number, features will be │ │ │ │ + * saved on an interval provided by the value (in seconds). │ │ │ │ + */ │ │ │ │ + auto: false, │ │ │ │ │ │ │ │ - var minX = this.tileOrigin.lon + (start.x * this.tileSize.w * res); │ │ │ │ - var maxX = minX + (numTileCols * this.tileSize.w * res); │ │ │ │ + /** │ │ │ │ + * Property: timer │ │ │ │ + * {Number} The id of the timer. │ │ │ │ + */ │ │ │ │ + timer: null, │ │ │ │ │ │ │ │ - var maxY = this.tileOrigin.lat - (start.y * this.tileSize.h * res); │ │ │ │ - var minY = maxY - (numTileRows * this.tileSize.h * res); │ │ │ │ - return new OpenLayers.Bounds(minX, minY, maxX, maxY); │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Strategy.Save │ │ │ │ + * Create a new Save strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Strategy.prototype.initialize.apply(this, [options]); │ │ │ │ + this.events = new OpenLayers.Events(this); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Returns an exact clone of this OpenLayers.Layer.ArcGISCache │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * [obj] - {Object} optional object to assign the cloned instance to. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.ArcGISCache>} clone of this instance │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully activated. │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.ArcGISCache(this.name, this.url, this.options); │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (this.auto) { │ │ │ │ + if (typeof this.auto === "number") { │ │ │ │ + this.timer = window.setInterval( │ │ │ │ + OpenLayers.Function.bind(this.save, this), │ │ │ │ + this.auto * 1000 │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "featureadded": this.triggerSave, │ │ │ │ + "afterfeaturemodified": this.triggerSave, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - return OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: initGriddedTiles │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ */ │ │ │ │ - initGriddedTiles: function(bounds) { │ │ │ │ - delete this._tileOrigin; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initGriddedTiles.apply(this, arguments); │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + if (this.auto) { │ │ │ │ + if (typeof this.auto === "number") { │ │ │ │ + window.clearInterval(this.timer); │ │ │ │ + } else { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "featureadded": this.triggerSave, │ │ │ │ + "afterfeaturemodified": this.triggerSave, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getMaxExtent │ │ │ │ - * Get this layer's maximum extent. │ │ │ │ + * Method: triggerSave │ │ │ │ + * Registered as a listener. Calls save if a feature has insert, update, │ │ │ │ + * or delete state. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} │ │ │ │ + * Parameters: │ │ │ │ + * event - {Object} The event this function is listening for. │ │ │ │ */ │ │ │ │ - getMaxExtent: function() { │ │ │ │ - var resolution = this.map.getResolution(); │ │ │ │ - return this.maxExtent = this.getMaxExtentForResolution(resolution); │ │ │ │ + triggerSave: function(event) { │ │ │ │ + var feature = event.feature; │ │ │ │ + if (feature.state === OpenLayers.State.INSERT || │ │ │ │ + feature.state === OpenLayers.State.UPDATE || │ │ │ │ + feature.state === OpenLayers.State.DELETE) { │ │ │ │ + this.save([event.feature]); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getTileOrigin │ │ │ │ - * Determine the origin for aligning the grid of tiles. │ │ │ │ - * The origin will be derived from the layer's <maxExtent> property. │ │ │ │ + * APIMethod: save │ │ │ │ + * Tell the layer protocol to commit unsaved features. If the layer │ │ │ │ + * projection differs from the map projection, features will be │ │ │ │ + * transformed into the layer projection before being committed. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.LonLat>} The tile origin. │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array} Features to be saved. If null, then default is all │ │ │ │ + * features in the layer. Features are assumed to be in the map │ │ │ │ + * projection. │ │ │ │ */ │ │ │ │ - getTileOrigin: function() { │ │ │ │ - if (!this._tileOrigin) { │ │ │ │ - var extent = this.getMaxExtent(); │ │ │ │ - this._tileOrigin = new OpenLayers.LonLat(extent.left, extent.bottom); │ │ │ │ + save: function(features) { │ │ │ │ + if (!features) { │ │ │ │ + features = this.layer.features; │ │ │ │ } │ │ │ │ - return this._tileOrigin; │ │ │ │ + this.events.triggerEvent("start", { │ │ │ │ + features: features │ │ │ │ + }); │ │ │ │ + var remote = this.layer.projection; │ │ │ │ + var local = this.layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var len = features.length; │ │ │ │ + var clones = new Array(len); │ │ │ │ + var orig, clone; │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + orig = features[i]; │ │ │ │ + clone = orig.clone(); │ │ │ │ + clone.fid = orig.fid; │ │ │ │ + clone.state = orig.state; │ │ │ │ + if (orig.url) { │ │ │ │ + clone.url = orig.url; │ │ │ │ + } │ │ │ │ + clone._original = orig; │ │ │ │ + clone.geometry.transform(local, remote); │ │ │ │ + clones[i] = clone; │ │ │ │ + } │ │ │ │ + features = clones; │ │ │ │ + } │ │ │ │ + this.layer.protocol.commit(features, { │ │ │ │ + callback: this.onCommit, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getURL │ │ │ │ - * Determine the URL for a tile given the tile bounds. This is should support │ │ │ │ - * urls that access tiles through an ArcGIS Server MapServer or directly through │ │ │ │ - * the hex folder structure using HTTP. Just be sure to set the useArcGISServer │ │ │ │ - * property appropriately! This is basically the same as │ │ │ │ - * 'OpenLayers.Layer.TMS.getURL', but with the addition of hex addressing, │ │ │ │ - * and tile rounding. │ │ │ │ + * Method: onCommit │ │ │ │ + * Called after protocol commit. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The URL for a tile based on given bounds. │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} A response object. │ │ │ │ */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - var res = this.getResolution(); │ │ │ │ - │ │ │ │ - // tile center │ │ │ │ - var originTileX = (this.tileOrigin.lon + (res * this.tileSize.w / 2)); │ │ │ │ - var originTileY = (this.tileOrigin.lat - (res * this.tileSize.h / 2)); │ │ │ │ - │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var point = { │ │ │ │ - x: center.lon, │ │ │ │ - y: center.lat │ │ │ │ + onCommit: function(response) { │ │ │ │ + var evt = { │ │ │ │ + "response": response │ │ │ │ }; │ │ │ │ - var x = (Math.round(Math.abs((center.lon - originTileX) / (res * this.tileSize.w)))); │ │ │ │ - var y = (Math.round(Math.abs((originTileY - center.lat) / (res * this.tileSize.h)))); │ │ │ │ - var z = this.map.getZoom(); │ │ │ │ - │ │ │ │ - // this prevents us from getting pink tiles (non-existant tiles) │ │ │ │ - if (this.lods) { │ │ │ │ - var lod = this.lods[this.map.getZoom()]; │ │ │ │ - if ((x < lod.startTileCol || x > lod.endTileCol) || │ │ │ │ - (y < lod.startTileRow || y > lod.endTileRow)) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - var start = this.getUpperLeftTileCoord(res); │ │ │ │ - var end = this.getLowerRightTileCoord(res); │ │ │ │ - if ((x < start.x || x >= end.x) || │ │ │ │ - (y < start.y || y >= end.y)) { │ │ │ │ - return null; │ │ │ │ + if (response.success()) { │ │ │ │ + var features = response.reqFeatures; │ │ │ │ + // deal with inserts, updates, and deletes │ │ │ │ + var state, feature; │ │ │ │ + var destroys = []; │ │ │ │ + var insertIds = response.insertIds || []; │ │ │ │ + var j = 0; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + // if projection was different, we may be dealing with clones │ │ │ │ + feature = feature._original || feature; │ │ │ │ + state = feature.state; │ │ │ │ + if (state) { │ │ │ │ + if (state == OpenLayers.State.DELETE) { │ │ │ │ + destroys.push(feature); │ │ │ │ + } else if (state == OpenLayers.State.INSERT) { │ │ │ │ + feature.fid = insertIds[j]; │ │ │ │ + ++j; │ │ │ │ + } │ │ │ │ + feature.state = null; │ │ │ │ + } │ │ │ │ } │ │ │ │ - } │ │ │ │ │ │ │ │ - // Construct the url string │ │ │ │ - var url = this.url; │ │ │ │ - var s = '' + x + y + z; │ │ │ │ + if (destroys.length > 0) { │ │ │ │ + this.layer.destroyFeatures(destroys); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(s, url); │ │ │ │ - } │ │ │ │ + this.events.triggerEvent("success", evt); │ │ │ │ │ │ │ │ - // Accessing tiles through ArcGIS Server uses a different path │ │ │ │ - // structure than direct access via the folder structure. │ │ │ │ - if (this.useArcGISServer) { │ │ │ │ - // AGS MapServers have pretty url access to tiles │ │ │ │ - url = url + '/tile/${z}/${y}/${x}'; │ │ │ │ } else { │ │ │ │ - // The tile images are stored using hex values on disk. │ │ │ │ - x = 'C' + OpenLayers.Number.zeroPad(x, 8, 16); │ │ │ │ - y = 'R' + OpenLayers.Number.zeroPad(y, 8, 16); │ │ │ │ - z = 'L' + OpenLayers.Number.zeroPad(z, 2, 10); │ │ │ │ - url = url + '/${z}/${y}/${x}.' + this.type; │ │ │ │ + this.events.triggerEvent("fail", evt); │ │ │ │ } │ │ │ │ - │ │ │ │ - // Write the values into our formatted url │ │ │ │ - url = OpenLayers.String.format(url, { │ │ │ │ - 'x': x, │ │ │ │ - 'y': y, │ │ │ │ - 'z': z │ │ │ │ - }); │ │ │ │ - │ │ │ │ - return OpenLayers.Util.urlAppend( │ │ │ │ - url, OpenLayers.Util.getParameterString(this.params) │ │ │ │ - ); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: 'OpenLayers.Layer.ArcGISCache' │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Save" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Bing.js │ │ │ │ + OpenLayers/Strategy/Cluster.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/XYZ.js │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.Bing │ │ │ │ - * Bing layer using direct tile access as provided by Bing Maps REST Services. │ │ │ │ - * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more │ │ │ │ - * information. Note: Terms of Service compliant use requires the map to be │ │ │ │ - * configured with an <OpenLayers.Control.Attribution> control and the │ │ │ │ - * attribution placed on or near the map. │ │ │ │ - * │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Cluster │ │ │ │ + * Strategy for vector feature clustering. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.XYZ> │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: key │ │ │ │ - * {String} API key for Bing maps, get your own key │ │ │ │ - * at http://bingmapsportal.com/ . │ │ │ │ - */ │ │ │ │ - key: null, │ │ │ │ +OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: serverResolutions │ │ │ │ - * {Array} the resolutions provided by the Bing servers. │ │ │ │ + * APIProperty: distance │ │ │ │ + * {Integer} Pixel distance between features that should be considered a │ │ │ │ + * single cluster. Default is 20 pixels. │ │ │ │ */ │ │ │ │ - serverResolutions: [ │ │ │ │ - 156543.03390625, 78271.516953125, 39135.7584765625, │ │ │ │ - 19567.87923828125, 9783.939619140625, 4891.9698095703125, │ │ │ │ - 2445.9849047851562, 1222.9924523925781, 611.4962261962891, │ │ │ │ - 305.74811309814453, 152.87405654907226, 76.43702827453613, │ │ │ │ - 38.218514137268066, 19.109257068634033, 9.554628534317017, │ │ │ │ - 4.777314267158508, 2.388657133579254, 1.194328566789627, │ │ │ │ - 0.5971642833948135, 0.29858214169740677, 0.14929107084870338, │ │ │ │ - 0.07464553542435169 │ │ │ │ - ], │ │ │ │ + distance: 20, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: attributionTemplate │ │ │ │ - * {String} │ │ │ │ + * APIProperty: threshold │ │ │ │ + * {Integer} Optional threshold below which original features will be │ │ │ │ + * added to the layer instead of clusters. For example, a threshold │ │ │ │ + * of 3 would mean that any time there are 2 or fewer features in │ │ │ │ + * a cluster, those features will be added directly to the layer instead │ │ │ │ + * of a cluster representing those features. Default is null (which is │ │ │ │ + * equivalent to 1 - meaning that clusters may contain just one feature). │ │ │ │ */ │ │ │ │ - attributionTemplate: '<span class="olBingAttribution ${type}">' + │ │ │ │ - '<div><a target="_blank" href="http://www.bing.com/maps/">' + │ │ │ │ - '<img src="${logo}" /></a></div>${copyrights}' + │ │ │ │ - '<a style="white-space: nowrap" target="_blank" ' + │ │ │ │ - 'href="http://www.microsoft.com/maps/product/terms.html">' + │ │ │ │ - 'Terms of Use</a></span>', │ │ │ │ + threshold: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: metadata │ │ │ │ - * {Object} Metadata for this layer, as returned by the callback script │ │ │ │ + * Property: features │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} Cached features. │ │ │ │ */ │ │ │ │ - metadata: null, │ │ │ │ + features: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: protocolRegex │ │ │ │ - * {RegExp} Regular expression to match and replace http: in bing urls │ │ │ │ + * Property: clusters │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} Calculated clusters. │ │ │ │ */ │ │ │ │ - protocolRegex: /^http:/i, │ │ │ │ + clusters: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ - * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ - * used. Default is "Road". │ │ │ │ + * Property: clustering │ │ │ │ + * {Boolean} The strategy is currently clustering features. │ │ │ │ */ │ │ │ │ - type: "Road", │ │ │ │ + clustering: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: culture │ │ │ │ - * {String} The culture identifier. See http://msdn.microsoft.com/en-us/library/ff701709.aspx │ │ │ │ - * for the definition and the possible values. Default is "en-US". │ │ │ │ + * Property: resolution │ │ │ │ + * {Float} The resolution (map units per pixel) of the current cluster set. │ │ │ │ */ │ │ │ │ - culture: "en-US", │ │ │ │ + resolution: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: metadataParams │ │ │ │ - * {Object} Optional url parameters for the Get Imagery Metadata request │ │ │ │ - * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx │ │ │ │ - */ │ │ │ │ - metadataParams: null, │ │ │ │ - │ │ │ │ - /** APIProperty: tileOptions │ │ │ │ - * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ - * created by this Layer. Default is │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: 'anonymous'} │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ - tileOptions: null, │ │ │ │ - │ │ │ │ - /** APIProperty: protocol │ │ │ │ - * {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo │ │ │ │ - * Can be 'http:' 'https:' or '' │ │ │ │ - * │ │ │ │ - * Warning: tiles may not be available under both HTTP and HTTPS protocols. │ │ │ │ - * Microsoft approved use of both HTTP and HTTPS urls for tiles. However │ │ │ │ - * this is undocumented and the Imagery Metadata API always returns HTTP │ │ │ │ - * urls. │ │ │ │ + * Constructor: OpenLayers.Strategy.Cluster │ │ │ │ + * Create a new clustering strategy. │ │ │ │ * │ │ │ │ - * Default is '', unless when executed from a file:/// uri, in which case │ │ │ │ - * it is 'http:'. │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - protocol: ~window.location.href.indexOf('http') ? '' : 'http:', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Bing │ │ │ │ - * Create a new Bing layer. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var road = new OpenLayers.Layer.Bing({ │ │ │ │ - * name: "My Bing Aerial Layer", │ │ │ │ - * type: "Aerial", │ │ │ │ - * key: "my-api-key-here", │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Configuration properties for the layer. │ │ │ │ - * │ │ │ │ - * Required configuration properties: │ │ │ │ - * key - {String} Bing Maps API key for your application. Get one at │ │ │ │ - * http://bingmapsportal.com/. │ │ │ │ - * type - {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ - * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ - * used. │ │ │ │ - * │ │ │ │ - * Any other documented layer properties can be provided in the config object. │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully activated. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - sphericalMercator: true │ │ │ │ - }, options); │ │ │ │ - var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ - │ │ │ │ - var newArgs = [name, null, options]; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: 'anonymous' │ │ │ │ - }, this.options.tileOptions); │ │ │ │ - this.loadMetadata(); │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "beforefeaturesadded": this.cacheFeatures, │ │ │ │ + "featuresremoved": this.clearCache, │ │ │ │ + "moveend": this.cluster, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: loadMetadata │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ */ │ │ │ │ - loadMetadata: function() { │ │ │ │ - this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ - // link the processMetadata method to the global scope and bind it │ │ │ │ - // to this instance │ │ │ │ - window[this._callbackId] = OpenLayers.Function.bind( │ │ │ │ - OpenLayers.Layer.Bing.processMetadata, this │ │ │ │ - ); │ │ │ │ - var params = OpenLayers.Util.applyDefaults({ │ │ │ │ - key: this.key, │ │ │ │ - jsonp: this._callbackId, │ │ │ │ - include: "ImageryProviders" │ │ │ │ - }, this.metadataParams); │ │ │ │ - var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + │ │ │ │ - this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = this._callbackId; │ │ │ │ - document.getElementsByTagName("head")[0].appendChild(script); │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.layer.events.un({ │ │ │ │ + "beforefeaturesadded": this.cacheFeatures, │ │ │ │ + "featuresremoved": this.clearCache, │ │ │ │ + "moveend": this.cluster, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: initLayer │ │ │ │ + * Method: cacheFeatures │ │ │ │ + * Cache features before they are added to the layer. │ │ │ │ * │ │ │ │ - * Sets layer properties according to the metadata provided by the API │ │ │ │ + * Parameters: │ │ │ │ + * event - {Object} The event that this was listening for. This will come │ │ │ │ + * with a batch of features to be clustered. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} False to stop features from being added to the layer. │ │ │ │ */ │ │ │ │ - initLayer: function() { │ │ │ │ - var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ - var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ - url = url.replace("{culture}", this.culture); │ │ │ │ - url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.url = []; │ │ │ │ - for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ - this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])); │ │ │ │ + cacheFeatures: function(event) { │ │ │ │ + var propagate = true; │ │ │ │ + if (!this.clustering) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.features = event.features; │ │ │ │ + this.cluster(); │ │ │ │ + propagate = false; │ │ │ │ } │ │ │ │ - this.addOptions({ │ │ │ │ - maxResolution: Math.min( │ │ │ │ - this.serverResolutions[res.zoomMin], │ │ │ │ - this.maxResolution || Number.POSITIVE_INFINITY │ │ │ │ - ), │ │ │ │ - numZoomLevels: Math.min( │ │ │ │ - res.zoomMax + 1 - res.zoomMin, this.numZoomLevels │ │ │ │ - ) │ │ │ │ - }, true); │ │ │ │ - if (!this.isBaseLayer) { │ │ │ │ - this.redraw(); │ │ │ │ + return propagate; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: clearCache │ │ │ │ + * Clear out the cached features. │ │ │ │ + */ │ │ │ │ + clearCache: function() { │ │ │ │ + if (!this.clustering) { │ │ │ │ + this.features = null; │ │ │ │ } │ │ │ │ - this.updateAttribution(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getURL │ │ │ │ + * Method: cluster │ │ │ │ + * Cluster features based on some threshold distance. │ │ │ │ * │ │ │ │ - * Paramters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * Parameters: │ │ │ │ + * event - {Object} The event received when cluster is called as a │ │ │ │ + * result of a moveend event. │ │ │ │ */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - if (!this.url) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var xyz = this.getXYZ(bounds), │ │ │ │ - x = xyz.x, │ │ │ │ - y = xyz.y, │ │ │ │ - z = xyz.z; │ │ │ │ - var quadDigits = []; │ │ │ │ - for (var i = z; i > 0; --i) { │ │ │ │ - var digit = '0'; │ │ │ │ - var mask = 1 << (i - 1); │ │ │ │ - if ((x & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - } │ │ │ │ - if ((y & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - digit++; │ │ │ │ + cluster: function(event) { │ │ │ │ + if ((!event || event.zoomChanged) && this.features) { │ │ │ │ + var resolution = this.layer.map.getResolution(); │ │ │ │ + if (resolution != this.resolution || !this.clustersExist()) { │ │ │ │ + this.resolution = resolution; │ │ │ │ + var clusters = []; │ │ │ │ + var feature, clustered, cluster; │ │ │ │ + for (var i = 0; i < this.features.length; ++i) { │ │ │ │ + feature = this.features[i]; │ │ │ │ + if (feature.geometry) { │ │ │ │ + clustered = false; │ │ │ │ + for (var j = clusters.length - 1; j >= 0; --j) { │ │ │ │ + cluster = clusters[j]; │ │ │ │ + if (this.shouldCluster(cluster, feature)) { │ │ │ │ + this.addToCluster(cluster, feature); │ │ │ │ + clustered = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!clustered) { │ │ │ │ + clusters.push(this.createCluster(this.features[i])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.clustering = true; │ │ │ │ + this.layer.removeAllFeatures(); │ │ │ │ + this.clustering = false; │ │ │ │ + if (clusters.length > 0) { │ │ │ │ + if (this.threshold > 1) { │ │ │ │ + var clone = clusters.slice(); │ │ │ │ + clusters = []; │ │ │ │ + var candidate; │ │ │ │ + for (var i = 0, len = clone.length; i < len; ++i) { │ │ │ │ + candidate = clone[i]; │ │ │ │ + if (candidate.attributes.count < this.threshold) { │ │ │ │ + Array.prototype.push.apply(clusters, candidate.cluster); │ │ │ │ + } else { │ │ │ │ + clusters.push(candidate); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.clustering = true; │ │ │ │ + // A legitimate feature addition could occur during this │ │ │ │ + // addFeatures call. For clustering to behave well, features │ │ │ │ + // should be removed from a layer before requesting a new batch. │ │ │ │ + this.layer.addFeatures(clusters); │ │ │ │ + this.clustering = false; │ │ │ │ + } │ │ │ │ + this.clusters = clusters; │ │ │ │ } │ │ │ │ - quadDigits.push(digit); │ │ │ │ } │ │ │ │ - var quadKey = quadDigits.join(""); │ │ │ │ - var url = this.selectUrl('' + x + y + z, this.url); │ │ │ │ - │ │ │ │ - return OpenLayers.String.format(url, { │ │ │ │ - 'quadkey': quadKey │ │ │ │ - }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateAttribution │ │ │ │ - * Updates the attribution according to the requirements outlined in │ │ │ │ - * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html │ │ │ │ + * Method: clustersExist │ │ │ │ + * Determine whether calculated clusters are already on the layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The calculated clusters are already on the layer. │ │ │ │ */ │ │ │ │ - updateAttribution: function() { │ │ │ │ - var metadata = this.metadata; │ │ │ │ - if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var res = metadata.resourceSets[0].resources[0]; │ │ │ │ - var extent = this.map.getExtent().transform( │ │ │ │ - this.map.getProjectionObject(), │ │ │ │ - new OpenLayers.Projection("EPSG:4326") │ │ │ │ - ); │ │ │ │ - var providers = res.imageryProviders || [], │ │ │ │ - zoom = OpenLayers.Util.indexOf(this.serverResolutions, │ │ │ │ - this.getServerResolution()), │ │ │ │ - copyrights = "", │ │ │ │ - provider, i, ii, j, jj, bbox, coverage; │ │ │ │ - for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ - provider = providers[i]; │ │ │ │ - for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ - coverage = provider.coverageAreas[j]; │ │ │ │ - // axis order provided is Y,X │ │ │ │ - bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ - if (extent.intersectsBounds(bbox) && │ │ │ │ - zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ - copyrights += provider.attribution + " "; │ │ │ │ + clustersExist: function() { │ │ │ │ + var exist = false; │ │ │ │ + if (this.clusters && this.clusters.length > 0 && │ │ │ │ + this.clusters.length == this.layer.features.length) { │ │ │ │ + exist = true; │ │ │ │ + for (var i = 0; i < this.clusters.length; ++i) { │ │ │ │ + if (this.clusters[i] != this.layer.features[i]) { │ │ │ │ + exist = false; │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ - type: this.type.toLowerCase(), │ │ │ │ - logo: logo, │ │ │ │ - copyrights: copyrights │ │ │ │ - }); │ │ │ │ - this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "attribution" │ │ │ │ - }); │ │ │ │ + return exist; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * Method: shouldCluster │ │ │ │ + * Determine whether to include a feature in a given cluster. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * cluster - {<OpenLayers.Feature.Vector>} A cluster. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} A feature. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The feature should be included in the cluster. │ │ │ │ */ │ │ │ │ - setMap: function() { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("moveend", this, this.updateAttribution); │ │ │ │ + shouldCluster: function(cluster, feature) { │ │ │ │ + var cc = cluster.geometry.getBounds().getCenterLonLat(); │ │ │ │ + var fc = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + var distance = ( │ │ │ │ + Math.sqrt( │ │ │ │ + Math.pow((cc.lon - fc.lon), 2) + Math.pow((cc.lat - fc.lat), 2) │ │ │ │ + ) / this.resolution │ │ │ │ + ); │ │ │ │ + return (distance <= this.distance); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * │ │ │ │ + * Method: addToCluster │ │ │ │ + * Add a feature to a cluster. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing> │ │ │ │ + * cluster - {<OpenLayers.Feature.Vector>} A cluster. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} A feature. │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Bing(this.options); │ │ │ │ - } │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - return obj; │ │ │ │ + addToCluster: function(cluster, feature) { │ │ │ │ + cluster.cluster.push(feature); │ │ │ │ + cluster.attributes.count += 1; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * Method: createCluster │ │ │ │ + * Given a feature, create a cluster. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} A cluster. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.map && │ │ │ │ - this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ - OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments); │ │ │ │ + createCluster: function(feature) { │ │ │ │ + var center = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + var cluster = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.Point(center.lon, center.lat), { │ │ │ │ + count: 1 │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + cluster.cluster = [feature]; │ │ │ │ + return cluster; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Cluster" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Layer.Bing.processMetadata │ │ │ │ - * This function will be bound to an instance, linked to the global scope with │ │ │ │ - * an id, and called by the JSONP script returned by the API. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * metadata - {Object} metadata as returned by the API │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ - this.metadata = metadata; │ │ │ │ - this.initLayer(); │ │ │ │ - var script = document.getElementById(this._callbackId); │ │ │ │ - script.parentNode.removeChild(script); │ │ │ │ - window[this._callbackId] = undefined; // cannot delete from window in IE │ │ │ │ - delete this._callbackId; │ │ │ │ -}; │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Layer/SphericalMercator.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ @@ -36829,771 +36873,1250 @@ │ │ │ │ */ │ │ │ │ getMapObjectPixelFromXY: function(x, y) { │ │ │ │ return new GPoint(x, y); │ │ │ │ } │ │ │ │ │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/WorldWind.js │ │ │ │ + OpenLayers/Layer/XYZ.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.WorldWind │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.XYZ │ │ │ │ + * The XYZ class is designed to make it easier for people who have tiles │ │ │ │ + * arranged by a standard XYZ grid. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.WorldWind = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - │ │ │ │ - DEFAULT_PARAMS: {}, │ │ │ │ +OpenLayers.Layer.XYZ = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ /** │ │ │ │ * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} WorldWind layer is a base layer by default. │ │ │ │ + * Default is true, as this is designed to be a base tile source. │ │ │ │ */ │ │ │ │ isBaseLayer: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: lzd │ │ │ │ - * {Float} LevelZeroTileSizeDegrees │ │ │ │ + /** │ │ │ │ + * APIProperty: sphericalMercator │ │ │ │ + * Whether the tile extents should be set to the defaults for │ │ │ │ + * spherical mercator. Useful for things like OpenStreetMap. │ │ │ │ + * Default is false, except for the OSM subclass. │ │ │ │ */ │ │ │ │ - lzd: null, │ │ │ │ + sphericalMercator: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomLevels │ │ │ │ - * {Integer} Number of zoom levels. │ │ │ │ + * APIProperty: zoomOffset │ │ │ │ + * {Number} If your cache has more zoom levels than you want to provide │ │ │ │ + * access to with this layer, supply a zoomOffset. This zoom offset │ │ │ │ + * is added to the current map zoom level to determine the level │ │ │ │ + * for a requested tile. For example, if you supply a zoomOffset │ │ │ │ + * of 3, when the map is at the zoom 0, tiles will be requested from │ │ │ │ + * level 3 of your cache. Default is 0 (assumes cache level and map │ │ │ │ + * zoom are equivalent). Using <zoomOffset> is an alternative to │ │ │ │ + * setting <serverResolutions> if you only want to expose a subset │ │ │ │ + * of the server resolutions. │ │ │ │ */ │ │ │ │ - zoomLevels: null, │ │ │ │ + zoomOffset: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.WorldWind │ │ │ │ - * │ │ │ │ + * APIProperty: serverResolutions │ │ │ │ + * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ + * property if the map resolutions differ from the server. This │ │ │ │ + * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ + * resolutions that the server supports and that you don't want to │ │ │ │ + * provide with this layer; you can also look at <zoomOffset>, which is │ │ │ │ + * an alternative to <serverResolutions> for that specific purpose. │ │ │ │ + * (b) The map can work with resolutions that aren't supported by │ │ │ │ + * the server, i.e. that aren't in <serverResolutions>. When the │ │ │ │ + * map is displayed in such a resolution data for the closest │ │ │ │ + * server-supported resolution is loaded and the layer div is │ │ │ │ + * stretched as necessary. │ │ │ │ + */ │ │ │ │ + serverResolutions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.XYZ │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} Name of Layer │ │ │ │ - * url - {String} Base URL │ │ │ │ - * lzd - {Float} Level zero tile size degrees │ │ │ │ - * zoomLevels - {Integer} number of zoom levels │ │ │ │ - * params - {Object} additional parameters │ │ │ │ - * options - {Object} additional options │ │ │ │ + * name - {String} │ │ │ │ + * url - {String} │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ - initialize: function(name, url, lzd, zoomLevels, params, options) { │ │ │ │ - this.lzd = lzd; │ │ │ │ - this.zoomLevels = zoomLevels; │ │ │ │ - var newArguments = []; │ │ │ │ - newArguments.push(name, url, params, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ - this.params = OpenLayers.Util.applyDefaults( │ │ │ │ - this.params, this.DEFAULT_PARAMS │ │ │ │ - ); │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + if (options && options.sphericalMercator || this.sphericalMercator) { │ │ │ │ + options = OpenLayers.Util.extend({ │ │ │ │ + projection: "EPSG:900913", │ │ │ │ + numZoomLevels: 19 │ │ │ │ + }, options); │ │ │ │ + } │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, [ │ │ │ │ + name || this.name, url || this.url, {}, │ │ │ │ + options │ │ │ │ + ]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getZoom │ │ │ │ - * Convert map zoom to WW zoom. │ │ │ │ + * APIMethod: clone │ │ │ │ + * Create a clone of this layer │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} Is this ever used? │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.XYZ>} An exact clone of this OpenLayers.Layer.XYZ │ │ │ │ */ │ │ │ │ - getZoom: function() { │ │ │ │ - var zoom = this.map.getZoom(); │ │ │ │ - var extent = this.map.getMaxExtent(); │ │ │ │ - zoom = zoom - Math.log(this.maxResolution / (this.lzd / 512)) / Math.log(2); │ │ │ │ - return zoom; │ │ │ │ + clone: function(obj) { │ │ │ │ + │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.XYZ(this.name, │ │ │ │ + this.url, │ │ │ │ + this.getOptions()); │ │ │ │ + } │ │ │ │ + │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: getURL │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters │ │ │ │ */ │ │ │ │ getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var zoom = this.getZoom(); │ │ │ │ - var extent = this.map.getMaxExtent(); │ │ │ │ - var deg = this.lzd / Math.pow(2, this.getZoom()); │ │ │ │ - var x = Math.floor((bounds.left - extent.left) / deg); │ │ │ │ - var y = Math.floor((bounds.bottom - extent.bottom) / deg); │ │ │ │ - if (this.map.getResolution() <= (this.lzd / 512) && │ │ │ │ - this.getZoom() <= this.zoomLevels) { │ │ │ │ - return this.getFullRequestString({ │ │ │ │ - L: zoom, │ │ │ │ - X: x, │ │ │ │ - Y: y │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - return OpenLayers.Util.getImageLocation("blank.gif"); │ │ │ │ + var xyz = this.getXYZ(bounds); │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + var s = '' + xyz.x + xyz.y + xyz.z; │ │ │ │ + url = this.selectUrl(s, url); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return OpenLayers.String.format(url, xyz); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getXYZ │ │ │ │ + * Calculates x, y and z for the given bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} - an object with x, y and z properties. │ │ │ │ + */ │ │ │ │ + getXYZ: function(bounds) { │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.maxExtent.left) / │ │ │ │ + (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((this.maxExtent.top - bounds.top) / │ │ │ │ + (res * this.tileSize.h)); │ │ │ │ + var z = this.getServerZoom(); │ │ │ │ + │ │ │ │ + if (this.wrapDateLine) { │ │ │ │ + var limit = Math.pow(2, z); │ │ │ │ + x = ((x % limit) + limit) % limit; │ │ │ │ } │ │ │ │ │ │ │ │ + return { │ │ │ │ + 'x': x, │ │ │ │ + 'y': y, │ │ │ │ + 'z': z │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.WorldWind" │ │ │ │ + /* APIMethod: setMap │ │ │ │ + * When the layer is added to a map, then we can fetch our origin │ │ │ │ + * (if we don't have one.) │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + if (!this.tileOrigin) { │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(this.maxExtent.left, │ │ │ │ + this.maxExtent.bottom); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/TileCache.js │ │ │ │ + OpenLayers/Tile/UTFGrid.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ + * @requires OpenLayers/Tile.js │ │ │ │ + * @requires OpenLayers/Format/JSON.js │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.TileCache │ │ │ │ - * A read only TileCache layer. Used to requests tiles cached by TileCache in │ │ │ │ - * a web accessible cache. This means that you have to pre-populate your │ │ │ │ - * cache before this layer can be used. It is meant only to read tiles │ │ │ │ - * created by TileCache, and not to make calls to TileCache for tile │ │ │ │ - * creation. Create a new instance with the │ │ │ │ - * <OpenLayers.Layer.TileCache> constructor. │ │ │ │ + * Class: OpenLayers.Tile.UTFGrid │ │ │ │ + * Instances of OpenLayers.Tile.UTFGrid are used to manage │ │ │ │ + * UTFGrids. This is an unusual tile type in that it doesn't have a │ │ │ │ + * rendered image; only a 'hit grid' that can be used to │ │ │ │ + * look up feature attributes. │ │ │ │ + * │ │ │ │ + * See the <OpenLayers.Tile.UTFGrid> constructor for details on constructing a │ │ │ │ + * new instance. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ + * - <OpenLayers.Tile> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.TileCache = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ +OpenLayers.Tile.UTFGrid = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} Treat this layer as a base layer. Default is true. │ │ │ │ + * Property: url │ │ │ │ + * {String} │ │ │ │ + * The URL of the UTFGrid file being requested. Provided by the <getURL> │ │ │ │ + * method. │ │ │ │ */ │ │ │ │ - isBaseLayer: true, │ │ │ │ + url: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: utfgridResolution │ │ │ │ + * {Number} │ │ │ │ + * Ratio of the pixel width to the width of a UTFGrid data point. If an │ │ │ │ + * entry in the grid represents a 4x4 block of pixels, the │ │ │ │ + * utfgridResolution would be 4. Default is 2. │ │ │ │ + */ │ │ │ │ + utfgridResolution: 2, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: format │ │ │ │ - * {String} Mime type of the images returned. Default is image/png. │ │ │ │ + * Property: json │ │ │ │ + * {Object} │ │ │ │ + * Stores the parsed JSON tile data structure. │ │ │ │ */ │ │ │ │ - format: 'image/png', │ │ │ │ + json: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: serverResolutions │ │ │ │ - * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ - * property if the map resolutions differ from the server. This │ │ │ │ - * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ - * resolutions that the server supports and that you don't want to │ │ │ │ - * provide with this layer. (b) The map can work with resolutions │ │ │ │ - * that aren't supported by the server, i.e. that aren't in │ │ │ │ - * <serverResolutions>. When the map is displayed in such a resolution │ │ │ │ - * data for the closest server-supported resolution is loaded and the │ │ │ │ - * layer div is stretched as necessary. │ │ │ │ + /** │ │ │ │ + * Property: format │ │ │ │ + * {OpenLayers.Format.JSON} │ │ │ │ + * Parser instance used to parse JSON for cross browser support. The native │ │ │ │ + * JSON.parse method will be used where available (all except IE<8). │ │ │ │ */ │ │ │ │ - serverResolutions: null, │ │ │ │ + format: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.TileCache │ │ │ │ - * Create a new read only TileCache layer. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Tile.UTFGrid │ │ │ │ + * Constructor for a new <OpenLayers.Tile.UTFGrid> instance. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} Name of the layer displayed in the interface │ │ │ │ - * url - {String} Location of the web accessible cache (not the location of │ │ │ │ - * your tilecache script!) │ │ │ │ - * layername - {String} Layer name as defined in the TileCache │ │ │ │ - * configuration │ │ │ │ - * options - {Object} Optional object with properties to be set on the │ │ │ │ - * layer. Note that you should speficy your resolutions to match │ │ │ │ - * your TileCache configuration. This can be done by setting │ │ │ │ - * the resolutions array directly (here or on the map), by setting │ │ │ │ - * maxResolution and numZoomLevels, or by using scale based properties. │ │ │ │ + * layer - {<OpenLayers.Layer>} layer that the tile will go in. │ │ │ │ + * position - {<OpenLayers.Pixel>} │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * url - {<String>} Deprecated. Remove me in 3.0. │ │ │ │ + * size - {<OpenLayers.Size>} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - initialize: function(name, url, layername, options) { │ │ │ │ - this.layername = layername; │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, │ │ │ │ - [name, url, {}, options]); │ │ │ │ - this.extension = this.format.split('/')[1].toLowerCase(); │ │ │ │ - this.extension = (this.extension == 'jpg') ? 'jpeg' : this.extension; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.clear(); │ │ │ │ + OpenLayers.Tile.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * obj - {Object} │ │ │ │ + * Method: draw │ │ │ │ + * Check that a tile should be drawn, and draw it. │ │ │ │ + * In the case of UTFGrids, "drawing" it means fetching and │ │ │ │ + * parsing the json. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Layer.TileCache>} An exact clone of this │ │ │ │ - * <OpenLayers.Layer.TileCache> │ │ │ │ + * {Boolean} Was a tile drawn? │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ + draw: function() { │ │ │ │ + var drawn = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ + if (drawn) { │ │ │ │ + if (this.isLoading) { │ │ │ │ + this.abortLoading(); │ │ │ │ + //if we're already loading, send 'reload' instead of 'loadstart'. │ │ │ │ + this.events.triggerEvent("reload"); │ │ │ │ + } else { │ │ │ │ + this.isLoading = true; │ │ │ │ + this.events.triggerEvent("loadstart"); │ │ │ │ + } │ │ │ │ + this.url = this.layer.getURL(this.bounds); │ │ │ │ │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.TileCache(this.name, │ │ │ │ - this.url, │ │ │ │ - this.layername, │ │ │ │ - this.getOptions()); │ │ │ │ + if (this.layer.useJSONP) { │ │ │ │ + // Use JSONP method to avoid xbrowser policy │ │ │ │ + var ols = new OpenLayers.Protocol.Script({ │ │ │ │ + url: this.url, │ │ │ │ + callback: function(response) { │ │ │ │ + this.isLoading = false; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + this.json = response.data; │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + ols.read(); │ │ │ │ + this.request = ols; │ │ │ │ + } else { │ │ │ │ + // Use standard XHR │ │ │ │ + this.request = OpenLayers.Request.GET({ │ │ │ │ + url: this.url, │ │ │ │ + callback: function(response) { │ │ │ │ + this.isLoading = false; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + if (response.status === 200) { │ │ │ │ + this.parseData(response.responseText); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unload(); │ │ │ │ } │ │ │ │ + return drawn; │ │ │ │ + }, │ │ │ │ │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + /** │ │ │ │ + * Method: abortLoading │ │ │ │ + * Cancel a pending request. │ │ │ │ + */ │ │ │ │ + abortLoading: function() { │ │ │ │ + if (this.request) { │ │ │ │ + this.request.abort(); │ │ │ │ + delete this.request; │ │ │ │ + } │ │ │ │ + this.isLoading = false; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ + /** │ │ │ │ + * Method: getFeatureInfo │ │ │ │ + * Get feature information associated with a pixel offset. If the pixel │ │ │ │ + * offset corresponds to a feature, the returned object will have id │ │ │ │ + * and data properties. Otherwise, null will be returned. │ │ │ │ + * │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * i - {Number} X-axis pixel offset (from top left of tile) │ │ │ │ + * j - {Number} Y-axis pixel offset (from top left of tile) │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Object with feature id and data properties corresponding to the │ │ │ │ + * given pixel offset. │ │ │ │ + */ │ │ │ │ + getFeatureInfo: function(i, j) { │ │ │ │ + var info = null; │ │ │ │ + if (this.json) { │ │ │ │ + var id = this.getFeatureId(i, j); │ │ │ │ + if (id !== null) { │ │ │ │ + info = { │ │ │ │ + id: id, │ │ │ │ + data: this.json.data[id] │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return info; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return obj; │ │ │ │ + /** │ │ │ │ + * Method: getFeatureId │ │ │ │ + * Get the identifier for the feature associated with a pixel offset. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * i - {Number} X-axis pixel offset (from top left of tile) │ │ │ │ + * j - {Number} Y-axis pixel offset (from top left of tile) │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} The feature identifier corresponding to the given pixel offset. │ │ │ │ + * Returns null if pixel doesn't correspond to a feature. │ │ │ │ + */ │ │ │ │ + getFeatureId: function(i, j) { │ │ │ │ + var id = null; │ │ │ │ + if (this.json) { │ │ │ │ + var resolution = this.utfgridResolution; │ │ │ │ + var row = Math.floor(j / resolution); │ │ │ │ + var col = Math.floor(i / resolution); │ │ │ │ + var charCode = this.json.grid[row].charCodeAt(col); │ │ │ │ + var index = this.indexFromCharCode(charCode); │ │ │ │ + var keys = this.json.keys; │ │ │ │ + if (!isNaN(index) && (index in keys)) { │ │ │ │ + id = keys[index]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return id; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getURL │ │ │ │ + * Method: indexFromCharCode │ │ │ │ + * Given a character code for one of the UTFGrid "grid" characters, │ │ │ │ + * resolve the integer index for the feature id in the UTFGrid "keys" │ │ │ │ + * array. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ + * charCode - {Integer} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as parameters. │ │ │ │ + * {Integer} Index for the feature id from the keys array. │ │ │ │ */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var bbox = this.maxExtent; │ │ │ │ - var size = this.tileSize; │ │ │ │ - var tileX = Math.round((bounds.left - bbox.left) / (res * size.w)); │ │ │ │ - var tileY = Math.round((bounds.bottom - bbox.bottom) / (res * size.h)); │ │ │ │ - var tileZ = this.serverResolutions != null ? │ │ │ │ - OpenLayers.Util.indexOf(this.serverResolutions, res) : │ │ │ │ - this.map.getZoom(); │ │ │ │ + indexFromCharCode: function(charCode) { │ │ │ │ + if (charCode >= 93) { │ │ │ │ + charCode--; │ │ │ │ + } │ │ │ │ + if (charCode >= 35) { │ │ │ │ + charCode--; │ │ │ │ + } │ │ │ │ + return charCode - 32; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var components = [ │ │ │ │ - this.layername, │ │ │ │ - OpenLayers.Number.zeroPad(tileZ, 2), │ │ │ │ - OpenLayers.Number.zeroPad(parseInt(tileX / 1000000), 3), │ │ │ │ - OpenLayers.Number.zeroPad((parseInt(tileX / 1000) % 1000), 3), │ │ │ │ - OpenLayers.Number.zeroPad((parseInt(tileX) % 1000), 3), │ │ │ │ - OpenLayers.Number.zeroPad(parseInt(tileY / 1000000), 3), │ │ │ │ - OpenLayers.Number.zeroPad((parseInt(tileY / 1000) % 1000), 3), │ │ │ │ - OpenLayers.Number.zeroPad((parseInt(tileY) % 1000), 3) + '.' + this.extension │ │ │ │ - ]; │ │ │ │ - var path = components.join('/'); │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(path, url); │ │ │ │ + /** │ │ │ │ + * Method: parseData │ │ │ │ + * Parse the JSON from a request │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * str - {String} UTFGrid as a JSON string. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} parsed javascript data │ │ │ │ + */ │ │ │ │ + parseData: function(str) { │ │ │ │ + if (!this.format) { │ │ │ │ + this.format = new OpenLayers.Format.JSON(); │ │ │ │ } │ │ │ │ - url = (url.charAt(url.length - 1) == '/') ? url : url + '/'; │ │ │ │ - return url + path; │ │ │ │ + this.json = this.format.read(str); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.TileCache" │ │ │ │ + /** │ │ │ │ + * Method: clear │ │ │ │ + * Delete data stored with this tile. │ │ │ │ + */ │ │ │ │ + clear: function() { │ │ │ │ + this.json = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Tile.UTFGrid" │ │ │ │ + │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/Text.js │ │ │ │ + OpenLayers/Layer/UTFGrid.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Layer/XYZ.js │ │ │ │ + * @requires OpenLayers/Tile/UTFGrid.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.Text │ │ │ │ - * Read Text format. Create a new instance with the <OpenLayers.Format.Text> │ │ │ │ - * constructor. This reads text which is formatted like CSV text, using │ │ │ │ - * tabs as the seperator by default. It provides parsing of data originally │ │ │ │ - * used in the MapViewerService, described on the wiki. This Format is used │ │ │ │ - * by the <OpenLayers.Layer.Text> class. │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.UTFGrid │ │ │ │ + * This Layer reads from UTFGrid tiled data sources. Since UTFGrids are │ │ │ │ + * essentially JSON-based ASCII art with attached attributes, they are not │ │ │ │ + * visibly rendered. In order to use them in the map, you must add a │ │ │ │ + * <OpenLayers.Control.UTFGrid> control as well. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * │ │ │ │ + * (start code) │ │ │ │ + * var world_utfgrid = new OpenLayers.Layer.UTFGrid({ │ │ │ │ + * url: "/tiles/world_utfgrid/${z}/${x}/${y}.json", │ │ │ │ + * utfgridResolution: 4, │ │ │ │ + * displayInLayerSwitcher: false │ │ │ │ + * ); │ │ │ │ + * map.addLayer(world_utfgrid); │ │ │ │ + * │ │ │ │ + * var control = new OpenLayers.Control.UTFGrid({ │ │ │ │ + * layers: [world_utfgrid], │ │ │ │ + * handlerMode: 'move', │ │ │ │ + * callback: function(dataLookup) { │ │ │ │ + * // do something with returned data │ │ │ │ + * } │ │ │ │ + * }) │ │ │ │ + * (end code) │ │ │ │ * │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format> │ │ │ │ + * - <OpenLayers.Layer.XYZ> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.Text = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ +OpenLayers.Layer.UTFGrid = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultStyle │ │ │ │ - * defaultStyle allows one to control the default styling of the features. │ │ │ │ - * It should be a symbolizer hash. By default, this is set to match the │ │ │ │ - * Layer.Text behavior, which is to use the default OpenLayers Icon. │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * Default is false, as UTFGrids are designed to be a transparent overlay layer. │ │ │ │ */ │ │ │ │ - defaultStyle: null, │ │ │ │ + isBaseLayer: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractStyles │ │ │ │ - * set to true to extract styles from the TSV files, using information │ │ │ │ - * from the image or icon, iconSize and iconOffset fields. This will result │ │ │ │ - * in features with a symbolizer (style) property set, using the │ │ │ │ - * default symbolizer specified in <defaultStyle>. Set to false if you │ │ │ │ - * wish to use a styleMap or OpenLayers.Style options to style your │ │ │ │ - * layer instead. │ │ │ │ + * APIProperty: projection │ │ │ │ + * {<OpenLayers.Projection>} │ │ │ │ + * Source projection for the UTFGrids. Default is "EPSG:900913". │ │ │ │ */ │ │ │ │ - extractStyles: true, │ │ │ │ + projection: new OpenLayers.Projection("EPSG:900913"), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.Text │ │ │ │ - * Create a new parser for TSV Text. │ │ │ │ + * Property: useJSONP │ │ │ │ + * {Boolean} │ │ │ │ + * Should we use a JSONP script approach instead of a standard AJAX call? │ │ │ │ + * │ │ │ │ + * Set to true for using utfgrids from another server. │ │ │ │ + * Avoids same-domain policy restrictions. │ │ │ │ + * Note that this only works if the server accepts │ │ │ │ + * the callback GET parameter and dynamically │ │ │ │ + * wraps the returned json in a function call. │ │ │ │ + * │ │ │ │ + * Default is false │ │ │ │ + */ │ │ │ │ + useJSONP: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} │ │ │ │ + * URL tempate for UTFGrid tiles. Include x, y, and z parameters. │ │ │ │ + * E.g. "/tiles/${z}/${x}/${y}.json" │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: utfgridResolution │ │ │ │ + * {Number} │ │ │ │ + * Ratio of the pixel width to the width of a UTFGrid data point. If an │ │ │ │ + * entry in the grid represents a 4x4 block of pixels, the │ │ │ │ + * utfgridResolution would be 4. Default is 2 (specified in │ │ │ │ + * <OpenLayers.Tile.UTFGrid>). │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tileClass │ │ │ │ + * {<OpenLayers.Tile>} The tile class to use for this layer. │ │ │ │ + * Defaults is <OpenLayers.Tile.UTFGrid>. │ │ │ │ + */ │ │ │ │ + tileClass: OpenLayers.Tile.UTFGrid, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.UTFGrid │ │ │ │ + * Create a new UTFGrid layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * config - {Object} Configuration properties for the layer. │ │ │ │ + * │ │ │ │ + * Required configuration properties: │ │ │ │ + * url - {String} The url template for UTFGrid tiles. See the <url> property. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply( │ │ │ │ + this, [options.name, options.url, {}, options] │ │ │ │ + ); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + utfgridResolution: this.utfgridResolution │ │ │ │ + }, this.tileOptions); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (options.extractStyles !== false) { │ │ │ │ - options.defaultStyle = { │ │ │ │ - 'externalGraphic': OpenLayers.Util.getImageLocation("marker.png"), │ │ │ │ - 'graphicWidth': 21, │ │ │ │ - 'graphicHeight': 25, │ │ │ │ - 'graphicXOffset': -10.5, │ │ │ │ - 'graphicYOffset': -12.5 │ │ │ │ - }; │ │ │ │ + /** │ │ │ │ + * Method: createBackBuffer │ │ │ │ + * The UTFGrid cannot create a back buffer, so this method is overriden. │ │ │ │ + */ │ │ │ │ + createBackBuffer: function() {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Create a clone of this layer │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} Only used by a subclass of this layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.UTFGrid>} An exact clone of this OpenLayers.Layer.UTFGrid │ │ │ │ + */ │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.UTFGrid(this.getOptions()); │ │ │ │ } │ │ │ │ │ │ │ │ - OpenLayers.Format.prototype.initialize.apply(this, [options]); │ │ │ │ + // get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Return a list of features from a Tab Seperated Values text string. │ │ │ │ - * │ │ │ │ + * APIProperty: getFeatureInfo │ │ │ │ + * Get details about a feature associated with a map location. The object │ │ │ │ + * returned will have id and data properties. If the given location │ │ │ │ + * doesn't correspond to a feature, null will be returned. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * text - {String} │ │ │ │ + * location - {<OpenLayers.LonLat>} map location │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + * {Object} Object representing the feature id and UTFGrid data │ │ │ │ + * corresponding to the given map location. Returns null if the given │ │ │ │ + * location doesn't hit a feature. │ │ │ │ */ │ │ │ │ - read: function(text) { │ │ │ │ - var lines = text.split('\n'); │ │ │ │ - var columns; │ │ │ │ - var features = []; │ │ │ │ - // length - 1 to allow for trailing new line │ │ │ │ - for (var lcv = 0; lcv < (lines.length - 1); lcv++) { │ │ │ │ - var currLine = lines[lcv].replace(/^\s*/, '').replace(/\s*$/, ''); │ │ │ │ - │ │ │ │ - if (currLine.charAt(0) != '#') { │ │ │ │ - /* not a comment */ │ │ │ │ + getFeatureInfo: function(location) { │ │ │ │ + var info = null; │ │ │ │ + var tileInfo = this.getTileData(location); │ │ │ │ + if (tileInfo && tileInfo.tile) { │ │ │ │ + info = tileInfo.tile.getFeatureInfo(tileInfo.i, tileInfo.j); │ │ │ │ + } │ │ │ │ + return info; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!columns) { │ │ │ │ - //First line is columns │ │ │ │ - columns = currLine.split('\t'); │ │ │ │ - } else { │ │ │ │ - var vals = currLine.split('\t'); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ - var attributes = {}; │ │ │ │ - var style = this.defaultStyle ? │ │ │ │ - OpenLayers.Util.applyDefaults({}, this.defaultStyle) : │ │ │ │ - null; │ │ │ │ - var icon, iconSize, iconOffset, overflow; │ │ │ │ - var set = false; │ │ │ │ - for (var valIndex = 0; valIndex < vals.length; valIndex++) { │ │ │ │ - if (vals[valIndex]) { │ │ │ │ - if (columns[valIndex] == 'point') { │ │ │ │ - var coords = vals[valIndex].split(','); │ │ │ │ - geometry.y = parseFloat(coords[0]); │ │ │ │ - geometry.x = parseFloat(coords[1]); │ │ │ │ - set = true; │ │ │ │ - } else if (columns[valIndex] == 'lat') { │ │ │ │ - geometry.y = parseFloat(vals[valIndex]); │ │ │ │ - set = true; │ │ │ │ - } else if (columns[valIndex] == 'lon') { │ │ │ │ - geometry.x = parseFloat(vals[valIndex]); │ │ │ │ - set = true; │ │ │ │ - } else if (columns[valIndex] == 'title') │ │ │ │ - attributes['title'] = vals[valIndex]; │ │ │ │ - else if (columns[valIndex] == 'image' || │ │ │ │ - columns[valIndex] == 'icon' && style) { │ │ │ │ - style['externalGraphic'] = vals[valIndex]; │ │ │ │ - } else if (columns[valIndex] == 'iconSize' && style) { │ │ │ │ - var size = vals[valIndex].split(','); │ │ │ │ - style['graphicWidth'] = parseFloat(size[0]); │ │ │ │ - style['graphicHeight'] = parseFloat(size[1]); │ │ │ │ - } else if (columns[valIndex] == 'iconOffset' && style) { │ │ │ │ - var offset = vals[valIndex].split(','); │ │ │ │ - style['graphicXOffset'] = parseFloat(offset[0]); │ │ │ │ - style['graphicYOffset'] = parseFloat(offset[1]); │ │ │ │ - } else if (columns[valIndex] == 'description') { │ │ │ │ - attributes['description'] = vals[valIndex]; │ │ │ │ - } else if (columns[valIndex] == 'overflow') { │ │ │ │ - attributes['overflow'] = vals[valIndex]; │ │ │ │ - } else { │ │ │ │ - // For StyleMap filtering, allow additional │ │ │ │ - // columns to be stored as attributes. │ │ │ │ - attributes[columns[valIndex]] = vals[valIndex]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (set) { │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, attributes, style); │ │ │ │ - features.push(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIMethod: getFeatureId │ │ │ │ + * Get the identifier for the feature associated with a map location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * location - {<OpenLayers.LonLat>} map location │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The feature identifier corresponding to the given map location. │ │ │ │ + * Returns null if the location doesn't hit a feature. │ │ │ │ + */ │ │ │ │ + getFeatureId: function(location) { │ │ │ │ + var id = null; │ │ │ │ + var info = this.getTileData(location); │ │ │ │ + if (info.tile) { │ │ │ │ + id = info.tile.getFeatureId(info.i, info.j); │ │ │ │ } │ │ │ │ - return features; │ │ │ │ + return id; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Text" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.UTFGrid" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Text.js │ │ │ │ + OpenLayers/Layer/KaMap.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Markers.js │ │ │ │ - * @requires OpenLayers/Format/Text.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.Text │ │ │ │ - * This layer creates markers given data in a text file. The <location> │ │ │ │ - * property of the layer (specified as a property of the options argument │ │ │ │ - * in the <OpenLayers.Layer.Text> constructor) points to a tab delimited │ │ │ │ - * file with data used to create markers. │ │ │ │ - * │ │ │ │ - * The first row of the data file should be a header line with the column names │ │ │ │ - * of the data. Each column should be delimited by a tab space. The │ │ │ │ - * possible columns are: │ │ │ │ - * - *point* lat,lon of the point where a marker is to be placed │ │ │ │ - * - *lat* Latitude of the point where a marker is to be placed │ │ │ │ - * - *lon* Longitude of the point where a marker is to be placed │ │ │ │ - * - *icon* or *image* URL of marker icon to use. │ │ │ │ - * - *iconSize* Size of Icon to use. │ │ │ │ - * - *iconOffset* Where the top-left corner of the icon is to be placed │ │ │ │ - * relative to the latitude and longitude of the point. │ │ │ │ - * - *title* The text of the 'title' is placed inside an 'h2' marker │ │ │ │ - * inside a popup, which opens when the marker is clicked. │ │ │ │ - * - *description* The text of the 'description' is placed below the h2 │ │ │ │ - * in the popup. this can be plain text or HTML. │ │ │ │ - * │ │ │ │ - * Example text file: │ │ │ │ - * (code) │ │ │ │ - * lat lon title description iconSize iconOffset icon │ │ │ │ - * 10 20 title description 21,25 -10,-25 http://www.openlayers.org/dev/img/marker.png │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Layer.KaMap │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Markers> │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Text = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: location │ │ │ │ - * {String} URL of text file. Must be specified in the "options" argument │ │ │ │ - * of the constructor. Can not be changed once passed in. │ │ │ │ - */ │ │ │ │ - location: null, │ │ │ │ +OpenLayers.Layer.KaMap = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: features │ │ │ │ - * {Array(<OpenLayers.Feature>)} │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} KaMap Layer is always a base layer │ │ │ │ */ │ │ │ │ - features: null, │ │ │ │ + isBaseLayer: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: formatOptions │ │ │ │ - * {Object} Hash of options which should be passed to the format when it is │ │ │ │ - * created. Must be passed in the constructor. │ │ │ │ - */ │ │ │ │ - formatOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: selectedFeature │ │ │ │ - * {<OpenLayers.Feature>} │ │ │ │ + * Constant: DEFAULT_PARAMS │ │ │ │ + * {Object} parameters set by default. The default parameters set │ │ │ │ + * the format via the 'i' parameter to 'jpeg'. │ │ │ │ */ │ │ │ │ - selectedFeature: null, │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + i: 'jpeg', │ │ │ │ + map: '' │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Text │ │ │ │ - * Create a text layer. │ │ │ │ + * Constructor: OpenLayers.Layer.KaMap │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * options - {Object} Object with properties to be set on the layer. │ │ │ │ - * Must include <location> property. │ │ │ │ + * name - {String} │ │ │ │ + * url - {String} │ │ │ │ + * params - {Object} Parameters to be sent to the HTTP server in the │ │ │ │ + * query string for the tile. The format can be set via the 'i' │ │ │ │ + * parameter (defaults to jpg) , and the map should be set via │ │ │ │ + * the 'map' parameter. It has been reported that ka-Map may behave │ │ │ │ + * inconsistently if your format parameter does not match the format │ │ │ │ + * parameter configured in your config.php. (See ticket #327 for more │ │ │ │ + * information.) │ │ │ │ + * options - {Object} Additional options for the layer. Any of the │ │ │ │ + * APIProperties listed on this layer, and any layer types it │ │ │ │ + * extends, can be overridden through the options parameter. │ │ │ │ */ │ │ │ │ - initialize: function(name, options) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.initialize.apply(this, arguments); │ │ │ │ - this.features = []; │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ + this.params = OpenLayers.Util.applyDefaults( │ │ │ │ + this.params, this.DEFAULT_PARAMS │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - // Warning: Layer.Markers.destroy() must be called prior to calling │ │ │ │ - // clearFeatures() here, otherwise we leak memory. Indeed, if │ │ │ │ - // Layer.Markers.destroy() is called after clearFeatures(), it won't be │ │ │ │ - // able to remove the marker image elements from the layer's div since │ │ │ │ - // the markers will have been destroyed by clearFeatures(). │ │ │ │ - OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ - this.clearFeatures(); │ │ │ │ - this.features = null; │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + var scale = Math.round((this.map.getScale() * 10000)) / 10000; │ │ │ │ + var pX = Math.round(bounds.left / mapRes); │ │ │ │ + var pY = -Math.round(bounds.top / mapRes); │ │ │ │ + return this.getFullRequestString({ │ │ │ │ + t: pY, │ │ │ │ + l: pX, │ │ │ │ + s: scale │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: loadText │ │ │ │ - * Start the load of the Text data. Don't do this when we first add the layer, │ │ │ │ - * since we may not be visible at any point, and it would therefore be a waste. │ │ │ │ + /** │ │ │ │ + * Method: calculateGridLayout │ │ │ │ + * ka-Map uses the center point of the map as an origin for │ │ │ │ + * its tiles. Override calculateGridLayout to center tiles │ │ │ │ + * correctly for this case. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bound>} │ │ │ │ + * origin - {<OpenLayers.LonLat>} │ │ │ │ + * resolution - {Number} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Object containing properties tilelon, tilelat, startcol, │ │ │ │ + * startrow │ │ │ │ */ │ │ │ │ - loadText: function() { │ │ │ │ - if (!this.loaded) { │ │ │ │ - if (this.location != null) { │ │ │ │ + calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ + var tilelon = resolution * this.tileSize.w; │ │ │ │ + var tilelat = resolution * this.tileSize.h; │ │ │ │ │ │ │ │ - var onFail = function(e) { │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - }; │ │ │ │ + var offsetlon = bounds.left; │ │ │ │ + var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ │ │ │ │ - this.events.triggerEvent("loadstart"); │ │ │ │ - OpenLayers.Request.GET({ │ │ │ │ - url: this.location, │ │ │ │ - success: this.parseData, │ │ │ │ - failure: onFail, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.loaded = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var offsetlat = bounds.top; │ │ │ │ + var tilerow = Math.floor(offsetlat / tilelat) + this.buffer; │ │ │ │ + │ │ │ │ + return { │ │ │ │ + tilelon: tilelon, │ │ │ │ + tilelat: tilelat, │ │ │ │ + startcol: tilecol, │ │ │ │ + startrow: tilerow │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveTo │ │ │ │ - * If layer is visible and Text has not been loaded, load Text. │ │ │ │ - * │ │ │ │ + * Method: getTileBoundsForGridIndex │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {Object} │ │ │ │ - * zoomChanged - {Object} │ │ │ │ - * minor - {Object} │ │ │ │ + * row - {Number} The row of the grid │ │ │ │ + * col - {Number} The column of the grid │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} The bounds for the tile at (row, col) │ │ │ │ */ │ │ │ │ - moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ - if (this.visibility && !this.loaded) { │ │ │ │ - this.loadText(); │ │ │ │ - } │ │ │ │ + getTileBoundsForGridIndex: function(row, col) { │ │ │ │ + var origin = this.getTileOrigin(); │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + var tilelon = tileLayout.tilelon; │ │ │ │ + var tilelat = tileLayout.tilelat; │ │ │ │ + var minX = (tileLayout.startcol + col) * tilelon; │ │ │ │ + var minY = (tileLayout.startrow - row) * tilelat; │ │ │ │ + return new OpenLayers.Bounds( │ │ │ │ + minX, minY, │ │ │ │ + minX + tilelon, minY + tilelat │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseData │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * ajaxRequest - {<OpenLayers.Request.XMLHttpRequest>} │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Kamap>} An exact clone of this OpenLayers.Layer.KaMap │ │ │ │ */ │ │ │ │ - parseData: function(ajaxRequest) { │ │ │ │ - var text = ajaxRequest.responseText; │ │ │ │ + clone: function(obj) { │ │ │ │ │ │ │ │ - var options = {}; │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.KaMap(this.name, │ │ │ │ + this.url, │ │ │ │ + this.params, │ │ │ │ + this.getOptions()); │ │ │ │ + } │ │ │ │ │ │ │ │ - OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ │ │ │ │ - if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ - options.externalProjection = this.projection; │ │ │ │ - options.internalProjection = this.map.getProjectionObject(); │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + if (this.tileSize != null) { │ │ │ │ + obj.tileSize = this.tileSize.clone(); │ │ │ │ } │ │ │ │ │ │ │ │ - var parser = new OpenLayers.Format.Text(options); │ │ │ │ - var features = parser.read(text); │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - var data = {}; │ │ │ │ - var feature = features[i]; │ │ │ │ - var location; │ │ │ │ - var iconSize, iconOffset; │ │ │ │ + // we do not want to copy reference to grid, so we make a new array │ │ │ │ + obj.grid = []; │ │ │ │ │ │ │ │ - location = new OpenLayers.LonLat(feature.geometry.x, │ │ │ │ - feature.geometry.y); │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (feature.style.graphicWidth && │ │ │ │ - feature.style.graphicHeight) { │ │ │ │ - iconSize = new OpenLayers.Size( │ │ │ │ - feature.style.graphicWidth, │ │ │ │ - feature.style.graphicHeight); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIMethod: getTileBounds │ │ │ │ + * Returns The tile bounds for a layer given a pixel location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * viewPortPx - {<OpenLayers.Pixel>} The location in the viewport. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} Bounds of the tile at the given pixel location. │ │ │ │ + */ │ │ │ │ + getTileBounds: function(viewPortPx) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ + var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ + var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ + var tileLeft = tileMapWidth * Math.floor(mapPoint.lon / tileMapWidth); │ │ │ │ + var tileBottom = tileMapHeight * Math.floor(mapPoint.lat / tileMapHeight); │ │ │ │ + return new OpenLayers.Bounds(tileLeft, tileBottom, │ │ │ │ + tileLeft + tileMapWidth, │ │ │ │ + tileBottom + tileMapHeight); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // FIXME: At the moment, we only use this if we have an │ │ │ │ - // externalGraphic, because icon has no setOffset API Method. │ │ │ │ - /** │ │ │ │ - * FIXME FIRST!! │ │ │ │ - * The Text format does all sorts of parseFloating │ │ │ │ - * The result of a parseFloat for a bogus string is NaN. That │ │ │ │ - * means the three possible values here are undefined, NaN, or a │ │ │ │ - * number. The previous check was an identity check for null. This │ │ │ │ - * means it was failing for all undefined or NaN. A slightly better │ │ │ │ - * check is for undefined. An even better check is to see if the │ │ │ │ - * value is a number (see #1441). │ │ │ │ - */ │ │ │ │ - if (feature.style.graphicXOffset !== undefined && │ │ │ │ - feature.style.graphicYOffset !== undefined) { │ │ │ │ - iconOffset = new OpenLayers.Pixel( │ │ │ │ - feature.style.graphicXOffset, │ │ │ │ - feature.style.graphicYOffset); │ │ │ │ - } │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.KaMap" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/KaMapCache.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - if (feature.style.externalGraphic != null) { │ │ │ │ - data.icon = new OpenLayers.Icon(feature.style.externalGraphic, │ │ │ │ - iconSize, │ │ │ │ - iconOffset); │ │ │ │ - } else { │ │ │ │ - data.icon = OpenLayers.Marker.defaultIcon(); │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - //allows for the case where the image url is not │ │ │ │ - // specified but the size is. use a default icon │ │ │ │ - // but change the size │ │ │ │ - if (iconSize != null) { │ │ │ │ - data.icon.setSize(iconSize); │ │ │ │ - } │ │ │ │ - } │ │ │ │ │ │ │ │ - if ((feature.attributes.title != null) && │ │ │ │ - (feature.attributes.description != null)) { │ │ │ │ - data['popupContentHTML'] = │ │ │ │ - '<h2>' + feature.attributes.title + '</h2>' + │ │ │ │ - '<p>' + feature.attributes.description + '</p>'; │ │ │ │ - } │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ + * @requires OpenLayers/Layer/KaMap.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - data['overflow'] = feature.attributes.overflow || "auto"; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.KaMapCache │ │ │ │ + * │ │ │ │ + * This class is designed to talk directly to a web-accessible ka-Map │ │ │ │ + * cache generated by the precache2.php script. │ │ │ │ + * │ │ │ │ + * To create a a new KaMapCache layer, you must indicate also the "i" parameter │ │ │ │ + * (that will be used to calculate the file extension), and another special │ │ │ │ + * parameter, object names "metaTileSize", with "h" (height) and "w" (width) │ │ │ │ + * properties. │ │ │ │ + * │ │ │ │ + * // Create a new kaMapCache layer. │ │ │ │ + * var kamap_base = new OpenLayers.Layer.KaMapCache( │ │ │ │ + * "Satellite", │ │ │ │ + * "http://www.example.org/web/acessible/cache", │ │ │ │ + * {g: "satellite", map: "world", i: 'png24', metaTileSize: {w: 5, h: 5} } │ │ │ │ + * ); │ │ │ │ + * │ │ │ │ + * // Create an kaMapCache overlay layer (using "isBaseLayer: false"). │ │ │ │ + * // Forces the output to be a "gif", using the "i" parameter. │ │ │ │ + * var kamap_overlay = new OpenLayers.Layer.KaMapCache( │ │ │ │ + * "Streets", │ │ │ │ + * "http://www.example.org/web/acessible/cache", │ │ │ │ + * {g: "streets", map: "world", i: "gif", metaTileSize: {w: 5, h: 5} }, │ │ │ │ + * {isBaseLayer: false} │ │ │ │ + * ); │ │ │ │ + * │ │ │ │ + * The cache URLs must look like: │ │ │ │ + * var/cache/World/50000/Group_Name/def/t-440320/l20480 │ │ │ │ + * │ │ │ │ + * This means that the cache generated via tile.php will *not* work with │ │ │ │ + * this class, and should instead use the KaMap layer. │ │ │ │ + * │ │ │ │ + * More information is available in Ticket #1518. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.KaMap> │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.KaMapCache = OpenLayers.Class(OpenLayers.Layer.KaMap, { │ │ │ │ │ │ │ │ - var markerFeature = new OpenLayers.Feature(this, location, data); │ │ │ │ - this.features.push(markerFeature); │ │ │ │ - var marker = markerFeature.createMarker(); │ │ │ │ - if ((feature.attributes.title != null) && │ │ │ │ - (feature.attributes.description != null)) { │ │ │ │ - marker.events.register('click', markerFeature, this.markerClick); │ │ │ │ - } │ │ │ │ - this.addMarker(marker); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ + /** │ │ │ │ + * Constant: IMAGE_EXTENSIONS │ │ │ │ + * {Object} Simple hash map to convert format to extension. │ │ │ │ + */ │ │ │ │ + IMAGE_EXTENSIONS: { │ │ │ │ + 'jpeg': 'jpg', │ │ │ │ + 'gif': 'gif', │ │ │ │ + 'png': 'png', │ │ │ │ + 'png8': 'png', │ │ │ │ + 'png24': 'png', │ │ │ │ + 'dithered': 'png' │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: markerClick │ │ │ │ + * Constant: DEFAULT_FORMAT │ │ │ │ + * {Object} Simple hash map to convert format to extension. │ │ │ │ + */ │ │ │ │ + DEFAULT_FORMAT: 'jpeg', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.KaMapCache │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Context: │ │ │ │ - * - {<OpenLayers.Feature>} │ │ │ │ + * name - {String} │ │ │ │ + * url - {String} │ │ │ │ + * params - {Object} Parameters to be sent to the HTTP server in the │ │ │ │ + * query string for the tile. The format can be set via the 'i' │ │ │ │ + * parameter (defaults to jpg) , and the map should be set via │ │ │ │ + * the 'map' parameter. It has been reported that ka-Map may behave │ │ │ │ + * inconsistently if your format parameter does not match the format │ │ │ │ + * parameter configured in your config.php. (See ticket #327 for more │ │ │ │ + * information.) │ │ │ │ + * options - {Object} Additional options for the layer. Any of the │ │ │ │ + * APIProperties listed on this layer, and any layer types it │ │ │ │ + * extends, can be overridden through the options parameter. │ │ │ │ */ │ │ │ │ - markerClick: function(evt) { │ │ │ │ - var sameMarkerClicked = (this == this.layer.selectedFeature); │ │ │ │ - this.layer.selectedFeature = (!sameMarkerClicked) ? this : null; │ │ │ │ - for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ - this.layer.map.removePopup(this.layer.map.popups[i]); │ │ │ │ - } │ │ │ │ - if (!sameMarkerClicked) { │ │ │ │ - this.layer.map.addPopup(this.createPopup()); │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.KaMap.prototype.initialize.apply(this, arguments); │ │ │ │ + this.extension = this.IMAGE_EXTENSIONS[this.params.i.toLowerCase() || this.DEFAULT_FORMAT]; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearFeatures │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters │ │ │ │ */ │ │ │ │ - clearFeatures: function() { │ │ │ │ - if (this.features != null) { │ │ │ │ - while (this.features.length > 0) { │ │ │ │ - var feature = this.features[0]; │ │ │ │ - OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ - feature.destroy(); │ │ │ │ - } │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + var scale = Math.round((this.map.getScale() * 10000)) / 10000; │ │ │ │ + var pX = Math.round(bounds.left / mapRes); │ │ │ │ + var pY = -Math.round(bounds.top / mapRes); │ │ │ │ + │ │ │ │ + var metaX = Math.floor(pX / this.tileSize.w / this.params.metaTileSize.w) * this.tileSize.w * this.params.metaTileSize.w; │ │ │ │ + var metaY = Math.floor(pY / this.tileSize.h / this.params.metaTileSize.h) * this.tileSize.h * this.params.metaTileSize.h; │ │ │ │ + │ │ │ │ + var components = [ │ │ │ │ + "/", │ │ │ │ + this.params.map, │ │ │ │ + "/", │ │ │ │ + scale, │ │ │ │ + "/", │ │ │ │ + this.params.g.replace(/\s/g, '_'), │ │ │ │ + "/def/t", │ │ │ │ + metaY, │ │ │ │ + "/l", │ │ │ │ + metaX, │ │ │ │ + "/t", │ │ │ │ + pY, │ │ │ │ + "l", │ │ │ │ + pX, │ │ │ │ + ".", │ │ │ │ + this.extension │ │ │ │ + ]; │ │ │ │ + │ │ │ │ + var url = this.url; │ │ │ │ + │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(components.join(''), url); │ │ │ │ } │ │ │ │ + return url + components.join(""); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Text" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.KaMapCache" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Boxes.js │ │ │ │ + OpenLayers/Layer/Zoomify.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ +/* │ │ │ │ + * Development supported by a R&D grant DC08P02OUK006 - Old Maps Online │ │ │ │ + * (www.oldmapsonline.org) from Ministry of Culture of the Czech Republic. │ │ │ │ + */ │ │ │ │ + │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer.js │ │ │ │ - * @requires OpenLayers/Layer/Markers.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.Boxes │ │ │ │ - * Draw divs as 'boxes' on the layer. │ │ │ │ + * Class: OpenLayers.Layer.Zoomify │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Markers> │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Boxes = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ +OpenLayers.Layer.Zoomify = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Boxes │ │ │ │ + * Property: size │ │ │ │ + * {<OpenLayers.Size>} The Zoomify image size in pixels. │ │ │ │ + */ │ │ │ │ + size: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + isBaseLayer: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: standardTileSize │ │ │ │ + * {Integer} The size of a standard (non-border) square tile in pixels. │ │ │ │ + */ │ │ │ │ + standardTileSize: 256, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tileOriginCorner │ │ │ │ + * {String} This layer uses top-left as tile origin │ │ │ │ + **/ │ │ │ │ + tileOriginCorner: "tl", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: numberOfTiers │ │ │ │ + * {Integer} Depth of the Zoomify pyramid, number of tiers (zoom levels) │ │ │ │ + * - filled during Zoomify pyramid initialization. │ │ │ │ + */ │ │ │ │ + numberOfTiers: 0, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tileCountUpToTier │ │ │ │ + * {Array(Integer)} Number of tiles up to the given tier of pyramid. │ │ │ │ + * - filled during Zoomify pyramid initialization. │ │ │ │ + */ │ │ │ │ + tileCountUpToTier: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tierSizeInTiles │ │ │ │ + * {Array(<OpenLayers.Size>)} Size (in tiles) for each tier of pyramid. │ │ │ │ + * - filled during Zoomify pyramid initialization. │ │ │ │ + */ │ │ │ │ + tierSizeInTiles: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: tierImageSize │ │ │ │ + * {Array(<OpenLayers.Size>)} Image size in pixels for each pyramid tier. │ │ │ │ + * - filled during Zoomify pyramid initialization. │ │ │ │ + */ │ │ │ │ + tierImageSize: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.Zoomify │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} │ │ │ │ + * name - {String} A name for the layer. │ │ │ │ + * url - {String} - Relative or absolute path to the image or more │ │ │ │ + * precisly to the TileGroup[X] directories root. │ │ │ │ + * Flash plugin use the variable name "zoomifyImagePath" for this. │ │ │ │ + * size - {<OpenLayers.Size>} The size (in pixels) of the image. │ │ │ │ * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ + initialize: function(name, url, size, options) { │ │ │ │ + │ │ │ │ + // initilize the Zoomify pyramid for given size │ │ │ │ + this.initializeZoomify(size); │ │ │ │ + │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, [ │ │ │ │ + name, url, size, {}, │ │ │ │ + options │ │ │ │ + ]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: drawMarker │ │ │ │ - * Calculate the pixel location for the marker, create it, and │ │ │ │ - * add it to the layer's div │ │ │ │ + * Method: initializeZoomify │ │ │ │ + * It generates constants for all tiers of the Zoomify pyramid │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * size - {<OpenLayers.Size>} The size of the image in pixels │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * marker - {<OpenLayers.Marker.Box>} │ │ │ │ */ │ │ │ │ - drawMarker: function(marker) { │ │ │ │ - var topleft = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: marker.bounds.left, │ │ │ │ - lat: marker.bounds.top │ │ │ │ - }); │ │ │ │ - var botright = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: marker.bounds.right, │ │ │ │ - lat: marker.bounds.bottom │ │ │ │ - }); │ │ │ │ - if (botright == null || topleft == null) { │ │ │ │ - marker.display(false); │ │ │ │ - } else { │ │ │ │ - var markerDiv = marker.draw(topleft, { │ │ │ │ - w: Math.max(1, botright.x - topleft.x), │ │ │ │ - h: Math.max(1, botright.y - topleft.y) │ │ │ │ - }); │ │ │ │ - if (!marker.drawn) { │ │ │ │ - this.div.appendChild(markerDiv); │ │ │ │ - marker.drawn = true; │ │ │ │ - } │ │ │ │ + initializeZoomify: function(size) { │ │ │ │ + │ │ │ │ + var imageSize = size.clone(); │ │ │ │ + this.size = size.clone(); │ │ │ │ + var tiles = new OpenLayers.Size( │ │ │ │ + Math.ceil(imageSize.w / this.standardTileSize), │ │ │ │ + Math.ceil(imageSize.h / this.standardTileSize) │ │ │ │ + ); │ │ │ │ + │ │ │ │ + this.tierSizeInTiles = [tiles]; │ │ │ │ + this.tierImageSize = [imageSize]; │ │ │ │ + │ │ │ │ + while (imageSize.w > this.standardTileSize || │ │ │ │ + imageSize.h > this.standardTileSize) { │ │ │ │ + │ │ │ │ + imageSize = new OpenLayers.Size( │ │ │ │ + Math.floor(imageSize.w / 2), │ │ │ │ + Math.floor(imageSize.h / 2) │ │ │ │ + ); │ │ │ │ + tiles = new OpenLayers.Size( │ │ │ │ + Math.ceil(imageSize.w / this.standardTileSize), │ │ │ │ + Math.ceil(imageSize.h / this.standardTileSize) │ │ │ │ + ); │ │ │ │ + this.tierSizeInTiles.push(tiles); │ │ │ │ + this.tierImageSize.push(imageSize); │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.tierSizeInTiles.reverse(); │ │ │ │ + this.tierImageSize.reverse(); │ │ │ │ + │ │ │ │ + this.numberOfTiers = this.tierSizeInTiles.length; │ │ │ │ + var resolutions = [1]; │ │ │ │ + this.tileCountUpToTier = [0]; │ │ │ │ + for (var i = 1; i < this.numberOfTiers; i++) { │ │ │ │ + resolutions.unshift(Math.pow(2, i)); │ │ │ │ + this.tileCountUpToTier.push( │ │ │ │ + this.tierSizeInTiles[i - 1].w * this.tierSizeInTiles[i - 1].h + │ │ │ │ + this.tileCountUpToTier[i - 1] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (!this.serverResolutions) { │ │ │ │ + this.serverResolutions = resolutions; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * APIMethod:destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + // for now, nothing special to do here. │ │ │ │ + OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments); │ │ │ │ + │ │ │ │ + // Remove from memory the Zoomify pyramid - is that enough? │ │ │ │ + this.tileCountUpToTier.length = 0; │ │ │ │ + this.tierSizeInTiles.length = 0; │ │ │ │ + this.tierImageSize.length = 0; │ │ │ │ + │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: removeMarker │ │ │ │ - * │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * marker - {<OpenLayers.Marker.Box>} │ │ │ │ + * obj - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Zoomify>} An exact clone of this <OpenLayers.Layer.Zoomify> │ │ │ │ */ │ │ │ │ - removeMarker: function(marker) { │ │ │ │ - OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ - if ((marker.div != null) && │ │ │ │ - (marker.div.parentNode == this.div)) { │ │ │ │ - this.div.removeChild(marker.div); │ │ │ │ + clone: function(obj) { │ │ │ │ + │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Zoomify(this.name, │ │ │ │ + this.url, │ │ │ │ + this.size, │ │ │ │ + this.options); │ │ │ │ + } │ │ │ │ + │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters │ │ │ │ + */ │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getZoomForResolution(res); │ │ │ │ + │ │ │ │ + var tileIndex = x + y * this.tierSizeInTiles[z].w + this.tileCountUpToTier[z]; │ │ │ │ + var path = "TileGroup" + Math.floor((tileIndex) / 256) + │ │ │ │ + "/" + z + "-" + x + "-" + y + ".jpg"; │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(path, url); │ │ │ │ } │ │ │ │ + return url + path; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Boxes" │ │ │ │ + /** │ │ │ │ + * Method: getImageSize │ │ │ │ + * getImageSize returns size for a particular tile. If bounds are given as │ │ │ │ + * first argument, size is calculated (bottom-right tiles are non square). │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + getImageSize: function() { │ │ │ │ + if (arguments.length > 0) { │ │ │ │ + var bounds = this.adjustBounds(arguments[0]); │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getZoomForResolution(res); │ │ │ │ + var w = this.standardTileSize; │ │ │ │ + var h = this.standardTileSize; │ │ │ │ + if (x == this.tierSizeInTiles[z].w - 1) { │ │ │ │ + var w = this.tierImageSize[z].w % this.standardTileSize; │ │ │ │ + } │ │ │ │ + if (y == this.tierSizeInTiles[z].h - 1) { │ │ │ │ + var h = this.tierImageSize[z].h % this.standardTileSize; │ │ │ │ + } │ │ │ │ + return (new OpenLayers.Size(w, h)); │ │ │ │ + } else { │ │ │ │ + return this.tileSize; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setMap │ │ │ │ + * When the layer is added to a map, then we can fetch our origin │ │ │ │ + * (if we don't have one.) │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, │ │ │ │ + this.map.maxExtent.top); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Zoomify" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Layer/Vector.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -38611,1642 +39134,809 @@ │ │ │ │ } │ │ │ │ return maxExtent; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.Vector" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/PointTrack.js │ │ │ │ + OpenLayers/Layer/PointGrid.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Layer/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.PointTrack │ │ │ │ - * Vector layer to display ordered point features as a line, creating one │ │ │ │ - * LineString feature for each pair of two points. │ │ │ │ + * Class: OpenLayers.Layer.PointGrid │ │ │ │ + * A point grid layer dynamically generates a regularly spaced grid of point │ │ │ │ + * features. This is a specialty layer for cases where an application needs │ │ │ │ + * a regular grid of points. It can be used, for example, in an editing │ │ │ │ + * environment to snap to a grid. │ │ │ │ + * │ │ │ │ + * Create a new vector layer with the <OpenLayers.Layer.PointGrid> constructor. │ │ │ │ + * (code) │ │ │ │ + * // create a grid with points spaced at 10 map units │ │ │ │ + * var points = new OpenLayers.Layer.PointGrid({dx: 10, dy: 10}); │ │ │ │ + * │ │ │ │ + * // create a grid with different x/y spacing rotated 15 degrees clockwise. │ │ │ │ + * var points = new OpenLayers.Layer.PointGrid({dx: 5, dy: 10, rotation: 15}); │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Vector> │ │ │ │ + * - <OpenLayers.Layer.Vector> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.PointTrack = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ +OpenLayers.Layer.PointGrid = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: dataFrom │ │ │ │ - * {<OpenLayers.Layer.PointTrack.TARGET_NODE>} or │ │ │ │ - * {<OpenLayers.Layer.PointTrack.SOURCE_NODE>} optional. If the lines │ │ │ │ - * should get the data/attributes from one of the two points it is │ │ │ │ - * composed of, which one should it be? │ │ │ │ + * APIProperty: dx │ │ │ │ + * {Number} Point grid spacing in the x-axis direction (map units). │ │ │ │ + * Read-only. Use the <setSpacing> method to modify this value. │ │ │ │ */ │ │ │ │ - dataFrom: null, │ │ │ │ + dx: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: styleFrom │ │ │ │ - * {<OpenLayers.Layer.PointTrack.TARGET_NODE>} or │ │ │ │ - * {<OpenLayers.Layer.PointTrack.SOURCE_NODE>} optional. If the lines │ │ │ │ - * should get the style from one of the two points it is composed of, │ │ │ │ - * which one should it be? │ │ │ │ + * APIProperty: dy │ │ │ │ + * {Number} Point grid spacing in the y-axis direction (map units). │ │ │ │ + * Read-only. Use the <setSpacing> method to modify this value. │ │ │ │ */ │ │ │ │ - styleFrom: null, │ │ │ │ + dy: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.PointTrack │ │ │ │ - * Constructor for a new OpenLayers.PointTrack instance. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} name of the layer │ │ │ │ - * options - {Object} Optional object with properties to tag onto the │ │ │ │ - * instance. │ │ │ │ + * APIProperty: ratio │ │ │ │ + * {Number} Ratio of the desired grid size to the map viewport size. │ │ │ │ + * Default is 1.5. Larger ratios mean the grid is recalculated less often │ │ │ │ + * while panning. The <maxFeatures> setting has precedence when determining │ │ │ │ + * grid size. Read-only. Use the <setRatio> method to modify this value. │ │ │ │ */ │ │ │ │ + ratio: 1.5, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: addNodes │ │ │ │ - * Adds point features that will be used to create lines from, using point │ │ │ │ - * pairs. The first point of a pair will be the source node, the second │ │ │ │ - * will be the target node. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pointFeatures - {Array(<OpenLayers.Feature>)} │ │ │ │ - * options - {Object} │ │ │ │ - * │ │ │ │ - * Supported options: │ │ │ │ - * silent - {Boolean} true to suppress (before)feature(s)added events │ │ │ │ + * APIProperty: maxFeatures │ │ │ │ + * {Number} The maximum number of points to generate in the grid. Default │ │ │ │ + * is 250. Read-only. Use the <setMaxFeatures> method to modify this value. │ │ │ │ */ │ │ │ │ - addNodes: function(pointFeatures, options) { │ │ │ │ - if (pointFeatures.length < 2) { │ │ │ │ - throw new Error("At least two point features have to be added to " + │ │ │ │ - "create a line from"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var lines = new Array(pointFeatures.length - 1); │ │ │ │ - │ │ │ │ - var pointFeature, startPoint, endPoint; │ │ │ │ - for (var i = 0, len = pointFeatures.length; i < len; i++) { │ │ │ │ - pointFeature = pointFeatures[i]; │ │ │ │ - endPoint = pointFeature.geometry; │ │ │ │ - │ │ │ │ - if (!endPoint) { │ │ │ │ - var lonlat = pointFeature.lonlat; │ │ │ │ - endPoint = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ - } else if (endPoint.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ - throw new TypeError("Only features with point geometries are supported."); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (i > 0) { │ │ │ │ - var attributes = (this.dataFrom != null) ? │ │ │ │ - (pointFeatures[i + this.dataFrom].data || │ │ │ │ - pointFeatures[i + this.dataFrom].attributes) : │ │ │ │ - null; │ │ │ │ - var style = (this.styleFrom != null) ? │ │ │ │ - (pointFeatures[i + this.styleFrom].style) : │ │ │ │ - null; │ │ │ │ - var line = new OpenLayers.Geometry.LineString([startPoint, │ │ │ │ - endPoint │ │ │ │ - ]); │ │ │ │ - │ │ │ │ - lines[i - 1] = new OpenLayers.Feature.Vector(line, attributes, │ │ │ │ - style); │ │ │ │ - } │ │ │ │ - │ │ │ │ - startPoint = endPoint; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.addFeatures(lines, options); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.PointTrack" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Layer.PointTrack.SOURCE_NODE │ │ │ │ - * {Number} value for <OpenLayers.Layer.PointTrack.dataFrom> and │ │ │ │ - * <OpenLayers.Layer.PointTrack.styleFrom> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.PointTrack.SOURCE_NODE = -1; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Layer.PointTrack.TARGET_NODE │ │ │ │ - * {Number} value for <OpenLayers.Layer.PointTrack.dataFrom> and │ │ │ │ - * <OpenLayers.Layer.PointTrack.styleFrom> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.PointTrack.TARGET_NODE = 0; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Layer.PointTrack.dataFrom │ │ │ │ - * {Object} with the following keys - *deprecated* │ │ │ │ - * - SOURCE_NODE: take data/attributes from the source node of the line │ │ │ │ - * - TARGET_NODE: take data/attributes from the target node of the line │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.PointTrack.dataFrom = { │ │ │ │ - 'SOURCE_NODE': -1, │ │ │ │ - 'TARGET_NODE': 0 │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Tile/UTFGrid.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Tile.js │ │ │ │ - * @requires OpenLayers/Format/JSON.js │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Tile.UTFGrid │ │ │ │ - * Instances of OpenLayers.Tile.UTFGrid are used to manage │ │ │ │ - * UTFGrids. This is an unusual tile type in that it doesn't have a │ │ │ │ - * rendered image; only a 'hit grid' that can be used to │ │ │ │ - * look up feature attributes. │ │ │ │ - * │ │ │ │ - * See the <OpenLayers.Tile.UTFGrid> constructor for details on constructing a │ │ │ │ - * new instance. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Tile> │ │ │ │ - */ │ │ │ │ -OpenLayers.Tile.UTFGrid = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ + maxFeatures: 250, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: url │ │ │ │ - * {String} │ │ │ │ - * The URL of the UTFGrid file being requested. Provided by the <getURL> │ │ │ │ - * method. │ │ │ │ + /** │ │ │ │ + * APIProperty: rotation │ │ │ │ + * {Number} Grid rotation (in degrees clockwise from the positive x-axis). │ │ │ │ + * Default is 0. Read-only. Use the <setRotation> method to modify this │ │ │ │ + * value. │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + rotation: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: utfgridResolution │ │ │ │ - * {Number} │ │ │ │ - * Ratio of the pixel width to the width of a UTFGrid data point. If an │ │ │ │ - * entry in the grid represents a 4x4 block of pixels, the │ │ │ │ - * utfgridResolution would be 4. Default is 2. │ │ │ │ + * APIProperty: origin │ │ │ │ + * {<OpenLayers.LonLat>} Grid origin. The grid lattice will be aligned with │ │ │ │ + * the origin. If not set at construction, the center of the map's maximum │ │ │ │ + * extent is used. Read-only. Use the <setOrigin> method to modify this │ │ │ │ + * value. │ │ │ │ */ │ │ │ │ - utfgridResolution: 2, │ │ │ │ + origin: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: json │ │ │ │ - * {Object} │ │ │ │ - * Stores the parsed JSON tile data structure. │ │ │ │ + /** │ │ │ │ + * Property: gridBounds │ │ │ │ + * {<OpenLayers.Bounds>} Internally cached grid bounds (with optional │ │ │ │ + * rotation applied). │ │ │ │ */ │ │ │ │ - json: null, │ │ │ │ + gridBounds: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: format │ │ │ │ - * {OpenLayers.Format.JSON} │ │ │ │ - * Parser instance used to parse JSON for cross browser support. The native │ │ │ │ - * JSON.parse method will be used where available (all except IE<8). │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.PointGrid │ │ │ │ + * Creates a new point grid layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} An object containing all configuration properties for │ │ │ │ + * the layer. The <dx> and <dy> properties are required to be set at │ │ │ │ + * construction. Any other layer properties may be set in this object. │ │ │ │ */ │ │ │ │ - format: null, │ │ │ │ + initialize: function(config) { │ │ │ │ + config = config || {}; │ │ │ │ + OpenLayers.Layer.Vector.prototype.initialize.apply(this, [config.name, config]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Tile.UTFGrid │ │ │ │ - * Constructor for a new <OpenLayers.Tile.UTFGrid> instance. │ │ │ │ + * Method: setMap │ │ │ │ + * The layer has been added to the map. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer>} layer that the tile will go in. │ │ │ │ - * position - {<OpenLayers.Pixel>} │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * url - {<String>} Deprecated. Remove me in 3.0. │ │ │ │ - * size - {<OpenLayers.Size>} │ │ │ │ - * options - {Object} │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ + map.events.register("moveend", this, this.onMoveEnd); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up. │ │ │ │ + /** │ │ │ │ + * Method: removeMap │ │ │ │ + * The layer has been removed from the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.clear(); │ │ │ │ - OpenLayers.Tile.prototype.destroy.apply(this, arguments); │ │ │ │ + removeMap: function(map) { │ │ │ │ + map.events.unregister("moveend", this, this.onMoveEnd); │ │ │ │ + OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * Check that a tile should be drawn, and draw it. │ │ │ │ - * In the case of UTFGrids, "drawing" it means fetching and │ │ │ │ - * parsing the json. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Was a tile drawn? │ │ │ │ + * APIMethod: setRatio │ │ │ │ + * Set the grid <ratio> property and update the grid. Can only be called │ │ │ │ + * after the layer has been added to a map with a center/extent. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * ratio - {Number} │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - var drawn = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ - if (drawn) { │ │ │ │ - if (this.isLoading) { │ │ │ │ - this.abortLoading(); │ │ │ │ - //if we're already loading, send 'reload' instead of 'loadstart'. │ │ │ │ - this.events.triggerEvent("reload"); │ │ │ │ - } else { │ │ │ │ - this.isLoading = true; │ │ │ │ - this.events.triggerEvent("loadstart"); │ │ │ │ - } │ │ │ │ - this.url = this.layer.getURL(this.bounds); │ │ │ │ - │ │ │ │ - if (this.layer.useJSONP) { │ │ │ │ - // Use JSONP method to avoid xbrowser policy │ │ │ │ - var ols = new OpenLayers.Protocol.Script({ │ │ │ │ - url: this.url, │ │ │ │ - callback: function(response) { │ │ │ │ - this.isLoading = false; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - this.json = response.data; │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - ols.read(); │ │ │ │ - this.request = ols; │ │ │ │ - } else { │ │ │ │ - // Use standard XHR │ │ │ │ - this.request = OpenLayers.Request.GET({ │ │ │ │ - url: this.url, │ │ │ │ - callback: function(response) { │ │ │ │ - this.isLoading = false; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - if (response.status === 200) { │ │ │ │ - this.parseData(response.responseText); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unload(); │ │ │ │ - } │ │ │ │ - return drawn; │ │ │ │ + setRatio: function(ratio) { │ │ │ │ + this.ratio = ratio; │ │ │ │ + this.updateGrid(true); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: abortLoading │ │ │ │ - * Cancel a pending request. │ │ │ │ + * APIMethod: setMaxFeatures │ │ │ │ + * Set the grid <maxFeatures> property and update the grid. Can only be │ │ │ │ + * called after the layer has been added to a map with a center/extent. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * maxFeatures - {Number} │ │ │ │ */ │ │ │ │ - abortLoading: function() { │ │ │ │ - if (this.request) { │ │ │ │ - this.request.abort(); │ │ │ │ - delete this.request; │ │ │ │ - } │ │ │ │ - this.isLoading = false; │ │ │ │ + setMaxFeatures: function(maxFeatures) { │ │ │ │ + this.maxFeatures = maxFeatures; │ │ │ │ + this.updateGrid(true); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getFeatureInfo │ │ │ │ - * Get feature information associated with a pixel offset. If the pixel │ │ │ │ - * offset corresponds to a feature, the returned object will have id │ │ │ │ - * and data properties. Otherwise, null will be returned. │ │ │ │ - * │ │ │ │ + * APIMethod: setSpacing │ │ │ │ + * Set the grid <dx> and <dy> properties and update the grid. If only one │ │ │ │ + * argument is provided, it will be set as <dx> and <dy>. Can only be │ │ │ │ + * called after the layer has been added to a map with a center/extent. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * i - {Number} X-axis pixel offset (from top left of tile) │ │ │ │ - * j - {Number} Y-axis pixel offset (from top left of tile) │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Object with feature id and data properties corresponding to the │ │ │ │ - * given pixel offset. │ │ │ │ + * dx - {Number} │ │ │ │ + * dy - {Number} │ │ │ │ */ │ │ │ │ - getFeatureInfo: function(i, j) { │ │ │ │ - var info = null; │ │ │ │ - if (this.json) { │ │ │ │ - var id = this.getFeatureId(i, j); │ │ │ │ - if (id !== null) { │ │ │ │ - info = { │ │ │ │ - id: id, │ │ │ │ - data: this.json.data[id] │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return info; │ │ │ │ + setSpacing: function(dx, dy) { │ │ │ │ + this.dx = dx; │ │ │ │ + this.dy = dy || dx; │ │ │ │ + this.updateGrid(true); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getFeatureId │ │ │ │ - * Get the identifier for the feature associated with a pixel offset. │ │ │ │ + * APIMethod: setOrigin │ │ │ │ + * Set the grid <origin> property and update the grid. Can only be called │ │ │ │ + * after the layer has been added to a map with a center/extent. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * i - {Number} X-axis pixel offset (from top left of tile) │ │ │ │ - * j - {Number} Y-axis pixel offset (from top left of tile) │ │ │ │ + * origin - {<OpenLayers.LonLat>} │ │ │ │ + */ │ │ │ │ + setOrigin: function(origin) { │ │ │ │ + this.origin = origin; │ │ │ │ + this.updateGrid(true); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getOrigin │ │ │ │ + * Get the grid <origin> property. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} The feature identifier corresponding to the given pixel offset. │ │ │ │ - * Returns null if pixel doesn't correspond to a feature. │ │ │ │ + * {<OpenLayers.LonLat>} The grid origin. │ │ │ │ */ │ │ │ │ - getFeatureId: function(i, j) { │ │ │ │ - var id = null; │ │ │ │ - if (this.json) { │ │ │ │ - var resolution = this.utfgridResolution; │ │ │ │ - var row = Math.floor(j / resolution); │ │ │ │ - var col = Math.floor(i / resolution); │ │ │ │ - var charCode = this.json.grid[row].charCodeAt(col); │ │ │ │ - var index = this.indexFromCharCode(charCode); │ │ │ │ - var keys = this.json.keys; │ │ │ │ - if (!isNaN(index) && (index in keys)) { │ │ │ │ - id = keys[index]; │ │ │ │ - } │ │ │ │ + getOrigin: function() { │ │ │ │ + if (!this.origin) { │ │ │ │ + this.origin = this.map.getExtent().getCenterLonLat(); │ │ │ │ } │ │ │ │ - return id; │ │ │ │ + return this.origin; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: indexFromCharCode │ │ │ │ - * Given a character code for one of the UTFGrid "grid" characters, │ │ │ │ - * resolve the integer index for the feature id in the UTFGrid "keys" │ │ │ │ - * array. │ │ │ │ + * APIMethod: setRotation │ │ │ │ + * Set the grid <rotation> property and update the grid. Rotation values │ │ │ │ + * are in degrees clockwise from the positive x-axis (negative values │ │ │ │ + * for counter-clockwise rotation). Can only be called after the layer │ │ │ │ + * has been added to a map with a center/extent. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * charCode - {Integer} │ │ │ │ + * rotation - {Number} Degrees clockwise from the positive x-axis. │ │ │ │ + */ │ │ │ │ + setRotation: function(rotation) { │ │ │ │ + this.rotation = rotation; │ │ │ │ + this.updateGrid(true); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: onMoveEnd │ │ │ │ + * Listener for map "moveend" events. │ │ │ │ + */ │ │ │ │ + onMoveEnd: function() { │ │ │ │ + this.updateGrid(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getViewBounds │ │ │ │ + * Gets the (potentially rotated) view bounds for grid calculations. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Integer} Index for the feature id from the keys array. │ │ │ │ + * {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - indexFromCharCode: function(charCode) { │ │ │ │ - if (charCode >= 93) { │ │ │ │ - charCode--; │ │ │ │ - } │ │ │ │ - if (charCode >= 35) { │ │ │ │ - charCode--; │ │ │ │ + getViewBounds: function() { │ │ │ │ + var bounds = this.map.getExtent(); │ │ │ │ + if (this.rotation) { │ │ │ │ + var origin = this.getOrigin(); │ │ │ │ + var rotationOrigin = new OpenLayers.Geometry.Point(origin.lon, origin.lat); │ │ │ │ + var rect = bounds.toGeometry(); │ │ │ │ + rect.rotate(-this.rotation, rotationOrigin); │ │ │ │ + bounds = rect.getBounds(); │ │ │ │ } │ │ │ │ - return charCode - 32; │ │ │ │ + return bounds; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseData │ │ │ │ - * Parse the JSON from a request │ │ │ │ + * Method: updateGrid │ │ │ │ + * Update the grid. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * str - {String} UTFGrid as a JSON string. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} parsed javascript data │ │ │ │ + * force - {Boolean} Update the grid even if the previous bounds are still │ │ │ │ + * valid. │ │ │ │ */ │ │ │ │ - parseData: function(str) { │ │ │ │ - if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.JSON(); │ │ │ │ + updateGrid: function(force) { │ │ │ │ + if (force || this.invalidBounds()) { │ │ │ │ + var viewBounds = this.getViewBounds(); │ │ │ │ + var origin = this.getOrigin(); │ │ │ │ + var rotationOrigin = new OpenLayers.Geometry.Point(origin.lon, origin.lat); │ │ │ │ + var viewBoundsWidth = viewBounds.getWidth(); │ │ │ │ + var viewBoundsHeight = viewBounds.getHeight(); │ │ │ │ + var aspectRatio = viewBoundsWidth / viewBoundsHeight; │ │ │ │ + var maxHeight = Math.sqrt(this.dx * this.dy * this.maxFeatures / aspectRatio); │ │ │ │ + var maxWidth = maxHeight * aspectRatio; │ │ │ │ + var gridWidth = Math.min(viewBoundsWidth * this.ratio, maxWidth); │ │ │ │ + var gridHeight = Math.min(viewBoundsHeight * this.ratio, maxHeight); │ │ │ │ + var center = viewBounds.getCenterLonLat(); │ │ │ │ + this.gridBounds = new OpenLayers.Bounds( │ │ │ │ + center.lon - (gridWidth / 2), │ │ │ │ + center.lat - (gridHeight / 2), │ │ │ │ + center.lon + (gridWidth / 2), │ │ │ │ + center.lat + (gridHeight / 2) │ │ │ │ + ); │ │ │ │ + var rows = Math.floor(gridHeight / this.dy); │ │ │ │ + var cols = Math.floor(gridWidth / this.dx); │ │ │ │ + var gridLeft = origin.lon + (this.dx * Math.ceil((this.gridBounds.left - origin.lon) / this.dx)); │ │ │ │ + var gridBottom = origin.lat + (this.dy * Math.ceil((this.gridBounds.bottom - origin.lat) / this.dy)); │ │ │ │ + var features = new Array(rows * cols); │ │ │ │ + var x, y, point; │ │ │ │ + for (var i = 0; i < cols; ++i) { │ │ │ │ + x = gridLeft + (i * this.dx); │ │ │ │ + for (var j = 0; j < rows; ++j) { │ │ │ │ + y = gridBottom + (j * this.dy); │ │ │ │ + point = new OpenLayers.Geometry.Point(x, y); │ │ │ │ + if (this.rotation) { │ │ │ │ + point.rotate(this.rotation, rotationOrigin); │ │ │ │ + } │ │ │ │ + features[(i * rows) + j] = new OpenLayers.Feature.Vector(point); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.destroyFeatures(this.features, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.addFeatures(features, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ } │ │ │ │ - this.json = this.format.read(str); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clear │ │ │ │ - * Delete data stored with this tile. │ │ │ │ + /** │ │ │ │ + * Method: invalidBounds │ │ │ │ + * Determine whether the previously generated point grid is invalid. │ │ │ │ + * This occurs when the map bounds extends beyond the previously │ │ │ │ + * generated grid bounds. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - clear: function() { │ │ │ │ - this.json = null; │ │ │ │ + invalidBounds: function() { │ │ │ │ + return !this.gridBounds || !this.gridBounds.containsBounds(this.getViewBounds()); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Tile.UTFGrid" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.PointGrid" │ │ │ │ │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/UTFGrid.js │ │ │ │ + OpenLayers/Layer/ArcGISCache.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ -/** │ │ │ │ +/** │ │ │ │ * @requires OpenLayers/Layer/XYZ.js │ │ │ │ - * @requires OpenLayers/Tile/UTFGrid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.UTFGrid │ │ │ │ - * This Layer reads from UTFGrid tiled data sources. Since UTFGrids are │ │ │ │ - * essentially JSON-based ASCII art with attached attributes, they are not │ │ │ │ - * visibly rendered. In order to use them in the map, you must add a │ │ │ │ - * <OpenLayers.Control.UTFGrid> control as well. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * │ │ │ │ - * (start code) │ │ │ │ - * var world_utfgrid = new OpenLayers.Layer.UTFGrid({ │ │ │ │ - * url: "/tiles/world_utfgrid/${z}/${x}/${y}.json", │ │ │ │ - * utfgridResolution: 4, │ │ │ │ - * displayInLayerSwitcher: false │ │ │ │ - * ); │ │ │ │ - * map.addLayer(world_utfgrid); │ │ │ │ + * Class: OpenLayers.Layer.ArcGISCache │ │ │ │ + * Layer for accessing cached map tiles from an ArcGIS Server style mapcache. │ │ │ │ + * Tile must already be cached for this layer to access it. This does not require │ │ │ │ + * ArcGIS Server itself. │ │ │ │ * │ │ │ │ - * var control = new OpenLayers.Control.UTFGrid({ │ │ │ │ - * layers: [world_utfgrid], │ │ │ │ - * handlerMode: 'move', │ │ │ │ - * callback: function(dataLookup) { │ │ │ │ - * // do something with returned data │ │ │ │ - * } │ │ │ │ - * }) │ │ │ │ - * (end code) │ │ │ │ + * A few attempts have been made at this kind of layer before. See │ │ │ │ + * http://trac.osgeo.org/openlayers/ticket/1967 │ │ │ │ + * and │ │ │ │ + * http://trac.osgeo.org/openlayers/browser/sandbox/tschaub/arcgiscache/lib/OpenLayers/Layer/ArcGISCache.js │ │ │ │ * │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.XYZ> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.UTFGrid = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * Default is false, as UTFGrids are designed to be a transparent overlay layer. │ │ │ │ - */ │ │ │ │ - isBaseLayer: false, │ │ │ │ + * Typically the problem encountered is that the tiles seem to "jump around". │ │ │ │ + * This is due to the fact that the actual max extent for the tiles on AGS layers │ │ │ │ + * changes at each zoom level due to the way these caches are constructed. │ │ │ │ + * We have attempted to use the resolutions, tile size, and tile origin │ │ │ │ + * from the cache meta data to make the appropriate changes to the max extent │ │ │ │ + * of the tile to compensate for this behavior. This must be done as zoom levels change │ │ │ │ + * and before tiles are requested, which is why methods from base classes are overridden. │ │ │ │ + * │ │ │ │ + * For reference, you can access mapcache meta data in two ways. For accessing a │ │ │ │ + * mapcache through ArcGIS Server, you can simply go to the landing page for the │ │ │ │ + * layer. (ie. http://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer) │ │ │ │ + * For accessing it directly through HTTP, there should always be a conf.xml file │ │ │ │ + * in the root directory. │ │ │ │ + * (ie. http://serverx.esri.com/arcgiscache/DG_County_roads_yesA_backgroundDark/Layers/conf.xml) │ │ │ │ + * │ │ │ │ + *Inherits from: │ │ │ │ + * - <OpenLayers.Layer.XYZ> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: projection │ │ │ │ - * {<OpenLayers.Projection>} │ │ │ │ - * Source projection for the UTFGrids. Default is "EPSG:900913". │ │ │ │ + * APIProperty: url │ │ │ │ + * {String | Array} The base URL for the layer cache. You can also │ │ │ │ + * provide a list of URL strings for the layer if your cache is │ │ │ │ + * available from multiple origins. This must be set before the layer │ │ │ │ + * is drawn. │ │ │ │ */ │ │ │ │ - projection: new OpenLayers.Projection("EPSG:900913"), │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: useJSONP │ │ │ │ - * {Boolean} │ │ │ │ - * Should we use a JSONP script approach instead of a standard AJAX call? │ │ │ │ - * │ │ │ │ - * Set to true for using utfgrids from another server. │ │ │ │ - * Avoids same-domain policy restrictions. │ │ │ │ - * Note that this only works if the server accepts │ │ │ │ - * the callback GET parameter and dynamically │ │ │ │ - * wraps the returned json in a function call. │ │ │ │ - * │ │ │ │ - * Default is false │ │ │ │ + * APIProperty: tileOrigin │ │ │ │ + * {<OpenLayers.LonLat>} The location of the tile origin for the cache. │ │ │ │ + * An ArcGIS cache has it's origin at the upper-left (lowest x value │ │ │ │ + * and highest y value of the coordinate system). The units for the │ │ │ │ + * tile origin should be the same as the units for the cached data. │ │ │ │ */ │ │ │ │ - useJSONP: false, │ │ │ │ + tileOrigin: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} │ │ │ │ - * URL tempate for UTFGrid tiles. Include x, y, and z parameters. │ │ │ │ - * E.g. "/tiles/${z}/${x}/${y}.json" │ │ │ │ + * APIProperty: tileSize │ │ │ │ + * {<OpenLayers.Size>} This size of each tile. Defaults to 256 by 256 pixels. │ │ │ │ */ │ │ │ │ + tileSize: new OpenLayers.Size(256, 256), │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: utfgridResolution │ │ │ │ - * {Number} │ │ │ │ - * Ratio of the pixel width to the width of a UTFGrid data point. If an │ │ │ │ - * entry in the grid represents a 4x4 block of pixels, the │ │ │ │ - * utfgridResolution would be 4. Default is 2 (specified in │ │ │ │ - * <OpenLayers.Tile.UTFGrid>). │ │ │ │ + * APIProperty: useAGS │ │ │ │ + * {Boolean} Indicates if we are going to be accessing the ArcGIS Server (AGS) │ │ │ │ + * cache via an AGS MapServer or directly through HTTP. When accessing via │ │ │ │ + * AGS the path structure uses a standard z/y/x structure. But AGS actually │ │ │ │ + * stores the tile images on disk using a hex based folder structure that looks │ │ │ │ + * like "http://example.com/mylayer/L00/R00000000/C00000000.png". Learn more │ │ │ │ + * about this here: │ │ │ │ + * http://blogs.esri.com/Support/blogs/mappingcenter/archive/2010/08/20/Checking-Your-Local-Cache-Folders.aspx │ │ │ │ + * Defaults to true; │ │ │ │ */ │ │ │ │ + useArcGISServer: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: tileClass │ │ │ │ - * {<OpenLayers.Tile>} The tile class to use for this layer. │ │ │ │ - * Defaults is <OpenLayers.Tile.UTFGrid>. │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} Image type for the layer. This becomes the filename extension │ │ │ │ + * in tile requests. Default is "png" (generating a url like │ │ │ │ + * "http://example.com/mylayer/L00/R00000000/C00000000.png"). │ │ │ │ */ │ │ │ │ - tileClass: OpenLayers.Tile.UTFGrid, │ │ │ │ + type: 'png', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.UTFGrid │ │ │ │ - * Create a new UTFGrid layer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Configuration properties for the layer. │ │ │ │ - * │ │ │ │ - * Required configuration properties: │ │ │ │ - * url - {String} The url template for UTFGrid tiles. See the <url> property. │ │ │ │ + * APIProperty: useScales │ │ │ │ + * {Boolean} Optional override to indicate that the layer should use 'scale' information │ │ │ │ + * returned from the server capabilities object instead of 'resolution' information. │ │ │ │ + * This can be important if your tile server uses an unusual DPI for the tiles. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply( │ │ │ │ - this, [options.name, options.url, {}, options] │ │ │ │ - ); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - utfgridResolution: this.utfgridResolution │ │ │ │ - }, this.tileOptions); │ │ │ │ - }, │ │ │ │ + useScales: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createBackBuffer │ │ │ │ - * The UTFGrid cannot create a back buffer, so this method is overriden. │ │ │ │ + * APIProperty: overrideDPI │ │ │ │ + * {Boolean} Optional override to change the OpenLayers.DOTS_PER_INCH setting based │ │ │ │ + * on the tile information in the server capabilities object. This can be useful │ │ │ │ + * if your server has a non-standard DPI setting on its tiles, and you're only using │ │ │ │ + * tiles with that DPI. This value is used while OpenLayers is calculating resolution │ │ │ │ + * using scales, and is not necessary if you have resolution information. (This is │ │ │ │ + * typically the case) Regardless, this setting can be useful, but is dangerous │ │ │ │ + * because it will impact other layers while calculating resolution. Only use this │ │ │ │ + * if you know what you are doing. (See OpenLayers.Util.getResolutionFromScale) │ │ │ │ */ │ │ │ │ - createBackBuffer: function() {}, │ │ │ │ + overrideDPI: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a clone of this layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} Only used by a subclass of this layer. │ │ │ │ + * Constructor: OpenLayers.Layer.ArcGISCache │ │ │ │ + * Creates a new instance of this class │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.UTFGrid>} An exact clone of this OpenLayers.Layer.UTFGrid │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} │ │ │ │ + * url - {String} │ │ │ │ + * options - {Object} extra layer options │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.UTFGrid(this.getOptions()); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: getFeatureInfo │ │ │ │ - * Get details about a feature associated with a map location. The object │ │ │ │ - * returned will have id and data properties. If the given location │ │ │ │ - * doesn't correspond to a feature, null will be returned. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * location - {<OpenLayers.LonLat>} map location │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Object representing the feature id and UTFGrid data │ │ │ │ - * corresponding to the given map location. Returns null if the given │ │ │ │ - * location doesn't hit a feature. │ │ │ │ - */ │ │ │ │ - getFeatureInfo: function(location) { │ │ │ │ - var info = null; │ │ │ │ - var tileInfo = this.getTileData(location); │ │ │ │ - if (tileInfo && tileInfo.tile) { │ │ │ │ - info = tileInfo.tile.getFeatureInfo(tileInfo.i, tileInfo.j); │ │ │ │ + if (this.resolutions) { │ │ │ │ + this.serverResolutions = this.resolutions; │ │ │ │ + this.maxExtent = this.getMaxExtentForResolution(this.resolutions[0]); │ │ │ │ } │ │ │ │ - return info; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getFeatureId │ │ │ │ - * Get the identifier for the feature associated with a map location. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * location - {<OpenLayers.LonLat>} map location │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The feature identifier corresponding to the given map location. │ │ │ │ - * Returns null if the location doesn't hit a feature. │ │ │ │ - */ │ │ │ │ - getFeatureId: function(location) { │ │ │ │ - var id = null; │ │ │ │ - var info = this.getTileData(location); │ │ │ │ - if (info.tile) { │ │ │ │ - id = info.tile.getFeatureId(info.i, info.j); │ │ │ │ - } │ │ │ │ - return id; │ │ │ │ - }, │ │ │ │ + // this block steps through translating the values from the server layer JSON │ │ │ │ + // capabilities object into values that we can use. This is also a helpful │ │ │ │ + // reference when configuring this layer directly. │ │ │ │ + if (this.layerInfo) { │ │ │ │ + // alias the object │ │ │ │ + var info = this.layerInfo; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.UTFGrid" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/PointGrid.js │ │ │ │ - ====================================================================== */ │ │ │ │ + // build our extents │ │ │ │ + var startingTileExtent = new OpenLayers.Bounds( │ │ │ │ + info.fullExtent.xmin, │ │ │ │ + info.fullExtent.ymin, │ │ │ │ + info.fullExtent.xmax, │ │ │ │ + info.fullExtent.ymax │ │ │ │ + ); │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + // set our projection based on the given spatial reference. │ │ │ │ + // esri uses slightly different IDs, so this may not be comprehensive │ │ │ │ + this.projection = 'EPSG:' + info.spatialReference.wkid; │ │ │ │ + this.sphericalMercator = (info.spatialReference.wkid == 102100); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ - */ │ │ │ │ + // convert esri units into openlayers units (basic feet or meters only) │ │ │ │ + this.units = (info.units == "esriFeet") ? 'ft' : 'm'; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.PointGrid │ │ │ │ - * A point grid layer dynamically generates a regularly spaced grid of point │ │ │ │ - * features. This is a specialty layer for cases where an application needs │ │ │ │ - * a regular grid of points. It can be used, for example, in an editing │ │ │ │ - * environment to snap to a grid. │ │ │ │ - * │ │ │ │ - * Create a new vector layer with the <OpenLayers.Layer.PointGrid> constructor. │ │ │ │ - * (code) │ │ │ │ - * // create a grid with points spaced at 10 map units │ │ │ │ - * var points = new OpenLayers.Layer.PointGrid({dx: 10, dy: 10}); │ │ │ │ - * │ │ │ │ - * // create a grid with different x/y spacing rotated 15 degrees clockwise. │ │ │ │ - * var points = new OpenLayers.Layer.PointGrid({dx: 5, dy: 10, rotation: 15}); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Vector> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.PointGrid = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ + // optional extended section based on whether or not the server returned │ │ │ │ + // specific tile information │ │ │ │ + if (!!info.tileInfo) { │ │ │ │ + // either set the tiles based on rows/columns, or specific width/height │ │ │ │ + this.tileSize = new OpenLayers.Size( │ │ │ │ + info.tileInfo.width || info.tileInfo.cols, │ │ │ │ + info.tileInfo.height || info.tileInfo.rows │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: dx │ │ │ │ - * {Number} Point grid spacing in the x-axis direction (map units). │ │ │ │ - * Read-only. Use the <setSpacing> method to modify this value. │ │ │ │ - */ │ │ │ │ - dx: null, │ │ │ │ + // this must be set when manually configuring this layer │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat( │ │ │ │ + info.tileInfo.origin.x, │ │ │ │ + info.tileInfo.origin.y │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: dy │ │ │ │ - * {Number} Point grid spacing in the y-axis direction (map units). │ │ │ │ - * Read-only. Use the <setSpacing> method to modify this value. │ │ │ │ - */ │ │ │ │ - dy: null, │ │ │ │ + var upperLeft = new OpenLayers.Geometry.Point( │ │ │ │ + startingTileExtent.left, │ │ │ │ + startingTileExtent.top │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: ratio │ │ │ │ - * {Number} Ratio of the desired grid size to the map viewport size. │ │ │ │ - * Default is 1.5. Larger ratios mean the grid is recalculated less often │ │ │ │ - * while panning. The <maxFeatures> setting has precedence when determining │ │ │ │ - * grid size. Read-only. Use the <setRatio> method to modify this value. │ │ │ │ - */ │ │ │ │ - ratio: 1.5, │ │ │ │ + var bottomRight = new OpenLayers.Geometry.Point( │ │ │ │ + startingTileExtent.right, │ │ │ │ + startingTileExtent.bottom │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: maxFeatures │ │ │ │ - * {Number} The maximum number of points to generate in the grid. Default │ │ │ │ - * is 250. Read-only. Use the <setMaxFeatures> method to modify this value. │ │ │ │ - */ │ │ │ │ - maxFeatures: 250, │ │ │ │ + if (this.useScales) { │ │ │ │ + this.scales = []; │ │ │ │ + } else { │ │ │ │ + this.resolutions = []; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: rotation │ │ │ │ - * {Number} Grid rotation (in degrees clockwise from the positive x-axis). │ │ │ │ - * Default is 0. Read-only. Use the <setRotation> method to modify this │ │ │ │ - * value. │ │ │ │ - */ │ │ │ │ - rotation: 0, │ │ │ │ + this.lods = []; │ │ │ │ + for (var key in info.tileInfo.lods) { │ │ │ │ + if (info.tileInfo.lods.hasOwnProperty(key)) { │ │ │ │ + var lod = info.tileInfo.lods[key]; │ │ │ │ + if (this.useScales) { │ │ │ │ + this.scales.push(lod.scale); │ │ │ │ + } else { │ │ │ │ + this.resolutions.push(lod.resolution); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: origin │ │ │ │ - * {<OpenLayers.LonLat>} Grid origin. The grid lattice will be aligned with │ │ │ │ - * the origin. If not set at construction, the center of the map's maximum │ │ │ │ - * extent is used. Read-only. Use the <setOrigin> method to modify this │ │ │ │ - * value. │ │ │ │ - */ │ │ │ │ - origin: null, │ │ │ │ + var start = this.getContainingTileCoords(upperLeft, lod.resolution); │ │ │ │ + lod.startTileCol = start.x; │ │ │ │ + lod.startTileRow = start.y; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: gridBounds │ │ │ │ - * {<OpenLayers.Bounds>} Internally cached grid bounds (with optional │ │ │ │ - * rotation applied). │ │ │ │ - */ │ │ │ │ - gridBounds: null, │ │ │ │ + var end = this.getContainingTileCoords(bottomRight, lod.resolution); │ │ │ │ + lod.endTileCol = end.x; │ │ │ │ + lod.endTileRow = end.y; │ │ │ │ + this.lods.push(lod); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.PointGrid │ │ │ │ - * Creates a new point grid layer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} An object containing all configuration properties for │ │ │ │ - * the layer. The <dx> and <dy> properties are required to be set at │ │ │ │ - * construction. Any other layer properties may be set in this object. │ │ │ │ - */ │ │ │ │ - initialize: function(config) { │ │ │ │ - config = config || {}; │ │ │ │ - OpenLayers.Layer.Vector.prototype.initialize.apply(this, [config.name, config]); │ │ │ │ + this.maxExtent = this.calculateMaxExtentWithLOD(this.lods[0]); │ │ │ │ + this.serverResolutions = this.resolutions; │ │ │ │ + if (this.overrideDPI && info.tileInfo.dpi) { │ │ │ │ + // see comment above for 'overrideDPI' │ │ │ │ + OpenLayers.DOTS_PER_INCH = info.tileInfo.dpi; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * The layer has been added to the map. │ │ │ │ + * Method: getContainingTileCoords │ │ │ │ + * Calculates the x/y pixel corresponding to the position of the tile │ │ │ │ + * that contains the given point and for the for the given resolution. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ - map.events.register("moveend", this, this.onMoveEnd); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: removeMap │ │ │ │ - * The layer has been removed from the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - removeMap: function(map) { │ │ │ │ - map.events.unregister("moveend", this, this.onMoveEnd); │ │ │ │ - OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setRatio │ │ │ │ - * Set the grid <ratio> property and update the grid. Can only be called │ │ │ │ - * after the layer has been added to a map with a center/extent. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * ratio - {Number} │ │ │ │ - */ │ │ │ │ - setRatio: function(ratio) { │ │ │ │ - this.ratio = ratio; │ │ │ │ - this.updateGrid(true); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setMaxFeatures │ │ │ │ - * Set the grid <maxFeatures> property and update the grid. Can only be │ │ │ │ - * called after the layer has been added to a map with a center/extent. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * maxFeatures - {Number} │ │ │ │ - */ │ │ │ │ - setMaxFeatures: function(maxFeatures) { │ │ │ │ - this.maxFeatures = maxFeatures; │ │ │ │ - this.updateGrid(true); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setSpacing │ │ │ │ - * Set the grid <dx> and <dy> properties and update the grid. If only one │ │ │ │ - * argument is provided, it will be set as <dx> and <dy>. Can only be │ │ │ │ - * called after the layer has been added to a map with a center/extent. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * dx - {Number} │ │ │ │ - * dy - {Number} │ │ │ │ - */ │ │ │ │ - setSpacing: function(dx, dy) { │ │ │ │ - this.dx = dx; │ │ │ │ - this.dy = dy || dx; │ │ │ │ - this.updateGrid(true); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setOrigin │ │ │ │ - * Set the grid <origin> property and update the grid. Can only be called │ │ │ │ - * after the layer has been added to a map with a center/extent. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * origin - {<OpenLayers.LonLat>} │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * res - {Float} The resolution for which to compute the extent. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position │ │ │ │ + * of the upper left tile for the given resolution. │ │ │ │ */ │ │ │ │ - setOrigin: function(origin) { │ │ │ │ - this.origin = origin; │ │ │ │ - this.updateGrid(true); │ │ │ │ + getContainingTileCoords: function(point, res) { │ │ │ │ + return new OpenLayers.Pixel( │ │ │ │ + Math.max(Math.floor((point.x - this.tileOrigin.lon) / (this.tileSize.w * res)), 0), │ │ │ │ + Math.max(Math.floor((this.tileOrigin.lat - point.y) / (this.tileSize.h * res)), 0) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getOrigin │ │ │ │ - * Get the grid <origin> property. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.LonLat>} The grid origin. │ │ │ │ + /** │ │ │ │ + * Method: calculateMaxExtentWithLOD │ │ │ │ + * Given a Level of Detail object from the server, this function │ │ │ │ + * calculates the actual max extent │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lod - {Object} a Level of Detail Object from the server capabilities object │ │ │ │ + representing a particular zoom level │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} The actual extent of the tiles for the given zoom level │ │ │ │ */ │ │ │ │ - getOrigin: function() { │ │ │ │ - if (!this.origin) { │ │ │ │ - this.origin = this.map.getExtent().getCenterLonLat(); │ │ │ │ - } │ │ │ │ - return this.origin; │ │ │ │ - }, │ │ │ │ + calculateMaxExtentWithLOD: function(lod) { │ │ │ │ + // the max extent we're provided with just overlaps some tiles │ │ │ │ + // our real extent is the bounds of all the tiles we touch │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setRotation │ │ │ │ - * Set the grid <rotation> property and update the grid. Rotation values │ │ │ │ - * are in degrees clockwise from the positive x-axis (negative values │ │ │ │ - * for counter-clockwise rotation). Can only be called after the layer │ │ │ │ - * has been added to a map with a center/extent. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * rotation - {Number} Degrees clockwise from the positive x-axis. │ │ │ │ - */ │ │ │ │ - setRotation: function(rotation) { │ │ │ │ - this.rotation = rotation; │ │ │ │ - this.updateGrid(true); │ │ │ │ - }, │ │ │ │ + var numTileCols = (lod.endTileCol - lod.startTileCol) + 1; │ │ │ │ + var numTileRows = (lod.endTileRow - lod.startTileRow) + 1; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onMoveEnd │ │ │ │ - * Listener for map "moveend" events. │ │ │ │ - */ │ │ │ │ - onMoveEnd: function() { │ │ │ │ - this.updateGrid(); │ │ │ │ - }, │ │ │ │ + var minX = this.tileOrigin.lon + (lod.startTileCol * this.tileSize.w * lod.resolution); │ │ │ │ + var maxX = minX + (numTileCols * this.tileSize.w * lod.resolution); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getViewBounds │ │ │ │ - * Gets the (potentially rotated) view bounds for grid calculations. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} │ │ │ │ - */ │ │ │ │ - getViewBounds: function() { │ │ │ │ - var bounds = this.map.getExtent(); │ │ │ │ - if (this.rotation) { │ │ │ │ - var origin = this.getOrigin(); │ │ │ │ - var rotationOrigin = new OpenLayers.Geometry.Point(origin.lon, origin.lat); │ │ │ │ - var rect = bounds.toGeometry(); │ │ │ │ - rect.rotate(-this.rotation, rotationOrigin); │ │ │ │ - bounds = rect.getBounds(); │ │ │ │ - } │ │ │ │ - return bounds; │ │ │ │ + var maxY = this.tileOrigin.lat - (lod.startTileRow * this.tileSize.h * lod.resolution); │ │ │ │ + var minY = maxY - (numTileRows * this.tileSize.h * lod.resolution); │ │ │ │ + return new OpenLayers.Bounds(minX, minY, maxX, maxY); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: updateGrid │ │ │ │ - * Update the grid. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * force - {Boolean} Update the grid even if the previous bounds are still │ │ │ │ - * valid. │ │ │ │ + /** │ │ │ │ + * Method: calculateMaxExtentWithExtent │ │ │ │ + * Given a 'suggested' max extent from the server, this function uses │ │ │ │ + * information about the actual tile sizes to determine the actual │ │ │ │ + * extent of the layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * extent - {<OpenLayers.Bounds>} The 'suggested' extent for the layer │ │ │ │ + * res - {Float} The resolution for which to compute the extent. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} The actual extent of the tiles for the given zoom level │ │ │ │ */ │ │ │ │ - updateGrid: function(force) { │ │ │ │ - if (force || this.invalidBounds()) { │ │ │ │ - var viewBounds = this.getViewBounds(); │ │ │ │ - var origin = this.getOrigin(); │ │ │ │ - var rotationOrigin = new OpenLayers.Geometry.Point(origin.lon, origin.lat); │ │ │ │ - var viewBoundsWidth = viewBounds.getWidth(); │ │ │ │ - var viewBoundsHeight = viewBounds.getHeight(); │ │ │ │ - var aspectRatio = viewBoundsWidth / viewBoundsHeight; │ │ │ │ - var maxHeight = Math.sqrt(this.dx * this.dy * this.maxFeatures / aspectRatio); │ │ │ │ - var maxWidth = maxHeight * aspectRatio; │ │ │ │ - var gridWidth = Math.min(viewBoundsWidth * this.ratio, maxWidth); │ │ │ │ - var gridHeight = Math.min(viewBoundsHeight * this.ratio, maxHeight); │ │ │ │ - var center = viewBounds.getCenterLonLat(); │ │ │ │ - this.gridBounds = new OpenLayers.Bounds( │ │ │ │ - center.lon - (gridWidth / 2), │ │ │ │ - center.lat - (gridHeight / 2), │ │ │ │ - center.lon + (gridWidth / 2), │ │ │ │ - center.lat + (gridHeight / 2) │ │ │ │ - ); │ │ │ │ - var rows = Math.floor(gridHeight / this.dy); │ │ │ │ - var cols = Math.floor(gridWidth / this.dx); │ │ │ │ - var gridLeft = origin.lon + (this.dx * Math.ceil((this.gridBounds.left - origin.lon) / this.dx)); │ │ │ │ - var gridBottom = origin.lat + (this.dy * Math.ceil((this.gridBounds.bottom - origin.lat) / this.dy)); │ │ │ │ - var features = new Array(rows * cols); │ │ │ │ - var x, y, point; │ │ │ │ - for (var i = 0; i < cols; ++i) { │ │ │ │ - x = gridLeft + (i * this.dx); │ │ │ │ - for (var j = 0; j < rows; ++j) { │ │ │ │ - y = gridBottom + (j * this.dy); │ │ │ │ - point = new OpenLayers.Geometry.Point(x, y); │ │ │ │ - if (this.rotation) { │ │ │ │ - point.rotate(this.rotation, rotationOrigin); │ │ │ │ - } │ │ │ │ - features[(i * rows) + j] = new OpenLayers.Feature.Vector(point); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.destroyFeatures(this.features, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.addFeatures(features, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + calculateMaxExtentWithExtent: function(extent, res) { │ │ │ │ + var upperLeft = new OpenLayers.Geometry.Point(extent.left, extent.top); │ │ │ │ + var bottomRight = new OpenLayers.Geometry.Point(extent.right, extent.bottom); │ │ │ │ + var start = this.getContainingTileCoords(upperLeft, res); │ │ │ │ + var end = this.getContainingTileCoords(bottomRight, res); │ │ │ │ + var lod = { │ │ │ │ + resolution: res, │ │ │ │ + startTileCol: start.x, │ │ │ │ + startTileRow: start.y, │ │ │ │ + endTileCol: end.x, │ │ │ │ + endTileRow: end.y │ │ │ │ + }; │ │ │ │ + return this.calculateMaxExtentWithLOD(lod); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: invalidBounds │ │ │ │ - * Determine whether the previously generated point grid is invalid. │ │ │ │ - * This occurs when the map bounds extends beyond the previously │ │ │ │ - * generated grid bounds. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + /** │ │ │ │ + * Method: getUpperLeftTileCoord │ │ │ │ + * Calculates the x/y pixel corresponding to the position │ │ │ │ + * of the upper left tile for the given resolution. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * res - {Float} The resolution for which to compute the extent. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position │ │ │ │ + * of the upper left tile for the given resolution. │ │ │ │ */ │ │ │ │ - invalidBounds: function() { │ │ │ │ - return !this.gridBounds || !this.gridBounds.containsBounds(this.getViewBounds()); │ │ │ │ + getUpperLeftTileCoord: function(res) { │ │ │ │ + var upperLeft = new OpenLayers.Geometry.Point( │ │ │ │ + this.maxExtent.left, │ │ │ │ + this.maxExtent.top); │ │ │ │ + return this.getContainingTileCoords(upperLeft, res); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.PointGrid" │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/Zoomify.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/* │ │ │ │ - * Development supported by a R&D grant DC08P02OUK006 - Old Maps Online │ │ │ │ - * (www.oldmapsonline.org) from Ministry of Culture of the Czech Republic. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.Zoomify │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.Zoomify = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: size │ │ │ │ - * {<OpenLayers.Size>} The Zoomify image size in pixels. │ │ │ │ - */ │ │ │ │ - size: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - isBaseLayer: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: standardTileSize │ │ │ │ - * {Integer} The size of a standard (non-border) square tile in pixels. │ │ │ │ - */ │ │ │ │ - standardTileSize: 256, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Property: tileOriginCorner │ │ │ │ - * {String} This layer uses top-left as tile origin │ │ │ │ - **/ │ │ │ │ - tileOriginCorner: "tl", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: numberOfTiers │ │ │ │ - * {Integer} Depth of the Zoomify pyramid, number of tiers (zoom levels) │ │ │ │ - * - filled during Zoomify pyramid initialization. │ │ │ │ - */ │ │ │ │ - numberOfTiers: 0, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: tileCountUpToTier │ │ │ │ - * {Array(Integer)} Number of tiles up to the given tier of pyramid. │ │ │ │ - * - filled during Zoomify pyramid initialization. │ │ │ │ - */ │ │ │ │ - tileCountUpToTier: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: tierSizeInTiles │ │ │ │ - * {Array(<OpenLayers.Size>)} Size (in tiles) for each tier of pyramid. │ │ │ │ - * - filled during Zoomify pyramid initialization. │ │ │ │ - */ │ │ │ │ - tierSizeInTiles: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: tierImageSize │ │ │ │ - * {Array(<OpenLayers.Size>)} Image size in pixels for each pyramid tier. │ │ │ │ - * - filled during Zoomify pyramid initialization. │ │ │ │ - */ │ │ │ │ - tierImageSize: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.Zoomify │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} A name for the layer. │ │ │ │ - * url - {String} - Relative or absolute path to the image or more │ │ │ │ - * precisly to the TileGroup[X] directories root. │ │ │ │ - * Flash plugin use the variable name "zoomifyImagePath" for this. │ │ │ │ - * size - {<OpenLayers.Size>} The size (in pixels) of the image. │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ + * Method: getLowerRightTileCoord │ │ │ │ + * Calculates the x/y pixel corresponding to the position │ │ │ │ + * of the lower right tile for the given resolution. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * res - {Float} The resolution for which to compute the extent. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position │ │ │ │ + * of the lower right tile for the given resolution. │ │ │ │ */ │ │ │ │ - initialize: function(name, url, size, options) { │ │ │ │ - │ │ │ │ - // initilize the Zoomify pyramid for given size │ │ │ │ - this.initializeZoomify(size); │ │ │ │ - │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, [ │ │ │ │ - name, url, size, {}, │ │ │ │ - options │ │ │ │ - ]); │ │ │ │ + getLowerRightTileCoord: function(res) { │ │ │ │ + var bottomRight = new OpenLayers.Geometry.Point( │ │ │ │ + this.maxExtent.right, │ │ │ │ + this.maxExtent.bottom); │ │ │ │ + return this.getContainingTileCoords(bottomRight, res); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: initializeZoomify │ │ │ │ - * It generates constants for all tiers of the Zoomify pyramid │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * size - {<OpenLayers.Size>} The size of the image in pixels │ │ │ │ + /** │ │ │ │ + * Method: getMaxExtentForResolution │ │ │ │ + * Since the max extent of a set of tiles can change from zoom level │ │ │ │ + * to zoom level, we need to be able to calculate that max extent │ │ │ │ + * for a given resolution. │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * res - {Float} The resolution for which to compute the extent. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} The extent for this resolution │ │ │ │ */ │ │ │ │ - initializeZoomify: function(size) { │ │ │ │ - │ │ │ │ - var imageSize = size.clone(); │ │ │ │ - this.size = size.clone(); │ │ │ │ - var tiles = new OpenLayers.Size( │ │ │ │ - Math.ceil(imageSize.w / this.standardTileSize), │ │ │ │ - Math.ceil(imageSize.h / this.standardTileSize) │ │ │ │ - ); │ │ │ │ - │ │ │ │ - this.tierSizeInTiles = [tiles]; │ │ │ │ - this.tierImageSize = [imageSize]; │ │ │ │ - │ │ │ │ - while (imageSize.w > this.standardTileSize || │ │ │ │ - imageSize.h > this.standardTileSize) { │ │ │ │ - │ │ │ │ - imageSize = new OpenLayers.Size( │ │ │ │ - Math.floor(imageSize.w / 2), │ │ │ │ - Math.floor(imageSize.h / 2) │ │ │ │ - ); │ │ │ │ - tiles = new OpenLayers.Size( │ │ │ │ - Math.ceil(imageSize.w / this.standardTileSize), │ │ │ │ - Math.ceil(imageSize.h / this.standardTileSize) │ │ │ │ - ); │ │ │ │ - this.tierSizeInTiles.push(tiles); │ │ │ │ - this.tierImageSize.push(imageSize); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.tierSizeInTiles.reverse(); │ │ │ │ - this.tierImageSize.reverse(); │ │ │ │ - │ │ │ │ - this.numberOfTiers = this.tierSizeInTiles.length; │ │ │ │ - var resolutions = [1]; │ │ │ │ - this.tileCountUpToTier = [0]; │ │ │ │ - for (var i = 1; i < this.numberOfTiers; i++) { │ │ │ │ - resolutions.unshift(Math.pow(2, i)); │ │ │ │ - this.tileCountUpToTier.push( │ │ │ │ - this.tierSizeInTiles[i - 1].w * this.tierSizeInTiles[i - 1].h + │ │ │ │ - this.tileCountUpToTier[i - 1] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (!this.serverResolutions) { │ │ │ │ - this.serverResolutions = resolutions; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + getMaxExtentForResolution: function(res) { │ │ │ │ + var start = this.getUpperLeftTileCoord(res); │ │ │ │ + var end = this.getLowerRightTileCoord(res); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod:destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - // for now, nothing special to do here. │ │ │ │ - OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments); │ │ │ │ + var numTileCols = (end.x - start.x) + 1; │ │ │ │ + var numTileRows = (end.y - start.y) + 1; │ │ │ │ │ │ │ │ - // Remove from memory the Zoomify pyramid - is that enough? │ │ │ │ - this.tileCountUpToTier.length = 0; │ │ │ │ - this.tierSizeInTiles.length = 0; │ │ │ │ - this.tierImageSize.length = 0; │ │ │ │ + var minX = this.tileOrigin.lon + (start.x * this.tileSize.w * res); │ │ │ │ + var maxX = minX + (numTileCols * this.tileSize.w * res); │ │ │ │ │ │ │ │ + var maxY = this.tileOrigin.lat - (start.y * this.tileSize.h * res); │ │ │ │ + var minY = maxY - (numTileRows * this.tileSize.h * res); │ │ │ │ + return new OpenLayers.Bounds(minX, minY, maxX, maxY); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Zoomify>} An exact clone of this <OpenLayers.Layer.Zoomify> │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Returns an exact clone of this OpenLayers.Layer.ArcGISCache │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * [obj] - {Object} optional object to assign the cloned instance to. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.ArcGISCache>} clone of this instance │ │ │ │ */ │ │ │ │ clone: function(obj) { │ │ │ │ - │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Zoomify(this.name, │ │ │ │ - this.url, │ │ │ │ - this.size, │ │ │ │ - this.options); │ │ │ │ + obj = new OpenLayers.Layer.ArcGISCache(this.name, this.url, this.options); │ │ │ │ } │ │ │ │ - │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ + return OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getURL │ │ │ │ - * │ │ │ │ + * Method: initGriddedTiles │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getZoomForResolution(res); │ │ │ │ - │ │ │ │ - var tileIndex = x + y * this.tierSizeInTiles[z].w + this.tileCountUpToTier[z]; │ │ │ │ - var path = "TileGroup" + Math.floor((tileIndex) / 256) + │ │ │ │ - "/" + z + "-" + x + "-" + y + ".jpg"; │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(path, url); │ │ │ │ - } │ │ │ │ - return url + path; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getImageSize │ │ │ │ - * getImageSize returns size for a particular tile. If bounds are given as │ │ │ │ - * first argument, size is calculated (bottom-right tiles are non square). │ │ │ │ - * │ │ │ │ */ │ │ │ │ - getImageSize: function() { │ │ │ │ - if (arguments.length > 0) { │ │ │ │ - var bounds = this.adjustBounds(arguments[0]); │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getZoomForResolution(res); │ │ │ │ - var w = this.standardTileSize; │ │ │ │ - var h = this.standardTileSize; │ │ │ │ - if (x == this.tierSizeInTiles[z].w - 1) { │ │ │ │ - var w = this.tierImageSize[z].w % this.standardTileSize; │ │ │ │ - } │ │ │ │ - if (y == this.tierSizeInTiles[z].h - 1) { │ │ │ │ - var h = this.tierImageSize[z].h % this.standardTileSize; │ │ │ │ - } │ │ │ │ - return (new OpenLayers.Size(w, h)); │ │ │ │ - } else { │ │ │ │ - return this.tileSize; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setMap │ │ │ │ - * When the layer is added to a map, then we can fetch our origin │ │ │ │ - * (if we don't have one.) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, │ │ │ │ - this.map.maxExtent.top); │ │ │ │ + initGriddedTiles: function(bounds) { │ │ │ │ + delete this._tileOrigin; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initGriddedTiles.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Zoomify" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/TMS.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.TMS │ │ │ │ - * Create a layer for accessing tiles from services that conform with the │ │ │ │ - * Tile Map Service Specification │ │ │ │ - * (http://wiki.osgeo.org/wiki/Tile_Map_Service_Specification). │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var layer = new OpenLayers.Layer.TMS( │ │ │ │ - * "My Layer", // name for display in LayerSwitcher │ │ │ │ - * "http://tilecache.osgeo.org/wms-c/Basic.py/", // service endpoint │ │ │ │ - * {layername: "basic", type: "png"} // required properties │ │ │ │ - * ); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.TMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: serviceVersion │ │ │ │ - * {String} Service version for tile requests. Default is "1.0.0". │ │ │ │ - */ │ │ │ │ - serviceVersion: "1.0.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: layername │ │ │ │ - * {String} The identifier for the <TileMap> as advertised by the service. │ │ │ │ - * For example, if the service advertises a <TileMap> with │ │ │ │ - * 'href="http://tms.osgeo.org/1.0.0/vmap0"', the <layername> property │ │ │ │ - * would be set to "vmap0". │ │ │ │ - */ │ │ │ │ - layername: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} The format extension corresponding to the requested tile image │ │ │ │ - * type. This is advertised in a <TileFormat> element as the │ │ │ │ - * "extension" attribute. For example, if the service advertises a │ │ │ │ - * <TileMap> with <TileFormat width="256" height="256" mime-type="image/jpeg" extension="jpg" />, │ │ │ │ - * the <type> property would be set to "jpg". │ │ │ │ - */ │ │ │ │ - type: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} Make this layer a base layer. Default is true. Set false to │ │ │ │ - * use the layer as an overlay. │ │ │ │ - */ │ │ │ │ - isBaseLayer: true, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: tileOrigin │ │ │ │ - * {<OpenLayers.LonLat>} Optional origin for aligning the grid of tiles. │ │ │ │ - * If provided, requests for tiles at all resolutions will be aligned │ │ │ │ - * with this location (no tiles shall overlap this location). If │ │ │ │ - * not provided, the grid of tiles will be aligned with the bottom-left │ │ │ │ - * corner of the map's <maxExtent>. Default is ``null``. │ │ │ │ + * Method: getMaxExtent │ │ │ │ + * Get this layer's maximum extent. │ │ │ │ * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var layer = new OpenLayers.Layer.TMS( │ │ │ │ - * "My Layer", │ │ │ │ - * "http://tilecache.osgeo.org/wms-c/Basic.py/", │ │ │ │ - * { │ │ │ │ - * layername: "basic", │ │ │ │ - * type: "png", │ │ │ │ - * // set if different than the bottom left of map.maxExtent │ │ │ │ - * tileOrigin: new OpenLayers.LonLat(-180, -90) │ │ │ │ - * } │ │ │ │ - * ); │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ - tileOrigin: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: serverResolutions │ │ │ │ - * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ - * property if the map resolutions differ from the server. This │ │ │ │ - * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ - * resolutions that the server supports and that you don't want to │ │ │ │ - * provide with this layer; you can also look at <zoomOffset>, which is │ │ │ │ - * an alternative to <serverResolutions> for that specific purpose. │ │ │ │ - * (b) The map can work with resolutions that aren't supported by │ │ │ │ - * the server, i.e. that aren't in <serverResolutions>. When the │ │ │ │ - * map is displayed in such a resolution data for the closest │ │ │ │ - * server-supported resolution is loaded and the layer div is │ │ │ │ - * stretched as necessary. │ │ │ │ - */ │ │ │ │ - serverResolutions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomOffset │ │ │ │ - * {Number} If your cache has more zoom levels than you want to provide │ │ │ │ - * access to with this layer, supply a zoomOffset. This zoom offset │ │ │ │ - * is added to the current map zoom level to determine the level │ │ │ │ - * for a requested tile. For example, if you supply a zoomOffset │ │ │ │ - * of 3, when the map is at the zoom 0, tiles will be requested from │ │ │ │ - * level 3 of your cache. Default is 0 (assumes cache level and map │ │ │ │ - * zoom are equivalent). Using <zoomOffset> is an alternative to │ │ │ │ - * setting <serverResolutions> if you only want to expose a subset │ │ │ │ - * of the server resolutions. │ │ │ │ - */ │ │ │ │ - zoomOffset: 0, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.TMS │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} Title to be displayed in a <OpenLayers.Control.LayerSwitcher> │ │ │ │ - * url - {String} Service endpoint (without the version number). E.g. │ │ │ │ - * "http://tms.osgeo.org/". │ │ │ │ - * options - {Object} Additional properties to be set on the layer. The │ │ │ │ - * <layername> and <type> properties must be set here. │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - var newArguments = []; │ │ │ │ - newArguments.push(name, url, {}, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ + getMaxExtent: function() { │ │ │ │ + var resolution = this.map.getResolution(); │ │ │ │ + return this.maxExtent = this.getMaxExtentForResolution(resolution); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a complete copy of this layer. │ │ │ │ + * Method: getTileOrigin │ │ │ │ + * Determine the origin for aligning the grid of tiles. │ │ │ │ + * The origin will be derived from the layer's <maxExtent> property. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} Should only be provided by subclasses that call this │ │ │ │ - * method. │ │ │ │ - * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Layer.TMS>} An exact clone of this <OpenLayers.Layer.TMS> │ │ │ │ + * {<OpenLayers.LonLat>} The tile origin. │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.TMS(this.name, │ │ │ │ - this.url, │ │ │ │ - this.getOptions()); │ │ │ │ + getTileOrigin: function() { │ │ │ │ + if (!this._tileOrigin) { │ │ │ │ + var extent = this.getMaxExtent(); │ │ │ │ + this._tileOrigin = new OpenLayers.LonLat(extent.left, extent.bottom); │ │ │ │ } │ │ │ │ - │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ + return this._tileOrigin; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: getURL │ │ │ │ - * │ │ │ │ + * Determine the URL for a tile given the tile bounds. This is should support │ │ │ │ + * urls that access tiles through an ArcGIS Server MapServer or directly through │ │ │ │ + * the hex folder structure using HTTP. Just be sure to set the useArcGISServer │ │ │ │ + * property appropriately! This is basically the same as │ │ │ │ + * 'OpenLayers.Layer.TMS.getURL', but with the addition of hex addressing, │ │ │ │ + * and tile rounding. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters │ │ │ │ + * {String} The URL for a tile based on given bounds. │ │ │ │ */ │ │ │ │ getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getServerZoom(); │ │ │ │ - var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type; │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(path, url); │ │ │ │ - } │ │ │ │ - return url + path; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * When the layer is added to a map, then we can fetch our origin │ │ │ │ - * (if we don't have one.) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ - if (!this.tileOrigin) { │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, │ │ │ │ - this.map.maxExtent.bottom); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.TMS" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/WMS.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.WMS │ │ │ │ - * Instances of OpenLayers.Layer.WMS are used to display data from OGC Web │ │ │ │ - * Mapping Services. Create a new WMS layer with the <OpenLayers.Layer.WMS> │ │ │ │ - * constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_PARAMS │ │ │ │ - * {Object} Hashtable of default parameter key/value pairs │ │ │ │ - */ │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - service: "WMS", │ │ │ │ - version: "1.1.1", │ │ │ │ - request: "GetMap", │ │ │ │ - styles: "", │ │ │ │ - format: "image/jpeg" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} Default is true for WMS layer │ │ │ │ - */ │ │ │ │ - isBaseLayer: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: encodeBBOX │ │ │ │ - * {Boolean} Should the BBOX commas be encoded? The WMS spec says 'no', │ │ │ │ - * but some services want it that way. Default false. │ │ │ │ - */ │ │ │ │ - encodeBBOX: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: noMagic │ │ │ │ - * {Boolean} If true, the image format will not be automagicaly switched │ │ │ │ - * from image/jpeg to image/png or image/gif when using │ │ │ │ - * TRANSPARENT=TRUE. Also isBaseLayer will not changed by the │ │ │ │ - * constructor. Default false. │ │ │ │ - */ │ │ │ │ - noMagic: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: yx │ │ │ │ - * {Object} Keys in this object are EPSG codes for which the axis order │ │ │ │ - * is to be reversed (yx instead of xy, LatLon instead of LonLat), with │ │ │ │ - * true as value. This is only relevant for WMS versions >= 1.3.0, and │ │ │ │ - * only if yx is not set in <OpenLayers.Projection.defaults> for the │ │ │ │ - * used projection. │ │ │ │ - */ │ │ │ │ - yx: {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.WMS │ │ │ │ - * Create a new WMS layer object │ │ │ │ - * │ │ │ │ - * Examples: │ │ │ │ - * │ │ │ │ - * The code below creates a simple WMS layer using the image/jpeg format. │ │ │ │ - * (code) │ │ │ │ - * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", │ │ │ │ - * "http://wms.jpl.nasa.gov/wms.cgi", │ │ │ │ - * {layers: "modis,global_mosaic"}); │ │ │ │ - * (end) │ │ │ │ - * Note the 3rd argument (params). Properties added to this object will be │ │ │ │ - * added to the WMS GetMap requests used for this layer's tiles. The only │ │ │ │ - * mandatory parameter is "layers". Other common WMS params include │ │ │ │ - * "transparent", "styles" and "format". Note that the "srs" param will │ │ │ │ - * always be ignored. Instead, it will be derived from the baseLayer's or │ │ │ │ - * map's projection. │ │ │ │ - * │ │ │ │ - * The code below creates a transparent WMS layer with additional options. │ │ │ │ - * (code) │ │ │ │ - * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", │ │ │ │ - * "http://wms.jpl.nasa.gov/wms.cgi", │ │ │ │ - * { │ │ │ │ - * layers: "modis,global_mosaic", │ │ │ │ - * transparent: true │ │ │ │ - * }, { │ │ │ │ - * opacity: 0.5, │ │ │ │ - * singleTile: true │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * Note that by default, a WMS layer is configured as baseLayer. Setting │ │ │ │ - * the "transparent" param to true will apply some magic (see <noMagic>). │ │ │ │ - * The default image format changes from image/jpeg to image/png, and the │ │ │ │ - * layer is not configured as baseLayer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} A name for the layer │ │ │ │ - * url - {String} Base url for the WMS │ │ │ │ - * (e.g. http://wms.jpl.nasa.gov/wms.cgi) │ │ │ │ - * params - {Object} An object with key/value pairs representing the │ │ │ │ - * GetMap query string parameters and parameter values. │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer. │ │ │ │ - * These options include all properties listed above, plus the ones │ │ │ │ - * inherited from superclasses. │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - var newArguments = []; │ │ │ │ - //uppercase params │ │ │ │ - params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ - if (parseFloat(params.VERSION) >= 1.3 && !params.EXCEPTIONS) { │ │ │ │ - params.EXCEPTIONS = "INIMAGE"; │ │ │ │ - } │ │ │ │ - newArguments.push(name, url, params, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ - OpenLayers.Util.applyDefaults( │ │ │ │ - this.params, │ │ │ │ - OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS) │ │ │ │ - ); │ │ │ │ + var res = this.getResolution(); │ │ │ │ │ │ │ │ + // tile center │ │ │ │ + var originTileX = (this.tileOrigin.lon + (res * this.tileSize.w / 2)); │ │ │ │ + var originTileY = (this.tileOrigin.lat - (res * this.tileSize.h / 2)); │ │ │ │ │ │ │ │ - //layer is transparent │ │ │ │ - if (!this.noMagic && this.params.TRANSPARENT && │ │ │ │ - this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var point = { │ │ │ │ + x: center.lon, │ │ │ │ + y: center.lat │ │ │ │ + }; │ │ │ │ + var x = (Math.round(Math.abs((center.lon - originTileX) / (res * this.tileSize.w)))); │ │ │ │ + var y = (Math.round(Math.abs((originTileY - center.lat) / (res * this.tileSize.h)))); │ │ │ │ + var z = this.map.getZoom(); │ │ │ │ │ │ │ │ - // unless explicitly set in options, make layer an overlay │ │ │ │ - if ((options == null) || (!options.isBaseLayer)) { │ │ │ │ - this.isBaseLayer = false; │ │ │ │ + // this prevents us from getting pink tiles (non-existant tiles) │ │ │ │ + if (this.lods) { │ │ │ │ + var lod = this.lods[this.map.getZoom()]; │ │ │ │ + if ((x < lod.startTileCol || x > lod.endTileCol) || │ │ │ │ + (y < lod.startTileRow || y > lod.endTileRow)) { │ │ │ │ + return null; │ │ │ │ } │ │ │ │ - │ │ │ │ - // jpegs can never be transparent, so intelligently switch the │ │ │ │ - // format, depending on the browser's capabilities │ │ │ │ - if (this.params.FORMAT == "image/jpeg") { │ │ │ │ - this.params.FORMAT = OpenLayers.Util.alphaHack() ? "image/gif" : │ │ │ │ - "image/png"; │ │ │ │ + } else { │ │ │ │ + var start = this.getUpperLeftTileCoord(res); │ │ │ │ + var end = this.getLowerRightTileCoord(res); │ │ │ │ + if ((x < start.x || x >= end.x) || │ │ │ │ + (y < start.y || y >= end.y)) { │ │ │ │ + return null; │ │ │ │ } │ │ │ │ } │ │ │ │ │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - * Create a clone of this layer │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.WMS>} An exact clone of this layer │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ + // Construct the url string │ │ │ │ + var url = this.url; │ │ │ │ + var s = '' + x + y + z; │ │ │ │ │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.WMS(this.name, │ │ │ │ - this.url, │ │ │ │ - this.params, │ │ │ │ - this.getOptions()); │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(s, url); │ │ │ │ } │ │ │ │ │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: reverseAxisOrder │ │ │ │ - * Returns true if the axis order is reversed for the WMS version and │ │ │ │ - * projection of the layer. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} true if the axis order is reversed, false otherwise. │ │ │ │ - */ │ │ │ │ - reverseAxisOrder: function() { │ │ │ │ - var projCode = this.projection.getCode(); │ │ │ │ - return parseFloat(this.params.VERSION) >= 1.3 && │ │ │ │ - !!(this.yx[projCode] || (OpenLayers.Projection.defaults[projCode] && │ │ │ │ - OpenLayers.Projection.defaults[projCode].yx)); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getURL │ │ │ │ - * Return a GetMap query string for this layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the │ │ │ │ - * request. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters. │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - │ │ │ │ - var imageSize = this.getImageSize(); │ │ │ │ - var newParams = {}; │ │ │ │ - // WMS 1.3 introduced axis order │ │ │ │ - var reverseAxisOrder = this.reverseAxisOrder(); │ │ │ │ - newParams.BBOX = this.encodeBBOX ? │ │ │ │ - bounds.toBBOX(null, reverseAxisOrder) : │ │ │ │ - bounds.toArray(reverseAxisOrder); │ │ │ │ - newParams.WIDTH = imageSize.w; │ │ │ │ - newParams.HEIGHT = imageSize.h; │ │ │ │ - var requestString = this.getFullRequestString(newParams); │ │ │ │ - return requestString; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: mergeNewParams │ │ │ │ - * Catch changeParams and uppercase the new params to be merged in │ │ │ │ - * before calling changeParams on the super class. │ │ │ │ - * │ │ │ │ - * Once params have been changed, the tiles will be reloaded with │ │ │ │ - * the new parameters. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * newParams - {Object} Hashtable of new params to use │ │ │ │ - */ │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ - var newArguments = [upperParams]; │ │ │ │ - return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, │ │ │ │ - newArguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getFullRequestString │ │ │ │ - * Combine the layer's url with its params and these newParams. │ │ │ │ - * │ │ │ │ - * Add the SRS parameter from projection -- this is probably │ │ │ │ - * more eloquently done via a setProjection() method, but this │ │ │ │ - * works for now and always. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * newParams - {Object} │ │ │ │ - * altUrl - {String} Use this as the url instead of the layer's url │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - getFullRequestString: function(newParams, altUrl) { │ │ │ │ - var mapProjection = this.map.getProjectionObject(); │ │ │ │ - var projectionCode = this.projection && this.projection.equals(mapProjection) ? │ │ │ │ - this.projection.getCode() : │ │ │ │ - mapProjection.getCode(); │ │ │ │ - var value = (projectionCode == "none") ? null : projectionCode; │ │ │ │ - if (parseFloat(this.params.VERSION) >= 1.3) { │ │ │ │ - this.params.CRS = value; │ │ │ │ + // Accessing tiles through ArcGIS Server uses a different path │ │ │ │ + // structure than direct access via the folder structure. │ │ │ │ + if (this.useArcGISServer) { │ │ │ │ + // AGS MapServers have pretty url access to tiles │ │ │ │ + url = url + '/tile/${z}/${y}/${x}'; │ │ │ │ } else { │ │ │ │ - this.params.SRS = value; │ │ │ │ + // The tile images are stored using hex values on disk. │ │ │ │ + x = 'C' + OpenLayers.Number.zeroPad(x, 8, 16); │ │ │ │ + y = 'R' + OpenLayers.Number.zeroPad(y, 8, 16); │ │ │ │ + z = 'L' + OpenLayers.Number.zeroPad(z, 2, 10); │ │ │ │ + url = url + '/${z}/${y}/${x}.' + this.type; │ │ │ │ } │ │ │ │ │ │ │ │ - if (typeof this.params.TRANSPARENT == "boolean") { │ │ │ │ - newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE"; │ │ │ │ - } │ │ │ │ + // Write the values into our formatted url │ │ │ │ + url = OpenLayers.String.format(url, { │ │ │ │ + 'x': x, │ │ │ │ + 'y': y, │ │ │ │ + 'z': z │ │ │ │ + }); │ │ │ │ │ │ │ │ - return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply( │ │ │ │ - this, arguments); │ │ │ │ + return OpenLayers.Util.urlAppend( │ │ │ │ + url, OpenLayers.Util.getParameterString(this.params) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ + CLASS_NAME: 'OpenLayers.Layer.ArcGISCache' │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Format/ArcXML.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -41713,898 +41403,120 @@ │ │ │ │ │ │ │ │ return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.ArcIMS" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/ArcGIS93Rest.js │ │ │ │ + OpenLayers/Layer/WorldWind.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.ArcGIS93Rest │ │ │ │ - * Instances of OpenLayers.Layer.ArcGIS93Rest are used to display data from │ │ │ │ - * ESRI ArcGIS Server 9.3 (and up?) Mapping Services using the REST API. │ │ │ │ - * Create a new ArcGIS93Rest layer with the <OpenLayers.Layer.ArcGIS93Rest> │ │ │ │ - * constructor. More detail on the REST API is available at │ │ │ │ - * http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/index.html ; │ │ │ │ - * specifically, the URL provided to this layer should be an export service │ │ │ │ - * URL: http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/export.html │ │ │ │ + * Class: OpenLayers.Layer.WorldWind │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.ArcGIS93Rest = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ +OpenLayers.Layer.WorldWind = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_PARAMS │ │ │ │ - * {Object} Hashtable of default parameter key/value pairs │ │ │ │ - */ │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - format: "png" │ │ │ │ - }, │ │ │ │ + DEFAULT_PARAMS: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} Default is true for ArcGIS93Rest layer │ │ │ │ + * {Boolean} WorldWind layer is a base layer by default. │ │ │ │ */ │ │ │ │ isBaseLayer: true, │ │ │ │ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.ArcGIS93Rest │ │ │ │ - * Create a new ArcGIS93Rest layer object. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var arcims = new OpenLayers.Layer.ArcGIS93Rest("MyName", │ │ │ │ - * "http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Specialty/ESRI_StateCityHighway_USA/MapServer/export", │ │ │ │ - * { │ │ │ │ - * layers: "0,1,2" │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} A name for the layer │ │ │ │ - * url - {String} Base url for the ArcGIS server REST service │ │ │ │ - * options - {Object} An object with key/value pairs representing the │ │ │ │ - * options and option values. │ │ │ │ - * │ │ │ │ - * Valid Options: │ │ │ │ - * format - {String} MIME type of desired image type. │ │ │ │ - * layers - {String} Comma-separated list of layers to display. │ │ │ │ - * srs - {String} Projection ID. │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - var newArguments = []; │ │ │ │ - //uppercase params │ │ │ │ - params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ - newArguments.push(name, url, params, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ - OpenLayers.Util.applyDefaults( │ │ │ │ - this.params, │ │ │ │ - OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS) │ │ │ │ - ); │ │ │ │ - │ │ │ │ - //layer is transparent │ │ │ │ - if (this.params.TRANSPARENT && │ │ │ │ - this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ - │ │ │ │ - // unless explicitly set in options, make layer an overlay │ │ │ │ - if ((options == null) || (!options.isBaseLayer)) { │ │ │ │ - this.isBaseLayer = false; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // jpegs can never be transparent, so intelligently switch the │ │ │ │ - // format, depending on the browser's capabilities │ │ │ │ - if (this.params.FORMAT == "jpg") { │ │ │ │ - this.params.FORMAT = OpenLayers.Util.alphaHack() ? "gif" : │ │ │ │ - "png"; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - * Create a clone of this layer │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.ArcGIS93Rest>} An exact clone of this layer │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ - │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.ArcGIS93Rest(this.name, │ │ │ │ - this.url, │ │ │ │ - this.params, │ │ │ │ - this.getOptions()); │ │ │ │ - } │ │ │ │ - │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getURL │ │ │ │ - * Return an image url this layer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the │ │ │ │ - * request. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string with the map image's url. │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - │ │ │ │ - // ArcGIS Server only wants the numeric portion of the projection ID. │ │ │ │ - var projWords = this.projection.getCode().split(":"); │ │ │ │ - var srid = projWords[projWords.length - 1]; │ │ │ │ - │ │ │ │ - var imageSize = this.getImageSize(); │ │ │ │ - var newParams = { │ │ │ │ - 'BBOX': bounds.toBBOX(), │ │ │ │ - 'SIZE': imageSize.w + "," + imageSize.h, │ │ │ │ - // We always want image, the other options were json, image with a whole lotta html around it, etc. │ │ │ │ - 'F': "image", │ │ │ │ - 'BBOXSR': srid, │ │ │ │ - 'IMAGESR': srid │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Now add the filter parameters. │ │ │ │ - if (this.layerDefs) { │ │ │ │ - var layerDefStrList = []; │ │ │ │ - var layerID; │ │ │ │ - for (layerID in this.layerDefs) { │ │ │ │ - if (this.layerDefs.hasOwnProperty(layerID)) { │ │ │ │ - if (this.layerDefs[layerID]) { │ │ │ │ - layerDefStrList.push(layerID); │ │ │ │ - layerDefStrList.push(":"); │ │ │ │ - layerDefStrList.push(this.layerDefs[layerID]); │ │ │ │ - layerDefStrList.push(";"); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (layerDefStrList.length > 0) { │ │ │ │ - newParams['LAYERDEFS'] = layerDefStrList.join(""); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var requestString = this.getFullRequestString(newParams); │ │ │ │ - return requestString; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setLayerFilter │ │ │ │ - * addTile creates a tile, initializes it, and adds it to the layer div. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} The id of the layer to which the filter applies. │ │ │ │ - * queryDef - {String} A sql-ish query filter, for more detail see the ESRI │ │ │ │ - * documentation at http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/export.html │ │ │ │ + /** │ │ │ │ + * APIProperty: lzd │ │ │ │ + * {Float} LevelZeroTileSizeDegrees │ │ │ │ */ │ │ │ │ - setLayerFilter: function(id, queryDef) { │ │ │ │ - if (!this.layerDefs) { │ │ │ │ - this.layerDefs = {}; │ │ │ │ - } │ │ │ │ - if (queryDef) { │ │ │ │ - this.layerDefs[id] = queryDef; │ │ │ │ - } else { │ │ │ │ - delete this.layerDefs[id]; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + lzd: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearLayerFilter │ │ │ │ - * Clears layer filters, either from a specific layer, │ │ │ │ - * or all of them. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} The id of the layer from which to remove any │ │ │ │ - * filter. If unspecified/blank, all filters │ │ │ │ - * will be removed. │ │ │ │ + * APIProperty: zoomLevels │ │ │ │ + * {Integer} Number of zoom levels. │ │ │ │ */ │ │ │ │ - clearLayerFilter: function(id) { │ │ │ │ - if (id) { │ │ │ │ - delete this.layerDefs[id]; │ │ │ │ - } else { │ │ │ │ - delete this.layerDefs; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + zoomLevels: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: mergeNewParams │ │ │ │ - * Catch changeParams and uppercase the new params to be merged in │ │ │ │ - * before calling changeParams on the super class. │ │ │ │ - * │ │ │ │ - * Once params have been changed, the tiles will be reloaded with │ │ │ │ - * the new parameters. │ │ │ │ + * Constructor: OpenLayers.Layer.WorldWind │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * newParams - {Object} Hashtable of new params to use │ │ │ │ - */ │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ - var newArguments = [upperParams]; │ │ │ │ - return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, │ │ │ │ - newArguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.ArcGIS93Rest" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/OSM.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/XYZ.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.OSM │ │ │ │ - * This layer allows accessing OpenStreetMap tiles. By default the OpenStreetMap │ │ │ │ - * hosted tile.openstreetmap.org Mapnik tileset is used. If you wish to use │ │ │ │ - * a different layer instead, you need to provide a different │ │ │ │ - * URL to the constructor. Here's an example for using OpenCycleMap: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ - * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.XYZ> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} The layer name. Defaults to "OpenStreetMap" if the first │ │ │ │ - * argument to the constructor is null or undefined. │ │ │ │ - */ │ │ │ │ - name: "OpenStreetMap", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} The tileset URL scheme. Defaults to │ │ │ │ - * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png │ │ │ │ - * (the official OSM tileset) if the second argument to the constructor │ │ │ │ - * is null or undefined. To use another tileset you can have something │ │ │ │ - * like this: │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ - * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ - url: [ │ │ │ │ - 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ - 'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ - 'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png' │ │ │ │ - ], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: attribution │ │ │ │ - * {String} The layer attribution. │ │ │ │ - */ │ │ │ │ - attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: sphericalMercator │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - sphericalMercator: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: wrapDateLine │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - wrapDateLine: true, │ │ │ │ - │ │ │ │ - /** APIProperty: tileOptions │ │ │ │ - * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ - * created by this Layer. Default is │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: 'anonymous'} │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * When using OSM tilesets other than the default ones, it may be │ │ │ │ - * necessary to set this to │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: null} │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * if the server does not send Access-Control-Allow-Origin headers. │ │ │ │ - */ │ │ │ │ - tileOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.OSM │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} The layer name. │ │ │ │ - * url - {String} The tileset URL scheme. │ │ │ │ - * options - {Object} Configuration options for the layer. Any inherited │ │ │ │ - * layer option can be set in this object (e.g. │ │ │ │ - * <OpenLayers.Layer.Grid.buffer>). │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: 'anonymous' │ │ │ │ - }, this.options && this.options.tileOptions); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.OSM( │ │ │ │ - this.name, this.url, this.getOptions()); │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/MapServer.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.MapServer │ │ │ │ - * Instances of OpenLayers.Layer.MapServer are used to display │ │ │ │ - * data from a MapServer CGI instance. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.MapServer = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_PARAMS │ │ │ │ - * {Object} Hashtable of default parameter key/value pairs │ │ │ │ - */ │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - mode: "map", │ │ │ │ - map_imagetype: "png" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.MapServer │ │ │ │ - * Create a new MapServer layer object │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} A name for the layer │ │ │ │ - * url - {String} Base url for the MapServer CGI │ │ │ │ - * (e.g. http://www2.dmsolutions.ca/cgi-bin/mapserv) │ │ │ │ - * params - {Object} An object with key/value pairs representing the │ │ │ │ - * GetMap query string parameters and parameter values. │ │ │ │ - * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ + * name - {String} Name of Layer │ │ │ │ + * url - {String} Base URL │ │ │ │ + * lzd - {Float} Level zero tile size degrees │ │ │ │ + * zoomLevels - {Integer} number of zoom levels │ │ │ │ + * params - {Object} additional parameters │ │ │ │ + * options - {Object} additional options │ │ │ │ */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ + initialize: function(name, url, lzd, zoomLevels, params, options) { │ │ │ │ + this.lzd = lzd; │ │ │ │ + this.zoomLevels = zoomLevels; │ │ │ │ + var newArguments = []; │ │ │ │ + newArguments.push(name, url, params, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ this.params = OpenLayers.Util.applyDefaults( │ │ │ │ this.params, this.DEFAULT_PARAMS │ │ │ │ ); │ │ │ │ - │ │ │ │ - // unless explicitly set in options, if the layer is transparent, │ │ │ │ - // it will be an overlay │ │ │ │ - if (options == null || options.isBaseLayer == null) { │ │ │ │ - this.isBaseLayer = ((this.params.transparent != "true") && │ │ │ │ - (this.params.transparent != true)); │ │ │ │ - } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clone │ │ │ │ - * Create a clone of this layer │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.MapServer>} An exact clone of this layer │ │ │ │ + * Method: getZoom │ │ │ │ + * Convert map zoom to WW zoom. │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.MapServer(this.name, │ │ │ │ - this.url, │ │ │ │ - this.params, │ │ │ │ - this.getOptions()); │ │ │ │ - } │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ + getZoom: function() { │ │ │ │ + var zoom = this.map.getZoom(); │ │ │ │ + var extent = this.map.getMaxExtent(); │ │ │ │ + zoom = zoom - Math.log(this.maxResolution / (this.lzd / 512)) / Math.log(2); │ │ │ │ + return zoom; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: getURL │ │ │ │ - * Return a query string for this layer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox │ │ │ │ - * for the request │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also │ │ │ │ - * the passed-in bounds and appropriate tile size specified │ │ │ │ - * as parameters. │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - // Make a list, so that getFullRequestString uses literal "," │ │ │ │ - var extent = [bounds.left, bounds.bottom, bounds.right, bounds.top]; │ │ │ │ - │ │ │ │ - var imageSize = this.getImageSize(); │ │ │ │ - │ │ │ │ - // make lists, so that literal ','s are used │ │ │ │ - var url = this.getFullRequestString({ │ │ │ │ - mapext: extent, │ │ │ │ - imgext: extent, │ │ │ │ - map_size: [imageSize.w, imageSize.h], │ │ │ │ - imgx: imageSize.w / 2, │ │ │ │ - imgy: imageSize.h / 2, │ │ │ │ - imgxy: [imageSize.w, imageSize.h] │ │ │ │ - }); │ │ │ │ - │ │ │ │ - return url; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getFullRequestString │ │ │ │ - * combine the layer's url with its params and these newParams. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * newParams - {Object} New parameters that should be added to the │ │ │ │ - * request string. │ │ │ │ - * altUrl - {String} (optional) Replace the URL in the full request │ │ │ │ - * string with the provided URL. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters embedded in it. │ │ │ │ - */ │ │ │ │ - getFullRequestString: function(newParams, altUrl) { │ │ │ │ - // use layer's url unless altUrl passed in │ │ │ │ - var url = (altUrl == null) ? this.url : altUrl; │ │ │ │ - │ │ │ │ - // create a new params hashtable with all the layer params and the │ │ │ │ - // new params together. then convert to string │ │ │ │ - var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ - allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ - var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ - │ │ │ │ - // if url is not a string, it should be an array of strings, │ │ │ │ - // in which case we will deterministically select one of them in │ │ │ │ - // order to evenly distribute requests to different urls. │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(paramsString, url); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // ignore parameters that are already in the url search string │ │ │ │ - var urlParams = OpenLayers.Util.upperCaseObject( │ │ │ │ - OpenLayers.Util.getParameters(url)); │ │ │ │ - for (var key in allParams) { │ │ │ │ - if (key.toUpperCase() in urlParams) { │ │ │ │ - delete allParams[key]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ - │ │ │ │ - // requestString always starts with url │ │ │ │ - var requestString = url; │ │ │ │ - │ │ │ │ - // MapServer needs '+' seperating things like bounds/height/width. │ │ │ │ - // Since typically this is URL encoded, we use a slight hack: we │ │ │ │ - // depend on the list-like functionality of getParameterString to │ │ │ │ - // leave ',' only in the case of list items (since otherwise it is │ │ │ │ - // encoded) then do a regular expression replace on the , characters │ │ │ │ - // to '+' │ │ │ │ - // │ │ │ │ - paramsString = paramsString.replace(/,/g, "+"); │ │ │ │ - │ │ │ │ - if (paramsString != "") { │ │ │ │ - var lastServerChar = url.charAt(url.length - 1); │ │ │ │ - if ((lastServerChar == "&") || (lastServerChar == "?")) { │ │ │ │ - requestString += paramsString; │ │ │ │ - } else { │ │ │ │ - if (url.indexOf('?') == -1) { │ │ │ │ - //serverPath has no ? -- add one │ │ │ │ - requestString += '?' + paramsString; │ │ │ │ - } else { │ │ │ │ - //serverPath contains ?, so must already have paramsString at the end │ │ │ │ - requestString += '&' + paramsString; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return requestString; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.MapServer" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/KaMap.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.KaMap │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.KaMap = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} KaMap Layer is always a base layer │ │ │ │ - */ │ │ │ │ - isBaseLayer: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_PARAMS │ │ │ │ - * {Object} parameters set by default. The default parameters set │ │ │ │ - * the format via the 'i' parameter to 'jpeg'. │ │ │ │ - */ │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - i: 'jpeg', │ │ │ │ - map: '' │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.KaMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * url - {String} │ │ │ │ - * params - {Object} Parameters to be sent to the HTTP server in the │ │ │ │ - * query string for the tile. The format can be set via the 'i' │ │ │ │ - * parameter (defaults to jpg) , and the map should be set via │ │ │ │ - * the 'map' parameter. It has been reported that ka-Map may behave │ │ │ │ - * inconsistently if your format parameter does not match the format │ │ │ │ - * parameter configured in your config.php. (See ticket #327 for more │ │ │ │ - * information.) │ │ │ │ - * options - {Object} Additional options for the layer. Any of the │ │ │ │ - * APIProperties listed on this layer, and any layer types it │ │ │ │ - * extends, can be overridden through the options parameter. │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ - this.params = OpenLayers.Util.applyDefaults( │ │ │ │ - this.params, this.DEFAULT_PARAMS │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getURL │ │ │ │ - * │ │ │ │ * Parameters: │ │ │ │ * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - var scale = Math.round((this.map.getScale() * 10000)) / 10000; │ │ │ │ - var pX = Math.round(bounds.left / mapRes); │ │ │ │ - var pY = -Math.round(bounds.top / mapRes); │ │ │ │ - return this.getFullRequestString({ │ │ │ │ - t: pY, │ │ │ │ - l: pX, │ │ │ │ - s: scale │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: calculateGridLayout │ │ │ │ - * ka-Map uses the center point of the map as an origin for │ │ │ │ - * its tiles. Override calculateGridLayout to center tiles │ │ │ │ - * correctly for this case. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bound>} │ │ │ │ - * origin - {<OpenLayers.LonLat>} │ │ │ │ - * resolution - {Number} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Object containing properties tilelon, tilelat, startcol, │ │ │ │ - * startrow │ │ │ │ - */ │ │ │ │ - calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ - var tilelon = resolution * this.tileSize.w; │ │ │ │ - var tilelat = resolution * this.tileSize.h; │ │ │ │ - │ │ │ │ - var offsetlon = bounds.left; │ │ │ │ - var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ - │ │ │ │ - var offsetlat = bounds.top; │ │ │ │ - var tilerow = Math.floor(offsetlat / tilelat) + this.buffer; │ │ │ │ - │ │ │ │ - return { │ │ │ │ - tilelon: tilelon, │ │ │ │ - tilelat: tilelat, │ │ │ │ - startcol: tilecol, │ │ │ │ - startrow: tilerow │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getTileBoundsForGridIndex │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * row - {Number} The row of the grid │ │ │ │ - * col - {Number} The column of the grid │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} The bounds for the tile at (row, col) │ │ │ │ - */ │ │ │ │ - getTileBoundsForGridIndex: function(row, col) { │ │ │ │ - var origin = this.getTileOrigin(); │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - var tilelon = tileLayout.tilelon; │ │ │ │ - var tilelat = tileLayout.tilelat; │ │ │ │ - var minX = (tileLayout.startcol + col) * tilelon; │ │ │ │ - var minY = (tileLayout.startrow - row) * tilelat; │ │ │ │ - return new OpenLayers.Bounds( │ │ │ │ - minX, minY, │ │ │ │ - minX + tilelon, minY + tilelat │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Kamap>} An exact clone of this OpenLayers.Layer.KaMap │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ - │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.KaMap(this.name, │ │ │ │ - this.url, │ │ │ │ - this.params, │ │ │ │ - this.getOptions()); │ │ │ │ - } │ │ │ │ - │ │ │ │ - //get all additions from superclasses │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ - if (this.tileSize != null) { │ │ │ │ - obj.tileSize = this.tileSize.clone(); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // we do not want to copy reference to grid, so we make a new array │ │ │ │ - obj.grid = []; │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getTileBounds │ │ │ │ - * Returns The tile bounds for a layer given a pixel location. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * viewPortPx - {<OpenLayers.Pixel>} The location in the viewport. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} Bounds of the tile at the given pixel location. │ │ │ │ - */ │ │ │ │ - getTileBounds: function(viewPortPx) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ - var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ - var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ - var tileLeft = tileMapWidth * Math.floor(mapPoint.lon / tileMapWidth); │ │ │ │ - var tileBottom = tileMapHeight * Math.floor(mapPoint.lat / tileMapHeight); │ │ │ │ - return new OpenLayers.Bounds(tileLeft, tileBottom, │ │ │ │ - tileLeft + tileMapWidth, │ │ │ │ - tileBottom + tileMapHeight); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.KaMap" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Layer/KaMapCache.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ - * @requires OpenLayers/Layer/KaMap.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.KaMapCache │ │ │ │ - * │ │ │ │ - * This class is designed to talk directly to a web-accessible ka-Map │ │ │ │ - * cache generated by the precache2.php script. │ │ │ │ - * │ │ │ │ - * To create a a new KaMapCache layer, you must indicate also the "i" parameter │ │ │ │ - * (that will be used to calculate the file extension), and another special │ │ │ │ - * parameter, object names "metaTileSize", with "h" (height) and "w" (width) │ │ │ │ - * properties. │ │ │ │ - * │ │ │ │ - * // Create a new kaMapCache layer. │ │ │ │ - * var kamap_base = new OpenLayers.Layer.KaMapCache( │ │ │ │ - * "Satellite", │ │ │ │ - * "http://www.example.org/web/acessible/cache", │ │ │ │ - * {g: "satellite", map: "world", i: 'png24', metaTileSize: {w: 5, h: 5} } │ │ │ │ - * ); │ │ │ │ - * │ │ │ │ - * // Create an kaMapCache overlay layer (using "isBaseLayer: false"). │ │ │ │ - * // Forces the output to be a "gif", using the "i" parameter. │ │ │ │ - * var kamap_overlay = new OpenLayers.Layer.KaMapCache( │ │ │ │ - * "Streets", │ │ │ │ - * "http://www.example.org/web/acessible/cache", │ │ │ │ - * {g: "streets", map: "world", i: "gif", metaTileSize: {w: 5, h: 5} }, │ │ │ │ - * {isBaseLayer: false} │ │ │ │ - * ); │ │ │ │ - * │ │ │ │ - * The cache URLs must look like: │ │ │ │ - * var/cache/World/50000/Group_Name/def/t-440320/l20480 │ │ │ │ - * │ │ │ │ - * This means that the cache generated via tile.php will *not* work with │ │ │ │ - * this class, and should instead use the KaMap layer. │ │ │ │ - * │ │ │ │ - * More information is available in Ticket #1518. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.KaMap> │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.KaMapCache = OpenLayers.Class(OpenLayers.Layer.KaMap, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: IMAGE_EXTENSIONS │ │ │ │ - * {Object} Simple hash map to convert format to extension. │ │ │ │ - */ │ │ │ │ - IMAGE_EXTENSIONS: { │ │ │ │ - 'jpeg': 'jpg', │ │ │ │ - 'gif': 'gif', │ │ │ │ - 'png': 'png', │ │ │ │ - 'png8': 'png', │ │ │ │ - 'png24': 'png', │ │ │ │ - 'dithered': 'png' │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_FORMAT │ │ │ │ - * {Object} Simple hash map to convert format to extension. │ │ │ │ - */ │ │ │ │ - DEFAULT_FORMAT: 'jpeg', │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.KaMapCache │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * url - {String} │ │ │ │ - * params - {Object} Parameters to be sent to the HTTP server in the │ │ │ │ - * query string for the tile. The format can be set via the 'i' │ │ │ │ - * parameter (defaults to jpg) , and the map should be set via │ │ │ │ - * the 'map' parameter. It has been reported that ka-Map may behave │ │ │ │ - * inconsistently if your format parameter does not match the format │ │ │ │ - * parameter configured in your config.php. (See ticket #327 for more │ │ │ │ - * information.) │ │ │ │ - * options - {Object} Additional options for the layer. Any of the │ │ │ │ - * APIProperties listed on this layer, and any layer types it │ │ │ │ - * extends, can be overridden through the options parameter. │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.KaMap.prototype.initialize.apply(this, arguments); │ │ │ │ - this.extension = this.IMAGE_EXTENSIONS[this.params.i.toLowerCase() || this.DEFAULT_FORMAT]; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getURL │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ * {String} A string with the layer's url and parameters and also the │ │ │ │ - * passed-in bounds and appropriate tile size specified as │ │ │ │ - * parameters │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters │ │ │ │ */ │ │ │ │ getURL: function(bounds) { │ │ │ │ bounds = this.adjustBounds(bounds); │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - var scale = Math.round((this.map.getScale() * 10000)) / 10000; │ │ │ │ - var pX = Math.round(bounds.left / mapRes); │ │ │ │ - var pY = -Math.round(bounds.top / mapRes); │ │ │ │ - │ │ │ │ - var metaX = Math.floor(pX / this.tileSize.w / this.params.metaTileSize.w) * this.tileSize.w * this.params.metaTileSize.w; │ │ │ │ - var metaY = Math.floor(pY / this.tileSize.h / this.params.metaTileSize.h) * this.tileSize.h * this.params.metaTileSize.h; │ │ │ │ - │ │ │ │ - var components = [ │ │ │ │ - "/", │ │ │ │ - this.params.map, │ │ │ │ - "/", │ │ │ │ - scale, │ │ │ │ - "/", │ │ │ │ - this.params.g.replace(/\s/g, '_'), │ │ │ │ - "/def/t", │ │ │ │ - metaY, │ │ │ │ - "/l", │ │ │ │ - metaX, │ │ │ │ - "/t", │ │ │ │ - pY, │ │ │ │ - "l", │ │ │ │ - pX, │ │ │ │ - ".", │ │ │ │ - this.extension │ │ │ │ - ]; │ │ │ │ - │ │ │ │ - var url = this.url; │ │ │ │ - │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(components.join(''), url); │ │ │ │ + var zoom = this.getZoom(); │ │ │ │ + var extent = this.map.getMaxExtent(); │ │ │ │ + var deg = this.lzd / Math.pow(2, this.getZoom()); │ │ │ │ + var x = Math.floor((bounds.left - extent.left) / deg); │ │ │ │ + var y = Math.floor((bounds.bottom - extent.bottom) / deg); │ │ │ │ + if (this.map.getResolution() <= (this.lzd / 512) && │ │ │ │ + this.getZoom() <= this.zoomLevels) { │ │ │ │ + return this.getFullRequestString({ │ │ │ │ + L: zoom, │ │ │ │ + X: x, │ │ │ │ + Y: y │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + return OpenLayers.Util.getImageLocation("blank.gif"); │ │ │ │ } │ │ │ │ - return url + components.join(""); │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.KaMapCache" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.WorldWind" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Layer/Image.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -42862,532 +41774,1250 @@ │ │ │ │ getURL: function(bounds) { │ │ │ │ return this.url; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.Image" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/WMTS.js │ │ │ │ + OpenLayers/Layer/Markers.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Grid.js │ │ │ │ + * @requires OpenLayers/Layer.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.WMTS │ │ │ │ - * Instances of the WMTS class allow viewing of tiles from a service that │ │ │ │ - * implements the OGC WMTS specification version 1.0.0. │ │ │ │ + * Class: OpenLayers.Layer.Markers │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Grid> │ │ │ │ + * - <OpenLayers.Layer> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.WMTS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ +OpenLayers.Layer.Markers = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} Markers layer is never a base layer. │ │ │ │ + */ │ │ │ │ + isBaseLayer: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: markers │ │ │ │ + * {Array(<OpenLayers.Marker>)} internal marker list │ │ │ │ + */ │ │ │ │ + markers: null, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: drawn │ │ │ │ + * {Boolean} internal state of drawing. This is a workaround for the fact │ │ │ │ + * that the map does not call moveTo with a zoomChanged when the map is │ │ │ │ + * first starting up. This lets us catch the case where we have *never* │ │ │ │ + * drawn the layer, and draw it even if the zoom hasn't changed. │ │ │ │ + */ │ │ │ │ + drawn: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} The layer will be considered a base layer. Default is true. │ │ │ │ + * Constructor: OpenLayers.Layer.Markers │ │ │ │ + * Create a Markers layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ - isBaseLayer: true, │ │ │ │ + initialize: function(name, options) { │ │ │ │ + OpenLayers.Layer.prototype.initialize.apply(this, arguments); │ │ │ │ + this.markers = []; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: version │ │ │ │ - * {String} WMTS version. Default is "1.0.0". │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - version: "1.0.0", │ │ │ │ + destroy: function() { │ │ │ │ + this.clearMarkers(); │ │ │ │ + this.markers = null; │ │ │ │ + OpenLayers.Layer.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: requestEncoding │ │ │ │ - * {String} Request encoding. Can be "REST" or "KVP". Default is "KVP". │ │ │ │ + * APIMethod: setOpacity │ │ │ │ + * Sets the opacity for all the markers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * opacity - {Float} │ │ │ │ */ │ │ │ │ - requestEncoding: "KVP", │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + if (opacity != this.opacity) { │ │ │ │ + this.opacity = opacity; │ │ │ │ + for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ + this.markers[i].setOpacity(this.opacity); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: moveTo │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * zoomChanged - {Boolean} │ │ │ │ + * dragging - {Boolean} │ │ │ │ + */ │ │ │ │ + moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ + OpenLayers.Layer.prototype.moveTo.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (zoomChanged || !this.drawn) { │ │ │ │ + for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ + this.drawMarker(this.markers[i]); │ │ │ │ + } │ │ │ │ + this.drawn = true; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String|Array(String)} The base URL or request URL template for the WMTS │ │ │ │ - * service. Must be provided. Array is only supported for base URLs, not │ │ │ │ - * for request URL templates. URL templates are only supported for │ │ │ │ - * REST <requestEncoding>. │ │ │ │ + * APIMethod: addMarker │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * marker - {<OpenLayers.Marker>} │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + addMarker: function(marker) { │ │ │ │ + this.markers.push(marker); │ │ │ │ + │ │ │ │ + if (this.opacity < 1) { │ │ │ │ + marker.setOpacity(this.opacity); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.map && this.map.getExtent()) { │ │ │ │ + marker.map = this.map; │ │ │ │ + this.drawMarker(marker); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layer │ │ │ │ - * {String} The layer identifier advertised by the WMTS service. Must be │ │ │ │ - * provided. │ │ │ │ + * APIMethod: removeMarker │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * marker - {<OpenLayers.Marker>} │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + removeMarker: function(marker) { │ │ │ │ + if (this.markers && this.markers.length) { │ │ │ │ + OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ + marker.erase(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: matrixSet │ │ │ │ - * {String} One of the advertised matrix set identifiers. Must be provided. │ │ │ │ + /** │ │ │ │ + * Method: clearMarkers │ │ │ │ + * This method removes all markers from a layer. The markers are not │ │ │ │ + * destroyed by this function, but are removed from the list of markers. │ │ │ │ */ │ │ │ │ - matrixSet: null, │ │ │ │ + clearMarkers: function() { │ │ │ │ + if (this.markers != null) { │ │ │ │ + while (this.markers.length > 0) { │ │ │ │ + this.removeMarker(this.markers[0]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: style │ │ │ │ - * {String} One of the advertised layer styles. Must be provided. │ │ │ │ + * Method: drawMarker │ │ │ │ + * Calculate the pixel location for the marker, create it, and │ │ │ │ + * add it to the layer's div │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * marker - {<OpenLayers.Marker>} │ │ │ │ */ │ │ │ │ - style: null, │ │ │ │ + drawMarker: function(marker) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(marker.lonlat); │ │ │ │ + if (px == null) { │ │ │ │ + marker.display(false); │ │ │ │ + } else { │ │ │ │ + if (!marker.isDrawn()) { │ │ │ │ + var markerImg = marker.draw(px); │ │ │ │ + this.div.appendChild(markerImg); │ │ │ │ + } else if (marker.icon) { │ │ │ │ + marker.icon.moveTo(px); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: format │ │ │ │ - * {String} The image MIME type. Default is "image/jpeg". │ │ │ │ + * APIMethod: getDataExtent │ │ │ │ + * Calculates the max extent which includes all of the markers. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - format: "image/jpeg", │ │ │ │ + getDataExtent: function() { │ │ │ │ + var maxExtent = null; │ │ │ │ + │ │ │ │ + if (this.markers && (this.markers.length > 0)) { │ │ │ │ + var maxExtent = new OpenLayers.Bounds(); │ │ │ │ + for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ + var marker = this.markers[i]; │ │ │ │ + maxExtent.extend(marker.lonlat); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return maxExtent; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Markers" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/Text.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.Text │ │ │ │ + * Read Text format. Create a new instance with the <OpenLayers.Format.Text> │ │ │ │ + * constructor. This reads text which is formatted like CSV text, using │ │ │ │ + * tabs as the seperator by default. It provides parsing of data originally │ │ │ │ + * used in the MapViewerService, described on the wiki. This Format is used │ │ │ │ + * by the <OpenLayers.Layer.Text> class. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.Text = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: tileOrigin │ │ │ │ - * {<OpenLayers.LonLat>} The top-left corner of the tile matrix in map │ │ │ │ - * units. If the tile origin for each matrix in a set is different, │ │ │ │ - * the <matrixIds> should include a topLeftCorner property. If │ │ │ │ - * not provided, the tile origin will default to the top left corner │ │ │ │ - * of the layer <maxExtent>. │ │ │ │ + * APIProperty: defaultStyle │ │ │ │ + * defaultStyle allows one to control the default styling of the features. │ │ │ │ + * It should be a symbolizer hash. By default, this is set to match the │ │ │ │ + * Layer.Text behavior, which is to use the default OpenLayers Icon. │ │ │ │ */ │ │ │ │ - tileOrigin: null, │ │ │ │ + defaultStyle: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: tileFullExtent │ │ │ │ - * {<OpenLayers.Bounds>} The full extent of the tile set. If not supplied, │ │ │ │ - * the layer's <maxExtent> property will be used. │ │ │ │ + * APIProperty: extractStyles │ │ │ │ + * set to true to extract styles from the TSV files, using information │ │ │ │ + * from the image or icon, iconSize and iconOffset fields. This will result │ │ │ │ + * in features with a symbolizer (style) property set, using the │ │ │ │ + * default symbolizer specified in <defaultStyle>. Set to false if you │ │ │ │ + * wish to use a styleMap or OpenLayers.Style options to style your │ │ │ │ + * layer instead. │ │ │ │ */ │ │ │ │ - tileFullExtent: null, │ │ │ │ + extractStyles: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: formatSuffix │ │ │ │ - * {String} For REST request encoding, an image format suffix must be │ │ │ │ - * included in the request. If not provided, the suffix will be derived │ │ │ │ - * from the <format> property. │ │ │ │ + * Constructor: OpenLayers.Format.Text │ │ │ │ + * Create a new parser for TSV Text. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - formatSuffix: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + │ │ │ │ + if (options.extractStyles !== false) { │ │ │ │ + options.defaultStyle = { │ │ │ │ + 'externalGraphic': OpenLayers.Util.getImageLocation("marker.png"), │ │ │ │ + 'graphicWidth': 21, │ │ │ │ + 'graphicHeight': 25, │ │ │ │ + 'graphicXOffset': -10.5, │ │ │ │ + 'graphicYOffset': -12.5 │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + │ │ │ │ + OpenLayers.Format.prototype.initialize.apply(this, [options]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: matrixIds │ │ │ │ - * {Array} A list of tile matrix identifiers. If not provided, the matrix │ │ │ │ - * identifiers will be assumed to be integers corresponding to the │ │ │ │ - * map zoom level. If a list of strings is provided, each item should │ │ │ │ - * be the matrix identifier that corresponds to the map zoom level. │ │ │ │ - * Additionally, a list of objects can be provided. Each object should │ │ │ │ - * describe the matrix as presented in the WMTS capabilities. These │ │ │ │ - * objects should have the propertes shown below. │ │ │ │ + * APIMethod: read │ │ │ │ + * Return a list of features from a Tab Seperated Values text string. │ │ │ │ * │ │ │ │ - * Matrix properties: │ │ │ │ - * identifier - {String} The matrix identifier (required). │ │ │ │ - * scaleDenominator - {Number} The matrix scale denominator. │ │ │ │ - * topLeftCorner - {<OpenLayers.LonLat>} The top left corner of the │ │ │ │ - * matrix. Must be provided if different than the layer <tileOrigin>. │ │ │ │ - * tileWidth - {Number} The tile width for the matrix. Must be provided │ │ │ │ - * if different than the width given in the layer <tileSize>. │ │ │ │ - * tileHeight - {Number} The tile height for the matrix. Must be provided │ │ │ │ - * if different than the height given in the layer <tileSize>. │ │ │ │ + * Parameters: │ │ │ │ + * text - {String} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ */ │ │ │ │ - matrixIds: null, │ │ │ │ + read: function(text) { │ │ │ │ + var lines = text.split('\n'); │ │ │ │ + var columns; │ │ │ │ + var features = []; │ │ │ │ + // length - 1 to allow for trailing new line │ │ │ │ + for (var lcv = 0; lcv < (lines.length - 1); lcv++) { │ │ │ │ + var currLine = lines[lcv].replace(/^\s*/, '').replace(/\s*$/, ''); │ │ │ │ + │ │ │ │ + if (currLine.charAt(0) != '#') { │ │ │ │ + /* not a comment */ │ │ │ │ + │ │ │ │ + if (!columns) { │ │ │ │ + //First line is columns │ │ │ │ + columns = currLine.split('\t'); │ │ │ │ + } else { │ │ │ │ + var vals = currLine.split('\t'); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ + var attributes = {}; │ │ │ │ + var style = this.defaultStyle ? │ │ │ │ + OpenLayers.Util.applyDefaults({}, this.defaultStyle) : │ │ │ │ + null; │ │ │ │ + var icon, iconSize, iconOffset, overflow; │ │ │ │ + var set = false; │ │ │ │ + for (var valIndex = 0; valIndex < vals.length; valIndex++) { │ │ │ │ + if (vals[valIndex]) { │ │ │ │ + if (columns[valIndex] == 'point') { │ │ │ │ + var coords = vals[valIndex].split(','); │ │ │ │ + geometry.y = parseFloat(coords[0]); │ │ │ │ + geometry.x = parseFloat(coords[1]); │ │ │ │ + set = true; │ │ │ │ + } else if (columns[valIndex] == 'lat') { │ │ │ │ + geometry.y = parseFloat(vals[valIndex]); │ │ │ │ + set = true; │ │ │ │ + } else if (columns[valIndex] == 'lon') { │ │ │ │ + geometry.x = parseFloat(vals[valIndex]); │ │ │ │ + set = true; │ │ │ │ + } else if (columns[valIndex] == 'title') │ │ │ │ + attributes['title'] = vals[valIndex]; │ │ │ │ + else if (columns[valIndex] == 'image' || │ │ │ │ + columns[valIndex] == 'icon' && style) { │ │ │ │ + style['externalGraphic'] = vals[valIndex]; │ │ │ │ + } else if (columns[valIndex] == 'iconSize' && style) { │ │ │ │ + var size = vals[valIndex].split(','); │ │ │ │ + style['graphicWidth'] = parseFloat(size[0]); │ │ │ │ + style['graphicHeight'] = parseFloat(size[1]); │ │ │ │ + } else if (columns[valIndex] == 'iconOffset' && style) { │ │ │ │ + var offset = vals[valIndex].split(','); │ │ │ │ + style['graphicXOffset'] = parseFloat(offset[0]); │ │ │ │ + style['graphicYOffset'] = parseFloat(offset[1]); │ │ │ │ + } else if (columns[valIndex] == 'description') { │ │ │ │ + attributes['description'] = vals[valIndex]; │ │ │ │ + } else if (columns[valIndex] == 'overflow') { │ │ │ │ + attributes['overflow'] = vals[valIndex]; │ │ │ │ + } else { │ │ │ │ + // For StyleMap filtering, allow additional │ │ │ │ + // columns to be stored as attributes. │ │ │ │ + attributes[columns[valIndex]] = vals[valIndex]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (set) { │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, attributes, style); │ │ │ │ + features.push(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return features; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Text" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/Text.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/Markers.js │ │ │ │ + * @requires OpenLayers/Format/Text.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.Text │ │ │ │ + * This layer creates markers given data in a text file. The <location> │ │ │ │ + * property of the layer (specified as a property of the options argument │ │ │ │ + * in the <OpenLayers.Layer.Text> constructor) points to a tab delimited │ │ │ │ + * file with data used to create markers. │ │ │ │ + * │ │ │ │ + * The first row of the data file should be a header line with the column names │ │ │ │ + * of the data. Each column should be delimited by a tab space. The │ │ │ │ + * possible columns are: │ │ │ │ + * - *point* lat,lon of the point where a marker is to be placed │ │ │ │ + * - *lat* Latitude of the point where a marker is to be placed │ │ │ │ + * - *lon* Longitude of the point where a marker is to be placed │ │ │ │ + * - *icon* or *image* URL of marker icon to use. │ │ │ │ + * - *iconSize* Size of Icon to use. │ │ │ │ + * - *iconOffset* Where the top-left corner of the icon is to be placed │ │ │ │ + * relative to the latitude and longitude of the point. │ │ │ │ + * - *title* The text of the 'title' is placed inside an 'h2' marker │ │ │ │ + * inside a popup, which opens when the marker is clicked. │ │ │ │ + * - *description* The text of the 'description' is placed below the h2 │ │ │ │ + * in the popup. this can be plain text or HTML. │ │ │ │ + * │ │ │ │ + * Example text file: │ │ │ │ + * (code) │ │ │ │ + * lat lon title description iconSize iconOffset icon │ │ │ │ + * 10 20 title description 21,25 -10,-25 http://www.openlayers.org/dev/img/marker.png │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.Markers> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Text = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: dimensions │ │ │ │ - * {Array} For RESTful request encoding, extra dimensions may be specified. │ │ │ │ - * Items in this list should be property names in the <params> object. │ │ │ │ - * Values of extra dimensions will be determined from the corresponding │ │ │ │ - * values in the <params> object. │ │ │ │ + * APIProperty: location │ │ │ │ + * {String} URL of text file. Must be specified in the "options" argument │ │ │ │ + * of the constructor. Can not be changed once passed in. │ │ │ │ */ │ │ │ │ - dimensions: null, │ │ │ │ + location: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: features │ │ │ │ + * {Array(<OpenLayers.Feature>)} │ │ │ │ + */ │ │ │ │ + features: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: params │ │ │ │ - * {Object} Extra parameters to include in tile requests. For KVP │ │ │ │ - * <requestEncoding>, these properties will be encoded in the request │ │ │ │ - * query string. For REST <requestEncoding>, these properties will │ │ │ │ - * become part of the request path, with order determined by the │ │ │ │ - * <dimensions> list. │ │ │ │ + * APIProperty: formatOptions │ │ │ │ + * {Object} Hash of options which should be passed to the format when it is │ │ │ │ + * created. Must be passed in the constructor. │ │ │ │ */ │ │ │ │ - params: null, │ │ │ │ + formatOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: selectedFeature │ │ │ │ + * {<OpenLayers.Feature>} │ │ │ │ + */ │ │ │ │ + selectedFeature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomOffset │ │ │ │ - * {Number} If your cache has more levels than you want to provide │ │ │ │ - * access to with this layer, supply a zoomOffset. This zoom offset │ │ │ │ - * is added to the current map zoom level to determine the level │ │ │ │ - * for a requested tile. For example, if you supply a zoomOffset │ │ │ │ - * of 3, when the map is at the zoom 0, tiles will be requested from │ │ │ │ - * level 3 of your cache. Default is 0 (assumes cache level and map │ │ │ │ - * zoom are equivalent). Additionally, if this layer is to be used │ │ │ │ - * as an overlay and the cache has fewer zoom levels than the base │ │ │ │ - * layer, you can supply a negative zoomOffset. For example, if a │ │ │ │ - * map zoom level of 1 corresponds to your cache level zero, you would │ │ │ │ - * supply a -1 zoomOffset (and set the maxResolution of the layer │ │ │ │ - * appropriately). The zoomOffset value has no effect if complete │ │ │ │ - * matrix definitions (including scaleDenominator) are supplied in │ │ │ │ - * the <matrixIds> property. Defaults to 0 (no zoom offset). │ │ │ │ + * Constructor: OpenLayers.Layer.Text │ │ │ │ + * Create a text layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} │ │ │ │ + * options - {Object} Object with properties to be set on the layer. │ │ │ │ + * Must include <location> property. │ │ │ │ */ │ │ │ │ - zoomOffset: 0, │ │ │ │ + initialize: function(name, options) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.initialize.apply(this, arguments); │ │ │ │ + this.features = []; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: serverResolutions │ │ │ │ - * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ - * property if the map resolutions differ from the server. This │ │ │ │ - * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ - * resolutions that the server supports and that you don't want to │ │ │ │ - * provide with this layer; you can also look at <zoomOffset>, which is │ │ │ │ - * an alternative to <serverResolutions> for that specific purpose. │ │ │ │ - * (b) The map can work with resolutions that aren't supported by │ │ │ │ - * the server, i.e. that aren't in <serverResolutions>. When the │ │ │ │ - * map is displayed in such a resolution data for the closest │ │ │ │ - * server-supported resolution is loaded and the layer div is │ │ │ │ - * stretched as necessary. │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - serverResolutions: null, │ │ │ │ + destroy: function() { │ │ │ │ + // Warning: Layer.Markers.destroy() must be called prior to calling │ │ │ │ + // clearFeatures() here, otherwise we leak memory. Indeed, if │ │ │ │ + // Layer.Markers.destroy() is called after clearFeatures(), it won't be │ │ │ │ + // able to remove the marker image elements from the layer's div since │ │ │ │ + // the markers will have been destroyed by clearFeatures(). │ │ │ │ + OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ + this.clearFeatures(); │ │ │ │ + this.features = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: formatSuffixMap │ │ │ │ - * {Object} a map between WMTS 'format' request parameter and tile image file suffix │ │ │ │ + * Method: loadText │ │ │ │ + * Start the load of the Text data. Don't do this when we first add the layer, │ │ │ │ + * since we may not be visible at any point, and it would therefore be a waste. │ │ │ │ */ │ │ │ │ - formatSuffixMap: { │ │ │ │ - "image/png": "png", │ │ │ │ - "image/png8": "png", │ │ │ │ - "image/png24": "png", │ │ │ │ - "image/png32": "png", │ │ │ │ - "png": "png", │ │ │ │ - "image/jpeg": "jpg", │ │ │ │ - "image/jpg": "jpg", │ │ │ │ - "jpeg": "jpg", │ │ │ │ - "jpg": "jpg" │ │ │ │ + loadText: function() { │ │ │ │ + if (!this.loaded) { │ │ │ │ + if (this.location != null) { │ │ │ │ + │ │ │ │ + var onFail = function(e) { │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + this.events.triggerEvent("loadstart"); │ │ │ │ + OpenLayers.Request.GET({ │ │ │ │ + url: this.location, │ │ │ │ + success: this.parseData, │ │ │ │ + failure: onFail, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.loaded = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: matrix │ │ │ │ - * {Object} Matrix definition for the current map resolution. Updated by │ │ │ │ - * the <updateMatrixProperties> method. │ │ │ │ + * Method: moveTo │ │ │ │ + * If layer is visible and Text has not been loaded, load Text. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {Object} │ │ │ │ + * zoomChanged - {Object} │ │ │ │ + * minor - {Object} │ │ │ │ */ │ │ │ │ - matrix: null, │ │ │ │ + moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ + if (this.visibility && !this.loaded) { │ │ │ │ + this.loadText(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.WMTS │ │ │ │ - * Create a new WMTS layer. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var wmts = new OpenLayers.Layer.WMTS({ │ │ │ │ - * name: "My WMTS Layer", │ │ │ │ - * url: "http://example.com/wmts", │ │ │ │ - * layer: "layer_id", │ │ │ │ - * style: "default", │ │ │ │ - * matrixSet: "matrix_id" │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ + * Method: parseData │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * config - {Object} Configuration properties for the layer. │ │ │ │ - * │ │ │ │ - * Required configuration properties: │ │ │ │ - * url - {String} The base url for the service. See the <url> property. │ │ │ │ - * layer - {String} The layer identifier. See the <layer> property. │ │ │ │ - * style - {String} The layer style identifier. See the <style> property. │ │ │ │ - * matrixSet - {String} The tile matrix set identifier. See the <matrixSet> │ │ │ │ - * property. │ │ │ │ - * │ │ │ │ - * Any other documented layer properties can be provided in the config object. │ │ │ │ + * ajaxRequest - {<OpenLayers.Request.XMLHttpRequest>} │ │ │ │ */ │ │ │ │ - initialize: function(config) { │ │ │ │ + parseData: function(ajaxRequest) { │ │ │ │ + var text = ajaxRequest.responseText; │ │ │ │ │ │ │ │ - // confirm required properties are supplied │ │ │ │ - var required = { │ │ │ │ - url: true, │ │ │ │ - layer: true, │ │ │ │ - style: true, │ │ │ │ - matrixSet: true │ │ │ │ - }; │ │ │ │ - for (var prop in required) { │ │ │ │ - if (!(prop in config)) { │ │ │ │ - throw new Error("Missing property '" + prop + "' in layer configuration."); │ │ │ │ - } │ │ │ │ + var options = {}; │ │ │ │ + │ │ │ │ + OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ + │ │ │ │ + if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ + options.externalProjection = this.projection; │ │ │ │ + options.internalProjection = this.map.getProjectionObject(); │ │ │ │ } │ │ │ │ │ │ │ │ - config.params = OpenLayers.Util.upperCaseObject(config.params); │ │ │ │ - var args = [config.name, config.url, config.params, config]; │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, args); │ │ │ │ + var parser = new OpenLayers.Format.Text(options); │ │ │ │ + var features = parser.read(text); │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + var data = {}; │ │ │ │ + var feature = features[i]; │ │ │ │ + var location; │ │ │ │ + var iconSize, iconOffset; │ │ │ │ │ │ │ │ + location = new OpenLayers.LonLat(feature.geometry.x, │ │ │ │ + feature.geometry.y); │ │ │ │ │ │ │ │ - // determine format suffix (for REST) │ │ │ │ - if (!this.formatSuffix) { │ │ │ │ - this.formatSuffix = this.formatSuffixMap[this.format] || this.format.split("/").pop(); │ │ │ │ - } │ │ │ │ + if (feature.style.graphicWidth && │ │ │ │ + feature.style.graphicHeight) { │ │ │ │ + iconSize = new OpenLayers.Size( │ │ │ │ + feature.style.graphicWidth, │ │ │ │ + feature.style.graphicHeight); │ │ │ │ + } │ │ │ │ │ │ │ │ - // expand matrixIds (may be array of string or array of object) │ │ │ │ - if (this.matrixIds) { │ │ │ │ - var len = this.matrixIds.length; │ │ │ │ - if (len && typeof this.matrixIds[0] === "string") { │ │ │ │ - var ids = this.matrixIds; │ │ │ │ - this.matrixIds = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - this.matrixIds[i] = { │ │ │ │ - identifier: ids[i] │ │ │ │ - }; │ │ │ │ + // FIXME: At the moment, we only use this if we have an │ │ │ │ + // externalGraphic, because icon has no setOffset API Method. │ │ │ │ + /** │ │ │ │ + * FIXME FIRST!! │ │ │ │ + * The Text format does all sorts of parseFloating │ │ │ │ + * The result of a parseFloat for a bogus string is NaN. That │ │ │ │ + * means the three possible values here are undefined, NaN, or a │ │ │ │ + * number. The previous check was an identity check for null. This │ │ │ │ + * means it was failing for all undefined or NaN. A slightly better │ │ │ │ + * check is for undefined. An even better check is to see if the │ │ │ │ + * value is a number (see #1441). │ │ │ │ + */ │ │ │ │ + if (feature.style.graphicXOffset !== undefined && │ │ │ │ + feature.style.graphicYOffset !== undefined) { │ │ │ │ + iconOffset = new OpenLayers.Pixel( │ │ │ │ + feature.style.graphicXOffset, │ │ │ │ + feature.style.graphicYOffset); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (feature.style.externalGraphic != null) { │ │ │ │ + data.icon = new OpenLayers.Icon(feature.style.externalGraphic, │ │ │ │ + iconSize, │ │ │ │ + iconOffset); │ │ │ │ + } else { │ │ │ │ + data.icon = OpenLayers.Marker.defaultIcon(); │ │ │ │ + │ │ │ │ + //allows for the case where the image url is not │ │ │ │ + // specified but the size is. use a default icon │ │ │ │ + // but change the size │ │ │ │ + if (iconSize != null) { │ │ │ │ + data.icon.setSize(iconSize); │ │ │ │ } │ │ │ │ } │ │ │ │ - } │ │ │ │ │ │ │ │ + if ((feature.attributes.title != null) && │ │ │ │ + (feature.attributes.description != null)) { │ │ │ │ + data['popupContentHTML'] = │ │ │ │ + '<h2>' + feature.attributes.title + '</h2>' + │ │ │ │ + '<p>' + feature.attributes.description + '</p>'; │ │ │ │ + } │ │ │ │ + │ │ │ │ + data['overflow'] = feature.attributes.overflow || "auto"; │ │ │ │ + │ │ │ │ + var markerFeature = new OpenLayers.Feature(this, location, data); │ │ │ │ + this.features.push(markerFeature); │ │ │ │ + var marker = markerFeature.createMarker(); │ │ │ │ + if ((feature.attributes.title != null) && │ │ │ │ + (feature.attributes.description != null)) { │ │ │ │ + marker.events.register('click', markerFeature, this.markerClick); │ │ │ │ + } │ │ │ │ + this.addMarker(marker); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * Property: markerClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Context: │ │ │ │ + * - {<OpenLayers.Feature>} │ │ │ │ */ │ │ │ │ - setMap: function() { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + markerClick: function(evt) { │ │ │ │ + var sameMarkerClicked = (this == this.layer.selectedFeature); │ │ │ │ + this.layer.selectedFeature = (!sameMarkerClicked) ? this : null; │ │ │ │ + for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ + this.layer.map.removePopup(this.layer.map.popups[i]); │ │ │ │ + } │ │ │ │ + if (!sameMarkerClicked) { │ │ │ │ + this.layer.map.addPopup(this.createPopup()); │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateMatrixProperties │ │ │ │ - * Called when map resolution changes to update matrix related properties. │ │ │ │ + * Method: clearFeatures │ │ │ │ */ │ │ │ │ - updateMatrixProperties: function() { │ │ │ │ - this.matrix = this.getMatrix(); │ │ │ │ - if (this.matrix) { │ │ │ │ - if (this.matrix.topLeftCorner) { │ │ │ │ - this.tileOrigin = this.matrix.topLeftCorner; │ │ │ │ - } │ │ │ │ - if (this.matrix.tileWidth && this.matrix.tileHeight) { │ │ │ │ - this.tileSize = new OpenLayers.Size( │ │ │ │ - this.matrix.tileWidth, this.matrix.tileHeight │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (!this.tileOrigin) { │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat( │ │ │ │ - this.maxExtent.left, this.maxExtent.top │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (!this.tileFullExtent) { │ │ │ │ - this.tileFullExtent = this.maxExtent; │ │ │ │ + clearFeatures: function() { │ │ │ │ + if (this.features != null) { │ │ │ │ + while (this.features.length > 0) { │ │ │ │ + var feature = this.features[0]; │ │ │ │ + OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ + feature.destroy(); │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Text" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/TMS.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.TMS │ │ │ │ + * Create a layer for accessing tiles from services that conform with the │ │ │ │ + * Tile Map Service Specification │ │ │ │ + * (http://wiki.osgeo.org/wiki/Tile_Map_Service_Specification). │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var layer = new OpenLayers.Layer.TMS( │ │ │ │ + * "My Layer", // name for display in LayerSwitcher │ │ │ │ + * "http://tilecache.osgeo.org/wms-c/Basic.py/", // service endpoint │ │ │ │ + * {layername: "basic", type: "png"} // required properties │ │ │ │ + * ); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.TMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: moveTo │ │ │ │ + * APIProperty: serviceVersion │ │ │ │ + * {String} Service version for tile requests. Default is "1.0.0". │ │ │ │ + */ │ │ │ │ + serviceVersion: "1.0.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: layername │ │ │ │ + * {String} The identifier for the <TileMap> as advertised by the service. │ │ │ │ + * For example, if the service advertises a <TileMap> with │ │ │ │ + * 'href="http://tms.osgeo.org/1.0.0/vmap0"', the <layername> property │ │ │ │ + * would be set to "vmap0". │ │ │ │ + */ │ │ │ │ + layername: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} The format extension corresponding to the requested tile image │ │ │ │ + * type. This is advertised in a <TileFormat> element as the │ │ │ │ + * "extension" attribute. For example, if the service advertises a │ │ │ │ + * <TileMap> with <TileFormat width="256" height="256" mime-type="image/jpeg" extension="jpg" />, │ │ │ │ + * the <type> property would be set to "jpg". │ │ │ │ + */ │ │ │ │ + type: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} Make this layer a base layer. Default is true. Set false to │ │ │ │ + * use the layer as an overlay. │ │ │ │ + */ │ │ │ │ + isBaseLayer: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: tileOrigin │ │ │ │ + * {<OpenLayers.LonLat>} Optional origin for aligning the grid of tiles. │ │ │ │ + * If provided, requests for tiles at all resolutions will be aligned │ │ │ │ + * with this location (no tiles shall overlap this location). If │ │ │ │ + * not provided, the grid of tiles will be aligned with the bottom-left │ │ │ │ + * corner of the map's <maxExtent>. Default is ``null``. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var layer = new OpenLayers.Layer.TMS( │ │ │ │ + * "My Layer", │ │ │ │ + * "http://tilecache.osgeo.org/wms-c/Basic.py/", │ │ │ │ + * { │ │ │ │ + * layername: "basic", │ │ │ │ + * type: "png", │ │ │ │ + * // set if different than the bottom left of map.maxExtent │ │ │ │ + * tileOrigin: new OpenLayers.LonLat(-180, -90) │ │ │ │ + * } │ │ │ │ + * ); │ │ │ │ + * (end) │ │ │ │ + */ │ │ │ │ + tileOrigin: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: serverResolutions │ │ │ │ + * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ + * property if the map resolutions differ from the server. This │ │ │ │ + * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ + * resolutions that the server supports and that you don't want to │ │ │ │ + * provide with this layer; you can also look at <zoomOffset>, which is │ │ │ │ + * an alternative to <serverResolutions> for that specific purpose. │ │ │ │ + * (b) The map can work with resolutions that aren't supported by │ │ │ │ + * the server, i.e. that aren't in <serverResolutions>. When the │ │ │ │ + * map is displayed in such a resolution data for the closest │ │ │ │ + * server-supported resolution is loaded and the layer div is │ │ │ │ + * stretched as necessary. │ │ │ │ + */ │ │ │ │ + serverResolutions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomOffset │ │ │ │ + * {Number} If your cache has more zoom levels than you want to provide │ │ │ │ + * access to with this layer, supply a zoomOffset. This zoom offset │ │ │ │ + * is added to the current map zoom level to determine the level │ │ │ │ + * for a requested tile. For example, if you supply a zoomOffset │ │ │ │ + * of 3, when the map is at the zoom 0, tiles will be requested from │ │ │ │ + * level 3 of your cache. Default is 0 (assumes cache level and map │ │ │ │ + * zoom are equivalent). Using <zoomOffset> is an alternative to │ │ │ │ + * setting <serverResolutions> if you only want to expose a subset │ │ │ │ + * of the server resolutions. │ │ │ │ + */ │ │ │ │ + zoomOffset: 0, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.TMS │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * zoomChanged - {Boolean} Tells when zoom has changed, as layers have to │ │ │ │ - * do some init work in that case. │ │ │ │ - * dragging - {Boolean} │ │ │ │ + * name - {String} Title to be displayed in a <OpenLayers.Control.LayerSwitcher> │ │ │ │ + * url - {String} Service endpoint (without the version number). E.g. │ │ │ │ + * "http://tms.osgeo.org/". │ │ │ │ + * options - {Object} Additional properties to be set on the layer. The │ │ │ │ + * <layername> and <type> properties must be set here. │ │ │ │ */ │ │ │ │ - moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ - if (zoomChanged || !this.matrix) { │ │ │ │ - this.updateMatrixProperties(); │ │ │ │ - } │ │ │ │ - return OpenLayers.Layer.Grid.prototype.moveTo.apply(this, arguments); │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + var newArguments = []; │ │ │ │ + newArguments.push(name, url, {}, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: clone │ │ │ │ - * │ │ │ │ + * Create a complete copy of this layer. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ + * obj - {Object} Should only be provided by subclasses that call this │ │ │ │ + * method. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Layer.WMTS>} An exact clone of this <OpenLayers.Layer.WMTS> │ │ │ │ + * {<OpenLayers.Layer.TMS>} An exact clone of this <OpenLayers.Layer.TMS> │ │ │ │ */ │ │ │ │ clone: function(obj) { │ │ │ │ + │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.WMTS(this.options); │ │ │ │ + obj = new OpenLayers.Layer.TMS(this.name, │ │ │ │ + this.url, │ │ │ │ + this.getOptions()); │ │ │ │ } │ │ │ │ + │ │ │ │ //get all additions from superclasses │ │ │ │ obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ // copy/set any non-init, non-simple values here │ │ │ │ + │ │ │ │ return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getIdentifier │ │ │ │ - * Get the current index in the matrixIds array. │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters │ │ │ │ */ │ │ │ │ - getIdentifier: function() { │ │ │ │ - return this.getServerZoom(); │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getServerZoom(); │ │ │ │ + var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type; │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(path, url); │ │ │ │ + } │ │ │ │ + return url + path; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getMatrix │ │ │ │ - * Get the appropriate matrix definition for the current map resolution. │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * When the layer is added to a map, then we can fetch our origin │ │ │ │ + * (if we don't have one.) │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - getMatrix: function() { │ │ │ │ - var matrix; │ │ │ │ - if (!this.matrixIds || this.matrixIds.length === 0) { │ │ │ │ - matrix = { │ │ │ │ - identifier: this.getIdentifier() │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - // get appropriate matrix given the map scale if possible │ │ │ │ - if ("scaleDenominator" in this.matrixIds[0]) { │ │ │ │ - // scale denominator calculation based on WMTS spec │ │ │ │ - var denom = │ │ │ │ - OpenLayers.METERS_PER_INCH * │ │ │ │ - OpenLayers.INCHES_PER_UNIT[this.units] * │ │ │ │ - this.getServerResolution() / 0.28E-3; │ │ │ │ - var diff = Number.POSITIVE_INFINITY; │ │ │ │ - var delta; │ │ │ │ - for (var i = 0, ii = this.matrixIds.length; i < ii; ++i) { │ │ │ │ - delta = Math.abs(1 - (this.matrixIds[i].scaleDenominator / denom)); │ │ │ │ - if (delta < diff) { │ │ │ │ - diff = delta; │ │ │ │ - matrix = this.matrixIds[i]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // fall back on zoom as index │ │ │ │ - matrix = this.matrixIds[this.getIdentifier()]; │ │ │ │ - } │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + if (!this.tileOrigin) { │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, │ │ │ │ + this.map.maxExtent.bottom); │ │ │ │ } │ │ │ │ - return matrix; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.TMS" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/GeoRSS.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/Markers.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.GeoRSS │ │ │ │ + * Add GeoRSS Point features to your map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.Markers> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.GeoRSS = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: getTileInfo │ │ │ │ - * Get tile information for a given location at the current map resolution. │ │ │ │ + * Property: location │ │ │ │ + * {String} store url of text file │ │ │ │ + */ │ │ │ │ + location: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: features │ │ │ │ + * {Array(<OpenLayers.Feature>)} │ │ │ │ + */ │ │ │ │ + features: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: formatOptions │ │ │ │ + * {Object} Hash of options which should be passed to the format when it is │ │ │ │ + * created. Must be passed in the constructor. │ │ │ │ + */ │ │ │ │ + formatOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: selectedFeature │ │ │ │ + * {<OpenLayers.Feature>} │ │ │ │ + */ │ │ │ │ + selectedFeature: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: icon │ │ │ │ + * {<OpenLayers.Icon>}. This determines the Icon to be used on the map │ │ │ │ + * for this GeoRSS layer. │ │ │ │ + */ │ │ │ │ + icon: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: popupSize │ │ │ │ + * {<OpenLayers.Size>} This determines the size of GeoRSS popups. If │ │ │ │ + * not provided, defaults to 250px by 120px. │ │ │ │ + */ │ │ │ │ + popupSize: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: useFeedTitle │ │ │ │ + * {Boolean} Set layer.name to the first <title> element in the feed. Default is true. │ │ │ │ + */ │ │ │ │ + useFeedTitle: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.GeoRSS │ │ │ │ + * Create a GeoRSS Layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * loc - {<OpenLayers.LonLat} A location in map coordinates. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object with "col", "row", "i", and "j" properties. The col │ │ │ │ - * and row values are zero based tile indexes from the top left. The │ │ │ │ - * i and j values are the number of pixels to the left and top │ │ │ │ - * (respectively) of the given location within the target tile. │ │ │ │ + * name - {String} │ │ │ │ + * location - {String} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - getTileInfo: function(loc) { │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - │ │ │ │ - var fx = (loc.lon - this.tileOrigin.lon) / (res * this.tileSize.w); │ │ │ │ - var fy = (this.tileOrigin.lat - loc.lat) / (res * this.tileSize.h); │ │ │ │ + initialize: function(name, location, options) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.initialize.apply(this, [name, options]); │ │ │ │ + this.location = location; │ │ │ │ + this.features = []; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var col = Math.floor(fx); │ │ │ │ - var row = Math.floor(fy); │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + // Warning: Layer.Markers.destroy() must be called prior to calling │ │ │ │ + // clearFeatures() here, otherwise we leak memory. Indeed, if │ │ │ │ + // Layer.Markers.destroy() is called after clearFeatures(), it won't be │ │ │ │ + // able to remove the marker image elements from the layer's div since │ │ │ │ + // the markers will have been destroyed by clearFeatures(). │ │ │ │ + OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ + this.clearFeatures(); │ │ │ │ + this.features = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return { │ │ │ │ - col: col, │ │ │ │ - row: row, │ │ │ │ - i: Math.floor((fx - col) * this.tileSize.w), │ │ │ │ - j: Math.floor((fy - row) * this.tileSize.h) │ │ │ │ - }; │ │ │ │ + /** │ │ │ │ + * Method: loadRSS │ │ │ │ + * Start the load of the RSS data. Don't do this when we first add the layer, │ │ │ │ + * since we may not be visible at any point, and it would therefore be a waste. │ │ │ │ + */ │ │ │ │ + loadRSS: function() { │ │ │ │ + if (!this.loaded) { │ │ │ │ + this.events.triggerEvent("loadstart"); │ │ │ │ + OpenLayers.Request.GET({ │ │ │ │ + url: this.location, │ │ │ │ + success: this.parseData, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.loaded = true; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getURL │ │ │ │ + * Method: moveTo │ │ │ │ + * If layer is visible and RSS has not been loaded, load RSS. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A URL for the tile corresponding to the given bounds. │ │ │ │ + * bounds - {Object} │ │ │ │ + * zoomChanged - {Object} │ │ │ │ + * minor - {Object} │ │ │ │ */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var url = ""; │ │ │ │ - if (!this.tileFullExtent || this.tileFullExtent.intersectsBounds(bounds)) { │ │ │ │ + moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ + if (this.visibility && !this.loaded) { │ │ │ │ + this.loadRSS(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var info = this.getTileInfo(center); │ │ │ │ - var matrixId = this.matrix.identifier; │ │ │ │ - var dimensions = this.dimensions, │ │ │ │ - params; │ │ │ │ + /** │ │ │ │ + * Method: parseData │ │ │ │ + * Parse the data returned from the Events call. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * ajaxRequest - {<OpenLayers.Request.XMLHttpRequest>} │ │ │ │ + */ │ │ │ │ + parseData: function(ajaxRequest) { │ │ │ │ + var doc = ajaxRequest.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read(ajaxRequest.responseText); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (OpenLayers.Util.isArray(this.url)) { │ │ │ │ - url = this.selectUrl([ │ │ │ │ - this.version, this.style, this.matrixSet, │ │ │ │ - this.matrix.identifier, info.row, info.col │ │ │ │ - ].join(","), this.url); │ │ │ │ - } else { │ │ │ │ - url = this.url; │ │ │ │ + if (this.useFeedTitle) { │ │ │ │ + var name = null; │ │ │ │ + try { │ │ │ │ + name = doc.getElementsByTagNameNS('*', 'title')[0].firstChild.nodeValue; │ │ │ │ + } catch (e) { │ │ │ │ + try { │ │ │ │ + name = doc.getElementsByTagName('title')[0].firstChild.nodeValue; │ │ │ │ + } catch (e) {} │ │ │ │ + } │ │ │ │ + if (name) { │ │ │ │ + this.setName(name); │ │ │ │ } │ │ │ │ + } │ │ │ │ │ │ │ │ - if (this.requestEncoding.toUpperCase() === "REST") { │ │ │ │ - params = this.params; │ │ │ │ - if (url.indexOf("{") !== -1) { │ │ │ │ - var template = url.replace(/\{/g, "${"); │ │ │ │ - var context = { │ │ │ │ - // spec does not make clear if capital S or not │ │ │ │ - style: this.style, │ │ │ │ - Style: this.style, │ │ │ │ - TileMatrixSet: this.matrixSet, │ │ │ │ - TileMatrix: this.matrix.identifier, │ │ │ │ - TileRow: info.row, │ │ │ │ - TileCol: info.col │ │ │ │ - }; │ │ │ │ - if (dimensions) { │ │ │ │ - var dimension, i; │ │ │ │ - for (i = dimensions.length - 1; i >= 0; --i) { │ │ │ │ - dimension = dimensions[i]; │ │ │ │ - context[dimension] = params[dimension.toUpperCase()]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - url = OpenLayers.String.format(template, context); │ │ │ │ - } else { │ │ │ │ - // include 'version', 'layer' and 'style' in tile resource url │ │ │ │ - var path = this.version + "/" + this.layer + "/" + this.style + "/"; │ │ │ │ + var options = {}; │ │ │ │ │ │ │ │ - // append optional dimension path elements │ │ │ │ - if (dimensions) { │ │ │ │ - for (var i = 0; i < dimensions.length; i++) { │ │ │ │ - if (params[dimensions[i]]) { │ │ │ │ - path = path + params[dimensions[i]] + "/"; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ │ │ │ │ - // append other required path elements │ │ │ │ - path = path + this.matrixSet + "/" + this.matrix.identifier + │ │ │ │ - "/" + info.row + "/" + info.col + "." + this.formatSuffix; │ │ │ │ + if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ + options.externalProjection = this.projection; │ │ │ │ + options.internalProjection = this.map.getProjectionObject(); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (!url.match(/\/$/)) { │ │ │ │ - url = url + "/"; │ │ │ │ - } │ │ │ │ - url = url + path; │ │ │ │ + var format = new OpenLayers.Format.GeoRSS(options); │ │ │ │ + var features = format.read(doc); │ │ │ │ + │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + var data = {}; │ │ │ │ + var feature = features[i]; │ │ │ │ + │ │ │ │ + // we don't support features with no geometry in the GeoRSS │ │ │ │ + // layer at this time. │ │ │ │ + if (!feature.geometry) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var title = feature.attributes.title ? │ │ │ │ + feature.attributes.title : "Untitled"; │ │ │ │ + │ │ │ │ + var description = feature.attributes.description ? │ │ │ │ + feature.attributes.description : "No description."; │ │ │ │ + │ │ │ │ + var link = feature.attributes.link ? feature.attributes.link : ""; │ │ │ │ + │ │ │ │ + var location = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + │ │ │ │ + │ │ │ │ + data.icon = this.icon == null ? │ │ │ │ + OpenLayers.Marker.defaultIcon() : │ │ │ │ + this.icon.clone(); │ │ │ │ + │ │ │ │ + data.popupSize = this.popupSize ? │ │ │ │ + this.popupSize.clone() : │ │ │ │ + new OpenLayers.Size(250, 120); │ │ │ │ + │ │ │ │ + if (title || description) { │ │ │ │ + // we have supplemental data, store them. │ │ │ │ + data.title = title; │ │ │ │ + data.description = description; │ │ │ │ + │ │ │ │ + var contentHTML = '<div class="olLayerGeoRSSClose">[x]</div>'; │ │ │ │ + contentHTML += '<div class="olLayerGeoRSSTitle">'; │ │ │ │ + if (link) { │ │ │ │ + contentHTML += '<a class="link" href="' + link + '" target="_blank">'; │ │ │ │ } │ │ │ │ - } else if (this.requestEncoding.toUpperCase() === "KVP") { │ │ │ │ + contentHTML += title; │ │ │ │ + if (link) { │ │ │ │ + contentHTML += '</a>'; │ │ │ │ + } │ │ │ │ + contentHTML += '</div>'; │ │ │ │ + contentHTML += '<div style="" class="olLayerGeoRSSDescription">'; │ │ │ │ + contentHTML += description; │ │ │ │ + contentHTML += '</div>'; │ │ │ │ + data['popupContentHTML'] = contentHTML; │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature(this, location, data); │ │ │ │ + this.features.push(feature); │ │ │ │ + var marker = feature.createMarker(); │ │ │ │ + marker.events.register('click', feature, this.markerClick); │ │ │ │ + this.addMarker(marker); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // assemble all required parameters │ │ │ │ - params = { │ │ │ │ - SERVICE: "WMTS", │ │ │ │ - REQUEST: "GetTile", │ │ │ │ - VERSION: this.version, │ │ │ │ - LAYER: this.layer, │ │ │ │ - STYLE: this.style, │ │ │ │ - TILEMATRIXSET: this.matrixSet, │ │ │ │ - TILEMATRIX: this.matrix.identifier, │ │ │ │ - TILEROW: info.row, │ │ │ │ - TILECOL: info.col, │ │ │ │ - FORMAT: this.format │ │ │ │ - }; │ │ │ │ - url = OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, [params]); │ │ │ │ + /** │ │ │ │ + * Method: markerClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + markerClick: function(evt) { │ │ │ │ + var sameMarkerClicked = (this == this.layer.selectedFeature); │ │ │ │ + this.layer.selectedFeature = (!sameMarkerClicked) ? this : null; │ │ │ │ + for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ + this.layer.map.removePopup(this.layer.map.popups[i]); │ │ │ │ + } │ │ │ │ + if (!sameMarkerClicked) { │ │ │ │ + var popup = this.createPopup(); │ │ │ │ + OpenLayers.Event.observe(popup.div, "click", │ │ │ │ + OpenLayers.Function.bind(function() { │ │ │ │ + for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ + this.layer.map.removePopup(this.layer.map.popups[i]); │ │ │ │ + } │ │ │ │ + }, this) │ │ │ │ + ); │ │ │ │ + this.layer.map.addPopup(popup); │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Method: clearFeatures │ │ │ │ + * Destroy all features in this layer. │ │ │ │ + */ │ │ │ │ + clearFeatures: function() { │ │ │ │ + if (this.features != null) { │ │ │ │ + while (this.features.length > 0) { │ │ │ │ + var feature = this.features[0]; │ │ │ │ + OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ + feature.destroy(); │ │ │ │ } │ │ │ │ } │ │ │ │ - return url; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.GeoRSS" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/TileCache.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.TileCache │ │ │ │ + * A read only TileCache layer. Used to requests tiles cached by TileCache in │ │ │ │ + * a web accessible cache. This means that you have to pre-populate your │ │ │ │ + * cache before this layer can be used. It is meant only to read tiles │ │ │ │ + * created by TileCache, and not to make calls to TileCache for tile │ │ │ │ + * creation. Create a new instance with the │ │ │ │ + * <OpenLayers.Layer.TileCache> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.TileCache = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} Treat this layer as a base layer. Default is true. │ │ │ │ + */ │ │ │ │ + isBaseLayer: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: format │ │ │ │ + * {String} Mime type of the images returned. Default is image/png. │ │ │ │ + */ │ │ │ │ + format: 'image/png', │ │ │ │ + │ │ │ │ /** │ │ │ │ - * APIMethod: mergeNewParams │ │ │ │ - * Extend the existing layer <params> with new properties. Tiles will be │ │ │ │ - * reloaded with updated params in the request. │ │ │ │ + * APIProperty: serverResolutions │ │ │ │ + * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ + * property if the map resolutions differ from the server. This │ │ │ │ + * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ + * resolutions that the server supports and that you don't want to │ │ │ │ + * provide with this layer. (b) The map can work with resolutions │ │ │ │ + * that aren't supported by the server, i.e. that aren't in │ │ │ │ + * <serverResolutions>. When the map is displayed in such a resolution │ │ │ │ + * data for the closest server-supported resolution is loaded and the │ │ │ │ + * layer div is stretched as necessary. │ │ │ │ + */ │ │ │ │ + serverResolutions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.TileCache │ │ │ │ + * Create a new read only TileCache layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} Name of the layer displayed in the interface │ │ │ │ + * url - {String} Location of the web accessible cache (not the location of │ │ │ │ + * your tilecache script!) │ │ │ │ + * layername - {String} Layer name as defined in the TileCache │ │ │ │ + * configuration │ │ │ │ + * options - {Object} Optional object with properties to be set on the │ │ │ │ + * layer. Note that you should speficy your resolutions to match │ │ │ │ + * your TileCache configuration. This can be done by setting │ │ │ │ + * the resolutions array directly (here or on the map), by setting │ │ │ │ + * maxResolution and numZoomLevels, or by using scale based properties. │ │ │ │ + */ │ │ │ │ + initialize: function(name, url, layername, options) { │ │ │ │ + this.layername = layername; │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, │ │ │ │ + [name, url, {}, options]); │ │ │ │ + this.extension = this.format.split('/')[1].toLowerCase(); │ │ │ │ + this.extension = (this.extension == 'jpg') ? 'jpeg' : this.extension; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * obj - {Object} │ │ │ │ * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.TileCache>} An exact clone of this │ │ │ │ + * <OpenLayers.Layer.TileCache> │ │ │ │ + */ │ │ │ │ + clone: function(obj) { │ │ │ │ + │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.TileCache(this.name, │ │ │ │ + this.url, │ │ │ │ + this.layername, │ │ │ │ + this.getOptions()); │ │ │ │ + } │ │ │ │ + │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * newParams - {Object} Properties to extend to existing <params>. │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as parameters. │ │ │ │ */ │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - if (this.requestEncoding.toUpperCase() === "KVP") { │ │ │ │ - return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply( │ │ │ │ - this, [OpenLayers.Util.upperCaseObject(newParams)] │ │ │ │ - ); │ │ │ │ + getURL: function(bounds) { │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var bbox = this.maxExtent; │ │ │ │ + var size = this.tileSize; │ │ │ │ + var tileX = Math.round((bounds.left - bbox.left) / (res * size.w)); │ │ │ │ + var tileY = Math.round((bounds.bottom - bbox.bottom) / (res * size.h)); │ │ │ │ + var tileZ = this.serverResolutions != null ? │ │ │ │ + OpenLayers.Util.indexOf(this.serverResolutions, res) : │ │ │ │ + this.map.getZoom(); │ │ │ │ + │ │ │ │ + var components = [ │ │ │ │ + this.layername, │ │ │ │ + OpenLayers.Number.zeroPad(tileZ, 2), │ │ │ │ + OpenLayers.Number.zeroPad(parseInt(tileX / 1000000), 3), │ │ │ │ + OpenLayers.Number.zeroPad((parseInt(tileX / 1000) % 1000), 3), │ │ │ │ + OpenLayers.Number.zeroPad((parseInt(tileX) % 1000), 3), │ │ │ │ + OpenLayers.Number.zeroPad(parseInt(tileY / 1000000), 3), │ │ │ │ + OpenLayers.Number.zeroPad((parseInt(tileY / 1000) % 1000), 3), │ │ │ │ + OpenLayers.Number.zeroPad((parseInt(tileY) % 1000), 3) + '.' + this.extension │ │ │ │ + ]; │ │ │ │ + var path = components.join('/'); │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(path, url); │ │ │ │ } │ │ │ │ + url = (url.charAt(url.length - 1) == '/') ? url : url + '/'; │ │ │ │ + return url + path; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.WMTS" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.TileCache" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Layer/MapGuide.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -43830,10452 +43460,10316 @@ │ │ │ │ requestString += tilePath; │ │ │ │ return requestString; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.MapGuide" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ + OpenLayers/Layer/PointTrack.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Layer/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.Vector.RootContainer │ │ │ │ - * A special layer type to combine multiple vector layers inside a single │ │ │ │ - * renderer root container. This class is not supposed to be instantiated │ │ │ │ - * from user space, it is a helper class for controls that require event │ │ │ │ - * processing for multiple vector layers. │ │ │ │ + * Class: OpenLayers.Layer.PointTrack │ │ │ │ + * Vector layer to display ordered point features as a line, creating one │ │ │ │ + * LineString feature for each pair of two points. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Vector> │ │ │ │ + * - <OpenLayers.Layer.Vector> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ +OpenLayers.Layer.PointTrack = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: displayInLayerSwitcher │ │ │ │ - * Set to false for this layer type │ │ │ │ + * APIProperty: dataFrom │ │ │ │ + * {<OpenLayers.Layer.PointTrack.TARGET_NODE>} or │ │ │ │ + * {<OpenLayers.Layer.PointTrack.SOURCE_NODE>} optional. If the lines │ │ │ │ + * should get the data/attributes from one of the two points it is │ │ │ │ + * composed of, which one should it be? │ │ │ │ */ │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ + dataFrom: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * Layers that are attached to this container. Required config option. │ │ │ │ + * APIProperty: styleFrom │ │ │ │ + * {<OpenLayers.Layer.PointTrack.TARGET_NODE>} or │ │ │ │ + * {<OpenLayers.Layer.PointTrack.SOURCE_NODE>} optional. If the lines │ │ │ │ + * should get the style from one of the two points it is composed of, │ │ │ │ + * which one should it be? │ │ │ │ */ │ │ │ │ - layers: null, │ │ │ │ + styleFrom: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Vector.RootContainer │ │ │ │ - * Create a new root container for multiple vector layer. This constructor │ │ │ │ - * is not supposed to be used from user space, it is only to be used by │ │ │ │ - * controls that need feature selection across multiple vector layers. │ │ │ │ + * Constructor: OpenLayers.PointTrack │ │ │ │ + * Constructor for a new OpenLayers.PointTrack instance. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} A name for the layer │ │ │ │ - * options - {Object} Optional object with non-default properties to set on │ │ │ │ - * the layer. │ │ │ │ - * │ │ │ │ - * Required options properties: │ │ │ │ - * layers - {Array(<OpenLayers.Layer.Vector>)} The layers managed by this │ │ │ │ - * container │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Vector.RootContainer>} A new vector layer root │ │ │ │ - * container │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: display │ │ │ │ + * name - {String} name of the layer │ │ │ │ + * options - {Object} Optional object with properties to tag onto the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - display: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getFeatureFromEvent │ │ │ │ - * walk through the layers to find the feature returned by the event │ │ │ │ + * APIMethod: addNodes │ │ │ │ + * Adds point features that will be used to create lines from, using point │ │ │ │ + * pairs. The first point of a pair will be the source node, the second │ │ │ │ + * will be the target node. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} event object with a feature property │ │ │ │ + * pointFeatures - {Array(<OpenLayers.Feature>)} │ │ │ │ + * options - {Object} │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ + * Supported options: │ │ │ │ + * silent - {Boolean} true to suppress (before)feature(s)added events │ │ │ │ */ │ │ │ │ - getFeatureFromEvent: function(evt) { │ │ │ │ - var layers = this.layers; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0; i < layers.length; i++) { │ │ │ │ - feature = layers[i].getFeatureFromEvent(evt); │ │ │ │ - if (feature) { │ │ │ │ - return feature; │ │ │ │ + addNodes: function(pointFeatures, options) { │ │ │ │ + if (pointFeatures.length < 2) { │ │ │ │ + throw new Error("At least two point features have to be added to " + │ │ │ │ + "create a line from"); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var lines = new Array(pointFeatures.length - 1); │ │ │ │ + │ │ │ │ + var pointFeature, startPoint, endPoint; │ │ │ │ + for (var i = 0, len = pointFeatures.length; i < len; i++) { │ │ │ │ + pointFeature = pointFeatures[i]; │ │ │ │ + endPoint = pointFeature.geometry; │ │ │ │ + │ │ │ │ + if (!endPoint) { │ │ │ │ + var lonlat = pointFeature.lonlat; │ │ │ │ + endPoint = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ + } else if (endPoint.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ + throw new TypeError("Only features with point geometries are supported."); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (i > 0) { │ │ │ │ + var attributes = (this.dataFrom != null) ? │ │ │ │ + (pointFeatures[i + this.dataFrom].data || │ │ │ │ + pointFeatures[i + this.dataFrom].attributes) : │ │ │ │ + null; │ │ │ │ + var style = (this.styleFrom != null) ? │ │ │ │ + (pointFeatures[i + this.styleFrom].style) : │ │ │ │ + null; │ │ │ │ + var line = new OpenLayers.Geometry.LineString([startPoint, │ │ │ │ + endPoint │ │ │ │ + ]); │ │ │ │ + │ │ │ │ + lines[i - 1] = new OpenLayers.Feature.Vector(line, attributes, │ │ │ │ + style); │ │ │ │ } │ │ │ │ + │ │ │ │ + startPoint = endPoint; │ │ │ │ } │ │ │ │ + │ │ │ │ + this.addFeatures(lines, options); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.PointTrack" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Layer.PointTrack.SOURCE_NODE │ │ │ │ + * {Number} value for <OpenLayers.Layer.PointTrack.dataFrom> and │ │ │ │ + * <OpenLayers.Layer.PointTrack.styleFrom> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.PointTrack.SOURCE_NODE = -1; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Layer.PointTrack.TARGET_NODE │ │ │ │ + * {Number} value for <OpenLayers.Layer.PointTrack.dataFrom> and │ │ │ │ + * <OpenLayers.Layer.PointTrack.styleFrom> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.PointTrack.TARGET_NODE = 0; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Layer.PointTrack.dataFrom │ │ │ │ + * {Object} with the following keys - *deprecated* │ │ │ │ + * - SOURCE_NODE: take data/attributes from the source node of the line │ │ │ │ + * - TARGET_NODE: take data/attributes from the target node of the line │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.PointTrack.dataFrom = { │ │ │ │ + 'SOURCE_NODE': -1, │ │ │ │ + 'TARGET_NODE': 0 │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/OSM.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/XYZ.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.OSM │ │ │ │ + * This layer allows accessing OpenStreetMap tiles. By default the OpenStreetMap │ │ │ │ + * hosted tile.openstreetmap.org Mapnik tileset is used. If you wish to use │ │ │ │ + * a different layer instead, you need to provide a different │ │ │ │ + * URL to the constructor. Here's an example for using OpenCycleMap: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.XYZ> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} The layer name. Defaults to "OpenStreetMap" if the first │ │ │ │ + * argument to the constructor is null or undefined. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ - this.collectRoots(); │ │ │ │ - map.events.register("changelayer", this, this.handleChangeLayer); │ │ │ │ - }, │ │ │ │ + name: "OpenStreetMap", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} The tileset URL scheme. Defaults to │ │ │ │ + * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png │ │ │ │ + * (the official OSM tileset) if the second argument to the constructor │ │ │ │ + * is null or undefined. To use another tileset you can have something │ │ │ │ + * like this: │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - removeMap: function(map) { │ │ │ │ - map.events.unregister("changelayer", this, this.handleChangeLayer); │ │ │ │ - this.resetRoots(); │ │ │ │ - OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + url: [ │ │ │ │ + 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ + 'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ + 'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png' │ │ │ │ + ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: collectRoots │ │ │ │ - * Collects the root nodes of all layers this control is configured with │ │ │ │ - * and moveswien the nodes to this control's layer │ │ │ │ + * Property: attribution │ │ │ │ + * {String} The layer attribution. │ │ │ │ */ │ │ │ │ - collectRoots: function() { │ │ │ │ - var layer; │ │ │ │ - // walk through all map layers, because we want to keep the order │ │ │ │ - for (var i = 0; i < this.map.layers.length; ++i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ - layer.renderer.moveRoot(this.renderer); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: resetRoots │ │ │ │ - * Resets the root nodes back into the layers they belong to. │ │ │ │ + * Property: sphericalMercator │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - resetRoots: function() { │ │ │ │ - var layer; │ │ │ │ - for (var i = 0; i < this.layers.length; ++i) { │ │ │ │ - layer = this.layers[i]; │ │ │ │ - if (this.renderer && layer.renderer.getRenderLayerId() == this.id) { │ │ │ │ - this.renderer.moveRoot(layer.renderer); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + sphericalMercator: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleChangeLayer │ │ │ │ - * Event handler for the map's changelayer event. We need to rebuild │ │ │ │ - * this container's layer dom if order of one of its layers changes. │ │ │ │ - * This handler is added with the setMap method, and removed with the │ │ │ │ - * removeMap method. │ │ │ │ - * │ │ │ │ + * Property: wrapDateLine │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + wrapDateLine: true, │ │ │ │ + │ │ │ │ + /** APIProperty: tileOptions │ │ │ │ + * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ + * created by this Layer. Default is │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: 'anonymous'} │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * When using OSM tilesets other than the default ones, it may be │ │ │ │ + * necessary to set this to │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: null} │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * if the server does not send Access-Control-Allow-Origin headers. │ │ │ │ + */ │ │ │ │ + tileOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.OSM │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ + * name - {String} The layer name. │ │ │ │ + * url - {String} The tileset URL scheme. │ │ │ │ + * options - {Object} Configuration options for the layer. Any inherited │ │ │ │ + * layer option can be set in this object (e.g. │ │ │ │ + * <OpenLayers.Layer.Grid.buffer>). │ │ │ │ */ │ │ │ │ - handleChangeLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (evt.property == "order" && │ │ │ │ - OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ - this.resetRoots(); │ │ │ │ - this.collectRoots(); │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: 'anonymous' │ │ │ │ + }, this.options && this.options.tileOptions); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: clone │ │ │ │ + */ │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.OSM( │ │ │ │ + this.name, this.url, this.getOptions()); │ │ │ │ } │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Google/v3.js │ │ │ │ + OpenLayers/Layer/ArcGIS93Rest.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Google.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: OpenLayers.Layer.Google.v3 │ │ │ │ - * │ │ │ │ - * Mixin providing functionality specific to the Google Maps API v3. │ │ │ │ - * │ │ │ │ - * To use this layer, you must include the GMaps v3 API in your html. │ │ │ │ + * Class: OpenLayers.Layer.ArcGIS93Rest │ │ │ │ + * Instances of OpenLayers.Layer.ArcGIS93Rest are used to display data from │ │ │ │ + * ESRI ArcGIS Server 9.3 (and up?) Mapping Services using the REST API. │ │ │ │ + * Create a new ArcGIS93Rest layer with the <OpenLayers.Layer.ArcGIS93Rest> │ │ │ │ + * constructor. More detail on the REST API is available at │ │ │ │ + * http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/index.html ; │ │ │ │ + * specifically, the URL provided to this layer should be an export service │ │ │ │ + * URL: http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/export.html │ │ │ │ * │ │ │ │ - * Note that this layer configures the google.maps.map object with the │ │ │ │ - * "disableDefaultUI" option set to true. Using UI controls that the Google │ │ │ │ - * Maps API provides is not supported by the OpenLayers API. │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Google.v3 = { │ │ │ │ +OpenLayers.Layer.ArcGIS93Rest = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: DEFAULTS │ │ │ │ - * {Object} It is not recommended to change the properties set here. Note │ │ │ │ - * that Google.v3 layers only work when sphericalMercator is set to true. │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * { │ │ │ │ - * sphericalMercator: true, │ │ │ │ - * projection: "EPSG:900913" │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ + * Constant: DEFAULT_PARAMS │ │ │ │ + * {Object} Hashtable of default parameter key/value pairs │ │ │ │ */ │ │ │ │ - DEFAULTS: { │ │ │ │ - sphericalMercator: true, │ │ │ │ - projection: "EPSG:900913" │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + format: "png" │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: animationEnabled │ │ │ │ - * {Boolean} If set to true, the transition between zoom levels will be │ │ │ │ - * animated (if supported by the GMaps API for the device used). Set to │ │ │ │ - * false to match the zooming experience of other layer types. Default │ │ │ │ - * is true. Note that the GMaps API does not give us control over zoom │ │ │ │ - * animation, so if set to false, when zooming, this will make the │ │ │ │ - * layer temporarily invisible, wait until GMaps reports the map being │ │ │ │ - * idle, and make it visible again. The result will be a blank layer │ │ │ │ - * for a few moments while zooming. │ │ │ │ - */ │ │ │ │ - animationEnabled: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: loadMapObject │ │ │ │ - * Load the GMap and register appropriate event listeners. │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} Default is true for ArcGIS93Rest layer │ │ │ │ */ │ │ │ │ - loadMapObject: function() { │ │ │ │ - if (!this.type) { │ │ │ │ - this.type = google.maps.MapTypeId.ROADMAP; │ │ │ │ - } │ │ │ │ - var mapObject; │ │ │ │ - var cache = OpenLayers.Layer.Google.cache[this.map.id]; │ │ │ │ - if (cache) { │ │ │ │ - // there are already Google layers added to this map │ │ │ │ - mapObject = cache.mapObject; │ │ │ │ - // increment the layer count │ │ │ │ - ++cache.count; │ │ │ │ - } else { │ │ │ │ - // this is the first Google layer for this map │ │ │ │ - // create GMap │ │ │ │ - var center = this.map.getCenter(); │ │ │ │ - var container = document.createElement('div'); │ │ │ │ - container.className = "olForeignContainer"; │ │ │ │ - container.style.width = '100%'; │ │ │ │ - container.style.height = '100%'; │ │ │ │ - mapObject = new google.maps.Map(container, { │ │ │ │ - center: center ? │ │ │ │ - new google.maps.LatLng(center.lat, center.lon) : new google.maps.LatLng(0, 0), │ │ │ │ - zoom: this.map.getZoom() || 0, │ │ │ │ - mapTypeId: this.type, │ │ │ │ - disableDefaultUI: true, │ │ │ │ - keyboardShortcuts: false, │ │ │ │ - draggable: false, │ │ │ │ - disableDoubleClickZoom: true, │ │ │ │ - scrollwheel: false, │ │ │ │ - streetViewControl: false │ │ │ │ - }); │ │ │ │ - var googleControl = document.createElement('div'); │ │ │ │ - googleControl.style.width = '100%'; │ │ │ │ - googleControl.style.height = '100%'; │ │ │ │ - mapObject.controls[google.maps.ControlPosition.TOP_LEFT].push(googleControl); │ │ │ │ - │ │ │ │ - // cache elements for use by any other google layers added to │ │ │ │ - // this same map │ │ │ │ - cache = { │ │ │ │ - googleControl: googleControl, │ │ │ │ - mapObject: mapObject, │ │ │ │ - count: 1 │ │ │ │ - }; │ │ │ │ - OpenLayers.Layer.Google.cache[this.map.id] = cache; │ │ │ │ - } │ │ │ │ - this.mapObject = mapObject; │ │ │ │ - this.setGMapVisibility(this.visibility); │ │ │ │ - }, │ │ │ │ + isBaseLayer: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: onMapResize │ │ │ │ - */ │ │ │ │ - onMapResize: function() { │ │ │ │ - if (this.visibility) { │ │ │ │ - google.maps.event.trigger(this.mapObject, "resize"); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setGMapVisibility │ │ │ │ - * Display the GMap container and associated elements. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Layer.ArcGIS93Rest │ │ │ │ + * Create a new ArcGIS93Rest layer object. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var arcims = new OpenLayers.Layer.ArcGIS93Rest("MyName", │ │ │ │ + * "http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Specialty/ESRI_StateCityHighway_USA/MapServer/export", │ │ │ │ + * { │ │ │ │ + * layers: "0,1,2" │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * visible - {Boolean} Display the GMap elements. │ │ │ │ + * name - {String} A name for the layer │ │ │ │ + * url - {String} Base url for the ArcGIS server REST service │ │ │ │ + * options - {Object} An object with key/value pairs representing the │ │ │ │ + * options and option values. │ │ │ │ + * │ │ │ │ + * Valid Options: │ │ │ │ + * format - {String} MIME type of desired image type. │ │ │ │ + * layers - {String} Comma-separated list of layers to display. │ │ │ │ + * srs - {String} Projection ID. │ │ │ │ */ │ │ │ │ - setGMapVisibility: function(visible) { │ │ │ │ - var cache = OpenLayers.Layer.Google.cache[this.map.id]; │ │ │ │ - var map = this.map; │ │ │ │ - if (cache) { │ │ │ │ - var type = this.type; │ │ │ │ - var layers = map.layers; │ │ │ │ - var layer; │ │ │ │ - for (var i = layers.length - 1; i >= 0; --i) { │ │ │ │ - layer = layers[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Google && │ │ │ │ - layer.visibility === true && layer.inRange === true) { │ │ │ │ - type = layer.type; │ │ │ │ - visible = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + var newArguments = []; │ │ │ │ + //uppercase params │ │ │ │ + params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ + newArguments.push(name, url, params, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ + OpenLayers.Util.applyDefaults( │ │ │ │ + this.params, │ │ │ │ + OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS) │ │ │ │ + ); │ │ │ │ + │ │ │ │ + //layer is transparent │ │ │ │ + if (this.params.TRANSPARENT && │ │ │ │ + this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ + │ │ │ │ + // unless explicitly set in options, make layer an overlay │ │ │ │ + if ((options == null) || (!options.isBaseLayer)) { │ │ │ │ + this.isBaseLayer = false; │ │ │ │ } │ │ │ │ - var container = this.mapObject.getDiv(); │ │ │ │ - if (visible === true) { │ │ │ │ - if (container.parentNode !== map.div) { │ │ │ │ - if (!cache.rendered) { │ │ │ │ - var me = this; │ │ │ │ - google.maps.event.addListenerOnce(this.mapObject, 'tilesloaded', function() { │ │ │ │ - cache.rendered = true; │ │ │ │ - me.setGMapVisibility(me.getVisibility()); │ │ │ │ - me.moveTo(me.map.getCenter()); │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - map.div.appendChild(container); │ │ │ │ - cache.googleControl.appendChild(map.viewPortDiv); │ │ │ │ - google.maps.event.trigger(this.mapObject, 'resize'); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.mapObject.setMapTypeId(type); │ │ │ │ - } else if (cache.googleControl.hasChildNodes()) { │ │ │ │ - map.div.appendChild(map.viewPortDiv); │ │ │ │ - map.div.removeChild(container); │ │ │ │ + │ │ │ │ + // jpegs can never be transparent, so intelligently switch the │ │ │ │ + // format, depending on the browser's capabilities │ │ │ │ + if (this.params.FORMAT == "jpg") { │ │ │ │ + this.params.FORMAT = OpenLayers.Util.alphaHack() ? "gif" : │ │ │ │ + "png"; │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getMapContainer │ │ │ │ - * │ │ │ │ + * Method: clone │ │ │ │ + * Create a clone of this layer │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} the GMap container's div │ │ │ │ + * {<OpenLayers.Layer.ArcGIS93Rest>} An exact clone of this layer │ │ │ │ */ │ │ │ │ - getMapContainer: function() { │ │ │ │ - return this.mapObject.getDiv(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - // │ │ │ │ - // TRANSLATION: MapObject Bounds <-> OpenLayers.Bounds │ │ │ │ - // │ │ │ │ + clone: function(obj) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getMapObjectBoundsFromOLBounds │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * olBounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} A MapObject Bounds, translated from olBounds │ │ │ │ - * Returns null if null value is passed in │ │ │ │ - */ │ │ │ │ - getMapObjectBoundsFromOLBounds: function(olBounds) { │ │ │ │ - var moBounds = null; │ │ │ │ - if (olBounds != null) { │ │ │ │ - var sw = this.sphericalMercator ? │ │ │ │ - this.inverseMercator(olBounds.bottom, olBounds.left) : │ │ │ │ - new OpenLayers.LonLat(olBounds.bottom, olBounds.left); │ │ │ │ - var ne = this.sphericalMercator ? │ │ │ │ - this.inverseMercator(olBounds.top, olBounds.right) : │ │ │ │ - new OpenLayers.LonLat(olBounds.top, olBounds.right); │ │ │ │ - moBounds = new google.maps.LatLngBounds( │ │ │ │ - new google.maps.LatLng(sw.lat, sw.lon), │ │ │ │ - new google.maps.LatLng(ne.lat, ne.lon) │ │ │ │ - ); │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.ArcGIS93Rest(this.name, │ │ │ │ + this.url, │ │ │ │ + this.params, │ │ │ │ + this.getOptions()); │ │ │ │ } │ │ │ │ - return moBounds; │ │ │ │ - }, │ │ │ │ │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ │ │ │ │ - /************************************ │ │ │ │ - * * │ │ │ │ - * MapObject Interface Controls * │ │ │ │ - * * │ │ │ │ - ************************************/ │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // LonLat - Pixel Translation │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getMapObjectLonLatFromMapObjectPixel │ │ │ │ - * │ │ │ │ + * Method: getURL │ │ │ │ + * Return an image url this layer. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * moPixel - {Object} MapObject Pixel format │ │ │ │ - * │ │ │ │ + * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the │ │ │ │ + * request. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Object} MapObject LonLat translated from MapObject Pixel │ │ │ │ + * {String} A string with the map image's url. │ │ │ │ */ │ │ │ │ - getMapObjectLonLatFromMapObjectPixel: function(moPixel) { │ │ │ │ - var size = this.map.getSize(); │ │ │ │ - var lon = this.getLongitudeFromMapObjectLonLat(this.mapObject.center); │ │ │ │ - var lat = this.getLatitudeFromMapObjectLonLat(this.mapObject.center); │ │ │ │ - var res = this.map.getResolution(); │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ │ │ │ │ - var delta_x = moPixel.x - (size.w / 2); │ │ │ │ - var delta_y = moPixel.y - (size.h / 2); │ │ │ │ + // ArcGIS Server only wants the numeric portion of the projection ID. │ │ │ │ + var projWords = this.projection.getCode().split(":"); │ │ │ │ + var srid = projWords[projWords.length - 1]; │ │ │ │ │ │ │ │ - var lonlat = new OpenLayers.LonLat( │ │ │ │ - lon + delta_x * res, │ │ │ │ - lat - delta_y * res │ │ │ │ - ); │ │ │ │ + var imageSize = this.getImageSize(); │ │ │ │ + var newParams = { │ │ │ │ + 'BBOX': bounds.toBBOX(), │ │ │ │ + 'SIZE': imageSize.w + "," + imageSize.h, │ │ │ │ + // We always want image, the other options were json, image with a whole lotta html around it, etc. │ │ │ │ + 'F': "image", │ │ │ │ + 'BBOXSR': srid, │ │ │ │ + 'IMAGESR': srid │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (this.wrapDateLine) { │ │ │ │ - lonlat = lonlat.wrapDateLine(this.maxExtent); │ │ │ │ + // Now add the filter parameters. │ │ │ │ + if (this.layerDefs) { │ │ │ │ + var layerDefStrList = []; │ │ │ │ + var layerID; │ │ │ │ + for (layerID in this.layerDefs) { │ │ │ │ + if (this.layerDefs.hasOwnProperty(layerID)) { │ │ │ │ + if (this.layerDefs[layerID]) { │ │ │ │ + layerDefStrList.push(layerID); │ │ │ │ + layerDefStrList.push(":"); │ │ │ │ + layerDefStrList.push(this.layerDefs[layerID]); │ │ │ │ + layerDefStrList.push(";"); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (layerDefStrList.length > 0) { │ │ │ │ + newParams['LAYERDEFS'] = layerDefStrList.join(""); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return this.getMapObjectLonLatFromLonLat(lonlat.lon, lonlat.lat); │ │ │ │ + var requestString = this.getFullRequestString(newParams); │ │ │ │ + return requestString; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getMapObjectPixelFromMapObjectLonLat │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * moLonLat - {Object} MapObject LonLat format │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} MapObject Pixel transtlated from MapObject LonLat │ │ │ │ - */ │ │ │ │ - getMapObjectPixelFromMapObjectLonLat: function(moLonLat) { │ │ │ │ - var lon = this.getLongitudeFromMapObjectLonLat(moLonLat); │ │ │ │ - var lat = this.getLatitudeFromMapObjectLonLat(moLonLat); │ │ │ │ - var res = this.map.getResolution(); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - return this.getMapObjectPixelFromXY((1 / res * (lon - extent.left)), │ │ │ │ - (1 / res * (extent.top - lat))); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setMapObjectCenter │ │ │ │ - * Set the mapObject to the specified center and zoom │ │ │ │ - * │ │ │ │ + * Method: setLayerFilter │ │ │ │ + * addTile creates a tile, initializes it, and adds it to the layer div. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * center - {Object} MapObject LonLat format │ │ │ │ - * zoom - {int} MapObject zoom format │ │ │ │ + * id - {String} The id of the layer to which the filter applies. │ │ │ │ + * queryDef - {String} A sql-ish query filter, for more detail see the ESRI │ │ │ │ + * documentation at http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/export.html │ │ │ │ */ │ │ │ │ - setMapObjectCenter: function(center, zoom) { │ │ │ │ - if (this.animationEnabled === false && zoom != this.mapObject.zoom) { │ │ │ │ - var mapContainer = this.getMapContainer(); │ │ │ │ - google.maps.event.addListenerOnce( │ │ │ │ - this.mapObject, │ │ │ │ - "idle", │ │ │ │ - function() { │ │ │ │ - mapContainer.style.visibility = ""; │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - mapContainer.style.visibility = "hidden"; │ │ │ │ + setLayerFilter: function(id, queryDef) { │ │ │ │ + if (!this.layerDefs) { │ │ │ │ + this.layerDefs = {}; │ │ │ │ + } │ │ │ │ + if (queryDef) { │ │ │ │ + this.layerDefs[id] = queryDef; │ │ │ │ + } else { │ │ │ │ + delete this.layerDefs[id]; │ │ │ │ } │ │ │ │ - this.mapObject.setOptions({ │ │ │ │ - center: center, │ │ │ │ - zoom: zoom │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - // Bounds │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getMapObjectZoomFromMapObjectBounds │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * moBounds - {Object} MapObject Bounds format │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} MapObject Zoom for specified MapObject Bounds │ │ │ │ - */ │ │ │ │ - getMapObjectZoomFromMapObjectBounds: function(moBounds) { │ │ │ │ - return this.mapObject.getBoundsZoomLevel(moBounds); │ │ │ │ }, │ │ │ │ │ │ │ │ - /************************************ │ │ │ │ - * * │ │ │ │ - * MapObject Primitives * │ │ │ │ - * * │ │ │ │ - ************************************/ │ │ │ │ - │ │ │ │ - │ │ │ │ - // LonLat │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: getMapObjectLonLatFromLonLat │ │ │ │ - * │ │ │ │ + * Method: clearLayerFilter │ │ │ │ + * Clears layer filters, either from a specific layer, │ │ │ │ + * or all of them. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * lon - {Float} │ │ │ │ - * lat - {Float} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} MapObject LonLat built from lon and lat params │ │ │ │ + * id - {String} The id of the layer from which to remove any │ │ │ │ + * filter. If unspecified/blank, all filters │ │ │ │ + * will be removed. │ │ │ │ */ │ │ │ │ - getMapObjectLonLatFromLonLat: function(lon, lat) { │ │ │ │ - var gLatLng; │ │ │ │ - if (this.sphericalMercator) { │ │ │ │ - var lonlat = this.inverseMercator(lon, lat); │ │ │ │ - gLatLng = new google.maps.LatLng(lonlat.lat, lonlat.lon); │ │ │ │ + clearLayerFilter: function(id) { │ │ │ │ + if (id) { │ │ │ │ + delete this.layerDefs[id]; │ │ │ │ } else { │ │ │ │ - gLatLng = new google.maps.LatLng(lat, lon); │ │ │ │ + delete this.layerDefs; │ │ │ │ } │ │ │ │ - return gLatLng; │ │ │ │ }, │ │ │ │ │ │ │ │ - // Pixel │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: getMapObjectPixelFromXY │ │ │ │ + * APIMethod: mergeNewParams │ │ │ │ + * Catch changeParams and uppercase the new params to be merged in │ │ │ │ + * before calling changeParams on the super class. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Integer} │ │ │ │ - * y - {Integer} │ │ │ │ + * Once params have been changed, the tiles will be reloaded with │ │ │ │ + * the new parameters. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Object} MapObject Pixel from x and y parameters │ │ │ │ + * Parameters: │ │ │ │ + * newParams - {Object} Hashtable of new params to use │ │ │ │ */ │ │ │ │ - getMapObjectPixelFromXY: function(x, y) { │ │ │ │ - return new google.maps.Point(x, y); │ │ │ │ - } │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ + var newArguments = [upperParams]; │ │ │ │ + return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, │ │ │ │ + newArguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ -}; │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.ArcGIS93Rest" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Events/buttonclick.js │ │ │ │ + OpenLayers/Layer/Bing.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/Layer/XYZ.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Events.buttonclick │ │ │ │ - * Extension event type for handling buttons on top of a dom element. This │ │ │ │ - * event type fires "buttonclick" on its <target> when a button was │ │ │ │ - * clicked. Buttons are detected by the "olButton" class. │ │ │ │ - * │ │ │ │ - * This event type makes sure that button clicks do not interfere with other │ │ │ │ - * events that are registered on the same <element>. │ │ │ │ - * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - *buttonclick* Triggered when a button is clicked. Listeners receive an │ │ │ │ - * object with a *buttonElement* property referencing the dom element of │ │ │ │ - * the clicked button, and an *buttonXY* property with the click position │ │ │ │ - * relative to the button. │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.Bing │ │ │ │ + * Bing layer using direct tile access as provided by Bing Maps REST Services. │ │ │ │ + * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more │ │ │ │ + * information. Note: Terms of Service compliant use requires the map to be │ │ │ │ + * configured with an <OpenLayers.Control.Attribution> control and the │ │ │ │ + * attribution placed on or near the map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.XYZ> │ │ │ │ */ │ │ │ │ -OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ +OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: target │ │ │ │ - * {<OpenLayers.Events>} The events instance that the buttonclick event will │ │ │ │ - * be triggered on. │ │ │ │ + * Property: key │ │ │ │ + * {String} API key for Bing maps, get your own key │ │ │ │ + * at http://bingmapsportal.com/ . │ │ │ │ */ │ │ │ │ - target: null, │ │ │ │ + key: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: events │ │ │ │ - * {Array} Events to observe and conditionally stop from propagating when │ │ │ │ - * an element with the olButton class (or its olAlphaImg child) is │ │ │ │ - * clicked. │ │ │ │ + * Property: serverResolutions │ │ │ │ + * {Array} the resolutions provided by the Bing servers. │ │ │ │ */ │ │ │ │ - events: [ │ │ │ │ - 'mousedown', 'mouseup', 'click', 'dblclick', │ │ │ │ - 'touchstart', 'touchmove', 'touchend', 'keydown' │ │ │ │ + serverResolutions: [ │ │ │ │ + 156543.03390625, 78271.516953125, 39135.7584765625, │ │ │ │ + 19567.87923828125, 9783.939619140625, 4891.9698095703125, │ │ │ │ + 2445.9849047851562, 1222.9924523925781, 611.4962261962891, │ │ │ │ + 305.74811309814453, 152.87405654907226, 76.43702827453613, │ │ │ │ + 38.218514137268066, 19.109257068634033, 9.554628534317017, │ │ │ │ + 4.777314267158508, 2.388657133579254, 1.194328566789627, │ │ │ │ + 0.5971642833948135, 0.29858214169740677, 0.14929107084870338, │ │ │ │ + 0.07464553542435169 │ │ │ │ ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: startRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that start │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * Property: attributionTemplate │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - startRegEx: /^mousedown|touchstart$/, │ │ │ │ + attributionTemplate: '<span class="olBingAttribution ${type}">' + │ │ │ │ + '<div><a target="_blank" href="http://www.bing.com/maps/">' + │ │ │ │ + '<img src="${logo}" /></a></div>${copyrights}' + │ │ │ │ + '<a style="white-space: nowrap" target="_blank" ' + │ │ │ │ + 'href="http://www.microsoft.com/maps/product/terms.html">' + │ │ │ │ + 'Terms of Use</a></span>', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: cancelRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that cancel │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * Property: metadata │ │ │ │ + * {Object} Metadata for this layer, as returned by the callback script │ │ │ │ */ │ │ │ │ - cancelRegEx: /^touchmove$/, │ │ │ │ + metadata: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: completeRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that complete │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * Property: protocolRegex │ │ │ │ + * {RegExp} Regular expression to match and replace http: in bing urls │ │ │ │ */ │ │ │ │ - completeRegEx: /^mouseup|touchend$/, │ │ │ │ + protocolRegex: /^http:/i, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: startEvt │ │ │ │ - * {Event} The event that started the click sequence │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ + * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ + * used. Default is "Road". │ │ │ │ */ │ │ │ │ + type: "Road", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Events.buttonclick │ │ │ │ - * Construct a buttonclick event type. Applications are not supposed to │ │ │ │ - * create instances of this class - they are created on demand by │ │ │ │ - * <OpenLayers.Events> instances. │ │ │ │ + * APIProperty: culture │ │ │ │ + * {String} The culture identifier. See http://msdn.microsoft.com/en-us/library/ff701709.aspx │ │ │ │ + * for the definition and the possible values. Default is "en-US". │ │ │ │ + */ │ │ │ │ + culture: "en-US", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: metadataParams │ │ │ │ + * {Object} Optional url parameters for the Get Imagery Metadata request │ │ │ │ + * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx │ │ │ │ + */ │ │ │ │ + metadataParams: null, │ │ │ │ + │ │ │ │ + /** APIProperty: tileOptions │ │ │ │ + * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ + * created by this Layer. Default is │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: 'anonymous'} │ │ │ │ + * (end) │ │ │ │ + */ │ │ │ │ + tileOptions: null, │ │ │ │ + │ │ │ │ + /** APIProperty: protocol │ │ │ │ + * {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo │ │ │ │ + * Can be 'http:' 'https:' or '' │ │ │ │ + * │ │ │ │ + * Warning: tiles may not be available under both HTTP and HTTPS protocols. │ │ │ │ + * Microsoft approved use of both HTTP and HTTPS urls for tiles. However │ │ │ │ + * this is undocumented and the Imagery Metadata API always returns HTTP │ │ │ │ + * urls. │ │ │ │ + * │ │ │ │ + * Default is '', unless when executed from a file:/// uri, in which case │ │ │ │ + * it is 'http:'. │ │ │ │ + */ │ │ │ │ + protocol: ~window.location.href.indexOf('http') ? '' : 'http:', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.Bing │ │ │ │ + * Create a new Bing layer. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var road = new OpenLayers.Layer.Bing({ │ │ │ │ + * name: "My Bing Aerial Layer", │ │ │ │ + * type: "Aerial", │ │ │ │ + * key: "my-api-key-here", │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * target - {<OpenLayers.Events>} The events instance that the buttonclick │ │ │ │ - * event will be triggered on. │ │ │ │ + * options - {Object} Configuration properties for the layer. │ │ │ │ + * │ │ │ │ + * Required configuration properties: │ │ │ │ + * key - {String} Bing Maps API key for your application. Get one at │ │ │ │ + * http://bingmapsportal.com/. │ │ │ │ + * type - {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ + * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ + * used. │ │ │ │ + * │ │ │ │ + * Any other documented layer properties can be provided in the config object. │ │ │ │ */ │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + initialize: function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + sphericalMercator: true │ │ │ │ + }, options); │ │ │ │ + var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ + │ │ │ │ + var newArgs = [name, null, options]; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: 'anonymous' │ │ │ │ + }, this.options.tileOptions); │ │ │ │ + this.loadMetadata(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * Method: loadMetadata │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.unregister(this.events[i], this, this.buttonClick); │ │ │ │ - } │ │ │ │ - delete this.target; │ │ │ │ + loadMetadata: function() { │ │ │ │ + this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ + // link the processMetadata method to the global scope and bind it │ │ │ │ + // to this instance │ │ │ │ + window[this._callbackId] = OpenLayers.Function.bind( │ │ │ │ + OpenLayers.Layer.Bing.processMetadata, this │ │ │ │ + ); │ │ │ │ + var params = OpenLayers.Util.applyDefaults({ │ │ │ │ + key: this.key, │ │ │ │ + jsonp: this._callbackId, │ │ │ │ + include: "ImageryProviders" │ │ │ │ + }, this.metadataParams); │ │ │ │ + var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + │ │ │ │ + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = this._callbackId; │ │ │ │ + document.getElementsByTagName("head")[0].appendChild(script); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getPressedButton │ │ │ │ - * Get the pressed button, if any. Returns undefined if no button │ │ │ │ - * was pressed. │ │ │ │ - * │ │ │ │ - * Arguments: │ │ │ │ - * element - {DOMElement} The event target. │ │ │ │ + * Method: initLayer │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The button element, or undefined. │ │ │ │ + * Sets layer properties according to the metadata provided by the API │ │ │ │ */ │ │ │ │ - getPressedButton: function(element) { │ │ │ │ - var depth = 3, // limit the search depth │ │ │ │ - button; │ │ │ │ - do { │ │ │ │ - if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ - // hit! │ │ │ │ - button = element; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - element = element.parentNode; │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return button; │ │ │ │ + initLayer: function() { │ │ │ │ + var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ + var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ + url = url.replace("{culture}", this.culture); │ │ │ │ + url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.url = []; │ │ │ │ + for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ + this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])); │ │ │ │ + } │ │ │ │ + this.addOptions({ │ │ │ │ + maxResolution: Math.min( │ │ │ │ + this.serverResolutions[res.zoomMin], │ │ │ │ + this.maxResolution || Number.POSITIVE_INFINITY │ │ │ │ + ), │ │ │ │ + numZoomLevels: Math.min( │ │ │ │ + res.zoomMax + 1 - res.zoomMin, this.numZoomLevels │ │ │ │ + ) │ │ │ │ + }, true); │ │ │ │ + if (!this.isBaseLayer) { │ │ │ │ + this.redraw(); │ │ │ │ + } │ │ │ │ + this.updateAttribution(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: ignore │ │ │ │ - * Check for event target elements that should be ignored by OpenLayers. │ │ │ │ + * Method: getURL │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * element - {DOMElement} The event target. │ │ │ │ + * Paramters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - ignore: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - ignore = false; │ │ │ │ - do { │ │ │ │ - if (element.nodeName.toLowerCase() === 'a') { │ │ │ │ - ignore = true; │ │ │ │ - break; │ │ │ │ + getURL: function(bounds) { │ │ │ │ + if (!this.url) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var xyz = this.getXYZ(bounds), │ │ │ │ + x = xyz.x, │ │ │ │ + y = xyz.y, │ │ │ │ + z = xyz.z; │ │ │ │ + var quadDigits = []; │ │ │ │ + for (var i = z; i > 0; --i) { │ │ │ │ + var digit = '0'; │ │ │ │ + var mask = 1 << (i - 1); │ │ │ │ + if ((x & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ } │ │ │ │ - element = element.parentNode; │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return ignore; │ │ │ │ + if ((y & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + digit++; │ │ │ │ + } │ │ │ │ + quadDigits.push(digit); │ │ │ │ + } │ │ │ │ + var quadKey = quadDigits.join(""); │ │ │ │ + var url = this.selectUrl('' + x + y + z, this.url); │ │ │ │ + │ │ │ │ + return OpenLayers.String.format(url, { │ │ │ │ + 'quadkey': quadKey │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buttonClick │ │ │ │ - * Check if a button was clicked, and fire the buttonclick event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: updateAttribution │ │ │ │ + * Updates the attribution according to the requirements outlined in │ │ │ │ + * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html │ │ │ │ */ │ │ │ │ - buttonClick: function(evt) { │ │ │ │ - var propagate = true, │ │ │ │ - element = OpenLayers.Event.element(evt); │ │ │ │ - if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ - // was a button pressed? │ │ │ │ - var button = this.getPressedButton(element); │ │ │ │ - if (button) { │ │ │ │ - if (evt.type === "keydown") { │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_RETURN: │ │ │ │ - case OpenLayers.Event.KEY_SPACE: │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button │ │ │ │ - }); │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (this.startEvt) { │ │ │ │ - if (this.completeRegEx.test(evt.type)) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ - var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ - var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ - var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ - pos[0] = pos[0] - scrollLeft; │ │ │ │ - pos[1] = pos[1] - scrollTop; │ │ │ │ - │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button, │ │ │ │ - buttonXY: { │ │ │ │ - x: this.startEvt.clientX - pos[0], │ │ │ │ - y: this.startEvt.clientY - pos[1] │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (this.cancelRegEx.test(evt.type)) { │ │ │ │ - delete this.startEvt; │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - } │ │ │ │ - if (this.startRegEx.test(evt.type)) { │ │ │ │ - this.startEvt = evt; │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ + updateAttribution: function() { │ │ │ │ + var metadata = this.metadata; │ │ │ │ + if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var res = metadata.resourceSets[0].resources[0]; │ │ │ │ + var extent = this.map.getExtent().transform( │ │ │ │ + this.map.getProjectionObject(), │ │ │ │ + new OpenLayers.Projection("EPSG:4326") │ │ │ │ + ); │ │ │ │ + var providers = res.imageryProviders || [], │ │ │ │ + zoom = OpenLayers.Util.indexOf(this.serverResolutions, │ │ │ │ + this.getServerResolution()), │ │ │ │ + copyrights = "", │ │ │ │ + provider, i, ii, j, jj, bbox, coverage; │ │ │ │ + for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ + provider = providers[i]; │ │ │ │ + for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ + coverage = provider.coverageAreas[j]; │ │ │ │ + // axis order provided is Y,X │ │ │ │ + bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ + if (extent.intersectsBounds(bbox) && │ │ │ │ + zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ + copyrights += provider.attribution + " "; │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ - delete this.startEvt; │ │ │ │ } │ │ │ │ } │ │ │ │ - return propagate; │ │ │ │ - } │ │ │ │ + var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ + type: this.type.toLowerCase(), │ │ │ │ + logo: logo, │ │ │ │ + copyrights: copyrights │ │ │ │ + }); │ │ │ │ + this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "attribution" │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + */ │ │ │ │ + setMap: function() { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("moveend", this, this.updateAttribution); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing> │ │ │ │ + */ │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Bing(this.options); │ │ │ │ + } │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.map && │ │ │ │ + this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ + OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ }); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Layer.Bing.processMetadata │ │ │ │ + * This function will be bound to an instance, linked to the global scope with │ │ │ │ + * an id, and called by the JSONP script returned by the API. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * metadata - {Object} metadata as returned by the API │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ + this.metadata = metadata; │ │ │ │ + this.initLayer(); │ │ │ │ + var script = document.getElementById(this._callbackId); │ │ │ │ + script.parentNode.removeChild(script); │ │ │ │ + window[this._callbackId] = undefined; // cannot delete from window in IE │ │ │ │ + delete this._callbackId; │ │ │ │ +}; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Panel.js │ │ │ │ + OpenLayers/Layer/WMS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Panel │ │ │ │ - * The Panel control is a container for other controls. With it toolbars │ │ │ │ - * may be composed. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Layer.WMS │ │ │ │ + * Instances of OpenLayers.Layer.WMS are used to display data from OGC Web │ │ │ │ + * Mapping Services. Create a new WMS layer with the <OpenLayers.Layer.WMS> │ │ │ │ + * constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - /** │ │ │ │ - * Property: controls │ │ │ │ - * {Array(<OpenLayers.Control>)} │ │ │ │ - */ │ │ │ │ - controls: null, │ │ │ │ +OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * Constant: DEFAULT_PARAMS │ │ │ │ + * {Object} Hashtable of default parameter key/value pairs │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + service: "WMS", │ │ │ │ + version: "1.1.1", │ │ │ │ + request: "GetMap", │ │ │ │ + styles: "", │ │ │ │ + format: "image/jpeg" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultControl │ │ │ │ - * {<OpenLayers.Control>} The control which is activated when the control is │ │ │ │ - * activated (turned on), which also happens at instantiation. │ │ │ │ - * If <saveState> is true, <defaultControl> will be nullified after the │ │ │ │ - * first activation of the panel. │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} Default is true for WMS layer │ │ │ │ */ │ │ │ │ - defaultControl: null, │ │ │ │ + isBaseLayer: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: saveState │ │ │ │ - * {Boolean} If set to true, the active state of this panel's controls will │ │ │ │ - * be stored on panel deactivation, and restored on reactivation. Default │ │ │ │ - * is false. │ │ │ │ + * APIProperty: encodeBBOX │ │ │ │ + * {Boolean} Should the BBOX commas be encoded? The WMS spec says 'no', │ │ │ │ + * but some services want it that way. Default false. │ │ │ │ */ │ │ │ │ - saveState: false, │ │ │ │ + encodeBBOX: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: allowDepress │ │ │ │ - * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can │ │ │ │ - * be deactivated by clicking the icon that represents them. Default │ │ │ │ - * is false. │ │ │ │ + /** │ │ │ │ + * APIProperty: noMagic │ │ │ │ + * {Boolean} If true, the image format will not be automagicaly switched │ │ │ │ + * from image/jpeg to image/png or image/gif when using │ │ │ │ + * TRANSPARENT=TRUE. Also isBaseLayer will not changed by the │ │ │ │ + * constructor. Default false. │ │ │ │ */ │ │ │ │ - allowDepress: false, │ │ │ │ + noMagic: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: activeState │ │ │ │ - * {Object} stores the active state of this panel's controls. │ │ │ │ + * Property: yx │ │ │ │ + * {Object} Keys in this object are EPSG codes for which the axis order │ │ │ │ + * is to be reversed (yx instead of xy, LatLon instead of LonLat), with │ │ │ │ + * true as value. This is only relevant for WMS versions >= 1.3.0, and │ │ │ │ + * only if yx is not set in <OpenLayers.Projection.defaults> for the │ │ │ │ + * used projection. │ │ │ │ */ │ │ │ │ - activeState: null, │ │ │ │ + yx: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Panel │ │ │ │ - * Create a new control panel. │ │ │ │ - * │ │ │ │ - * Each control in the panel is represented by an icon. When clicking │ │ │ │ - * on an icon, the <activateControl> method is called. │ │ │ │ + * Constructor: OpenLayers.Layer.WMS │ │ │ │ + * Create a new WMS layer object │ │ │ │ * │ │ │ │ - * Specific properties for controls on a panel: │ │ │ │ - * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>, │ │ │ │ - * <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>. │ │ │ │ - * If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed. │ │ │ │ - * title - {string} Text displayed when mouse is over the icon that │ │ │ │ - * represents the control. │ │ │ │ + * Examples: │ │ │ │ * │ │ │ │ - * The <OpenLayers.Control.type> of a control determines the behavior when │ │ │ │ - * clicking its icon: │ │ │ │ - * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other │ │ │ │ - * controls of this type in the same panel are deactivated. This is │ │ │ │ - * the default type. │ │ │ │ - * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is │ │ │ │ - * toggled. │ │ │ │ - * <OpenLayers.Control.TYPE_BUTTON> - The │ │ │ │ - * <OpenLayers.Control.Button.trigger> method of the control is called, │ │ │ │ - * but its active state is not changed. │ │ │ │ + * The code below creates a simple WMS layer using the image/jpeg format. │ │ │ │ + * (code) │ │ │ │ + * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", │ │ │ │ + * "http://wms.jpl.nasa.gov/wms.cgi", │ │ │ │ + * {layers: "modis,global_mosaic"}); │ │ │ │ + * (end) │ │ │ │ + * Note the 3rd argument (params). Properties added to this object will be │ │ │ │ + * added to the WMS GetMap requests used for this layer's tiles. The only │ │ │ │ + * mandatory parameter is "layers". Other common WMS params include │ │ │ │ + * "transparent", "styles" and "format". Note that the "srs" param will │ │ │ │ + * always be ignored. Instead, it will be derived from the baseLayer's or │ │ │ │ + * map's projection. │ │ │ │ * │ │ │ │ - * If a control is <OpenLayers.Control.active>, it will be drawn with the │ │ │ │ - * olControl[Name]ItemActive class, otherwise with the │ │ │ │ - * olControl[Name]ItemInactive class. │ │ │ │ + * The code below creates a transparent WMS layer with additional options. │ │ │ │ + * (code) │ │ │ │ + * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", │ │ │ │ + * "http://wms.jpl.nasa.gov/wms.cgi", │ │ │ │ + * { │ │ │ │ + * layers: "modis,global_mosaic", │ │ │ │ + * transparent: true │ │ │ │ + * }, { │ │ │ │ + * opacity: 0.5, │ │ │ │ + * singleTile: true │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * Note that by default, a WMS layer is configured as baseLayer. Setting │ │ │ │ + * the "transparent" param to true will apply some magic (see <noMagic>). │ │ │ │ + * The default image format changes from image/jpeg to image/png, and the │ │ │ │ + * layer is not configured as baseLayer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.controls = []; │ │ │ │ - this.activeState = {}; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ - ctl = this.controls[i]; │ │ │ │ - if (ctl.events) { │ │ │ │ - ctl.events.un({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - ctl.panel_div = null; │ │ │ │ - } │ │ │ │ - this.activeState = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - if (control === this.defaultControl || │ │ │ │ - (this.saveState && this.activeState[control.id])) { │ │ │ │ - control.activate(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.saveState === true) { │ │ │ │ - this.defaultControl = null; │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ + * name - {String} A name for the layer │ │ │ │ + * url - {String} Base url for the WMS │ │ │ │ + * (e.g. http://wms.jpl.nasa.gov/wms.cgi) │ │ │ │ + * params - {Object} An object with key/value pairs representing the │ │ │ │ + * GetMap query string parameters and parameter values. │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer. │ │ │ │ + * These options include all properties listed above, plus the ones │ │ │ │ + * inherited from superclasses. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - this.activeState[control.id] = control.deactivate(); │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + var newArguments = []; │ │ │ │ + //uppercase params │ │ │ │ + params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ + if (parseFloat(params.VERSION) >= 1.3 && !params.EXCEPTIONS) { │ │ │ │ + params.EXCEPTIONS = "INIMAGE"; │ │ │ │ } │ │ │ │ - }, │ │ │ │ + newArguments.push(name, url, params, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ + OpenLayers.Util.applyDefaults( │ │ │ │ + this.params, │ │ │ │ + OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS) │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - } │ │ │ │ - this.addControlsToMap(this.controls); │ │ │ │ - return this.div; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: redraw │ │ │ │ - */ │ │ │ │ - redraw: function() { │ │ │ │ - for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ - this.div.removeChild(this.div.childNodes[i]); │ │ │ │ - } │ │ │ │ - this.div.innerHTML = ""; │ │ │ │ - if (this.active) { │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - this.div.appendChild(this.controls[i].panel_div); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + //layer is transparent │ │ │ │ + if (!this.noMagic && this.params.TRANSPARENT && │ │ │ │ + this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activateControl │ │ │ │ - * This method is called when the user click on the icon representing a │ │ │ │ - * control in the panel. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - */ │ │ │ │ - activateControl: function(control) { │ │ │ │ - if (!this.active) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ - control.trigger(); │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ - if (control.active) { │ │ │ │ - control.deactivate(); │ │ │ │ - } else { │ │ │ │ - control.activate(); │ │ │ │ - } │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (this.allowDepress && control.active) { │ │ │ │ - control.deactivate(); │ │ │ │ - } else { │ │ │ │ - var c; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - c = this.controls[i]; │ │ │ │ - if (c != control && │ │ │ │ - (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ - c.deactivate(); │ │ │ │ - } │ │ │ │ + // unless explicitly set in options, make layer an overlay │ │ │ │ + if ((options == null) || (!options.isBaseLayer)) { │ │ │ │ + this.isBaseLayer = false; │ │ │ │ } │ │ │ │ - control.activate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: addControls │ │ │ │ - * To build a toolbar, you add a set of controls to it. addControls │ │ │ │ - * lets you add a single control or a list of controls to the │ │ │ │ - * Control Panel. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * controls - {<OpenLayers.Control>} Controls to add in the panel. │ │ │ │ - */ │ │ │ │ - addControls: function(controls) { │ │ │ │ - if (!(OpenLayers.Util.isArray(controls))) { │ │ │ │ - controls = [controls]; │ │ │ │ - } │ │ │ │ - this.controls = this.controls.concat(controls); │ │ │ │ │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - var control = controls[i], │ │ │ │ - element = this.createControlMarkup(control); │ │ │ │ - OpenLayers.Element.addClass(element, │ │ │ │ - control.displayClass + "ItemInactive"); │ │ │ │ - OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ - if (control.title != "" && !element.title) { │ │ │ │ - element.title = control.title; │ │ │ │ + // jpegs can never be transparent, so intelligently switch the │ │ │ │ + // format, depending on the browser's capabilities │ │ │ │ + if (this.params.FORMAT == "image/jpeg") { │ │ │ │ + this.params.FORMAT = OpenLayers.Util.alphaHack() ? "image/gif" : │ │ │ │ + "image/png"; │ │ │ │ } │ │ │ │ - control.panel_div = element; │ │ │ │ } │ │ │ │ │ │ │ │ - if (this.map) { // map.addControl() has already been called on the panel │ │ │ │ - this.addControlsToMap(controls); │ │ │ │ - this.redraw(); │ │ │ │ - } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: createControlMarkup │ │ │ │ - * This function just creates a div for the control. If specific HTML │ │ │ │ - * markup is needed this function can be overridden in specific classes, │ │ │ │ - * or at panel instantiation time: │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var panel = new OpenLayers.Control.Panel({ │ │ │ │ - * defaultControl: control, │ │ │ │ - * // ovverride createControlMarkup to create actual buttons │ │ │ │ - * // including texts wrapped into span elements. │ │ │ │ - * createControlMarkup: function(control) { │ │ │ │ - * var button = document.createElement('button'), │ │ │ │ - * span = document.createElement('span'); │ │ │ │ - * if (control.text) { │ │ │ │ - * span.innerHTML = control.text; │ │ │ │ - * } │ │ │ │ - * return button; │ │ │ │ - * } │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control to create the HTML │ │ │ │ - * markup for. │ │ │ │ + * Method: clone │ │ │ │ + * Create a clone of this layer │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} The markup. │ │ │ │ + * {<OpenLayers.Layer.WMS>} An exact clone of this layer │ │ │ │ */ │ │ │ │ - createControlMarkup: function(control) { │ │ │ │ - return document.createElement("div"); │ │ │ │ - }, │ │ │ │ + clone: function(obj) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: addControlsToMap │ │ │ │ - * Only for internal use in draw() and addControls() methods. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * controls - {Array(<OpenLayers.Control>)} Controls to add into map. │ │ │ │ - */ │ │ │ │ - addControlsToMap: function(controls) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - control = controls[i]; │ │ │ │ - if (control.autoActivate === true) { │ │ │ │ - control.autoActivate = false; │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.autoActivate = true; │ │ │ │ - } else { │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.deactivate(); │ │ │ │ - } │ │ │ │ - control.events.on({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }); │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.WMS(this.name, │ │ │ │ + this.url, │ │ │ │ + this.params, │ │ │ │ + this.getOptions()); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: iconOn │ │ │ │ - * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ - */ │ │ │ │ - iconOn: function() { │ │ │ │ - var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Active"); │ │ │ │ - }, │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: iconOff │ │ │ │ - * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ - */ │ │ │ │ - iconOff: function() { │ │ │ │ - var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Inactive"); │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onButtonClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * APIMethod: reverseAxisOrder │ │ │ │ + * Returns true if the axis order is reversed for the WMS version and │ │ │ │ + * projection of the layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} true if the axis order is reversed, false otherwise. │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var controls = this.controls, │ │ │ │ - button = evt.buttonElement; │ │ │ │ - for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ - if (controls[i].panel_div === button) { │ │ │ │ - this.activateControl(controls[i]); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + reverseAxisOrder: function() { │ │ │ │ + var projCode = this.projection.getCode(); │ │ │ │ + return parseFloat(this.params.VERSION) >= 1.3 && │ │ │ │ + !!(this.yx[projCode] || (OpenLayers.Projection.defaults[projCode] && │ │ │ │ + OpenLayers.Projection.defaults[projCode].yx)); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getControlsBy │ │ │ │ - * Get a list of controls with properties matching the given criteria. │ │ │ │ + * Method: getURL │ │ │ │ + * Return a GetMap query string for this layer │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * 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. │ │ │ │ + * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the │ │ │ │ + * request. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array(<OpenLayers.Control>)} A list of controls matching the given criteria. │ │ │ │ - * An empty array is returned if no matches are found. │ │ │ │ + * {String} A string with the layer's url and parameters and also the │ │ │ │ + * passed-in bounds and appropriate tile size specified as │ │ │ │ + * parameters. │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + │ │ │ │ + var imageSize = this.getImageSize(); │ │ │ │ + var newParams = {}; │ │ │ │ + // WMS 1.3 introduced axis order │ │ │ │ + var reverseAxisOrder = this.reverseAxisOrder(); │ │ │ │ + newParams.BBOX = this.encodeBBOX ? │ │ │ │ + bounds.toBBOX(null, reverseAxisOrder) : │ │ │ │ + bounds.toArray(reverseAxisOrder); │ │ │ │ + newParams.WIDTH = imageSize.w; │ │ │ │ + newParams.HEIGHT = imageSize.h; │ │ │ │ + var requestString = this.getFullRequestString(newParams); │ │ │ │ + return requestString; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getControlsByName │ │ │ │ - * Get a list of contorls with names matching the given name. │ │ │ │ - * │ │ │ │ + * APIMethod: mergeNewParams │ │ │ │ + * Catch changeParams and uppercase the new params to be merged in │ │ │ │ + * before calling changeParams on the super class. │ │ │ │ + * │ │ │ │ + * Once params have been changed, the tiles will be reloaded with │ │ │ │ + * the new parameters. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * match - {String | Object} A control name. The name can also be a regular │ │ │ │ - * expression literal or object. In addition, it can be any object │ │ │ │ - * with a method named test. For reqular expressions or other, if │ │ │ │ - * name.test(control.name) evaluates to true, the control will be included │ │ │ │ - * in the list of controls returned. If no controls are found, an empty │ │ │ │ - * array is returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Control>)} A list of controls matching the given name. │ │ │ │ - * An empty array is returned if no matches are found. │ │ │ │ + * newParams - {Object} Hashtable of new params to use │ │ │ │ */ │ │ │ │ - getControlsByName: function(match) { │ │ │ │ - return this.getControlsBy("name", match); │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ + var newArguments = [upperParams]; │ │ │ │ + return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, │ │ │ │ + newArguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getControlsByClass │ │ │ │ - * Get a list of controls of a given type (CLASS_NAME). │ │ │ │ + /** │ │ │ │ + * APIMethod: getFullRequestString │ │ │ │ + * Combine the layer's url with its params and these newParams. │ │ │ │ + * │ │ │ │ + * Add the SRS parameter from projection -- this is probably │ │ │ │ + * more eloquently done via a setProjection() method, but this │ │ │ │ + * works for now and always. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * 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. │ │ │ │ - * │ │ │ │ + * newParams - {Object} │ │ │ │ + * altUrl - {String} Use this as the url instead of the layer's url │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Array(<OpenLayers.Control>)} A list of controls matching the given type. │ │ │ │ - * An empty array is returned if no matches are found. │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - getControlsByClass: function(match) { │ │ │ │ - return this.getControlsBy("CLASS_NAME", match); │ │ │ │ + getFullRequestString: function(newParams, altUrl) { │ │ │ │ + var mapProjection = this.map.getProjectionObject(); │ │ │ │ + var projectionCode = this.projection && this.projection.equals(mapProjection) ? │ │ │ │ + this.projection.getCode() : │ │ │ │ + mapProjection.getCode(); │ │ │ │ + var value = (projectionCode == "none") ? null : projectionCode; │ │ │ │ + if (parseFloat(this.params.VERSION) >= 1.3) { │ │ │ │ + this.params.CRS = value; │ │ │ │ + } else { │ │ │ │ + this.params.SRS = value; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (typeof this.params.TRANSPARENT == "boolean") { │ │ │ │ + newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE"; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply( │ │ │ │ + this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ }); │ │ │ │ - │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Snapping.js │ │ │ │ + OpenLayers/Layer/WMTS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Layer/Vector.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Snapping │ │ │ │ - * Acts as a snapping agent while editing vector features. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Layer.WMTS │ │ │ │ + * Instances of the WMTS class allow viewing of tiles from a service that │ │ │ │ + * implements the OGC WMTS specification version 1.0.0. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Snapping = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Layer.WMTS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforesnap - Triggered before a snap occurs. Listeners receive an │ │ │ │ - * event object with *point*, *x*, *y*, *distance*, *layer*, and │ │ │ │ - * *snapType* properties. The point property will be original point │ │ │ │ - * geometry considered for snapping. The x and y properties represent │ │ │ │ - * coordinates the point will receive. The distance is the distance │ │ │ │ - * of the snap. The layer is the target layer. The snapType property │ │ │ │ - * will be one of "node", "vertex", or "edge". Return false to stop │ │ │ │ - * snapping from occurring. │ │ │ │ - * snap - Triggered when a snap occurs. Listeners receive an event with │ │ │ │ - * *point*, *snapType*, *layer*, and *distance* properties. The point │ │ │ │ - * will be the location snapped to. The snapType will be one of "node", │ │ │ │ - * "vertex", or "edge". The layer will be the target layer. The │ │ │ │ - * distance will be the distance of the snap in map units. │ │ │ │ - * unsnap - Triggered when a vertex is unsnapped. Listeners receive an │ │ │ │ - * event with a *point* property. │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} The layer will be considered a base layer. Default is true. │ │ │ │ */ │ │ │ │ + isBaseLayer: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * CONSTANT: DEFAULTS │ │ │ │ - * Default target properties. │ │ │ │ + * Property: version │ │ │ │ + * {String} WMTS version. Default is "1.0.0". │ │ │ │ */ │ │ │ │ - DEFAULTS: { │ │ │ │ - tolerance: 10, │ │ │ │ - node: true, │ │ │ │ - edge: true, │ │ │ │ - vertex: true │ │ │ │ - }, │ │ │ │ + version: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: greedy │ │ │ │ - * {Boolean} Snap to closest feature in first layer with an eligible │ │ │ │ - * feature. Default is true. │ │ │ │ + * APIProperty: requestEncoding │ │ │ │ + * {String} Request encoding. Can be "REST" or "KVP". Default is "KVP". │ │ │ │ */ │ │ │ │ - greedy: true, │ │ │ │ + requestEncoding: "KVP", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: precedence │ │ │ │ - * {Array} List representing precedence of different snapping types. │ │ │ │ - * Default is "node", "vertex", "edge". │ │ │ │ + * APIProperty: url │ │ │ │ + * {String|Array(String)} The base URL or request URL template for the WMTS │ │ │ │ + * service. Must be provided. Array is only supported for base URLs, not │ │ │ │ + * for request URL templates. URL templates are only supported for │ │ │ │ + * REST <requestEncoding>. │ │ │ │ */ │ │ │ │ - precedence: ["node", "vertex", "edge"], │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: resolution │ │ │ │ - * {Float} The map resolution for the previously considered snap. │ │ │ │ + * APIProperty: layer │ │ │ │ + * {String} The layer identifier advertised by the WMTS service. Must be │ │ │ │ + * provided. │ │ │ │ */ │ │ │ │ - resolution: null, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: geoToleranceCache │ │ │ │ - * {Object} A cache of geo-tolerances. Tolerance values (in map units) are │ │ │ │ - * calculated when the map resolution changes. │ │ │ │ + /** │ │ │ │ + * APIProperty: matrixSet │ │ │ │ + * {String} One of the advertised matrix set identifiers. Must be provided. │ │ │ │ */ │ │ │ │ - geoToleranceCache: null, │ │ │ │ + matrixSet: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: style │ │ │ │ + * {String} One of the advertised layer styles. Must be provided. │ │ │ │ + */ │ │ │ │ + style: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: format │ │ │ │ + * {String} The image MIME type. Default is "image/jpeg". │ │ │ │ + */ │ │ │ │ + format: "image/jpeg", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The current editable layer. Set at │ │ │ │ - * construction or after construction with <setLayer>. │ │ │ │ + * APIProperty: tileOrigin │ │ │ │ + * {<OpenLayers.LonLat>} The top-left corner of the tile matrix in map │ │ │ │ + * units. If the tile origin for each matrix in a set is different, │ │ │ │ + * the <matrixIds> should include a topLeftCorner property. If │ │ │ │ + * not provided, the tile origin will default to the top left corner │ │ │ │ + * of the layer <maxExtent>. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + tileOrigin: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The current editable feature. │ │ │ │ + * APIProperty: tileFullExtent │ │ │ │ + * {<OpenLayers.Bounds>} The full extent of the tile set. If not supplied, │ │ │ │ + * the layer's <maxExtent> property will be used. │ │ │ │ */ │ │ │ │ - feature: null, │ │ │ │ + tileFullExtent: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: point │ │ │ │ - * {<OpenLayers.Geometry.Point>} The currently snapped vertex. │ │ │ │ + * APIProperty: formatSuffix │ │ │ │ + * {String} For REST request encoding, an image format suffix must be │ │ │ │ + * included in the request. If not provided, the suffix will be derived │ │ │ │ + * from the <format> property. │ │ │ │ */ │ │ │ │ - point: null, │ │ │ │ + formatSuffix: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Snapping │ │ │ │ - * Creates a new snapping control. A control is constructed with an editable │ │ │ │ - * layer and a set of configuration objects for target layers. While the │ │ │ │ - * control is active, dragging vertices while drawing new features or │ │ │ │ - * modifying existing features on the editable layer will engage │ │ │ │ - * snapping to features on the target layers. Whether a vertex snaps to │ │ │ │ - * a feature on a target layer depends on the target layer configuration. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An object containing all configuration properties for │ │ │ │ - * the control. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} The editable layer. Features from this │ │ │ │ - * layer that are digitized or modified may have vertices snapped to │ │ │ │ - * features from any of the target layers. │ │ │ │ - * targets - {Array(Object | OpenLayers.Layer.Vector)} A list of objects for │ │ │ │ - * configuring target layers. See valid properties of the target │ │ │ │ - * objects below. If the items in the targets list are vector layers │ │ │ │ - * (instead of configuration objects), the defaults from the <defaults> │ │ │ │ - * property will apply. The editable layer itself may be a target │ │ │ │ - * layer, allowing newly created or edited features to be snapped to │ │ │ │ - * existing features from the same layer. If no targets are provided │ │ │ │ - * the layer given in the constructor (as <layer>) will become the │ │ │ │ - * initial target. │ │ │ │ - * defaults - {Object} An object with default properties to be applied │ │ │ │ - * to all target objects. │ │ │ │ - * greedy - {Boolean} Snap to closest feature in first target layer that │ │ │ │ - * applies. Default is true. If false, all features in all target │ │ │ │ - * layers will be checked and the closest feature in all target layers │ │ │ │ - * will be chosen. The greedy property determines if the order of the │ │ │ │ - * target layers is significant. By default, the order of the target │ │ │ │ - * layers is significant where layers earlier in the target layer list │ │ │ │ - * have precedence over layers later in the list. Within a single │ │ │ │ - * layer, the closest feature is always chosen for snapping. This │ │ │ │ - * property only determines whether the search for a closer feature │ │ │ │ - * continues after an eligible feature is found in a target layer. │ │ │ │ - * │ │ │ │ - * Valid target properties: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} A target layer. Features from this │ │ │ │ - * layer will be eligible to act as snapping target for the editable │ │ │ │ - * layer. │ │ │ │ - * tolerance - {Float} The distance (in pixels) at which snapping may occur. │ │ │ │ - * Default is 10. │ │ │ │ - * node - {Boolean} Snap to nodes (first or last point in a geometry) in │ │ │ │ - * target layer. Default is true. │ │ │ │ - * nodeTolerance - {Float} Optional distance at which snapping may occur │ │ │ │ - * for nodes specifically. If none is provided, <tolerance> will be │ │ │ │ - * used. │ │ │ │ - * vertex - {Boolean} Snap to vertices in target layer. Default is true. │ │ │ │ - * vertexTolerance - {Float} Optional distance at which snapping may occur │ │ │ │ - * for vertices specifically. If none is provided, <tolerance> will be │ │ │ │ - * used. │ │ │ │ - * edge - {Boolean} Snap to edges in target layer. Default is true. │ │ │ │ - * edgeTolerance - {Float} Optional distance at which snapping may occur │ │ │ │ - * for edges specifically. If none is provided, <tolerance> will be │ │ │ │ - * used. │ │ │ │ - * filter - {<OpenLayers.Filter>} Optional filter to evaluate to determine if │ │ │ │ - * feature is eligible for snapping. If filter evaluates to true for a │ │ │ │ - * target feature a vertex may be snapped to the feature. │ │ │ │ - * minResolution - {Number} If a minResolution is provided, snapping to this │ │ │ │ - * target will only be considered if the map resolution is greater than │ │ │ │ - * or equal to this value (the minResolution is inclusive). Default is │ │ │ │ - * no minimum resolution limit. │ │ │ │ - * maxResolution - {Number} If a maxResolution is provided, snapping to this │ │ │ │ - * target will only be considered if the map resolution is strictly │ │ │ │ - * less than this value (the maxResolution is exclusive). Default is │ │ │ │ - * no maximum resolution limit. │ │ │ │ + * APIProperty: matrixIds │ │ │ │ + * {Array} A list of tile matrix identifiers. If not provided, the matrix │ │ │ │ + * identifiers will be assumed to be integers corresponding to the │ │ │ │ + * map zoom level. If a list of strings is provided, each item should │ │ │ │ + * be the matrix identifier that corresponds to the map zoom level. │ │ │ │ + * Additionally, a list of objects can be provided. Each object should │ │ │ │ + * describe the matrix as presented in the WMTS capabilities. These │ │ │ │ + * objects should have the propertes shown below. │ │ │ │ + * │ │ │ │ + * Matrix properties: │ │ │ │ + * identifier - {String} The matrix identifier (required). │ │ │ │ + * scaleDenominator - {Number} The matrix scale denominator. │ │ │ │ + * topLeftCorner - {<OpenLayers.LonLat>} The top left corner of the │ │ │ │ + * matrix. Must be provided if different than the layer <tileOrigin>. │ │ │ │ + * tileWidth - {Number} The tile width for the matrix. Must be provided │ │ │ │ + * if different than the width given in the layer <tileSize>. │ │ │ │ + * tileHeight - {Number} The tile height for the matrix. Must be provided │ │ │ │ + * if different than the height given in the layer <tileSize>. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options || {}; // TODO: this could be done by the super │ │ │ │ + matrixIds: null, │ │ │ │ │ │ │ │ - // set the editable layer if provided │ │ │ │ - if (this.options.layer) { │ │ │ │ - this.setLayer(this.options.layer); │ │ │ │ - } │ │ │ │ - // configure target layers │ │ │ │ - var defaults = OpenLayers.Util.extend({}, this.options.defaults); │ │ │ │ - this.defaults = OpenLayers.Util.applyDefaults(defaults, this.DEFAULTS); │ │ │ │ - this.setTargets(this.options.targets); │ │ │ │ - if (this.targets.length === 0 && this.layer) { │ │ │ │ - this.addTargetLayer(this.layer); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: dimensions │ │ │ │ + * {Array} For RESTful request encoding, extra dimensions may be specified. │ │ │ │ + * Items in this list should be property names in the <params> object. │ │ │ │ + * Values of extra dimensions will be determined from the corresponding │ │ │ │ + * values in the <params> object. │ │ │ │ + */ │ │ │ │ + dimensions: null, │ │ │ │ │ │ │ │ - this.geoToleranceCache = {}; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: params │ │ │ │ + * {Object} Extra parameters to include in tile requests. For KVP │ │ │ │ + * <requestEncoding>, these properties will be encoded in the request │ │ │ │ + * query string. For REST <requestEncoding>, these properties will │ │ │ │ + * become part of the request path, with order determined by the │ │ │ │ + * <dimensions> list. │ │ │ │ + */ │ │ │ │ + params: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setLayer │ │ │ │ - * Set the editable layer. Call the setLayer method if the editable layer │ │ │ │ - * changes and the same control should be used on a new editable layer. │ │ │ │ - * If the control is already active, it will be active after the new │ │ │ │ - * layer is set. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} The new editable layer. │ │ │ │ + * APIProperty: zoomOffset │ │ │ │ + * {Number} If your cache has more levels than you want to provide │ │ │ │ + * access to with this layer, supply a zoomOffset. This zoom offset │ │ │ │ + * is added to the current map zoom level to determine the level │ │ │ │ + * for a requested tile. For example, if you supply a zoomOffset │ │ │ │ + * of 3, when the map is at the zoom 0, tiles will be requested from │ │ │ │ + * level 3 of your cache. Default is 0 (assumes cache level and map │ │ │ │ + * zoom are equivalent). Additionally, if this layer is to be used │ │ │ │ + * as an overlay and the cache has fewer zoom levels than the base │ │ │ │ + * layer, you can supply a negative zoomOffset. For example, if a │ │ │ │ + * map zoom level of 1 corresponds to your cache level zero, you would │ │ │ │ + * supply a -1 zoomOffset (and set the maxResolution of the layer │ │ │ │ + * appropriately). The zoomOffset value has no effect if complete │ │ │ │ + * matrix definitions (including scaleDenominator) are supplied in │ │ │ │ + * the <matrixIds> property. Defaults to 0 (no zoom offset). │ │ │ │ */ │ │ │ │ - setLayer: function(layer) { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layer = layer; │ │ │ │ - this.activate(); │ │ │ │ - } else { │ │ │ │ - this.layer = layer; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + zoomOffset: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setTargets │ │ │ │ - * Set the targets for the snapping agent. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * targets - {Array} An array of target configs or target layers. │ │ │ │ + * APIProperty: serverResolutions │ │ │ │ + * {Array} A list of all resolutions available on the server. Only set this │ │ │ │ + * property if the map resolutions differ from the server. This │ │ │ │ + * property serves two purposes. (a) <serverResolutions> can include │ │ │ │ + * resolutions that the server supports and that you don't want to │ │ │ │ + * provide with this layer; you can also look at <zoomOffset>, which is │ │ │ │ + * an alternative to <serverResolutions> for that specific purpose. │ │ │ │ + * (b) The map can work with resolutions that aren't supported by │ │ │ │ + * the server, i.e. that aren't in <serverResolutions>. When the │ │ │ │ + * map is displayed in such a resolution data for the closest │ │ │ │ + * server-supported resolution is loaded and the layer div is │ │ │ │ + * stretched as necessary. │ │ │ │ */ │ │ │ │ - setTargets: function(targets) { │ │ │ │ - this.targets = []; │ │ │ │ - if (targets && targets.length) { │ │ │ │ - var target; │ │ │ │ - for (var i = 0, len = targets.length; i < len; ++i) { │ │ │ │ - target = targets[i]; │ │ │ │ - if (target instanceof OpenLayers.Layer.Vector) { │ │ │ │ - this.addTargetLayer(target); │ │ │ │ - } else { │ │ │ │ - this.addTarget(target); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + serverResolutions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addTargetLayer │ │ │ │ - * Add a target layer with the default target config. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} A target layer. │ │ │ │ + * Property: formatSuffixMap │ │ │ │ + * {Object} a map between WMTS 'format' request parameter and tile image file suffix │ │ │ │ */ │ │ │ │ - addTargetLayer: function(layer) { │ │ │ │ - this.addTarget({ │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ + formatSuffixMap: { │ │ │ │ + "image/png": "png", │ │ │ │ + "image/png8": "png", │ │ │ │ + "image/png24": "png", │ │ │ │ + "image/png32": "png", │ │ │ │ + "png": "png", │ │ │ │ + "image/jpeg": "jpg", │ │ │ │ + "image/jpg": "jpg", │ │ │ │ + "jpeg": "jpg", │ │ │ │ + "jpg": "jpg" │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addTarget │ │ │ │ - * Add a configured target layer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * target - {Object} A target config. │ │ │ │ + * Property: matrix │ │ │ │ + * {Object} Matrix definition for the current map resolution. Updated by │ │ │ │ + * the <updateMatrixProperties> method. │ │ │ │ */ │ │ │ │ - addTarget: function(target) { │ │ │ │ - target = OpenLayers.Util.applyDefaults(target, this.defaults); │ │ │ │ - target.nodeTolerance = target.nodeTolerance || target.tolerance; │ │ │ │ - target.vertexTolerance = target.vertexTolerance || target.tolerance; │ │ │ │ - target.edgeTolerance = target.edgeTolerance || target.tolerance; │ │ │ │ - this.targets.push(target); │ │ │ │ - }, │ │ │ │ + matrix: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeTargetLayer │ │ │ │ - * Remove a target layer. │ │ │ │ + * Constructor: OpenLayers.Layer.WMTS │ │ │ │ + * Create a new WMTS layer. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var wmts = new OpenLayers.Layer.WMTS({ │ │ │ │ + * name: "My WMTS Layer", │ │ │ │ + * url: "http://example.com/wmts", │ │ │ │ + * layer: "layer_id", │ │ │ │ + * style: "default", │ │ │ │ + * matrixSet: "matrix_id" │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} The target layer to remove. │ │ │ │ + * config - {Object} Configuration properties for the layer. │ │ │ │ + * │ │ │ │ + * Required configuration properties: │ │ │ │ + * url - {String} The base url for the service. See the <url> property. │ │ │ │ + * layer - {String} The layer identifier. See the <layer> property. │ │ │ │ + * style - {String} The layer style identifier. See the <style> property. │ │ │ │ + * matrixSet - {String} The tile matrix set identifier. See the <matrixSet> │ │ │ │ + * property. │ │ │ │ + * │ │ │ │ + * Any other documented layer properties can be provided in the config object. │ │ │ │ */ │ │ │ │ - removeTargetLayer: function(layer) { │ │ │ │ - var target; │ │ │ │ - for (var i = this.targets.length - 1; i >= 0; --i) { │ │ │ │ - target = this.targets[i]; │ │ │ │ - if (target.layer === layer) { │ │ │ │ - this.removeTarget(target); │ │ │ │ + initialize: function(config) { │ │ │ │ + │ │ │ │ + // confirm required properties are supplied │ │ │ │ + var required = { │ │ │ │ + url: true, │ │ │ │ + layer: true, │ │ │ │ + style: true, │ │ │ │ + matrixSet: true │ │ │ │ + }; │ │ │ │ + for (var prop in required) { │ │ │ │ + if (!(prop in config)) { │ │ │ │ + throw new Error("Missing property '" + prop + "' in layer configuration."); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + config.params = OpenLayers.Util.upperCaseObject(config.params); │ │ │ │ + var args = [config.name, config.url, config.params, config]; │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, args); │ │ │ │ + │ │ │ │ + │ │ │ │ + // determine format suffix (for REST) │ │ │ │ + if (!this.formatSuffix) { │ │ │ │ + this.formatSuffix = this.formatSuffixMap[this.format] || this.format.split("/").pop(); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // expand matrixIds (may be array of string or array of object) │ │ │ │ + if (this.matrixIds) { │ │ │ │ + var len = this.matrixIds.length; │ │ │ │ + if (len && typeof this.matrixIds[0] === "string") { │ │ │ │ + var ids = this.matrixIds; │ │ │ │ + this.matrixIds = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + this.matrixIds[i] = { │ │ │ │ + identifier: ids[i] │ │ │ │ + }; │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeTarget │ │ │ │ - * Remove a target. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * target - {Object} A target config. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} The targets array. │ │ │ │ + * Method: setMap │ │ │ │ */ │ │ │ │ - removeTarget: function(target) { │ │ │ │ - return OpenLayers.Util.removeItem(this.targets, target); │ │ │ │ + setMap: function() { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the control. Activating the control registers listeners for │ │ │ │ - * editing related events so that during feature creation and │ │ │ │ - * modification, moving vertices will trigger snapping. │ │ │ │ + * Method: updateMatrixProperties │ │ │ │ + * Called when map resolution changes to update matrix related properties. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (this.layer && this.layer.events) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - sketchstarted: this.onSketchModified, │ │ │ │ - sketchmodified: this.onSketchModified, │ │ │ │ - vertexmodified: this.onVertexModified, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + updateMatrixProperties: function() { │ │ │ │ + this.matrix = this.getMatrix(); │ │ │ │ + if (this.matrix) { │ │ │ │ + if (this.matrix.topLeftCorner) { │ │ │ │ + this.tileOrigin = this.matrix.topLeftCorner; │ │ │ │ + } │ │ │ │ + if (this.matrix.tileWidth && this.matrix.tileHeight) { │ │ │ │ + this.tileSize = new OpenLayers.Size( │ │ │ │ + this.matrix.tileWidth, this.matrix.tileHeight │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (!this.tileOrigin) { │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat( │ │ │ │ + this.maxExtent.left, this.maxExtent.top │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (!this.tileFullExtent) { │ │ │ │ + this.tileFullExtent = this.maxExtent; │ │ │ │ } │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the control. Deactivating the control unregisters listeners │ │ │ │ - * so feature editing may proceed without engaging the snapping agent. │ │ │ │ + * Method: moveTo │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * zoomChanged - {Boolean} Tells when zoom has changed, as layers have to │ │ │ │ + * do some init work in that case. │ │ │ │ + * dragging - {Boolean} │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - if (this.layer && this.layer.events) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - sketchstarted: this.onSketchModified, │ │ │ │ - sketchmodified: this.onSketchModified, │ │ │ │ - vertexmodified: this.onVertexModified, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ + if (zoomChanged || !this.matrix) { │ │ │ │ + this.updateMatrixProperties(); │ │ │ │ } │ │ │ │ - this.feature = null; │ │ │ │ - this.point = null; │ │ │ │ - return deactivated; │ │ │ │ + return OpenLayers.Layer.Grid.prototype.moveTo.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onSketchModified │ │ │ │ - * Registered as a listener for the sketchmodified event on the editable │ │ │ │ - * layer. │ │ │ │ - * │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The sketch modified event. │ │ │ │ + * obj - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.WMTS>} An exact clone of this <OpenLayers.Layer.WMTS> │ │ │ │ */ │ │ │ │ - onSketchModified: function(event) { │ │ │ │ - this.feature = event.feature; │ │ │ │ - this.considerSnapping(event.vertex, event.vertex); │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.WMTS(this.options); │ │ │ │ + } │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onVertexModified │ │ │ │ - * Registered as a listener for the vertexmodified event on the editable │ │ │ │ - * layer. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * event - {Object} The vertex modified event. │ │ │ │ + * Method: getIdentifier │ │ │ │ + * Get the current index in the matrixIds array. │ │ │ │ */ │ │ │ │ - onVertexModified: function(event) { │ │ │ │ - this.feature = event.feature; │ │ │ │ - var loc = this.layer.map.getLonLatFromViewPortPx(event.pixel); │ │ │ │ - this.considerSnapping( │ │ │ │ - event.vertex, new OpenLayers.Geometry.Point(loc.lon, loc.lat) │ │ │ │ - ); │ │ │ │ + getIdentifier: function() { │ │ │ │ + return this.getServerZoom(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: considerSnapping │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} The vertex to be snapped (or │ │ │ │ - * unsnapped). │ │ │ │ - * loc - {<OpenLayers.Geometry.Point>} The location of the mouse in map │ │ │ │ - * coords. │ │ │ │ + * Method: getMatrix │ │ │ │ + * Get the appropriate matrix definition for the current map resolution. │ │ │ │ */ │ │ │ │ - considerSnapping: function(point, loc) { │ │ │ │ - var best = { │ │ │ │ - rank: Number.POSITIVE_INFINITY, │ │ │ │ - dist: Number.POSITIVE_INFINITY, │ │ │ │ - x: null, │ │ │ │ - y: null │ │ │ │ - }; │ │ │ │ - var snapped = false; │ │ │ │ - var result, target; │ │ │ │ - for (var i = 0, len = this.targets.length; i < len; ++i) { │ │ │ │ - target = this.targets[i]; │ │ │ │ - result = this.testTarget(target, loc); │ │ │ │ - if (result) { │ │ │ │ - if (this.greedy) { │ │ │ │ - best = result; │ │ │ │ - best.target = target; │ │ │ │ - snapped = true; │ │ │ │ - break; │ │ │ │ - } else { │ │ │ │ - if ((result.rank < best.rank) || │ │ │ │ - (result.rank === best.rank && result.dist < best.dist)) { │ │ │ │ - best = result; │ │ │ │ - best.target = target; │ │ │ │ - snapped = true; │ │ │ │ + getMatrix: function() { │ │ │ │ + var matrix; │ │ │ │ + if (!this.matrixIds || this.matrixIds.length === 0) { │ │ │ │ + matrix = { │ │ │ │ + identifier: this.getIdentifier() │ │ │ │ + }; │ │ │ │ + } else { │ │ │ │ + // get appropriate matrix given the map scale if possible │ │ │ │ + if ("scaleDenominator" in this.matrixIds[0]) { │ │ │ │ + // scale denominator calculation based on WMTS spec │ │ │ │ + var denom = │ │ │ │ + OpenLayers.METERS_PER_INCH * │ │ │ │ + OpenLayers.INCHES_PER_UNIT[this.units] * │ │ │ │ + this.getServerResolution() / 0.28E-3; │ │ │ │ + var diff = Number.POSITIVE_INFINITY; │ │ │ │ + var delta; │ │ │ │ + for (var i = 0, ii = this.matrixIds.length; i < ii; ++i) { │ │ │ │ + delta = Math.abs(1 - (this.matrixIds[i].scaleDenominator / denom)); │ │ │ │ + if (delta < diff) { │ │ │ │ + diff = delta; │ │ │ │ + matrix = this.matrixIds[i]; │ │ │ │ } │ │ │ │ } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (snapped) { │ │ │ │ - var proceed = this.events.triggerEvent("beforesnap", { │ │ │ │ - point: point, │ │ │ │ - x: best.x, │ │ │ │ - y: best.y, │ │ │ │ - distance: best.dist, │ │ │ │ - layer: best.target.layer, │ │ │ │ - snapType: this.precedence[best.rank] │ │ │ │ - }); │ │ │ │ - if (proceed !== false) { │ │ │ │ - point.x = best.x; │ │ │ │ - point.y = best.y; │ │ │ │ - this.point = point; │ │ │ │ - this.events.triggerEvent("snap", { │ │ │ │ - point: point, │ │ │ │ - snapType: this.precedence[best.rank], │ │ │ │ - layer: best.target.layer, │ │ │ │ - distance: best.dist │ │ │ │ - }); │ │ │ │ } else { │ │ │ │ - snapped = false; │ │ │ │ + // fall back on zoom as index │ │ │ │ + matrix = this.matrixIds[this.getIdentifier()]; │ │ │ │ } │ │ │ │ } │ │ │ │ - if (this.point && !snapped) { │ │ │ │ - point.x = loc.x; │ │ │ │ - point.y = loc.y; │ │ │ │ - this.point = null; │ │ │ │ - this.events.triggerEvent("unsnap", { │ │ │ │ - point: point │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + return matrix; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: testTarget │ │ │ │ + /** │ │ │ │ + * Method: getTileInfo │ │ │ │ + * Get tile information for a given location at the current map resolution. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * target - {Object} Object with target layer configuration. │ │ │ │ - * loc - {<OpenLayers.Geometry.Point>} The location of the mouse in map │ │ │ │ - * coords. │ │ │ │ + * loc - {<OpenLayers.LonLat} A location in map coordinates. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} A result object with rank, dist, x, and y properties. │ │ │ │ - * Returns null if candidate is not eligible for snapping. │ │ │ │ + * {Object} An object with "col", "row", "i", and "j" properties. The col │ │ │ │ + * and row values are zero based tile indexes from the top left. The │ │ │ │ + * i and j values are the number of pixels to the left and top │ │ │ │ + * (respectively) of the given location within the target tile. │ │ │ │ */ │ │ │ │ - testTarget: function(target, loc) { │ │ │ │ - var resolution = this.layer.map.getResolution(); │ │ │ │ - if ("minResolution" in target) { │ │ │ │ - if (resolution < target.minResolution) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if ("maxResolution" in target) { │ │ │ │ - if (resolution >= target.maxResolution) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var tolerance = { │ │ │ │ - node: this.getGeoTolerance(target.nodeTolerance, resolution), │ │ │ │ - vertex: this.getGeoTolerance(target.vertexTolerance, resolution), │ │ │ │ - edge: this.getGeoTolerance(target.edgeTolerance, resolution) │ │ │ │ - }; │ │ │ │ - // this could be cached if we don't support setting tolerance values directly │ │ │ │ - var maxTolerance = Math.max( │ │ │ │ - tolerance.node, tolerance.vertex, tolerance.edge │ │ │ │ - ); │ │ │ │ - var result = { │ │ │ │ - rank: Number.POSITIVE_INFINITY, │ │ │ │ - dist: Number.POSITIVE_INFINITY │ │ │ │ + getTileInfo: function(loc) { │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + │ │ │ │ + var fx = (loc.lon - this.tileOrigin.lon) / (res * this.tileSize.w); │ │ │ │ + var fy = (this.tileOrigin.lat - loc.lat) / (res * this.tileSize.h); │ │ │ │ + │ │ │ │ + var col = Math.floor(fx); │ │ │ │ + var row = Math.floor(fy); │ │ │ │ + │ │ │ │ + return { │ │ │ │ + col: col, │ │ │ │ + row: row, │ │ │ │ + i: Math.floor((fx - col) * this.tileSize.w), │ │ │ │ + j: Math.floor((fy - row) * this.tileSize.h) │ │ │ │ }; │ │ │ │ - var eligible = false; │ │ │ │ - var features = target.layer.features; │ │ │ │ - var feature, type, vertices, vertex, closest, dist, found; │ │ │ │ - var numTypes = this.precedence.length; │ │ │ │ - var ll = new OpenLayers.LonLat(loc.x, loc.y); │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (feature !== this.feature && !feature._sketch && │ │ │ │ - feature.state !== OpenLayers.State.DELETE && │ │ │ │ - (!target.filter || target.filter.evaluate(feature))) { │ │ │ │ - if (feature.atPoint(ll, maxTolerance, maxTolerance)) { │ │ │ │ - for (var j = 0, stop = Math.min(result.rank + 1, numTypes); j < stop; ++j) { │ │ │ │ - type = this.precedence[j]; │ │ │ │ - if (target[type]) { │ │ │ │ - if (type === "edge") { │ │ │ │ - closest = feature.geometry.distanceTo(loc, { │ │ │ │ - details: true │ │ │ │ - }); │ │ │ │ - dist = closest.distance; │ │ │ │ - if (dist <= tolerance[type] && dist < result.dist) { │ │ │ │ - result = { │ │ │ │ - rank: j, │ │ │ │ - dist: dist, │ │ │ │ - x: closest.x0, │ │ │ │ - y: closest.y0 // closest coords on feature │ │ │ │ - }; │ │ │ │ - eligible = true; │ │ │ │ - // don't look for lower precedence types for this feature │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // look for nodes or vertices │ │ │ │ - vertices = feature.geometry.getVertices(type === "node"); │ │ │ │ - found = false; │ │ │ │ - for (var k = 0, klen = vertices.length; k < klen; ++k) { │ │ │ │ - vertex = vertices[k]; │ │ │ │ - dist = vertex.distanceTo(loc); │ │ │ │ - if (dist <= tolerance[type] && │ │ │ │ - (j < result.rank || (j === result.rank && dist < result.dist))) { │ │ │ │ - result = { │ │ │ │ - rank: j, │ │ │ │ - dist: dist, │ │ │ │ - x: vertex.x, │ │ │ │ - y: vertex.y │ │ │ │ - }; │ │ │ │ - eligible = true; │ │ │ │ - found = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (found) { │ │ │ │ - // don't look for lower precedence types for this feature │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return eligible ? result : null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getGeoTolerance │ │ │ │ - * Calculate a tolerance in map units given a tolerance in pixels. This │ │ │ │ - * takes advantage of the <geoToleranceCache> when the map resolution │ │ │ │ - * has not changed. │ │ │ │ - * │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * tolerance - {Number} A tolerance value in pixels. │ │ │ │ - * resolution - {Number} Map resolution. │ │ │ │ - * │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Number} A tolerance value in map units. │ │ │ │ + * {String} A URL for the tile corresponding to the given bounds. │ │ │ │ */ │ │ │ │ - getGeoTolerance: function(tolerance, resolution) { │ │ │ │ - if (resolution !== this.resolution) { │ │ │ │ - this.resolution = resolution; │ │ │ │ - this.geoToleranceCache = {}; │ │ │ │ - } │ │ │ │ - var geoTolerance = this.geoToleranceCache[tolerance]; │ │ │ │ - if (geoTolerance === undefined) { │ │ │ │ - geoTolerance = tolerance * resolution; │ │ │ │ - this.geoToleranceCache[tolerance] = geoTolerance; │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var url = ""; │ │ │ │ + if (!this.tileFullExtent || this.tileFullExtent.intersectsBounds(bounds)) { │ │ │ │ + │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var info = this.getTileInfo(center); │ │ │ │ + var matrixId = this.matrix.identifier; │ │ │ │ + var dimensions = this.dimensions, │ │ │ │ + params; │ │ │ │ + │ │ │ │ + if (OpenLayers.Util.isArray(this.url)) { │ │ │ │ + url = this.selectUrl([ │ │ │ │ + this.version, this.style, this.matrixSet, │ │ │ │ + this.matrix.identifier, info.row, info.col │ │ │ │ + ].join(","), this.url); │ │ │ │ + } else { │ │ │ │ + url = this.url; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.requestEncoding.toUpperCase() === "REST") { │ │ │ │ + params = this.params; │ │ │ │ + if (url.indexOf("{") !== -1) { │ │ │ │ + var template = url.replace(/\{/g, "${"); │ │ │ │ + var context = { │ │ │ │ + // spec does not make clear if capital S or not │ │ │ │ + style: this.style, │ │ │ │ + Style: this.style, │ │ │ │ + TileMatrixSet: this.matrixSet, │ │ │ │ + TileMatrix: this.matrix.identifier, │ │ │ │ + TileRow: info.row, │ │ │ │ + TileCol: info.col │ │ │ │ + }; │ │ │ │ + if (dimensions) { │ │ │ │ + var dimension, i; │ │ │ │ + for (i = dimensions.length - 1; i >= 0; --i) { │ │ │ │ + dimension = dimensions[i]; │ │ │ │ + context[dimension] = params[dimension.toUpperCase()]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + url = OpenLayers.String.format(template, context); │ │ │ │ + } else { │ │ │ │ + // include 'version', 'layer' and 'style' in tile resource url │ │ │ │ + var path = this.version + "/" + this.layer + "/" + this.style + "/"; │ │ │ │ + │ │ │ │ + // append optional dimension path elements │ │ │ │ + if (dimensions) { │ │ │ │ + for (var i = 0; i < dimensions.length; i++) { │ │ │ │ + if (params[dimensions[i]]) { │ │ │ │ + path = path + params[dimensions[i]] + "/"; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // append other required path elements │ │ │ │ + path = path + this.matrixSet + "/" + this.matrix.identifier + │ │ │ │ + "/" + info.row + "/" + info.col + "." + this.formatSuffix; │ │ │ │ + │ │ │ │ + if (!url.match(/\/$/)) { │ │ │ │ + url = url + "/"; │ │ │ │ + } │ │ │ │ + url = url + path; │ │ │ │ + } │ │ │ │ + } else if (this.requestEncoding.toUpperCase() === "KVP") { │ │ │ │ + │ │ │ │ + // assemble all required parameters │ │ │ │ + params = { │ │ │ │ + SERVICE: "WMTS", │ │ │ │ + REQUEST: "GetTile", │ │ │ │ + VERSION: this.version, │ │ │ │ + LAYER: this.layer, │ │ │ │ + STYLE: this.style, │ │ │ │ + TILEMATRIXSET: this.matrixSet, │ │ │ │ + TILEMATRIX: this.matrix.identifier, │ │ │ │ + TILEROW: info.row, │ │ │ │ + TILECOL: info.col, │ │ │ │ + FORMAT: this.format │ │ │ │ + }; │ │ │ │ + url = OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, [params]); │ │ │ │ + │ │ │ │ + } │ │ │ │ } │ │ │ │ - return geoTolerance; │ │ │ │ + return url; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - * Clean up the control. │ │ │ │ + * APIMethod: mergeNewParams │ │ │ │ + * Extend the existing layer <params> with new properties. Tiles will be │ │ │ │ + * reloaded with updated params in the request. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * newParams - {Object} Properties to extend to existing <params>. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); // TODO: this should be handled by the super │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + if (this.requestEncoding.toUpperCase() === "KVP") { │ │ │ │ + return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply( │ │ │ │ + this, [OpenLayers.Util.upperCaseObject(newParams)] │ │ │ │ + ); │ │ │ │ } │ │ │ │ - delete this.layer; │ │ │ │ - delete this.targets; │ │ │ │ - OpenLayers.Control.prototype.destroy.call(this); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Snapping" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.WMTS" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/CacheWrite.js │ │ │ │ + OpenLayers/Layer/MapServer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ - * @requires OpenLayers/Console.js │ │ │ │ + * @requires OpenLayers/Layer/Grid.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.CacheWrite │ │ │ │ - * A control for caching image tiles in the browser's local storage. The │ │ │ │ - * <OpenLayers.Control.CacheRead> control is used to fetch and use the cached │ │ │ │ - * tile images. │ │ │ │ - * │ │ │ │ - * Note: Before using this control on any layer that is not your own, make sure │ │ │ │ - * that the terms of service of the tile provider allow local storage of tiles. │ │ │ │ + * Class: OpenLayers.Layer.MapServer │ │ │ │ + * Instances of OpenLayers.Layer.MapServer are used to display │ │ │ │ + * data from a MapServer CGI instance. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Layer.Grid> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.CacheWrite = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * To register events in the constructor, configure <eventListeners>. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * cachefull - Triggered when the cache is full. Listeners receive an │ │ │ │ - * object with a tile property as first argument. The tile references │ │ │ │ - * the tile that couldn't be cached. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: eventListeners │ │ │ │ - * {Object} Object with event listeners, keyed by event name. An optional │ │ │ │ - * scope property defines the scope that listeners will be executed in. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * {Array(<OpenLayers.Layer.Grid>)}. Optional. If provided, caching │ │ │ │ - * will be enabled for these layers only, otherwise for all cacheable │ │ │ │ - * layers. │ │ │ │ - */ │ │ │ │ - layers: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: imageFormat │ │ │ │ - * {String} The image format used for caching. The default is "image/png". │ │ │ │ - * Supported formats depend on the user agent. If an unsupported │ │ │ │ - * <imageFormat> is provided, "image/png" will be used. For aerial │ │ │ │ - * imagery, "image/jpeg" is recommended. │ │ │ │ - */ │ │ │ │ - imageFormat: "image/png", │ │ │ │ +OpenLayers.Layer.MapServer = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: quotaRegEx │ │ │ │ - * {RegExp} │ │ │ │ + * Constant: DEFAULT_PARAMS │ │ │ │ + * {Object} Hashtable of default parameter key/value pairs │ │ │ │ */ │ │ │ │ - quotaRegEx: (/quota/i), │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + mode: "map", │ │ │ │ + map_imagetype: "png" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.CacheWrite │ │ │ │ + * Constructor: OpenLayers.Layer.MapServer │ │ │ │ + * Create a new MapServer layer object │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Object with API properties for this control. │ │ │ │ + * name - {String} A name for the layer │ │ │ │ + * url - {String} Base url for the MapServer CGI │ │ │ │ + * (e.g. http://www2.dmsolutions.ca/cgi-bin/mapserv) │ │ │ │ + * params - {Object} An object with key/value pairs representing the │ │ │ │ + * GetMap query string parameters and parameter values. │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - var i, layers = this.layers || map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.addLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (!this.layers) { │ │ │ │ - map.events.on({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + this.params = OpenLayers.Util.applyDefaults( │ │ │ │ + this.params, this.DEFAULT_PARAMS │ │ │ │ + ); │ │ │ │ + │ │ │ │ + // unless explicitly set in options, if the layer is transparent, │ │ │ │ + // it will be an overlay │ │ │ │ + if (options == null || options.isBaseLayer == null) { │ │ │ │ + this.isBaseLayer = ((this.params.transparent != "true") && │ │ │ │ + (this.params.transparent != true)); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addLayer │ │ │ │ - * Adds a layer to the control. Once added, tiles requested for this layer │ │ │ │ - * will be cached. │ │ │ │ + * Method: clone │ │ │ │ + * Create a clone of this layer │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} Object with a layer property referencing an │ │ │ │ - * <OpenLayers.Layer> instance │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.MapServer>} An exact clone of this layer │ │ │ │ */ │ │ │ │ - addLayer: function(evt) { │ │ │ │ - evt.layer.events.on({ │ │ │ │ - tileloadstart: this.makeSameOrigin, │ │ │ │ - tileloaded: this.onTileLoaded, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.MapServer(this.name, │ │ │ │ + this.url, │ │ │ │ + this.params, │ │ │ │ + this.getOptions()); │ │ │ │ + } │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeLayer │ │ │ │ - * Removes a layer from the control. Once removed, tiles requested for this │ │ │ │ - * layer will no longer be cached. │ │ │ │ + * Method: getURL │ │ │ │ + * Return a query string for this layer │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Object with a layer property referencing an │ │ │ │ - * <OpenLayers.Layer> instance │ │ │ │ + * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox │ │ │ │ + * for the request │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters and also │ │ │ │ + * the passed-in bounds and appropriate tile size specified │ │ │ │ + * as parameters. │ │ │ │ */ │ │ │ │ - removeLayer: function(evt) { │ │ │ │ - evt.layer.events.un({ │ │ │ │ - tileloadstart: this.makeSameOrigin, │ │ │ │ - tileloaded: this.onTileLoaded, │ │ │ │ - scope: this │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + // Make a list, so that getFullRequestString uses literal "," │ │ │ │ + var extent = [bounds.left, bounds.bottom, bounds.right, bounds.top]; │ │ │ │ + │ │ │ │ + var imageSize = this.getImageSize(); │ │ │ │ + │ │ │ │ + // make lists, so that literal ','s are used │ │ │ │ + var url = this.getFullRequestString({ │ │ │ │ + mapext: extent, │ │ │ │ + imgext: extent, │ │ │ │ + map_size: [imageSize.w, imageSize.h], │ │ │ │ + imgx: imageSize.w / 2, │ │ │ │ + imgy: imageSize.h / 2, │ │ │ │ + imgxy: [imageSize.w, imageSize.h] │ │ │ │ }); │ │ │ │ + │ │ │ │ + return url; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: makeSameOrigin │ │ │ │ - * If the tile does not have CORS image loading enabled and is from a │ │ │ │ - * different origin, use OpenLayers.ProxyHost to make it a same origin url. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: getFullRequestString │ │ │ │ + * combine the layer's url with its params and these newParams. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * newParams - {Object} New parameters that should be added to the │ │ │ │ + * request string. │ │ │ │ + * altUrl - {String} (optional) Replace the URL in the full request │ │ │ │ + * string with the provided URL. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string with the layer's url and parameters embedded in it. │ │ │ │ */ │ │ │ │ - makeSameOrigin: function(evt) { │ │ │ │ - if (this.active) { │ │ │ │ - var tile = evt.tile; │ │ │ │ - if (tile instanceof OpenLayers.Tile.Image && │ │ │ │ - !tile.crossOriginKeyword && │ │ │ │ - tile.url.substr(0, 5) !== "data:") { │ │ │ │ - var sameOriginUrl = OpenLayers.Request.makeSameOrigin( │ │ │ │ - tile.url, OpenLayers.ProxyHost │ │ │ │ - ); │ │ │ │ - OpenLayers.Control.CacheWrite.urlMap[sameOriginUrl] = tile.url; │ │ │ │ - tile.url = sameOriginUrl; │ │ │ │ + getFullRequestString: function(newParams, altUrl) { │ │ │ │ + // use layer's url unless altUrl passed in │ │ │ │ + var url = (altUrl == null) ? this.url : altUrl; │ │ │ │ + │ │ │ │ + // create a new params hashtable with all the layer params and the │ │ │ │ + // new params together. then convert to string │ │ │ │ + var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ + allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ + var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + │ │ │ │ + // if url is not a string, it should be an array of strings, │ │ │ │ + // in which case we will deterministically select one of them in │ │ │ │ + // order to evenly distribute requests to different urls. │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(paramsString, url); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // ignore parameters that are already in the url search string │ │ │ │ + var urlParams = OpenLayers.Util.upperCaseObject( │ │ │ │ + OpenLayers.Util.getParameters(url)); │ │ │ │ + for (var key in allParams) { │ │ │ │ + if (key.toUpperCase() in urlParams) { │ │ │ │ + delete allParams[key]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + │ │ │ │ + // requestString always starts with url │ │ │ │ + var requestString = url; │ │ │ │ + │ │ │ │ + // MapServer needs '+' seperating things like bounds/height/width. │ │ │ │ + // Since typically this is URL encoded, we use a slight hack: we │ │ │ │ + // depend on the list-like functionality of getParameterString to │ │ │ │ + // leave ',' only in the case of list items (since otherwise it is │ │ │ │ + // encoded) then do a regular expression replace on the , characters │ │ │ │ + // to '+' │ │ │ │ + // │ │ │ │ + paramsString = paramsString.replace(/,/g, "+"); │ │ │ │ + │ │ │ │ + if (paramsString != "") { │ │ │ │ + var lastServerChar = url.charAt(url.length - 1); │ │ │ │ + if ((lastServerChar == "&") || (lastServerChar == "?")) { │ │ │ │ + requestString += paramsString; │ │ │ │ + } else { │ │ │ │ + if (url.indexOf('?') == -1) { │ │ │ │ + //serverPath has no ? -- add one │ │ │ │ + requestString += '?' + paramsString; │ │ │ │ + } else { │ │ │ │ + //serverPath contains ?, so must already have paramsString at the end │ │ │ │ + requestString += '&' + paramsString; │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + return requestString; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.MapServer" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/Boxes.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer.js │ │ │ │ + * @requires OpenLayers/Layer/Markers.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.Boxes │ │ │ │ + * Draw divs as 'boxes' on the layer. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.Markers> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Boxes = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: onTileLoaded │ │ │ │ - * Decides whether a tile can be cached and calls the cache method. │ │ │ │ + * Constructor: OpenLayers.Layer.Boxes │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * name - {String} │ │ │ │ + * options - {Object} Hashtable of extra options to tag onto the layer │ │ │ │ */ │ │ │ │ - onTileLoaded: function(evt) { │ │ │ │ - if (this.active && !evt.aborted && │ │ │ │ - evt.tile instanceof OpenLayers.Tile.Image && │ │ │ │ - evt.tile.url.substr(0, 5) !== 'data:') { │ │ │ │ - this.cache({ │ │ │ │ - tile: evt.tile │ │ │ │ - }); │ │ │ │ - delete OpenLayers.Control.CacheWrite.urlMap[evt.tile.url]; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cache │ │ │ │ - * Adds a tile to the cache. When the cache is full, the "cachefull" event │ │ │ │ - * is triggered. │ │ │ │ + * Method: drawMarker │ │ │ │ + * Calculate the pixel location for the marker, create it, and │ │ │ │ + * add it to the layer's div │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} Object with a tile property, tile being the │ │ │ │ - * <OpenLayers.Tile.Image> with the data to add to the cache │ │ │ │ + * Parameters: │ │ │ │ + * marker - {<OpenLayers.Marker.Box>} │ │ │ │ */ │ │ │ │ - cache: function(obj) { │ │ │ │ - if (window.localStorage) { │ │ │ │ - var tile = obj.tile; │ │ │ │ - try { │ │ │ │ - var canvasContext = tile.getCanvasContext(); │ │ │ │ - if (canvasContext) { │ │ │ │ - var urlMap = OpenLayers.Control.CacheWrite.urlMap; │ │ │ │ - var url = urlMap[tile.url] || tile.url; │ │ │ │ - window.localStorage.setItem( │ │ │ │ - "olCache_" + url, │ │ │ │ - canvasContext.canvas.toDataURL(this.imageFormat) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } catch (e) { │ │ │ │ - // local storage full or CORS violation │ │ │ │ - var reason = e.name || e.message; │ │ │ │ - if (reason && this.quotaRegEx.test(reason)) { │ │ │ │ - this.events.triggerEvent("cachefull", { │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.error(e.toString()); │ │ │ │ - } │ │ │ │ + drawMarker: function(marker) { │ │ │ │ + var topleft = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: marker.bounds.left, │ │ │ │ + lat: marker.bounds.top │ │ │ │ + }); │ │ │ │ + var botright = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: marker.bounds.right, │ │ │ │ + lat: marker.bounds.bottom │ │ │ │ + }); │ │ │ │ + if (botright == null || topleft == null) { │ │ │ │ + marker.display(false); │ │ │ │ + } else { │ │ │ │ + var markerDiv = marker.draw(topleft, { │ │ │ │ + w: Math.max(1, botright.x - topleft.x), │ │ │ │ + h: Math.max(1, botright.y - topleft.y) │ │ │ │ + }); │ │ │ │ + if (!marker.drawn) { │ │ │ │ + this.div.appendChild(markerDiv); │ │ │ │ + marker.drawn = true; │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * APIMethod: removeMarker │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * marker - {<OpenLayers.Marker.Box>} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layers || this.map) { │ │ │ │ - var i, layers = this.layers || this.map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.un({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + removeMarker: function(marker) { │ │ │ │ + OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ + if ((marker.div != null) && │ │ │ │ + (marker.div.parentNode == this.div)) { │ │ │ │ + this.div.removeChild(marker.div); │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.CacheWrite" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Boxes" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * APIFunction: OpenLayers.Control.CacheWrite.clearCache │ │ │ │ - * Clears all tiles cached with <OpenLayers.Control.CacheWrite> from the cache. │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.CacheWrite.clearCache = function() { │ │ │ │ - if (!window.localStorage) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var i, key; │ │ │ │ - for (i = window.localStorage.length - 1; i >= 0; --i) { │ │ │ │ - key = window.localStorage.key(i); │ │ │ │ - if (key.substr(0, 8) === "olCache_") { │ │ │ │ - window.localStorage.removeItem(key); │ │ │ │ - } │ │ │ │ - } │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Property: OpenLayers.Control.CacheWrite.urlMap │ │ │ │ - * {Object} Mapping of same origin urls to cache url keys. Entries will be │ │ │ │ - * deleted as soon as a tile was cached. │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.CacheWrite.urlMap = {}; │ │ │ │ - │ │ │ │ - │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Drag.js │ │ │ │ + OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Layer/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Drag │ │ │ │ - * The drag handler is used to deal with sequences of browser events related │ │ │ │ - * to dragging. The handler is used by controls that want to know when │ │ │ │ - * a drag sequence begins, when a drag is happening, and when it has │ │ │ │ - * finished. │ │ │ │ - * │ │ │ │ - * Controls that use the drag handler typically construct it with callbacks │ │ │ │ - * for 'down', 'move', and 'done'. Callbacks for these keys are called │ │ │ │ - * when the drag begins, with each move, and when the drag is done. In │ │ │ │ - * addition, controls can have callbacks keyed to 'up' and 'out' if they │ │ │ │ - * care to differentiate between the types of events that correspond with │ │ │ │ - * the end of a drag sequence. If no drag actually occurs (no mouse move) │ │ │ │ - * the 'down' and 'up' callbacks will be called, but not the 'done' │ │ │ │ - * callback. │ │ │ │ - * │ │ │ │ - * Create a new drag handler with the <OpenLayers.Handler.Drag> constructor. │ │ │ │ + * Class: OpenLayers.Layer.Vector.RootContainer │ │ │ │ + * A special layer type to combine multiple vector layers inside a single │ │ │ │ + * renderer root container. This class is not supposed to be instantiated │ │ │ │ + * from user space, it is a helper class for controls that require event │ │ │ │ + * processing for multiple vector layers. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Layer.Vector> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: started │ │ │ │ - * {Boolean} When a mousedown or touchstart event is received, we want to │ │ │ │ - * record it, but not set 'dragging' until the mouse moves after starting. │ │ │ │ - */ │ │ │ │ - started: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: stopDown │ │ │ │ - * {Boolean} Stop propagation of mousedown events from getting to listeners │ │ │ │ - * on the same element. Default is true. │ │ │ │ - */ │ │ │ │ - stopDown: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: dragging │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - dragging: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: last │ │ │ │ - * {<OpenLayers.Pixel>} The last pixel location of the drag. │ │ │ │ - */ │ │ │ │ - last: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: start │ │ │ │ - * {<OpenLayers.Pixel>} The first pixel location of the drag. │ │ │ │ - */ │ │ │ │ - start: null, │ │ │ │ +OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: lastMoveEvt │ │ │ │ - * {Object} The last mousemove event that occurred. Used to │ │ │ │ - * position the map correctly when our "delay drag" │ │ │ │ - * timeout expired. │ │ │ │ + * Property: displayInLayerSwitcher │ │ │ │ + * Set to false for this layer type │ │ │ │ */ │ │ │ │ - lastMoveEvt: null, │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: oldOnselectstart │ │ │ │ - * {Function} │ │ │ │ + * APIProperty: layers │ │ │ │ + * Layers that are attached to this container. Required config option. │ │ │ │ */ │ │ │ │ - oldOnselectstart: null, │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: interval │ │ │ │ - * {Integer} In order to increase performance, an interval (in │ │ │ │ - * milliseconds) can be set to reduce the number of drag events │ │ │ │ - * called. If set, a new drag event will not be set until the │ │ │ │ - * interval has passed. │ │ │ │ - * Defaults to 0, meaning no interval. │ │ │ │ + * Constructor: OpenLayers.Layer.Vector.RootContainer │ │ │ │ + * Create a new root container for multiple vector layer. This constructor │ │ │ │ + * is not supposed to be used from user space, it is only to be used by │ │ │ │ + * controls that need feature selection across multiple vector layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} A name for the layer │ │ │ │ + * options - {Object} Optional object with non-default properties to set on │ │ │ │ + * the layer. │ │ │ │ + * │ │ │ │ + * Required options properties: │ │ │ │ + * layers - {Array(<OpenLayers.Layer.Vector>)} The layers managed by this │ │ │ │ + * container │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Vector.RootContainer>} A new vector layer root │ │ │ │ + * container │ │ │ │ */ │ │ │ │ - interval: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timeoutId │ │ │ │ - * {String} The id of the timeout used for the mousedown interval. │ │ │ │ - * This is "private", and should be left alone. │ │ │ │ + * Method: display │ │ │ │ */ │ │ │ │ - timeoutId: null, │ │ │ │ + display: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} If set to true, the handler will also handle mouse moves when │ │ │ │ - * the cursor has moved out of the map viewport. Default is false. │ │ │ │ + * Method: getFeatureFromEvent │ │ │ │ + * walk through the layers to find the feature returned by the event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} event object with a feature property │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - documentDrag: false, │ │ │ │ + getFeatureFromEvent: function(evt) { │ │ │ │ + var layers = this.layers; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0; i < layers.length; i++) { │ │ │ │ + feature = layers[i].getFeatureFromEvent(evt); │ │ │ │ + if (feature) { │ │ │ │ + return feature; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: documentEvents │ │ │ │ - * {Boolean} Are we currently observing document events? │ │ │ │ + * Method: setMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - documentEvents: null, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ + this.collectRoots(); │ │ │ │ + map.events.register("changelayer", this, this.handleChangeLayer); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Drag │ │ │ │ - * Returns OpenLayers.Handler.Drag │ │ │ │ + * Method: removeMap │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ - * this handler. If a handler is being used without a control, the │ │ │ │ - * handlers setMap method must be overridden to deal properly with │ │ │ │ - * the map. │ │ │ │ - * callbacks - {Object} An object containing a single function to be │ │ │ │ - * called when the drag operation is finished. The callback should │ │ │ │ - * expect to recieve a single argument, the pixel location of the event. │ │ │ │ - * Callbacks for 'move' and 'done' are supported. You can also speficy │ │ │ │ - * callbacks for 'down', 'up', and 'out' to respond to those events. │ │ │ │ - * options - {Object} │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - var me = this; │ │ │ │ - this._docMove = function(evt) { │ │ │ │ - me.mousemove({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - }, │ │ │ │ - element: document │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - this._docUp = function(evt) { │ │ │ │ - me.mouseup({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + removeMap: function(map) { │ │ │ │ + map.events.unregister("changelayer", this, this.handleChangeLayer); │ │ │ │ + this.resetRoots(); │ │ │ │ + OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: dragstart │ │ │ │ - * This private method is factorized from mousedown and touchstart methods │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Method: collectRoots │ │ │ │ + * Collects the root nodes of all layers this control is configured with │ │ │ │ + * and moveswien the nodes to this control's layer │ │ │ │ */ │ │ │ │ - dragstart: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - this.dragging = false; │ │ │ │ - if (this.checkModifiers(evt) && │ │ │ │ - (OpenLayers.Event.isLeftClick(evt) || │ │ │ │ - OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ - this.started = true; │ │ │ │ - this.start = evt.xy; │ │ │ │ - this.last = evt.xy; │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - this.down(evt); │ │ │ │ - this.callback("down", [evt.xy]); │ │ │ │ - │ │ │ │ - // prevent document dragging │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart ? │ │ │ │ - document.onselectstart : OpenLayers.Function.True; │ │ │ │ + collectRoots: function() { │ │ │ │ + var layer; │ │ │ │ + // walk through all map layers, because we want to keep the order │ │ │ │ + for (var i = 0; i < this.map.layers.length; ++i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ + layer.renderer.moveRoot(this.renderer); │ │ │ │ } │ │ │ │ - document.onselectstart = OpenLayers.Function.False; │ │ │ │ - │ │ │ │ - propagate = !this.stopDown; │ │ │ │ - } else { │ │ │ │ - this.started = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ } │ │ │ │ - return propagate; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragmove │ │ │ │ - * This private method is factorized from mousemove and touchmove methods │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Method: resetRoots │ │ │ │ + * Resets the root nodes back into the layers they belong to. │ │ │ │ */ │ │ │ │ - dragmove: function(evt) { │ │ │ │ - this.lastMoveEvt = evt; │ │ │ │ - if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || │ │ │ │ - evt.xy.y != this.last.y)) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - if (evt.element === document) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - // do setEvent manually because the documentEvents are not │ │ │ │ - // registered with the map │ │ │ │ - this.setEvent(evt); │ │ │ │ - } else { │ │ │ │ - this.removeDocumentEvents(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.interval > 0) { │ │ │ │ - this.timeoutId = setTimeout( │ │ │ │ - OpenLayers.Function.bind(this.removeTimeout, this), │ │ │ │ - this.interval); │ │ │ │ - } │ │ │ │ - this.dragging = true; │ │ │ │ - │ │ │ │ - this.move(evt); │ │ │ │ - this.callback("move", [evt.xy]); │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart; │ │ │ │ - document.onselectstart = OpenLayers.Function.False; │ │ │ │ + resetRoots: function() { │ │ │ │ + var layer; │ │ │ │ + for (var i = 0; i < this.layers.length; ++i) { │ │ │ │ + layer = this.layers[i]; │ │ │ │ + if (this.renderer && layer.renderer.getRenderLayerId() == this.id) { │ │ │ │ + this.renderer.moveRoot(layer.renderer); │ │ │ │ } │ │ │ │ - this.last = evt.xy; │ │ │ │ } │ │ │ │ - return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragend │ │ │ │ - * This private method is factorized from mouseup and touchend methods │ │ │ │ - * │ │ │ │ + * Method: handleChangeLayer │ │ │ │ + * Event handler for the map's changelayer event. We need to rebuild │ │ │ │ + * this container's layer dom if order of one of its layers changes. │ │ │ │ + * This handler is added with the setMap method, and removed with the │ │ │ │ + * removeMap method. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} The event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - dragend: function(evt) { │ │ │ │ - if (this.started) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - this.removeDocumentEvents(); │ │ │ │ - } │ │ │ │ - var dragged = (this.start != this.last); │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - this.up(evt); │ │ │ │ - this.callback("up", [evt.xy]); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]); │ │ │ │ - } │ │ │ │ - document.onselectstart = this.oldOnselectstart; │ │ │ │ + handleChangeLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (evt.property == "order" && │ │ │ │ + OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ + this.resetRoots(); │ │ │ │ + this.collectRoots(); │ │ │ │ } │ │ │ │ - return true; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * The four methods below (down, move, up, and out) are used by subclasses │ │ │ │ - * to do their own processing related to these mouse events. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: down │ │ │ │ - * This method is called during the handling of the mouse down event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse down event │ │ │ │ - */ │ │ │ │ - down: function(evt) {}, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer/Google/v3.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: move │ │ │ │ - * This method is called during the handling of the mouse move event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse move event │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - move: function(evt) {}, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: up │ │ │ │ - * This method is called during the handling of the mouse up event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse up event │ │ │ │ - */ │ │ │ │ - up: function(evt) {}, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: out │ │ │ │ - * This method is called during the handling of the mouse out event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse out event │ │ │ │ - */ │ │ │ │ - out: function(evt) {}, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/Google.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * The methods below are part of the magic of event handling. Because │ │ │ │ - * they are named like browser events, they are registered as listeners │ │ │ │ - * for the events they represent. │ │ │ │ - */ │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Layer.Google.v3 │ │ │ │ + * │ │ │ │ + * Mixin providing functionality specific to the Google Maps API v3. │ │ │ │ + * │ │ │ │ + * To use this layer, you must include the GMaps v3 API in your html. │ │ │ │ + * │ │ │ │ + * Note that this layer configures the google.maps.map object with the │ │ │ │ + * "disableDefaultUI" option set to true. Using UI controls that the Google │ │ │ │ + * Maps API provides is not supported by the OpenLayers API. │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Google.v3 = { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mousedown events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Constant: DEFAULTS │ │ │ │ + * {Object} It is not recommended to change the properties set here. Note │ │ │ │ + * that Google.v3 layers only work when sphericalMercator is set to true. │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * { │ │ │ │ + * sphericalMercator: true, │ │ │ │ + * projection: "EPSG:900913" │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - return this.dragstart(evt); │ │ │ │ + DEFAULTS: { │ │ │ │ + sphericalMercator: true, │ │ │ │ + projection: "EPSG:900913" │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * APIProperty: animationEnabled │ │ │ │ + * {Boolean} If set to true, the transition between zoom levels will be │ │ │ │ + * animated (if supported by the GMaps API for the device used). Set to │ │ │ │ + * false to match the zooming experience of other layer types. Default │ │ │ │ + * is true. Note that the GMaps API does not give us control over zoom │ │ │ │ + * animation, so if set to false, when zooming, this will make the │ │ │ │ + * layer temporarily invisible, wait until GMaps reports the map being │ │ │ │ + * idle, and make it visible again. The result will be a blank layer │ │ │ │ + * for a few moments while zooming. │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return this.dragstart(evt); │ │ │ │ - }, │ │ │ │ + animationEnabled: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mousemove │ │ │ │ - * Handle mousemove events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + /** │ │ │ │ + * Method: loadMapObject │ │ │ │ + * Load the GMap and register appropriate event listeners. │ │ │ │ */ │ │ │ │ - mousemove: function(evt) { │ │ │ │ - return this.dragmove(evt); │ │ │ │ - }, │ │ │ │ + loadMapObject: function() { │ │ │ │ + if (!this.type) { │ │ │ │ + this.type = google.maps.MapTypeId.ROADMAP; │ │ │ │ + } │ │ │ │ + var mapObject; │ │ │ │ + var cache = OpenLayers.Layer.Google.cache[this.map.id]; │ │ │ │ + if (cache) { │ │ │ │ + // there are already Google layers added to this map │ │ │ │ + mapObject = cache.mapObject; │ │ │ │ + // increment the layer count │ │ │ │ + ++cache.count; │ │ │ │ + } else { │ │ │ │ + // this is the first Google layer for this map │ │ │ │ + // create GMap │ │ │ │ + var center = this.map.getCenter(); │ │ │ │ + var container = document.createElement('div'); │ │ │ │ + container.className = "olForeignContainer"; │ │ │ │ + container.style.width = '100%'; │ │ │ │ + container.style.height = '100%'; │ │ │ │ + mapObject = new google.maps.Map(container, { │ │ │ │ + center: center ? │ │ │ │ + new google.maps.LatLng(center.lat, center.lon) : new google.maps.LatLng(0, 0), │ │ │ │ + zoom: this.map.getZoom() || 0, │ │ │ │ + mapTypeId: this.type, │ │ │ │ + disableDefaultUI: true, │ │ │ │ + keyboardShortcuts: false, │ │ │ │ + draggable: false, │ │ │ │ + disableDoubleClickZoom: true, │ │ │ │ + scrollwheel: false, │ │ │ │ + streetViewControl: false │ │ │ │ + }); │ │ │ │ + var googleControl = document.createElement('div'); │ │ │ │ + googleControl.style.width = '100%'; │ │ │ │ + googleControl.style.height = '100%'; │ │ │ │ + mapObject.controls[google.maps.ControlPosition.TOP_LEFT].push(googleControl); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Handle touchmove events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ - */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - return this.dragmove(evt); │ │ │ │ + // cache elements for use by any other google layers added to │ │ │ │ + // this same map │ │ │ │ + cache = { │ │ │ │ + googleControl: googleControl, │ │ │ │ + mapObject: mapObject, │ │ │ │ + count: 1 │ │ │ │ + }; │ │ │ │ + OpenLayers.Layer.Google.cache[this.map.id] = cache; │ │ │ │ + } │ │ │ │ + this.mapObject = mapObject; │ │ │ │ + this.setGMapVisibility(this.visibility); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeTimeout │ │ │ │ - * Private. Called by mousemove() to remove the drag timeout. │ │ │ │ + * APIMethod: onMapResize │ │ │ │ */ │ │ │ │ - removeTimeout: function() { │ │ │ │ - this.timeoutId = null; │ │ │ │ - // if timeout expires while we're still dragging (mouseup │ │ │ │ - // hasn't occurred) then call mousemove to move to the │ │ │ │ - // correct position │ │ │ │ - if (this.dragging) { │ │ │ │ - this.mousemove(this.lastMoveEvt); │ │ │ │ + onMapResize: function() { │ │ │ │ + if (this.visibility) { │ │ │ │ + google.maps.event.trigger(this.mapObject, "resize"); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouseup events │ │ │ │ - * │ │ │ │ + * Method: setGMapVisibility │ │ │ │ + * Display the GMap container and associated elements. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * visible - {Boolean} Display the GMap elements. │ │ │ │ */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - return this.dragend(evt); │ │ │ │ + setGMapVisibility: function(visible) { │ │ │ │ + var cache = OpenLayers.Layer.Google.cache[this.map.id]; │ │ │ │ + var map = this.map; │ │ │ │ + if (cache) { │ │ │ │ + var type = this.type; │ │ │ │ + var layers = map.layers; │ │ │ │ + var layer; │ │ │ │ + for (var i = layers.length - 1; i >= 0; --i) { │ │ │ │ + layer = layers[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Google && │ │ │ │ + layer.visibility === true && layer.inRange === true) { │ │ │ │ + type = layer.type; │ │ │ │ + visible = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var container = this.mapObject.getDiv(); │ │ │ │ + if (visible === true) { │ │ │ │ + if (container.parentNode !== map.div) { │ │ │ │ + if (!cache.rendered) { │ │ │ │ + var me = this; │ │ │ │ + google.maps.event.addListenerOnce(this.mapObject, 'tilesloaded', function() { │ │ │ │ + cache.rendered = true; │ │ │ │ + me.setGMapVisibility(me.getVisibility()); │ │ │ │ + me.moveTo(me.map.getCenter()); │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + map.div.appendChild(container); │ │ │ │ + cache.googleControl.appendChild(map.viewPortDiv); │ │ │ │ + google.maps.event.trigger(this.mapObject, 'resize'); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.mapObject.setMapTypeId(type); │ │ │ │ + } else if (cache.googleControl.hasChildNodes()) { │ │ │ │ + map.div.appendChild(map.viewPortDiv); │ │ │ │ + map.div.removeChild(container); │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchend │ │ │ │ - * Handle touchend events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ + * Method: getMapContainer │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {DOMElement} the GMap container's div │ │ │ │ */ │ │ │ │ - touchend: function(evt) { │ │ │ │ - // override evt.xy with last position since touchend does not have │ │ │ │ - // any touch position │ │ │ │ - evt.xy = this.last; │ │ │ │ - return this.dragend(evt); │ │ │ │ + getMapContainer: function() { │ │ │ │ + return this.mapObject.getDiv(); │ │ │ │ }, │ │ │ │ │ │ │ │ + // │ │ │ │ + // TRANSLATION: MapObject Bounds <-> OpenLayers.Bounds │ │ │ │ + // │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: mouseout │ │ │ │ - * Handle mouseout events │ │ │ │ - * │ │ │ │ + * APIMethod: getMapObjectBoundsFromOLBounds │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ + * olBounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {Object} A MapObject Bounds, translated from olBounds │ │ │ │ + * Returns null if null value is passed in │ │ │ │ */ │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - this.addDocumentEvents(); │ │ │ │ - } else { │ │ │ │ - var dragged = (this.start != this.last); │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - this.out(evt); │ │ │ │ - this.callback("out", []); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]); │ │ │ │ - } │ │ │ │ - if (document.onselectstart) { │ │ │ │ - document.onselectstart = this.oldOnselectstart; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + getMapObjectBoundsFromOLBounds: function(olBounds) { │ │ │ │ + var moBounds = null; │ │ │ │ + if (olBounds != null) { │ │ │ │ + var sw = this.sphericalMercator ? │ │ │ │ + this.inverseMercator(olBounds.bottom, olBounds.left) : │ │ │ │ + new OpenLayers.LonLat(olBounds.bottom, olBounds.left); │ │ │ │ + var ne = this.sphericalMercator ? │ │ │ │ + this.inverseMercator(olBounds.top, olBounds.right) : │ │ │ │ + new OpenLayers.LonLat(olBounds.top, olBounds.right); │ │ │ │ + moBounds = new google.maps.LatLngBounds( │ │ │ │ + new google.maps.LatLng(sw.lat, sw.lon), │ │ │ │ + new google.maps.LatLng(ne.lat, ne.lon) │ │ │ │ + ); │ │ │ │ } │ │ │ │ - return true; │ │ │ │ + return moBounds; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ + /************************************ │ │ │ │ + * * │ │ │ │ + * MapObject Interface Controls * │ │ │ │ + * * │ │ │ │ + ************************************/ │ │ │ │ + │ │ │ │ + │ │ │ │ + // LonLat - Pixel Translation │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: click │ │ │ │ - * The drag handler captures the click event. If something else registers │ │ │ │ - * for clicks on the same element, its listener will not be called │ │ │ │ - * after a drag. │ │ │ │ + * APIMethod: getMapObjectLonLatFromMapObjectPixel │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Parameters: │ │ │ │ + * moPixel - {Object} MapObject Pixel format │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {Object} MapObject LonLat translated from MapObject Pixel │ │ │ │ */ │ │ │ │ - click: function(evt) { │ │ │ │ - // let the click event propagate only if the mouse moved │ │ │ │ - return (this.start == this.last); │ │ │ │ + getMapObjectLonLatFromMapObjectPixel: function(moPixel) { │ │ │ │ + var size = this.map.getSize(); │ │ │ │ + var lon = this.getLongitudeFromMapObjectLonLat(this.mapObject.center); │ │ │ │ + var lat = this.getLatitudeFromMapObjectLonLat(this.mapObject.center); │ │ │ │ + var res = this.map.getResolution(); │ │ │ │ + │ │ │ │ + var delta_x = moPixel.x - (size.w / 2); │ │ │ │ + var delta_y = moPixel.y - (size.h / 2); │ │ │ │ + │ │ │ │ + var lonlat = new OpenLayers.LonLat( │ │ │ │ + lon + delta_x * res, │ │ │ │ + lat - delta_y * res │ │ │ │ + ); │ │ │ │ + │ │ │ │ + if (this.wrapDateLine) { │ │ │ │ + lonlat = lonlat.wrapDateLine(this.maxExtent); │ │ │ │ + } │ │ │ │ + return this.getMapObjectLonLatFromLonLat(lonlat.lon, lonlat.lat); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the handler. │ │ │ │ + * APIMethod: getMapObjectPixelFromMapObjectLonLat │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * moLonLat - {Object} MapObject LonLat format │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The handler was successfully activated. │ │ │ │ + * {Object} MapObject Pixel transtlated from MapObject LonLat │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragging = false; │ │ │ │ - activated = true; │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ + getMapObjectPixelFromMapObjectLonLat: function(moLonLat) { │ │ │ │ + var lon = this.getLongitudeFromMapObjectLonLat(moLonLat); │ │ │ │ + var lat = this.getLatitudeFromMapObjectLonLat(moLonLat); │ │ │ │ + var res = this.map.getResolution(); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + return this.getMapObjectPixelFromXY((1 / res * (lon - extent.left)), │ │ │ │ + (1 / res * (extent.top - lat))); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivate the handler. │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setMapObjectCenter │ │ │ │ + * Set the mapObject to the specified center and zoom │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated. │ │ │ │ + * Parameters: │ │ │ │ + * center - {Object} MapObject LonLat format │ │ │ │ + * zoom - {int} MapObject zoom format │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ + setMapObjectCenter: function(center, zoom) { │ │ │ │ + if (this.animationEnabled === false && zoom != this.mapObject.zoom) { │ │ │ │ + var mapContainer = this.getMapContainer(); │ │ │ │ + google.maps.event.addListenerOnce( │ │ │ │ + this.mapObject, │ │ │ │ + "idle", │ │ │ │ + function() { │ │ │ │ + mapContainer.style.visibility = ""; │ │ │ │ + } │ │ │ │ ); │ │ │ │ + mapContainer.style.visibility = "hidden"; │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + this.mapObject.setOptions({ │ │ │ │ + center: center, │ │ │ │ + zoom: zoom │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: adjustXY │ │ │ │ - * Converts event coordinates that are relative to the document body to │ │ │ │ - * ones that are relative to the map viewport. The latter is the default in │ │ │ │ - * OpenLayers. │ │ │ │ + │ │ │ │ + // Bounds │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getMapObjectZoomFromMapObjectBounds │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ + * moBounds - {Object} MapObject Bounds format │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} MapObject Zoom for specified MapObject Bounds │ │ │ │ */ │ │ │ │ - adjustXY: function(evt) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ - evt.xy.x -= pos[0]; │ │ │ │ - evt.xy.y -= pos[1]; │ │ │ │ + getMapObjectZoomFromMapObjectBounds: function(moBounds) { │ │ │ │ + return this.mapObject.getBoundsZoomLevel(moBounds); │ │ │ │ }, │ │ │ │ │ │ │ │ + /************************************ │ │ │ │ + * * │ │ │ │ + * MapObject Primitives * │ │ │ │ + * * │ │ │ │ + ************************************/ │ │ │ │ + │ │ │ │ + │ │ │ │ + // LonLat │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: addDocumentEvents │ │ │ │ - * Start observing document events when documentDrag is true and the mouse │ │ │ │ - * cursor leaves the map viewport while dragging. │ │ │ │ + * APIMethod: getMapObjectLonLatFromLonLat │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lon - {Float} │ │ │ │ + * lat - {Float} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} MapObject LonLat built from lon and lat params │ │ │ │ */ │ │ │ │ - addDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = true; │ │ │ │ - OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.observe(document, "mouseup", this._docUp); │ │ │ │ + getMapObjectLonLatFromLonLat: function(lon, lat) { │ │ │ │ + var gLatLng; │ │ │ │ + if (this.sphericalMercator) { │ │ │ │ + var lonlat = this.inverseMercator(lon, lat); │ │ │ │ + gLatLng = new google.maps.LatLng(lonlat.lat, lonlat.lon); │ │ │ │ + } else { │ │ │ │ + gLatLng = new google.maps.LatLng(lat, lon); │ │ │ │ + } │ │ │ │ + return gLatLng; │ │ │ │ }, │ │ │ │ │ │ │ │ + // Pixel │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: removeDocumentEvents │ │ │ │ - * Stops observing document events when documentDrag is true and the mouse │ │ │ │ - * cursor re-enters the map viewport while dragging. │ │ │ │ + * APIMethod: getMapObjectPixelFromXY │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Integer} │ │ │ │ + * y - {Integer} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} MapObject Pixel from x and y parameters │ │ │ │ */ │ │ │ │ - removeDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = false; │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mouseup", this._docUp); │ │ │ │ - }, │ │ │ │ + getMapObjectPixelFromXY: function(x, y) { │ │ │ │ + return new google.maps.Point(x, y); │ │ │ │ + } │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ -}); │ │ │ │ +}; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Feature.js │ │ │ │ + OpenLayers/Tile/Image/IFrame.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Tile/Image.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Feature │ │ │ │ - * Handler to respond to mouse events related to a drawn feature. Callbacks │ │ │ │ - * with the following keys will be notified of the following events │ │ │ │ - * associated with features: click, clickout, over, out, and dblclick. │ │ │ │ - * │ │ │ │ - * This handler stops event propagation for mousedown and mouseup if those │ │ │ │ - * browser events target features that can be selected. │ │ │ │ + * Constant: OpenLayers.Tile.Image.IFrame │ │ │ │ + * Mixin for tiles that use form-encoded POST requests to get images from │ │ │ │ + * remote services. Images will be loaded using HTTP-POST into an IFrame. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * This mixin will be applied to <OpenLayers.Tile.Image> instances │ │ │ │ + * configured with <OpenLayers.Tile.Image.maxGetUrlLength> set. │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ +OpenLayers.Tile.Image.IFrame = { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: EVENTMAP │ │ │ │ - * {Object} A object mapping the browser events to objects with callback │ │ │ │ - * keys for in and out. │ │ │ │ + * Property: useIFrame │ │ │ │ + * {Boolean} true if we are currently using an IFrame to render POST │ │ │ │ + * responses, false if we are using an img element to render GET responses. │ │ │ │ */ │ │ │ │ - EVENTMAP: { │ │ │ │ - 'click': { │ │ │ │ - 'in': 'click', │ │ │ │ - 'out': 'clickout' │ │ │ │ - }, │ │ │ │ - 'mousemove': { │ │ │ │ - 'in': 'over', │ │ │ │ - 'out': 'out' │ │ │ │ - }, │ │ │ │ - 'dblclick': { │ │ │ │ - 'in': 'dblclick', │ │ │ │ - 'out': null │ │ │ │ - }, │ │ │ │ - 'mousedown': { │ │ │ │ - 'in': null, │ │ │ │ - 'out': null │ │ │ │ - }, │ │ │ │ - 'mouseup': { │ │ │ │ - 'in': null, │ │ │ │ - 'out': null │ │ │ │ - }, │ │ │ │ - 'touchstart': { │ │ │ │ - 'in': 'click', │ │ │ │ - 'out': 'clickout' │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + useIFrame: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The last feature that was hovered. │ │ │ │ + * Property: blankImageUrl │ │ │ │ + * {String} Using a data scheme url is not supported by all browsers, but │ │ │ │ + * we don't care because we either set it as css backgroundImage, or the │ │ │ │ + * image's display style is set to "none" when we use it. │ │ │ │ */ │ │ │ │ - feature: null, │ │ │ │ + blankImageUrl: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAQAIBRAA7", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: lastFeature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The last feature that was handled. │ │ │ │ + * Method: draw │ │ │ │ + * Set useIFrame in the instance, and operate the image/iframe switch. │ │ │ │ + * Then call Tile.Image.draw. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - lastFeature: null, │ │ │ │ + draw: function() { │ │ │ │ + var draw = OpenLayers.Tile.Image.prototype.shouldDraw.call(this); │ │ │ │ + if (draw) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: down │ │ │ │ - * {<OpenLayers.Pixel>} The location of the last mousedown. │ │ │ │ - */ │ │ │ │ - down: null, │ │ │ │ + // this.url isn't set to the currect value yet, so we call getURL │ │ │ │ + // on the layer and store the result in a local variable │ │ │ │ + var url = this.layer.getURL(this.bounds); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: up │ │ │ │ - * {<OpenLayers.Pixel>} The location of the last mouseup. │ │ │ │ - */ │ │ │ │ - up: null, │ │ │ │ + var usedIFrame = this.useIFrame; │ │ │ │ + this.useIFrame = this.maxGetUrlLength !== null && │ │ │ │ + !this.layer.async && │ │ │ │ + url.length > this.maxGetUrlLength; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: clickTolerance │ │ │ │ - * {Number} The number of pixels the mouse can move between mousedown │ │ │ │ - * and mouseup for the event to still be considered a click. │ │ │ │ - * Dragging the map should not trigger the click and clickout callbacks │ │ │ │ - * unless the map is moved by less than this tolerance. Defaults to 4. │ │ │ │ - */ │ │ │ │ - clickTolerance: 4, │ │ │ │ + var fromIFrame = usedIFrame && !this.useIFrame; │ │ │ │ + var toIFrame = !usedIFrame && this.useIFrame; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: geometryTypes │ │ │ │ - * To restrict dragging to a limited set of geometry types, send a list │ │ │ │ - * of strings corresponding to the geometry class names. │ │ │ │ - * │ │ │ │ - * @type Array(String) │ │ │ │ - */ │ │ │ │ - geometryTypes: null, │ │ │ │ + if (fromIFrame || toIFrame) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: stopClick │ │ │ │ - * {Boolean} If stopClick is set to true, handled clicks do not │ │ │ │ - * propagate to other click listeners. Otherwise, handled clicks │ │ │ │ - * do propagate. Unhandled clicks always propagate, whatever the │ │ │ │ - * value of stopClick. Defaults to true. │ │ │ │ - */ │ │ │ │ - stopClick: true, │ │ │ │ + // Switching between GET (image) and POST (iframe). │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: stopDown │ │ │ │ - * {Boolean} If stopDown is set to true, handled mousedowns do not │ │ │ │ - * propagate to other mousedown listeners. Otherwise, handled │ │ │ │ - * mousedowns do propagate. Unhandled mousedowns always propagate, │ │ │ │ - * whatever the value of stopDown. Defaults to true. │ │ │ │ - */ │ │ │ │ - stopDown: true, │ │ │ │ + // We remove the imgDiv (really either an image or an iframe) │ │ │ │ + // from the frame and set it to null to make sure initImage │ │ │ │ + // will call getImage. │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: stopUp │ │ │ │ - * {Boolean} If stopUp is set to true, handled mouseups do not │ │ │ │ - * propagate to other mouseup listeners. Otherwise, handled mouseups │ │ │ │ - * do propagate. Unhandled mouseups always propagate, whatever the │ │ │ │ - * value of stopUp. Defaults to false. │ │ │ │ - */ │ │ │ │ - stopUp: false, │ │ │ │ + if (this.imgDiv && this.imgDiv.parentNode === this.frame) { │ │ │ │ + this.frame.removeChild(this.imgDiv); │ │ │ │ + } │ │ │ │ + this.imgDiv = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Handler.Feature │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ - * callbacks - {Object} An object with a 'over' property whos value is │ │ │ │ - * a function to be called when the mouse is over a feature. The │ │ │ │ - * callback should expect to recieve a single argument, the feature. │ │ │ │ - * options - {Object} │ │ │ │ - */ │ │ │ │ - initialize: function(control, layer, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ - this.layer = layer; │ │ │ │ + // And if we had an iframe we also remove the event pane. │ │ │ │ + │ │ │ │ + if (fromIFrame) { │ │ │ │ + this.frame.removeChild(this.frame.firstChild); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Tile.Image.prototype.draw.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Method: getImage │ │ │ │ + * Creates the content for the frame on the tile. │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return OpenLayers.Event.isMultiTouch(evt) ? │ │ │ │ - true : this.mousedown(evt); │ │ │ │ + getImage: function() { │ │ │ │ + if (this.useIFrame === true) { │ │ │ │ + if (!this.frame.childNodes.length) { │ │ │ │ + var eventPane = document.createElement("div"), │ │ │ │ + style = eventPane.style; │ │ │ │ + style.position = "absolute"; │ │ │ │ + style.width = "100%"; │ │ │ │ + style.height = "100%"; │ │ │ │ + style.zIndex = 1; │ │ │ │ + style.backgroundImage = "url(" + this.blankImageUrl + ")"; │ │ │ │ + this.frame.appendChild(eventPane); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var id = this.id + '_iFrame', │ │ │ │ + iframe; │ │ │ │ + if (parseFloat(navigator.appVersion.split("MSIE")[1]) < 9) { │ │ │ │ + // Older IE versions do not set the name attribute of an iFrame │ │ │ │ + // properly via DOM manipulation, so we need to do it on our own with │ │ │ │ + // this hack. │ │ │ │ + iframe = document.createElement('<iframe name="' + id + '">'); │ │ │ │ + │ │ │ │ + // IFrames in older IE versions are not transparent, if you set │ │ │ │ + // the backgroundColor transparent. This is a workaround to get │ │ │ │ + // transparent iframes. │ │ │ │ + iframe.style.backgroundColor = '#FFFFFF'; │ │ │ │ + iframe.style.filter = 'chroma(color=#FFFFFF)'; │ │ │ │ + } else { │ │ │ │ + iframe = document.createElement('iframe'); │ │ │ │ + iframe.style.backgroundColor = 'transparent'; │ │ │ │ + │ │ │ │ + // iframe.name needs to be an unique id, otherwise it │ │ │ │ + // could happen that other iframes are overwritten. │ │ │ │ + iframe.name = id; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // some special properties to avoid scaling the images and scrollbars │ │ │ │ + // in the iframe │ │ │ │ + iframe.scrolling = 'no'; │ │ │ │ + iframe.marginWidth = '0px'; │ │ │ │ + iframe.marginHeight = '0px'; │ │ │ │ + iframe.frameBorder = '0'; │ │ │ │ + │ │ │ │ + iframe.style.position = "absolute"; │ │ │ │ + iframe.style.width = "100%"; │ │ │ │ + iframe.style.height = "100%"; │ │ │ │ + │ │ │ │ + if (this.layer.opacity < 1) { │ │ │ │ + OpenLayers.Util.modifyDOMElement(iframe, null, null, null, │ │ │ │ + null, null, null, this.layer.opacity); │ │ │ │ + } │ │ │ │ + this.frame.appendChild(iframe); │ │ │ │ + this.imgDiv = iframe; │ │ │ │ + return iframe; │ │ │ │ + } else { │ │ │ │ + return OpenLayers.Tile.Image.prototype.getImage.apply(this, arguments); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Handle touchmove events. We just prevent the browser default behavior, │ │ │ │ - * for Android Webkit not to select text when moving the finger after │ │ │ │ - * selecting a feature. │ │ │ │ + * Method: createRequestForm │ │ │ │ + * Create the html <form> element with width, height, bbox and all │ │ │ │ + * parameters specified in the layer params. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The form element which sends the HTTP-POST request to the │ │ │ │ + * WMS. │ │ │ │ */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - }, │ │ │ │ + createRequestForm: function() { │ │ │ │ + // creation of the form element │ │ │ │ + var form = document.createElement('form'); │ │ │ │ + form.method = 'POST'; │ │ │ │ + var cacheId = this.layer.params["_OLSALT"]; │ │ │ │ + cacheId = (cacheId ? cacheId + "_" : "") + this.bounds.toBBOX(); │ │ │ │ + form.action = OpenLayers.Util.urlAppend(this.layer.url, cacheId); │ │ │ │ + form.target = this.id + '_iFrame'; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mouse down. Stop propagation if a feature is targeted by this │ │ │ │ - * event (stops map dragging during feature selection). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - // Feature selection is only done with a left click. Other handlers may stop the │ │ │ │ - // propagation of left-click mousedown events but not right-click mousedown events. │ │ │ │ - // This mismatch causes problems when comparing the location of the down and up │ │ │ │ - // events in the click function so it is important ignore right-clicks. │ │ │ │ - if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ - this.down = evt.xy; │ │ │ │ + // adding all parameters in layer params as hidden fields to the html │ │ │ │ + // form element │ │ │ │ + var imageSize = this.layer.getImageSize(), │ │ │ │ + params = OpenLayers.Util.getParameters(this.url), │ │ │ │ + field; │ │ │ │ + │ │ │ │ + for (var par in params) { │ │ │ │ + field = document.createElement('input'); │ │ │ │ + field.type = 'hidden'; │ │ │ │ + field.name = par; │ │ │ │ + field.value = params[par]; │ │ │ │ + form.appendChild(field); │ │ │ │ } │ │ │ │ - return this.handle(evt) ? !this.stopDown : true; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouse up. Stop propagation if a feature is targeted by this │ │ │ │ - * event. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - this.up = evt.xy; │ │ │ │ - return this.handle(evt) ? !this.stopUp : true; │ │ │ │ + return form; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: click │ │ │ │ - * Handle click. Call the "click" callback if click on a feature, │ │ │ │ - * or the "clickout" callback if click outside any feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: setImgSrc │ │ │ │ + * Sets the source for the tile image │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * Parameters: │ │ │ │ + * url - {String} │ │ │ │ */ │ │ │ │ - click: function(evt) { │ │ │ │ - return this.handle(evt) ? !this.stopClick : true; │ │ │ │ + setImgSrc: function(url) { │ │ │ │ + if (this.useIFrame === true) { │ │ │ │ + if (url) { │ │ │ │ + var form = this.createRequestForm(); │ │ │ │ + this.frame.appendChild(form); │ │ │ │ + form.submit(); │ │ │ │ + this.frame.removeChild(form); │ │ │ │ + } else if (this.imgDiv.parentNode === this.frame) { │ │ │ │ + // we don't reuse iframes to avoid caching issues │ │ │ │ + this.frame.removeChild(this.imgDiv); │ │ │ │ + this.imgDiv = null; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + OpenLayers.Tile.Image.prototype.setImgSrc.apply(this, arguments); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousemove │ │ │ │ - * Handle mouse moves. Call the "over" callback if moving in to a feature, │ │ │ │ - * or the "out" callback if moving out of a feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * Method: onImageLoad │ │ │ │ + * Handler for the image onload event │ │ │ │ */ │ │ │ │ - mousemove: function(evt) { │ │ │ │ - if (!this.callbacks['over'] && !this.callbacks['out']) { │ │ │ │ - return true; │ │ │ │ + onImageLoad: function() { │ │ │ │ + //TODO de-uglify opacity handling │ │ │ │ + OpenLayers.Tile.Image.prototype.onImageLoad.apply(this, arguments); │ │ │ │ + if (this.useIFrame === true) { │ │ │ │ + this.imgDiv.style.opacity = 1; │ │ │ │ + this.frame.style.opacity = this.layer.opacity; │ │ │ │ } │ │ │ │ - this.handle(evt); │ │ │ │ - return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dblclick │ │ │ │ - * Handle dblclick. Call the "dblclick" callback if dblclick on a feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: createBackBuffer │ │ │ │ + * Override createBackBuffer to do nothing when we use an iframe. Moving an │ │ │ │ + * iframe from one element to another makes it necessary to reload the iframe │ │ │ │ + * because its content is lost. So we just give up. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - dblclick: function(evt) { │ │ │ │ - return !this.handle(evt); │ │ │ │ - }, │ │ │ │ + createBackBuffer: function() { │ │ │ │ + var backBuffer; │ │ │ │ + if (this.useIFrame === false) { │ │ │ │ + backBuffer = OpenLayers.Tile.Image.prototype.createBackBuffer.call(this); │ │ │ │ + } │ │ │ │ + return backBuffer; │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Marker/Box.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: geometryTypeMatches │ │ │ │ - * Return true if the geometry type of the passed feature matches │ │ │ │ - * one of the geometry types in the geometryTypes array. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Marker.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Marker.Box │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Marker> │ │ │ │ + */ │ │ │ │ +OpenLayers.Marker.Box = OpenLayers.Class(OpenLayers.Marker, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: bounds │ │ │ │ + * {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - geometryTypeMatches: function(feature) { │ │ │ │ - return this.geometryTypes == null || │ │ │ │ - OpenLayers.Util.indexOf(this.geometryTypes, │ │ │ │ - feature.geometry.CLASS_NAME) > -1; │ │ │ │ - }, │ │ │ │ + bounds: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handle │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The event occurred over a relevant feature. │ │ │ │ + /** │ │ │ │ + * Property: div │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - handle: function(evt) { │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - // feature has been destroyed │ │ │ │ - this.feature = null; │ │ │ │ - } │ │ │ │ - var type = evt.type; │ │ │ │ - var handled = false; │ │ │ │ - var previouslyIn = !!(this.feature); // previously in a feature │ │ │ │ - var click = (type == "click" || type == "dblclick" || type == "touchstart"); │ │ │ │ - this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - // feature has been destroyed │ │ │ │ - this.feature = null; │ │ │ │ - } │ │ │ │ - if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ - // last feature has been destroyed │ │ │ │ - this.lastFeature = null; │ │ │ │ - } │ │ │ │ - if (this.feature) { │ │ │ │ - if (type === "touchstart") { │ │ │ │ - // stop the event to prevent Android Webkit from │ │ │ │ - // "flashing" the map div │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - } │ │ │ │ - var inNew = (this.feature != this.lastFeature); │ │ │ │ - if (this.geometryTypeMatches(this.feature)) { │ │ │ │ - // in to a feature │ │ │ │ - if (previouslyIn && inNew) { │ │ │ │ - // out of last feature and in to another │ │ │ │ - if (this.lastFeature) { │ │ │ │ - this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ - } │ │ │ │ - this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ - } else if (!previouslyIn || click) { │ │ │ │ - // in feature for the first time │ │ │ │ - this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ - } │ │ │ │ - this.lastFeature = this.feature; │ │ │ │ - handled = true; │ │ │ │ - } else { │ │ │ │ - // not in to a feature │ │ │ │ - if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ - // out of last feature for the first time │ │ │ │ - this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ - } │ │ │ │ - // next time the mouse goes in a feature whose geometry type │ │ │ │ - // doesn't match we don't want to call the 'out' callback │ │ │ │ - // again, so let's set this.feature to null so that │ │ │ │ - // previouslyIn will evaluate to false the next time │ │ │ │ - // we enter handle. Yes, a bit hackish... │ │ │ │ - this.feature = null; │ │ │ │ - } │ │ │ │ - } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ - this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ - } │ │ │ │ - return handled; │ │ │ │ - }, │ │ │ │ + div: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: triggerCallback │ │ │ │ - * Call the callback keyed in the event map with the supplied arguments. │ │ │ │ - * For click and clickout, the <clickTolerance> is checked first. │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Marker.Box │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * type - {String} │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * borderColor - {String} │ │ │ │ + * borderWidth - {int} │ │ │ │ */ │ │ │ │ - triggerCallback: function(type, mode, args) { │ │ │ │ - var key = this.EVENTMAP[type][mode]; │ │ │ │ - if (key) { │ │ │ │ - if (type == 'click' && this.up && this.down) { │ │ │ │ - // for click/clickout, only trigger callback if tolerance is met │ │ │ │ - var dpx = Math.sqrt( │ │ │ │ - Math.pow(this.up.x - this.down.x, 2) + │ │ │ │ - Math.pow(this.up.y - this.down.y, 2) │ │ │ │ - ); │ │ │ │ - if (dpx <= this.clickTolerance) { │ │ │ │ - this.callback(key, args); │ │ │ │ - } │ │ │ │ - // we're done with this set of events now: clear the cached │ │ │ │ - // positions so we can't trip over them later (this can occur │ │ │ │ - // if one of the up/down events gets eaten before it gets to us │ │ │ │ - // but we still get the click) │ │ │ │ - this.up = this.down = null; │ │ │ │ - } else { │ │ │ │ - this.callback(key, args); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + initialize: function(bounds, borderColor, borderWidth) { │ │ │ │ + this.bounds = bounds; │ │ │ │ + this.div = OpenLayers.Util.createDiv(); │ │ │ │ + this.div.style.overflow = 'hidden'; │ │ │ │ + this.events = new OpenLayers.Events(this, this.div); │ │ │ │ + this.setBorder(borderColor, borderWidth); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Turn on the handler. Returns false if the handler was already active. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - this.map.events.on({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - activated = true; │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ + destroy: function() { │ │ │ │ + │ │ │ │ + this.bounds = null; │ │ │ │ + this.div = null; │ │ │ │ + │ │ │ │ + OpenLayers.Marker.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Turn off the handler. Returns false if the handler was already active. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + /** │ │ │ │ + * Method: setBorder │ │ │ │ + * Allow the user to change the box's color and border width │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * color - {String} Default is "red" │ │ │ │ + * width - {int} Default is 2 │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.moveLayerBack(); │ │ │ │ - this.feature = null; │ │ │ │ - this.lastFeature = null; │ │ │ │ - this.down = null; │ │ │ │ - this.up = null; │ │ │ │ - this.map.events.un({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - deactivated = true; │ │ │ │ + setBorder: function(color, width) { │ │ │ │ + if (!color) { │ │ │ │ + color = "red"; │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + if (!width) { │ │ │ │ + width = 2; │ │ │ │ + } │ │ │ │ + this.div.style.border = width + "px solid " + color; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleMapEvents │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * sz - {<OpenLayers.Size>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A new DOM Image with this marker's icon set at the │ │ │ │ + * location passed-in │ │ │ │ */ │ │ │ │ - handleMapEvents: function(evt) { │ │ │ │ - if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - } │ │ │ │ + draw: function(px, sz) { │ │ │ │ + OpenLayers.Util.modifyDOMElement(this.div, null, px, sz); │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveLayerToTop │ │ │ │ - * Moves the layer for this handler to the top, so mouse events can reach │ │ │ │ - * it. │ │ │ │ + * Method: onScreen │ │ │ │ + * │ │ │ │ + * Rreturn: │ │ │ │ + * {Boolean} Whether or not the marker is currently visible on screen. │ │ │ │ */ │ │ │ │ - moveLayerToTop: function() { │ │ │ │ - var index = Math.max(this.map.Z_INDEX_BASE['Feature'] - 1, │ │ │ │ - this.layer.getZIndex()) + 1; │ │ │ │ - this.layer.setZIndex(index); │ │ │ │ - │ │ │ │ + onScreen: function() { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.map) { │ │ │ │ + var screenBounds = this.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsBounds(this.bounds, true, true); │ │ │ │ + } │ │ │ │ + return onScreen; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveLayerBack │ │ │ │ - * Moves the layer back to the position determined by the map's layers │ │ │ │ - * array. │ │ │ │ + * Method: display │ │ │ │ + * Hide or show the icon │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * display - {Boolean} │ │ │ │ */ │ │ │ │ - moveLayerBack: function() { │ │ │ │ - var index = this.layer.getZIndex() - 1; │ │ │ │ - if (index >= this.map.Z_INDEX_BASE['Feature']) { │ │ │ │ - this.layer.setZIndex(index); │ │ │ │ - } else { │ │ │ │ - this.map.setLayerZIndex(this.layer, │ │ │ │ - this.map.getLayerIndex(this.layer)); │ │ │ │ - } │ │ │ │ + display: function(display) { │ │ │ │ + this.div.style.display = (display) ? "" : "none"; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ + CLASS_NAME: "OpenLayers.Marker.Box" │ │ │ │ }); │ │ │ │ + │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/DragFeature.js │ │ │ │ + OpenLayers/Popup/Anchored.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ - * @requires OpenLayers/Handler/Feature.js │ │ │ │ + * @requires OpenLayers/Popup.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.DragFeature │ │ │ │ - * The DragFeature control moves a feature with a drag of the mouse. Create a │ │ │ │ - * new control with the <OpenLayers.Control.DragFeature> constructor. │ │ │ │ - * │ │ │ │ - * Inherits From: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Class: OpenLayers.Popup.Anchored │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Popup> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.DragFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: geometryTypes │ │ │ │ - * {Array(String)} To restrict dragging to a limited set of geometry types, │ │ │ │ - * send a list of strings corresponding to the geometry class names. │ │ │ │ - */ │ │ │ │ - geometryTypes: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: onStart │ │ │ │ - * {Function} Define this function if you want to know when a drag starts. │ │ │ │ - * The function should expect to receive two arguments: the feature │ │ │ │ - * that is about to be dragged and the pixel location of the mouse. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature that is about to be │ │ │ │ - * dragged. │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The pixel location of the mouse. │ │ │ │ - */ │ │ │ │ - onStart: function(feature, pixel) {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: onDrag │ │ │ │ - * {Function} Define this function if you want to know about each move of a │ │ │ │ - * feature. The function should expect to receive two arguments: the │ │ │ │ - * feature that is being dragged and the pixel location of the mouse. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature that was dragged. │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The pixel location of the mouse. │ │ │ │ - */ │ │ │ │ - onDrag: function(feature, pixel) {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: onComplete │ │ │ │ - * {Function} Define this function if you want to know when a feature is │ │ │ │ - * done dragging. The function should expect to receive two arguments: │ │ │ │ - * the feature that is being dragged and the pixel location of the │ │ │ │ - * mouse. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature that was dragged. │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The pixel location of the mouse. │ │ │ │ - */ │ │ │ │ - onComplete: function(feature, pixel) {}, │ │ │ │ +OpenLayers.Popup.Anchored = │ │ │ │ + OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: onEnter │ │ │ │ - * {Function} Define this function if you want to know when the mouse │ │ │ │ - * goes over a feature and thereby makes this feature a candidate │ │ │ │ - * for dragging. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature that is ready │ │ │ │ - * to be dragged. │ │ │ │ - */ │ │ │ │ - onEnter: function(feature) {}, │ │ │ │ + /** │ │ │ │ + * Property: relativePosition │ │ │ │ + * {String} Relative position of the popup ("br", "tr", "tl" or "bl"). │ │ │ │ + */ │ │ │ │ + relativePosition: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: onLeave │ │ │ │ - * {Function} Define this function if you want to know when the mouse │ │ │ │ - * goes out of the feature that was dragged. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature that was dragged. │ │ │ │ - */ │ │ │ │ - onLeave: function(feature) {}, │ │ │ │ + /** │ │ │ │ + * APIProperty: keepInMap │ │ │ │ + * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ + * contrain the popup such that it always fits in the available map │ │ │ │ + * space. By default, this is set. If you are creating popups that are │ │ │ │ + * near map edges and not allowing pannning, and especially if you have │ │ │ │ + * a popup which has a fixedRelativePosition, setting this to false may │ │ │ │ + * be a smart thing to do. │ │ │ │ + * │ │ │ │ + * For anchored popups, default is true, since subclasses will │ │ │ │ + * usually want this functionality. │ │ │ │ + */ │ │ │ │ + keepInMap: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} If set to true, mouse dragging will continue even if the │ │ │ │ - * mouse cursor leaves the map viewport. Default is false. │ │ │ │ - */ │ │ │ │ - documentDrag: false, │ │ │ │ + /** │ │ │ │ + * Property: anchor │ │ │ │ + * {Object} Object to which we'll anchor the popup. Must expose a │ │ │ │ + * 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>). │ │ │ │ + */ │ │ │ │ + anchor: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} │ │ │ │ - */ │ │ │ │ - layer: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Popup.Anchored │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {String} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * contentSize - {<OpenLayers.Size>} │ │ │ │ + * contentHTML - {String} │ │ │ │ + * anchor - {Object} Object which must expose a 'size' <OpenLayers.Size> │ │ │ │ + * and 'offset' <OpenLayers.Pixel> (generally an <OpenLayers.Icon>). │ │ │ │ + * closeBox - {Boolean} │ │ │ │ + * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ + */ │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ + closeBoxCallback) { │ │ │ │ + var newArguments = [ │ │ │ │ + id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback │ │ │ │ + ]; │ │ │ │ + OpenLayers.Popup.prototype.initialize.apply(this, newArguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - feature: null, │ │ │ │ + this.anchor = (anchor != null) ? anchor : │ │ │ │ + { │ │ │ │ + size: new OpenLayers.Size(0, 0), │ │ │ │ + offset: new OpenLayers.Pixel(0, 0) │ │ │ │ + }; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: dragCallbacks │ │ │ │ - * {Object} The functions that are sent to the drag handler for callback. │ │ │ │ - */ │ │ │ │ - dragCallbacks: {}, │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.anchor = null; │ │ │ │ + this.relativePosition = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: featureCallbacks │ │ │ │ - * {Object} The functions that are sent to the feature handler for callback. │ │ │ │ - */ │ │ │ │ - featureCallbacks: {}, │ │ │ │ + OpenLayers.Popup.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: lastPixel │ │ │ │ - * {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - lastPixel: null, │ │ │ │ + /** │ │ │ │ + * 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); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Control.DragFeature │ │ │ │ - * Create a new control to drag features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} The layer containing features to be │ │ │ │ - * dragged. │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * control. │ │ │ │ - */ │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.layer = layer; │ │ │ │ - this.handlers = { │ │ │ │ - drag: new OpenLayers.Handler.Drag( │ │ │ │ - this, OpenLayers.Util.extend({ │ │ │ │ - down: this.downFeature, │ │ │ │ - move: this.moveFeature, │ │ │ │ - up: this.upFeature, │ │ │ │ - out: this.cancel, │ │ │ │ - done: this.doneDragging │ │ │ │ - }, this.dragCallbacks), { │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - } │ │ │ │ - ), │ │ │ │ - feature: new OpenLayers.Handler.Feature( │ │ │ │ - this, this.layer, OpenLayers.Util.extend({ │ │ │ │ - // 'click' and 'clickout' callback are for the mobile │ │ │ │ - // support: no 'over' or 'out' in touch based browsers. │ │ │ │ - click: this.clickFeature, │ │ │ │ - clickout: this.clickoutFeature, │ │ │ │ - over: this.overFeature, │ │ │ │ - out: this.outFeature │ │ │ │ - }, this.featureCallbacks), { │ │ │ │ - geometryTypes: this.geometryTypes │ │ │ │ - } │ │ │ │ - ) │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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 - {<OpenLayers.Pixel>} │ │ │ │ + */ │ │ │ │ + moveTo: function(px) { │ │ │ │ + var oldRelativePosition = this.relativePosition; │ │ │ │ + this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clickFeature │ │ │ │ - * Called when the feature handler detects a click-in on a feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - clickFeature: function(feature) { │ │ │ │ - if (this.handlers.feature.touch && !this.over && this.overFeature(feature)) { │ │ │ │ - this.handlers.drag.dragstart(this.handlers.feature.evt); │ │ │ │ - // to let the events propagate to the feature handler (click callback) │ │ │ │ - this.handlers.drag.stopDown = false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clickoutFeature │ │ │ │ - * Called when the feature handler detects a click-out on a feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - clickoutFeature: function(feature) { │ │ │ │ - if (this.handlers.feature.touch && this.over) { │ │ │ │ - this.outFeature(feature); │ │ │ │ - this.handlers.drag.stopDown = true; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + //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: destroy │ │ │ │ - * Take care of things that are not handled in superclass │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.layer = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, []); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: setSize │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ + * contents div (in pixels). │ │ │ │ + */ │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the control and the feature handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Successfully activated the control and feature handler. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - return (this.handlers.feature.activate() && │ │ │ │ - OpenLayers.Control.prototype.activate.apply(this, arguments)); │ │ │ │ - }, │ │ │ │ + if ((this.lonlat) && (this.map)) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + this.moveTo(px); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the control and all handlers. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Successfully deactivated the control. │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - // the return from the handlers is unimportant in this case │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - this.handlers.feature.deactivate(); │ │ │ │ - this.feature = null; │ │ │ │ - this.dragging = false; │ │ │ │ - this.lastPixel = null; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, this.displayClass + "Over" │ │ │ │ - ); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: calculateRelativePosition │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * 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); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: overFeature │ │ │ │ - * Called when the feature handler detects a mouse-over on a feature. │ │ │ │ - * This activates the drag handler. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The selected feature. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Successfully activated the drag handler. │ │ │ │ - */ │ │ │ │ - overFeature: function(feature) { │ │ │ │ - var activated = false; │ │ │ │ - if (!this.handlers.drag.dragging) { │ │ │ │ - this.feature = feature; │ │ │ │ - this.handlers.drag.activate(); │ │ │ │ - activated = true; │ │ │ │ - this.over = true; │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ - this.onEnter(feature); │ │ │ │ - } else { │ │ │ │ - if (this.feature.id == feature.id) { │ │ │ │ - this.over = true; │ │ │ │ - } else { │ │ │ │ - this.over = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var quadrant = extent.determineQuadrant(lonlat); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: downFeature │ │ │ │ - * Called when the drag handler detects a mouse-down. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} Location of the mouse event. │ │ │ │ - */ │ │ │ │ - downFeature: function(pixel) { │ │ │ │ - this.lastPixel = pixel; │ │ │ │ - this.onStart(this.feature, pixel); │ │ │ │ - }, │ │ │ │ + return OpenLayers.Bounds.oppositeQuadrant(quadrant); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveFeature │ │ │ │ - * Called when the drag handler detects a mouse-move. Also calls the │ │ │ │ - * optional onDrag method. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} Location of the mouse event. │ │ │ │ - */ │ │ │ │ - moveFeature: function(pixel) { │ │ │ │ - var res = this.map.getResolution(); │ │ │ │ - this.feature.geometry.move(res * (pixel.x - this.lastPixel.x), │ │ │ │ - res * (this.lastPixel.y - pixel.y)); │ │ │ │ - this.layer.drawFeature(this.feature); │ │ │ │ - this.lastPixel = pixel; │ │ │ │ - this.onDrag(this.feature, pixel); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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 Framed, however, will want to do something │ │ │ │ + * special here. │ │ │ │ + */ │ │ │ │ + updateRelativePosition: function() { │ │ │ │ + //to be overridden by subclasses │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: upFeature │ │ │ │ - * Called when the drag handler detects a mouse-up. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} Location of the mouse event. │ │ │ │ - */ │ │ │ │ - upFeature: function(pixel) { │ │ │ │ - if (!this.over) { │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: calculateNewPx │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} 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); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: doneDragging │ │ │ │ - * Called when the drag handler is done dragging. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The last event pixel location. If this event │ │ │ │ - * came from a mouseout, this may not be in the map viewport. │ │ │ │ - */ │ │ │ │ - doneDragging: function(pixel) { │ │ │ │ - this.onComplete(this.feature, pixel); │ │ │ │ - }, │ │ │ │ + //use contentSize if size is not already set │ │ │ │ + var size = this.size || this.contentSize; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: outFeature │ │ │ │ - * Called when the feature handler detects a mouse-out on a feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature that the mouse left. │ │ │ │ - */ │ │ │ │ - outFeature: function(feature) { │ │ │ │ - if (!this.handlers.drag.dragging) { │ │ │ │ - this.over = false; │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, this.displayClass + "Over" │ │ │ │ - ); │ │ │ │ - this.onLeave(feature); │ │ │ │ - this.feature = null; │ │ │ │ - } else { │ │ │ │ - if (this.feature.id == feature.id) { │ │ │ │ - this.over = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + var top = (this.relativePosition.charAt(0) == 't'); │ │ │ │ + newPx.y += (top) ? -size.h : this.anchor.size.h; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: cancel │ │ │ │ - * Called when the drag handler detects a mouse-out (from the map viewport). │ │ │ │ - */ │ │ │ │ - cancel: function() { │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - this.over = false; │ │ │ │ - }, │ │ │ │ + var left = (this.relativePosition.charAt(1) == 'l'); │ │ │ │ + newPx.x += (left) ? -size.w : this.anchor.size.w; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control and all handlers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} The control's map. │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.drag.setMap(map); │ │ │ │ - this.handlers.feature.setMap(map); │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + return newPx; │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DragFeature" │ │ │ │ -}); │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/RegularPolygon.js │ │ │ │ + OpenLayers/Popup/Framed.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ + * @requires OpenLayers/Popup/Anchored.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.RegularPolygon │ │ │ │ - * Handler to draw a regular polygon on the map. Polygon is displayed on mouse │ │ │ │ - * down, moves or is modified on mouse move, and is finished on mouse up. │ │ │ │ - * The handler triggers callbacks for 'done' and 'cancel'. Create a new │ │ │ │ - * instance with the <OpenLayers.Handler.RegularPolygon> constructor. │ │ │ │ + * Class: OpenLayers.Popup.Framed │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler.Drag> │ │ │ │ + * - <OpenLayers.Popup.Anchored> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.RegularPolygon = OpenLayers.Class(OpenLayers.Handler.Drag, { │ │ │ │ +OpenLayers.Popup.Framed = │ │ │ │ + OpenLayers.Class(OpenLayers.Popup.Anchored, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: sides │ │ │ │ - * {Integer} Number of sides for the regular polygon. Needs to be greater │ │ │ │ - * than 2. Defaults to 4. │ │ │ │ - */ │ │ │ │ - sides: 4, │ │ │ │ + /** │ │ │ │ + * Property: imageSrc │ │ │ │ + * {String} location of the image to be used as the popup frame │ │ │ │ + */ │ │ │ │ + imageSrc: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: radius │ │ │ │ - * {Float} Optional radius in map units of the regular polygon. If this is │ │ │ │ - * set to some non-zero value, a polygon with a fixed radius will be │ │ │ │ - * drawn and dragged with mose movements. If this property is not │ │ │ │ - * set, dragging changes the radius of the polygon. Set to null by │ │ │ │ - * default. │ │ │ │ - */ │ │ │ │ - radius: null, │ │ │ │ + /** │ │ │ │ + * Property: imageSize │ │ │ │ + * {<OpenLayers.Size>} Size (measured in pixels) of the image located │ │ │ │ + * by the 'imageSrc' property. │ │ │ │ + */ │ │ │ │ + imageSize: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: snapAngle │ │ │ │ - * {Float} If set to a non-zero value, the handler will snap the polygon │ │ │ │ - * rotation to multiples of the snapAngle. Value is an angle measured │ │ │ │ - * in degrees counterclockwise from the positive x-axis. │ │ │ │ - */ │ │ │ │ - snapAngle: 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, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: snapToggle │ │ │ │ - * {String} If set, snapToggle is checked on mouse events and will set │ │ │ │ - * the snap mode to the opposite of what it currently is. To disallow │ │ │ │ - * toggling between snap and non-snap mode, set freehandToggle to │ │ │ │ - * null. Acceptable toggle values are 'shiftKey', 'ctrlKey', and │ │ │ │ - * 'altKey'. Snap mode is only possible if this.snapAngle is set to a │ │ │ │ - * non-zero value. │ │ │ │ - */ │ │ │ │ - snapToggle: 'shiftKey', │ │ │ │ + /** │ │ │ │ + * 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: layerOptions │ │ │ │ - * {Object} Any optional properties to be set on the sketch layer. │ │ │ │ - */ │ │ │ │ - layerOptions: 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: persist │ │ │ │ - * {Boolean} Leave the feature rendered until clear is called. Default │ │ │ │ - * is false. If set to true, the feature remains rendered until │ │ │ │ - * clear is called, typically by deactivating the handler or starting │ │ │ │ - * another drawing. │ │ │ │ - */ │ │ │ │ - persist: false, │ │ │ │ + /** │ │ │ │ + * 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, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: irregular │ │ │ │ - * {Boolean} Draw an irregular polygon instead of a regular polygon. │ │ │ │ - * Default is false. If true, the initial mouse down will represent │ │ │ │ - * one corner of the polygon bounds and with each mouse movement, the │ │ │ │ - * polygon will be stretched so the opposite corner of its bounds │ │ │ │ - * follows the mouse position. This property takes precedence over │ │ │ │ - * the radius property. If set to true, the radius property will │ │ │ │ - * be ignored. │ │ │ │ - */ │ │ │ │ - irregular: false, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Popup.Framed │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {String} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * contentSize - {<OpenLayers.Size>} │ │ │ │ + * contentHTML - {String} │ │ │ │ + * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ + * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ + * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ + * closeBox - {Boolean} │ │ │ │ + * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ + */ │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ + closeBoxCallback) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: citeCompliant │ │ │ │ - * {Boolean} If set to true, coordinates of features drawn in a map extent │ │ │ │ - * crossing the date line won't exceed the world bounds. Default is false. │ │ │ │ - */ │ │ │ │ - citeCompliant: false, │ │ │ │ + OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: angle │ │ │ │ - * {Float} The angle from the origin (mouse down) to the current mouse │ │ │ │ - * position, in radians. This is measured counterclockwise from the │ │ │ │ - * positive x-axis. │ │ │ │ - */ │ │ │ │ - angle: null, │ │ │ │ + if (this.fixedRelativePosition) { │ │ │ │ + //based on our decided relativePostion, set the current padding │ │ │ │ + // this keeps us from getting into trouble │ │ │ │ + this.updateRelativePosition(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: fixedRadius │ │ │ │ - * {Boolean} The polygon has a fixed radius. True if a radius is set before │ │ │ │ - * drawing begins. False otherwise. │ │ │ │ - */ │ │ │ │ - fixedRadius: false, │ │ │ │ + //make calculateRelativePosition always return the specified │ │ │ │ + // fixed position. │ │ │ │ + this.calculateRelativePosition = function(px) { │ │ │ │ + return this.relativePosition; │ │ │ │ + }; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The currently drawn polygon feature │ │ │ │ - */ │ │ │ │ - feature: null, │ │ │ │ + this.contentDiv.style.position = "absolute"; │ │ │ │ + this.contentDiv.style.zIndex = 1; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The temporary drawing layer │ │ │ │ - */ │ │ │ │ - layer: null, │ │ │ │ + if (closeBox) { │ │ │ │ + this.closeDiv.style.zIndex = 1; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: origin │ │ │ │ - * {<OpenLayers.Geometry.Point>} Location of the first mouse down │ │ │ │ - */ │ │ │ │ - origin: null, │ │ │ │ + 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%"; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Handler.RegularPolygon │ │ │ │ - * Create a new regular polygon handler. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ - * callbacks - {Object} An object with a properties whose values are │ │ │ │ - * functions. Various callbacks described below. │ │ │ │ - * options - {Object} An object with properties to be set on the handler. │ │ │ │ - * If the options.sides property is not specified, the number of sides │ │ │ │ - * will default to 4. │ │ │ │ - * │ │ │ │ - * Named callbacks: │ │ │ │ - * create - Called when a sketch is first created. Callback called with │ │ │ │ - * the creation point geometry and sketch feature. │ │ │ │ - * done - Called when the sketch drawing is finished. The callback will │ │ │ │ - * recieve a single argument, the sketch geometry. │ │ │ │ - * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ - * cancel callback will receive a geometry. │ │ │ │ - */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ - this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {}); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.imageSrc = null; │ │ │ │ + this.imageSize = null; │ │ │ │ + this.isAlphaImage = null; │ │ │ │ │ │ │ │ - OpenLayers.Handler.Drag.prototype.initialize.apply(this, │ │ │ │ - [control, callbacks, options]); │ │ │ │ - this.options = (options) ? options : {}; │ │ │ │ - }, │ │ │ │ + this.fixedRelativePosition = false; │ │ │ │ + this.positionBlocks = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setOptions │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * newOptions - {Object} │ │ │ │ - */ │ │ │ │ - setOptions: function(newOptions) { │ │ │ │ - OpenLayers.Util.extend(this.options, newOptions); │ │ │ │ - OpenLayers.Util.extend(this, newOptions); │ │ │ │ - }, │ │ │ │ + //remove our blocks │ │ │ │ + for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ + var block = this.blocks[i]; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Turn on the handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully activated │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.Drag.prototype.activate.apply(this, arguments)) { │ │ │ │ - // create temporary vector layer for rendering geometry sketch │ │ │ │ - var options = OpenLayers.Util.extend({ │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - // indicate that the temp vector layer will never be out of range │ │ │ │ - // without this, resolution properties must be specified at the │ │ │ │ - // map-level for this temporary layer to init its resolutions │ │ │ │ - // correctly │ │ │ │ - calculateInRange: OpenLayers.Function.True, │ │ │ │ - wrapDateLine: this.citeCompliant │ │ │ │ - }, this.layerOptions); │ │ │ │ - this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ - this.map.addLayer(this.layer); │ │ │ │ - activated = true; │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ + if (block.image) { │ │ │ │ + block.div.removeChild(block.image); │ │ │ │ + } │ │ │ │ + block.image = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Turn off the handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.Drag.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - // call the cancel callback if mid-drawing │ │ │ │ - if (this.dragging) { │ │ │ │ - this.cancel(); │ │ │ │ - } │ │ │ │ - // If a layer's map property is set to null, it means that that │ │ │ │ - // layer isn't added to the map. Since we ourself added the layer │ │ │ │ - // to the map in activate(), we can assume that if this.layer.map │ │ │ │ - // is null it means that the layer has been destroyed (as a result │ │ │ │ - // of map.destroy() for example. │ │ │ │ - if (this.layer.map != null) { │ │ │ │ - this.layer.destroy(false); │ │ │ │ - if (this.feature) { │ │ │ │ - this.feature.destroy(); │ │ │ │ + if (block.div) { │ │ │ │ + this.groupDiv.removeChild(block.div); │ │ │ │ } │ │ │ │ + block.div = null; │ │ │ │ } │ │ │ │ - this.layer = null; │ │ │ │ - this.feature = null; │ │ │ │ - deactivated = true; │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ - }, │ │ │ │ + this.blocks = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: down │ │ │ │ - * Start drawing a new feature │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The drag start event │ │ │ │ - */ │ │ │ │ - down: function(evt) { │ │ │ │ - this.fixedRadius = !!(this.radius); │ │ │ │ - var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ - this.origin = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ - // create the new polygon │ │ │ │ - if (!this.fixedRadius || this.irregular) { │ │ │ │ - // smallest radius should not be less one pixel in map units │ │ │ │ - // VML doesn't behave well with smaller │ │ │ │ - this.radius = this.map.getResolution(); │ │ │ │ - } │ │ │ │ - if (this.persist) { │ │ │ │ - this.clear(); │ │ │ │ - } │ │ │ │ - this.feature = new OpenLayers.Feature.Vector(); │ │ │ │ - this.createGeometry(); │ │ │ │ - this.callback("create", [this.origin, this.feature]); │ │ │ │ - this.layer.addFeatures([this.feature], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.layer.drawFeature(this.feature, this.style); │ │ │ │ - }, │ │ │ │ + OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: move │ │ │ │ - * Respond to drag move events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Evt} The move event │ │ │ │ - */ │ │ │ │ - move: function(evt) { │ │ │ │ - var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ - var point = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ - if (this.irregular) { │ │ │ │ - var ry = Math.sqrt(2) * Math.abs(point.y - this.origin.y) / 2; │ │ │ │ - this.radius = Math.max(this.map.getResolution() / 2, ry); │ │ │ │ - } else if (this.fixedRadius) { │ │ │ │ - this.origin = point; │ │ │ │ - } else { │ │ │ │ - this.calculateAngle(point, evt); │ │ │ │ - this.radius = Math.max(this.map.getResolution() / 2, │ │ │ │ - point.distanceTo(this.origin)); │ │ │ │ - } │ │ │ │ - this.modifyGeometry(); │ │ │ │ - if (this.irregular) { │ │ │ │ - var dx = point.x - this.origin.x; │ │ │ │ - var dy = point.y - this.origin.y; │ │ │ │ - var ratio; │ │ │ │ - if (dy == 0) { │ │ │ │ - ratio = dx / (this.radius * Math.sqrt(2)); │ │ │ │ - } else { │ │ │ │ - ratio = dx / dy; │ │ │ │ - } │ │ │ │ - this.feature.geometry.resize(1, this.origin, ratio); │ │ │ │ - this.feature.geometry.move(dx / 2, dy / 2); │ │ │ │ - } │ │ │ │ - this.layer.drawFeature(this.feature, this.style); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: setBackgroundColor │ │ │ │ + */ │ │ │ │ + setBackgroundColor: function(color) { │ │ │ │ + //does nothing since the framed popup's entire scheme is based on a │ │ │ │ + // an image -- changing the background color makes no sense. │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: up │ │ │ │ - * Finish drawing the feature │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse up event │ │ │ │ - */ │ │ │ │ - up: function(evt) { │ │ │ │ - this.finalize(); │ │ │ │ - // the mouseup method of superclass doesn't call the │ │ │ │ - // "done" callback if there's been no move between │ │ │ │ - // down and up │ │ │ │ - if (this.start == this.last) { │ │ │ │ - this.callback("done", [evt.xy]); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: setBorder │ │ │ │ + */ │ │ │ │ + setBorder: function() { │ │ │ │ + //does nothing since the framed popup's entire scheme is based on a │ │ │ │ + // an image -- changing the popup's border makes no sense. │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: out │ │ │ │ - * Finish drawing the feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse out event │ │ │ │ - */ │ │ │ │ - out: function(evt) { │ │ │ │ - this.finalize(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: setOpacity │ │ │ │ + * Sets the opacity of the popup. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ + */ │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + //does nothing since we suppose that we'll never apply an opacity │ │ │ │ + // to a framed popup │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createGeometry │ │ │ │ - * Create the new polygon geometry. This is called at the start of the │ │ │ │ - * drag and at any point during the drag if the number of sides │ │ │ │ - * changes. │ │ │ │ - */ │ │ │ │ - createGeometry: function() { │ │ │ │ - this.angle = Math.PI * ((1 / this.sides) - (1 / 2)); │ │ │ │ - if (this.snapAngle) { │ │ │ │ - this.angle += this.snapAngle * (Math.PI / 180); │ │ │ │ - } │ │ │ │ - this.feature.geometry = OpenLayers.Geometry.Polygon.createRegularPolygon( │ │ │ │ - this.origin, this.radius, this.sides, this.snapAngle │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: setSize │ │ │ │ + * Overridden here, because we need to update the blocks whenever the size │ │ │ │ + * of the popup has changed. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ + * contents div (in pixels). │ │ │ │ + */ │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: modifyGeometry │ │ │ │ - * Modify the polygon geometry in place. │ │ │ │ - */ │ │ │ │ - modifyGeometry: function() { │ │ │ │ - var angle, point; │ │ │ │ - var ring = this.feature.geometry.components[0]; │ │ │ │ - // if the number of sides ever changes, create a new geometry │ │ │ │ - if (ring.components.length != (this.sides + 1)) { │ │ │ │ - this.createGeometry(); │ │ │ │ - ring = this.feature.geometry.components[0]; │ │ │ │ - } │ │ │ │ - for (var i = 0; i < this.sides; ++i) { │ │ │ │ - point = ring.components[i]; │ │ │ │ - angle = this.angle + (i * 2 * Math.PI / this.sides); │ │ │ │ - point.x = this.origin.x + (this.radius * Math.cos(angle)); │ │ │ │ - point.y = this.origin.y + (this.radius * Math.sin(angle)); │ │ │ │ - point.clearBounds(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + this.updateBlocks(); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: calculateAngle │ │ │ │ - * Calculate the angle based on settings. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - calculateAngle: function(point, evt) { │ │ │ │ - var alpha = Math.atan2(point.y - this.origin.y, │ │ │ │ - point.x - this.origin.x); │ │ │ │ - if (this.snapAngle && (this.snapToggle && !evt[this.snapToggle])) { │ │ │ │ - var snapAngleRad = (Math.PI / 180) * this.snapAngle; │ │ │ │ - this.angle = Math.round(alpha / snapAngleRad) * snapAngleRad; │ │ │ │ - } else { │ │ │ │ - this.angle = alpha; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: updateRelativePosition │ │ │ │ + * When the relative position changes, we need to set the new padding │ │ │ │ + * BBOX on the popup, reposition the close div, and update the blocks. │ │ │ │ + */ │ │ │ │ + updateRelativePosition: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: cancel │ │ │ │ - * Finish the geometry and call the "cancel" callback. │ │ │ │ - */ │ │ │ │ - cancel: function() { │ │ │ │ - // the polygon geometry gets cloned in the callback method │ │ │ │ - this.callback("cancel", null); │ │ │ │ - this.finalize(); │ │ │ │ - }, │ │ │ │ + //update the padding │ │ │ │ + this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: finalize │ │ │ │ - * Finish the geometry and call the "done" callback. │ │ │ │ - */ │ │ │ │ - finalize: function() { │ │ │ │ - this.origin = null; │ │ │ │ - this.radius = this.options.radius; │ │ │ │ - }, │ │ │ │ + //update the position of our close box to new padding │ │ │ │ + if (this.closeDiv) { │ │ │ │ + // use the content div's css padding to determine if we should │ │ │ │ + // padd the close div │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clear │ │ │ │ - * Clear any rendered features on the temporary layer. This is called │ │ │ │ - * when the handler is deactivated, canceled, or done (unless persist │ │ │ │ - * is true). │ │ │ │ - */ │ │ │ │ - clear: function() { │ │ │ │ - if (this.layer) { │ │ │ │ - this.layer.renderer.clear(); │ │ │ │ - this.layer.destroyFeatures(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + this.closeDiv.style.right = contentDivPadding.right + │ │ │ │ + this.padding.right + "px"; │ │ │ │ + this.closeDiv.style.top = contentDivPadding.top + │ │ │ │ + this.padding.top + "px"; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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 with which to call the callback │ │ │ │ - * (defined by the control). │ │ │ │ - */ │ │ │ │ - callback: function(name, args) { │ │ │ │ - // override the callback method to always send the polygon geometry │ │ │ │ - if (this.callbacks[name]) { │ │ │ │ - this.callbacks[name].apply(this.control, │ │ │ │ - [this.feature.geometry.clone()]); │ │ │ │ - } │ │ │ │ - // since sketch features are added to the temporary layer │ │ │ │ - // they must be cleared here if done or cancel │ │ │ │ - if (!this.persist && (name == "done" || name == "cancel")) { │ │ │ │ - this.clear(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + this.updateBlocks(); │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.RegularPolygon" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Handler/Point.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Method: calculateNewPx │ │ │ │ + * Besides the standard offset as determined by the Anchored class, our │ │ │ │ + * Framed popups have a special 'offset' property for each of their │ │ │ │ + * positions, which is used to offset the popup relative to its anchor. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} The the new px position of the popup on the screen │ │ │ │ + * relative to the passed-in px. │ │ │ │ + */ │ │ │ │ + calculateNewPx: function(px) { │ │ │ │ + var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ │ │ │ │ + return newPx; │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Method: createBlocks │ │ │ │ + */ │ │ │ │ + createBlocks: function() { │ │ │ │ + this.blocks = []; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Handler.Point │ │ │ │ - * Handler to draw a point on the map. Point is displayed on activation, │ │ │ │ - * moves on mouse move, and is finished on mouse up. The handler triggers │ │ │ │ - * callbacks for 'done', 'cancel', and 'modify'. The modify callback is │ │ │ │ - * called with each change in the sketch and will receive the latest point │ │ │ │ - * drawn. Create a new instance with the <OpenLayers.Handler.Point> │ │ │ │ - * constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.Point = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + //since all positions contain the same number of blocks, we can │ │ │ │ + // just pick the first position and use its blocks array to create │ │ │ │ + // our blocks array │ │ │ │ + var firstPosition = null; │ │ │ │ + for (var key in this.positionBlocks) { │ │ │ │ + firstPosition = key; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: point │ │ │ │ - * {<OpenLayers.Feature.Vector>} The currently drawn point │ │ │ │ - */ │ │ │ │ - point: null, │ │ │ │ + var position = this.positionBlocks[firstPosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The temporary drawing layer │ │ │ │ - */ │ │ │ │ - layer: null, │ │ │ │ + var block = {}; │ │ │ │ + this.blocks.push(block); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: multi │ │ │ │ - * {Boolean} Cast features to multi-part geometries before passing to the │ │ │ │ - * layer. Default is false. │ │ │ │ - */ │ │ │ │ - multi: false, │ │ │ │ + var divId = this.id + '_FrameDecorationDiv_' + i; │ │ │ │ + block.div = OpenLayers.Util.createDiv(divId, │ │ │ │ + null, null, null, "absolute", null, "hidden", null │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: citeCompliant │ │ │ │ - * {Boolean} If set to true, coordinates of features drawn in a map extent │ │ │ │ - * crossing the date line won't exceed the world bounds. Default is false. │ │ │ │ - */ │ │ │ │ - citeCompliant: false, │ │ │ │ + var imgId = this.id + '_FrameDecorationImg_' + i; │ │ │ │ + var imageCreator = │ │ │ │ + (this.isAlphaImage) ? OpenLayers.Util.createAlphaImageDiv : │ │ │ │ + OpenLayers.Util.createImage; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: mouseDown │ │ │ │ - * {Boolean} The mouse is down │ │ │ │ - */ │ │ │ │ - mouseDown: false, │ │ │ │ + block.image = imageCreator(imgId, │ │ │ │ + null, this.imageSize, this.imageSrc, │ │ │ │ + "absolute", null, null, null │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: stoppedDown │ │ │ │ - * {Boolean} Indicate whether the last mousedown stopped the event │ │ │ │ - * propagation. │ │ │ │ - */ │ │ │ │ - stoppedDown: null, │ │ │ │ + block.div.appendChild(block.image); │ │ │ │ + this.groupDiv.appendChild(block.div); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: lastDown │ │ │ │ - * {<OpenLayers.Pixel>} Location of the last mouse down │ │ │ │ - */ │ │ │ │ - lastDown: null, │ │ │ │ + /** │ │ │ │ + * Method: updateBlocks │ │ │ │ + * Internal method, called on initialize and when the popup's relative │ │ │ │ + * position has changed. This function takes care of re-positioning │ │ │ │ + * the popup's blocks in their appropropriate places. │ │ │ │ + */ │ │ │ │ + updateBlocks: function() { │ │ │ │ + if (!this.blocks) { │ │ │ │ + this.createBlocks(); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: lastUp │ │ │ │ - * {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - lastUp: null, │ │ │ │ + if (this.size && this.relativePosition) { │ │ │ │ + var position = this.positionBlocks[this.relativePosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: persist │ │ │ │ - * {Boolean} Leave the feature rendered until destroyFeature is called. │ │ │ │ - * Default is false. If set to true, the feature remains rendered until │ │ │ │ - * destroyFeature is called, typically by deactivating the handler or │ │ │ │ - * starting another drawing. │ │ │ │ - */ │ │ │ │ - persist: false, │ │ │ │ + var positionBlock = position.blocks[i]; │ │ │ │ + var block = this.blocks[i]; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: stopDown │ │ │ │ - * {Boolean} Stop event propagation on mousedown. Must be false to │ │ │ │ - * allow "pan while drawing". Defaults to false. │ │ │ │ - */ │ │ │ │ - stopDown: false, │ │ │ │ + // adjust sizes │ │ │ │ + var l = positionBlock.anchor.left; │ │ │ │ + var b = positionBlock.anchor.bottom; │ │ │ │ + var r = positionBlock.anchor.right; │ │ │ │ + var t = positionBlock.anchor.top; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIPropery: stopUp │ │ │ │ - * {Boolean} Stop event propagation on mouse. Must be false to │ │ │ │ - * allow "pan while dragging". Defaults to fase. │ │ │ │ - */ │ │ │ │ - stopUp: false, │ │ │ │ + //note that we use the isNaN() test here because if the │ │ │ │ + // size object is initialized with a "auto" parameter, the │ │ │ │ + // size constructor calls parseFloat() on the string, │ │ │ │ + // which will turn it into NaN │ │ │ │ + // │ │ │ │ + var w = (isNaN(positionBlock.size.w)) ? this.size.w - (r + l) : │ │ │ │ + positionBlock.size.w; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layerOptions │ │ │ │ - * {Object} Any optional properties to be set on the sketch layer. │ │ │ │ - */ │ │ │ │ - layerOptions: null, │ │ │ │ + var h = (isNaN(positionBlock.size.h)) ? this.size.h - (b + t) : │ │ │ │ + positionBlock.size.h; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: pixelTolerance │ │ │ │ - * {Number} Maximum number of pixels between down and up (mousedown │ │ │ │ - * and mouseup, or touchstart and touchend) for the handler to │ │ │ │ - * add a new point. If set to an integer value, if the │ │ │ │ - * displacement between down and up is great to this value │ │ │ │ - * no point will be added. Default value is 5. │ │ │ │ - */ │ │ │ │ - pixelTolerance: 5, │ │ │ │ + block.div.style.width = (w < 0 ? 0 : w) + 'px'; │ │ │ │ + block.div.style.height = (h < 0 ? 0 : h) + 'px'; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: lastTouchPx │ │ │ │ - * {<OpenLayers.Pixel>} The last pixel used to know the distance between │ │ │ │ - * two touches (for double touch). │ │ │ │ - */ │ │ │ │ - lastTouchPx: null, │ │ │ │ + block.div.style.left = (l != null) ? l + 'px' : ''; │ │ │ │ + block.div.style.bottom = (b != null) ? b + 'px' : ''; │ │ │ │ + block.div.style.right = (r != null) ? r + 'px' : ''; │ │ │ │ + block.div.style.top = (t != null) ? t + 'px' : ''; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Handler.Point │ │ │ │ - * Create a new point handler. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ - * callbacks - {Object} An object with a properties whose values are │ │ │ │ - * functions. Various callbacks described below. │ │ │ │ - * options - {Object} An optional object with properties to be set on the │ │ │ │ - * handler │ │ │ │ - * │ │ │ │ - * Named callbacks: │ │ │ │ - * create - Called when a sketch is first created. Callback called with │ │ │ │ - * the creation point geometry and sketch feature. │ │ │ │ - * modify - Called with each move of a vertex with the vertex (point) │ │ │ │ - * geometry and the sketch feature. │ │ │ │ - * done - Called when the point drawing is finished. The callback will │ │ │ │ - * recieve a single argument, the point geometry. │ │ │ │ - * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ - * cancel callback will receive a geometry. │ │ │ │ - */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ - this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {}); │ │ │ │ - } │ │ │ │ + block.image.style.left = positionBlock.position.x + 'px'; │ │ │ │ + block.image.style.top = positionBlock.position.y + 'px'; │ │ │ │ + } │ │ │ │ │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ + this.contentDiv.style.top = this.padding.top + "px"; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * turn on the handler │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - if (!OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - // create temporary vector layer for rendering geometry sketch │ │ │ │ - // TBD: this could be moved to initialize/destroy - setting visibility here │ │ │ │ - var options = OpenLayers.Util.extend({ │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - // indicate that the temp vector layer will never be out of range │ │ │ │ - // without this, resolution properties must be specified at the │ │ │ │ - // map-level for this temporary layer to init its resolutions │ │ │ │ - // correctly │ │ │ │ - calculateInRange: OpenLayers.Function.True, │ │ │ │ - wrapDateLine: this.citeCompliant │ │ │ │ - }, this.layerOptions); │ │ │ │ - this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ - this.map.addLayer(this.layer); │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Popup/FramedCloud.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createFeature │ │ │ │ - * Add temporary features │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} A pixel location on the map. │ │ │ │ - */ │ │ │ │ - createFeature: function(pixel) { │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point( │ │ │ │ - lonlat.lon, lonlat.lat │ │ │ │ - ); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - this.callback("create", [this.point.geometry, this.point]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.layer.addFeatures([this.point], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * turn off the handler │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (!OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - this.cancel(); │ │ │ │ - // If a layer's map property is set to null, it means that that layer │ │ │ │ - // isn't added to the map. Since we ourself added the layer to the map │ │ │ │ - // in activate(), we can assume that if this.layer.map is null it means │ │ │ │ - // that the layer has been destroyed (as a result of map.destroy() for │ │ │ │ - // example. │ │ │ │ - if (this.layer.map != null) { │ │ │ │ - this.destroyFeature(true); │ │ │ │ - this.layer.destroy(false); │ │ │ │ - } │ │ │ │ - this.layer = null; │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Popup/Framed.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Bounds.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Pixel.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Size.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroyFeature │ │ │ │ - * Destroy the temporary geometries │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * force - {Boolean} Destroy even if persist is true. │ │ │ │ - */ │ │ │ │ - destroyFeature: function(force) { │ │ │ │ - if (this.layer && (force || !this.persist)) { │ │ │ │ - this.layer.destroyFeatures(); │ │ │ │ - } │ │ │ │ - this.point = null; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Popup.FramedCloud │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Popup.Framed> │ │ │ │ + */ │ │ │ │ +OpenLayers.Popup.FramedCloud = │ │ │ │ + OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroyPersistedFeature │ │ │ │ - * Destroy the persisted feature. │ │ │ │ - */ │ │ │ │ - destroyPersistedFeature: function() { │ │ │ │ - var layer = this.layer; │ │ │ │ - if (layer && layer.features.length > 1) { │ │ │ │ - this.layer.features[0].destroy(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: contentDisplayClass │ │ │ │ + * {String} The CSS class of the popup content div. │ │ │ │ + */ │ │ │ │ + contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: finalize │ │ │ │ - * Finish the geometry and call the "done" callback. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * cancel - {Boolean} Call cancel instead of done callback. Default │ │ │ │ - * is false. │ │ │ │ - */ │ │ │ │ - finalize: function(cancel) { │ │ │ │ - var key = cancel ? "cancel" : "done"; │ │ │ │ - this.mouseDown = false; │ │ │ │ - this.lastDown = null; │ │ │ │ - this.lastUp = null; │ │ │ │ - this.lastTouchPx = null; │ │ │ │ - this.callback(key, [this.geometryClone()]); │ │ │ │ - this.destroyFeature(cancel); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: autoSize │ │ │ │ + * {Boolean} Framed Cloud is autosizing by default. │ │ │ │ + */ │ │ │ │ + autoSize: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: cancel │ │ │ │ - * Finish the geometry and call the "cancel" callback. │ │ │ │ - */ │ │ │ │ - cancel: function() { │ │ │ │ - this.finalize(true); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: panMapIfOutOfView │ │ │ │ + * {Boolean} Framed Cloud does pan into view by default. │ │ │ │ + */ │ │ │ │ + panMapIfOutOfView: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: click │ │ │ │ - * Handle clicks. Clicks are stopped from propagating to other listeners │ │ │ │ - * on map.events or other dom elements. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - click: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: imageSize │ │ │ │ + * {<OpenLayers.Size>} │ │ │ │ + */ │ │ │ │ + imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: dblclick │ │ │ │ - * Handle double-clicks. Double-clicks are stopped from propagating to other │ │ │ │ - * listeners on map.events or other dom elements. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - dblclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: isAlphaImage │ │ │ │ + * {Boolean} The FramedCloud does not use an alpha image (in honor of the │ │ │ │ + * good ie6 folk out there) │ │ │ │ + */ │ │ │ │ + isAlphaImage: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: modifyFeature │ │ │ │ - * Modify the existing geometry given a pixel location. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} A pixel location on the map. │ │ │ │ - */ │ │ │ │ - modifyFeature: function(pixel) { │ │ │ │ - if (!this.point) { │ │ │ │ - this.createFeature(pixel); │ │ │ │ - } │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - this.point.geometry.x = lonlat.lon; │ │ │ │ - this.point.geometry.y = lonlat.lat; │ │ │ │ - this.callback("modify", [this.point.geometry, this.point, false]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.drawFeature(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: fixedRelativePosition │ │ │ │ + * {Boolean} The Framed Cloud popup works in just one fixed position. │ │ │ │ + */ │ │ │ │ + fixedRelativePosition: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: drawFeature │ │ │ │ - * Render features on the temporary layer. │ │ │ │ - */ │ │ │ │ - drawFeature: function() { │ │ │ │ - this.layer.drawFeature(this.point, this.style); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: positionBlocks │ │ │ │ + * {Object} Hash of differen position blocks, keyed by relativePosition │ │ │ │ + * two-character code string (ie "tl", "tr", "bl", "br") │ │ │ │ + */ │ │ │ │ + positionBlocks: { │ │ │ │ + "tl": { │ │ │ │ + 'offset': new OpenLayers.Pixel(44, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 18), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -688) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + "tr": { │ │ │ │ + 'offset': new OpenLayers.Pixel(-45, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 19), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ + position: new OpenLayers.Pixel(-215, -687) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + "bl": { │ │ │ │ + 'offset': new OpenLayers.Pixel(45, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-101, -674) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + "br": { │ │ │ │ + 'offset': new OpenLayers.Pixel(-44, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ + position: new OpenLayers.Pixel(-311, -674) │ │ │ │ + }] │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getGeometry │ │ │ │ - * Return the sketch geometry. If <multi> is true, this will return │ │ │ │ - * a multi-part geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} │ │ │ │ - */ │ │ │ │ - getGeometry: function() { │ │ │ │ - var geometry = this.point && this.point.geometry; │ │ │ │ - if (geometry && this.multi) { │ │ │ │ - geometry = new OpenLayers.Geometry.MultiPoint([geometry]); │ │ │ │ - } │ │ │ │ - return geometry; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: minSize │ │ │ │ + * {<OpenLayers.Size>} │ │ │ │ + */ │ │ │ │ + minSize: new OpenLayers.Size(105, 10), │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: geometryClone │ │ │ │ - * Return a clone of the relevant geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} │ │ │ │ - */ │ │ │ │ - geometryClone: function() { │ │ │ │ - var geom = this.getGeometry(); │ │ │ │ - return geom && geom.clone(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: maxSize │ │ │ │ + * {<OpenLayers.Size>} │ │ │ │ + */ │ │ │ │ + maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mousedown. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - return this.down(evt); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Popup.FramedCloud │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {String} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * contentSize - {<OpenLayers.Size>} │ │ │ │ + * contentHTML - {String} │ │ │ │ + * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ + * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ + * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ + * closeBox - {Boolean} │ │ │ │ + * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ + */ │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ + closeBoxCallback) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - this.lastTouchPx = evt.xy; │ │ │ │ - return this.down(evt); │ │ │ │ - }, │ │ │ │ + this.imageSrc = OpenLayers.Util.getImageLocation('cloud-popup-relative.png'); │ │ │ │ + OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mousemove │ │ │ │ - * Handle mousemove. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - mousemove: function(evt) { │ │ │ │ - return this.move(evt); │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/CSWGetRecords.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Handle touchmove. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - this.lastTouchPx = evt.xy; │ │ │ │ - return this.move(evt); │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouseup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - return this.up(evt); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: touchend │ │ │ │ - * Handle touchend. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - touchend: function(evt) { │ │ │ │ - evt.xy = this.lastTouchPx; │ │ │ │ - return this.up(evt); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.CSWGetRecords │ │ │ │ + * Default version is 2.0.2. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Format>} A CSWGetRecords format of the given version. │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.CSWGetRecords = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults( │ │ │ │ + options, OpenLayers.Format.CSWGetRecords.DEFAULTS │ │ │ │ + ); │ │ │ │ + var cls = OpenLayers.Format.CSWGetRecords["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported CSWGetRecords version: " + options.version; │ │ │ │ + } │ │ │ │ + return new cls(options); │ │ │ │ +}; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: down │ │ │ │ - * Handle mousedown and touchstart. Adjust the geometry and redraw. │ │ │ │ - * Return determines whether to propagate the event on the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - down: function(evt) { │ │ │ │ - this.mouseDown = true; │ │ │ │ - this.lastDown = evt.xy; │ │ │ │ - if (!this.touch) { // no point displayed until up on touch devices │ │ │ │ - this.modifyFeature(evt.xy); │ │ │ │ - } │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - return !this.stopDown; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Constant: DEFAULTS │ │ │ │ + * {Object} Default properties for the CSWGetRecords format. │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.CSWGetRecords.DEFAULTS = { │ │ │ │ + "version": "2.0.2" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WPSCapabilities.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: move │ │ │ │ - * Handle mousemove and touchmove. Adjust the geometry and redraw. │ │ │ │ - * Return determines whether to propagate the event on the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - move: function(evt) { │ │ │ │ - if (!this.touch // no point displayed until up on touch devices │ │ │ │ - && │ │ │ │ - (!this.mouseDown || this.stoppedDown)) { │ │ │ │ - this.modifyFeature(evt.xy); │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WPSCapabilities │ │ │ │ + * Read WPS Capabilities. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WPSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: up │ │ │ │ - * Handle mouseup and touchend. Send the latest point in the geometry to the control. │ │ │ │ - * Return determines whether to propagate the event on the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ */ │ │ │ │ - up: function(evt) { │ │ │ │ - this.mouseDown = false; │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - │ │ │ │ - // check keyboard modifiers │ │ │ │ - if (!this.checkModifiers(evt)) { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - // ignore double-clicks │ │ │ │ - if (this.lastUp && this.lastUp.equals(evt.xy)) { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy, │ │ │ │ - this.pixelTolerance)) { │ │ │ │ - if (this.touch) { │ │ │ │ - this.modifyFeature(evt.xy); │ │ │ │ - } │ │ │ │ - if (this.persist) { │ │ │ │ - this.destroyPersistedFeature(); │ │ │ │ - } │ │ │ │ - this.lastUp = evt.xy; │ │ │ │ - this.finalize(); │ │ │ │ - return !this.stopUp; │ │ │ │ - } else { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + defaultVersion: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mouseout │ │ │ │ - * Handle mouse out. For better user experience reset mouseDown │ │ │ │ - * and stoppedDown when the mouse leaves the map viewport. │ │ │ │ + * Constructor: OpenLayers.Format.WPSCapabilities │ │ │ │ + * Create a new parser for WPS Capabilities. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - this.mouseDown = false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: passesTolerance │ │ │ │ - * Determine whether the event is within the optional pixel tolerance. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return information about │ │ │ │ + * the service. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The event is within the pixel tolerance (if specified). │ │ │ │ + * {Object} Info about the WPS │ │ │ │ */ │ │ │ │ - passesTolerance: function(pixel1, pixel2, tolerance) { │ │ │ │ - var passes = true; │ │ │ │ │ │ │ │ - if (tolerance != null && pixel1 && pixel2) { │ │ │ │ - var dist = pixel1.distanceTo(pixel2); │ │ │ │ - if (dist > tolerance) { │ │ │ │ - passes = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return passes; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WPSCapabilities" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Point" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Path.js │ │ │ │ + OpenLayers/Format/WMTSCapabilities.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Path │ │ │ │ - * Handler to draw a path on the map. Path is displayed on mouse down, │ │ │ │ - * moves on mouse move, and is finished on mouse up. │ │ │ │ + * Class: OpenLayers.Format.WMTSCapabilities │ │ │ │ + * Read WMTS Capabilities. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler.Point> │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Path = OpenLayers.Class(OpenLayers.Handler.Point, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: line │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - line: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: maxVertices │ │ │ │ - * {Number} The maximum number of vertices which can be drawn by this │ │ │ │ - * handler. When the number of vertices reaches maxVertices, the │ │ │ │ - * geometry is automatically finalized. Default is null. │ │ │ │ - */ │ │ │ │ - maxVertices: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: doubleTouchTolerance │ │ │ │ - * {Number} Maximum number of pixels between two touches for │ │ │ │ - * the gesture to be considered a "finalize feature" action. │ │ │ │ - * Default is 20. │ │ │ │ - */ │ │ │ │ - doubleTouchTolerance: 20, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: freehand │ │ │ │ - * {Boolean} In freehand mode, the handler starts the path on mouse down, │ │ │ │ - * adds a point for every mouse move, and finishes the path on mouse up. │ │ │ │ - * Outside of freehand mode, a point is added to the path on every mouse │ │ │ │ - * click and double-click finishes the path. │ │ │ │ - */ │ │ │ │ - freehand: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: freehandToggle │ │ │ │ - * {String} If set, freehandToggle is checked on mouse events and will set │ │ │ │ - * the freehand mode to the opposite of this.freehand. To disallow │ │ │ │ - * toggling between freehand and non-freehand mode, set freehandToggle to │ │ │ │ - * null. Acceptable toggle values are 'shiftKey', 'ctrlKey', and 'altKey'. │ │ │ │ - */ │ │ │ │ - freehandToggle: 'shiftKey', │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: timerId │ │ │ │ - * {Integer} The timer used to test the double touch. │ │ │ │ - */ │ │ │ │ - timerId: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: redoStack │ │ │ │ - * {Array} Stack containing points removed with <undo>. │ │ │ │ - */ │ │ │ │ - redoStack: null, │ │ │ │ +OpenLayers.Format.WMTSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Path │ │ │ │ - * Create a new path hander │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ - * callbacks - {Object} An object with a properties whose values are │ │ │ │ - * functions. Various callbacks described below. │ │ │ │ - * options - {Object} An optional object with properties to be set on the │ │ │ │ - * handler │ │ │ │ - * │ │ │ │ - * Named callbacks: │ │ │ │ - * create - Called when a sketch is first created. Callback called with │ │ │ │ - * the creation point geometry and sketch feature. │ │ │ │ - * modify - Called with each move of a vertex with the vertex (point) │ │ │ │ - * geometry and the sketch feature. │ │ │ │ - * point - Called as each point is added. Receives the new point geometry. │ │ │ │ - * done - Called when the point drawing is finished. The callback will │ │ │ │ - * recieve a single argument, the linestring geometry. │ │ │ │ - * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ - * cancel callback will receive a geometry. │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ */ │ │ │ │ + defaultVersion: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFeature │ │ │ │ - * Add temporary geometries │ │ │ │ + * APIProperty: yx │ │ │ │ + * {Object} Members in the yx object are used to determine if a CRS URN │ │ │ │ + * corresponds to a CRS with y,x axis order. Member names are CRS URNs │ │ │ │ + * and values are boolean. By default, the following CRS URN are │ │ │ │ + * assumed to correspond to a CRS with y,x axis order: │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The initial pixel location for the new │ │ │ │ - * feature. │ │ │ │ + * * urn:ogc:def:crs:EPSG::4326 │ │ │ │ */ │ │ │ │ - createFeature: function(pixel) { │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point( │ │ │ │ - lonlat.lon, lonlat.lat │ │ │ │ - ); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - this.line = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.LineString([this.point.geometry]) │ │ │ │ - ); │ │ │ │ - this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.layer.addFeatures([this.line, this.point], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ + yx: { │ │ │ │ + "urn:ogc:def:crs:EPSG::4326": true │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroyFeature │ │ │ │ - * Destroy temporary geometries │ │ │ │ + * Constructor: OpenLayers.Format.WMTSCapabilities │ │ │ │ + * Create a new parser for WMTS capabilities. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * force - {Boolean} Destroy even if persist is true. │ │ │ │ - */ │ │ │ │ - destroyFeature: function(force) { │ │ │ │ - OpenLayers.Handler.Point.prototype.destroyFeature.call( │ │ │ │ - this, force); │ │ │ │ - this.line = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroyPersistedFeature │ │ │ │ - * Destroy the persisted feature. │ │ │ │ - */ │ │ │ │ - destroyPersistedFeature: function() { │ │ │ │ - var layer = this.layer; │ │ │ │ - if (layer && layer.features.length > 2) { │ │ │ │ - this.layer.features[0].destroy(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: removePoint │ │ │ │ - * Destroy the temporary point. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - removePoint: function() { │ │ │ │ - if (this.point) { │ │ │ │ - this.layer.removeFeatures([this.point]); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addPoint │ │ │ │ - * Add point to geometry. Send the point index to override │ │ │ │ - * the behavior of LinearRing that disregards adding duplicate points. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return information about │ │ │ │ + * the service (offering and observedProperty mostly). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The pixel location for the new point. │ │ │ │ - */ │ │ │ │ - addPoint: function(pixel) { │ │ │ │ - this.layer.removeFeatures([this.point]); │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - this.point = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat) │ │ │ │ - ); │ │ │ │ - this.line.geometry.addComponent( │ │ │ │ - this.point.geometry, this.line.geometry.components.length │ │ │ │ - ); │ │ │ │ - this.layer.addFeatures([this.point]); │ │ │ │ - this.callback("point", [this.point.geometry, this.getGeometry()]); │ │ │ │ - this.callback("modify", [this.point.geometry, this.getSketch()]); │ │ │ │ - this.drawFeature(); │ │ │ │ - delete this.redoStack; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: insertXY │ │ │ │ - * Insert a point in the current sketch given x & y coordinates. The new │ │ │ │ - * point is inserted immediately before the most recently drawn point. │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Number} The x-coordinate of the point. │ │ │ │ - * y - {Number} The y-coordinate of the point. │ │ │ │ + * Returns: │ │ │ │ + * {Object} Info about the WMTS Capabilities │ │ │ │ */ │ │ │ │ - insertXY: function(x, y) { │ │ │ │ - this.line.geometry.addComponent( │ │ │ │ - new OpenLayers.Geometry.Point(x, y), │ │ │ │ - this.getCurrentPointIndex() │ │ │ │ - ); │ │ │ │ - this.drawFeature(); │ │ │ │ - delete this.redoStack; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: insertDeltaXY │ │ │ │ - * Insert a point given offsets from the previously inserted point. │ │ │ │ + * APIMethod: createLayer │ │ │ │ + * Create a WMTS layer given a capabilities object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * dx - {Number} The x-coordinate offset of the point. │ │ │ │ - * dy - {Number} The y-coordinate offset of the point. │ │ │ │ - */ │ │ │ │ - insertDeltaXY: function(dx, dy) { │ │ │ │ - var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ - var p0 = this.line.geometry.components[previousIndex]; │ │ │ │ - if (p0 && !isNaN(p0.x) && !isNaN(p0.y)) { │ │ │ │ - this.insertXY(p0.x + dx, p0.y + dy); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: insertDirectionLength │ │ │ │ - * Insert a point in the current sketch given a direction and a length. │ │ │ │ + * capabilities - {Object} The object returned from a <read> call to this │ │ │ │ + * format. │ │ │ │ + * config - {Object} Configuration properties for the layer. Defaults for │ │ │ │ + * the layer will apply if not provided. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * direction - {Number} Degrees clockwise from the positive x-axis. │ │ │ │ - * length - {Number} Distance from the previously drawn point. │ │ │ │ - */ │ │ │ │ - insertDirectionLength: function(direction, length) { │ │ │ │ - direction *= Math.PI / 180; │ │ │ │ - var dx = length * Math.cos(direction); │ │ │ │ - var dy = length * Math.sin(direction); │ │ │ │ - this.insertDeltaXY(dx, dy); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: insertDeflectionLength │ │ │ │ - * Insert a point in the current sketch given a deflection and a length. │ │ │ │ - * The deflection should be degrees clockwise from the previously │ │ │ │ - * digitized segment. │ │ │ │ + * Required config properties: │ │ │ │ + * layer - {String} The layer identifier. │ │ │ │ + * │ │ │ │ + * Optional config properties: │ │ │ │ + * matrixSet - {String} The matrix set identifier, required if there is │ │ │ │ + * more than one matrix set in the layer capabilities. │ │ │ │ + * style - {String} The name of the style │ │ │ │ + * format - {String} Image format for the layer. Default is the first │ │ │ │ + * format returned in the GetCapabilities response. │ │ │ │ + * param - {Object} The dimensions values eg: {"Year": "2012"} │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * deflection - {Number} Degrees clockwise from the previous segment. │ │ │ │ - * length - {Number} Distance from the previously drawn point. │ │ │ │ - */ │ │ │ │ - insertDeflectionLength: function(deflection, length) { │ │ │ │ - var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ - if (previousIndex > 0) { │ │ │ │ - var p1 = this.line.geometry.components[previousIndex]; │ │ │ │ - var p0 = this.line.geometry.components[previousIndex - 1]; │ │ │ │ - var theta = Math.atan2(p1.y - p0.y, p1.x - p0.x); │ │ │ │ - this.insertDirectionLength( │ │ │ │ - (theta * 180 / Math.PI) + deflection, length │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getCurrentPointIndex │ │ │ │ - * │ │ │ │ * Returns: │ │ │ │ - * {Number} The index of the most recently drawn point. │ │ │ │ + * {<OpenLayers.Layer.WMTS>} A properly configured WMTS layer. Throws an │ │ │ │ + * error if an incomplete config is provided. Returns undefined if no │ │ │ │ + * layer could be created with the provided config. │ │ │ │ */ │ │ │ │ - getCurrentPointIndex: function() { │ │ │ │ - return this.line.geometry.components.length - 1; │ │ │ │ - }, │ │ │ │ + createLayer: function(capabilities, config) { │ │ │ │ + var layer; │ │ │ │ │ │ │ │ + // confirm required properties are supplied in config │ │ │ │ + if (!('layer' in config)) { │ │ │ │ + throw new Error("Missing property 'layer' in configuration."); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: undo │ │ │ │ - * Remove the most recently added point in the sketch geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} A point was removed. │ │ │ │ - */ │ │ │ │ - undo: function() { │ │ │ │ - var geometry = this.line.geometry; │ │ │ │ - var components = geometry.components; │ │ │ │ - var index = this.getCurrentPointIndex() - 1; │ │ │ │ - var target = components[index]; │ │ │ │ - var undone = geometry.removeComponent(target); │ │ │ │ - if (undone) { │ │ │ │ - // On touch devices, set the current ("mouse location") point to │ │ │ │ - // match the last digitized point. │ │ │ │ - if (this.touch && index > 0) { │ │ │ │ - components = geometry.components; // safety │ │ │ │ - var lastpt = components[index - 1]; │ │ │ │ - var curptidx = this.getCurrentPointIndex(); │ │ │ │ - var curpt = components[curptidx]; │ │ │ │ - curpt.x = lastpt.x; │ │ │ │ - curpt.y = lastpt.y; │ │ │ │ - } │ │ │ │ - if (!this.redoStack) { │ │ │ │ - this.redoStack = []; │ │ │ │ + var contents = capabilities.contents; │ │ │ │ + │ │ │ │ + // find the layer definition with the given identifier │ │ │ │ + var layers = contents.layers; │ │ │ │ + var layerDef; │ │ │ │ + for (var i = 0, ii = contents.layers.length; i < ii; ++i) { │ │ │ │ + if (contents.layers[i].identifier === config.layer) { │ │ │ │ + layerDef = contents.layers[i]; │ │ │ │ + break; │ │ │ │ } │ │ │ │ - this.redoStack.push(target); │ │ │ │ - this.drawFeature(); │ │ │ │ } │ │ │ │ - return undone; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: redo │ │ │ │ - * Reinsert the most recently removed point resulting from an <undo> call. │ │ │ │ - * The undo stack is deleted whenever a point is added by other means. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} A point was added. │ │ │ │ - */ │ │ │ │ - redo: function() { │ │ │ │ - var target = this.redoStack && this.redoStack.pop(); │ │ │ │ - if (target) { │ │ │ │ - this.line.geometry.addComponent(target, this.getCurrentPointIndex()); │ │ │ │ - this.drawFeature(); │ │ │ │ + if (!layerDef) { │ │ │ │ + throw new Error("Layer not found"); │ │ │ │ } │ │ │ │ - return !!target; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: freehandMode │ │ │ │ - * Determine whether to behave in freehand mode or not. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - freehandMode: function(evt) { │ │ │ │ - return (this.freehandToggle && evt[this.freehandToggle]) ? │ │ │ │ - !this.freehand : this.freehand; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: modifyFeature │ │ │ │ - * Modify the existing geometry given the new point │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The updated pixel location for the latest │ │ │ │ - * point. │ │ │ │ - * drawing - {Boolean} Indicate if we're currently drawing. │ │ │ │ - */ │ │ │ │ - modifyFeature: function(pixel, drawing) { │ │ │ │ - if (!this.line) { │ │ │ │ - this.createFeature(pixel); │ │ │ │ + var format = config.format; │ │ │ │ + if (!format && layerDef.formats && layerDef.formats.length) { │ │ │ │ + format = layerDef.formats[0]; │ │ │ │ } │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - this.point.geometry.x = lonlat.lon; │ │ │ │ - this.point.geometry.y = lonlat.lat; │ │ │ │ - this.callback("modify", [this.point.geometry, this.getSketch(), drawing]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.drawFeature(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawFeature │ │ │ │ - * Render geometries on the temporary layer. │ │ │ │ - */ │ │ │ │ - drawFeature: function() { │ │ │ │ - this.layer.drawFeature(this.line, this.style); │ │ │ │ - this.layer.drawFeature(this.point, this.style); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getSketch │ │ │ │ - * Return the sketch feature. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - getSketch: function() { │ │ │ │ - return this.line; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getGeometry │ │ │ │ - * Return the sketch geometry. If <multi> is true, this will return │ │ │ │ - * a multi-part geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.LineString>} │ │ │ │ - */ │ │ │ │ - getGeometry: function() { │ │ │ │ - var geometry = this.line && this.line.geometry; │ │ │ │ - if (geometry && this.multi) { │ │ │ │ - geometry = new OpenLayers.Geometry.MultiLineString([geometry]); │ │ │ │ + // find the matrixSet definition │ │ │ │ + var matrixSet; │ │ │ │ + if (config.matrixSet) { │ │ │ │ + matrixSet = contents.tileMatrixSets[config.matrixSet]; │ │ │ │ + } else if (layerDef.tileMatrixSetLinks.length >= 1) { │ │ │ │ + matrixSet = contents.tileMatrixSets[ │ │ │ │ + layerDef.tileMatrixSetLinks[0].tileMatrixSet]; │ │ │ │ + } │ │ │ │ + if (!matrixSet) { │ │ │ │ + throw new Error("matrixSet not found"); │ │ │ │ } │ │ │ │ - return geometry; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * method: touchstart │ │ │ │ - * handle touchstart. │ │ │ │ - * │ │ │ │ - * parameters: │ │ │ │ - * evt - {event} the browser event │ │ │ │ - * │ │ │ │ - * returns: │ │ │ │ - * {boolean} allow event propagation │ │ │ │ - */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - if (this.timerId && │ │ │ │ - this.passesTolerance(this.lastTouchPx, evt.xy, │ │ │ │ - this.doubleTouchTolerance)) { │ │ │ │ - // double-tap, finalize the geometry │ │ │ │ - this.finishGeometry(); │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - return false; │ │ │ │ - } else { │ │ │ │ - if (this.timerId) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ + // get the default style for the layer │ │ │ │ + var style; │ │ │ │ + for (var i = 0, ii = layerDef.styles.length; i < ii; ++i) { │ │ │ │ + style = layerDef.styles[i]; │ │ │ │ + if (style.isDefault) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ - this.timerId = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(function() { │ │ │ │ - this.timerId = null; │ │ │ │ - }, this), 300); │ │ │ │ - return OpenLayers.Handler.Point.prototype.touchstart.call(this, evt); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: down │ │ │ │ - * Handle mousedown and touchstart. Add a new point to the geometry and │ │ │ │ - * render it. Return determines whether to propagate the event on the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - down: function(evt) { │ │ │ │ - var stopDown = this.stopDown; │ │ │ │ - if (this.freehandMode(evt)) { │ │ │ │ - stopDown = true; │ │ │ │ - if (this.touch) { │ │ │ │ - this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ + var requestEncoding = config.requestEncoding; │ │ │ │ + if (!requestEncoding) { │ │ │ │ + requestEncoding = "KVP"; │ │ │ │ + if (capabilities.operationsMetadata.GetTile.dcp.http) { │ │ │ │ + var http = capabilities.operationsMetadata.GetTile.dcp.http; │ │ │ │ + // Get first get method │ │ │ │ + if (http.get[0].constraints) { │ │ │ │ + var constraints = http.get[0].constraints; │ │ │ │ + var allowedValues = constraints.GetEncoding.allowedValues; │ │ │ │ + │ │ │ │ + // The OGC documentation is not clear if we should use │ │ │ │ + // REST or RESTful, ArcGis use RESTful, │ │ │ │ + // and OpenLayers use REST. │ │ │ │ + if (!allowedValues.KVP && │ │ │ │ + (allowedValues.REST || allowedValues.RESTful)) { │ │ │ │ + requestEncoding = "REST"; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - if (!this.touch && (!this.lastDown || │ │ │ │ - !this.passesTolerance(this.lastDown, evt.xy, │ │ │ │ - this.pixelTolerance))) { │ │ │ │ - this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ - } │ │ │ │ - this.mouseDown = true; │ │ │ │ - this.lastDown = evt.xy; │ │ │ │ - this.stoppedDown = stopDown; │ │ │ │ - return !stopDown; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: move │ │ │ │ - * Handle mousemove and touchmove. Adjust the geometry and redraw. │ │ │ │ - * Return determines whether to propagate the event on the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - move: function(evt) { │ │ │ │ - if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ - if (this.persist) { │ │ │ │ - this.destroyPersistedFeature(); │ │ │ │ - } │ │ │ │ - if (this.maxVertices && this.line && │ │ │ │ - this.line.geometry.components.length === this.maxVertices) { │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize(); │ │ │ │ - } else { │ │ │ │ - this.addPoint(evt.xy); │ │ │ │ + var dimensions = []; │ │ │ │ + var params = config.params || {}; │ │ │ │ + // to don't overwrite the changes in the applyDefaults │ │ │ │ + delete config.params; │ │ │ │ + for (var id = 0, ld = layerDef.dimensions.length; id < ld; id++) { │ │ │ │ + var dimension = layerDef.dimensions[id]; │ │ │ │ + dimensions.push(dimension.identifier); │ │ │ │ + if (!params.hasOwnProperty(dimension.identifier)) { │ │ │ │ + params[dimension.identifier] = dimension['default']; │ │ │ │ } │ │ │ │ - return false; │ │ │ │ } │ │ │ │ - if (!this.touch && (!this.mouseDown || this.stoppedDown)) { │ │ │ │ - this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ + │ │ │ │ + var projection = config.projection || matrixSet.supportedCRS.replace( │ │ │ │ + /urn:ogc:def:crs:(\w+):(.*:)?(\w+)$/, "$1:$3"); │ │ │ │ + var units = config.units || │ │ │ │ + (projection === "EPSG:4326" ? "degrees" : "m"); │ │ │ │ + │ │ │ │ + var resolutions = []; │ │ │ │ + for (var mid in matrixSet.matrixIds) { │ │ │ │ + if (matrixSet.matrixIds.hasOwnProperty(mid)) { │ │ │ │ + resolutions.push( │ │ │ │ + matrixSet.matrixIds[mid].scaleDenominator * 0.28E-3 / │ │ │ │ + OpenLayers.METERS_PER_INCH / │ │ │ │ + OpenLayers.INCHES_PER_UNIT[units]); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: up │ │ │ │ - * Handle mouseup and touchend. Send the latest point in the geometry to │ │ │ │ - * the control. Return determines whether to propagate the event on the map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - up: function(evt) { │ │ │ │ - if (this.mouseDown && (!this.lastUp || !this.lastUp.equals(evt.xy))) { │ │ │ │ - if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ - if (this.persist) { │ │ │ │ - this.destroyPersistedFeature(); │ │ │ │ + var url; │ │ │ │ + if (requestEncoding === "REST" && layerDef.resourceUrls) { │ │ │ │ + url = []; │ │ │ │ + var resourceUrls = layerDef.resourceUrls, │ │ │ │ + resourceUrl; │ │ │ │ + for (var t = 0, tt = layerDef.resourceUrls.length; t < tt; ++t) { │ │ │ │ + resourceUrl = layerDef.resourceUrls[t]; │ │ │ │ + if (resourceUrl.format === format && resourceUrl.resourceType === "tile") { │ │ │ │ + url.push(resourceUrl.template); │ │ │ │ } │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize(); │ │ │ │ - } else { │ │ │ │ - if (this.passesTolerance(this.lastDown, evt.xy, │ │ │ │ - this.pixelTolerance)) { │ │ │ │ - if (this.touch) { │ │ │ │ - this.modifyFeature(evt.xy); │ │ │ │ - } │ │ │ │ - if (this.lastUp == null && this.persist) { │ │ │ │ - this.destroyPersistedFeature(); │ │ │ │ - } │ │ │ │ - this.addPoint(evt.xy); │ │ │ │ - this.lastUp = evt.xy; │ │ │ │ - if (this.line.geometry.components.length === this.maxVertices + 1) { │ │ │ │ - this.finishGeometry(); │ │ │ │ - } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + var httpGet = capabilities.operationsMetadata.GetTile.dcp.http.get; │ │ │ │ + url = []; │ │ │ │ + var constraint; │ │ │ │ + for (var i = 0, ii = httpGet.length; i < ii; i++) { │ │ │ │ + constraint = httpGet[i].constraints; │ │ │ │ + if (!constraint || (constraint && constraint.GetEncoding.allowedValues[requestEncoding])) { │ │ │ │ + url.push(httpGet[i].url); │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - this.mouseDown = false; │ │ │ │ - return !this.stopUp; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: finishGeometry │ │ │ │ - * Finish the geometry and send it back to the control. │ │ │ │ - */ │ │ │ │ - finishGeometry: function() { │ │ │ │ - var index = this.line.geometry.components.length - 1; │ │ │ │ - this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize(); │ │ │ │ + return new OpenLayers.Layer.WMTS( │ │ │ │ + OpenLayers.Util.applyDefaults(config, { │ │ │ │ + url: url, │ │ │ │ + requestEncoding: requestEncoding, │ │ │ │ + name: layerDef.title, │ │ │ │ + style: style.identifier, │ │ │ │ + format: format, │ │ │ │ + matrixIds: matrixSet.matrixIds, │ │ │ │ + matrixSet: matrixSet.identifier, │ │ │ │ + projection: projection, │ │ │ │ + units: units, │ │ │ │ + resolutions: config.isBaseLayer === false ? undefined : resolutions, │ │ │ │ + serverResolutions: resolutions, │ │ │ │ + tileFullExtent: matrixSet.bounds, │ │ │ │ + dimensions: dimensions, │ │ │ │ + params: params │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: dblclick │ │ │ │ - * Handle double-clicks. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow event propagation │ │ │ │ - */ │ │ │ │ - dblclick: function(evt) { │ │ │ │ - if (!this.freehandMode(evt)) { │ │ │ │ - this.finishGeometry(); │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMTSCapabilities" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Path" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Polygon.js │ │ │ │ + OpenLayers/Format/QueryStringFilter.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler/Path.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + * @requires OpenLayers/Console.js │ │ │ │ + * @requires OpenLayers/Format.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + * @requires OpenLayers/Filter/Comparison.js │ │ │ │ + * @requires OpenLayers/Filter/Logical.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Polygon │ │ │ │ - * Handler to draw a polygon on the map. Polygon is displayed on mouse down, │ │ │ │ - * moves on mouse move, and is finished on mouse up. │ │ │ │ + * Class: OpenLayers.Format.QueryStringFilter │ │ │ │ + * Parser for reading a query string and creating a simple filter. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler.Path> │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Format> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Polygon = OpenLayers.Class(OpenLayers.Handler.Path, { │ │ │ │ +OpenLayers.Format.QueryStringFilter = (function() { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: holeModifier │ │ │ │ - * {String} Key modifier to trigger hole digitizing. Acceptable values are │ │ │ │ - * "altKey", "shiftKey", or "ctrlKey". If not set, no hole digitizing │ │ │ │ - * will take place. Default is null. │ │ │ │ - */ │ │ │ │ - holeModifier: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: drawingHole │ │ │ │ - * {Boolean} Currently drawing an interior ring. │ │ │ │ - */ │ │ │ │ - drawingHole: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: polygon │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ + * Map the OpenLayers.Filter.Comparison types to the operation strings of │ │ │ │ + * the protocol. │ │ │ │ */ │ │ │ │ - polygon: null, │ │ │ │ + var cmpToStr = {}; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.EQUAL_TO] = "eq"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.NOT_EQUAL_TO] = "ne"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN] = "lt"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO] = "lte"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN] = "gt"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO] = "gte"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.LIKE] = "ilike"; │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Polygon │ │ │ │ - * Create a Polygon Handler. │ │ │ │ + * Function: regex2value │ │ │ │ + * Convert the value from a regular expression string to a LIKE/ILIKE │ │ │ │ + * string known to the web service. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ - * callbacks - {Object} An object with a properties whose values are │ │ │ │ - * functions. Various callbacks described below. │ │ │ │ - * options - {Object} An optional object with properties to be set on the │ │ │ │ - * handler │ │ │ │ + * value - {String} The regex string. │ │ │ │ * │ │ │ │ - * Named callbacks: │ │ │ │ - * create - Called when a sketch is first created. Callback called with │ │ │ │ - * the creation point geometry and sketch feature. │ │ │ │ - * modify - Called with each move of a vertex with the vertex (point) │ │ │ │ - * geometry and the sketch feature. │ │ │ │ - * point - Called as each point is added. Receives the new point geometry. │ │ │ │ - * done - Called when the point drawing is finished. The callback will │ │ │ │ - * recieve a single argument, the polygon geometry. │ │ │ │ - * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ - * cancel callback will receive a geometry. │ │ │ │ + * Returns: │ │ │ │ + * {String} The converted string. │ │ │ │ */ │ │ │ │ + function regex2value(value) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createFeature │ │ │ │ - * Add temporary geometries │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The initial pixel location for the new │ │ │ │ - * feature. │ │ │ │ - */ │ │ │ │ - createFeature: function(pixel) { │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point( │ │ │ │ - lonlat.lon, lonlat.lat │ │ │ │ - ); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - this.line = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.LinearRing([this.point.geometry]) │ │ │ │ - ); │ │ │ │ - this.polygon = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.Polygon([this.line.geometry]) │ │ │ │ - ); │ │ │ │ - this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.layer.addFeatures([this.polygon, this.point], { │ │ │ │ - silent: true │ │ │ │ + // highly sensitive!! Do not change this without running the │ │ │ │ + // Protocol/HTTP.html unit tests │ │ │ │ + │ │ │ │ + // convert % to \% │ │ │ │ + value = value.replace(/%/g, "\\%"); │ │ │ │ + │ │ │ │ + // convert \\. to \\_ (\\.* occurences converted later) │ │ │ │ + value = value.replace(/\\\\\.(\*)?/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "\\\\_"; │ │ │ │ }); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: addPoint │ │ │ │ - * Add point to geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} The pixel location for the new point. │ │ │ │ - */ │ │ │ │ - addPoint: function(pixel) { │ │ │ │ - if (!this.drawingHole && this.holeModifier && │ │ │ │ - this.evt && this.evt[this.holeModifier]) { │ │ │ │ - var geometry = this.point.geometry; │ │ │ │ - var features = this.control.layer.features; │ │ │ │ - var candidate, polygon; │ │ │ │ - // look for intersections, last drawn gets priority │ │ │ │ - for (var i = features.length - 1; i >= 0; --i) { │ │ │ │ - candidate = features[i].geometry; │ │ │ │ - if ((candidate instanceof OpenLayers.Geometry.Polygon || │ │ │ │ - candidate instanceof OpenLayers.Geometry.MultiPolygon) && │ │ │ │ - candidate.intersects(geometry)) { │ │ │ │ - polygon = features[i]; │ │ │ │ - this.control.layer.removeFeatures([polygon], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.control.layer.events.registerPriority( │ │ │ │ - "sketchcomplete", this, this.finalizeInteriorRing │ │ │ │ - ); │ │ │ │ - this.control.layer.events.registerPriority( │ │ │ │ - "sketchmodified", this, this.enforceTopology │ │ │ │ - ); │ │ │ │ - polygon.geometry.addComponent(this.line.geometry); │ │ │ │ - this.polygon = polygon; │ │ │ │ - this.drawingHole = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Handler.Path.prototype.addPoint.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + // convert \\.* to \\% │ │ │ │ + value = value.replace(/\\\\\.\*/g, "\\\\%"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getCurrentPointIndex │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} The index of the most recently drawn point. │ │ │ │ - */ │ │ │ │ - getCurrentPointIndex: function() { │ │ │ │ - return this.line.geometry.components.length - 2; │ │ │ │ - }, │ │ │ │ + // convert . to _ (\. and .* occurences converted later) │ │ │ │ + value = value.replace(/(\\)?\.(\*)?/g, function($0, $1, $2) { │ │ │ │ + return $1 || $2 ? $0 : "_"; │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: enforceTopology │ │ │ │ - * Simple topology enforcement for drawing interior rings. Ensures vertices │ │ │ │ - * of interior rings are contained by exterior ring. Other topology │ │ │ │ - * rules are enforced in <finalizeInteriorRing> to allow drawing of │ │ │ │ - * rings that intersect only during the sketch (e.g. a "C" shaped ring │ │ │ │ - * that nearly encloses another ring). │ │ │ │ - */ │ │ │ │ - enforceTopology: function(event) { │ │ │ │ - var point = event.vertex; │ │ │ │ - var components = this.line.geometry.components; │ │ │ │ - // ensure that vertices of interior ring are contained by exterior ring │ │ │ │ - if (!this.polygon.geometry.intersects(point)) { │ │ │ │ - var last = components[components.length - 3]; │ │ │ │ - point.x = last.x; │ │ │ │ - point.y = last.y; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + // convert .* to % (\.* occurnces converted later) │ │ │ │ + value = value.replace(/(\\)?\.\*/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "%"; │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: finishGeometry │ │ │ │ - * Finish the geometry and send it back to the control. │ │ │ │ - */ │ │ │ │ - finishGeometry: function() { │ │ │ │ - var index = this.line.geometry.components.length - 2; │ │ │ │ - this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize(); │ │ │ │ - }, │ │ │ │ + // convert \. to . │ │ │ │ + value = value.replace(/\\\./g, "."); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: finalizeInteriorRing │ │ │ │ - * Enforces that new ring has some area and doesn't contain vertices of any │ │ │ │ - * other rings. │ │ │ │ - */ │ │ │ │ - finalizeInteriorRing: function() { │ │ │ │ - var ring = this.line.geometry; │ │ │ │ - // ensure that ring has some area │ │ │ │ - var modified = (ring.getArea() !== 0); │ │ │ │ - if (modified) { │ │ │ │ - // ensure that new ring doesn't intersect any other rings │ │ │ │ - var rings = this.polygon.geometry.components; │ │ │ │ - for (var i = rings.length - 2; i >= 0; --i) { │ │ │ │ - if (ring.intersects(rings[i])) { │ │ │ │ - modified = false; │ │ │ │ + // replace \* with * (watching out for \\*) │ │ │ │ + value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "*"; │ │ │ │ + }); │ │ │ │ + │ │ │ │ + return value; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: wildcarded. │ │ │ │ + * {Boolean} If true percent signs are added around values │ │ │ │ + * read from LIKE filters, for example if the protocol │ │ │ │ + * read method is passed a LIKE filter whose property │ │ │ │ + * is "foo" and whose value is "bar" the string │ │ │ │ + * "foo__ilike=%bar%" will be sent in the query string; │ │ │ │ + * defaults to false. │ │ │ │ + */ │ │ │ │ + wildcarded: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: srsInBBOX │ │ │ │ + * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ + * Default is false. If true and the layer has a projection object set, │ │ │ │ + * any BBOX filter will be serialized with a fifth item identifying the │ │ │ │ + * projection. E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ + */ │ │ │ │ + srsInBBOX: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: write │ │ │ │ + * Serialize an <OpenLayers.Filter> objects using the "simple" filter syntax for │ │ │ │ + * query string parameters. This function must be called as a method of │ │ │ │ + * a protocol instance. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ + * params - {Object} The parameters object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} The resulting parameters object. │ │ │ │ + */ │ │ │ │ + write: function(filter, params) { │ │ │ │ + params = params || {}; │ │ │ │ + var className = filter.CLASS_NAME; │ │ │ │ + var filterType = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ + switch (filterType) { │ │ │ │ + case "Spatial": │ │ │ │ + switch (filter.type) { │ │ │ │ + case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ + params.bbox = filter.value.toArray(); │ │ │ │ + if (this.srsInBBOX && filter.projection) { │ │ │ │ + params.bbox.push(filter.projection.getCode()); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ + params.tolerance = filter.distance; │ │ │ │ + // no break here │ │ │ │ + case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ + params.lon = filter.value.x; │ │ │ │ + params.lat = filter.value.y; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + OpenLayers.Console.warn( │ │ │ │ + "Unknown spatial filter type " + filter.type); │ │ │ │ + } │ │ │ │ break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (modified) { │ │ │ │ - // ensure that new ring doesn't contain any other rings │ │ │ │ - var target; │ │ │ │ - outer: for (var i = rings.length - 2; i > 0; --i) { │ │ │ │ - var points = rings[i].components; │ │ │ │ - for (var j = 0, jj = points.length; j < jj; ++j) { │ │ │ │ - if (ring.containsPoint(points[j])) { │ │ │ │ - modified = false; │ │ │ │ - break outer; │ │ │ │ + case "Comparison": │ │ │ │ + var op = cmpToStr[filter.type]; │ │ │ │ + if (op !== undefined) { │ │ │ │ + var value = filter.value; │ │ │ │ + if (filter.type == OpenLayers.Filter.Comparison.LIKE) { │ │ │ │ + value = regex2value(value); │ │ │ │ + if (this.wildcarded) { │ │ │ │ + value = "%" + value + "%"; │ │ │ │ + } │ │ │ │ } │ │ │ │ + params[filter.property + "__" + op] = value; │ │ │ │ + params.queryable = params.queryable || []; │ │ │ │ + params.queryable.push(filter.property); │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.warn( │ │ │ │ + "Unknown comparison filter type " + filter.type); │ │ │ │ } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (modified) { │ │ │ │ - if (this.polygon.state !== OpenLayers.State.INSERT) { │ │ │ │ - this.polygon.state = OpenLayers.State.UPDATE; │ │ │ │ + break; │ │ │ │ + case "Logical": │ │ │ │ + if (filter.type === OpenLayers.Filter.Logical.AND) { │ │ │ │ + for (var i = 0, len = filter.filters.length; i < len; i++) { │ │ │ │ + params = this.write(filter.filters[i], params); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.warn( │ │ │ │ + "Unsupported logical filter type " + filter.type); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + OpenLayers.Console.warn("Unknown filter type " + filterType); │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - this.polygon.geometry.removeComponent(ring); │ │ │ │ - } │ │ │ │ - this.restoreFeature(); │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: cancel │ │ │ │ - * Finish the geometry and call the "cancel" callback. │ │ │ │ - */ │ │ │ │ - cancel: function() { │ │ │ │ - if (this.drawingHole) { │ │ │ │ - this.polygon.geometry.removeComponent(this.line.geometry); │ │ │ │ - this.restoreFeature(true); │ │ │ │ - } │ │ │ │ - return OpenLayers.Handler.Path.prototype.cancel.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: restoreFeature │ │ │ │ - * Move the feature from the sketch layer to the target layer. │ │ │ │ - * │ │ │ │ - * Properties: │ │ │ │ - * cancel - {Boolean} Cancel drawing. If falsey, the "sketchcomplete" event │ │ │ │ - * will be fired. │ │ │ │ - */ │ │ │ │ - restoreFeature: function(cancel) { │ │ │ │ - this.control.layer.events.unregister( │ │ │ │ - "sketchcomplete", this, this.finalizeInteriorRing │ │ │ │ - ); │ │ │ │ - this.control.layer.events.unregister( │ │ │ │ - "sketchmodified", this, this.enforceTopology │ │ │ │ - ); │ │ │ │ - this.layer.removeFeatures([this.polygon], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.control.layer.addFeatures([this.polygon], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.drawingHole = false; │ │ │ │ - if (!cancel) { │ │ │ │ - // Re-trigger "sketchcomplete" so other listeners can do their │ │ │ │ - // business. While this is somewhat sloppy (if a listener is │ │ │ │ - // registered with registerPriority - not common - between the start │ │ │ │ - // and end of a single ring drawing - very uncommon - it will be │ │ │ │ - // called twice). │ │ │ │ - // TODO: In 3.0, collapse sketch handlers into geometry specific │ │ │ │ - // drawing controls. │ │ │ │ - this.control.layer.events.triggerEvent( │ │ │ │ - "sketchcomplete", { │ │ │ │ - feature: this.polygon │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroyFeature │ │ │ │ - * Destroy temporary geometries │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * force - {Boolean} Destroy even if persist is true. │ │ │ │ - */ │ │ │ │ - destroyFeature: function(force) { │ │ │ │ - OpenLayers.Handler.Path.prototype.destroyFeature.call( │ │ │ │ - this, force); │ │ │ │ - this.polygon = null; │ │ │ │ - }, │ │ │ │ + return params; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: drawFeature │ │ │ │ - * Render geometries on the temporary layer. │ │ │ │ - */ │ │ │ │ - drawFeature: function() { │ │ │ │ - this.layer.drawFeature(this.polygon, this.style); │ │ │ │ - this.layer.drawFeature(this.point, this.style); │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.QueryStringFilter" │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getSketch │ │ │ │ - * Return the sketch feature. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - getSketch: function() { │ │ │ │ - return this.polygon; │ │ │ │ - }, │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getGeometry │ │ │ │ - * Return the sketch geometry. If <multi> is true, this will return │ │ │ │ - * a multi-part geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Polygon>} │ │ │ │ - */ │ │ │ │ - getGeometry: function() { │ │ │ │ - var geometry = this.polygon && this.polygon.geometry; │ │ │ │ - if (geometry && this.multi) { │ │ │ │ - geometry = new OpenLayers.Geometry.MultiPolygon([geometry]); │ │ │ │ - } │ │ │ │ - return geometry; │ │ │ │ - }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Polygon" │ │ │ │ -}); │ │ │ │ +})(); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Click.js │ │ │ │ + OpenLayers/Format/EncodedPolyline.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Format.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Click │ │ │ │ - * A handler for mouse clicks. The intention of this handler is to give │ │ │ │ - * controls more flexibility with handling clicks. Browsers trigger │ │ │ │ - * click events twice for a double-click. In addition, the mousedown, │ │ │ │ - * mousemove, mouseup sequence fires a click event. With this handler, │ │ │ │ - * controls can decide whether to ignore clicks associated with a double │ │ │ │ - * click. By setting a <pixelTolerance>, controls can also ignore clicks │ │ │ │ - * that include a drag. Create a new instance with the │ │ │ │ - * <OpenLayers.Handler.Click> constructor. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Format.EncodedPolyline │ │ │ │ + * Class for reading and writing encoded polylines. Create a new instance │ │ │ │ + * with the <OpenLayers.Format.EncodedPolyline> constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Format> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - /** │ │ │ │ - * APIProperty: delay │ │ │ │ - * {Number} Number of milliseconds between clicks before the event is │ │ │ │ - * considered a double-click. │ │ │ │ - */ │ │ │ │ - delay: 300, │ │ │ │ +OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: single │ │ │ │ - * {Boolean} Handle single clicks. Default is true. If false, clicks │ │ │ │ - * will not be reported. If true, single-clicks will be reported. │ │ │ │ + * APIProperty: geometryType │ │ │ │ + * {String} Geometry type to output. One of: linestring (default), │ │ │ │ + * linearring, point, multipoint or polygon. If the geometryType is │ │ │ │ + * point, only the first point of the string is returned. │ │ │ │ */ │ │ │ │ - single: true, │ │ │ │ + geometryType: "linestring", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: double │ │ │ │ - * {Boolean} Handle double-clicks. Default is false. │ │ │ │ + * Constructor: OpenLayers.Format.EncodedPolyline │ │ │ │ + * Create a new parser for encoded polylines │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Format.EncodedPolyline>} A new encoded polylines parser. │ │ │ │ */ │ │ │ │ - 'double': false, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.prototype.initialize.apply(this, [options]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: pixelTolerance │ │ │ │ - * {Number} Maximum number of pixels between mouseup and mousedown for an │ │ │ │ - * event to be considered a click. Default is 0. If set to an │ │ │ │ - * integer value, clicks with a drag greater than the value will be │ │ │ │ - * ignored. This property can only be set when the handler is │ │ │ │ - * constructed. │ │ │ │ + * APIMethod: read │ │ │ │ + * Deserialize an encoded polyline string and return a vector feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {String} An encoded polyline string │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} A vector feature with a linestring. │ │ │ │ */ │ │ │ │ - pixelTolerance: 0, │ │ │ │ + read: function(encoded) { │ │ │ │ + var geomType; │ │ │ │ + if (this.geometryType == "linestring") │ │ │ │ + geomType = OpenLayers.Geometry.LineString; │ │ │ │ + else if (this.geometryType == "linearring") │ │ │ │ + geomType = OpenLayers.Geometry.LinearRing; │ │ │ │ + else if (this.geometryType == "multipoint") │ │ │ │ + geomType = OpenLayers.Geometry.MultiPoint; │ │ │ │ + else if (this.geometryType != "point" && this.geometryType != "polygon") │ │ │ │ + return null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: dblclickTolerance │ │ │ │ - * {Number} Maximum distance in pixels between clicks for a sequence of │ │ │ │ - * events to be considered a double click. Default is 13. If the │ │ │ │ - * distance between two clicks is greater than this value, a double- │ │ │ │ - * click will not be fired. │ │ │ │ - */ │ │ │ │ - dblclickTolerance: 13, │ │ │ │ + var flatPoints = this.decodeDeltas(encoded, 2); │ │ │ │ + var flatPointsLength = flatPoints.length; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: stopSingle │ │ │ │ - * {Boolean} Stop other listeners from being notified of clicks. Default │ │ │ │ - * is false. If true, any listeners registered before this one for │ │ │ │ - * click or rightclick events will not be notified. │ │ │ │ - */ │ │ │ │ - stopSingle: false, │ │ │ │ + var pointGeometries = []; │ │ │ │ + for (var i = 0; i + 1 < flatPointsLength;) { │ │ │ │ + var y = flatPoints[i++], │ │ │ │ + x = flatPoints[i++]; │ │ │ │ + pointGeometries.push(new OpenLayers.Geometry.Point(x, y)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: stopDouble │ │ │ │ - * {Boolean} Stop other listeners from being notified of double-clicks. │ │ │ │ - * Default is false. If true, any click listeners registered before │ │ │ │ - * this one will not be notified of *any* double-click events. │ │ │ │ - * │ │ │ │ - * The one caveat with stopDouble is that given a map with two click │ │ │ │ - * handlers, one with stopDouble true and the other with stopSingle │ │ │ │ - * true, the stopSingle handler should be activated last to get │ │ │ │ - * uniform cross-browser performance. Since IE triggers one click │ │ │ │ - * with a dblclick and FF triggers two, if a stopSingle handler is │ │ │ │ - * activated first, all it gets in IE is a single click when the │ │ │ │ - * second handler stops propagation on the dblclick. │ │ │ │ - */ │ │ │ │ - stopDouble: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: timerId │ │ │ │ - * {Number} The id of the timeout waiting to clear the <delayedCall>. │ │ │ │ - */ │ │ │ │ - timerId: null, │ │ │ │ + if (this.geometryType == "point") │ │ │ │ + return new OpenLayers.Feature.Vector( │ │ │ │ + pointGeometries[0] │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: down │ │ │ │ - * {Object} Object that store relevant information about the last │ │ │ │ - * mousedown or touchstart. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ - * the average location of the mouse/touch event. Its 'touches' │ │ │ │ - * property records clientX/clientY of each touches. │ │ │ │ - */ │ │ │ │ - down: null, │ │ │ │ + if (this.geometryType == "polygon") │ │ │ │ + return new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.Polygon([ │ │ │ │ + new OpenLayers.Geometry.LinearRing(pointGeometries) │ │ │ │ + ]) │ │ │ │ + ); │ │ │ │ + │ │ │ │ + return new OpenLayers.Feature.Vector( │ │ │ │ + new geomType(pointGeometries) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: last │ │ │ │ - * {Object} Object that store relevant information about the last │ │ │ │ - * mousemove or touchmove. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ - * the average location of the mouse/touch event. Its 'touches' │ │ │ │ - * property records clientX/clientY of each touches. │ │ │ │ + * APIMethod: decode │ │ │ │ + * Deserialize an encoded string and return an array of n-dimensional │ │ │ │ + * points. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {String} An encoded string │ │ │ │ + * dims - {int} The dimension of the points that are returned │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(Array(int))} An array containing n-dimensional arrays of │ │ │ │ + * coordinates. │ │ │ │ */ │ │ │ │ - last: null, │ │ │ │ + decode: function(encoded, dims, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var flatPoints = this.decodeDeltas(encoded, dims, factor); │ │ │ │ + var flatPointsLength = flatPoints.length; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: first │ │ │ │ - * {Object} When waiting for double clicks, this object will store │ │ │ │ - * information about the first click in a two click sequence. │ │ │ │ - */ │ │ │ │ - first: null, │ │ │ │ + var points = []; │ │ │ │ + for (var i = 0; i + (dims - 1) < flatPointsLength;) { │ │ │ │ + var point = []; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: rightclickTimerId │ │ │ │ - * {Number} The id of the right mouse timeout waiting to clear the │ │ │ │ - * <delayedEvent>. │ │ │ │ - */ │ │ │ │ - rightclickTimerId: null, │ │ │ │ + for (var dim = 0; dim < dims; ++dim) { │ │ │ │ + point.push(flatPoints[i++]) │ │ │ │ + } │ │ │ │ + │ │ │ │ + points.push(point); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return points; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Click │ │ │ │ - * Create a new click handler. │ │ │ │ - * │ │ │ │ + * APIMethod: write │ │ │ │ + * Serialize a feature or array of features into a WKT string. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ - * this handler. If a handler is being used without a control, the │ │ │ │ - * handler's setMap method must be overridden to deal properly with │ │ │ │ - * the map. │ │ │ │ - * callbacks - {Object} An object with keys corresponding to callbacks │ │ │ │ - * that will be called by the handler. The callbacks should │ │ │ │ - * expect to recieve a single argument, the click event. │ │ │ │ - * Callbacks for 'click' and 'dblclick' are supported. │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * handler. │ │ │ │ + * features - {<OpenLayers.Feature.Vector>|Array} A feature or array of │ │ │ │ + * features │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The WKT string representation of the input geometries │ │ │ │ */ │ │ │ │ + write: function(features) { │ │ │ │ + var feature; │ │ │ │ + if (features.constructor == Array) │ │ │ │ + feature = features[0]; │ │ │ │ + else │ │ │ │ + feature = features; │ │ │ │ + │ │ │ │ + var geometry = feature.geometry; │ │ │ │ + var type = geometry.CLASS_NAME.split('.')[2].toLowerCase(); │ │ │ │ + │ │ │ │ + var pointGeometries; │ │ │ │ + if (type == "point") │ │ │ │ + pointGeometries = new Array(geometry); │ │ │ │ + else if (type == "linestring" || │ │ │ │ + type == "linearring" || │ │ │ │ + type == "multipoint") │ │ │ │ + pointGeometries = geometry.components; │ │ │ │ + else if (type == "polygon") │ │ │ │ + pointGeometries = geometry.components[0].components; │ │ │ │ + else │ │ │ │ + return null; │ │ │ │ + │ │ │ │ + var flatPoints = []; │ │ │ │ + │ │ │ │ + var pointGeometriesLength = pointGeometries.length; │ │ │ │ + for (var i = 0; i < pointGeometriesLength; ++i) { │ │ │ │ + var pointGeometry = pointGeometries[i]; │ │ │ │ + flatPoints.push(pointGeometry.y); │ │ │ │ + flatPoints.push(pointGeometry.x); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.encodeDeltas(flatPoints, 2); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart. │ │ │ │ + * APIMethod: encode │ │ │ │ + * Serialize an array of n-dimensional points and return an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * points - {Array(Array(int))} An array containing n-dimensional │ │ │ │ + * arrays of coordinates │ │ │ │ + * dims - {int} The dimension of the points that should be read │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {String} An encoded string │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true; │ │ │ │ + encode: function(points, dims, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var flatPoints = []; │ │ │ │ + │ │ │ │ + var pointsLength = points.length; │ │ │ │ + for (var i = 0; i < pointsLength; ++i) { │ │ │ │ + var point = points[i]; │ │ │ │ + │ │ │ │ + for (var dim = 0; dim < dims; ++dim) { │ │ │ │ + flatPoints.push(point[dim]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.encodeDeltas(flatPoints, dims, factor); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Store position of last move, because touchend event can have │ │ │ │ - * an empty "touches" property. │ │ │ │ + * APIMethod: encodeDeltas │ │ │ │ + * Encode a list of n-dimensional points and return an encoded string │ │ │ │ + * │ │ │ │ + * Attention: This function will modify the passed array! │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * numbers - {Array.<number>} A list of n-dimensional points. │ │ │ │ + * dimension - {number} The dimension of the points in the list. │ │ │ │ + * opt_factor - {number=} The factor by which the numbers will be │ │ │ │ + * multiplied. The remaining decimal places will get rounded away. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true; │ │ │ │ + encodeDeltas: function(numbers, dimension, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var d; │ │ │ │ + │ │ │ │ + var lastNumbers = new Array(dimension); │ │ │ │ + for (d = 0; d < dimension; ++d) { │ │ │ │ + lastNumbers[d] = 0; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength;) { │ │ │ │ + for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ + var num = numbers[i]; │ │ │ │ + var delta = num - lastNumbers[d]; │ │ │ │ + lastNumbers[d] = num; │ │ │ │ + │ │ │ │ + numbers[i] = delta; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.encodeFloats(numbers, factor); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: touchend │ │ │ │ - * Correctly set event xy property, and add lastTouches to have │ │ │ │ - * touches property from last touchstart or touchmove │ │ │ │ + * APIMethod: decodeDeltas │ │ │ │ + * Decode a list of n-dimensional points from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ + * dimension - {number} The dimension of the points in the encoded string. │ │ │ │ + * opt_factor - {number=} The factor by which the resulting numbers will │ │ │ │ + * be divided. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Array.<number>} A list of n-dimensional points. │ │ │ │ */ │ │ │ │ - touchend: function(evt) { │ │ │ │ - // touchstart may not have been allowed to propagate │ │ │ │ - if (this.down) { │ │ │ │ - evt.xy = this.last.xy; │ │ │ │ - evt.lastTouches = this.last.touches; │ │ │ │ - this.handleSingle(evt); │ │ │ │ - this.down = null; │ │ │ │ + decodeDeltas: function(encoded, dimension, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var d; │ │ │ │ + │ │ │ │ + var lastNumbers = new Array(dimension); │ │ │ │ + for (d = 0; d < dimension; ++d) { │ │ │ │ + lastNumbers[d] = 0; │ │ │ │ } │ │ │ │ - return true; │ │ │ │ + │ │ │ │ + var numbers = this.decodeFloats(encoded, factor); │ │ │ │ + │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength;) { │ │ │ │ + for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ + lastNumbers[d] += numbers[i]; │ │ │ │ + │ │ │ │ + numbers[i] = lastNumbers[d]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return numbers; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mousedown. │ │ │ │ + * APIMethod: encodeFloats │ │ │ │ + * Encode a list of floating point numbers and return an encoded string │ │ │ │ + * │ │ │ │ + * Attention: This function will modify the passed array! │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * numbers - {Array.<number>} A list of floating point numbers. │ │ │ │ + * opt_factor - {number=} The factor by which the numbers will be │ │ │ │ + * multiplied. The remaining decimal places will get rounded away. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true; │ │ │ │ + encodeFloats: function(numbers, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + numbers[i] = Math.round(numbers[i] * factor); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.encodeSignedIntegers(numbers); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouseup. Installed to support collection of right mouse events. │ │ │ │ - * │ │ │ │ + * APIMethod: decodeFloats │ │ │ │ + * Decode a list of floating point numbers from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ + * opt_factor - {number=} The factor by which the result will be divided. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Array.<number>} A list of floating point numbers. │ │ │ │ */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ + decodeFloats: function(encoded, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ │ │ │ │ - // Collect right mouse clicks from the mouseup │ │ │ │ - // IE - ignores the second right click in mousedown so using │ │ │ │ - // mouseup instead │ │ │ │ - if (this.checkModifiers(evt) && this.control.handleRightClicks && │ │ │ │ - OpenLayers.Event.isRightClick(evt)) { │ │ │ │ - propagate = this.rightclick(evt); │ │ │ │ + var numbers = this.decodeSignedIntegers(encoded); │ │ │ │ + │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + numbers[i] /= factor; │ │ │ │ } │ │ │ │ │ │ │ │ - return propagate; │ │ │ │ + return numbers; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: rightclick │ │ │ │ - * Handle rightclick. For a dblrightclick, we get two clicks so we need │ │ │ │ - * to always register for dblrightclick to properly handle single │ │ │ │ - * clicks. │ │ │ │ - * │ │ │ │ + * APIMethod: encodeSignedIntegers │ │ │ │ + * Encode a list of signed integers and return an encoded string │ │ │ │ + * │ │ │ │ + * Attention: This function will modify the passed array! │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * numbers - {Array.<number>} A list of signed integers. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - rightclick: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - //Second click received before timeout this must be │ │ │ │ - // a double click │ │ │ │ - this.clearTimer(); │ │ │ │ - this.callback('dblrightclick', [evt]); │ │ │ │ - return !this.stopDouble; │ │ │ │ - } else { │ │ │ │ - //Set the rightclickTimerId, send evt only if double is │ │ │ │ - // true else trigger single │ │ │ │ - var clickEvent = this['double'] ? │ │ │ │ - OpenLayers.Util.extend({}, evt) : │ │ │ │ - this.callback('rightclick', [evt]); │ │ │ │ + encodeSignedIntegers: function(numbers) { │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + var num = numbers[i]; │ │ │ │ │ │ │ │ - var delayedRightCall = OpenLayers.Function.bind( │ │ │ │ - this.delayedRightCall, │ │ │ │ - this, │ │ │ │ - clickEvent │ │ │ │ - ); │ │ │ │ - this.rightclickTimerId = window.setTimeout( │ │ │ │ - delayedRightCall, this.delay │ │ │ │ - ); │ │ │ │ + var signedNum = num << 1; │ │ │ │ + if (num < 0) { │ │ │ │ + signedNum = ~(signedNum); │ │ │ │ } │ │ │ │ + │ │ │ │ + numbers[i] = signedNum; │ │ │ │ } │ │ │ │ - return !this.stopSingle; │ │ │ │ + │ │ │ │ + return this.encodeUnsignedIntegers(numbers); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: delayedRightCall │ │ │ │ - * Sets <rightclickTimerId> to null. And optionally triggers the │ │ │ │ - * rightclick callback if evt is set. │ │ │ │ + * APIMethod: decodeSignedIntegers │ │ │ │ + * Decode a list of signed integers from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array.<number>} A list of signed integers. │ │ │ │ */ │ │ │ │ - delayedRightCall: function(evt) { │ │ │ │ - this.rightclickTimerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback('rightclick', [evt]); │ │ │ │ + decodeSignedIntegers: function(encoded) { │ │ │ │ + var numbers = this.decodeUnsignedIntegers(encoded); │ │ │ │ + │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + var num = numbers[i]; │ │ │ │ + numbers[i] = (num & 1) ? ~(num >> 1) : (num >> 1); │ │ │ │ } │ │ │ │ + │ │ │ │ + return numbers; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: click │ │ │ │ - * Handle click events from the browser. This is registered as a listener │ │ │ │ - * for click events and should not be called from other events in this │ │ │ │ - * handler. │ │ │ │ + * APIMethod: encodeUnsignedIntegers │ │ │ │ + * Encode a list of unsigned integers and return an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * numbers - {Array.<number>} A list of unsigned integers. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - click: function(evt) { │ │ │ │ - if (!this.last) { │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ + encodeUnsignedIntegers: function(numbers) { │ │ │ │ + var encoded = ''; │ │ │ │ + │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + encoded += this.encodeUnsignedInteger(numbers[i]); │ │ │ │ } │ │ │ │ - this.handleSingle(evt); │ │ │ │ - return !this.stopSingle; │ │ │ │ + │ │ │ │ + return encoded; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: dblclick │ │ │ │ - * Handle dblclick. For a dblclick, we get two clicks in some browsers │ │ │ │ - * (FF) and one in others (IE). So we need to always register for │ │ │ │ - * dblclick to properly handle single clicks. This method is registered │ │ │ │ - * as a listener for the dblclick browser event. It should *not* be │ │ │ │ - * called by other methods in this handler. │ │ │ │ - * │ │ │ │ + * APIMethod: decodeUnsignedIntegers │ │ │ │ + * Decode a list of unsigned integers from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Array.<number>} A list of unsigned integers. │ │ │ │ */ │ │ │ │ - dblclick: function(evt) { │ │ │ │ - this.handleDouble(evt); │ │ │ │ - return !this.stopDouble; │ │ │ │ - }, │ │ │ │ + decodeUnsignedIntegers: function(encoded) { │ │ │ │ + var numbers = []; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleDouble │ │ │ │ - * Handle double-click sequence. │ │ │ │ - */ │ │ │ │ - handleDouble: function(evt) { │ │ │ │ - if (this.passesDblclickTolerance(evt)) { │ │ │ │ - if (this["double"]) { │ │ │ │ - this.callback("dblclick", [evt]); │ │ │ │ - } │ │ │ │ - // to prevent a dblclick from firing the click callback in IE │ │ │ │ - this.clearTimer(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + var current = 0; │ │ │ │ + var shift = 0; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleSingle │ │ │ │ - * Handle single click sequence. │ │ │ │ - */ │ │ │ │ - handleSingle: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - // already received a click │ │ │ │ - if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ - // touch device, no dblclick event - this may be a double │ │ │ │ - if (this["double"]) { │ │ │ │ - // on Android don't let the browser zoom on the page │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - } │ │ │ │ - this.handleDouble(evt); │ │ │ │ - } │ │ │ │ - // if we're not in a touch environment we clear the click timer │ │ │ │ - // if we've got a second touch, we'll get two touchend events │ │ │ │ - if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ - this.clearTimer(); │ │ │ │ - } │ │ │ │ + var encodedLength = encoded.length; │ │ │ │ + for (var i = 0; i < encodedLength; ++i) { │ │ │ │ + var b = encoded.charCodeAt(i) - 63; │ │ │ │ + │ │ │ │ + current |= (b & 0x1f) << shift; │ │ │ │ + │ │ │ │ + if (b < 0x20) { │ │ │ │ + numbers.push(current); │ │ │ │ + current = 0; │ │ │ │ + shift = 0; │ │ │ │ } else { │ │ │ │ - // remember the first click info so we can compare to the second │ │ │ │ - this.first = this.getEventInfo(evt); │ │ │ │ - // set the timer, send evt only if single is true │ │ │ │ - //use a clone of the event object because it will no longer │ │ │ │ - //be a valid event object in IE in the timer callback │ │ │ │ - var clickEvent = this.single ? │ │ │ │ - OpenLayers.Util.extend({}, evt) : null; │ │ │ │ - this.queuePotentialClick(clickEvent); │ │ │ │ + shift += 5; │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: queuePotentialClick │ │ │ │ - * This method is separated out largely to make testing easier (so we │ │ │ │ - * don't have to override window.setTimeout) │ │ │ │ - */ │ │ │ │ - queuePotentialClick: function(evt) { │ │ │ │ - this.timerId = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(this.delayedCall, this, evt), │ │ │ │ - this.delay │ │ │ │ - ); │ │ │ │ + return numbers; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: passesTolerance │ │ │ │ - * Determine whether the event is within the optional pixel tolerance. Note │ │ │ │ - * that the pixel tolerance check only works if mousedown events get to │ │ │ │ - * the listeners registered here. If they are stopped by other elements, │ │ │ │ - * the <pixelTolerance> will have no effect here (this method will always │ │ │ │ - * return true). │ │ │ │ + * Method: encodeFloat │ │ │ │ + * Encode one single floating point number and return an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * num - {number} Floating point number that should be encoded. │ │ │ │ + * opt_factor - {number=} The factor by which num will be multiplied. │ │ │ │ + * The remaining decimal places will get rounded away. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The click is within the pixel tolerance (if specified). │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - passesTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ - passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ - // for touch environments, we also enforce that all touches │ │ │ │ - // start and end within the given tolerance to be considered a click │ │ │ │ - if (passes && this.touch && │ │ │ │ - this.down.touches.length === this.last.touches.length) { │ │ │ │ - // the touchend event doesn't come with touches, so we check │ │ │ │ - // down and last │ │ │ │ - for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ - if (this.getTouchDistance( │ │ │ │ - this.down.touches[i], │ │ │ │ - this.last.touches[i] │ │ │ │ - ) > this.pixelTolerance) { │ │ │ │ - passes = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return passes; │ │ │ │ + encodeFloat: function(num, opt_factor) { │ │ │ │ + num = Math.round(num * (opt_factor || 1e5)); │ │ │ │ + return this.encodeSignedInteger(num); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getTouchDistance │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: decodeFloat │ │ │ │ + * Decode one single floating point number from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ + * opt_factor - {number=} The factor by which the result will be divided. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The pixel displacement between two touches. │ │ │ │ + * {number} The decoded floating point number. │ │ │ │ */ │ │ │ │ - getTouchDistance: function(from, to) { │ │ │ │ - return Math.sqrt( │ │ │ │ - Math.pow(from.clientX - to.clientX, 2) + │ │ │ │ - Math.pow(from.clientY - to.clientY, 2) │ │ │ │ - ); │ │ │ │ + decodeFloat: function(encoded, opt_factor) { │ │ │ │ + var result = this.decodeSignedInteger(encoded); │ │ │ │ + return result / (opt_factor || 1e5); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: passesDblclickTolerance │ │ │ │ - * Determine whether the event is within the optional double-cick pixel │ │ │ │ - * tolerance. │ │ │ │ + * Method: encodeSignedInteger │ │ │ │ + * Encode one single signed integer and return an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * num - {number} Signed integer that should be encoded. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The click is within the double-click pixel tolerance. │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - passesDblclickTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.down && this.first) { │ │ │ │ - passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance; │ │ │ │ + encodeSignedInteger: function(num) { │ │ │ │ + var signedNum = num << 1; │ │ │ │ + if (num < 0) { │ │ │ │ + signedNum = ~(signedNum); │ │ │ │ } │ │ │ │ - return passes; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clearTimer │ │ │ │ - * Clear the timer and set <timerId> to null. │ │ │ │ - */ │ │ │ │ - clearTimer: function() { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - } │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - window.clearTimeout(this.rightclickTimerId); │ │ │ │ - this.rightclickTimerId = null; │ │ │ │ - } │ │ │ │ + return this.encodeUnsignedInteger(signedNum); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: delayedCall │ │ │ │ - * Sets <timerId> to null. And optionally triggers the click callback if │ │ │ │ - * evt is set. │ │ │ │ + * Method: decodeSignedInteger │ │ │ │ + * Decode one single signed integer from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {number} The decoded signed integer. │ │ │ │ */ │ │ │ │ - delayedCall: function(evt) { │ │ │ │ - this.timerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback("click", [evt]); │ │ │ │ - } │ │ │ │ + decodeSignedInteger: function(encoded) { │ │ │ │ + var result = this.decodeUnsignedInteger(encoded); │ │ │ │ + return ((result & 1) ? ~(result >> 1) : (result >> 1)); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: getEventInfo │ │ │ │ - * This method allows us to store event information without storing the │ │ │ │ - * actual event. In touch devices (at least), the same event is │ │ │ │ - * modified between touchstart, touchmove, and touchend. │ │ │ │ + * Method: encodeUnsignedInteger │ │ │ │ + * Encode one single unsigned integer and return an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * num - {number} Unsigned integer that should be encoded. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object with event related info. │ │ │ │ + * {string} The encoded string. │ │ │ │ */ │ │ │ │ - getEventInfo: function(evt) { │ │ │ │ - var touches; │ │ │ │ - if (evt.touches) { │ │ │ │ - var len = evt.touches.length; │ │ │ │ - touches = new Array(len); │ │ │ │ - var touch; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - touch = evt.touches[i]; │ │ │ │ - touches[i] = { │ │ │ │ - clientX: touch.olClientX, │ │ │ │ - clientY: touch.olClientY │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + encodeUnsignedInteger: function(num) { │ │ │ │ + var value, encoded = ''; │ │ │ │ + while (num >= 0x20) { │ │ │ │ + value = (0x20 | (num & 0x1f)) + 63; │ │ │ │ + encoded += (String.fromCharCode(value)); │ │ │ │ + num >>= 5; │ │ │ │ } │ │ │ │ - return { │ │ │ │ - xy: evt.xy, │ │ │ │ - touches: touches │ │ │ │ - }; │ │ │ │ + value = num + 63; │ │ │ │ + encoded += (String.fromCharCode(value)); │ │ │ │ + return encoded; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the handler. │ │ │ │ + * Method: decodeUnsignedInteger │ │ │ │ + * Decode one single unsigned integer from an encoded string │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * encoded - {string} An encoded string. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated. │ │ │ │ + * {number} The decoded unsigned integer. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.down = null; │ │ │ │ - this.first = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ + decodeUnsignedInteger: function(encoded) { │ │ │ │ + var result = 0; │ │ │ │ + var shift = 0; │ │ │ │ + │ │ │ │ + var encodedLength = encoded.length; │ │ │ │ + for (var i = 0; i < encodedLength; ++i) { │ │ │ │ + var b = encoded.charCodeAt(i) - 63; │ │ │ │ + │ │ │ │ + result |= (b & 0x1f) << shift; │ │ │ │ + │ │ │ │ + if (b < 0x20) │ │ │ │ + break; │ │ │ │ + │ │ │ │ + shift += 5; │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.EncodedPolyline" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/SLD.js │ │ │ │ + OpenLayers/Format/SOSCapabilities.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ - * @requires OpenLayers/Style.js │ │ │ │ - * @requires OpenLayers/Rule.js │ │ │ │ - * @requires OpenLayers/Filter/FeatureId.js │ │ │ │ - * @requires OpenLayers/Filter/Logical.js │ │ │ │ - * @requires OpenLayers/Filter/Comparison.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.SLD │ │ │ │ - * Read/Write SLD. Create a new instance with the <OpenLayers.Format.SLD> │ │ │ │ - * constructor. │ │ │ │ + * Class: OpenLayers.Format.SOSCapabilities │ │ │ │ + * Read SOS Capabilities. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.SLD = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: profile │ │ │ │ - * {String} If provided, use a custom profile. │ │ │ │ - * │ │ │ │ - * Currently supported profiles: │ │ │ │ - * - GeoServer - parses GeoServer vendor specific capabilities for SLD. │ │ │ │ - */ │ │ │ │ - profile: null, │ │ │ │ +OpenLayers.Format.SOSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ * APIProperty: defaultVersion │ │ │ │ * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ */ │ │ │ │ defaultVersion: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: stringifyOutput │ │ │ │ - * {Boolean} If true, write will return a string otherwise a DOMElement. │ │ │ │ - * Default is true. │ │ │ │ - */ │ │ │ │ - stringifyOutput: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: namedLayersAsArray │ │ │ │ - * {Boolean} Generate a namedLayers array. If false, the namedLayers │ │ │ │ - * property value will be an object keyed by layer name. Default is │ │ │ │ - * false. │ │ │ │ - */ │ │ │ │ - namedLayersAsArray: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Write a SLD document given a list of styles. │ │ │ │ + * Constructor: OpenLayers.Format.SOSCapabilities │ │ │ │ + * Create a new parser for SOS Capabilities. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * sld - {Object} An object representing the SLD. │ │ │ │ - * options - {Object} Optional configuration object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} An SLD document string. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: read │ │ │ │ - * Read and SLD doc and return an object representing the SLD. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String | DOMElement} Data to read. │ │ │ │ - * options - {Object} Options for the reader. │ │ │ │ + * Read capabilities data from a string, and return information about │ │ │ │ + * the service (offering and observedProperty mostly). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object representing the SLD. │ │ │ │ + * {Object} Info about the SOS │ │ │ │ */ │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SLD" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSCapabilities" │ │ │ │ + │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/GML/v2.js │ │ │ │ + OpenLayers/Format/CQL.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/GML/Base.js │ │ │ │ + * @requires OpenLayers/Format/WKT.js │ │ │ │ + * @requires OpenLayers/Filter/Comparison.js │ │ │ │ + * @requires OpenLayers/Filter/Logical.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.GML.v2 │ │ │ │ - * Parses GML version 2. │ │ │ │ + * Class: OpenLayers.Format.CQL │ │ │ │ + * Read CQL strings to get <OpenLayers.Filter> objects. Write │ │ │ │ + * <OpenLayers.Filter> objects to get CQL strings. Create a new parser with │ │ │ │ + * the <OpenLayers.Format.CQL> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.GML.Base> │ │ │ │ + * - <OpenLayers.Format> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.GML.v2 = OpenLayers.Class(OpenLayers.Format.GML.Base, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location for a particular minor version. │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/gml http://schemas.opengis.net/gml/2.1.2/feature.xsd", │ │ │ │ +OpenLayers.Format.CQL = (function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.GML.v2 │ │ │ │ - * Create a parser for GML v2. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - * │ │ │ │ - * Valid options properties: │ │ │ │ - * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ - * featureNS - {String} Feature namespace (required). │ │ │ │ - * geometryName - {String} Geometry element name. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.GML.Base.prototype.initialize.apply(this, [options]); │ │ │ │ - }, │ │ │ │ + var tokens = [ │ │ │ │ + "PROPERTY", "COMPARISON", "VALUE", "LOGICAL" │ │ │ │ + ], │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ - "outerBoundaryIs": function(node, container) { │ │ │ │ - var obj = {}; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - container.outer = obj.components[0]; │ │ │ │ - }, │ │ │ │ - "innerBoundaryIs": function(node, container) { │ │ │ │ - var obj = {}; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - container.inner.push(obj.components[0]); │ │ │ │ - }, │ │ │ │ - "Box": function(node, container) { │ │ │ │ - var obj = {}; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - if (!container.components) { │ │ │ │ - container.components = []; │ │ │ │ + patterns = { │ │ │ │ + PROPERTY: /^[_a-zA-Z]\w*/, │ │ │ │ + COMPARISON: /^(=|<>|<=|<|>=|>|LIKE)/i, │ │ │ │ + IS_NULL: /^IS NULL/i, │ │ │ │ + COMMA: /^,/, │ │ │ │ + LOGICAL: /^(AND|OR)/i, │ │ │ │ + VALUE: /^('([^']|'')*'|\d+(\.\d*)?|\.\d+)/, │ │ │ │ + LPAREN: /^\(/, │ │ │ │ + RPAREN: /^\)/, │ │ │ │ + SPATIAL: /^(BBOX|INTERSECTS|DWITHIN|WITHIN|CONTAINS)/i, │ │ │ │ + NOT: /^NOT/i, │ │ │ │ + BETWEEN: /^BETWEEN/i, │ │ │ │ + GEOMETRY: function(text) { │ │ │ │ + var type = /^(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)/.exec(text); │ │ │ │ + if (type) { │ │ │ │ + var len = text.length; │ │ │ │ + var idx = text.indexOf("(", type[0].length); │ │ │ │ + if (idx > -1) { │ │ │ │ + var depth = 1; │ │ │ │ + while (idx < len && depth > 0) { │ │ │ │ + idx++; │ │ │ │ + switch (text.charAt(idx)) { │ │ │ │ + case '(': │ │ │ │ + depth++; │ │ │ │ + break; │ │ │ │ + case ')': │ │ │ │ + depth--; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + // in default case, do nothing │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return [text.substr(0, idx + 1)]; │ │ │ │ } │ │ │ │ - var min = obj.points[0]; │ │ │ │ - var max = obj.points[1]; │ │ │ │ - container.components.push( │ │ │ │ - new OpenLayers.Bounds(min.x, min.y, max.x, max.y) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.Base.prototype.readers["gml"]), │ │ │ │ - "feature": OpenLayers.Format.GML.Base.prototype.readers["feature"], │ │ │ │ - "wfs": OpenLayers.Format.GML.Base.prototype.readers["wfs"] │ │ │ │ - }, │ │ │ │ + }, │ │ │ │ + END: /^$/ │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: write │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>) | OpenLayers.Feature.Vector} │ │ │ │ - * An array of features or a single feature. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} Given an array of features, a doc with a gml:featureMembers │ │ │ │ - * element will be returned. Given a single feature, a doc with a │ │ │ │ - * gml:featureMember element will be returned. │ │ │ │ - */ │ │ │ │ - write: function(features) { │ │ │ │ - var name; │ │ │ │ - if (OpenLayers.Util.isArray(features)) { │ │ │ │ - // GML2 only has abstract feature collections │ │ │ │ - // wfs provides a feature collection from a well-known schema │ │ │ │ - name = "wfs:FeatureCollection"; │ │ │ │ + follows = { │ │ │ │ + LPAREN: ['GEOMETRY', 'SPATIAL', 'PROPERTY', 'VALUE', 'LPAREN'], │ │ │ │ + RPAREN: ['NOT', 'LOGICAL', 'END', 'RPAREN'], │ │ │ │ + PROPERTY: ['COMPARISON', 'BETWEEN', 'COMMA', 'IS_NULL'], │ │ │ │ + BETWEEN: ['VALUE'], │ │ │ │ + IS_NULL: ['END'], │ │ │ │ + COMPARISON: ['VALUE'], │ │ │ │ + COMMA: ['GEOMETRY', 'VALUE', 'PROPERTY'], │ │ │ │ + VALUE: ['LOGICAL', 'COMMA', 'RPAREN', 'END'], │ │ │ │ + SPATIAL: ['LPAREN'], │ │ │ │ + LOGICAL: ['NOT', 'VALUE', 'SPATIAL', 'PROPERTY', 'LPAREN'], │ │ │ │ + NOT: ['PROPERTY', 'LPAREN'], │ │ │ │ + GEOMETRY: ['COMMA', 'RPAREN'] │ │ │ │ + }, │ │ │ │ + │ │ │ │ + operators = { │ │ │ │ + '=': OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ + '<>': OpenLayers.Filter.Comparison.NOT_EQUAL_TO, │ │ │ │ + '<': OpenLayers.Filter.Comparison.LESS_THAN, │ │ │ │ + '<=': OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO, │ │ │ │ + '>': OpenLayers.Filter.Comparison.GREATER_THAN, │ │ │ │ + '>=': OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO, │ │ │ │ + 'LIKE': OpenLayers.Filter.Comparison.LIKE, │ │ │ │ + 'BETWEEN': OpenLayers.Filter.Comparison.BETWEEN, │ │ │ │ + 'IS NULL': OpenLayers.Filter.Comparison.IS_NULL │ │ │ │ + }, │ │ │ │ + │ │ │ │ + operatorReverse = {}, │ │ │ │ + │ │ │ │ + logicals = { │ │ │ │ + 'AND': OpenLayers.Filter.Logical.AND, │ │ │ │ + 'OR': OpenLayers.Filter.Logical.OR │ │ │ │ + }, │ │ │ │ + │ │ │ │ + logicalReverse = {}, │ │ │ │ + │ │ │ │ + precedence = { │ │ │ │ + 'RPAREN': 3, │ │ │ │ + 'LOGICAL': 2, │ │ │ │ + 'COMPARISON': 1 │ │ │ │ + }; │ │ │ │ + │ │ │ │ + var i; │ │ │ │ + for (i in operators) { │ │ │ │ + if (operators.hasOwnProperty(i)) { │ │ │ │ + operatorReverse[operators[i]] = i; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + for (i in logicals) { │ │ │ │ + if (logicals.hasOwnProperty(i)) { │ │ │ │ + logicalReverse[logicals[i]] = i; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + function tryToken(text, pattern) { │ │ │ │ + if (pattern instanceof RegExp) { │ │ │ │ + return pattern.exec(text); │ │ │ │ } else { │ │ │ │ - name = "gml:featureMember"; │ │ │ │ + return pattern(text); │ │ │ │ } │ │ │ │ - var root = this.writeNode(name, features); │ │ │ │ - this.setAttributeNS( │ │ │ │ - root, this.namespaces["xsi"], │ │ │ │ - "xsi:schemaLocation", this.schemaLocation │ │ │ │ - ); │ │ │ │ + } │ │ │ │ │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [root]); │ │ │ │ - }, │ │ │ │ + function nextToken(text, tokens) { │ │ │ │ + var i, token, len = tokens.length; │ │ │ │ + for (i = 0; i < len; i++) { │ │ │ │ + token = tokens[i]; │ │ │ │ + var pat = patterns[token]; │ │ │ │ + var matches = tryToken(text, pat); │ │ │ │ + if (matches) { │ │ │ │ + var match = matches[0]; │ │ │ │ + var remainder = text.substr(match.length).replace(/^\s*/, ""); │ │ │ │ + return { │ │ │ │ + type: token, │ │ │ │ + text: match, │ │ │ │ + remainder: remainder │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ - */ │ │ │ │ - writers: { │ │ │ │ - "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ - "Point": function(geometry) { │ │ │ │ - var node = this.createElementNSPlus("gml:Point"); │ │ │ │ - this.writeNode("coordinates", [geometry], node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "coordinates": function(points) { │ │ │ │ - var numPoints = points.length; │ │ │ │ - var parts = new Array(numPoints); │ │ │ │ - var point; │ │ │ │ - for (var i = 0; i < numPoints; ++i) { │ │ │ │ - point = points[i]; │ │ │ │ - if (this.xy) { │ │ │ │ - parts[i] = point.x + "," + point.y; │ │ │ │ - } else { │ │ │ │ - parts[i] = point.y + "," + point.x; │ │ │ │ - } │ │ │ │ - if (point.z != undefined) { // allow null or undefined │ │ │ │ - parts[i] += "," + point.z; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return this.createElementNSPlus("gml:coordinates", { │ │ │ │ - attributes: { │ │ │ │ - decimal: ".", │ │ │ │ - cs: ",", │ │ │ │ - ts: " " │ │ │ │ - }, │ │ │ │ - value: (numPoints == 1) ? parts[0] : parts.join(" ") │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "LineString": function(geometry) { │ │ │ │ - var node = this.createElementNSPlus("gml:LineString"); │ │ │ │ - this.writeNode("coordinates", geometry.components, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Polygon": function(geometry) { │ │ │ │ - var node = this.createElementNSPlus("gml:Polygon"); │ │ │ │ - this.writeNode("outerBoundaryIs", geometry.components[0], node); │ │ │ │ - for (var i = 1; i < geometry.components.length; ++i) { │ │ │ │ - this.writeNode( │ │ │ │ - "innerBoundaryIs", geometry.components[i], node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "outerBoundaryIs": function(ring) { │ │ │ │ - var node = this.createElementNSPlus("gml:outerBoundaryIs"); │ │ │ │ - this.writeNode("LinearRing", ring, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "innerBoundaryIs": function(ring) { │ │ │ │ - var node = this.createElementNSPlus("gml:innerBoundaryIs"); │ │ │ │ - this.writeNode("LinearRing", ring, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "LinearRing": function(ring) { │ │ │ │ - var node = this.createElementNSPlus("gml:LinearRing"); │ │ │ │ - this.writeNode("coordinates", ring.components, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Box": function(bounds) { │ │ │ │ - var node = this.createElementNSPlus("gml:Box"); │ │ │ │ - this.writeNode("coordinates", [{ │ │ │ │ - x: bounds.left, │ │ │ │ - y: bounds.bottom │ │ │ │ - }, { │ │ │ │ - x: bounds.right, │ │ │ │ - y: bounds.top │ │ │ │ - }], node); │ │ │ │ - // srsName attribute is optional for gml:Box │ │ │ │ - if (this.srsName) { │ │ │ │ - node.setAttribute("srsName", this.srsName); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.Base.prototype.writers["gml"]), │ │ │ │ - "feature": OpenLayers.Format.GML.Base.prototype.writers["feature"], │ │ │ │ - "wfs": OpenLayers.Format.GML.Base.prototype.writers["wfs"] │ │ │ │ - }, │ │ │ │ + var msg = "ERROR: In parsing: [" + text + "], expected one of: "; │ │ │ │ + for (i = 0; i < len; i++) { │ │ │ │ + token = tokens[i]; │ │ │ │ + msg += "\n " + token + ": " + patterns[token]; │ │ │ │ + } │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.GML.v2" │ │ │ │ + throw new Error(msg); │ │ │ │ + } │ │ │ │ │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + function tokenize(text) { │ │ │ │ + var results = []; │ │ │ │ + var token, expect = ["NOT", "GEOMETRY", "SPATIAL", "PROPERTY", "LPAREN"]; │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + do { │ │ │ │ + token = nextToken(text, expect); │ │ │ │ + text = token.remainder; │ │ │ │ + expect = follows[token.type]; │ │ │ │ + if (token.type != "END" && !expect) { │ │ │ │ + throw new Error("No follows list for " + token.type); │ │ │ │ + } │ │ │ │ + results.push(token); │ │ │ │ + } while (token.type != "END"); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/GML/v2.js │ │ │ │ - * @requires OpenLayers/Format/Filter/v1.js │ │ │ │ - */ │ │ │ │ + return results; │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.Filter.v1_0_0 │ │ │ │ - * Write ogc:Filter version 1.0.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.GML.v2> │ │ │ │ - * - <OpenLayers.Format.Filter.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.Filter.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.GML.v2, OpenLayers.Format.Filter.v1, { │ │ │ │ + function buildAst(tokens) { │ │ │ │ + var operatorStack = [], │ │ │ │ + postfix = []; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.0.0 │ │ │ │ - */ │ │ │ │ - VERSION: "1.0.0", │ │ │ │ + while (tokens.length) { │ │ │ │ + var tok = tokens.shift(); │ │ │ │ + switch (tok.type) { │ │ │ │ + case "PROPERTY": │ │ │ │ + case "GEOMETRY": │ │ │ │ + case "VALUE": │ │ │ │ + postfix.push(tok); │ │ │ │ + break; │ │ │ │ + case "COMPARISON": │ │ │ │ + case "BETWEEN": │ │ │ │ + case "IS_NULL": │ │ │ │ + case "LOGICAL": │ │ │ │ + var p = precedence[tok.type]; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/ogc/filter/1.0.0/filter.xsd │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/ogc/filter/1.0.0/filter.xsd", │ │ │ │ + while (operatorStack.length > 0 && │ │ │ │ + (precedence[operatorStack[operatorStack.length - 1].type] <= p) │ │ │ │ + ) { │ │ │ │ + postfix.push(operatorStack.pop()); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.Filter.v1_0_0 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.Filter> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.GML.v2.prototype.initialize.apply( │ │ │ │ - this, [options] │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ + operatorStack.push(tok); │ │ │ │ + break; │ │ │ │ + case "SPATIAL": │ │ │ │ + case "NOT": │ │ │ │ + case "LPAREN": │ │ │ │ + operatorStack.push(tok); │ │ │ │ + break; │ │ │ │ + case "RPAREN": │ │ │ │ + while (operatorStack.length > 0 && │ │ │ │ + (operatorStack[operatorStack.length - 1].type != "LPAREN") │ │ │ │ + ) { │ │ │ │ + postfix.push(operatorStack.pop()); │ │ │ │ + } │ │ │ │ + operatorStack.pop(); // toss out the LPAREN │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "ogc": OpenLayers.Util.applyDefaults({ │ │ │ │ - "PropertyIsEqualTo": function(node, obj) { │ │ │ │ - var filter = new OpenLayers.Filter.Comparison({ │ │ │ │ - type: OpenLayers.Filter.Comparison.EQUAL_TO │ │ │ │ + if (operatorStack.length > 0 && │ │ │ │ + operatorStack[operatorStack.length - 1].type == "SPATIAL") { │ │ │ │ + postfix.push(operatorStack.pop()); │ │ │ │ + } │ │ │ │ + case "COMMA": │ │ │ │ + case "END": │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + throw new Error("Unknown token type " + tok.type); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + while (operatorStack.length > 0) { │ │ │ │ + postfix.push(operatorStack.pop()); │ │ │ │ + } │ │ │ │ + │ │ │ │ + function buildTree() { │ │ │ │ + var tok = postfix.pop(); │ │ │ │ + switch (tok.type) { │ │ │ │ + case "LOGICAL": │ │ │ │ + var rhs = buildTree(), │ │ │ │ + lhs = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Logical({ │ │ │ │ + filters: [lhs, rhs], │ │ │ │ + type: logicals[tok.text.toUpperCase()] │ │ │ │ }); │ │ │ │ - this.readChildNodes(node, filter); │ │ │ │ - obj.filters.push(filter); │ │ │ │ - }, │ │ │ │ - "PropertyIsNotEqualTo": function(node, obj) { │ │ │ │ - var filter = new OpenLayers.Filter.Comparison({ │ │ │ │ - type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO │ │ │ │ + case "NOT": │ │ │ │ + var operand = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Logical({ │ │ │ │ + filters: [operand], │ │ │ │ + type: OpenLayers.Filter.Logical.NOT │ │ │ │ }); │ │ │ │ - this.readChildNodes(node, filter); │ │ │ │ - obj.filters.push(filter); │ │ │ │ - }, │ │ │ │ - "PropertyIsLike": function(node, obj) { │ │ │ │ - var filter = new OpenLayers.Filter.Comparison({ │ │ │ │ - type: OpenLayers.Filter.Comparison.LIKE │ │ │ │ + case "BETWEEN": │ │ │ │ + var min, max, property; │ │ │ │ + postfix.pop(); // unneeded AND token here │ │ │ │ + max = buildTree(); │ │ │ │ + min = buildTree(); │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Comparison({ │ │ │ │ + property: property, │ │ │ │ + lowerBoundary: min, │ │ │ │ + upperBoundary: max, │ │ │ │ + type: OpenLayers.Filter.Comparison.BETWEEN │ │ │ │ }); │ │ │ │ - this.readChildNodes(node, filter); │ │ │ │ - var wildCard = node.getAttribute("wildCard"); │ │ │ │ - var singleChar = node.getAttribute("singleChar"); │ │ │ │ - var esc = node.getAttribute("escape"); │ │ │ │ - filter.value2regex(wildCard, singleChar, esc); │ │ │ │ - obj.filters.push(filter); │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.Filter.v1.prototype.readers["ogc"]), │ │ │ │ - "gml": OpenLayers.Format.GML.v2.prototype.readers["gml"], │ │ │ │ - "feature": OpenLayers.Format.GML.v2.prototype.readers["feature"] │ │ │ │ - }, │ │ │ │ + case "COMPARISON": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Comparison({ │ │ │ │ + property: property, │ │ │ │ + value: value, │ │ │ │ + type: operators[tok.text.toUpperCase()] │ │ │ │ + }); │ │ │ │ + case "IS_NULL": │ │ │ │ + var property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Comparison({ │ │ │ │ + property: property, │ │ │ │ + type: operators[tok.text.toUpperCase()] │ │ │ │ + }); │ │ │ │ + case "VALUE": │ │ │ │ + var match = tok.text.match(/^'(.*)'$/); │ │ │ │ + if (match) { │ │ │ │ + return match[1].replace(/''/g, "'"); │ │ │ │ + } else { │ │ │ │ + return Number(tok.text); │ │ │ │ + } │ │ │ │ + case "SPATIAL": │ │ │ │ + switch (tok.text.toUpperCase()) { │ │ │ │ + case "BBOX": │ │ │ │ + var maxy = buildTree(), │ │ │ │ + maxx = buildTree(), │ │ │ │ + miny = buildTree(), │ │ │ │ + minx = buildTree(), │ │ │ │ + prop = buildTree(); │ │ │ │ + │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + property: prop, │ │ │ │ + value: OpenLayers.Bounds.fromArray( │ │ │ │ + [minx, miny, maxx, maxy] │ │ │ │ + ) │ │ │ │ + }); │ │ │ │ + case "INTERSECTS": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + case "WITHIN": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.WITHIN, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + case "CONTAINS": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.CONTAINS, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + case "DWITHIN": │ │ │ │ + var distance = buildTree(), │ │ │ │ + value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ + value: value, │ │ │ │ + property: property, │ │ │ │ + distance: Number(distance) │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + case "GEOMETRY": │ │ │ │ + return OpenLayers.Geometry.fromWKT(tok.text); │ │ │ │ + default: │ │ │ │ + return tok.text; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + var result = buildTree(); │ │ │ │ + if (postfix.length > 0) { │ │ │ │ + var msg = "Remaining tokens after building AST: \n"; │ │ │ │ + for (var i = postfix.length - 1; i >= 0; i--) { │ │ │ │ + msg += postfix[i].type + ": " + postfix[i].text + "\n"; │ │ │ │ + } │ │ │ │ + throw new Error(msg); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return result; │ │ │ │ + } │ │ │ │ │ │ │ │ + return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * APIMethod: read │ │ │ │ + * Generate a filter from a CQL string. │ │ │ │ + │ │ │ │ + * Parameters: │ │ │ │ + * text - {String} The CQL text. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter>} A filter based on the CQL text. │ │ │ │ */ │ │ │ │ - writers: { │ │ │ │ - "ogc": OpenLayers.Util.applyDefaults({ │ │ │ │ - "PropertyIsEqualTo": function(filter) { │ │ │ │ - var node = this.createElementNSPlus("ogc:PropertyIsEqualTo"); │ │ │ │ - // no ogc:expression handling for PropertyName for now │ │ │ │ - this.writeNode("PropertyName", filter, node); │ │ │ │ - // handle Literals or Functions for now │ │ │ │ - this.writeOgcExpression(filter.value, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PropertyIsNotEqualTo": function(filter) { │ │ │ │ - var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo"); │ │ │ │ - // no ogc:expression handling for PropertyName for now │ │ │ │ - this.writeNode("PropertyName", filter, node); │ │ │ │ - // handle Literals or Functions for now │ │ │ │ - this.writeOgcExpression(filter.value, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PropertyIsLike": function(filter) { │ │ │ │ - var node = this.createElementNSPlus("ogc:PropertyIsLike", { │ │ │ │ - attributes: { │ │ │ │ - wildCard: "*", │ │ │ │ - singleChar: ".", │ │ │ │ - escape: "!" │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - // no ogc:expression handling for now │ │ │ │ - this.writeNode("PropertyName", filter, node); │ │ │ │ - // convert regex string to ogc string │ │ │ │ - this.writeNode("Literal", filter.regex2value(), node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "BBOX": function(filter) { │ │ │ │ - var node = this.createElementNSPlus("ogc:BBOX"); │ │ │ │ - // PropertyName is mandatory in 1.0.0, but e.g. GeoServer also │ │ │ │ - // accepts filters without it. When this is used with │ │ │ │ - // OpenLayers.Protocol.WFS, OpenLayers.Format.WFST will set a │ │ │ │ - // missing filter.property to the geometryName that is │ │ │ │ - // configured with the protocol, which defaults to "the_geom". │ │ │ │ - // So the only way to omit this mandatory property is to not │ │ │ │ - // set the property on the filter and to set the geometryName │ │ │ │ - // on the WFS protocol to null. The latter also happens when │ │ │ │ - // the protocol is configured without a geometryName and a │ │ │ │ - // featureNS. │ │ │ │ - filter.property && this.writeNode("PropertyName", filter, node); │ │ │ │ - var box = this.writeNode("gml:Box", filter.value, node); │ │ │ │ - if (filter.projection) { │ │ │ │ - box.setAttribute("srsName", filter.projection); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.Filter.v1.prototype.writers["ogc"]), │ │ │ │ - "gml": OpenLayers.Format.GML.v2.prototype.writers["gml"], │ │ │ │ - "feature": OpenLayers.Format.GML.v2.prototype.writers["feature"] │ │ │ │ + read: function(text) { │ │ │ │ + var result = buildAst(tokenize(text)); │ │ │ │ + if (this.keepData) { │ │ │ │ + this.data = result; │ │ │ │ + } │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: writeSpatial │ │ │ │ - * │ │ │ │ - * Read a {<OpenLayers.Filter.Spatial>} filter and converts it into XML. │ │ │ │ - * │ │ │ │ + * APIMethod: write │ │ │ │ + * Convert a filter into a CQL string. │ │ │ │ + │ │ │ │ * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter.Spatial>} The filter. │ │ │ │ - * name - {String} Name of the generated XML element. │ │ │ │ + * filter - {<OpenLayers.Filter>} The filter. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} The created XML element. │ │ │ │ + * {String} A CQL string based on the filter. │ │ │ │ */ │ │ │ │ - writeSpatial: function(filter, name) { │ │ │ │ - var node = this.createElementNSPlus("ogc:" + name); │ │ │ │ - this.writeNode("PropertyName", filter, node); │ │ │ │ - if (filter.value instanceof OpenLayers.Filter.Function) { │ │ │ │ - this.writeNode("Function", filter.value, node); │ │ │ │ - } else { │ │ │ │ - var child; │ │ │ │ - if (filter.value instanceof OpenLayers.Geometry) { │ │ │ │ - child = this.writeNode("feature:_geometry", filter.value).firstChild; │ │ │ │ - } else { │ │ │ │ - child = this.writeNode("gml:Box", filter.value); │ │ │ │ - } │ │ │ │ - if (filter.projection) { │ │ │ │ - child.setAttribute("srsName", filter.projection); │ │ │ │ - } │ │ │ │ - node.appendChild(child); │ │ │ │ + write: function(filter) { │ │ │ │ + if (filter instanceof OpenLayers.Geometry) { │ │ │ │ + return filter.toString(); │ │ │ │ + } │ │ │ │ + switch (filter.CLASS_NAME) { │ │ │ │ + case "OpenLayers.Filter.Spatial": │ │ │ │ + switch (filter.type) { │ │ │ │ + case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ + return "BBOX(" + │ │ │ │ + filter.property + "," + │ │ │ │ + filter.value.toBBOX() + │ │ │ │ + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ + return "DWITHIN(" + │ │ │ │ + filter.property + ", " + │ │ │ │ + this.write(filter.value) + ", " + │ │ │ │ + filter.distance + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ + return "WITHIN(" + │ │ │ │ + filter.property + ", " + │ │ │ │ + this.write(filter.value) + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ + return "INTERSECTS(" + │ │ │ │ + filter.property + ", " + │ │ │ │ + this.write(filter.value) + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.CONTAINS: │ │ │ │ + return "CONTAINS(" + │ │ │ │ + filter.property + ", " + │ │ │ │ + this.write(filter.value) + ")"; │ │ │ │ + default: │ │ │ │ + throw new Error("Unknown spatial filter type: " + filter.type); │ │ │ │ + } │ │ │ │ + case "OpenLayers.Filter.Logical": │ │ │ │ + if (filter.type == OpenLayers.Filter.Logical.NOT) { │ │ │ │ + // TODO: deal with precedence of logical operators to │ │ │ │ + // avoid extra parentheses (not urgent) │ │ │ │ + return "NOT (" + this.write(filter.filters[0]) + ")"; │ │ │ │ + } else { │ │ │ │ + var res = "("; │ │ │ │ + var first = true; │ │ │ │ + for (var i = 0; i < filter.filters.length; i++) { │ │ │ │ + if (first) { │ │ │ │ + first = false; │ │ │ │ + } else { │ │ │ │ + res += ") " + logicalReverse[filter.type] + " ("; │ │ │ │ + } │ │ │ │ + res += this.write(filter.filters[i]); │ │ │ │ + } │ │ │ │ + return res + ")"; │ │ │ │ + } │ │ │ │ + case "OpenLayers.Filter.Comparison": │ │ │ │ + if (filter.type == OpenLayers.Filter.Comparison.BETWEEN) { │ │ │ │ + return filter.property + " BETWEEN " + │ │ │ │ + this.write(filter.lowerBoundary) + " AND " + │ │ │ │ + this.write(filter.upperBoundary); │ │ │ │ + } else { │ │ │ │ + return (filter.value !== null) ? filter.property + │ │ │ │ + " " + operatorReverse[filter.type] + " " + │ │ │ │ + this.write(filter.value) : filter.property + │ │ │ │ + " " + operatorReverse[filter.type]; │ │ │ │ + } │ │ │ │ + case undefined: │ │ │ │ + if (typeof filter === "string") { │ │ │ │ + return "'" + filter.replace(/'/g, "''") + "'"; │ │ │ │ + } else if (typeof filter === "number") { │ │ │ │ + return String(filter); │ │ │ │ + } │ │ │ │ + default: │ │ │ │ + throw new Error("Can't encode: " + filter.CLASS_NAME + " " + filter); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Filter.v1_0_0" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.CQL" │ │ │ │ │ │ │ │ }); │ │ │ │ +})(); │ │ │ │ + │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/SLD/v1.js │ │ │ │ + OpenLayers/Format/Atom.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Rule.js │ │ │ │ - * @requires OpenLayers/Format/SLD.js │ │ │ │ - * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Point.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Line.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Polygon.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Text.js │ │ │ │ - * @requires OpenLayers/Symbolizer/Raster.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/GML/v3.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.SLD.v1 │ │ │ │ - * Superclass for SLD version 1 parsers. │ │ │ │ + * Class: OpenLayers.Format.Atom │ │ │ │ + * Read/write Atom feeds. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.AtomFeed> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.Filter.v1_0_0> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, { │ │ │ │ +OpenLayers.Format.Atom = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. Properties │ │ │ │ + * of this object should not be set individually. Read-only. All │ │ │ │ + * XML subclasses should have their own namespaces object. Use │ │ │ │ + * <setNamespace> to add or set a namespace alias after construction. │ │ │ │ */ │ │ │ │ namespaces: { │ │ │ │ - sld: "http://www.opengis.net/sld", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + atom: "http://www.w3.org/2005/Atom", │ │ │ │ + georss: "http://www.georss.org/georss" │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ + * APIProperty: feedTitle │ │ │ │ + * {String} Atom feed elements require a title. Default is "untitled". │ │ │ │ */ │ │ │ │ - defaultPrefix: "sld", │ │ │ │ + feedTitle: "untitled", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location for a particular minor version. │ │ │ │ - */ │ │ │ │ - schemaLocation: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: multipleSymbolizers │ │ │ │ - * {Boolean} Support multiple symbolizers per rule. Default is false. if │ │ │ │ - * true, an OpenLayers.Style2 instance will be created to represent │ │ │ │ - * user styles instead of an OpenLayers.Style instace. The │ │ │ │ - * OpenLayers.Style2 class allows collections of rules with multiple │ │ │ │ - * symbolizers, but is not currently useful for client side rendering. │ │ │ │ - * If multiple symbolizers is true, multiple FeatureTypeStyle elements │ │ │ │ - * are preserved in reading/writing by setting symbolizer zIndex values. │ │ │ │ - * In addition, the <defaultSymbolizer> property is ignored if │ │ │ │ - * multiple symbolizers are supported (defaults should be applied │ │ │ │ - * when rendering). │ │ │ │ + * APIProperty: defaultEntryTitle │ │ │ │ + * {String} Atom entry elements require a title. In cases where one is │ │ │ │ + * not provided in the feature attributes, this will be used. Default │ │ │ │ + * is "untitled". │ │ │ │ */ │ │ │ │ - multipleSymbolizers: false, │ │ │ │ + defaultEntryTitle: "untitled", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: featureTypeCounter │ │ │ │ - * {Number} Private counter for multiple feature type styles. │ │ │ │ + * Property: gmlParse │ │ │ │ + * {Object} GML Format object for parsing features │ │ │ │ + * Non-API and only created if necessary │ │ │ │ */ │ │ │ │ - featureTypeCounter: null, │ │ │ │ + gmlParser: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultSymbolizer. │ │ │ │ - * {Object} A symbolizer with the SLD defaults. │ │ │ │ + * APIProperty: xy │ │ │ │ + * {Boolean} Order of the GML coordinate: true:(x,y) or false:(y,x) │ │ │ │ + * For GeoRSS the default is (y,x), therefore: false │ │ │ │ */ │ │ │ │ - defaultSymbolizer: { │ │ │ │ - fillColor: "#808080", │ │ │ │ - fillOpacity: 1, │ │ │ │ - strokeColor: "#000000", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - pointRadius: 3, │ │ │ │ - graphicName: "square" │ │ │ │ - }, │ │ │ │ + xy: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.SLD.v1 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.SLD> constructor instead. │ │ │ │ + * Constructor: OpenLayers.Format.AtomEntry │ │ │ │ + * Create a new parser for Atom. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} An optional object whose properties will be set on │ │ │ │ * this instance. │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read │ │ │ │ - * │ │ │ │ + * APIMethod: read │ │ │ │ + * Return a list of features from an Atom feed or entry document. │ │ │ │ + │ │ │ │ * Parameters: │ │ │ │ - * data - {DOMElement} An SLD document element. │ │ │ │ - * options - {Object} Options for the reader. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * namedLayersAsArray - {Boolean} Generate a namedLayers array. If false, │ │ │ │ - * the namedLayers property value will be an object keyed by layer name. │ │ │ │ - * Default is false. │ │ │ │ + * doc - {Element} or {String} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object representing the SLD. │ │ │ │ + * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ */ │ │ │ │ - read: function(data, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var sld = { │ │ │ │ - namedLayers: options.namedLayersAsArray === true ? [] : {} │ │ │ │ - }; │ │ │ │ - this.readChildNodes(data, sld); │ │ │ │ - return sld; │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ + } │ │ │ │ + return this.parseFeatures(doc); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ + * APIMethod: write │ │ │ │ + * Serialize or more feature nodes to Atom documents. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {<OpenLayers.Feature.Vector>} or Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} an Atom entry document if passed one feature node, or a feed │ │ │ │ + * document if passed an array of feature nodes. │ │ │ │ */ │ │ │ │ - readers: OpenLayers.Util.applyDefaults({ │ │ │ │ - "sld": { │ │ │ │ - "StyledLayerDescriptor": function(node, sld) { │ │ │ │ - sld.version = node.getAttribute("version"); │ │ │ │ - this.readChildNodes(node, sld); │ │ │ │ - }, │ │ │ │ - "Name": function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Title": function(node, obj) { │ │ │ │ - obj.title = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Abstract": function(node, obj) { │ │ │ │ - obj.description = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "NamedLayer": function(node, sld) { │ │ │ │ - var layer = { │ │ │ │ - userStyles: [], │ │ │ │ - namedStyles: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, layer); │ │ │ │ - // give each of the user styles this layer name │ │ │ │ - for (var i = 0, len = layer.userStyles.length; i < len; ++i) { │ │ │ │ - layer.userStyles[i].layerName = layer.name; │ │ │ │ - } │ │ │ │ - if (OpenLayers.Util.isArray(sld.namedLayers)) { │ │ │ │ - sld.namedLayers.push(layer); │ │ │ │ - } else { │ │ │ │ - sld.namedLayers[layer.name] = layer; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "NamedStyle": function(node, layer) { │ │ │ │ - layer.namedStyles.push( │ │ │ │ - this.getChildName(node.firstChild) │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "UserStyle": function(node, layer) { │ │ │ │ - var obj = { │ │ │ │ - defaultsPerSymbolizer: true, │ │ │ │ - rules: [] │ │ │ │ - }; │ │ │ │ - this.featureTypeCounter = -1; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - var style; │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - delete obj.defaultsPerSymbolizer; │ │ │ │ - style = new OpenLayers.Style2(obj); │ │ │ │ - } else { │ │ │ │ - style = new OpenLayers.Style(this.defaultSymbolizer, obj); │ │ │ │ - } │ │ │ │ - layer.userStyles.push(style); │ │ │ │ - }, │ │ │ │ - "IsDefault": function(node, style) { │ │ │ │ - if (this.getChildValue(node) == "1") { │ │ │ │ - style.isDefault = true; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "FeatureTypeStyle": function(node, style) { │ │ │ │ - ++this.featureTypeCounter; │ │ │ │ - var obj = { │ │ │ │ - rules: this.multipleSymbolizers ? style.rules : [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - if (!this.multipleSymbolizers) { │ │ │ │ - style.rules = obj.rules; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Rule": function(node, obj) { │ │ │ │ - var config; │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config = { │ │ │ │ - symbolizers: [] │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - var rule = new OpenLayers.Rule(config); │ │ │ │ - this.readChildNodes(node, rule); │ │ │ │ - obj.rules.push(rule); │ │ │ │ - }, │ │ │ │ - "ElseFilter": function(node, rule) { │ │ │ │ - rule.elseFilter = true; │ │ │ │ - }, │ │ │ │ - "MinScaleDenominator": function(node, rule) { │ │ │ │ - rule.minScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "MaxScaleDenominator": function(node, rule) { │ │ │ │ - rule.maxScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "TextSymbolizer": function(node, rule) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push( │ │ │ │ - new OpenLayers.Symbolizer.Text(config) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Text"] = OpenLayers.Util.applyDefaults( │ │ │ │ - config, rule.symbolizer["Text"] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "LabelPlacement": function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "PointPlacement": function(node, symbolizer) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - config.labelRotation = config.rotation; │ │ │ │ - delete config.rotation; │ │ │ │ - var labelAlign, │ │ │ │ - x = symbolizer.labelAnchorPointX, │ │ │ │ - y = symbolizer.labelAnchorPointY; │ │ │ │ - if (x <= 1 / 3) { │ │ │ │ - labelAlign = 'l'; │ │ │ │ - } else if (x > 1 / 3 && x < 2 / 3) { │ │ │ │ - labelAlign = 'c'; │ │ │ │ - } else if (x >= 2 / 3) { │ │ │ │ - labelAlign = 'r'; │ │ │ │ - } │ │ │ │ - if (y <= 1 / 3) { │ │ │ │ - labelAlign += 'b'; │ │ │ │ - } else if (y > 1 / 3 && y < 2 / 3) { │ │ │ │ - labelAlign += 'm'; │ │ │ │ - } else if (y >= 2 / 3) { │ │ │ │ - labelAlign += 't'; │ │ │ │ - } │ │ │ │ - config.labelAlign = labelAlign; │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, config); │ │ │ │ - }, │ │ │ │ - "AnchorPoint": function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "AnchorPointX": function(node, symbolizer) { │ │ │ │ - var labelAnchorPointX = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (labelAnchorPointX) { │ │ │ │ - symbolizer.labelAnchorPointX = labelAnchorPointX; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "AnchorPointY": function(node, symbolizer) { │ │ │ │ - var labelAnchorPointY = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (labelAnchorPointY) { │ │ │ │ - symbolizer.labelAnchorPointY = labelAnchorPointY; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Displacement": function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "DisplacementX": function(node, symbolizer) { │ │ │ │ - var labelXOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (labelXOffset) { │ │ │ │ - symbolizer.labelXOffset = labelXOffset; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "DisplacementY": function(node, symbolizer) { │ │ │ │ - var labelYOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (labelYOffset) { │ │ │ │ - symbolizer.labelYOffset = labelYOffset; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "LinePlacement": function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "PerpendicularOffset": function(node, symbolizer) { │ │ │ │ - var labelPerpendicularOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (labelPerpendicularOffset) { │ │ │ │ - symbolizer.labelPerpendicularOffset = labelPerpendicularOffset; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Label": function(node, symbolizer) { │ │ │ │ - var value = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (value) { │ │ │ │ - symbolizer.label = value; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Font": function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "Halo": function(node, symbolizer) { │ │ │ │ - // halo has a fill, so send fresh object │ │ │ │ - var obj = {}; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - symbolizer.haloRadius = obj.haloRadius; │ │ │ │ - symbolizer.haloColor = obj.fillColor; │ │ │ │ - symbolizer.haloOpacity = obj.fillOpacity; │ │ │ │ - }, │ │ │ │ - "Radius": function(node, symbolizer) { │ │ │ │ - var radius = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (radius != null) { │ │ │ │ - // radius is only used for halo │ │ │ │ - symbolizer.haloRadius = radius; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "RasterSymbolizer": function(node, rule) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push( │ │ │ │ - new OpenLayers.Symbolizer.Raster(config) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Raster"] = OpenLayers.Util.applyDefaults( │ │ │ │ - config, rule.symbolizer["Raster"] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Geometry": function(node, obj) { │ │ │ │ - obj.geometry = {}; │ │ │ │ - this.readChildNodes(node, obj.geometry); │ │ │ │ - }, │ │ │ │ - "ColorMap": function(node, symbolizer) { │ │ │ │ - symbolizer.colorMap = []; │ │ │ │ - this.readChildNodes(node, symbolizer.colorMap); │ │ │ │ - }, │ │ │ │ - "ColorMapEntry": function(node, colorMap) { │ │ │ │ - var q = node.getAttribute("quantity"); │ │ │ │ - var o = node.getAttribute("opacity"); │ │ │ │ - colorMap.push({ │ │ │ │ - color: node.getAttribute("color"), │ │ │ │ - quantity: q !== null ? parseFloat(q) : undefined, │ │ │ │ - label: node.getAttribute("label") || undefined, │ │ │ │ - opacity: o !== null ? parseFloat(o) : undefined │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "LineSymbolizer": function(node, rule) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push( │ │ │ │ - new OpenLayers.Symbolizer.Line(config) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Line"] = OpenLayers.Util.applyDefaults( │ │ │ │ - config, rule.symbolizer["Line"] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "PolygonSymbolizer": function(node, rule) { │ │ │ │ - var config = { │ │ │ │ - fill: false, │ │ │ │ - stroke: false │ │ │ │ - }; │ │ │ │ - if (!this.multipleSymbolizers) { │ │ │ │ - config = rule.symbolizer["Polygon"] || config; │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push( │ │ │ │ - new OpenLayers.Symbolizer.Polygon(config) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Polygon"] = config; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "PointSymbolizer": function(node, rule) { │ │ │ │ - var config = { │ │ │ │ - fill: false, │ │ │ │ - stroke: false, │ │ │ │ - graphic: false │ │ │ │ - }; │ │ │ │ - if (!this.multipleSymbolizers) { │ │ │ │ - config = rule.symbolizer["Point"] || config; │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push( │ │ │ │ - new OpenLayers.Symbolizer.Point(config) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Point"] = config; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Stroke": function(node, symbolizer) { │ │ │ │ - symbolizer.stroke = true; │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "Fill": function(node, symbolizer) { │ │ │ │ - symbolizer.fill = true; │ │ │ │ - this.readChildNodes(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "CssParameter": function(node, symbolizer) { │ │ │ │ - var cssProperty = node.getAttribute("name"); │ │ │ │ - var symProperty = this.cssMap[cssProperty]; │ │ │ │ - // for labels, fill should map to fontColor and fill-opacity │ │ │ │ - // to fontOpacity │ │ │ │ - if (symbolizer.label) { │ │ │ │ - if (cssProperty === 'fill') { │ │ │ │ - symProperty = "fontColor"; │ │ │ │ - } else if (cssProperty === 'fill-opacity') { │ │ │ │ - symProperty = "fontOpacity"; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (symProperty) { │ │ │ │ - // Limited support for parsing of OGC expressions │ │ │ │ - var value = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be an empty string │ │ │ │ - if (value) { │ │ │ │ - symbolizer[symProperty] = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Graphic": function(node, symbolizer) { │ │ │ │ - symbolizer.graphic = true; │ │ │ │ - var graphic = {}; │ │ │ │ - // painter's order not respected here, clobber previous with next │ │ │ │ - this.readChildNodes(node, graphic); │ │ │ │ - // directly properties with names that match symbolizer properties │ │ │ │ - var properties = [ │ │ │ │ - "stroke", "strokeColor", "strokeWidth", "strokeOpacity", │ │ │ │ - "strokeLinecap", "fill", "fillColor", "fillOpacity", │ │ │ │ - "graphicName", "rotation", "graphicFormat" │ │ │ │ - ]; │ │ │ │ - var prop, value; │ │ │ │ - for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ - prop = properties[i]; │ │ │ │ - value = graphic[prop]; │ │ │ │ - if (value != undefined) { │ │ │ │ - symbolizer[prop] = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // set other generic properties with specific graphic property names │ │ │ │ - if (graphic.opacity != undefined) { │ │ │ │ - symbolizer.graphicOpacity = graphic.opacity; │ │ │ │ - } │ │ │ │ - if (graphic.size != undefined) { │ │ │ │ - var pointRadius = graphic.size / 2; │ │ │ │ - if (isNaN(pointRadius)) { │ │ │ │ - // likely a property name │ │ │ │ - symbolizer.graphicWidth = graphic.size; │ │ │ │ - } else { │ │ │ │ - symbolizer.pointRadius = graphic.size / 2; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (graphic.href != undefined) { │ │ │ │ - symbolizer.externalGraphic = graphic.href; │ │ │ │ - } │ │ │ │ - if (graphic.rotation != undefined) { │ │ │ │ - symbolizer.rotation = graphic.rotation; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "ExternalGraphic": function(node, graphic) { │ │ │ │ - this.readChildNodes(node, graphic); │ │ │ │ - }, │ │ │ │ - "Mark": function(node, graphic) { │ │ │ │ - this.readChildNodes(node, graphic); │ │ │ │ - }, │ │ │ │ - "WellKnownName": function(node, graphic) { │ │ │ │ - graphic.graphicName = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Opacity": function(node, obj) { │ │ │ │ - var opacity = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (opacity) { │ │ │ │ - obj.opacity = opacity; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Size": function(node, obj) { │ │ │ │ - var size = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (size) { │ │ │ │ - obj.size = size; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Rotation": function(node, obj) { │ │ │ │ - var rotation = this.readers.ogc._expression.call(this, node); │ │ │ │ - // always string, could be empty string │ │ │ │ - if (rotation) { │ │ │ │ - obj.rotation = rotation; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "OnlineResource": function(node, obj) { │ │ │ │ - obj.href = this.getAttributeNS( │ │ │ │ - node, this.namespaces.xlink, "href" │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "Format": function(node, graphic) { │ │ │ │ - graphic.graphicFormat = this.getChildValue(node); │ │ │ │ + write: function(features) { │ │ │ │ + var doc; │ │ │ │ + if (OpenLayers.Util.isArray(features)) { │ │ │ │ + doc = this.createElementNSPlus("atom:feed"); │ │ │ │ + doc.appendChild( │ │ │ │ + this.createElementNSPlus("atom:title", { │ │ │ │ + value: this.feedTitle │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + for (var i = 0, ii = features.length; i < ii; i++) { │ │ │ │ + doc.appendChild(this.buildEntryNode(features[i])); │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + doc = this.buildEntryNode(features); │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.Filter.v1_0_0.prototype.readers), │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: cssMap │ │ │ │ - * {Object} Object mapping supported css property names to OpenLayers │ │ │ │ - * symbolizer property names. │ │ │ │ - */ │ │ │ │ - cssMap: { │ │ │ │ - "stroke": "strokeColor", │ │ │ │ - "stroke-opacity": "strokeOpacity", │ │ │ │ - "stroke-width": "strokeWidth", │ │ │ │ - "stroke-linecap": "strokeLinecap", │ │ │ │ - "stroke-dasharray": "strokeDashstyle", │ │ │ │ - "fill": "fillColor", │ │ │ │ - "fill-opacity": "fillOpacity", │ │ │ │ - "font-family": "fontFamily", │ │ │ │ - "font-size": "fontSize", │ │ │ │ - "font-weight": "fontWeight", │ │ │ │ - "font-style": "fontStyle" │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [doc]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getCssProperty │ │ │ │ - * Given a symbolizer property, get the corresponding CSS property │ │ │ │ - * from the <cssMap>. │ │ │ │ + * Method: buildContentNode │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * sym - {String} A symbolizer property name. │ │ │ │ + * content - {Object} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A CSS property name or null if none found. │ │ │ │ + * {DOMElement} an Atom content node. │ │ │ │ + * │ │ │ │ + * TODO: types other than text. │ │ │ │ */ │ │ │ │ - getCssProperty: function(sym) { │ │ │ │ - var css = null; │ │ │ │ - for (var prop in this.cssMap) { │ │ │ │ - if (this.cssMap[prop] == sym) { │ │ │ │ - css = prop; │ │ │ │ - break; │ │ │ │ + buildContentNode: function(content) { │ │ │ │ + var node = this.createElementNSPlus("atom:content", { │ │ │ │ + attributes: { │ │ │ │ + type: content.type || null │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (content.src) { │ │ │ │ + node.setAttribute("src", content.src); │ │ │ │ + } else { │ │ │ │ + if (content.type == "text" || content.type == null) { │ │ │ │ + node.appendChild( │ │ │ │ + this.createTextNode(content.value) │ │ │ │ + ); │ │ │ │ + } else if (content.type == "html") { │ │ │ │ + if (typeof content.value != "string") { │ │ │ │ + throw "HTML content must be in form of an escaped string"; │ │ │ │ + } │ │ │ │ + node.appendChild( │ │ │ │ + this.createTextNode(content.value) │ │ │ │ + ); │ │ │ │ + } else if (content.type == "xhtml") { │ │ │ │ + node.appendChild(content.value); │ │ │ │ + } else if (content.type == "xhtml" || │ │ │ │ + content.type.match(/(\+|\/)xml$/)) { │ │ │ │ + node.appendChild(content.value); │ │ │ │ + } else { // MUST be a valid Base64 encoding │ │ │ │ + node.appendChild( │ │ │ │ + this.createTextNode(content.value) │ │ │ │ + ); │ │ │ │ } │ │ │ │ } │ │ │ │ - return css; │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getGraphicFormat │ │ │ │ - * Given a href for an external graphic, try to determine the mime-type. │ │ │ │ - * This method doesn't try too hard, and will fall back to │ │ │ │ - * <defaultGraphicFormat> if one of the known <graphicFormats> is not │ │ │ │ - * the file extension of the provided href. │ │ │ │ + * Method: buildEntryNode │ │ │ │ + * Build an Atom entry node from a feature object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * href - {String} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} The graphic format. │ │ │ │ + * {DOMElement} an Atom entry node. │ │ │ │ + * │ │ │ │ + * These entries are geared for publication using AtomPub. │ │ │ │ + * │ │ │ │ + * TODO: support extension elements │ │ │ │ */ │ │ │ │ - getGraphicFormat: function(href) { │ │ │ │ - var format, regex; │ │ │ │ - for (var key in this.graphicFormats) { │ │ │ │ - if (this.graphicFormats[key].test(href)) { │ │ │ │ - format = key; │ │ │ │ - break; │ │ │ │ + buildEntryNode: function(feature) { │ │ │ │ + var attrib = feature.attributes; │ │ │ │ + var atomAttrib = attrib.atom || {}; │ │ │ │ + var entryNode = this.createElementNSPlus("atom:entry"); │ │ │ │ + │ │ │ │ + // atom:author │ │ │ │ + if (atomAttrib.authors) { │ │ │ │ + var authors = OpenLayers.Util.isArray(atomAttrib.authors) ? │ │ │ │ + atomAttrib.authors : [atomAttrib.authors]; │ │ │ │ + for (var i = 0, ii = authors.length; i < ii; i++) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.buildPersonConstructNode( │ │ │ │ + "author", authors[i] │ │ │ │ + ) │ │ │ │ + ); │ │ │ │ } │ │ │ │ } │ │ │ │ - return format || this.defaultGraphicFormat; │ │ │ │ + │ │ │ │ + // atom:category │ │ │ │ + if (atomAttrib.categories) { │ │ │ │ + var categories = OpenLayers.Util.isArray(atomAttrib.categories) ? │ │ │ │ + atomAttrib.categories : [atomAttrib.categories]; │ │ │ │ + var category; │ │ │ │ + for (var i = 0, ii = categories.length; i < ii; i++) { │ │ │ │ + category = categories[i]; │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:category", { │ │ │ │ + attributes: { │ │ │ │ + term: category.term, │ │ │ │ + scheme: category.scheme || null, │ │ │ │ + label: category.label || null │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:content │ │ │ │ + if (atomAttrib.content) { │ │ │ │ + entryNode.appendChild(this.buildContentNode(atomAttrib.content)); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:contributor │ │ │ │ + if (atomAttrib.contributors) { │ │ │ │ + var contributors = OpenLayers.Util.isArray(atomAttrib.contributors) ? │ │ │ │ + atomAttrib.contributors : [atomAttrib.contributors]; │ │ │ │ + for (var i = 0, ii = contributors.length; i < ii; i++) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.buildPersonConstructNode( │ │ │ │ + "contributor", │ │ │ │ + contributors[i] │ │ │ │ + ) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:id │ │ │ │ + if (feature.fid) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:id", { │ │ │ │ + value: feature.fid │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:link │ │ │ │ + if (atomAttrib.links) { │ │ │ │ + var links = OpenLayers.Util.isArray(atomAttrib.links) ? │ │ │ │ + atomAttrib.links : [atomAttrib.links]; │ │ │ │ + var link; │ │ │ │ + for (var i = 0, ii = links.length; i < ii; i++) { │ │ │ │ + link = links[i]; │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:link", { │ │ │ │ + attributes: { │ │ │ │ + href: link.href, │ │ │ │ + rel: link.rel || null, │ │ │ │ + type: link.type || null, │ │ │ │ + hreflang: link.hreflang || null, │ │ │ │ + title: link.title || null, │ │ │ │ + length: link.length || null │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:published │ │ │ │ + if (atomAttrib.published) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:published", { │ │ │ │ + value: atomAttrib.published │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:rights │ │ │ │ + if (atomAttrib.rights) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:rights", { │ │ │ │ + value: atomAttrib.rights │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:source not implemented │ │ │ │ + │ │ │ │ + // atom:summary │ │ │ │ + if (atomAttrib.summary || attrib.description) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:summary", { │ │ │ │ + value: atomAttrib.summary || attrib.description │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // atom:title │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:title", { │ │ │ │ + value: atomAttrib.title || attrib.title || this.defaultEntryTitle │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + │ │ │ │ + // atom:updated │ │ │ │ + if (atomAttrib.updated) { │ │ │ │ + entryNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:updated", { │ │ │ │ + value: atomAttrib.updated │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // georss:where │ │ │ │ + if (feature.geometry) { │ │ │ │ + var whereNode = this.createElementNSPlus("georss:where"); │ │ │ │ + whereNode.appendChild( │ │ │ │ + this.buildGeometryNode(feature.geometry) │ │ │ │ + ); │ │ │ │ + entryNode.appendChild(whereNode); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return entryNode; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultGraphicFormat │ │ │ │ - * {String} If none other can be determined from <getGraphicFormat>, this │ │ │ │ - * default will be returned. │ │ │ │ + * Method: initGmlParser │ │ │ │ + * Creates a GML parser. │ │ │ │ */ │ │ │ │ - defaultGraphicFormat: "image/png", │ │ │ │ + initGmlParser: function() { │ │ │ │ + this.gmlParser = new OpenLayers.Format.GML.v3({ │ │ │ │ + xy: this.xy, │ │ │ │ + featureNS: "http://example.com#feature", │ │ │ │ + internalProjection: this.internalProjection, │ │ │ │ + externalProjection: this.externalProjection │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: graphicFormats │ │ │ │ - * {Object} Mapping of image mime-types to regular extensions matching │ │ │ │ - * well-known file extensions. │ │ │ │ + * Method: buildGeometryNode │ │ │ │ + * builds a GeoRSS node with a given geometry │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A gml node. │ │ │ │ */ │ │ │ │ - graphicFormats: { │ │ │ │ - "image/jpeg": /\.jpe?g$/i, │ │ │ │ - "image/gif": /\.gif$/i, │ │ │ │ - "image/png": /\.png$/i │ │ │ │ + buildGeometryNode: function(geometry) { │ │ │ │ + if (!this.gmlParser) { │ │ │ │ + this.initGmlParser(); │ │ │ │ + } │ │ │ │ + var node = this.gmlParser.writeNode("feature:_geometry", geometry); │ │ │ │ + return node.firstChild; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ + * Method: buildPersonConstructNode │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * sld - {Object} An object representing the SLD. │ │ │ │ + * name - {String} │ │ │ │ + * value - {Object} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} The root of an SLD document. │ │ │ │ + * {DOMElement} an Atom person construct node. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * >>> buildPersonConstructNode("author", {name: "John Smith"}) │ │ │ │ + * {<author><name>John Smith</name></author>} │ │ │ │ + * │ │ │ │ + * TODO: how to specify extension elements? Add to the oNames array? │ │ │ │ */ │ │ │ │ - write: function(sld) { │ │ │ │ - return this.writers.sld.StyledLayerDescriptor.apply(this, [sld]); │ │ │ │ + buildPersonConstructNode: function(name, value) { │ │ │ │ + var oNames = ["uri", "email"]; │ │ │ │ + var personNode = this.createElementNSPlus("atom:" + name); │ │ │ │ + personNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:name", { │ │ │ │ + value: value.name │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + for (var i = 0, ii = oNames.length; i < ii; i++) { │ │ │ │ + if (value[oNames[i]]) { │ │ │ │ + personNode.appendChild( │ │ │ │ + this.createElementNSPlus("atom:" + oNames[i], { │ │ │ │ + value: value[oNames[i]] │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return personNode; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * Method: getFirstChildValue │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * nsuri - {String} Child node namespace uri ("*" for any). │ │ │ │ + * name - {String} Child node name. │ │ │ │ + * def - {String} Optional string default to return if no child found. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The value of the first child with the given tag name. Returns │ │ │ │ + * default value or empty string if none found. │ │ │ │ */ │ │ │ │ - writers: OpenLayers.Util.applyDefaults({ │ │ │ │ - "sld": { │ │ │ │ - "_OGCExpression": function(nodeName, value) { │ │ │ │ - // only the simplest of ogc:expression handled │ │ │ │ - // {label: "some text and a ${propertyName}"} │ │ │ │ - var node = this.createElementNSPlus(nodeName); │ │ │ │ - var tokens = typeof value == "string" ? │ │ │ │ - value.split("${") : [value]; │ │ │ │ - node.appendChild(this.createTextNode(tokens[0])); │ │ │ │ - var item, last; │ │ │ │ - for (var i = 1, len = tokens.length; i < len; i++) { │ │ │ │ - item = tokens[i]; │ │ │ │ - last = item.indexOf("}"); │ │ │ │ - if (last > 0) { │ │ │ │ - this.writeNode( │ │ │ │ - "ogc:PropertyName", { │ │ │ │ - property: item.substring(0, last) │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - node.appendChild( │ │ │ │ - this.createTextNode(item.substring(++last)) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - // no ending }, so this is a literal ${ │ │ │ │ - node.appendChild( │ │ │ │ - this.createTextNode("${" + item) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "StyledLayerDescriptor": function(sld) { │ │ │ │ - var root = this.createElementNSPlus( │ │ │ │ - "sld:StyledLayerDescriptor", { │ │ │ │ - attributes: { │ │ │ │ - "version": this.VERSION, │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ - } │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // For ArcGIS Server it is necessary to define this │ │ │ │ - // at the root level (see ticket:2166). │ │ │ │ - root.setAttribute("xmlns:ogc", this.namespaces.ogc); │ │ │ │ - root.setAttribute("xmlns:gml", this.namespaces.gml); │ │ │ │ + getFirstChildValue: function(node, nsuri, name, def) { │ │ │ │ + var value; │ │ │ │ + var nodes = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ + if (nodes && nodes.length > 0) { │ │ │ │ + value = this.getChildValue(nodes[0], def); │ │ │ │ + } else { │ │ │ │ + value = def; │ │ │ │ + } │ │ │ │ + return value; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // add in optional name │ │ │ │ - if (sld.name) { │ │ │ │ - this.writeNode("Name", sld.name, root); │ │ │ │ - } │ │ │ │ - // add in optional title │ │ │ │ - if (sld.title) { │ │ │ │ - this.writeNode("Title", sld.title, root); │ │ │ │ - } │ │ │ │ - // add in optional description │ │ │ │ - if (sld.description) { │ │ │ │ - this.writeNode("Abstract", sld.description, root); │ │ │ │ - } │ │ │ │ - // add in named layers │ │ │ │ - // allow namedLayers to be an array │ │ │ │ - if (OpenLayers.Util.isArray(sld.namedLayers)) { │ │ │ │ - for (var i = 0, len = sld.namedLayers.length; i < len; ++i) { │ │ │ │ - this.writeNode("NamedLayer", sld.namedLayers[i], root); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - for (var name in sld.namedLayers) { │ │ │ │ - this.writeNode("NamedLayer", sld.namedLayers[name], root); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return root; │ │ │ │ - }, │ │ │ │ - "Name": function(name) { │ │ │ │ - return this.createElementNSPlus("sld:Name", { │ │ │ │ - value: name │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Title": function(title) { │ │ │ │ - return this.createElementNSPlus("sld:Title", { │ │ │ │ - value: title │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Abstract": function(description) { │ │ │ │ - return this.createElementNSPlus( │ │ │ │ - "sld:Abstract", { │ │ │ │ - value: description │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "NamedLayer": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("sld:NamedLayer"); │ │ │ │ + /** │ │ │ │ + * Method: parseFeature │ │ │ │ + * Parse feature from an Atom entry node.. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} An Atom entry or feed node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + parseFeature: function(node) { │ │ │ │ + var atomAttrib = {}; │ │ │ │ + var value = null; │ │ │ │ + var nodes = null; │ │ │ │ + var attval = null; │ │ │ │ + var atomns = this.namespaces.atom; │ │ │ │ │ │ │ │ - // add in required name │ │ │ │ - this.writeNode("Name", layer.name, node); │ │ │ │ + // atomAuthor* │ │ │ │ + this.parsePersonConstructs(node, "author", atomAttrib); │ │ │ │ │ │ │ │ - // optional sld:LayerFeatureConstraints here │ │ │ │ + // atomCategory* │ │ │ │ + nodes = this.getElementsByTagNameNS(node, atomns, "category"); │ │ │ │ + if (nodes.length > 0) { │ │ │ │ + atomAttrib.categories = []; │ │ │ │ + } │ │ │ │ + for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ + value = {}; │ │ │ │ + value.term = nodes[i].getAttribute("term"); │ │ │ │ + attval = nodes[i].getAttribute("scheme"); │ │ │ │ + if (attval) { │ │ │ │ + value.scheme = attval; │ │ │ │ + } │ │ │ │ + attval = nodes[i].getAttribute("label"); │ │ │ │ + if (attval) { │ │ │ │ + value.label = attval; │ │ │ │ + } │ │ │ │ + atomAttrib.categories.push(value); │ │ │ │ + } │ │ │ │ │ │ │ │ - // add in named styles │ │ │ │ - if (layer.namedStyles) { │ │ │ │ - for (var i = 0, len = layer.namedStyles.length; i < len; ++i) { │ │ │ │ - this.writeNode( │ │ │ │ - "NamedStyle", layer.namedStyles[i], node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ + // atomContent? │ │ │ │ + nodes = this.getElementsByTagNameNS(node, atomns, "content"); │ │ │ │ + if (nodes.length > 0) { │ │ │ │ + value = {}; │ │ │ │ + attval = nodes[0].getAttribute("type"); │ │ │ │ + if (attval) { │ │ │ │ + value.type = attval; │ │ │ │ + } │ │ │ │ + attval = nodes[0].getAttribute("src"); │ │ │ │ + if (attval) { │ │ │ │ + value.src = attval; │ │ │ │ + } else { │ │ │ │ + if (value.type == "text" || │ │ │ │ + value.type == "html" || │ │ │ │ + value.type == null) { │ │ │ │ + value.value = this.getFirstChildValue( │ │ │ │ + node, │ │ │ │ + atomns, │ │ │ │ + "content", │ │ │ │ + null │ │ │ │ + ); │ │ │ │ + } else if (value.type == "xhtml" || │ │ │ │ + value.type.match(/(\+|\/)xml$/)) { │ │ │ │ + value.value = this.getChildEl(nodes[0]); │ │ │ │ + } else { // MUST be base64 encoded │ │ │ │ + value.value = this.getFirstChildValue( │ │ │ │ + node, │ │ │ │ + atomns, │ │ │ │ + "content", │ │ │ │ + null │ │ │ │ + ); │ │ │ │ } │ │ │ │ + atomAttrib.content = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - // add in user styles │ │ │ │ - if (layer.userStyles) { │ │ │ │ - for (var i = 0, len = layer.userStyles.length; i < len; ++i) { │ │ │ │ - this.writeNode( │ │ │ │ - "UserStyle", layer.userStyles[i], node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + // atomContributor* │ │ │ │ + this.parsePersonConstructs(node, "contributor", atomAttrib); │ │ │ │ │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "NamedStyle": function(name) { │ │ │ │ - var node = this.createElementNSPlus("sld:NamedStyle"); │ │ │ │ - this.writeNode("Name", name, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "UserStyle": function(style) { │ │ │ │ - var node = this.createElementNSPlus("sld:UserStyle"); │ │ │ │ + // atomId │ │ │ │ + atomAttrib.id = this.getFirstChildValue(node, atomns, "id", null); │ │ │ │ │ │ │ │ - // add in optional name │ │ │ │ - if (style.name) { │ │ │ │ - this.writeNode("Name", style.name, node); │ │ │ │ - } │ │ │ │ - // add in optional title │ │ │ │ - if (style.title) { │ │ │ │ - this.writeNode("Title", style.title, node); │ │ │ │ - } │ │ │ │ - // add in optional description │ │ │ │ - if (style.description) { │ │ │ │ - this.writeNode("Abstract", style.description, node); │ │ │ │ + // atomLink* │ │ │ │ + nodes = this.getElementsByTagNameNS(node, atomns, "link"); │ │ │ │ + if (nodes.length > 0) { │ │ │ │ + atomAttrib.links = new Array(nodes.length); │ │ │ │ + } │ │ │ │ + var oAtts = ["rel", "type", "hreflang", "title", "length"]; │ │ │ │ + for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ + value = {}; │ │ │ │ + value.href = nodes[i].getAttribute("href"); │ │ │ │ + for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ + attval = nodes[i].getAttribute(oAtts[j]); │ │ │ │ + if (attval) { │ │ │ │ + value[oAtts[j]] = attval; │ │ │ │ } │ │ │ │ + } │ │ │ │ + atomAttrib.links[i] = value; │ │ │ │ + } │ │ │ │ │ │ │ │ - // add isdefault │ │ │ │ - if (style.isDefault) { │ │ │ │ - this.writeNode("IsDefault", style.isDefault, node); │ │ │ │ - } │ │ │ │ + // atomPublished? │ │ │ │ + value = this.getFirstChildValue(node, atomns, "published", null); │ │ │ │ + if (value) { │ │ │ │ + atomAttrib.published = value; │ │ │ │ + } │ │ │ │ │ │ │ │ - // add FeatureTypeStyles │ │ │ │ - if (this.multipleSymbolizers && style.rules) { │ │ │ │ - // group style objects by symbolizer zIndex │ │ │ │ - var rulesByZ = { │ │ │ │ - 0: [] │ │ │ │ - }; │ │ │ │ - var zValues = [0]; │ │ │ │ - var rule, ruleMap, symbolizer, zIndex, clone; │ │ │ │ - for (var i = 0, ii = style.rules.length; i < ii; ++i) { │ │ │ │ - rule = style.rules[i]; │ │ │ │ - if (rule.symbolizers) { │ │ │ │ - ruleMap = {}; │ │ │ │ - for (var j = 0, jj = rule.symbolizers.length; j < jj; ++j) { │ │ │ │ - symbolizer = rule.symbolizers[j]; │ │ │ │ - zIndex = symbolizer.zIndex; │ │ │ │ - if (!(zIndex in ruleMap)) { │ │ │ │ - clone = rule.clone(); │ │ │ │ - clone.symbolizers = []; │ │ │ │ - ruleMap[zIndex] = clone; │ │ │ │ - } │ │ │ │ - ruleMap[zIndex].symbolizers.push(symbolizer.clone()); │ │ │ │ - } │ │ │ │ - for (zIndex in ruleMap) { │ │ │ │ - if (!(zIndex in rulesByZ)) { │ │ │ │ - zValues.push(zIndex); │ │ │ │ - rulesByZ[zIndex] = []; │ │ │ │ - } │ │ │ │ - rulesByZ[zIndex].push(ruleMap[zIndex]); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // no symbolizers in rule │ │ │ │ - rulesByZ[0].push(rule.clone()); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // write one FeatureTypeStyle per zIndex │ │ │ │ - zValues.sort(); │ │ │ │ - var rules; │ │ │ │ - for (var i = 0, ii = zValues.length; i < ii; ++i) { │ │ │ │ - rules = rulesByZ[zValues[i]]; │ │ │ │ - if (rules.length > 0) { │ │ │ │ - clone = style.clone(); │ │ │ │ - clone.rules = rulesByZ[zValues[i]]; │ │ │ │ - this.writeNode("FeatureTypeStyle", clone, node); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.writeNode("FeatureTypeStyle", style, node); │ │ │ │ - } │ │ │ │ + // atomRights? │ │ │ │ + value = this.getFirstChildValue(node, atomns, "rights", null); │ │ │ │ + if (value) { │ │ │ │ + atomAttrib.rights = value; │ │ │ │ + } │ │ │ │ │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "IsDefault": function(bool) { │ │ │ │ - return this.createElementNSPlus( │ │ │ │ - "sld:IsDefault", { │ │ │ │ - value: (bool) ? "1" : "0" │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "FeatureTypeStyle": function(style) { │ │ │ │ - var node = this.createElementNSPlus("sld:FeatureTypeStyle"); │ │ │ │ + // atomSource? -- not implemented │ │ │ │ │ │ │ │ - // OpenLayers currently stores no Name, Title, Abstract, │ │ │ │ - // FeatureTypeName, or SemanticTypeIdentifier information │ │ │ │ - // related to FeatureTypeStyle │ │ │ │ + // atomSummary? │ │ │ │ + value = this.getFirstChildValue(node, atomns, "summary", null); │ │ │ │ + if (value) { │ │ │ │ + atomAttrib.summary = value; │ │ │ │ + } │ │ │ │ │ │ │ │ - // add in rules │ │ │ │ - for (var i = 0, len = style.rules.length; i < len; ++i) { │ │ │ │ - this.writeNode("Rule", style.rules[i], node); │ │ │ │ - } │ │ │ │ + // atomTitle │ │ │ │ + atomAttrib.title = this.getFirstChildValue( │ │ │ │ + node, atomns, "title", null │ │ │ │ + ); │ │ │ │ │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Rule": function(rule) { │ │ │ │ - var node = this.createElementNSPlus("sld:Rule"); │ │ │ │ + // atomUpdated │ │ │ │ + atomAttrib.updated = this.getFirstChildValue( │ │ │ │ + node, atomns, "updated", null │ │ │ │ + ); │ │ │ │ │ │ │ │ - // add in optional name │ │ │ │ - if (rule.name) { │ │ │ │ - this.writeNode("Name", rule.name, node); │ │ │ │ - } │ │ │ │ - // add in optional title │ │ │ │ - if (rule.title) { │ │ │ │ - this.writeNode("Title", rule.title, node); │ │ │ │ - } │ │ │ │ - // add in optional description │ │ │ │ - if (rule.description) { │ │ │ │ - this.writeNode("Abstract", rule.description, node); │ │ │ │ - } │ │ │ │ + var featureAttrib = { │ │ │ │ + title: atomAttrib.title, │ │ │ │ + description: atomAttrib.summary, │ │ │ │ + atom: atomAttrib │ │ │ │ + }; │ │ │ │ + var geometry = this.parseLocations(node)[0]; │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, featureAttrib); │ │ │ │ + feature.fid = atomAttrib.id; │ │ │ │ + return feature; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // add in LegendGraphic here │ │ │ │ + /** │ │ │ │ + * Method: parseFeatures │ │ │ │ + * Return features from an Atom entry or feed. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} An Atom entry or feed node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + */ │ │ │ │ + parseFeatures: function(node) { │ │ │ │ + var features = []; │ │ │ │ + var entries = this.getElementsByTagNameNS( │ │ │ │ + node, this.namespaces.atom, "entry" │ │ │ │ + ); │ │ │ │ + if (entries.length == 0) { │ │ │ │ + entries = [node]; │ │ │ │ + } │ │ │ │ + for (var i = 0, ii = entries.length; i < ii; i++) { │ │ │ │ + features.push(this.parseFeature(entries[i])); │ │ │ │ + } │ │ │ │ + return features; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // add in optional filters │ │ │ │ - if (rule.elseFilter) { │ │ │ │ - this.writeNode("ElseFilter", null, node); │ │ │ │ - } else if (rule.filter) { │ │ │ │ - this.writeNode("ogc:Filter", rule.filter, node); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: parseLocations │ │ │ │ + * Parse the locations from an Atom entry or feed. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} An Atom entry or feed node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * Array({<OpenLayers.Geometry>}) │ │ │ │ + */ │ │ │ │ + parseLocations: function(node) { │ │ │ │ + var georssns = this.namespaces.georss; │ │ │ │ │ │ │ │ - // add in scale limits │ │ │ │ - if (rule.minScaleDenominator != undefined) { │ │ │ │ - this.writeNode( │ │ │ │ - "MinScaleDenominator", rule.minScaleDenominator, node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (rule.maxScaleDenominator != undefined) { │ │ │ │ - this.writeNode( │ │ │ │ - "MaxScaleDenominator", rule.maxScaleDenominator, node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ + var locations = { │ │ │ │ + components: [] │ │ │ │ + }; │ │ │ │ + var where = this.getElementsByTagNameNS(node, georssns, "where"); │ │ │ │ + if (where && where.length > 0) { │ │ │ │ + if (!this.gmlParser) { │ │ │ │ + this.initGmlParser(); │ │ │ │ + } │ │ │ │ + for (var i = 0, ii = where.length; i < ii; i++) { │ │ │ │ + this.gmlParser.readChildNodes(where[i], locations); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - var type, symbolizer; │ │ │ │ - if (this.multipleSymbolizers && rule.symbolizers) { │ │ │ │ - var symbolizer; │ │ │ │ - for (var i = 0, ii = rule.symbolizers.length; i < ii; ++i) { │ │ │ │ - symbolizer = rule.symbolizers[i]; │ │ │ │ - type = symbolizer.CLASS_NAME.split(".").pop(); │ │ │ │ - this.writeNode( │ │ │ │ - type + "Symbolizer", symbolizer, node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // add in symbolizers (relies on geometry type keys) │ │ │ │ - var types = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ - for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ - type = types[i]; │ │ │ │ - symbolizer = rule.symbolizer[type]; │ │ │ │ - if (symbolizer) { │ │ │ │ - this.writeNode( │ │ │ │ - type + "Symbolizer", symbolizer, node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var components = locations.components; │ │ │ │ + var point = this.getElementsByTagNameNS(node, georssns, "point"); │ │ │ │ + if (point && point.length > 0) { │ │ │ │ + for (var i = 0, ii = point.length; i < ii; i++) { │ │ │ │ + var xy = OpenLayers.String.trim( │ │ │ │ + point[i].firstChild.nodeValue │ │ │ │ + ).split(/\s+/); │ │ │ │ + if (xy.length != 2) { │ │ │ │ + xy = OpenLayers.String.trim( │ │ │ │ + point[i].firstChild.nodeValue │ │ │ │ + ).split(/\s*,\s*/); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ + components.push(new OpenLayers.Geometry.Point(xy[1], xy[0])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - }, │ │ │ │ - "ElseFilter": function() { │ │ │ │ - return this.createElementNSPlus("sld:ElseFilter"); │ │ │ │ - }, │ │ │ │ - "MinScaleDenominator": function(scale) { │ │ │ │ - return this.createElementNSPlus( │ │ │ │ - "sld:MinScaleDenominator", { │ │ │ │ - value: scale │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "MaxScaleDenominator": function(scale) { │ │ │ │ - return this.createElementNSPlus( │ │ │ │ - "sld:MaxScaleDenominator", { │ │ │ │ - value: scale │ │ │ │ - } │ │ │ │ + var line = this.getElementsByTagNameNS(node, georssns, "line"); │ │ │ │ + if (line && line.length > 0) { │ │ │ │ + var coords; │ │ │ │ + var p; │ │ │ │ + var points; │ │ │ │ + for (var i = 0, ii = line.length; i < ii; i++) { │ │ │ │ + coords = OpenLayers.String.trim( │ │ │ │ + line[i].firstChild.nodeValue │ │ │ │ + ).split(/\s+/); │ │ │ │ + points = []; │ │ │ │ + for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ + p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ + points.push(p); │ │ │ │ + } │ │ │ │ + components.push( │ │ │ │ + new OpenLayers.Geometry.LineString(points) │ │ │ │ ); │ │ │ │ - }, │ │ │ │ - "LineSymbolizer": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:LineSymbolizer"); │ │ │ │ - this.writeNode("Stroke", symbolizer, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Stroke": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Stroke"); │ │ │ │ - │ │ │ │ - // GraphicFill here │ │ │ │ - // GraphicStroke here │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - // add in CssParameters │ │ │ │ - if (symbolizer.strokeColor != undefined) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "strokeColor" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.strokeOpacity != undefined) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "strokeOpacity" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.strokeWidth != undefined) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "strokeWidth" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.strokeDashstyle != undefined && symbolizer.strokeDashstyle !== "solid") { │ │ │ │ - // assumes valid stroke-dasharray value │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "strokeDashstyle" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.strokeLinecap != undefined) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "strokeLinecap" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "CssParameter": function(obj) { │ │ │ │ - // not handling ogc:expressions for now │ │ │ │ - return this.createElementNSPlus("sld:CssParameter", { │ │ │ │ - attributes: { │ │ │ │ - name: this.getCssProperty(obj.key) │ │ │ │ - }, │ │ │ │ - value: obj.symbolizer[obj.key] │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "TextSymbolizer": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:TextSymbolizer"); │ │ │ │ - // add in optional Label │ │ │ │ - if (symbolizer.label != null) { │ │ │ │ - this.writeNode("Label", symbolizer.label, node); │ │ │ │ - } │ │ │ │ - // add in optional Font │ │ │ │ - if (symbolizer.fontFamily != null || │ │ │ │ - symbolizer.fontSize != null || │ │ │ │ - symbolizer.fontWeight != null || │ │ │ │ - symbolizer.fontStyle != null) { │ │ │ │ - this.writeNode("Font", symbolizer, node); │ │ │ │ - } │ │ │ │ - // add in optional LabelPlacement │ │ │ │ - if (symbolizer.labelAnchorPointX != null || │ │ │ │ - symbolizer.labelAnchorPointY != null || │ │ │ │ - symbolizer.labelAlign != null || │ │ │ │ - symbolizer.labelXOffset != null || │ │ │ │ - symbolizer.labelYOffset != null || │ │ │ │ - symbolizer.labelRotation != null || │ │ │ │ - symbolizer.labelPerpendicularOffset != null) { │ │ │ │ - this.writeNode("LabelPlacement", symbolizer, node); │ │ │ │ - } │ │ │ │ - // add in optional Halo │ │ │ │ - if (symbolizer.haloRadius != null || │ │ │ │ - symbolizer.haloColor != null || │ │ │ │ - symbolizer.haloOpacity != null) { │ │ │ │ - this.writeNode("Halo", symbolizer, node); │ │ │ │ - } │ │ │ │ - // add in optional Fill │ │ │ │ - if (symbolizer.fontColor != null || │ │ │ │ - symbolizer.fontOpacity != null) { │ │ │ │ - this.writeNode("Fill", { │ │ │ │ - fillColor: symbolizer.fontColor, │ │ │ │ - fillOpacity: symbolizer.fontOpacity │ │ │ │ - }, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "LabelPlacement": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:LabelPlacement"); │ │ │ │ - // PointPlacement and LinePlacement are choices, so don't output both │ │ │ │ - if ((symbolizer.labelAnchorPointX != null || │ │ │ │ - symbolizer.labelAnchorPointY != null || │ │ │ │ - symbolizer.labelAlign != null || │ │ │ │ - symbolizer.labelXOffset != null || │ │ │ │ - symbolizer.labelYOffset != null || │ │ │ │ - symbolizer.labelRotation != null) && │ │ │ │ - symbolizer.labelPerpendicularOffset == null) { │ │ │ │ - this.writeNode("PointPlacement", symbolizer, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.labelPerpendicularOffset != null) { │ │ │ │ - this.writeNode("LinePlacement", symbolizer, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "LinePlacement": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:LinePlacement"); │ │ │ │ - this.writeNode("PerpendicularOffset", symbolizer.labelPerpendicularOffset, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PerpendicularOffset": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:PerpendicularOffset", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "PointPlacement": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:PointPlacement"); │ │ │ │ - if (symbolizer.labelAnchorPointX != null || │ │ │ │ - symbolizer.labelAnchorPointY != null || │ │ │ │ - symbolizer.labelAlign != null) { │ │ │ │ - this.writeNode("AnchorPoint", symbolizer, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.labelXOffset != null || │ │ │ │ - symbolizer.labelYOffset != null) { │ │ │ │ - this.writeNode("Displacement", symbolizer, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.labelRotation != null) { │ │ │ │ - this.writeNode("Rotation", symbolizer.labelRotation, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "AnchorPoint": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:AnchorPoint"); │ │ │ │ - var x = symbolizer.labelAnchorPointX, │ │ │ │ - y = symbolizer.labelAnchorPointY; │ │ │ │ - if (x != null) { │ │ │ │ - this.writeNode("AnchorPointX", x, node); │ │ │ │ - } │ │ │ │ - if (y != null) { │ │ │ │ - this.writeNode("AnchorPointY", y, node); │ │ │ │ - } │ │ │ │ - if (x == null && y == null) { │ │ │ │ - var xAlign = symbolizer.labelAlign.substr(0, 1), │ │ │ │ - yAlign = symbolizer.labelAlign.substr(1, 1); │ │ │ │ - if (xAlign === "l") { │ │ │ │ - x = 0; │ │ │ │ - } else if (xAlign === "c") { │ │ │ │ - x = 0.5; │ │ │ │ - } else if (xAlign === "r") { │ │ │ │ - x = 1; │ │ │ │ - } │ │ │ │ - if (yAlign === "b") { │ │ │ │ - y = 0; │ │ │ │ - } else if (yAlign === "m") { │ │ │ │ - y = 0.5; │ │ │ │ - } else if (yAlign === "t") { │ │ │ │ - y = 1; │ │ │ │ - } │ │ │ │ - this.writeNode("AnchorPointX", x, node); │ │ │ │ - this.writeNode("AnchorPointY", y, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "AnchorPointX": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:AnchorPointX", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "AnchorPointY": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:AnchorPointY", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Displacement": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Displacement"); │ │ │ │ - if (symbolizer.labelXOffset != null) { │ │ │ │ - this.writeNode("DisplacementX", symbolizer.labelXOffset, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.labelYOffset != null) { │ │ │ │ - this.writeNode("DisplacementY", symbolizer.labelYOffset, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "DisplacementX": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:DisplacementX", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "DisplacementY": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:DisplacementY", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Font": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Font"); │ │ │ │ - // add in CssParameters │ │ │ │ - if (symbolizer.fontFamily) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "fontFamily" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.fontSize) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "fontSize" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.fontWeight) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "fontWeight" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.fontStyle) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "fontStyle" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ + var polygon = this.getElementsByTagNameNS(node, georssns, "polygon"); │ │ │ │ + if (polygon && polygon.length > 0) { │ │ │ │ + var coords; │ │ │ │ + var p; │ │ │ │ + var points; │ │ │ │ + for (var i = 0, ii = polygon.length; i < ii; i++) { │ │ │ │ + coords = OpenLayers.String.trim( │ │ │ │ + polygon[i].firstChild.nodeValue │ │ │ │ + ).split(/\s+/); │ │ │ │ + points = []; │ │ │ │ + for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ + p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ + points.push(p); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Label": function(label) { │ │ │ │ - return this.writers.sld._OGCExpression.call( │ │ │ │ - this, "sld:Label", label │ │ │ │ + components.push( │ │ │ │ + new OpenLayers.Geometry.Polygon( │ │ │ │ + [new OpenLayers.Geometry.LinearRing(points)] │ │ │ │ + ) │ │ │ │ ); │ │ │ │ - }, │ │ │ │ - "Halo": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Halo"); │ │ │ │ - if (symbolizer.haloRadius) { │ │ │ │ - this.writeNode("Radius", symbolizer.haloRadius, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.haloColor || symbolizer.haloOpacity) { │ │ │ │ - this.writeNode("Fill", { │ │ │ │ - fillColor: symbolizer.haloColor, │ │ │ │ - fillOpacity: symbolizer.haloOpacity │ │ │ │ - }, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Radius": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:Radius", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "RasterSymbolizer": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:RasterSymbolizer"); │ │ │ │ - if (symbolizer.geometry) { │ │ │ │ - this.writeNode("Geometry", symbolizer.geometry, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.opacity) { │ │ │ │ - this.writeNode("Opacity", symbolizer.opacity, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.colorMap) { │ │ │ │ - this.writeNode("ColorMap", symbolizer.colorMap, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Geometry": function(geometry) { │ │ │ │ - var node = this.createElementNSPlus("sld:Geometry"); │ │ │ │ - if (geometry.property) { │ │ │ │ - this.writeNode("ogc:PropertyName", geometry, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ColorMap": function(colorMap) { │ │ │ │ - var node = this.createElementNSPlus("sld:ColorMap"); │ │ │ │ - for (var i = 0, len = colorMap.length; i < len; ++i) { │ │ │ │ - this.writeNode("ColorMapEntry", colorMap[i], node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ColorMapEntry": function(colorMapEntry) { │ │ │ │ - var node = this.createElementNSPlus("sld:ColorMapEntry"); │ │ │ │ - var a = colorMapEntry; │ │ │ │ - node.setAttribute("color", a.color); │ │ │ │ - a.opacity !== undefined && node.setAttribute("opacity", │ │ │ │ - parseFloat(a.opacity)); │ │ │ │ - a.quantity !== undefined && node.setAttribute("quantity", │ │ │ │ - parseFloat(a.quantity)); │ │ │ │ - a.label !== undefined && node.setAttribute("label", a.label); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PolygonSymbolizer": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:PolygonSymbolizer"); │ │ │ │ - if (symbolizer.fill !== false) { │ │ │ │ - this.writeNode("Fill", symbolizer, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.stroke !== false) { │ │ │ │ - this.writeNode("Stroke", symbolizer, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Fill": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Fill"); │ │ │ │ - │ │ │ │ - // GraphicFill here │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - // add in CssParameters │ │ │ │ - if (symbolizer.fillColor) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "fillColor" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (symbolizer.fillOpacity != null) { │ │ │ │ - this.writeNode( │ │ │ │ - "CssParameter", { │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - key: "fillOpacity" │ │ │ │ - }, │ │ │ │ - node │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + for (var i = 0, ii = components.length; i < ii; i++) { │ │ │ │ + if (components[i]) { │ │ │ │ + components[i].transform( │ │ │ │ + this.externalProjection, │ │ │ │ + this.internalProjection │ │ │ │ ); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PointSymbolizer": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:PointSymbolizer"); │ │ │ │ - this.writeNode("Graphic", symbolizer, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Graphic": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Graphic"); │ │ │ │ - if (symbolizer.externalGraphic != undefined) { │ │ │ │ - this.writeNode("ExternalGraphic", symbolizer, node); │ │ │ │ - } else { │ │ │ │ - this.writeNode("Mark", symbolizer, node); │ │ │ │ - } │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - if (symbolizer.graphicOpacity != undefined) { │ │ │ │ - this.writeNode("Opacity", symbolizer.graphicOpacity, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.pointRadius != undefined) { │ │ │ │ - this.writeNode("Size", symbolizer.pointRadius * 2, node); │ │ │ │ - } else if (symbolizer.graphicWidth != undefined) { │ │ │ │ - this.writeNode("Size", symbolizer.graphicWidth, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.rotation != undefined) { │ │ │ │ - this.writeNode("Rotation", symbolizer.rotation, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ExternalGraphic": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:ExternalGraphic"); │ │ │ │ - this.writeNode( │ │ │ │ - "OnlineResource", symbolizer.externalGraphic, node │ │ │ │ - ); │ │ │ │ - var format = symbolizer.graphicFormat || │ │ │ │ - this.getGraphicFormat(symbolizer.externalGraphic); │ │ │ │ - this.writeNode("Format", format, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Mark": function(symbolizer) { │ │ │ │ - var node = this.createElementNSPlus("sld:Mark"); │ │ │ │ - if (symbolizer.graphicName) { │ │ │ │ - this.writeNode("WellKnownName", symbolizer.graphicName, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.fill !== false) { │ │ │ │ - this.writeNode("Fill", symbolizer, node); │ │ │ │ - } │ │ │ │ - if (symbolizer.stroke !== false) { │ │ │ │ - this.writeNode("Stroke", symbolizer, node); │ │ │ │ + return components; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parsePersonConstruct │ │ │ │ + * Parse Atom person constructs from an Atom entry node. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} An Atom entry or feed node. │ │ │ │ + * name - {String} Construcy name ("author" or "contributor") │ │ │ │ + * data = {Object} Object in which to put parsed persons. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * An {Object}. │ │ │ │ + */ │ │ │ │ + parsePersonConstructs: function(node, name, data) { │ │ │ │ + var persons = []; │ │ │ │ + var atomns = this.namespaces.atom; │ │ │ │ + var nodes = this.getElementsByTagNameNS(node, atomns, name); │ │ │ │ + var oAtts = ["uri", "email"]; │ │ │ │ + for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ + var value = {}; │ │ │ │ + value.name = this.getFirstChildValue( │ │ │ │ + nodes[i], │ │ │ │ + atomns, │ │ │ │ + "name", │ │ │ │ + null │ │ │ │ + ); │ │ │ │ + for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ + var attval = this.getFirstChildValue( │ │ │ │ + nodes[i], │ │ │ │ + atomns, │ │ │ │ + oAtts[j], │ │ │ │ + null); │ │ │ │ + if (attval) { │ │ │ │ + value[oAtts[j]] = attval; │ │ │ │ } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "WellKnownName": function(name) { │ │ │ │ - return this.createElementNSPlus("sld:WellKnownName", { │ │ │ │ - value: name │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Opacity": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:Opacity", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Size": function(value) { │ │ │ │ - return this.writers.sld._OGCExpression.call( │ │ │ │ - this, "sld:Size", value │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "Rotation": function(value) { │ │ │ │ - return this.createElementNSPlus("sld:Rotation", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "OnlineResource": function(href) { │ │ │ │ - return this.createElementNSPlus("sld:OnlineResource", { │ │ │ │ - attributes: { │ │ │ │ - "xlink:type": "simple", │ │ │ │ - "xlink:href": href │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Format": function(format) { │ │ │ │ - return this.createElementNSPlus("sld:Format", { │ │ │ │ - value: format │ │ │ │ - }); │ │ │ │ } │ │ │ │ + persons.push(value); │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.Filter.v1_0_0.prototype.writers), │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SLD.v1" │ │ │ │ + if (persons.length > 0) { │ │ │ │ + data[name + "s"] = persons; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Atom" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/SLD/v1.js │ │ │ │ - * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.SLD.v1_0_0 │ │ │ │ - * Write SLD version 1.0.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.SLD.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.SLD.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.SLD.v1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.0.0 │ │ │ │ - */ │ │ │ │ - VERSION: "1.0.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/sld │ │ │ │ - * http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.SLD.v1_0_0 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.SLD> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/SLDSelect.js │ │ │ │ + OpenLayers/Format/GeoRSS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Layer/WMS.js │ │ │ │ - * @requires OpenLayers/Handler/RegularPolygon.js │ │ │ │ - * @requires OpenLayers/Handler/Polygon.js │ │ │ │ - * @requires OpenLayers/Handler/Path.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ - * @requires OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.SLDSelect │ │ │ │ - * Perform selections on WMS layers using Styled Layer Descriptor (SLD) │ │ │ │ + * Class: OpenLayers.Format.GeoRSS │ │ │ │ + * Read/write GeoRSS parser. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.GeoRSS> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.SLDSelect = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * selected - Triggered when a selection occurs. Listeners receive an │ │ │ │ - * event with *filters* and *layer* properties. Filters will be an │ │ │ │ - * array of OpenLayers.Filter objects created in order to perform │ │ │ │ - * the particular selection. │ │ │ │ - */ │ │ │ │ +OpenLayers.Format.GeoRSS = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: clearOnDeactivate │ │ │ │ - * {Boolean} Should the selection be cleared when the control is │ │ │ │ - * deactivated. Default value is false. │ │ │ │ + * APIProperty: rssns │ │ │ │ + * {String} RSS namespace to use. Defaults to │ │ │ │ + * "http://backend.userland.com/rss2" │ │ │ │ */ │ │ │ │ - clearOnDeactivate: false, │ │ │ │ + rssns: "http://backend.userland.com/rss2", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * {Array(<OpenLayers.Layer.WMS>)} The WMS layers this control will work │ │ │ │ - * on. │ │ │ │ + * APIProperty: featurens │ │ │ │ + * {String} Feature Attributes namespace. Defaults to │ │ │ │ + * "http://mapserver.gis.umn.edu/mapserver" │ │ │ │ */ │ │ │ │ - layers: null, │ │ │ │ + featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: callbacks │ │ │ │ - * {Object} The functions that are sent to the handler for callback │ │ │ │ + * APIProperty: georssns │ │ │ │ + * {String} GeoRSS namespace to use. Defaults to │ │ │ │ + * "http://www.georss.org/georss" │ │ │ │ */ │ │ │ │ - callbacks: null, │ │ │ │ + georssns: "http://www.georss.org/georss", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: selectionSymbolizer │ │ │ │ - * {Object} Determines the styling of the selected objects. Default is │ │ │ │ - * a selection in red. │ │ │ │ + * APIProperty: geons │ │ │ │ + * {String} W3C Geo namespace to use. Defaults to │ │ │ │ + * "http://www.w3.org/2003/01/geo/wgs84_pos#" │ │ │ │ */ │ │ │ │ - selectionSymbolizer: { │ │ │ │ - 'Polygon': { │ │ │ │ - fillColor: '#FF0000', │ │ │ │ - stroke: false │ │ │ │ - }, │ │ │ │ - 'Line': { │ │ │ │ - strokeColor: '#FF0000', │ │ │ │ - strokeWidth: 2 │ │ │ │ - }, │ │ │ │ - 'Point': { │ │ │ │ - graphicName: 'square', │ │ │ │ - fillColor: '#FF0000', │ │ │ │ - pointRadius: 5 │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + geons: "http://www.w3.org/2003/01/geo/wgs84_pos#", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layerOptions │ │ │ │ - * {Object} The options to apply to the selection layer, by default the │ │ │ │ - * selection layer will be kept out of the layer switcher. │ │ │ │ + * APIProperty: featureTitle │ │ │ │ + * {String} Default title for features. Defaults to "Untitled" │ │ │ │ */ │ │ │ │ - layerOptions: null, │ │ │ │ + featureTitle: "Untitled", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the control's handler │ │ │ │ + * APIProperty: featureDescription │ │ │ │ + * {String} Default description for features. Defaults to "No Description" │ │ │ │ */ │ │ │ │ + featureDescription: "No Description", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: sketchStyle │ │ │ │ - * {<OpenLayers.Style>|Object} Style or symbolizer to use for the sketch │ │ │ │ - * handler. The recommended way of styling the sketch layer, however, is │ │ │ │ - * to configure an <OpenLayers.StyleMap> in the layerOptions of the │ │ │ │ - * <handlerOptions>: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Control.SLDSelect(OpenLayers.Handler.Path, { │ │ │ │ - * handlerOptions: { │ │ │ │ - * layerOptions: { │ │ │ │ - * styleMap: new OpenLayers.StyleMap({ │ │ │ │ - * "default": {strokeColor: "yellow"} │ │ │ │ - * }) │ │ │ │ - * } │ │ │ │ - * } │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ + * Property: gmlParse │ │ │ │ + * {Object} GML Format object for parsing features │ │ │ │ + * Non-API and only created if necessary │ │ │ │ */ │ │ │ │ - sketchStyle: null, │ │ │ │ + gmlParser: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: wfsCache │ │ │ │ - * {Object} Cache to use for storing parsed results from │ │ │ │ - * <OpenLayers.Format.WFSDescribeFeatureType.read>. If not provided, │ │ │ │ - * these will be cached on the prototype. │ │ │ │ + * APIProperty: xy │ │ │ │ + * {Boolean} Order of the GML coordinate: true:(x,y) or false:(y,x) │ │ │ │ + * For GeoRSS the default is (y,x), therefore: false │ │ │ │ */ │ │ │ │ - wfsCache: {}, │ │ │ │ + xy: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layerCache │ │ │ │ - * {Object} Cache to use for storing references to the selection layers. │ │ │ │ - * Normally each source layer will have exactly 1 selection layer of │ │ │ │ - * type OpenLayers.Layer.WMS. If not provided, layers will │ │ │ │ - * be cached on the prototype. Note that if <clearOnDeactivate> is │ │ │ │ - * true, the layer will no longer be cached after deactivating the │ │ │ │ - * control. │ │ │ │ + * Constructor: OpenLayers.Format.GeoRSS │ │ │ │ + * Create a new parser for GeoRSS. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - layerCache: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.SLDSelect │ │ │ │ - * Create a new control for selecting features in WMS layers using │ │ │ │ - * Styled Layer Descriptor (SLD). │ │ │ │ + * Method: createGeometryFromItem │ │ │ │ + * Return a geometry from a GeoRSS Item. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * handler - {<OpenLayers.Class>} A sketch handler class. This determines │ │ │ │ - * the type of selection, e.g. box (<OpenLayers.Handler.Box>), point │ │ │ │ - * (<OpenLayers.Handler.Point>), path (<OpenLayers.Handler.Path>) or │ │ │ │ - * polygon (<OpenLayers.Handler.Polygon>) selection. To use circle │ │ │ │ - * type selection, use <OpenLayers.Handler.RegularPolygon> and pass │ │ │ │ - * the number of desired sides (e.g. 40) as "sides" property to the │ │ │ │ - * <handlerOptions>. │ │ │ │ - * options - {Object} An object containing all configuration properties for │ │ │ │ - * the control. │ │ │ │ + * item - {DOMElement} A GeoRSS item node. │ │ │ │ * │ │ │ │ - * Valid options: │ │ │ │ - * layers - Array({<OpenLayers.Layer.WMS>}) The layers to perform the │ │ │ │ - * selection on. │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry representing the node. │ │ │ │ */ │ │ │ │ - initialize: function(handler, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + createGeometryFromItem: function(item) { │ │ │ │ + var point = this.getElementsByTagNameNS(item, this.georssns, "point"); │ │ │ │ + var lat = this.getElementsByTagNameNS(item, this.geons, 'lat'); │ │ │ │ + var lon = this.getElementsByTagNameNS(item, this.geons, 'long'); │ │ │ │ │ │ │ │ - this.callbacks = OpenLayers.Util.extend({ │ │ │ │ - done: this.select, │ │ │ │ - click: this.select │ │ │ │ - }, this.callbacks); │ │ │ │ - this.handlerOptions = this.handlerOptions || {}; │ │ │ │ - this.layerOptions = OpenLayers.Util.applyDefaults(this.layerOptions, { │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - tileOptions: { │ │ │ │ - maxGetUrlLength: 2048 │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (this.sketchStyle) { │ │ │ │ - this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults( │ │ │ │ - this.handlerOptions.layerOptions, { │ │ │ │ - styleMap: new OpenLayers.StyleMap({ │ │ │ │ - "default": this.sketchStyle │ │ │ │ - }) │ │ │ │ + var line = this.getElementsByTagNameNS(item, │ │ │ │ + this.georssns, │ │ │ │ + "line"); │ │ │ │ + var polygon = this.getElementsByTagNameNS(item, │ │ │ │ + this.georssns, │ │ │ │ + "polygon"); │ │ │ │ + var where = this.getElementsByTagNameNS(item, │ │ │ │ + this.georssns, │ │ │ │ + "where"); │ │ │ │ + var box = this.getElementsByTagNameNS(item, │ │ │ │ + this.georssns, │ │ │ │ + "box"); │ │ │ │ + │ │ │ │ + if (point.length > 0 || (lat.length > 0 && lon.length > 0)) { │ │ │ │ + var location; │ │ │ │ + if (point.length > 0) { │ │ │ │ + location = OpenLayers.String.trim( │ │ │ │ + point[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ + if (location.length != 2) { │ │ │ │ + location = OpenLayers.String.trim( │ │ │ │ + point[0].firstChild.nodeValue).split(/\s*,\s*/); │ │ │ │ } │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.handler = new handler(this, this.callbacks, this.handlerOptions); │ │ │ │ - }, │ │ │ │ + } else { │ │ │ │ + location = [parseFloat(lat[0].firstChild.nodeValue), │ │ │ │ + parseFloat(lon[0].firstChild.nodeValue) │ │ │ │ + ]; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Take care of things that are not handled in superclass. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var key in this.layerCache) { │ │ │ │ - delete this.layerCache[key]; │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(location[1], location[0]); │ │ │ │ + │ │ │ │ + } else if (line.length > 0) { │ │ │ │ + var coords = OpenLayers.String.trim(this.getChildValue(line[0])).split(/\s+/); │ │ │ │ + var components = []; │ │ │ │ + var point; │ │ │ │ + for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ + components.push(point); │ │ │ │ + } │ │ │ │ + geometry = new OpenLayers.Geometry.LineString(components); │ │ │ │ + } else if (polygon.length > 0) { │ │ │ │ + var coords = OpenLayers.String.trim(this.getChildValue(polygon[0])).split(/\s+/); │ │ │ │ + var components = []; │ │ │ │ + var point; │ │ │ │ + for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ + components.push(point); │ │ │ │ + } │ │ │ │ + geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]); │ │ │ │ + } else if (where.length > 0) { │ │ │ │ + if (!this.gmlParser) { │ │ │ │ + this.gmlParser = new OpenLayers.Format.GML({ │ │ │ │ + 'xy': this.xy │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + var feature = this.gmlParser.parseFeature(where[0]); │ │ │ │ + geometry = feature.geometry; │ │ │ │ + } else if (box.length > 0) { │ │ │ │ + var coords = OpenLayers.String.trim(box[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ + var components = []; │ │ │ │ + var point; │ │ │ │ + if (coords.length > 3) { │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[1], coords[2]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[3], coords[2]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[3], coords[0]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ + components.push(point); │ │ │ │ + } │ │ │ │ + geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]); │ │ │ │ } │ │ │ │ - for (var key in this.wfsCache) { │ │ │ │ - delete this.wfsCache[key]; │ │ │ │ + │ │ │ │ + if (geometry && this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: coupleLayerVisiblity │ │ │ │ - * Couple the selection layer and the source layer with respect to │ │ │ │ - * layer visibility. So if the source layer is turned off, the │ │ │ │ - * selection layer is also turned off. │ │ │ │ - * │ │ │ │ - * Context: │ │ │ │ - * - {<OpenLayers.Layer>} │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ - */ │ │ │ │ - coupleLayerVisiblity: function(evt) { │ │ │ │ - this.setVisibility(evt.object.getVisibility()); │ │ │ │ + return geometry; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createSelectionLayer │ │ │ │ - * Creates a "clone" from the source layer in which the selection can │ │ │ │ - * be drawn. This ensures both the source layer and the selection are │ │ │ │ - * visible and not only the selection. │ │ │ │ + * Method: createFeatureFromItem │ │ │ │ + * Return a feature from a GeoRSS Item. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * source - {<OpenLayers.Layer.WMS>} The source layer on which the selection │ │ │ │ - * is performed. │ │ │ │ + * item - {DOMElement} A GeoRSS item node. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Layer.WMS>} A WMS layer with maxGetUrlLength configured to 2048 │ │ │ │ - * since SLD selections can easily get quite long. │ │ │ │ + * {<OpenLayers.Feature.Vector>} A feature representing the item. │ │ │ │ */ │ │ │ │ - createSelectionLayer: function(source) { │ │ │ │ - // check if we already have a selection layer for the source layer │ │ │ │ - var selectionLayer; │ │ │ │ - if (!this.layerCache[source.id]) { │ │ │ │ - selectionLayer = new OpenLayers.Layer.WMS(source.name, │ │ │ │ - source.url, source.params, │ │ │ │ - OpenLayers.Util.applyDefaults( │ │ │ │ - this.layerOptions, │ │ │ │ - source.getOptions()) │ │ │ │ - ); │ │ │ │ - this.layerCache[source.id] = selectionLayer; │ │ │ │ - // make sure the layers are coupled wrt visibility, but only │ │ │ │ - // if they are not displayed in the layer switcher, because in │ │ │ │ - // that case the user cannot control visibility. │ │ │ │ - if (this.layerOptions.displayInLayerSwitcher === false) { │ │ │ │ - source.events.on({ │ │ │ │ - "visibilitychanged": this.coupleLayerVisiblity, │ │ │ │ - scope: selectionLayer │ │ │ │ - }); │ │ │ │ + createFeatureFromItem: function(item) { │ │ │ │ + var geometry = this.createGeometryFromItem(item); │ │ │ │ + │ │ │ │ + /* Provide defaults for title and description */ │ │ │ │ + var title = this._getChildValue(item, "*", "title", this.featureTitle); │ │ │ │ + │ │ │ │ + /* First try RSS descriptions, then Atom summaries */ │ │ │ │ + var description = this._getChildValue( │ │ │ │ + item, "*", "description", │ │ │ │ + this._getChildValue(item, "*", "content", │ │ │ │ + this._getChildValue(item, "*", "summary", this.featureDescription))); │ │ │ │ + │ │ │ │ + /* If no link URL is found in the first child node, try the │ │ │ │ + href attribute */ │ │ │ │ + var link = this._getChildValue(item, "*", "link"); │ │ │ │ + if (!link) { │ │ │ │ + try { │ │ │ │ + link = this.getElementsByTagNameNS(item, "*", "link")[0].getAttribute("href"); │ │ │ │ + } catch (e) { │ │ │ │ + link = null; │ │ │ │ } │ │ │ │ - this.map.addLayer(selectionLayer); │ │ │ │ - } else { │ │ │ │ - selectionLayer = this.layerCache[source.id]; │ │ │ │ } │ │ │ │ - return selectionLayer; │ │ │ │ + │ │ │ │ + var id = this._getChildValue(item, "*", "id", null); │ │ │ │ + │ │ │ │ + var data = { │ │ │ │ + "title": title, │ │ │ │ + "description": description, │ │ │ │ + "link": link │ │ │ │ + }; │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, data); │ │ │ │ + feature.fid = id; │ │ │ │ + return feature; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createSLD │ │ │ │ - * Create the SLD document for the layer using the supplied filters. │ │ │ │ + * Method: _getChildValue │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.WMS>} │ │ │ │ - * filters - Array({<OpenLayers.Filter>}) The filters to be applied. │ │ │ │ - * geometryAttributes - Array({Object}) The geometry attributes of the │ │ │ │ - * layer. │ │ │ │ + * node - {DOMElement} │ │ │ │ + * nsuri - {String} Child node namespace uri ("*" for any). │ │ │ │ + * name - {String} Child node name. │ │ │ │ + * def - {String} Optional string default to return if no child found. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} The SLD document generated as a string. │ │ │ │ - */ │ │ │ │ - createSLD: function(layer, filters, geometryAttributes) { │ │ │ │ - var sld = { │ │ │ │ - version: "1.0.0", │ │ │ │ - namedLayers: {} │ │ │ │ - }; │ │ │ │ - var layerNames = [layer.params.LAYERS].join(",").split(","); │ │ │ │ - for (var i = 0, len = layerNames.length; i < len; i++) { │ │ │ │ - var name = layerNames[i]; │ │ │ │ - sld.namedLayers[name] = { │ │ │ │ - name: name, │ │ │ │ - userStyles: [] │ │ │ │ - }; │ │ │ │ - var symbolizer = this.selectionSymbolizer; │ │ │ │ - var geometryAttribute = geometryAttributes[i]; │ │ │ │ - if (geometryAttribute.type.indexOf('Polygon') >= 0) { │ │ │ │ - symbolizer = { │ │ │ │ - Polygon: this.selectionSymbolizer['Polygon'] │ │ │ │ - }; │ │ │ │ - } else if (geometryAttribute.type.indexOf('LineString') >= 0) { │ │ │ │ - symbolizer = { │ │ │ │ - Line: this.selectionSymbolizer['Line'] │ │ │ │ - }; │ │ │ │ - } else if (geometryAttribute.type.indexOf('Point') >= 0) { │ │ │ │ - symbolizer = { │ │ │ │ - Point: this.selectionSymbolizer['Point'] │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - var filter = filters[i]; │ │ │ │ - sld.namedLayers[name].userStyles.push({ │ │ │ │ - name: 'default', │ │ │ │ - rules: [ │ │ │ │ - new OpenLayers.Rule({ │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - filter: filter, │ │ │ │ - maxScaleDenominator: layer.options.minScale │ │ │ │ - }) │ │ │ │ - ] │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Format.SLD({ │ │ │ │ - srsName: this.map.getProjection() │ │ │ │ - }).write(sld); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseDescribeLayer │ │ │ │ - * Parse the SLD WMS DescribeLayer response and issue the corresponding │ │ │ │ - * WFS DescribeFeatureType request │ │ │ │ - * │ │ │ │ - * request - {XMLHttpRequest} The request object. │ │ │ │ + * {String} The value of the first child with the given tag name. Returns │ │ │ │ + * default value or empty string if none found. │ │ │ │ */ │ │ │ │ - parseDescribeLayer: function(request) { │ │ │ │ - var format = new OpenLayers.Format.WMSDescribeLayer(); │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - var describeLayer = format.read(doc); │ │ │ │ - var typeNames = []; │ │ │ │ - var url = null; │ │ │ │ - for (var i = 0, len = describeLayer.length; i < len; i++) { │ │ │ │ - // perform a WFS DescribeFeatureType request │ │ │ │ - if (describeLayer[i].owsType == "WFS") { │ │ │ │ - typeNames.push(describeLayer[i].typeName); │ │ │ │ - url = describeLayer[i].owsURL; │ │ │ │ - } │ │ │ │ + _getChildValue: function(node, nsuri, name, def) { │ │ │ │ + var value; │ │ │ │ + var eles = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ + if (eles && eles[0] && eles[0].firstChild && │ │ │ │ + eles[0].firstChild.nodeValue) { │ │ │ │ + value = this.getChildValue(eles[0]); │ │ │ │ + } else { │ │ │ │ + value = (def == undefined) ? "" : def; │ │ │ │ } │ │ │ │ - var options = { │ │ │ │ - url: url, │ │ │ │ - params: { │ │ │ │ - SERVICE: "WFS", │ │ │ │ - TYPENAME: typeNames.toString(), │ │ │ │ - REQUEST: "DescribeFeatureType", │ │ │ │ - VERSION: "1.0.0" │ │ │ │ - }, │ │ │ │ - callback: function(request) { │ │ │ │ - var format = new OpenLayers.Format.WFSDescribeFeatureType(); │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - var describeFeatureType = format.read(doc); │ │ │ │ - this.control.wfsCache[this.layer.id] = describeFeatureType; │ │ │ │ - this.control._queue && this.control.applySelection(); │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }; │ │ │ │ - OpenLayers.Request.GET(options); │ │ │ │ + return value; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getGeometryAttributes │ │ │ │ - * Look up the geometry attributes from the WFS DescribeFeatureType response │ │ │ │ + * APIMethod: read │ │ │ │ + * Return a list of features from a GeoRSS doc │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.WMS>} The layer for which to look up the │ │ │ │ - * geometry attributes. │ │ │ │ + * doc - {Element} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * Array({Object}) Array of geometry attributes │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ */ │ │ │ │ - getGeometryAttributes: function(layer) { │ │ │ │ - var result = []; │ │ │ │ - var cache = this.wfsCache[layer.id]; │ │ │ │ - for (var i = 0, len = cache.featureTypes.length; i < len; i++) { │ │ │ │ - var typeName = cache.featureTypes[i]; │ │ │ │ - var properties = typeName.properties; │ │ │ │ - for (var j = 0, lenj = properties.length; j < lenj; j++) { │ │ │ │ - var property = properties[j]; │ │ │ │ - var type = property.type; │ │ │ │ - if ((type.indexOf('LineString') >= 0) || │ │ │ │ - (type.indexOf('GeometryAssociationType') >= 0) || │ │ │ │ - (type.indexOf('GeometryPropertyType') >= 0) || │ │ │ │ - (type.indexOf('Point') >= 0) || │ │ │ │ - (type.indexOf('Polygon') >= 0)) { │ │ │ │ - result.push(property); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ } │ │ │ │ - return result; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the control. Activating the control will perform a SLD WMS │ │ │ │ - * DescribeLayer request followed by a WFS DescribeFeatureType request │ │ │ │ - * so that the proper symbolizers can be chosen based on the geometry │ │ │ │ - * type. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - var layer = this.layers[i]; │ │ │ │ - if (layer && !this.wfsCache[layer.id]) { │ │ │ │ - var options = { │ │ │ │ - url: layer.url, │ │ │ │ - params: { │ │ │ │ - SERVICE: "WMS", │ │ │ │ - VERSION: layer.params.VERSION, │ │ │ │ - LAYERS: layer.params.LAYERS, │ │ │ │ - REQUEST: "DescribeLayer" │ │ │ │ - }, │ │ │ │ - callback: this.parseDescribeLayer, │ │ │ │ - scope: { │ │ │ │ - layer: layer, │ │ │ │ - control: this │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - OpenLayers.Request.GET(options); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /* Try RSS items first, then Atom entries */ │ │ │ │ + var itemlist = null; │ │ │ │ + itemlist = this.getElementsByTagNameNS(doc, '*', 'item'); │ │ │ │ + if (itemlist.length == 0) { │ │ │ │ + itemlist = this.getElementsByTagNameNS(doc, '*', 'entry'); │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the control. If clearOnDeactivate is true, remove the │ │ │ │ - * selection layer(s). │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - var layer = this.layers[i]; │ │ │ │ - if (layer && this.clearOnDeactivate === true) { │ │ │ │ - var layerCache = this.layerCache; │ │ │ │ - var selectionLayer = layerCache[layer.id]; │ │ │ │ - if (selectionLayer) { │ │ │ │ - layer.events.un({ │ │ │ │ - "visibilitychanged": this.coupleLayerVisiblity, │ │ │ │ - scope: selectionLayer │ │ │ │ - }); │ │ │ │ - selectionLayer.destroy(); │ │ │ │ - delete layerCache[layer.id]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var numItems = itemlist.length; │ │ │ │ + var features = new Array(numItems); │ │ │ │ + for (var i = 0; i < numItems; i++) { │ │ │ │ + features[i] = this.createFeatureFromItem(itemlist[i]); │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + return features; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * APIMethod: setLayers │ │ │ │ - * Set the layers on which the selection should be performed. Call the │ │ │ │ - * setLayers method if the layer(s) to be used change and the same │ │ │ │ - * control should be used on a new set of layers. │ │ │ │ - * If the control is already active, it will be active after the new │ │ │ │ - * set of layers is set. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layers - {Array(<OpenLayers.Layer.WMS>)} The new set of layers on which │ │ │ │ - * the selection should be performed. │ │ │ │ + * APIMethod: write │ │ │ │ + * Accept Feature Collection, and return a string. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} List of features to serialize into a string. │ │ │ │ */ │ │ │ │ - setLayers: function(layers) { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layers = layers; │ │ │ │ - this.activate(); │ │ │ │ + write: function(features) { │ │ │ │ + var georss; │ │ │ │ + if (OpenLayers.Util.isArray(features)) { │ │ │ │ + georss = this.createElementNS(this.rssns, "rss"); │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + georss.appendChild(this.createFeatureXML(features[i])); │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - this.layers = layers; │ │ │ │ + georss = this.createFeatureXML(features); │ │ │ │ } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [georss]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Function: createFilter │ │ │ │ - * Create the filter to be used in the SLD. │ │ │ │ - * │ │ │ │ + * Method: createFeatureXML │ │ │ │ + * Accept an <OpenLayers.Feature.Vector>, and build a geometry for it. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometryAttribute - {Object} Used to get the name of the geometry │ │ │ │ - * attribute which is needed for constructing the spatial filter. │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The geometry to use. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Filter.Spatial>} The spatial filter created. │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - createFilter: function(geometryAttribute, geometry) { │ │ │ │ - var filter = null; │ │ │ │ - if (this.handler instanceof OpenLayers.Handler.RegularPolygon) { │ │ │ │ - // box │ │ │ │ - if (this.handler.irregular === true) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry.getBounds() │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } else if (this.handler instanceof OpenLayers.Handler.Polygon) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }); │ │ │ │ - } else if (this.handler instanceof OpenLayers.Handler.Path) { │ │ │ │ - // if source layer is point based, use DWITHIN instead │ │ │ │ - if (geometryAttribute.type.indexOf('Point') >= 0) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - distance: this.map.getExtent().getWidth() * 0.01, │ │ │ │ - distanceUnits: this.map.getUnits(), │ │ │ │ - value: geometry │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }); │ │ │ │ + createFeatureXML: function(feature) { │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + var featureNode = this.createElementNS(this.rssns, "item"); │ │ │ │ + var titleNode = this.createElementNS(this.rssns, "title"); │ │ │ │ + titleNode.appendChild(this.createTextNode(feature.attributes.title ? feature.attributes.title : "")); │ │ │ │ + var descNode = this.createElementNS(this.rssns, "description"); │ │ │ │ + descNode.appendChild(this.createTextNode(feature.attributes.description ? feature.attributes.description : "")); │ │ │ │ + featureNode.appendChild(titleNode); │ │ │ │ + featureNode.appendChild(descNode); │ │ │ │ + if (feature.attributes.link) { │ │ │ │ + var linkNode = this.createElementNS(this.rssns, "link"); │ │ │ │ + linkNode.appendChild(this.createTextNode(feature.attributes.link)); │ │ │ │ + featureNode.appendChild(linkNode); │ │ │ │ + } │ │ │ │ + for (var attr in feature.attributes) { │ │ │ │ + if (attr == "link" || attr == "title" || attr == "description") { │ │ │ │ + continue; │ │ │ │ } │ │ │ │ - } else if (this.handler instanceof OpenLayers.Handler.Click) { │ │ │ │ - if (geometryAttribute.type.indexOf('Polygon') >= 0) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - distance: this.map.getExtent().getWidth() * 0.01, │ │ │ │ - distanceUnits: this.map.getUnits(), │ │ │ │ - value: geometry │ │ │ │ - }); │ │ │ │ + var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ + var nodename = attr; │ │ │ │ + if (attr.search(":") != -1) { │ │ │ │ + nodename = attr.split(":")[1]; │ │ │ │ } │ │ │ │ + var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ + attrContainer.appendChild(attrText); │ │ │ │ + featureNode.appendChild(attrContainer); │ │ │ │ } │ │ │ │ - return filter; │ │ │ │ + featureNode.appendChild(geometryNode); │ │ │ │ + return featureNode; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: select │ │ │ │ - * When the handler is done, use SLD_BODY on the selection layer to │ │ │ │ - * display the selection in the map. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: buildGeometryNode │ │ │ │ + * builds a GeoRSS node with a given geometry │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {Object} or {<OpenLayers.Geometry>} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A gml node. │ │ │ │ */ │ │ │ │ - select: function(geometry) { │ │ │ │ - this._queue = function() { │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - var layer = this.layers[i]; │ │ │ │ - var geometryAttributes = this.getGeometryAttributes(layer); │ │ │ │ - var filters = []; │ │ │ │ - for (var j = 0, lenj = geometryAttributes.length; j < lenj; j++) { │ │ │ │ - var geometryAttribute = geometryAttributes[j]; │ │ │ │ - if (geometryAttribute !== null) { │ │ │ │ - // from the click handler we will not get an actual │ │ │ │ - // geometry so transform │ │ │ │ - if (!(geometry instanceof OpenLayers.Geometry)) { │ │ │ │ - var point = this.map.getLonLatFromPixel( │ │ │ │ - geometry.xy); │ │ │ │ - geometry = new OpenLayers.Geometry.Point( │ │ │ │ - point.lon, point.lat); │ │ │ │ - } │ │ │ │ - var filter = this.createFilter(geometryAttribute, │ │ │ │ - geometry); │ │ │ │ - if (filter !== null) { │ │ │ │ - filters.push(filter); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - var selectionLayer = this.createSelectionLayer(layer); │ │ │ │ - │ │ │ │ - this.events.triggerEvent("selected", { │ │ │ │ - layer: layer, │ │ │ │ - filters: filters │ │ │ │ - }); │ │ │ │ + buildGeometryNode: function(geometry) { │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + geometry.transform(this.internalProjection, │ │ │ │ + this.externalProjection); │ │ │ │ + } │ │ │ │ + var node; │ │ │ │ + // match Polygon │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") { │ │ │ │ + node = this.createElementNS(this.georssns, 'georss:polygon'); │ │ │ │ │ │ │ │ - var sld = this.createSLD(layer, filters, geometryAttributes); │ │ │ │ + node.appendChild(this.buildCoordinatesNode(geometry.components[0])); │ │ │ │ + } │ │ │ │ + // match LineString │ │ │ │ + else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") { │ │ │ │ + node = this.createElementNS(this.georssns, 'georss:line'); │ │ │ │ │ │ │ │ - selectionLayer.mergeNewParams({ │ │ │ │ - SLD_BODY: sld │ │ │ │ - }); │ │ │ │ - delete this._queue; │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - this.applySelection(); │ │ │ │ + node.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + } │ │ │ │ + // match Point │ │ │ │ + else if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + node = this.createElementNS(this.georssns, 'georss:point'); │ │ │ │ + node.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + } else { │ │ │ │ + throw "Couldn't parse " + geometry.CLASS_NAME; │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: applySelection │ │ │ │ - * Checks if all required wfs data is cached, and applies the selection │ │ │ │ + /** │ │ │ │ + * Method: buildCoordinatesNode │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - applySelection: function() { │ │ │ │ - var canApply = true; │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - if (!this.wfsCache[this.layers[i].id]) { │ │ │ │ - canApply = false; │ │ │ │ - break; │ │ │ │ + buildCoordinatesNode: function(geometry) { │ │ │ │ + var points = null; │ │ │ │ + │ │ │ │ + if (geometry.components) { │ │ │ │ + points = geometry.components; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var path; │ │ │ │ + if (points) { │ │ │ │ + var numPoints = points.length; │ │ │ │ + var parts = new Array(numPoints); │ │ │ │ + for (var i = 0; i < numPoints; i++) { │ │ │ │ + parts[i] = points[i].y + " " + points[i].x; │ │ │ │ } │ │ │ │ + path = parts.join(" "); │ │ │ │ + } else { │ │ │ │ + path = geometry.y + " " + geometry.x; │ │ │ │ } │ │ │ │ - canApply && this._queue.call(this); │ │ │ │ + return this.createTextNode(path); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.SLDSelect" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.GeoRSS" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Button.js │ │ │ │ + OpenLayers/Format/WMSCapabilities.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Button │ │ │ │ - * The Button control is a very simple push-button, for use with │ │ │ │ - * <OpenLayers.Control.Panel>. │ │ │ │ - * When clicked, the function trigger() is executed. │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities │ │ │ │ + * Read WMS Capabilities. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - * │ │ │ │ - * 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.Format.XML.VersionedOGC> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Button = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.WMSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Property: type │ │ │ │ - * {Integer} OpenLayers.Control.TYPE_BUTTON. │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.1.1". │ │ │ │ */ │ │ │ │ - type: OpenLayers.Control.TYPE_BUTTON, │ │ │ │ + defaultVersion: "1.1.1", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: trigger │ │ │ │ - * Called by a control panel when the button is clicked. │ │ │ │ + * APIProperty: profile │ │ │ │ + * {String} If provided, use a custom profile. │ │ │ │ + * │ │ │ │ + * Currently supported profiles: │ │ │ │ + * - WMSC - parses vendor specific capabilities for WMS-C. │ │ │ │ */ │ │ │ │ - trigger: function() {}, │ │ │ │ + profile: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMSCapabilities │ │ │ │ + * Create a new parser for WMS capabilities. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return a list of layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named layers. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Button" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/NavigationHistory.js │ │ │ │ + OpenLayers/Format/CSWGetDomain.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Control/Button.js │ │ │ │ + * @requires OpenLayers/Format.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.NavigationHistory │ │ │ │ - * A navigation history control. This is a meta-control, that creates two │ │ │ │ - * dependent controls: <previous> and <next>. Call the trigger method │ │ │ │ - * on the <previous> and <next> 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. │ │ │ │ + * Class: OpenLayers.Format.CSWGetDomain │ │ │ │ + * Default version is 2.0.2. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Format>} A CSWGetDomain format of the given version. │ │ │ │ */ │ │ │ │ -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 │ │ │ │ - * {<OpenLayers.Control>} 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 <previous> control. │ │ │ │ - */ │ │ │ │ - previousOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: next │ │ │ │ - * {<OpenLayers.Control>} 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 <next> 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, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ - */ │ │ │ │ - autoActivate: true, │ │ │ │ +OpenLayers.Format.CSWGetDomain = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults( │ │ │ │ + options, OpenLayers.Format.CSWGetDomain.DEFAULTS │ │ │ │ + ); │ │ │ │ + var cls = OpenLayers.Format.CSWGetDomain["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported CSWGetDomain version: " + options.version; │ │ │ │ + } │ │ │ │ + return new cls(options); │ │ │ │ +}; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: clearOnDeactivate │ │ │ │ - * {Boolean} Clear the history when the control is deactivated. Default │ │ │ │ - * is false. │ │ │ │ - */ │ │ │ │ - clearOnDeactivate: false, │ │ │ │ +/** │ │ │ │ + * Constant: DEFAULTS │ │ │ │ + * {Object} Default properties for the CSWGetDomain format. │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.CSWGetDomain.DEFAULTS = { │ │ │ │ + "version": "2.0.2" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/Context.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: registry │ │ │ │ - * {Object} An object with keys corresponding to event types. Values │ │ │ │ - * are functions that return an object representing the current state. │ │ │ │ - */ │ │ │ │ - registry: null, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: nextStack │ │ │ │ - * {Array} Array of items in the history. │ │ │ │ - */ │ │ │ │ - nextStack: null, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: previousStack │ │ │ │ - * {Array} List of items in the history. First item represents the current │ │ │ │ - * state. │ │ │ │ - */ │ │ │ │ - previousStack: null, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.Context │ │ │ │ + * Base class for both Format.WMC and Format.OWSContext │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.Context = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: listeners │ │ │ │ - * {Object} An object containing properties corresponding to event types. │ │ │ │ - * This object is used to configure the control and is modified on │ │ │ │ - * construction. │ │ │ │ + * Property: layerOptions │ │ │ │ + * {Object} Default options for layers created by the parser. These │ │ │ │ + * options are overridden by the options which are read from the │ │ │ │ + * capabilities document. │ │ │ │ */ │ │ │ │ - listeners: null, │ │ │ │ + layerOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: restoring │ │ │ │ - * {Boolean} Currently restoring a history state. This is set to true │ │ │ │ - * before calling restore and set to false after restore returns. │ │ │ │ + * Property: layerParams │ │ │ │ + * {Object} Default parameters for layers created by the parser. This │ │ │ │ + * can be used e.g. to override DEFAULT_PARAMS for │ │ │ │ + * OpenLayers.Layer.WMS. │ │ │ │ */ │ │ │ │ - restoring: false, │ │ │ │ + layerParams: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.NavigationHistory │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Format.Context │ │ │ │ + * Create a new parser for Context documents. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - this.registry = OpenLayers.Util.extend({ │ │ │ │ - "moveend": this.getState │ │ │ │ - }, this.registry); │ │ │ │ - │ │ │ │ - var previousOptions = { │ │ │ │ - trigger: OpenLayers.Function.bind(this.previousTrigger, this), │ │ │ │ - displayClass: 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 + " " + this.displayClass + "Next" │ │ │ │ - }; │ │ │ │ - OpenLayers.Util.extend(nextOptions, this.nextOptions); │ │ │ │ - this.next = new OpenLayers.Control.Button(nextOptions); │ │ │ │ - │ │ │ │ - this.clear(); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onPreviousChange │ │ │ │ - * Called when the previous history stack changes. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read Context data from a string, and return an object with map │ │ │ │ + * properties and a list of layers. │ │ │ │ * │ │ │ │ * 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. │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * options - {Object} The options object must contain a map property. If │ │ │ │ + * the map property is a string, it must be the id of a dom element │ │ │ │ + * where the new map will be placed. If the map property is an │ │ │ │ + * <OpenLayers.Map>, the layers from the context document will be added │ │ │ │ + * to the map. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Map>} A map based on the context. │ │ │ │ */ │ │ │ │ - onPreviousChange: function(state, length) { │ │ │ │ - if (state && !this.previous.active) { │ │ │ │ - this.previous.activate(); │ │ │ │ - } else if (!state && this.previous.active) { │ │ │ │ - this.previous.deactivate(); │ │ │ │ + read: function(data, options) { │ │ │ │ + var context = OpenLayers.Format.XML.VersionedOGC.prototype.read.apply(this, │ │ │ │ + arguments); │ │ │ │ + var map; │ │ │ │ + if (options && options.map) { │ │ │ │ + this.context = context; │ │ │ │ + if (options.map instanceof OpenLayers.Map) { │ │ │ │ + map = this.mergeContextToMap(context, options.map); │ │ │ │ + } else { │ │ │ │ + var mapOptions = options.map; │ │ │ │ + if (OpenLayers.Util.isElement(mapOptions) || │ │ │ │ + typeof mapOptions == "string") { │ │ │ │ + // we assume mapOptions references a div │ │ │ │ + // element │ │ │ │ + mapOptions = { │ │ │ │ + div: mapOptions │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + map = this.contextToMap(context, mapOptions); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // not documented as part of the API, provided as a non-API option │ │ │ │ + map = context; │ │ │ │ } │ │ │ │ + return map; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onNextChange │ │ │ │ - * Called when the next history stack changes. │ │ │ │ + * Method: getLayerFromContext │ │ │ │ + * Create a WMS layer from a layerContext object. │ │ │ │ * │ │ │ │ * 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. │ │ │ │ + * layerContext - {Object} An object representing a WMS layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.WMS>} A WMS layer. │ │ │ │ */ │ │ │ │ - onNextChange: function(state, length) { │ │ │ │ - if (state && !this.next.active) { │ │ │ │ - this.next.activate(); │ │ │ │ - } else if (!state && this.next.active) { │ │ │ │ - this.next.deactivate(); │ │ │ │ + getLayerFromContext: function(layerContext) { │ │ │ │ + var i, len; │ │ │ │ + // fill initial options object from layerContext │ │ │ │ + var options = { │ │ │ │ + queryable: layerContext.queryable, //keep queryable for api compatibility │ │ │ │ + visibility: layerContext.visibility, │ │ │ │ + maxExtent: layerContext.maxExtent, │ │ │ │ + metadata: OpenLayers.Util.applyDefaults(layerContext.metadata, { │ │ │ │ + styles: layerContext.styles, │ │ │ │ + formats: layerContext.formats, │ │ │ │ + "abstract": layerContext["abstract"], │ │ │ │ + dataURL: layerContext.dataURL │ │ │ │ + }), │ │ │ │ + numZoomLevels: layerContext.numZoomLevels, │ │ │ │ + units: layerContext.units, │ │ │ │ + isBaseLayer: layerContext.isBaseLayer, │ │ │ │ + opacity: layerContext.opacity, │ │ │ │ + displayInLayerSwitcher: layerContext.displayInLayerSwitcher, │ │ │ │ + singleTile: layerContext.singleTile, │ │ │ │ + tileSize: (layerContext.tileSize) ? │ │ │ │ + new OpenLayers.Size( │ │ │ │ + layerContext.tileSize.width, │ │ │ │ + layerContext.tileSize.height │ │ │ │ + ) : undefined, │ │ │ │ + minScale: layerContext.minScale || layerContext.maxScaleDenominator, │ │ │ │ + maxScale: layerContext.maxScale || layerContext.minScaleDenominator, │ │ │ │ + srs: layerContext.srs, │ │ │ │ + dimensions: layerContext.dimensions, │ │ │ │ + metadataURL: layerContext.metadataURL │ │ │ │ + }; │ │ │ │ + if (this.layerOptions) { │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.layerOptions); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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; │ │ │ │ + var params = { │ │ │ │ + layers: layerContext.name, │ │ │ │ + transparent: layerContext.transparent, │ │ │ │ + version: layerContext.version │ │ │ │ + }; │ │ │ │ + if (layerContext.formats && layerContext.formats.length > 0) { │ │ │ │ + // set default value for params if current attribute is not positionned │ │ │ │ + params.format = layerContext.formats[0].value; │ │ │ │ + for (i = 0, len = layerContext.formats.length; i < len; i++) { │ │ │ │ + var format = layerContext.formats[i]; │ │ │ │ + if (format.current == true) { │ │ │ │ + params.format = format.value; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (layerContext.styles && layerContext.styles.length > 0) { │ │ │ │ + for (i = 0, len = layerContext.styles.length; i < len; i++) { │ │ │ │ + var style = layerContext.styles[i]; │ │ │ │ + if (style.current == true) { │ │ │ │ + // three style types to consider │ │ │ │ + // 1) linked SLD │ │ │ │ + // 2) inline SLD │ │ │ │ + // 3) named style │ │ │ │ + if (style.href) { │ │ │ │ + params.sld = style.href; │ │ │ │ + } else if (style.body) { │ │ │ │ + params.sld_body = style.body; │ │ │ │ + } else { │ │ │ │ + params.styles = style.name; │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.layerParams) { │ │ │ │ + OpenLayers.Util.applyDefaults(params, this.layerParams); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control and <previous> and <next> child │ │ │ │ - * controls. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.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(); │ │ │ │ + var layer = null; │ │ │ │ + var service = layerContext.service; │ │ │ │ + if (service == OpenLayers.Format.Context.serviceTypes.WFS) { │ │ │ │ + options.strategies = [new OpenLayers.Strategy.BBOX()]; │ │ │ │ + options.protocol = new OpenLayers.Protocol.WFS({ │ │ │ │ + url: layerContext.url, │ │ │ │ + // since we do not know featureNS, let the protocol │ │ │ │ + // determine it automagically using featurePrefix │ │ │ │ + featurePrefix: layerContext.name.split(":")[0], │ │ │ │ + featureType: layerContext.name.split(":").pop() │ │ │ │ + }); │ │ │ │ + layer = new OpenLayers.Layer.Vector( │ │ │ │ + layerContext.title || layerContext.name, │ │ │ │ + options │ │ │ │ + ); │ │ │ │ + } else if (service == OpenLayers.Format.Context.serviceTypes.KML) { │ │ │ │ + // use a vector layer with an HTTP Protcol and a Fixed strategy │ │ │ │ + options.strategies = [new OpenLayers.Strategy.Fixed()]; │ │ │ │ + options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ + url: layerContext.url, │ │ │ │ + format: new OpenLayers.Format.KML() │ │ │ │ + }); │ │ │ │ + layer = new OpenLayers.Layer.Vector( │ │ │ │ + layerContext.title || layerContext.name, │ │ │ │ + options │ │ │ │ + ); │ │ │ │ + } else if (service == OpenLayers.Format.Context.serviceTypes.GML) { │ │ │ │ + // use a vector layer with a HTTP Protocol and a Fixed strategy │ │ │ │ + options.strategies = [new OpenLayers.Strategy.Fixed()]; │ │ │ │ + options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ + url: layerContext.url, │ │ │ │ + format: new OpenLayers.Format.GML() │ │ │ │ + }); │ │ │ │ + layer = new OpenLayers.Layer.Vector( │ │ │ │ + layerContext.title || layerContext.name, │ │ │ │ + options │ │ │ │ + ); │ │ │ │ + } else if (layerContext.features) { │ │ │ │ + // inline GML or KML features │ │ │ │ + layer = new OpenLayers.Layer.Vector( │ │ │ │ + layerContext.title || layerContext.name, │ │ │ │ + options │ │ │ │ + ); │ │ │ │ + layer.addFeatures(layerContext.features); │ │ │ │ + } else if (layerContext.categoryLayer !== true) { │ │ │ │ + layer = new OpenLayers.Layer.WMS( │ │ │ │ + layerContext.title || layerContext.name, │ │ │ │ + layerContext.url, │ │ │ │ + params, │ │ │ │ + options │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return layer; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: previousTrigger │ │ │ │ - * Restore the previous state. If no items are in the previous history │ │ │ │ - * stack, this has no effect. │ │ │ │ + * Method: getLayersFromContext │ │ │ │ + * Create an array of layers from an array of layerContext objects. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layersContext - {Array(Object)} An array of objects representing layers. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} Item representing state that was restored. Undefined if no │ │ │ │ - * items are in the previous history stack. │ │ │ │ + * {Array(<OpenLayers.Layer>)} An array of layers. │ │ │ │ */ │ │ │ │ - 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); │ │ │ │ + getLayersFromContext: function(layersContext) { │ │ │ │ + var layers = []; │ │ │ │ + for (var i = 0, len = layersContext.length; i < len; i++) { │ │ │ │ + var layer = this.getLayerFromContext(layersContext[i]); │ │ │ │ + if (layer !== null) { │ │ │ │ + layers.push(layer); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return state; │ │ │ │ + return layers; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * Method: contextToMap │ │ │ │ + * Create a map given a context object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} The context object. │ │ │ │ + * options - {Object} Default map options. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} Item representing state that was restored. Undefined if no │ │ │ │ - * items are in the next history stack. │ │ │ │ + * {<OpenLayers.Map>} A map based on the context object. │ │ │ │ */ │ │ │ │ - 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 │ │ │ │ - ); │ │ │ │ + contextToMap: function(context, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + maxExtent: context.maxExtent, │ │ │ │ + projection: context.projection, │ │ │ │ + units: context.units │ │ │ │ + }, options); │ │ │ │ + │ │ │ │ + if (options.maxExtent) { │ │ │ │ + options.maxResolution = │ │ │ │ + options.maxExtent.getWidth() / OpenLayers.Map.TILE_WIDTH; │ │ │ │ } │ │ │ │ - return state; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: clear │ │ │ │ - * Clear history. │ │ │ │ - */ │ │ │ │ - clear: function() { │ │ │ │ - this.previousStack = []; │ │ │ │ - this.previous.deactivate(); │ │ │ │ - this.nextStack = []; │ │ │ │ - this.next.deactivate(); │ │ │ │ + var metadata = { │ │ │ │ + contactInformation: context.contactInformation, │ │ │ │ + "abstract": context["abstract"], │ │ │ │ + keywords: context.keywords, │ │ │ │ + logo: context.logo, │ │ │ │ + descriptionURL: context.descriptionURL │ │ │ │ + }; │ │ │ │ + │ │ │ │ + options.metadata = metadata; │ │ │ │ + │ │ │ │ + var map = new OpenLayers.Map(options); │ │ │ │ + map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ + map.setCenter( │ │ │ │ + context.bounds.getCenterLonLat(), │ │ │ │ + map.getZoomForExtent(context.bounds, true) │ │ │ │ + ); │ │ │ │ + return map; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getState │ │ │ │ - * Get the current state and return it. │ │ │ │ + * Method: mergeContextToMap │ │ │ │ + * Add layers from a context object to a map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} The context object. │ │ │ │ + * map - {<OpenLayers.Map>} The map. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object representing the current state. │ │ │ │ + * {<OpenLayers.Map>} The same map with layers added. │ │ │ │ */ │ │ │ │ - getState: function() { │ │ │ │ - return { │ │ │ │ - center: this.map.getCenter(), │ │ │ │ - resolution: this.map.getResolution(), │ │ │ │ - projection: this.map.getProjectionObject(), │ │ │ │ - units: this.map.getProjectionObject().getUnits() || │ │ │ │ - this.map.units || this.map.baseLayer.units │ │ │ │ - }; │ │ │ │ + mergeContextToMap: function(context, map) { │ │ │ │ + map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ + return map; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: restore │ │ │ │ - * Update the state with the given object. │ │ │ │ + * APIMethod: write │ │ │ │ + * Write a context document given a map. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * state - {Object} An object representing the state to restore. │ │ │ │ + * obj - {<OpenLayers.Map> | Object} A map or context object. │ │ │ │ + * options - {Object} Optional configuration object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A context document string. │ │ │ │ */ │ │ │ │ - restore: function(state) { │ │ │ │ - var center, zoom; │ │ │ │ - if (this.map.getProjectionObject() == state.projection) { │ │ │ │ - zoom = this.map.getZoomForResolution(state.resolution); │ │ │ │ - center = state.center; │ │ │ │ - } else { │ │ │ │ - center = state.center.clone(); │ │ │ │ - center.transform(state.projection, this.map.getProjectionObject()); │ │ │ │ - var sourceUnits = state.units; │ │ │ │ - var targetUnits = this.map.getProjectionObject().getUnits() || │ │ │ │ - this.map.units || this.map.baseLayer.units; │ │ │ │ - var resolutionFactor = sourceUnits && targetUnits ? │ │ │ │ - OpenLayers.INCHES_PER_UNIT[sourceUnits] / OpenLayers.INCHES_PER_UNIT[targetUnits] : 1; │ │ │ │ - zoom = this.map.getZoomForResolution(resolutionFactor * state.resolution); │ │ │ │ - } │ │ │ │ - this.map.setCenter(center, zoom); │ │ │ │ + write: function(obj, options) { │ │ │ │ + obj = this.toContext(obj); │ │ │ │ + return OpenLayers.Format.XML.VersionedOGC.prototype.write.apply(this, │ │ │ │ + arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Context" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Format.Context.serviceTypes │ │ │ │ + * Enumeration for service types │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.Context.serviceTypes = { │ │ │ │ + "WMS": "urn:ogc:serviceType:WMS", │ │ │ │ + "WFS": "urn:ogc:serviceType:WFS", │ │ │ │ + "WCS": "urn:ogc:serviceType:WCS", │ │ │ │ + "GML": "urn:ogc:serviceType:GML", │ │ │ │ + "SLD": "urn:ogc:serviceType:SLD", │ │ │ │ + "FES": "urn:ogc:serviceType:FES", │ │ │ │ + "KML": "urn:ogc:serviceType:KML" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/OWSContext.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/Context.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.OWSContext │ │ │ │ + * Read and write OWS Context documents. OWS Context documents are a │ │ │ │ + * preliminary OGC (Open Geospatial Consortium) standard for storing the │ │ │ │ + * state of a web mapping application. In a way it is the successor to │ │ │ │ + * Web Map Context (WMC), since it is more generic and more types of layers │ │ │ │ + * can be stored. Also, nesting of layers is supported since version 0.3.1. │ │ │ │ + * For more information see: http://www.ogcnetwork.net/context │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.Context> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.OWSContext = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: setListeners │ │ │ │ - * Sets functions to be registered in the listeners object. │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "0.3.1". │ │ │ │ */ │ │ │ │ - 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); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + defaultVersion: "0.3.1", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the control. This registers any listeners. │ │ │ │ + * Constructor: OpenLayers.Format.OWSContext │ │ │ │ + * Create a new parser for OWS Context documents. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Control successfully activated. │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - 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. │ │ │ │ + * Method: getVersion │ │ │ │ + * Returns the version to use. Subclasses can override this function │ │ │ │ + * if a different version detection is needed. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * root - {DOMElement} │ │ │ │ + * options - {Object} Optional configuration object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The version to use. │ │ │ │ */ │ │ │ │ - initStack: function() { │ │ │ │ - if (this.map.getCenter()) { │ │ │ │ - this.listeners.moveend(); │ │ │ │ + getVersion: function(root, options) { │ │ │ │ + var version = OpenLayers.Format.XML.VersionedOGC.prototype.getVersion.apply( │ │ │ │ + this, arguments); │ │ │ │ + // 0.3.1 is backwards compatible with 0.3.0 │ │ │ │ + if (version === "0.3.0") { │ │ │ │ + version = this.defaultVersion; │ │ │ │ } │ │ │ │ + return version; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the control. This unregisters any listeners. │ │ │ │ + * Method: toContext │ │ │ │ + * Create a context object free from layer given a map or a │ │ │ │ + * context object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {<OpenLayers.Map> | Object} The map or context. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Control successfully deactivated. │ │ │ │ + * {Object} A context object. │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ - } │ │ │ │ + toContext: function(obj) { │ │ │ │ + var context = {}; │ │ │ │ + if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ + context.bounds = obj.getExtent(); │ │ │ │ + context.maxExtent = obj.maxExtent; │ │ │ │ + context.projection = obj.projection; │ │ │ │ + context.size = obj.getSize(); │ │ │ │ + context.layers = obj.layers; │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + return context; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.NavigationHistory" │ │ │ │ -}); │ │ │ │ + CLASS_NAME: "OpenLayers.Format.OWSContext" │ │ │ │ │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Geolocate.js │ │ │ │ + OpenLayers/Format/GPX.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ * @requires OpenLayers/Projection.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Geolocate │ │ │ │ - * The Geolocate control wraps w3c geolocation API into control that can be │ │ │ │ - * bound to a map, and generate events on location update │ │ │ │ - * │ │ │ │ - * To use this control requires to load the proj4js library if the projection │ │ │ │ - * of the map is not EPSG:4326 or EPSG:900913. │ │ │ │ + * Class: OpenLayers.Format.GPX │ │ │ │ + * Read/write GPX parser. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.GPX> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Geolocate = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * locationupdated - Triggered when browser return a new position. Listeners will │ │ │ │ - * receive an object with a 'position' property which is the browser.geolocation.position │ │ │ │ - * native object, as well as a 'point' property which is the location transformed in the │ │ │ │ - * current map projection. │ │ │ │ - * locationfailed - Triggered when geolocation has failed │ │ │ │ - * locationuncapable - Triggered when control is activated on a browser │ │ │ │ - * which doesn't support geolocation │ │ │ │ + * APIProperty: defaultDesc │ │ │ │ + * {String} Default description for the waypoints/tracks in the case │ │ │ │ + * where the feature has no "description" attribute. │ │ │ │ + * Default is "No description available". │ │ │ │ */ │ │ │ │ + defaultDesc: "No description available", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: geolocation │ │ │ │ - * {Object} The geolocation engine, as a property to be possibly mocked. │ │ │ │ - * This is set lazily to avoid a memory leak in IE9. │ │ │ │ + * APIProperty: extractWaypoints │ │ │ │ + * {Boolean} Extract waypoints from GPX. (default: true) │ │ │ │ */ │ │ │ │ - geolocation: null, │ │ │ │ + extractWaypoints: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: available │ │ │ │ - * {Boolean} The navigator.geolocation object is available. │ │ │ │ + * APIProperty: extractTracks │ │ │ │ + * {Boolean} Extract tracks from GPX. (default: true) │ │ │ │ */ │ │ │ │ - available: ('geolocation' in navigator), │ │ │ │ + extractTracks: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: bind │ │ │ │ - * {Boolean} If true, map center will be set on location update. │ │ │ │ + * APIProperty: extractRoutes │ │ │ │ + * {Boolean} Extract routes from GPX. (default: true) │ │ │ │ */ │ │ │ │ - bind: true, │ │ │ │ + extractRoutes: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: watch │ │ │ │ - * {Boolean} If true, position will be update regularly. │ │ │ │ + * APIProperty: extractAttributes │ │ │ │ + * {Boolean} Extract feature attributes from GPX. (default: true) │ │ │ │ + * NOTE: Attributes as part of extensions to the GPX standard may not │ │ │ │ + * be extracted. │ │ │ │ */ │ │ │ │ - watch: false, │ │ │ │ + extractAttributes: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: geolocationOptions │ │ │ │ - * {Object} Options to pass to the navigator's geolocation API. See │ │ │ │ - * <http://dev.w3.org/geo/api/spec-source.html>. No specific │ │ │ │ - * option is passed to the geolocation API by default. │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - geolocationOptions: null, │ │ │ │ + namespaces: { │ │ │ │ + gpx: "http://www.topografix.com/GPX/1/1", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Geolocate │ │ │ │ - * Create a new control to deal with browser geolocation API │ │ │ │ - * │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location. Defaults to │ │ │ │ + * "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd" │ │ │ │ */ │ │ │ │ + schemaLocation: "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * APIProperty: creator │ │ │ │ + * {String} The creator attribute to be added to the written GPX files. │ │ │ │ + * Defaults to "OpenLayers" │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + creator: "OpenLayers", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activates the control. │ │ │ │ + * Constructor: OpenLayers.Format.GPX │ │ │ │ + * Create a new parser for GPX. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The control was effectively activated. │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (this.available && !this.geolocation) { │ │ │ │ - // set lazily to avoid IE9 memory leak │ │ │ │ - this.geolocation = navigator.geolocation; │ │ │ │ - } │ │ │ │ - if (!this.geolocation) { │ │ │ │ - this.events.triggerEvent("locationuncapable"); │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - if (this.watch) { │ │ │ │ - this.watchId = this.geolocation.watchPosition( │ │ │ │ - OpenLayers.Function.bind(this.geolocate, this), │ │ │ │ - OpenLayers.Function.bind(this.failure, this), │ │ │ │ - this.geolocationOptions │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.getCurrentLocation(); │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ + initialize: function(options) { │ │ │ │ + // GPX coordinates are always in longlat WGS84 │ │ │ │ + this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivates the control. │ │ │ │ + * APIMethod: read │ │ │ │ + * Return a list of features from a GPX doc │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * doc - {Element} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The control was effectively deactivated. │ │ │ │ + * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active && this.watchId !== null) { │ │ │ │ - this.geolocation.clearWatch(this.watchId); │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ + var features = []; │ │ │ │ + │ │ │ │ + if (this.extractTracks) { │ │ │ │ + var tracks = doc.getElementsByTagName("trk"); │ │ │ │ + for (var i = 0, len = tracks.length; i < len; i++) { │ │ │ │ + // Attributes are only in trk nodes, not trkseg nodes │ │ │ │ + var attrs = {}; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attrs = this.parseAttributes(tracks[i]); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var segs = this.getElementsByTagNameNS(tracks[i], tracks[i].namespaceURI, "trkseg"); │ │ │ │ + for (var j = 0, seglen = segs.length; j < seglen; j++) { │ │ │ │ + // We don't yet support extraction of trkpt attributes │ │ │ │ + // All trksegs of a trk get that trk's attributes │ │ │ │ + var track = this.extractSegment(segs[j], "trkpt"); │ │ │ │ + features.push(new OpenLayers.Feature.Vector(track, attrs)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.extractRoutes) { │ │ │ │ + var routes = doc.getElementsByTagName("rte"); │ │ │ │ + for (var k = 0, klen = routes.length; k < klen; k++) { │ │ │ │ + var attrs = {}; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attrs = this.parseAttributes(routes[k]); │ │ │ │ + } │ │ │ │ + var route = this.extractSegment(routes[k], "rtept"); │ │ │ │ + features.push(new OpenLayers.Feature.Vector(route, attrs)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.extractWaypoints) { │ │ │ │ + var waypoints = doc.getElementsByTagName("wpt"); │ │ │ │ + for (var l = 0, len = waypoints.length; l < len; l++) { │ │ │ │ + var attrs = {}; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attrs = this.parseAttributes(waypoints[l]); │ │ │ │ + } │ │ │ │ + var wpt = new OpenLayers.Geometry.Point(waypoints[l].getAttribute("lon"), waypoints[l].getAttribute("lat")); │ │ │ │ + features.push(new OpenLayers.Feature.Vector(wpt, attrs)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + for (var g = 0, featLength = features.length; g < featLength; g++) { │ │ │ │ + features[g].geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return features; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: geolocate │ │ │ │ - * Activates the control. │ │ │ │ + * Method: extractSegment │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * segment - {DOMElement} a trkseg or rte node to parse │ │ │ │ + * segmentType - {String} nodeName of waypoints that form the line │ │ │ │ * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.LineString>} A linestring geometry │ │ │ │ */ │ │ │ │ - geolocate: function(position) { │ │ │ │ - var center = new OpenLayers.LonLat( │ │ │ │ - position.coords.longitude, │ │ │ │ - position.coords.latitude │ │ │ │ - ).transform( │ │ │ │ - new OpenLayers.Projection("EPSG:4326"), │ │ │ │ - this.map.getProjectionObject() │ │ │ │ - ); │ │ │ │ - if (this.bind) { │ │ │ │ - this.map.setCenter(center); │ │ │ │ + extractSegment: function(segment, segmentType) { │ │ │ │ + var points = this.getElementsByTagNameNS(segment, segment.namespaceURI, segmentType); │ │ │ │ + var point_features = []; │ │ │ │ + for (var i = 0, len = points.length; i < len; i++) { │ │ │ │ + point_features.push(new OpenLayers.Geometry.Point(points[i].getAttribute("lon"), points[i].getAttribute("lat"))); │ │ │ │ } │ │ │ │ - this.events.triggerEvent("locationupdated", { │ │ │ │ - position: position, │ │ │ │ - point: new OpenLayers.Geometry.Point( │ │ │ │ - center.lon, center.lat │ │ │ │ - ) │ │ │ │ + return new OpenLayers.Geometry.LineString(point_features); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseAttributes │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {<DOMElement>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An attributes object. │ │ │ │ + */ │ │ │ │ + parseAttributes: function(node) { │ │ │ │ + // node is either a wpt, trk or rte │ │ │ │ + // attributes are children of the form <attr>value</attr> │ │ │ │ + var attributes = {}; │ │ │ │ + var attrNode = node.firstChild, │ │ │ │ + value, name; │ │ │ │ + while (attrNode) { │ │ │ │ + if (attrNode.nodeType == 1 && attrNode.firstChild) { │ │ │ │ + value = attrNode.firstChild; │ │ │ │ + if (value.nodeType == 3 || value.nodeType == 4) { │ │ │ │ + name = (attrNode.prefix) ? │ │ │ │ + attrNode.nodeName.split(":")[1] : │ │ │ │ + attrNode.nodeName; │ │ │ │ + if (name != "trkseg" && name != "rtept") { │ │ │ │ + attributes[name] = value.nodeValue; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + attrNode = attrNode.nextSibling; │ │ │ │ + } │ │ │ │ + return attributes; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: write │ │ │ │ + * Accepts Feature Collection, and returns a string. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} List of features to serialize into a string. │ │ │ │ + * metadata - {Object} A key/value pairs object to build a metadata node to │ │ │ │ + * add to the gpx. Supported keys are 'name', 'desc', 'author'. │ │ │ │ + */ │ │ │ │ + write: function(features, metadata) { │ │ │ │ + features = OpenLayers.Util.isArray(features) ? │ │ │ │ + features : [features]; │ │ │ │ + var gpx = this.createElementNS(this.namespaces.gpx, "gpx"); │ │ │ │ + gpx.setAttribute("version", "1.1"); │ │ │ │ + gpx.setAttribute("creator", this.creator); │ │ │ │ + this.setAttributes(gpx, { │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ }); │ │ │ │ + │ │ │ │ + if (metadata && typeof metadata == 'object') { │ │ │ │ + gpx.appendChild(this.buildMetadataNode(metadata)); │ │ │ │ + } │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + gpx.appendChild(this.buildFeatureNode(features[i])); │ │ │ │ + } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [gpx]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getCurrentLocation │ │ │ │ + * Method: buildMetadataNode │ │ │ │ + * Creates a "metadata" node. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Returns true if a event will be fired (successfull │ │ │ │ - * registration) │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - getCurrentLocation: function() { │ │ │ │ - if (!this.active || this.watch) { │ │ │ │ - return false; │ │ │ │ + buildMetadataNode: function(metadata) { │ │ │ │ + var types = ['name', 'desc', 'author'], │ │ │ │ + node = this.createElementNS(this.namespaces.gpx, 'metadata'); │ │ │ │ + for (var i = 0; i < types.length; i++) { │ │ │ │ + var type = types[i]; │ │ │ │ + if (metadata[type]) { │ │ │ │ + var n = this.createElementNS(this.namespaces.gpx, type); │ │ │ │ + n.appendChild(this.createTextNode(metadata[type])); │ │ │ │ + node.appendChild(n); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.geolocation.getCurrentPosition( │ │ │ │ - OpenLayers.Function.bind(this.geolocate, this), │ │ │ │ - OpenLayers.Function.bind(this.failure, this), │ │ │ │ - this.geolocationOptions │ │ │ │ - ); │ │ │ │ - return true; │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: failure │ │ │ │ - * method called on browser's geolocation failure │ │ │ │ + * Method: buildFeatureNode │ │ │ │ + * Accepts an <OpenLayers.Feature.Vector>, and builds a node for it. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} - The created node, either a 'wpt' or a 'trk'. │ │ │ │ */ │ │ │ │ - failure: function(error) { │ │ │ │ - this.events.triggerEvent("locationfailed", { │ │ │ │ - error: error │ │ │ │ - }); │ │ │ │ + buildFeatureNode: function(feature) { │ │ │ │ + var geometry = feature.geometry; │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.internalProjection, │ │ │ │ + this.externalProjection); │ │ │ │ + } │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + var wpt = this.buildWptNode(geometry); │ │ │ │ + this.appendAttributesNode(wpt, feature); │ │ │ │ + return wpt; │ │ │ │ + } else { │ │ │ │ + var trkNode = this.createElementNS(this.namespaces.gpx, "trk"); │ │ │ │ + this.appendAttributesNode(trkNode, feature); │ │ │ │ + var trkSegNodes = this.buildTrkSegNode(geometry); │ │ │ │ + trkSegNodes = OpenLayers.Util.isArray(trkSegNodes) ? │ │ │ │ + trkSegNodes : [trkSegNodes]; │ │ │ │ + for (var i = 0, len = trkSegNodes.length; i < len; i++) { │ │ │ │ + trkNode.appendChild(trkSegNodes[i]); │ │ │ │ + } │ │ │ │ + return trkNode; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Geolocate" │ │ │ │ + /** │ │ │ │ + * Method: buildTrkSegNode │ │ │ │ + * Builds trkseg node(s) given a geometry │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * trknode │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + */ │ │ │ │ + buildTrkSegNode: function(geometry) { │ │ │ │ + var node, │ │ │ │ + i, │ │ │ │ + len, │ │ │ │ + point, │ │ │ │ + nodes; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" || │ │ │ │ + geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ + node = this.createElementNS(this.namespaces.gpx, "trkseg"); │ │ │ │ + for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ + point = geometry.components[i]; │ │ │ │ + node.appendChild(this.buildTrkPtNode(point)); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + } else { │ │ │ │ + nodes = []; │ │ │ │ + for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ + nodes.push(this.buildTrkSegNode(geometry.components[i])); │ │ │ │ + } │ │ │ │ + return nodes; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: buildTrkPtNode │ │ │ │ + * Builds a trkpt node given a point │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A trkpt node │ │ │ │ + */ │ │ │ │ + buildTrkPtNode: function(point) { │ │ │ │ + var node = this.createElementNS(this.namespaces.gpx, "trkpt"); │ │ │ │ + node.setAttribute("lon", point.x); │ │ │ │ + node.setAttribute("lat", point.y); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: buildWptNode │ │ │ │ + * Builds a wpt node given a point │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A wpt node │ │ │ │ + */ │ │ │ │ + buildWptNode: function(geometry) { │ │ │ │ + var node = this.createElementNS(this.namespaces.gpx, "wpt"); │ │ │ │ + node.setAttribute("lon", geometry.x); │ │ │ │ + node.setAttribute("lat", geometry.y); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: appendAttributesNode │ │ │ │ + * Adds some attributes node. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} the node to append the attribute nodes to. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + appendAttributesNode: function(node, feature) { │ │ │ │ + var name = this.createElementNS(this.namespaces.gpx, 'name'); │ │ │ │ + name.appendChild(this.createTextNode( │ │ │ │ + feature.attributes.name || feature.id)); │ │ │ │ + node.appendChild(name); │ │ │ │ + var desc = this.createElementNS(this.namespaces.gpx, 'desc'); │ │ │ │ + desc.appendChild(this.createTextNode( │ │ │ │ + feature.attributes.description || this.defaultDesc)); │ │ │ │ + node.appendChild(desc); │ │ │ │ + // TBD - deal with remaining (non name/description) attributes. │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.GPX" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/PanZoom.js │ │ │ │ + OpenLayers/Format/WMC.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/Context.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.PanZoom │ │ │ │ - * The PanZoom is a visible control, composed of a │ │ │ │ - * <OpenLayers.Control.PanPanel> and a <OpenLayers.Control.ZoomPanel>. By │ │ │ │ - * default it is drawn in the upper left corner of the map. │ │ │ │ + * Class: OpenLayers.Format.WMC │ │ │ │ + * Read and write Web Map Context documents. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.Context> │ │ │ │ */ │ │ │ │ -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. If you want to pan by some ratio │ │ │ │ - * of the map dimensions, use <slideRatio> instead. │ │ │ │ - */ │ │ │ │ - slideFactor: 50, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: slideRatio │ │ │ │ - * {Number} The fraction of map width/height by which we'll pan the map │ │ │ │ - * on clicking the arrow buttons. Default is null. If set, will │ │ │ │ - * override <slideFactor>. E.g. if slideRatio is .5, then the Pan Up │ │ │ │ - * button will pan up half the map height. │ │ │ │ - */ │ │ │ │ - slideRatio: null, │ │ │ │ +OpenLayers.Format.WMC = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: buttons │ │ │ │ - * {Array(DOMElement)} Array of Button Divs │ │ │ │ + /** │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ */ │ │ │ │ - buttons: null, │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: position │ │ │ │ - * {<OpenLayers.Pixel>} │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMC │ │ │ │ + * Create a new parser for Web Map Context documents. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - position: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.PanZoom │ │ │ │ - * │ │ │ │ + * Method: layerToContext │ │ │ │ + * Create a layer context object given a wms layer object. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * layer - {<OpenLayers.Layer.WMS>} The layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} A layer context object. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X, │ │ │ │ - OpenLayers.Control.PanZoom.Y); │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + layerToContext: function(layer) { │ │ │ │ + var parser = this.getParser(); │ │ │ │ + var layerContext = { │ │ │ │ + queryable: layer.queryable, │ │ │ │ + visibility: layer.visibility, │ │ │ │ + name: layer.params["LAYERS"], │ │ │ │ + title: layer.name, │ │ │ │ + "abstract": layer.metadata["abstract"], │ │ │ │ + dataURL: layer.metadata.dataURL, │ │ │ │ + metadataURL: layer.metadataURL, │ │ │ │ + server: { │ │ │ │ + version: layer.params["VERSION"], │ │ │ │ + url: layer.url │ │ │ │ + }, │ │ │ │ + maxExtent: layer.maxExtent, │ │ │ │ + transparent: layer.params["TRANSPARENT"], │ │ │ │ + numZoomLevels: layer.numZoomLevels, │ │ │ │ + units: layer.units, │ │ │ │ + isBaseLayer: layer.isBaseLayer, │ │ │ │ + opacity: layer.opacity == 1 ? undefined : layer.opacity, │ │ │ │ + displayInLayerSwitcher: layer.displayInLayerSwitcher, │ │ │ │ + singleTile: layer.singleTile, │ │ │ │ + tileSize: (layer.singleTile || !layer.tileSize) ? │ │ │ │ + undefined : { │ │ │ │ + width: layer.tileSize.w, │ │ │ │ + height: layer.tileSize.h │ │ │ │ + }, │ │ │ │ + minScale: (layer.options.resolutions || │ │ │ │ + layer.options.scales || │ │ │ │ + layer.options.maxResolution || │ │ │ │ + layer.options.minScale) ? │ │ │ │ + layer.minScale : undefined, │ │ │ │ + maxScale: (layer.options.resolutions || │ │ │ │ + layer.options.scales || │ │ │ │ + layer.options.minResolution || │ │ │ │ + layer.options.maxScale) ? │ │ │ │ + layer.maxScale : undefined, │ │ │ │ + formats: [], │ │ │ │ + styles: [], │ │ │ │ + srs: layer.srs, │ │ │ │ + dimensions: layer.dimensions │ │ │ │ + }; │ │ │ │ + │ │ │ │ + │ │ │ │ + if (layer.metadata.servertitle) { │ │ │ │ + layerContext.server.title = layer.metadata.servertitle; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (layer.metadata.formats && layer.metadata.formats.length > 0) { │ │ │ │ + for (var i = 0, len = layer.metadata.formats.length; i < len; i++) { │ │ │ │ + var format = layer.metadata.formats[i]; │ │ │ │ + layerContext.formats.push({ │ │ │ │ + value: format.value, │ │ │ │ + current: (format.value == layer.params["FORMAT"]) │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + layerContext.formats.push({ │ │ │ │ + value: layer.params["FORMAT"], │ │ │ │ + current: true │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ + for (var i = 0, len = layer.metadata.styles.length; i < len; i++) { │ │ │ │ + var style = layer.metadata.styles[i]; │ │ │ │ + if ((style.href == layer.params["SLD"]) || │ │ │ │ + (style.body == layer.params["SLD_BODY"]) || │ │ │ │ + (style.name == layer.params["STYLES"])) { │ │ │ │ + style.current = true; │ │ │ │ + } else { │ │ │ │ + style.current = false; │ │ │ │ + } │ │ │ │ + layerContext.styles.push(style); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + layerContext.styles.push({ │ │ │ │ + href: layer.params["SLD"], │ │ │ │ + body: layer.params["SLD_BODY"], │ │ │ │ + name: layer.params["STYLES"] || parser.defaultStyleName, │ │ │ │ + title: parser.defaultStyleTitle, │ │ │ │ + current: true │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return layerContext; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Method: toContext │ │ │ │ + * Create a context object free from layer given a map or a │ │ │ │ + * context object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {<OpenLayers.Map> | Object} The map or context. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} A context object. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ + toContext: function(obj) { │ │ │ │ + var context = {}; │ │ │ │ + var layers = obj.layers; │ │ │ │ + if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ + var metadata = obj.metadata || {}; │ │ │ │ + context.size = obj.getSize(); │ │ │ │ + context.bounds = obj.getExtent(); │ │ │ │ + context.projection = obj.projection; │ │ │ │ + context.title = obj.title; │ │ │ │ + context.keywords = metadata.keywords; │ │ │ │ + context["abstract"] = metadata["abstract"]; │ │ │ │ + context.logo = metadata.logo; │ │ │ │ + context.descriptionURL = metadata.descriptionURL; │ │ │ │ + context.contactInformation = metadata.contactInformation; │ │ │ │ + context.maxExtent = obj.maxExtent; │ │ │ │ + } else { │ │ │ │ + // copy all obj properties except the "layers" property │ │ │ │ + OpenLayers.Util.applyDefaults(context, obj); │ │ │ │ + if (context.layers != undefined) { │ │ │ │ + delete(context.layers); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.removeButtons(); │ │ │ │ - this.buttons = null; │ │ │ │ - this.position = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (context.layersContext == undefined) { │ │ │ │ + context.layersContext = []; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // let's convert layers into layersContext object (if any) │ │ │ │ + if (layers != undefined && OpenLayers.Util.isArray(layers)) { │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ + context.layersContext.push(this.layerToContext(layer)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return context; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ - * Properties: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC" │ │ │ │ + │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSDescribeLayer.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSDescribeLayer │ │ │ │ + * Read SLD WMS DescribeLayer response │ │ │ │ + * DescribeLayer is meant to couple WMS to WFS and WCS │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSDescribeLayer = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.1.1". │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - }, │ │ │ │ + defaultVersion: "1.1.1", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * Constructor: OpenLayers.Format.WMSDescribeLayer │ │ │ │ + * Create a new parser for WMS DescribeLayer responses. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read DescribeLayer data from a string, and return the response. │ │ │ │ + * The OGC currently defines 2 formats which are allowed for output, │ │ │ │ + * so we need to parse these 2 types │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A reference to the container div for the PanZoom control. │ │ │ │ + * {Array} Array of {<LayerDescription>} objects which have: │ │ │ │ + * - {String} owsType: WFS/WCS │ │ │ │ + * - {String} owsURL: the online resource │ │ │ │ + * - {String} typeName: the name of the typename on the service │ │ │ │ */ │ │ │ │ - draw: function(px) { │ │ │ │ - // initialize our internal div │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - px = this.position; │ │ │ │ │ │ │ │ - // place the controls │ │ │ │ - this.buttons = []; │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer" │ │ │ │ │ │ │ │ - var sz = { │ │ │ │ - w: 18, │ │ │ │ - h: 18 │ │ │ │ - }; │ │ │ │ - var centered = new OpenLayers.Pixel(px.x + sz.w / 2, px.y); │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WFS.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - 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; │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/GML.js │ │ │ │ + * @requires OpenLayers/Console.js │ │ │ │ + * @requires OpenLayers/Lang.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WFS │ │ │ │ + * Read/Write WFS. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.GML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WFS = OpenLayers.Class(OpenLayers.Format.GML, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer>} │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: _addButton │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} │ │ │ │ - * img - {String} │ │ │ │ - * xy - {<OpenLayers.Pixel>} │ │ │ │ - * sz - {<OpenLayers.Size>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A Div (an alphaImageDiv, to be precise) that contains the │ │ │ │ - * image of the button, and has all the proper event handlers set. │ │ │ │ + * APIProperty: wfsns │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - _addButton: function(id, img, xy, sz) { │ │ │ │ - var imgLocation = OpenLayers.Util.getImageLocation(img); │ │ │ │ - var btn = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - this.id + "_" + id, │ │ │ │ - xy, sz, imgLocation, "absolute"); │ │ │ │ - btn.style.cursor = "pointer"; │ │ │ │ - //we want to add the outer div │ │ │ │ - this.div.appendChild(btn); │ │ │ │ - btn.action = id; │ │ │ │ - btn.className = "olButton"; │ │ │ │ + wfsns: "http://www.opengis.net/wfs", │ │ │ │ │ │ │ │ - //we want to remember/reference the outer div │ │ │ │ - this.buttons.push(btn); │ │ │ │ - return btn; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: ogcns │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + ogcns: "http://www.opengis.net/ogc", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: _removeButton │ │ │ │ + * Constructor: OpenLayers.Format.WFS │ │ │ │ + * Create a WFS-T formatter. This requires a layer: that layer should │ │ │ │ + * have two properties: geometry_column and typename. The parser │ │ │ │ + * for this format is subclassed entirely from GML: There is a writer │ │ │ │ + * only, which uses most of the code from the GML layer, and wraps │ │ │ │ + * it in transactional elements. │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} │ │ │ │ + * layer - {<OpenLayers.Layer>} │ │ │ │ + */ │ │ │ │ + initialize: function(options, layer) { │ │ │ │ + OpenLayers.Format.GML.prototype.initialize.apply(this, [options]); │ │ │ │ + this.layer = layer; │ │ │ │ + if (this.layer.featureNS) { │ │ │ │ + this.featureNS = this.layer.featureNS; │ │ │ │ + } │ │ │ │ + if (this.layer.options.geometry_column) { │ │ │ │ + this.geometryName = this.layer.options.geometry_column; │ │ │ │ + } │ │ │ │ + if (this.layer.options.typename) { │ │ │ │ + this.featureName = this.layer.options.typename; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: write │ │ │ │ + * Takes a feature list, and generates a WFS-T Transaction │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * btn - {Object} │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ */ │ │ │ │ - _removeButton: function(btn) { │ │ │ │ - this.div.removeChild(btn); │ │ │ │ - OpenLayers.Util.removeItem(this.buttons, btn); │ │ │ │ + write: function(features) { │ │ │ │ + │ │ │ │ + var transaction = this.createElementNS(this.wfsns, 'wfs:Transaction'); │ │ │ │ + transaction.setAttribute("version", "1.0.0"); │ │ │ │ + transaction.setAttribute("service", "WFS"); │ │ │ │ + for (var i = 0; i < features.length; i++) { │ │ │ │ + switch (features[i].state) { │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + transaction.appendChild(this.insert(features[i])); │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + transaction.appendChild(this.update(features[i])); │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + transaction.appendChild(this.remove(features[i])); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [transaction]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeButtons │ │ │ │ + * Method: createFeatureXML │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - removeButtons: function() { │ │ │ │ - for (var i = this.buttons.length - 1; i >= 0; --i) { │ │ │ │ - this._removeButton(this.buttons[i]); │ │ │ │ + createFeatureXML: function(feature) { │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + var geomContainer = this.createElementNS(this.featureNS, "feature:" + this.geometryName); │ │ │ │ + geomContainer.appendChild(geometryNode); │ │ │ │ + var featureContainer = this.createElementNS(this.featureNS, "feature:" + this.featureName); │ │ │ │ + featureContainer.appendChild(geomContainer); │ │ │ │ + for (var attr in feature.attributes) { │ │ │ │ + var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ + var nodename = attr; │ │ │ │ + if (attr.search(":") != -1) { │ │ │ │ + nodename = attr.split(":")[1]; │ │ │ │ + } │ │ │ │ + var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ + attrContainer.appendChild(attrText); │ │ │ │ + featureContainer.appendChild(attrContainer); │ │ │ │ } │ │ │ │ + return featureContainer; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onButtonClick │ │ │ │ + * Method: insert │ │ │ │ + * Takes a feature, and generates a WFS-T Transaction "Insert" │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + insert: function(feature) { │ │ │ │ + var insertNode = this.createElementNS(this.wfsns, 'wfs:Insert'); │ │ │ │ + insertNode.appendChild(this.createFeatureXML(feature)); │ │ │ │ + return insertNode; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ + * Takes a feature, and generates a WFS-T Transaction "Update" │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var btn = evt.buttonElement; │ │ │ │ - switch (btn.action) { │ │ │ │ - case "panup": │ │ │ │ - this.map.pan(0, -this.getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case "pandown": │ │ │ │ - this.map.pan(0, this.getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case "panleft": │ │ │ │ - this.map.pan(-this.getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - case "panright": │ │ │ │ - this.map.pan(this.getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - case "zoomin": │ │ │ │ - this.map.zoomIn(); │ │ │ │ - break; │ │ │ │ - case "zoomout": │ │ │ │ - this.map.zoomOut(); │ │ │ │ - break; │ │ │ │ - case "zoomworld": │ │ │ │ - this.map.zoomToMaxExtent(); │ │ │ │ - break; │ │ │ │ + update: function(feature) { │ │ │ │ + if (!feature.fid) { │ │ │ │ + OpenLayers.Console.userError(OpenLayers.i18n("noFID")); │ │ │ │ } │ │ │ │ + var updateNode = this.createElementNS(this.wfsns, 'wfs:Update'); │ │ │ │ + updateNode.setAttribute("typeName", this.featurePrefix + ':' + this.featureName); │ │ │ │ + updateNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ + │ │ │ │ + var propertyNode = this.createElementNS(this.wfsns, 'wfs:Property'); │ │ │ │ + var nameNode = this.createElementNS(this.wfsns, 'wfs:Name'); │ │ │ │ + │ │ │ │ + var txtNode = this.createTextNode(this.geometryName); │ │ │ │ + nameNode.appendChild(txtNode); │ │ │ │ + propertyNode.appendChild(nameNode); │ │ │ │ + │ │ │ │ + var valueNode = this.createElementNS(this.wfsns, 'wfs:Value'); │ │ │ │ + │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + │ │ │ │ + if (feature.layer) { │ │ │ │ + geometryNode.setAttribute( │ │ │ │ + "srsName", feature.layer.projection.getCode() │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + valueNode.appendChild(geometryNode); │ │ │ │ + │ │ │ │ + propertyNode.appendChild(valueNode); │ │ │ │ + updateNode.appendChild(propertyNode); │ │ │ │ + │ │ │ │ + // add in attributes │ │ │ │ + for (var propName in feature.attributes) { │ │ │ │ + propertyNode = this.createElementNS(this.wfsns, 'wfs:Property'); │ │ │ │ + nameNode = this.createElementNS(this.wfsns, 'wfs:Name'); │ │ │ │ + nameNode.appendChild(this.createTextNode(propName)); │ │ │ │ + propertyNode.appendChild(nameNode); │ │ │ │ + valueNode = this.createElementNS(this.wfsns, 'wfs:Value'); │ │ │ │ + valueNode.appendChild(this.createTextNode(feature.attributes[propName])); │ │ │ │ + propertyNode.appendChild(valueNode); │ │ │ │ + updateNode.appendChild(propertyNode); │ │ │ │ + } │ │ │ │ + │ │ │ │ + │ │ │ │ + var filterNode = this.createElementNS(this.ogcns, 'ogc:Filter'); │ │ │ │ + var filterIdNode = this.createElementNS(this.ogcns, 'ogc:FeatureId'); │ │ │ │ + filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ + filterNode.appendChild(filterIdNode); │ │ │ │ + updateNode.appendChild(filterNode); │ │ │ │ + │ │ │ │ + return updateNode; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getSlideFactor │ │ │ │ + * Method: remove │ │ │ │ + * Takes a feature, and generates a WFS-T Transaction "Delete" │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * dim - {String} "w" or "h" (for width or height). │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} The slide factor for panning in the requested direction. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - getSlideFactor: function(dim) { │ │ │ │ - return this.slideRatio ? │ │ │ │ - this.map.getSize()[dim] * this.slideRatio : │ │ │ │ - this.slideFactor; │ │ │ │ - }, │ │ │ │ + remove: function(feature) { │ │ │ │ + if (!feature.fid) { │ │ │ │ + OpenLayers.Console.userError(OpenLayers.i18n("noFID")); │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + var deleteNode = this.createElementNS(this.wfsns, 'wfs:Delete'); │ │ │ │ + deleteNode.setAttribute("typeName", this.featurePrefix + ':' + this.featureName); │ │ │ │ + deleteNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PanZoom" │ │ │ │ -}); │ │ │ │ + var filterNode = this.createElementNS(this.ogcns, 'ogc:Filter'); │ │ │ │ + var filterIdNode = this.createElementNS(this.ogcns, 'ogc:FeatureId'); │ │ │ │ + filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ + filterNode.appendChild(filterIdNode); │ │ │ │ + deleteNode.appendChild(filterNode); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: X │ │ │ │ - * {Integer} │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.PanZoom.X = 4; │ │ │ │ + return deleteNode; │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: Y │ │ │ │ - * {Integer} │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.PanZoom.Y = 4; │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Remove ciruclar ref to layer │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.layer = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFS" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/PanZoomBar.js │ │ │ │ + OpenLayers/Format/SOSGetFeatureOfInterest.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/PanZoom.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/GML/v3.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.PanZoomBar │ │ │ │ - * The PanZoomBar is a visible control composed of a │ │ │ │ - * <OpenLayers.Control.PanPanel> and a <OpenLayers.Control.ZoomBar>. │ │ │ │ - * By default it is displayed in the upper left corner of the map as 4 │ │ │ │ - * directional arrows above a vertical slider. │ │ │ │ + * Class: OpenLayers.Format.SOSGetFeatureOfInterest │ │ │ │ + * Read and write SOS GetFeatureOfInterest. This is used to get to │ │ │ │ + * the location of the features (stations). The stations can have 1 or more │ │ │ │ + * sensors. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control.PanZoom> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoom, { │ │ │ │ +OpenLayers.Format.SOSGetFeatureOfInterest = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomStopWidth │ │ │ │ - */ │ │ │ │ - zoomStopWidth: 18, │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.0.0 │ │ │ │ + */ │ │ │ │ + VERSION: "1.0.0", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomStopHeight │ │ │ │ - */ │ │ │ │ - zoomStopHeight: 11, │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + sos: "http://www.opengis.net/sos/1.0", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: slider │ │ │ │ - */ │ │ │ │ - slider: null, │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosAll.xsd", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: sliderEvents │ │ │ │ - * {<OpenLayers.Events>} │ │ │ │ - */ │ │ │ │ - sliderEvents: null, │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + */ │ │ │ │ + defaultPrefix: "sos", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: zoombarDiv │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - zoombarDiv: null, │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomWorldIcon │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - zoomWorldIcon: false, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.SOSGetFeatureOfInterest │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: panIcons │ │ │ │ - * {Boolean} Set this property to false not to display the pan icons. If │ │ │ │ - * false the zoom world icon is placed under the zoom bar. Defaults to │ │ │ │ - * true. │ │ │ │ - */ │ │ │ │ - panIcons: true, │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Parse a GetFeatureOfInterest response and return an array of features │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} An array of features. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: forceFixedZoomLevel │ │ │ │ - * {Boolean} Force a fixed zoom level even though the map has │ │ │ │ - * fractionalZoom │ │ │ │ - */ │ │ │ │ - forceFixedZoomLevel: false, │ │ │ │ + var info = { │ │ │ │ + features: [] │ │ │ │ + }; │ │ │ │ + this.readNode(data, info); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: mouseDragStart │ │ │ │ - * {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - mouseDragStart: null, │ │ │ │ + var features = []; │ │ │ │ + for (var i = 0, len = info.features.length; i < len; i++) { │ │ │ │ + var container = info.features[i]; │ │ │ │ + // reproject features if needed │ │ │ │ + if (this.internalProjection && this.externalProjection && │ │ │ │ + container.components[0]) { │ │ │ │ + container.components[0].transform( │ │ │ │ + this.externalProjection, this.internalProjection │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature.Vector( │ │ │ │ + container.components[0], container.attributes); │ │ │ │ + features.push(feature); │ │ │ │ + } │ │ │ │ + return features; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "sa": { │ │ │ │ + "SamplingPoint": function(node, obj) { │ │ │ │ + // sampling point can also be without a featureMember if │ │ │ │ + // there is only 1 │ │ │ │ + if (!obj.attributes) { │ │ │ │ + var feature = { │ │ │ │ + attributes: {} │ │ │ │ + }; │ │ │ │ + obj.features.push(feature); │ │ │ │ + obj = feature; │ │ │ │ + } │ │ │ │ + obj.attributes.id = this.getAttributeNS(node, │ │ │ │ + this.namespaces.gml, "id"); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "position": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ + "FeatureCollection": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "featureMember": function(node, obj) { │ │ │ │ + var feature = { │ │ │ │ + attributes: {} │ │ │ │ + }; │ │ │ │ + obj.features.push(feature); │ │ │ │ + this.readChildNodes(node, feature); │ │ │ │ + }, │ │ │ │ + "name": function(node, obj) { │ │ │ │ + obj.attributes.name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "pos": function(node, obj) { │ │ │ │ + // we need to parse the srsName to get to the │ │ │ │ + // externalProjection, that's why we cannot use │ │ │ │ + // GML v3 for this │ │ │ │ + if (!this.externalProjection) { │ │ │ │ + this.externalProjection = new OpenLayers.Projection( │ │ │ │ + node.getAttribute("srsName")); │ │ │ │ + } │ │ │ │ + OpenLayers.Format.GML.v3.prototype.readers.gml.pos.apply( │ │ │ │ + this, [node, obj]); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.GML.v3.prototype.readers.gml) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: { │ │ │ │ + "sos": { │ │ │ │ + "GetFeatureOfInterest": function(options) { │ │ │ │ + var node = this.createElementNSPlus("GetFeatureOfInterest", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + service: 'SOS', │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + for (var i = 0, len = options.fois.length; i < len; i++) { │ │ │ │ + this.writeNode("FeatureOfInterestId", { │ │ │ │ + foi: options.fois[i] │ │ │ │ + }, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "FeatureOfInterestId": function(options) { │ │ │ │ + var node = this.createElementNSPlus("FeatureOfInterestId", { │ │ │ │ + value: options.foi │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSGetFeatureOfInterest" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/OSM.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + * @requires OpenLayers/Projection.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.OSM │ │ │ │ + * OSM parser. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.OSM> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.OSM = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: deltaY │ │ │ │ - * {Number} The cumulative vertical pixel offset during a zoom bar drag. │ │ │ │ + * APIProperty: checkTags │ │ │ │ + * {Boolean} Should tags be checked to determine whether something │ │ │ │ + * should be treated as a seperate node. Will slow down parsing. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - deltaY: null, │ │ │ │ + checkTags: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: zoomStart │ │ │ │ - * {<OpenLayers.Pixel>} │ │ │ │ + * Property: interestingTagsExclude │ │ │ │ + * {Array} List of tags to exclude from 'interesting' checks on nodes. │ │ │ │ + * Must be set when creating the format. Will only be used if checkTags │ │ │ │ + * is set. │ │ │ │ */ │ │ │ │ - zoomStart: null, │ │ │ │ + interestingTagsExclude: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.PanZoomBar │ │ │ │ + * APIProperty: areaTags │ │ │ │ + * {Array} List of tags indicating that something is an area. │ │ │ │ + * Must be set when creating the format. Will only be used if │ │ │ │ + * checkTags is true. │ │ │ │ */ │ │ │ │ + areaTags: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Constructor: OpenLayers.Format.OSM │ │ │ │ + * Create a new parser for OSM. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ + initialize: function(options) { │ │ │ │ + var layer_defaults = { │ │ │ │ + 'interestingTagsExclude': ['source', 'source_ref', │ │ │ │ + 'source:ref', 'history', 'attribution', 'created_by' │ │ │ │ + ], │ │ │ │ + 'areaTags': ['area', 'building', 'leisure', 'tourism', 'ruins', │ │ │ │ + 'historic', 'landuse', 'military', 'natural', 'sport' │ │ │ │ + ] │ │ │ │ + }; │ │ │ │ │ │ │ │ - this._removeZoomBar(); │ │ │ │ + layer_defaults = OpenLayers.Util.extend(layer_defaults, options); │ │ │ │ │ │ │ │ - this.map.events.un({ │ │ │ │ - "changebaselayer": this.redraw, │ │ │ │ - "updatesize": this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + var interesting = {}; │ │ │ │ + for (var i = 0; i < layer_defaults.interestingTagsExclude.length; i++) { │ │ │ │ + interesting[layer_defaults.interestingTagsExclude[i]] = true; │ │ │ │ + } │ │ │ │ + layer_defaults.interestingTagsExclude = interesting; │ │ │ │ │ │ │ │ - OpenLayers.Control.PanZoom.prototype.destroy.apply(this, arguments); │ │ │ │ + var area = {}; │ │ │ │ + for (var i = 0; i < layer_defaults.areaTags.length; i++) { │ │ │ │ + area[layer_defaults.areaTags[i]] = true; │ │ │ │ + } │ │ │ │ + layer_defaults.areaTags = area; │ │ │ │ │ │ │ │ - delete this.mouseDragStart; │ │ │ │ - delete this.zoomStart; │ │ │ │ + // OSM coordinates are always in longlat WGS84 │ │ │ │ + this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [layer_defaults]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ + * APIMethod: read │ │ │ │ + * Return a list of features from a OSM doc │ │ │ │ + │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.PanZoom.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.on({ │ │ │ │ - "changebaselayer": this.redraw, │ │ │ │ - "updatesize": this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: redraw │ │ │ │ - * clear the div and start over. │ │ │ │ + * doc - {Element} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ */ │ │ │ │ - redraw: function() { │ │ │ │ - if (this.div != null) { │ │ │ │ - this.removeButtons(); │ │ │ │ - this._removeZoomBar(); │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ } │ │ │ │ - this.draw(); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - draw: function(px) { │ │ │ │ - // initialize our internal div │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - px = this.position.clone(); │ │ │ │ + var nodes = this.getNodes(doc); │ │ │ │ + var ways = this.getWays(doc); │ │ │ │ │ │ │ │ - // place the controls │ │ │ │ - this.buttons = []; │ │ │ │ + // Geoms will contain at least ways.length entries. │ │ │ │ + var feat_list = new Array(ways.length); │ │ │ │ │ │ │ │ - var sz = { │ │ │ │ - w: 18, │ │ │ │ - h: 18 │ │ │ │ - }; │ │ │ │ - if (this.panIcons) { │ │ │ │ - var centered = new OpenLayers.Pixel(px.x + sz.w / 2, px.y); │ │ │ │ - var wposition = sz.w; │ │ │ │ + for (var i = 0; i < ways.length; i++) { │ │ │ │ + // We know the minimal of this one ahead of time. (Could be -1 │ │ │ │ + // due to areas/polygons) │ │ │ │ + var point_list = new Array(ways[i].nodes.length); │ │ │ │ │ │ │ │ - if (this.zoomWorldIcon) { │ │ │ │ - centered = new OpenLayers.Pixel(px.x + sz.w, px.y); │ │ │ │ - } │ │ │ │ + var poly = this.isWayArea(ways[i]) ? 1 : 0; │ │ │ │ + for (var j = 0; j < ways[i].nodes.length; j++) { │ │ │ │ + var node = nodes[ways[i].nodes[j]]; │ │ │ │ │ │ │ │ - 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); │ │ │ │ + var point = new OpenLayers.Geometry.Point(node.lon, node.lat); │ │ │ │ │ │ │ │ - wposition *= 2; │ │ │ │ + // Since OSM is topological, we stash the node ID internally. │ │ │ │ + point.osm_id = parseInt(ways[i].nodes[j]); │ │ │ │ + point_list[j] = point; │ │ │ │ + │ │ │ │ + // We don't display nodes if they're used inside other │ │ │ │ + // elements. │ │ │ │ + node.used = true; │ │ │ │ } │ │ │ │ - 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); │ │ │ │ - } else { │ │ │ │ - this._addButton("zoomin", "zoom-plus-mini.png", px, sz); │ │ │ │ - centered = this._addZoomBar(px.add(0, sz.h)); │ │ │ │ - this._addButton("zoomout", "zoom-minus-mini.png", centered, sz); │ │ │ │ - if (this.zoomWorldIcon) { │ │ │ │ - centered = centered.add(0, sz.h + 3); │ │ │ │ - this._addButton("zoomworld", "zoom-world-mini.png", centered, sz); │ │ │ │ + var geometry = null; │ │ │ │ + if (poly) { │ │ │ │ + geometry = new OpenLayers.Geometry.Polygon( │ │ │ │ + new OpenLayers.Geometry.LinearRing(point_list)); │ │ │ │ + } else { │ │ │ │ + geometry = new OpenLayers.Geometry.LineString(point_list); │ │ │ │ + } │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ } │ │ │ │ + var feat = new OpenLayers.Feature.Vector(geometry, │ │ │ │ + ways[i].tags); │ │ │ │ + feat.osm_id = parseInt(ways[i].id); │ │ │ │ + feat.fid = "way." + feat.osm_id; │ │ │ │ + feat_list[i] = feat; │ │ │ │ } │ │ │ │ - return this.div; │ │ │ │ + for (var node_id in nodes) { │ │ │ │ + var node = nodes[node_id]; │ │ │ │ + if (!node.used || this.checkTags) { │ │ │ │ + var tags = null; │ │ │ │ + │ │ │ │ + if (this.checkTags) { │ │ │ │ + var result = this.getTags(node.node, true); │ │ │ │ + if (node.used && !result[1]) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + tags = result[0]; │ │ │ │ + } else { │ │ │ │ + tags = this.getTags(node.node); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var feat = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.Point(node['lon'], node['lat']), │ │ │ │ + tags); │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + feat.geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ + } │ │ │ │ + feat.osm_id = parseInt(node_id); │ │ │ │ + feat.fid = "node." + feat.osm_id; │ │ │ │ + feat_list.push(feat); │ │ │ │ + } │ │ │ │ + // Memory cleanup │ │ │ │ + node.node = null; │ │ │ │ + } │ │ │ │ + return feat_list; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: _addZoomBar │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: getNodes │ │ │ │ + * Return the node items from a doc. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * centered - {<OpenLayers.Pixel>} where zoombar drawing is to start. │ │ │ │ + * doc - {DOMElement} node to parse tags from │ │ │ │ */ │ │ │ │ - _addZoomBar: function(centered) { │ │ │ │ - var imgLocation = OpenLayers.Util.getImageLocation("slider.png"); │ │ │ │ - var id = this.id + "_" + this.map.id; │ │ │ │ - var minZoom = this.map.getMinZoom(); │ │ │ │ - var zoomsToEnd = this.map.getNumZoomLevels() - 1 - this.map.getZoom(); │ │ │ │ - var slider = OpenLayers.Util.createAlphaImageDiv(id, │ │ │ │ - centered.add(-1, zoomsToEnd * this.zoomStopHeight), { │ │ │ │ - w: 20, │ │ │ │ - h: 9 │ │ │ │ - }, │ │ │ │ - imgLocation, │ │ │ │ - "absolute"); │ │ │ │ - slider.style.cursor = "move"; │ │ │ │ - this.slider = slider; │ │ │ │ - │ │ │ │ - this.sliderEvents = new OpenLayers.Events(this, slider, null, true, { │ │ │ │ - includeXY: true │ │ │ │ - }); │ │ │ │ - this.sliderEvents.on({ │ │ │ │ - "touchstart": this.zoomBarDown, │ │ │ │ - "touchmove": this.zoomBarDrag, │ │ │ │ - "touchend": this.zoomBarUp, │ │ │ │ - "mousedown": this.zoomBarDown, │ │ │ │ - "mousemove": this.zoomBarDrag, │ │ │ │ - "mouseup": this.zoomBarUp │ │ │ │ - }); │ │ │ │ + getNodes: function(doc) { │ │ │ │ + var node_list = doc.getElementsByTagName("node"); │ │ │ │ + var nodes = {}; │ │ │ │ + for (var i = 0; i < node_list.length; i++) { │ │ │ │ + var node = node_list[i]; │ │ │ │ + var id = node.getAttribute("id"); │ │ │ │ + nodes[id] = { │ │ │ │ + 'lat': node.getAttribute("lat"), │ │ │ │ + 'lon': node.getAttribute("lon"), │ │ │ │ + 'node': node │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + return nodes; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var sz = { │ │ │ │ - w: this.zoomStopWidth, │ │ │ │ - h: this.zoomStopHeight * (this.map.getNumZoomLevels() - minZoom) │ │ │ │ - }; │ │ │ │ - var imgLocation = OpenLayers.Util.getImageLocation("zoombar.png"); │ │ │ │ - var div = null; │ │ │ │ + /** │ │ │ │ + * Method: getWays │ │ │ │ + * Return the way items from a doc. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * doc - {DOMElement} node to parse tags from │ │ │ │ + */ │ │ │ │ + getWays: function(doc) { │ │ │ │ + var way_list = doc.getElementsByTagName("way"); │ │ │ │ + var return_ways = []; │ │ │ │ + for (var i = 0; i < way_list.length; i++) { │ │ │ │ + var way = way_list[i]; │ │ │ │ + var way_object = { │ │ │ │ + id: way.getAttribute("id") │ │ │ │ + }; │ │ │ │ │ │ │ │ - if (OpenLayers.Util.alphaHack()) { │ │ │ │ - var id = this.id + "_" + this.map.id; │ │ │ │ - div = OpenLayers.Util.createAlphaImageDiv(id, centered, { │ │ │ │ - w: sz.w, │ │ │ │ - h: this.zoomStopHeight │ │ │ │ - }, │ │ │ │ - imgLocation, │ │ │ │ - "absolute", null, "crop"); │ │ │ │ - div.style.height = sz.h + "px"; │ │ │ │ - } else { │ │ │ │ - div = OpenLayers.Util.createDiv( │ │ │ │ - 'OpenLayers_Control_PanZoomBar_Zoombar' + this.map.id, │ │ │ │ - centered, │ │ │ │ - sz, │ │ │ │ - imgLocation); │ │ │ │ - } │ │ │ │ - div.style.cursor = "pointer"; │ │ │ │ - div.className = "olButton"; │ │ │ │ - this.zoombarDiv = div; │ │ │ │ + way_object.tags = this.getTags(way); │ │ │ │ │ │ │ │ - this.div.appendChild(div); │ │ │ │ + var node_list = way.getElementsByTagName("nd"); │ │ │ │ │ │ │ │ - this.startTop = parseInt(div.style.top); │ │ │ │ - this.div.appendChild(slider); │ │ │ │ + way_object.nodes = new Array(node_list.length); │ │ │ │ │ │ │ │ - this.map.events.register("zoomend", this, this.moveZoomBar); │ │ │ │ + for (var j = 0; j < node_list.length; j++) { │ │ │ │ + way_object.nodes[j] = node_list[j].getAttribute("ref"); │ │ │ │ + } │ │ │ │ + return_ways.push(way_object); │ │ │ │ + } │ │ │ │ + return return_ways; │ │ │ │ │ │ │ │ - centered = centered.add(0, │ │ │ │ - this.zoomStopHeight * (this.map.getNumZoomLevels() - minZoom)); │ │ │ │ - return centered; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: _removeZoomBar │ │ │ │ + * Method: getTags │ │ │ │ + * Return the tags list attached to a specific DOM element. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * dom_node - {DOMElement} node to parse tags from │ │ │ │ + * interesting_tags - {Boolean} whether the return from this function should │ │ │ │ + * return a boolean indicating that it has 'interesting tags' -- │ │ │ │ + * tags like attribution and source are ignored. (To change the list │ │ │ │ + * of tags, see interestingTagsExclude) │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * tags - {Object} hash of tags │ │ │ │ + * interesting - {Boolean} if interesting_tags is passed, returns │ │ │ │ + * whether there are any interesting tags on this element. │ │ │ │ */ │ │ │ │ - _removeZoomBar: function() { │ │ │ │ - this.sliderEvents.un({ │ │ │ │ - "touchstart": this.zoomBarDown, │ │ │ │ - "touchmove": this.zoomBarDrag, │ │ │ │ - "touchend": this.zoomBarUp, │ │ │ │ - "mousedown": this.zoomBarDown, │ │ │ │ - "mousemove": this.zoomBarDrag, │ │ │ │ - "mouseup": this.zoomBarUp │ │ │ │ - }); │ │ │ │ - this.sliderEvents.destroy(); │ │ │ │ + getTags: function(dom_node, interesting_tags) { │ │ │ │ + var tag_list = dom_node.getElementsByTagName("tag"); │ │ │ │ + var tags = {}; │ │ │ │ + var interesting = false; │ │ │ │ + for (var j = 0; j < tag_list.length; j++) { │ │ │ │ + var key = tag_list[j].getAttribute("k"); │ │ │ │ + tags[key] = tag_list[j].getAttribute("v"); │ │ │ │ + if (interesting_tags) { │ │ │ │ + if (!this.interestingTagsExclude[key]) { │ │ │ │ + interesting = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return interesting_tags ? [tags, interesting] : tags; │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.div.removeChild(this.zoombarDiv); │ │ │ │ - this.zoombarDiv = null; │ │ │ │ - this.div.removeChild(this.slider); │ │ │ │ - this.slider = null; │ │ │ │ + /** │ │ │ │ + * Method: isWayArea │ │ │ │ + * Given a way object from getWays, check whether the tags and geometry │ │ │ │ + * indicate something is an area. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + isWayArea: function(way) { │ │ │ │ + var poly_shaped = false; │ │ │ │ + var poly_tags = false; │ │ │ │ │ │ │ │ - this.map.events.unregister("zoomend", this, this.moveZoomBar); │ │ │ │ + if (way.nodes[0] == way.nodes[way.nodes.length - 1]) { │ │ │ │ + poly_shaped = true; │ │ │ │ + } │ │ │ │ + if (this.checkTags) { │ │ │ │ + for (var key in way.tags) { │ │ │ │ + if (this.areaTags[key]) { │ │ │ │ + poly_tags = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return poly_shaped && (this.checkTags ? poly_tags : true); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onButtonClick │ │ │ │ + * APIMethod: write │ │ │ │ + * Takes a list of features, returns a serialized OSM format file for use │ │ │ │ + * in tools like JOSM. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - OpenLayers.Control.PanZoom.prototype.onButtonClick.apply(this, arguments); │ │ │ │ - if (evt.buttonElement === this.zoombarDiv) { │ │ │ │ - var levels = evt.buttonXY.y / this.zoomStopHeight; │ │ │ │ - if (this.forceFixedZoomLevel || !this.map.fractionalZoom) { │ │ │ │ - levels = Math.floor(levels); │ │ │ │ + write: function(features) { │ │ │ │ + if (!(OpenLayers.Util.isArray(features))) { │ │ │ │ + features = [features]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.osm_id = 1; │ │ │ │ + this.created_nodes = {}; │ │ │ │ + var root_node = this.createElementNS(null, "osm"); │ │ │ │ + root_node.setAttribute("version", "0.5"); │ │ │ │ + root_node.setAttribute("generator", "OpenLayers " + OpenLayers.VERSION_NUMBER); │ │ │ │ + │ │ │ │ + // Loop backwards, because the deserializer puts nodes last, and │ │ │ │ + // we want them first if possible │ │ │ │ + for (var i = features.length - 1; i >= 0; i--) { │ │ │ │ + var nodes = this.createFeatureNodes(features[i]); │ │ │ │ + for (var j = 0; j < nodes.length; j++) { │ │ │ │ + root_node.appendChild(nodes[j]); │ │ │ │ } │ │ │ │ - var zoom = (this.map.getNumZoomLevels() - 1) - levels; │ │ │ │ - zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1); │ │ │ │ - this.map.zoomTo(zoom); │ │ │ │ } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root_node]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * Method: createFeatureNodes │ │ │ │ + * Takes a feature, returns a list of nodes from size 0->n. │ │ │ │ + * Will include all pieces of the serialization that are required which │ │ │ │ + * have not already been created. Calls out to createXML based on geometry │ │ │ │ + * type. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - passEventToSlider: function(evt) { │ │ │ │ - this.sliderEvents.handleBrowserEvent(evt); │ │ │ │ + createFeatureNodes: function(feature) { │ │ │ │ + var nodes = []; │ │ │ │ + var className = feature.geometry.CLASS_NAME; │ │ │ │ + var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ + type = type.toLowerCase(); │ │ │ │ + var builder = this.createXML[type]; │ │ │ │ + if (builder) { │ │ │ │ + nodes = builder.apply(this, [feature]); │ │ │ │ + } │ │ │ │ + return nodes; │ │ │ │ }, │ │ │ │ │ │ │ │ - /* │ │ │ │ - * Method: zoomBarDown │ │ │ │ - * event listener for clicks on the slider │ │ │ │ + /** │ │ │ │ + * Method: createXML │ │ │ │ + * Takes a feature, returns a list of nodes from size 0->n. │ │ │ │ + * Will include all pieces of the serialization that are required which │ │ │ │ + * have not already been created. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - zoomBarDown: function(evt) { │ │ │ │ - if (!OpenLayers.Event.isLeftClick(evt) && !OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ - return; │ │ │ │ + createXML: { │ │ │ │ + 'point': function(point) { │ │ │ │ + var id = null; │ │ │ │ + var geometry = point.geometry ? point.geometry : point; │ │ │ │ + │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + geometry.transform(this.internalProjection, │ │ │ │ + this.externalProjection); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var already_exists = false; // We don't return anything if the node │ │ │ │ + // has already been created │ │ │ │ + if (point.osm_id) { │ │ │ │ + id = point.osm_id; │ │ │ │ + if (this.created_nodes[id]) { │ │ │ │ + already_exists = true; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + id = -this.osm_id; │ │ │ │ + this.osm_id++; │ │ │ │ + } │ │ │ │ + if (already_exists) { │ │ │ │ + node = this.created_nodes[id]; │ │ │ │ + } else { │ │ │ │ + var node = this.createElementNS(null, "node"); │ │ │ │ + } │ │ │ │ + this.created_nodes[id] = node; │ │ │ │ + node.setAttribute("id", id); │ │ │ │ + node.setAttribute("lon", geometry.x); │ │ │ │ + node.setAttribute("lat", geometry.y); │ │ │ │ + if (point.attributes) { │ │ │ │ + this.serializeTags(point, node); │ │ │ │ + } │ │ │ │ + this.setState(point, node); │ │ │ │ + return already_exists ? [] : [node]; │ │ │ │ + }, │ │ │ │ + linestring: function(feature) { │ │ │ │ + var id; │ │ │ │ + var nodes = []; │ │ │ │ + var geometry = feature.geometry; │ │ │ │ + if (feature.osm_id) { │ │ │ │ + id = feature.osm_id; │ │ │ │ + } else { │ │ │ │ + id = -this.osm_id; │ │ │ │ + this.osm_id++; │ │ │ │ + } │ │ │ │ + var way = this.createElementNS(null, "way"); │ │ │ │ + way.setAttribute("id", id); │ │ │ │ + for (var i = 0; i < geometry.components.length; i++) { │ │ │ │ + var node = this.createXML['point'].apply(this, [geometry.components[i]]); │ │ │ │ + if (node.length) { │ │ │ │ + node = node[0]; │ │ │ │ + var node_ref = node.getAttribute("id"); │ │ │ │ + nodes.push(node); │ │ │ │ + } else { │ │ │ │ + node_ref = geometry.components[i].osm_id; │ │ │ │ + node = this.created_nodes[node_ref]; │ │ │ │ + } │ │ │ │ + this.setState(feature, node); │ │ │ │ + var nd_dom = this.createElementNS(null, "nd"); │ │ │ │ + nd_dom.setAttribute("ref", node_ref); │ │ │ │ + way.appendChild(nd_dom); │ │ │ │ + } │ │ │ │ + this.serializeTags(feature, way); │ │ │ │ + nodes.push(way); │ │ │ │ + │ │ │ │ + return nodes; │ │ │ │ + }, │ │ │ │ + polygon: function(feature) { │ │ │ │ + var attrs = OpenLayers.Util.extend({ │ │ │ │ + 'area': 'yes' │ │ │ │ + }, feature.attributes); │ │ │ │ + var feat = new OpenLayers.Feature.Vector(feature.geometry.components[0], attrs); │ │ │ │ + feat.osm_id = feature.osm_id; │ │ │ │ + return this.createXML['linestring'].apply(this, [feat]); │ │ │ │ } │ │ │ │ - this.map.events.on({ │ │ │ │ - "touchmove": this.passEventToSlider, │ │ │ │ - "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 │ │ │ │ + /** │ │ │ │ + * Method: serializeTags │ │ │ │ + * Given a feature, serialize the attributes onto the given node. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * node - {DOMNode} │ │ │ │ */ │ │ │ │ - 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(); │ │ │ │ - } │ │ │ │ - // set cumulative displacement │ │ │ │ - this.deltaY = this.zoomStart.y - evt.xy.y; │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ + serializeTags: function(feature, node) { │ │ │ │ + for (var key in feature.attributes) { │ │ │ │ + var tag = this.createElementNS(null, "tag"); │ │ │ │ + tag.setAttribute("k", key); │ │ │ │ + tag.setAttribute("v", feature.attributes[key]); │ │ │ │ + node.appendChild(tag); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /* │ │ │ │ - * Method: zoomBarUp │ │ │ │ - * Perform cleanup when a mouseup event is received -- discover new zoom │ │ │ │ - * level and switch to it. │ │ │ │ + /** │ │ │ │ + * Method: setState │ │ │ │ + * OpenStreetMap has a convention that 'state' is stored for modification or deletion. │ │ │ │ + * This allows the file to be uploaded via JOSM or the bulk uploader tool. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * node - {DOMNode} │ │ │ │ */ │ │ │ │ - zoomBarUp: function(evt) { │ │ │ │ - if (!OpenLayers.Event.isLeftClick(evt) && evt.type !== "touchend") { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (this.mouseDragStart) { │ │ │ │ - this.div.style.cursor = ""; │ │ │ │ - this.map.events.un({ │ │ │ │ - "touchmove": this.passEventToSlider, │ │ │ │ - "mouseup": this.passEventToSlider, │ │ │ │ - "mousemove": this.passEventToSlider, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - var zoomLevel = this.map.zoom; │ │ │ │ - if (!this.forceFixedZoomLevel && this.map.fractionalZoom) { │ │ │ │ - zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ - zoomLevel = Math.min(Math.max(zoomLevel, 0), │ │ │ │ - this.map.getNumZoomLevels() - 1); │ │ │ │ - } else { │ │ │ │ - zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ - zoomLevel = Math.max(Math.round(zoomLevel), 0); │ │ │ │ + setState: function(feature, node) { │ │ │ │ + if (feature.state) { │ │ │ │ + var state = null; │ │ │ │ + switch (feature.state) { │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + state = "modify"; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + state = "delete"; │ │ │ │ + } │ │ │ │ + if (state) { │ │ │ │ + node.setAttribute("action", state); │ │ │ │ } │ │ │ │ - this.map.zoomTo(zoomLevel); │ │ │ │ - this.mouseDragStart = null; │ │ │ │ - this.zoomStart = null; │ │ │ │ - this.deltaY = 0; │ │ │ │ - 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" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.OSM" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Pinch.js │ │ │ │ + OpenLayers/Format/SOSGetObservation.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/SOSGetFeatureOfInterest.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Pinch │ │ │ │ - * The pinch handler is used to deal with sequences of browser events related │ │ │ │ - * to pinch gestures. The handler is used by controls that want to know │ │ │ │ - * when a pinch sequence begins, when a pinch is happening, and when it has │ │ │ │ - * finished. │ │ │ │ - * │ │ │ │ - * Controls that use the pinch handler typically construct it with callbacks │ │ │ │ - * for 'start', 'move', and 'done'. Callbacks for these keys are │ │ │ │ - * called when the pinch begins, with each change, and when the pinch is │ │ │ │ - * done. │ │ │ │ - * │ │ │ │ - * Create a new pinch handler with the <OpenLayers.Handler.Pinch> constructor. │ │ │ │ + * Class: OpenLayers.Format.SOSGetObservation │ │ │ │ + * Read and write SOS GetObersation (to get the actual values from a sensor) │ │ │ │ + * version 1.0.0 │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Pinch = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ +OpenLayers.Format.SOSGetObservation = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: started │ │ │ │ - * {Boolean} When a touchstart event is received, we want to record it, │ │ │ │ - * but not set 'pinching' until the touchmove get started after │ │ │ │ - * starting. │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - started: false, │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + sos: "http://www.opengis.net/sos/1.0", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + om: "http://www.opengis.net/om/1.0", │ │ │ │ + sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: stopDown │ │ │ │ - * {Boolean} Stop propagation of touchstart events from getting to │ │ │ │ - * listeners on the same element. Default is false. │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ */ │ │ │ │ - stopDown: false, │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: pinching │ │ │ │ - * {Boolean} │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.0.0 │ │ │ │ */ │ │ │ │ - pinching: false, │ │ │ │ + VERSION: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: last │ │ │ │ - * {Object} Object that store informations related to pinch last touch. │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location │ │ │ │ */ │ │ │ │ - last: null, │ │ │ │ + schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosGetObservation.xsd", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: start │ │ │ │ - * {Object} Object that store informations related to pinch touchstart. │ │ │ │ + * Property: defaultPrefix │ │ │ │ */ │ │ │ │ - start: null, │ │ │ │ + defaultPrefix: "sos", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Pinch │ │ │ │ - * Returns OpenLayers.Handler.Pinch │ │ │ │ + * Constructor: OpenLayers.Format.SOSGetObservation │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ - * this handler. If a handler is being used without a control, the │ │ │ │ - * handlers setMap method must be overridden to deal properly with │ │ │ │ - * the map. │ │ │ │ - * callbacks - {Object} An object containing functions to be called when │ │ │ │ - * the pinch operation start, change, or is finished. The callbacks │ │ │ │ - * should expect to receive an object argument, which contains │ │ │ │ - * information about scale, distance, and position of touch points. │ │ │ │ - * options - {Object} │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: read │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {Object} An object containing the measurements │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - this.pinching = false; │ │ │ │ - if (OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ - this.started = true; │ │ │ │ - this.last = this.start = { │ │ │ │ - distance: this.getDistance(evt.touches), │ │ │ │ - delta: 0, │ │ │ │ - scale: 1 │ │ │ │ - }; │ │ │ │ - this.callback("start", [evt, this.start]); │ │ │ │ - propagate = !this.stopDown; │ │ │ │ - } else if (this.started) { │ │ │ │ - // Some webkit versions send fake single-touch events during │ │ │ │ - // multitouch, which cause the drag handler to trigger │ │ │ │ - return false; │ │ │ │ - } else { │ │ │ │ - this.started = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ } │ │ │ │ - // prevent document dragging │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - return propagate; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Handle touchmove events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ - */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - if (this.started && OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ - this.pinching = true; │ │ │ │ - var current = this.getPinchData(evt); │ │ │ │ - this.callback("move", [evt, current]); │ │ │ │ - this.last = current; │ │ │ │ - // prevent document dragging │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - } else if (this.started) { │ │ │ │ - // Some webkit versions send fake single-touch events during │ │ │ │ - // multitouch, which cause the drag handler to trigger │ │ │ │ - return false; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ } │ │ │ │ - return true; │ │ │ │ + var info = { │ │ │ │ + measurements: [], │ │ │ │ + observations: [] │ │ │ │ + }; │ │ │ │ + this.readNode(data, info); │ │ │ │ + return info; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchend │ │ │ │ - * Handle touchend events │ │ │ │ + * Method: write │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * options - {Object} Optional object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {String} An SOS GetObservation request XML string. │ │ │ │ */ │ │ │ │ - touchend: function(evt) { │ │ │ │ - if (this.started && !OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ - this.started = false; │ │ │ │ - this.pinching = false; │ │ │ │ - this.callback("done", [evt, this.start, this.last]); │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ + write: function(options) { │ │ │ │ + var node = this.writeNode("sos:GetObservation", options); │ │ │ │ + node.setAttribute("xmlns:om", this.namespaces.om); │ │ │ │ + node.setAttribute("xmlns:ogc", this.namespaces.ogc); │ │ │ │ + this.setAttributeNS( │ │ │ │ + node, this.namespaces.xsi, │ │ │ │ + "xsi:schemaLocation", this.schemaLocation │ │ │ │ + ); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully activated. │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.pinching = false; │ │ │ │ - activated = true; │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ + readers: { │ │ │ │ + "om": { │ │ │ │ + "ObservationCollection": function(node, obj) { │ │ │ │ + obj.id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "member": function(node, observationCollection) { │ │ │ │ + this.readChildNodes(node, observationCollection); │ │ │ │ + }, │ │ │ │ + "Measurement": function(node, observationCollection) { │ │ │ │ + var measurement = {}; │ │ │ │ + observationCollection.measurements.push(measurement); │ │ │ │ + this.readChildNodes(node, measurement); │ │ │ │ + }, │ │ │ │ + "Observation": function(node, observationCollection) { │ │ │ │ + var observation = {}; │ │ │ │ + observationCollection.observations.push(observation); │ │ │ │ + this.readChildNodes(node, observation); │ │ │ │ + }, │ │ │ │ + "samplingTime": function(node, measurement) { │ │ │ │ + var samplingTime = {}; │ │ │ │ + measurement.samplingTime = samplingTime; │ │ │ │ + this.readChildNodes(node, samplingTime); │ │ │ │ + }, │ │ │ │ + "observedProperty": function(node, measurement) { │ │ │ │ + measurement.observedProperty = │ │ │ │ + this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ + this.readChildNodes(node, measurement); │ │ │ │ + }, │ │ │ │ + "procedure": function(node, measurement) { │ │ │ │ + measurement.procedure = │ │ │ │ + this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ + this.readChildNodes(node, measurement); │ │ │ │ + }, │ │ │ │ + "featureOfInterest": function(node, observation) { │ │ │ │ + var foi = { │ │ │ │ + features: [] │ │ │ │ + }; │ │ │ │ + observation.fois = []; │ │ │ │ + observation.fois.push(foi); │ │ │ │ + this.readChildNodes(node, foi); │ │ │ │ + // postprocessing to get actual features │ │ │ │ + var features = []; │ │ │ │ + for (var i = 0, len = foi.features.length; i < len; i++) { │ │ │ │ + var feature = foi.features[i]; │ │ │ │ + features.push(new OpenLayers.Feature.Vector( │ │ │ │ + feature.components[0], feature.attributes)); │ │ │ │ + } │ │ │ │ + foi.features = features; │ │ │ │ + }, │ │ │ │ + "result": function(node, measurement) { │ │ │ │ + var result = {}; │ │ │ │ + measurement.result = result; │ │ │ │ + if (this.getChildValue(node) !== '') { │ │ │ │ + result.value = this.getChildValue(node); │ │ │ │ + result.uom = node.getAttribute("uom"); │ │ │ │ + } else { │ │ │ │ + this.readChildNodes(node, result); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "sa": OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.sa, │ │ │ │ + "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ + "TimeInstant": function(node, samplingTime) { │ │ │ │ + var timeInstant = {}; │ │ │ │ + samplingTime.timeInstant = timeInstant; │ │ │ │ + this.readChildNodes(node, timeInstant); │ │ │ │ + }, │ │ │ │ + "timePosition": function(node, timeInstant) { │ │ │ │ + timeInstant.timePosition = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.gml) │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivate the handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated. │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.started = false; │ │ │ │ - this.pinching = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ + writers: { │ │ │ │ + "sos": { │ │ │ │ + "GetObservation": function(options) { │ │ │ │ + var node = this.createElementNSPlus("GetObservation", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + service: 'SOS' │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("offering", options, node); │ │ │ │ + if (options.eventTime) { │ │ │ │ + this.writeNode("eventTime", options, node); │ │ │ │ + } │ │ │ │ + for (var procedure in options.procedures) { │ │ │ │ + this.writeNode("procedure", options.procedures[procedure], node); │ │ │ │ + } │ │ │ │ + for (var observedProperty in options.observedProperties) { │ │ │ │ + this.writeNode("observedProperty", options.observedProperties[observedProperty], node); │ │ │ │ + } │ │ │ │ + if (options.foi) { │ │ │ │ + this.writeNode("featureOfInterest", options.foi, node); │ │ │ │ + } │ │ │ │ + this.writeNode("responseFormat", options, node); │ │ │ │ + if (options.resultModel) { │ │ │ │ + this.writeNode("resultModel", options, node); │ │ │ │ + } │ │ │ │ + if (options.responseMode) { │ │ │ │ + this.writeNode("responseMode", options, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "featureOfInterest": function(foi) { │ │ │ │ + var node = this.createElementNSPlus("featureOfInterest"); │ │ │ │ + this.writeNode("ObjectID", foi.objectId, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ObjectID": function(options) { │ │ │ │ + return this.createElementNSPlus("ObjectID", { │ │ │ │ + value: options │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "responseFormat": function(options) { │ │ │ │ + return this.createElementNSPlus("responseFormat", { │ │ │ │ + value: options.responseFormat │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "procedure": function(procedure) { │ │ │ │ + return this.createElementNSPlus("procedure", { │ │ │ │ + value: procedure │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "offering": function(options) { │ │ │ │ + return this.createElementNSPlus("offering", { │ │ │ │ + value: options.offering │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "observedProperty": function(observedProperty) { │ │ │ │ + return this.createElementNSPlus("observedProperty", { │ │ │ │ + value: observedProperty │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "eventTime": function(options) { │ │ │ │ + var node = this.createElementNSPlus("eventTime"); │ │ │ │ + if (options.eventTime === 'latest') { │ │ │ │ + this.writeNode("ogc:TM_Equals", options, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "resultModel": function(options) { │ │ │ │ + return this.createElementNSPlus("resultModel", { │ │ │ │ + value: options.resultModel │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "responseMode": function(options) { │ │ │ │ + return this.createElementNSPlus("responseMode", { │ │ │ │ + value: options.responseMode │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ogc": { │ │ │ │ + "TM_Equals": function(options) { │ │ │ │ + var node = this.createElementNSPlus("ogc:TM_Equals"); │ │ │ │ + this.writeNode("ogc:PropertyName", { │ │ │ │ + property: "urn:ogc:data:time:iso8601" │ │ │ │ + }, node); │ │ │ │ + if (options.eventTime === 'latest') { │ │ │ │ + this.writeNode("gml:TimeInstant", { │ │ │ │ + value: 'latest' │ │ │ │ + }, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "PropertyName": function(options) { │ │ │ │ + return this.createElementNSPlus("ogc:PropertyName", { │ │ │ │ + value: options.property │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "gml": { │ │ │ │ + "TimeInstant": function(options) { │ │ │ │ + var node = this.createElementNSPlus("gml:TimeInstant"); │ │ │ │ + this.writeNode("gml:timePosition", options, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "timePosition": function(options) { │ │ │ │ + var node = this.createElementNSPlus("gml:timePosition", { │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + } │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getDistance │ │ │ │ - * Get the distance in pixels between two touches. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * touches - {Array(Object)} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} The distance in pixels. │ │ │ │ - */ │ │ │ │ - getDistance: function(touches) { │ │ │ │ - var t0 = touches[0]; │ │ │ │ - var t1 = touches[1]; │ │ │ │ - return Math.sqrt( │ │ │ │ - Math.pow(t0.olClientX - t1.olClientX, 2) + │ │ │ │ - Math.pow(t0.olClientY - t1.olClientY, 2) │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getPinchData │ │ │ │ - * Get informations about the pinch event. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Object that contains data about the current pinch. │ │ │ │ - */ │ │ │ │ - getPinchData: function(evt) { │ │ │ │ - var distance = this.getDistance(evt.touches); │ │ │ │ - var scale = distance / this.start.distance; │ │ │ │ - return { │ │ │ │ - distance: distance, │ │ │ │ - delta: this.last.distance - distance, │ │ │ │ - scale: scale │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSGetObservation" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Pinch" │ │ │ │ }); │ │ │ │ - │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/PinchZoom.js │ │ │ │ + OpenLayers/Format/KML.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler/Pinch.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Date.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + * @requires OpenLayers/Geometry/Collection.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + * @requires OpenLayers/Projection.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.PinchZoom │ │ │ │ - * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Class: OpenLayers.Format.KML │ │ │ │ + * Read/Write KML. Create a new instance with the <OpenLayers.Format.KML> │ │ │ │ + * constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.PinchZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.KML = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + kml: "http://www.opengis.net/kml/2.2", │ │ │ │ + gx: "http://www.google.com/kml/ext/2.2" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: kmlns │ │ │ │ + * {String} KML Namespace to use. Defaults to 2.0 namespace. │ │ │ │ + */ │ │ │ │ + kmlns: "http://earth.google.com/kml/2.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: type │ │ │ │ - * {OpenLayers.Control.TYPES} │ │ │ │ + * APIProperty: placemarksDesc │ │ │ │ + * {String} Name of the placemarks. Default is "No description available". │ │ │ │ */ │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + placemarksDesc: "No description available", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: foldersName │ │ │ │ + * {String} Name of the folders. Default is "OpenLayers export". │ │ │ │ + * If set to null, no name element will be created. │ │ │ │ + */ │ │ │ │ + foldersName: "OpenLayers export", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: foldersDesc │ │ │ │ + * {String} Description of the folders. Default is "Exported on [date]." │ │ │ │ + * If set to null, no description element will be created. │ │ │ │ + */ │ │ │ │ + foldersDesc: "Exported on " + new Date(), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: pinchOrigin │ │ │ │ - * {Object} Cached object representing the pinch start (in pixels). │ │ │ │ + * APIProperty: extractAttributes │ │ │ │ + * {Boolean} Extract attributes from KML. Default is true. │ │ │ │ + * Extracting styleUrls requires this to be set to true │ │ │ │ + * Note that currently only Data and SimpleData │ │ │ │ + * elements are handled. │ │ │ │ */ │ │ │ │ - pinchOrigin: null, │ │ │ │ + extractAttributes: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: currentCenter │ │ │ │ - * {Object} Cached object representing the latest pinch center (in pixels). │ │ │ │ + * APIProperty: kvpAttributes │ │ │ │ + * {Boolean} Only used if extractAttributes is true. │ │ │ │ + * If set to true, attributes will be simple │ │ │ │ + * key-value pairs, compatible with other formats, │ │ │ │ + * Any displayName elements will be ignored. │ │ │ │ + * If set to false, attributes will be objects, │ │ │ │ + * retaining any displayName elements, but not │ │ │ │ + * compatible with other formats. Any CDATA in │ │ │ │ + * displayName will be read in as a string value. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - currentCenter: null, │ │ │ │ + kvpAttributes: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * Property: extractStyles │ │ │ │ + * {Boolean} Extract styles from KML. Default is false. │ │ │ │ + * Extracting styleUrls also requires extractAttributes to be │ │ │ │ + * set to true │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + extractStyles: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: preserveCenter │ │ │ │ - * {Boolean} Set this to true if you don't want the map center to change │ │ │ │ - * while pinching. For example you may want to set preserveCenter to │ │ │ │ - * true when the user location is being watched and you want to preserve │ │ │ │ - * the user location at the center of the map even if he zooms in or │ │ │ │ - * out using pinch. This property's value can be changed any time on an │ │ │ │ - * existing instance. Default is false. │ │ │ │ + * APIProperty: extractTracks │ │ │ │ + * {Boolean} Extract gx:Track elements from Placemark elements. Default │ │ │ │ + * is false. If true, features will be generated for all points in │ │ │ │ + * all gx:Track elements. Features will have a when (Date) attribute │ │ │ │ + * based on when elements in the track. If tracks include angle │ │ │ │ + * elements, features will have heading, tilt, and roll attributes. │ │ │ │ + * If track point coordinates have three values, features will have │ │ │ │ + * an altitude attribute with the third coordinate value. │ │ │ │ */ │ │ │ │ - preserveCenter: false, │ │ │ │ + extractTracks: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the pinch handler │ │ │ │ + * APIProperty: trackAttributes │ │ │ │ + * {Array} If <extractTracks> is true, points within gx:Track elements will │ │ │ │ + * be parsed as features with when, heading, tilt, and roll attributes. │ │ │ │ + * Any additional attribute names can be provided in <trackAttributes>. │ │ │ │ */ │ │ │ │ + trackAttributes: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.PinchZoom │ │ │ │ - * Create a control for zooming with pinch gestures. This works on devices │ │ │ │ - * with multi-touch support. │ │ │ │ + * Property: internalns │ │ │ │ + * {String} KML Namespace to use -- defaults to the namespace of the │ │ │ │ + * Placemark node being parsed, but falls back to kmlns. │ │ │ │ + */ │ │ │ │ + internalns: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: features │ │ │ │ + * {Array} Array of features │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + features: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: styles │ │ │ │ + * {Object} Storage of style objects │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + styles: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: styleBaseUrl │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + styleBaseUrl: "", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: fetched │ │ │ │ + * {Object} Storage of KML URLs that have been fetched before │ │ │ │ + * in order to prevent reloading them. │ │ │ │ + */ │ │ │ │ + fetched: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: maxDepth │ │ │ │ + * {Integer} Maximum depth for recursive loading external KML URLs │ │ │ │ + * Defaults to 0: do no external fetching │ │ │ │ + */ │ │ │ │ + maxDepth: 0, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.KML │ │ │ │ + * Create a new parser for KML. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} An optional object whose properties will be set on │ │ │ │ - * the control │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - this.handler = new OpenLayers.Handler.Pinch(this, { │ │ │ │ - start: this.pinchStart, │ │ │ │ - move: this.pinchMove, │ │ │ │ - done: this.pinchDone │ │ │ │ - }, this.handlerOptions); │ │ │ │ + // compile regular expressions once instead of every time they are used │ │ │ │ + this.regExes = { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g), │ │ │ │ + kmlColor: (/(\w{2})(\w{2})(\w{2})(\w{2})/), │ │ │ │ + kmlIconPalette: (/root:\/\/icons\/palette-(\d+)(\.\w+)/), │ │ │ │ + straightBracket: (/\$\[(.*?)\]/g) │ │ │ │ + }; │ │ │ │ + // KML coordinates are always in longlat WGS84 │ │ │ │ + this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: pinchStart │ │ │ │ + * APIMethod: read │ │ │ │ + * Read data from a string, and return a list of features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * pinchData - {Object} pinch data object related to the current touchmove │ │ │ │ - * of the pinch gesture. This give us the current scale of the pinch. │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} List of features. │ │ │ │ */ │ │ │ │ - pinchStart: function(evt, pinchData) { │ │ │ │ - var xy = (this.preserveCenter) ? │ │ │ │ - this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ - this.pinchOrigin = xy; │ │ │ │ - this.currentCenter = xy; │ │ │ │ + read: function(data) { │ │ │ │ + this.features = []; │ │ │ │ + this.styles = {}; │ │ │ │ + this.fetched = {}; │ │ │ │ + │ │ │ │ + // Set default options │ │ │ │ + var options = { │ │ │ │ + depth: 0, │ │ │ │ + styleBaseUrl: this.styleBaseUrl │ │ │ │ + }; │ │ │ │ + │ │ │ │ + return this.parseData(data, options); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: pinchMove │ │ │ │ + * Method: parseData │ │ │ │ + * Read data from a string, and return a list of features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * options - {Object} Hash of options │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * pinchData - {Object} pinch data object related to the current touchmove │ │ │ │ - * of the pinch gesture. This give us the current scale of the pinch. │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} List of features. │ │ │ │ */ │ │ │ │ - pinchMove: function(evt, pinchData) { │ │ │ │ - var scale = pinchData.scale; │ │ │ │ - var containerOrigin = this.map.layerContainerOriginPx; │ │ │ │ - var pinchOrigin = this.pinchOrigin; │ │ │ │ - var current = (this.preserveCenter) ? │ │ │ │ - this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ + parseData: function(data, options) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ │ │ │ │ - var dx = Math.round((containerOrigin.x + current.x - pinchOrigin.x) + (scale - 1) * (containerOrigin.x - pinchOrigin.x)); │ │ │ │ - var dy = Math.round((containerOrigin.y + current.y - pinchOrigin.y) + (scale - 1) * (containerOrigin.y - pinchOrigin.y)); │ │ │ │ + // Loop throught the following node types in this order and │ │ │ │ + // process the nodes found │ │ │ │ + var types = ["Link", "NetworkLink", "Style", "StyleMap", "Placemark"]; │ │ │ │ + for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ + var type = types[i]; │ │ │ │ │ │ │ │ - this.map.applyTransform(dx, dy, scale); │ │ │ │ - this.currentCenter = current; │ │ │ │ + var nodes = this.getElementsByTagNameNS(data, "*", type); │ │ │ │ + │ │ │ │ + // skip to next type if no nodes are found │ │ │ │ + if (nodes.length == 0) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + │ │ │ │ + switch (type.toLowerCase()) { │ │ │ │ + │ │ │ │ + // Fetch external links │ │ │ │ + case "link": │ │ │ │ + case "networklink": │ │ │ │ + this.parseLinks(nodes, options); │ │ │ │ + break; │ │ │ │ + │ │ │ │ + // parse style information │ │ │ │ + case "style": │ │ │ │ + if (this.extractStyles) { │ │ │ │ + this.parseStyles(nodes, options); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "stylemap": │ │ │ │ + if (this.extractStyles) { │ │ │ │ + this.parseStyleMaps(nodes, options); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + │ │ │ │ + // parse features │ │ │ │ + case "placemark": │ │ │ │ + this.parseFeatures(nodes, options); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return this.features; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: pinchDone │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * start - {Object} pinch data object related to the touchstart event that │ │ │ │ - * started the pinch gesture. │ │ │ │ - * last - {Object} pinch data object related to the last touchmove event │ │ │ │ - * of the pinch gesture. This give us the final scale of the pinch. │ │ │ │ + * Method: parseLinks │ │ │ │ + * Finds URLs of linked KML documents and fetches them │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ + * options - {Object} Hash of options │ │ │ │ + * │ │ │ │ */ │ │ │ │ - pinchDone: function(evt, start, last) { │ │ │ │ - this.map.applyTransform(); │ │ │ │ - var zoom = this.map.getZoomForResolution(this.map.getResolution() / last.scale, true); │ │ │ │ - if (zoom !== this.map.getZoom() || !this.currentCenter.equals(this.pinchOrigin)) { │ │ │ │ - var resolution = this.map.getResolutionForZoom(zoom); │ │ │ │ - │ │ │ │ - var location = this.map.getLonLatFromPixel(this.pinchOrigin); │ │ │ │ - var zoomPixel = this.currentCenter; │ │ │ │ - var size = this.map.getSize(); │ │ │ │ + parseLinks: function(nodes, options) { │ │ │ │ │ │ │ │ - location.lon += resolution * ((size.w / 2) - zoomPixel.x); │ │ │ │ - location.lat -= resolution * ((size.h / 2) - zoomPixel.y); │ │ │ │ + // Fetch external links <NetworkLink> and <Link> │ │ │ │ + // Don't do anything if we have reached our maximum depth for recursion │ │ │ │ + if (options.depth >= this.maxDepth) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ │ │ │ │ - // Force a reflow before calling setCenter. This is to work │ │ │ │ - // around an issue occuring in iOS. │ │ │ │ - // │ │ │ │ - // See https://github.com/openlayers/openlayers/pull/351. │ │ │ │ - // │ │ │ │ - // Without a reflow setting the layer container div's top left │ │ │ │ - // style properties to "0px" - as done in Map.moveTo when zoom │ │ │ │ - // is changed - won't actually correctly reposition the layer │ │ │ │ - // container div. │ │ │ │ - // │ │ │ │ - // Also, we need to use a statement that the Google Closure │ │ │ │ - // compiler won't optimize away. │ │ │ │ - this.map.div.clientWidth = this.map.div.clientWidth; │ │ │ │ + // increase depth │ │ │ │ + var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ + newOptions.depth++; │ │ │ │ │ │ │ │ - this.map.setCenter(location, zoom); │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var href = this.parseProperty(nodes[i], "*", "href"); │ │ │ │ + if (href && !this.fetched[href]) { │ │ │ │ + this.fetched[href] = true; // prevent reloading the same urls │ │ │ │ + var data = this.fetchLink(href); │ │ │ │ + if (data) { │ │ │ │ + this.parseData(data, newOptions); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PinchZoom" │ │ │ │ + }, │ │ │ │ │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/ZoomIn.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Method: fetchLink │ │ │ │ + * Fetches a URL and returns the result │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * href - {String} url to be fetched │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + fetchLink: function(href) { │ │ │ │ + var request = OpenLayers.Request.GET({ │ │ │ │ + url: href, │ │ │ │ + async: false │ │ │ │ + }); │ │ │ │ + if (request) { │ │ │ │ + return request.responseText; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * Method: parseStyles │ │ │ │ + * Parses <Style> nodes │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ + * options - {Object} Hash of options │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + parseStyles: function(nodes, options) { │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var style = this.parseStyle(nodes[i]); │ │ │ │ + if (style) { │ │ │ │ + var styleName = (options.styleBaseUrl || "") + "#" + style.id; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control/Button.js │ │ │ │ - */ │ │ │ │ + this.styles[styleName] = style; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.ZoomIn │ │ │ │ - * The ZoomIn control is a button to increase the zoom level of a map. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ZoomIn = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + /** │ │ │ │ + * Method: parseKmlColor │ │ │ │ + * Parses a kml color (in 'aabbggrr' format) and returns the corresponding │ │ │ │ + * color and opacity or null if the color is invalid. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * kmlColor - {String} a kml formated color │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ + parseKmlColor: function(kmlColor) { │ │ │ │ + var color = null; │ │ │ │ + if (kmlColor) { │ │ │ │ + var matches = kmlColor.match(this.regExes.kmlColor); │ │ │ │ + if (matches) { │ │ │ │ + color = { │ │ │ │ + color: '#' + matches[4] + matches[3] + matches[2], │ │ │ │ + opacity: parseInt(matches[1], 16) / 255 │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return color; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: trigger │ │ │ │ + * Method: parseStyle │ │ │ │ + * Parses the children of a <Style> node and builds the style hash │ │ │ │ + * accordingly │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} <Style> node │ │ │ │ + * │ │ │ │ */ │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.zoomIn(); │ │ │ │ + parseStyle: function(node) { │ │ │ │ + var style = {}; │ │ │ │ + │ │ │ │ + var types = ["LineStyle", "PolyStyle", "IconStyle", "BalloonStyle", │ │ │ │ + "LabelStyle" │ │ │ │ + ]; │ │ │ │ + var type, styleTypeNode, nodeList, geometry, parser; │ │ │ │ + for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ + type = types[i]; │ │ │ │ + styleTypeNode = this.getElementsByTagNameNS(node, "*", type)[0]; │ │ │ │ + if (!styleTypeNode) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // only deal with first geometry of this type │ │ │ │ + switch (type.toLowerCase()) { │ │ │ │ + case "linestyle": │ │ │ │ + var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ + var color = this.parseKmlColor(kmlColor); │ │ │ │ + if (color) { │ │ │ │ + style["strokeColor"] = color.color; │ │ │ │ + style["strokeOpacity"] = color.opacity; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var width = this.parseProperty(styleTypeNode, "*", "width"); │ │ │ │ + if (width) { │ │ │ │ + style["strokeWidth"] = width; │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + │ │ │ │ + case "polystyle": │ │ │ │ + var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ + var color = this.parseKmlColor(kmlColor); │ │ │ │ + if (color) { │ │ │ │ + style["fillOpacity"] = color.opacity; │ │ │ │ + style["fillColor"] = color.color; │ │ │ │ + } │ │ │ │ + // Check if fill is disabled │ │ │ │ + var fill = this.parseProperty(styleTypeNode, "*", "fill"); │ │ │ │ + if (fill == "0") { │ │ │ │ + style["fillColor"] = "none"; │ │ │ │ + } │ │ │ │ + // Check if outline is disabled │ │ │ │ + var outline = this.parseProperty(styleTypeNode, "*", "outline"); │ │ │ │ + if (outline == "0") { │ │ │ │ + style["strokeWidth"] = "0"; │ │ │ │ + } │ │ │ │ + │ │ │ │ + break; │ │ │ │ + │ │ │ │ + case "iconstyle": │ │ │ │ + // set scale │ │ │ │ + var scale = parseFloat(this.parseProperty(styleTypeNode, │ │ │ │ + "*", "scale") || 1); │ │ │ │ + │ │ │ │ + // set default width and height of icon │ │ │ │ + var width = 32 * scale; │ │ │ │ + var height = 32 * scale; │ │ │ │ + │ │ │ │ + var iconNode = this.getElementsByTagNameNS(styleTypeNode, │ │ │ │ + "*", │ │ │ │ + "Icon")[0]; │ │ │ │ + if (iconNode) { │ │ │ │ + var href = this.parseProperty(iconNode, "*", "href"); │ │ │ │ + if (href) { │ │ │ │ + │ │ │ │ + var w = this.parseProperty(iconNode, "*", "w"); │ │ │ │ + var h = this.parseProperty(iconNode, "*", "h"); │ │ │ │ + │ │ │ │ + // Settings for Google specific icons that are 64x64 │ │ │ │ + // We set the width and height to 64 and halve the │ │ │ │ + // scale to prevent icons from being too big │ │ │ │ + var google = "http://maps.google.com/mapfiles/kml"; │ │ │ │ + if (OpenLayers.String.startsWith( │ │ │ │ + href, google) && !w && !h) { │ │ │ │ + w = 64; │ │ │ │ + h = 64; │ │ │ │ + scale = scale / 2; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // if only dimension is defined, make sure the │ │ │ │ + // other one has the same value │ │ │ │ + w = w || h; │ │ │ │ + h = h || w; │ │ │ │ + │ │ │ │ + if (w) { │ │ │ │ + width = parseInt(w) * scale; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (h) { │ │ │ │ + height = parseInt(h) * scale; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // support for internal icons │ │ │ │ + // (/root://icons/palette-x.png) │ │ │ │ + // x and y tell the position on the palette: │ │ │ │ + // - in pixels │ │ │ │ + // - starting from the left bottom │ │ │ │ + // We translate that to a position in the list │ │ │ │ + // and request the appropriate icon from the │ │ │ │ + // google maps website │ │ │ │ + var matches = href.match(this.regExes.kmlIconPalette); │ │ │ │ + if (matches) { │ │ │ │ + var palette = matches[1]; │ │ │ │ + var file_extension = matches[2]; │ │ │ │ + │ │ │ │ + var x = this.parseProperty(iconNode, "*", "x"); │ │ │ │ + var y = this.parseProperty(iconNode, "*", "y"); │ │ │ │ + │ │ │ │ + var posX = x ? x / 32 : 0; │ │ │ │ + var posY = y ? (7 - y / 32) : 7; │ │ │ │ + │ │ │ │ + var pos = posY * 8 + posX; │ │ │ │ + href = "http://maps.google.com/mapfiles/kml/pal" + │ │ │ │ + palette + "/icon" + pos + file_extension; │ │ │ │ + } │ │ │ │ + │ │ │ │ + style["graphicOpacity"] = 1; // fully opaque │ │ │ │ + style["externalGraphic"] = href; │ │ │ │ + } │ │ │ │ + │ │ │ │ + } │ │ │ │ + │ │ │ │ + │ │ │ │ + // hotSpots define the offset for an Icon │ │ │ │ + var hotSpotNode = this.getElementsByTagNameNS(styleTypeNode, │ │ │ │ + "*", │ │ │ │ + "hotSpot")[0]; │ │ │ │ + if (hotSpotNode) { │ │ │ │ + var x = parseFloat(hotSpotNode.getAttribute("x")); │ │ │ │ + var y = parseFloat(hotSpotNode.getAttribute("y")); │ │ │ │ + │ │ │ │ + var xUnits = hotSpotNode.getAttribute("xunits"); │ │ │ │ + if (xUnits == "pixels") { │ │ │ │ + style["graphicXOffset"] = -x * scale; │ │ │ │ + } else if (xUnits == "insetPixels") { │ │ │ │ + style["graphicXOffset"] = -width + (x * scale); │ │ │ │ + } else if (xUnits == "fraction") { │ │ │ │ + style["graphicXOffset"] = -width * x; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var yUnits = hotSpotNode.getAttribute("yunits"); │ │ │ │ + if (yUnits == "pixels") { │ │ │ │ + style["graphicYOffset"] = -height + (y * scale) + 1; │ │ │ │ + } else if (yUnits == "insetPixels") { │ │ │ │ + style["graphicYOffset"] = -(y * scale) + 1; │ │ │ │ + } else if (yUnits == "fraction") { │ │ │ │ + style["graphicYOffset"] = -height * (1 - y) + 1; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + style["graphicWidth"] = width; │ │ │ │ + style["graphicHeight"] = height; │ │ │ │ + break; │ │ │ │ + │ │ │ │ + case "balloonstyle": │ │ │ │ + var balloonStyle = OpenLayers.Util.getXmlNodeValue( │ │ │ │ + styleTypeNode); │ │ │ │ + if (balloonStyle) { │ │ │ │ + style["balloonStyle"] = balloonStyle.replace( │ │ │ │ + this.regExes.straightBracket, "${$1}"); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "labelstyle": │ │ │ │ + var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ + var color = this.parseKmlColor(kmlColor); │ │ │ │ + if (color) { │ │ │ │ + style["fontColor"] = color.color; │ │ │ │ + style["fontOpacity"] = color.opacity; │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + │ │ │ │ + default: │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // Some polygons have no line color, so we use the fillColor for that │ │ │ │ + if (!style["strokeColor"] && style["fillColor"]) { │ │ │ │ + style["strokeColor"] = style["fillColor"]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var id = node.getAttribute("id"); │ │ │ │ + if (id && style) { │ │ │ │ + style.id = id; │ │ │ │ } │ │ │ │ + │ │ │ │ + return style; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomIn" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/ScaleLine.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Method: parseStyleMaps │ │ │ │ + * Parses <StyleMap> nodes, but only uses the 'normal' key │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ + * options - {Object} Hash of options │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + parseStyleMaps: function(nodes, options) { │ │ │ │ + // Only the default or "normal" part of the StyleMap is processed now │ │ │ │ + // To do the select or "highlight" bit, we'd need to change lots more │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var node = nodes[i]; │ │ │ │ + var pairs = this.getElementsByTagNameNS(node, "*", │ │ │ │ + "Pair"); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - */ │ │ │ │ + var id = node.getAttribute("id"); │ │ │ │ + for (var j = 0, jlen = pairs.length; j < jlen; j++) { │ │ │ │ + var pair = pairs[j]; │ │ │ │ + // Use the shortcut in the SLD format to quickly retrieve the │ │ │ │ + // value of a node. Maybe it's good to have a method in │ │ │ │ + // Format.XML to do this │ │ │ │ + var key = this.parseProperty(pair, "*", "key"); │ │ │ │ + var styleUrl = this.parseProperty(pair, "*", "styleUrl"); │ │ │ │ + │ │ │ │ + if (styleUrl && key == "normal") { │ │ │ │ + this.styles[(options.styleBaseUrl || "") + "#" + id] = │ │ │ │ + this.styles[(options.styleBaseUrl || "") + styleUrl]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // TODO: implement the "select" part │ │ │ │ + //if (styleUrl && key == "highlight") { │ │ │ │ + //} │ │ │ │ + │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.ScaleLine │ │ │ │ - * The ScaleLine displays a small line indicator representing the current │ │ │ │ - * map scale on the map. By default it is drawn in the lower left corner of │ │ │ │ - * the map. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - * │ │ │ │ - * Is a very close copy of: │ │ │ │ - * - <OpenLayers.Control.Scale> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ScaleLine = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: maxWidth │ │ │ │ - * {Integer} Maximum width of the scale line in pixels. Default is 100. │ │ │ │ + * Method: parseFeatures │ │ │ │ + * Loop through all Placemark nodes and parse them. │ │ │ │ + * Will create a list of features │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ + * options - {Object} Hash of options │ │ │ │ + * │ │ │ │ */ │ │ │ │ - maxWidth: 100, │ │ │ │ + parseFeatures: function(nodes, options) { │ │ │ │ + var features = []; │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var featureNode = nodes[i]; │ │ │ │ + var feature = this.parseFeature.apply(this, [featureNode]); │ │ │ │ + if (feature) { │ │ │ │ + │ │ │ │ + // Create reference to styleUrl │ │ │ │ + if (this.extractStyles && feature.attributes && │ │ │ │ + feature.attributes.styleUrl) { │ │ │ │ + feature.style = this.getStyle(feature.attributes.styleUrl, options); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.extractStyles) { │ │ │ │ + // Make sure that <Style> nodes within a placemark are │ │ │ │ + // processed as well │ │ │ │ + var inlineStyleNode = this.getElementsByTagNameNS(featureNode, │ │ │ │ + "*", │ │ │ │ + "Style")[0]; │ │ │ │ + if (inlineStyleNode) { │ │ │ │ + var inlineStyle = this.parseStyle(inlineStyleNode); │ │ │ │ + if (inlineStyle) { │ │ │ │ + feature.style = OpenLayers.Util.extend( │ │ │ │ + feature.style, inlineStyle │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // check if gx:Track elements should be parsed │ │ │ │ + if (this.extractTracks) { │ │ │ │ + var tracks = this.getElementsByTagNameNS( │ │ │ │ + featureNode, this.namespaces.gx, "Track" │ │ │ │ + ); │ │ │ │ + if (tracks && tracks.length > 0) { │ │ │ │ + var track = tracks[0]; │ │ │ │ + var container = { │ │ │ │ + features: [], │ │ │ │ + feature: feature │ │ │ │ + }; │ │ │ │ + this.readNode(track, container); │ │ │ │ + if (container.features.length > 0) { │ │ │ │ + features.push.apply(features, container.features); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // add feature to list of features │ │ │ │ + features.push(feature); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + throw "Bad Placemark: " + i; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // add new features to existing feature list │ │ │ │ + this.features = this.features.concat(features); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: topOutUnits │ │ │ │ - * {String} Units for zoomed out on top bar. Default is km. │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ */ │ │ │ │ - topOutUnits: "km", │ │ │ │ + readers: { │ │ │ │ + "kml": { │ │ │ │ + "when": function(node, container) { │ │ │ │ + container.whens.push(OpenLayers.Date.parse( │ │ │ │ + this.getChildValue(node) │ │ │ │ + )); │ │ │ │ + }, │ │ │ │ + "_trackPointAttribute": function(node, container) { │ │ │ │ + var name = node.nodeName.split(":").pop(); │ │ │ │ + container.attributes[name].push(this.getChildValue(node)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "gx": { │ │ │ │ + "Track": function(node, container) { │ │ │ │ + var obj = { │ │ │ │ + whens: [], │ │ │ │ + points: [], │ │ │ │ + angles: [] │ │ │ │ + }; │ │ │ │ + if (this.trackAttributes) { │ │ │ │ + var name; │ │ │ │ + obj.attributes = {}; │ │ │ │ + for (var i = 0, ii = this.trackAttributes.length; i < ii; ++i) { │ │ │ │ + name = this.trackAttributes[i]; │ │ │ │ + obj.attributes[name] = []; │ │ │ │ + if (!(name in this.readers.kml)) { │ │ │ │ + this.readers.kml[name] = this.readers.kml._trackPointAttribute; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + if (obj.whens.length !== obj.points.length) { │ │ │ │ + throw new Error("gx:Track with unequal number of when (" + │ │ │ │ + obj.whens.length + ") and gx:coord (" + │ │ │ │ + obj.points.length + ") elements."); │ │ │ │ + } │ │ │ │ + var hasAngles = obj.angles.length > 0; │ │ │ │ + if (hasAngles && obj.whens.length !== obj.angles.length) { │ │ │ │ + throw new Error("gx:Track with unequal number of when (" + │ │ │ │ + obj.whens.length + ") and gx:angles (" + │ │ │ │ + obj.angles.length + ") elements."); │ │ │ │ + } │ │ │ │ + var feature, point, angles; │ │ │ │ + for (var i = 0, ii = obj.whens.length; i < ii; ++i) { │ │ │ │ + feature = container.feature.clone(); │ │ │ │ + feature.fid = container.feature.fid || container.feature.id; │ │ │ │ + point = obj.points[i]; │ │ │ │ + feature.geometry = point; │ │ │ │ + if ("z" in point) { │ │ │ │ + feature.attributes.altitude = point.z; │ │ │ │ + } │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + feature.geometry.transform( │ │ │ │ + this.externalProjection, this.internalProjection │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (this.trackAttributes) { │ │ │ │ + for (var j = 0, jj = this.trackAttributes.length; j < jj; ++j) { │ │ │ │ + var name = this.trackAttributes[j]; │ │ │ │ + feature.attributes[name] = obj.attributes[name][i]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + feature.attributes.when = obj.whens[i]; │ │ │ │ + feature.attributes.trackId = container.feature.id; │ │ │ │ + if (hasAngles) { │ │ │ │ + angles = obj.angles[i]; │ │ │ │ + feature.attributes.heading = parseFloat(angles[0]); │ │ │ │ + feature.attributes.tilt = parseFloat(angles[1]); │ │ │ │ + feature.attributes.roll = parseFloat(angles[2]); │ │ │ │ + } │ │ │ │ + container.features.push(feature); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "coord": function(node, container) { │ │ │ │ + var str = this.getChildValue(node); │ │ │ │ + var coords = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ + var point = new OpenLayers.Geometry.Point(coords[0], coords[1]); │ │ │ │ + if (coords.length > 2) { │ │ │ │ + point.z = parseFloat(coords[2]); │ │ │ │ + } │ │ │ │ + container.points.push(point); │ │ │ │ + }, │ │ │ │ + "angles": function(node, container) { │ │ │ │ + var str = this.getChildValue(node); │ │ │ │ + var parts = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ + container.angles.push(parts); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: topInUnits │ │ │ │ - * {String} Units for zoomed in on top bar. Default is m. │ │ │ │ + * Method: parseFeature │ │ │ │ + * This function is the core of the KML parsing code in OpenLayers. │ │ │ │ + * It creates the geometries that are then attached to the returned │ │ │ │ + * feature, and calls parseAttributes() to get attribute data out. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} A vector feature. │ │ │ │ */ │ │ │ │ - topInUnits: "m", │ │ │ │ + parseFeature: function(node) { │ │ │ │ + // only accept one geometry per feature - look for highest "order" │ │ │ │ + var order = ["MultiGeometry", "Polygon", "LineString", "Point"]; │ │ │ │ + var type, nodeList, geometry, parser; │ │ │ │ + for (var i = 0, len = order.length; i < len; ++i) { │ │ │ │ + type = order[i]; │ │ │ │ + this.internalns = node.namespaceURI ? │ │ │ │ + node.namespaceURI : this.kmlns; │ │ │ │ + nodeList = this.getElementsByTagNameNS(node, │ │ │ │ + this.internalns, type); │ │ │ │ + if (nodeList.length > 0) { │ │ │ │ + // only deal with first geometry of this type │ │ │ │ + var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ + if (parser) { │ │ │ │ + geometry = parser.apply(this, [nodeList[0]]); │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + throw new TypeError("Unsupported geometry type: " + type); │ │ │ │ + } │ │ │ │ + // stop looking for different geometry types │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // construct feature (optionally with attributes) │ │ │ │ + var attributes; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attributes = this.parseAttributes(node); │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, attributes); │ │ │ │ + │ │ │ │ + var fid = node.getAttribute("id") || node.getAttribute("name"); │ │ │ │ + if (fid != null) { │ │ │ │ + feature.fid = fid; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return feature; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: bottomOutUnits │ │ │ │ - * {String} Units for zoomed out on bottom bar. Default is mi. │ │ │ │ + * Method: getStyle │ │ │ │ + * Retrieves a style from a style hash using styleUrl as the key │ │ │ │ + * If the styleUrl doesn't exist yet, we try to fetch it │ │ │ │ + * Internet │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * styleUrl - {String} URL of style │ │ │ │ + * options - {Object} Hash of options │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} - (reference to) Style hash │ │ │ │ */ │ │ │ │ - bottomOutUnits: "mi", │ │ │ │ + getStyle: function(styleUrl, options) { │ │ │ │ + │ │ │ │ + var styleBaseUrl = OpenLayers.Util.removeTail(styleUrl); │ │ │ │ + │ │ │ │ + var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ + newOptions.depth++; │ │ │ │ + newOptions.styleBaseUrl = styleBaseUrl; │ │ │ │ + │ │ │ │ + // Fetch remote Style URLs (if not fetched before) │ │ │ │ + if (!this.styles[styleUrl] && │ │ │ │ + !OpenLayers.String.startsWith(styleUrl, "#") && │ │ │ │ + newOptions.depth <= this.maxDepth && │ │ │ │ + !this.fetched[styleBaseUrl]) { │ │ │ │ + │ │ │ │ + var data = this.fetchLink(styleBaseUrl); │ │ │ │ + if (data) { │ │ │ │ + this.parseData(data, newOptions); │ │ │ │ + } │ │ │ │ + │ │ │ │ + } │ │ │ │ + │ │ │ │ + // return requested style │ │ │ │ + var style = OpenLayers.Util.extend({}, this.styles[styleUrl]); │ │ │ │ + return style; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: bottomInUnits │ │ │ │ - * {String} Units for zoomed in on bottom bar. Default is ft. │ │ │ │ + * Property: parseGeometry │ │ │ │ + * Properties of this object are the functions that parse geometries based │ │ │ │ + * on their type. │ │ │ │ */ │ │ │ │ - bottomInUnits: "ft", │ │ │ │ + parseGeometry: { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseGeometry.point │ │ │ │ + * Given a KML node representing a point geometry, create an OpenLayers │ │ │ │ + * point geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} A KML Point node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Point>} A point geometry. │ │ │ │ + */ │ │ │ │ + point: function(node) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, this.internalns, │ │ │ │ + "coordinates"); │ │ │ │ + var coords = []; │ │ │ │ + if (nodeList.length > 0) { │ │ │ │ + var coordString = nodeList[0].firstChild.nodeValue; │ │ │ │ + coordString = coordString.replace(this.regExes.removeSpace, ""); │ │ │ │ + coords = coordString.split(","); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var point = null; │ │ │ │ + if (coords.length > 1) { │ │ │ │ + // preserve third dimension │ │ │ │ + if (coords.length == 2) { │ │ │ │ + coords[2] = null; │ │ │ │ + } │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[0], coords[1], │ │ │ │ + coords[2]); │ │ │ │ + } else { │ │ │ │ + throw "Bad coordinate string: " + coordString; │ │ │ │ + } │ │ │ │ + return point; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseGeometry.linestring │ │ │ │ + * Given a KML node representing a linestring geometry, create an │ │ │ │ + * OpenLayers linestring geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} A KML LineString node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.LineString>} A linestring geometry. │ │ │ │ + */ │ │ │ │ + linestring: function(node, ring) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, this.internalns, │ │ │ │ + "coordinates"); │ │ │ │ + var line = null; │ │ │ │ + if (nodeList.length > 0) { │ │ │ │ + var coordString = this.getChildValue(nodeList[0]); │ │ │ │ + │ │ │ │ + coordString = coordString.replace(this.regExes.trimSpace, │ │ │ │ + ""); │ │ │ │ + coordString = coordString.replace(this.regExes.trimComma, │ │ │ │ + ","); │ │ │ │ + var pointList = coordString.split(this.regExes.splitSpace); │ │ │ │ + var numPoints = pointList.length; │ │ │ │ + var points = new Array(numPoints); │ │ │ │ + var coords, numCoords; │ │ │ │ + for (var i = 0; i < numPoints; ++i) { │ │ │ │ + coords = pointList[i].split(","); │ │ │ │ + numCoords = coords.length; │ │ │ │ + if (numCoords > 1) { │ │ │ │ + if (coords.length == 2) { │ │ │ │ + coords[2] = null; │ │ │ │ + } │ │ │ │ + points[i] = new OpenLayers.Geometry.Point(coords[0], │ │ │ │ + coords[1], │ │ │ │ + coords[2]); │ │ │ │ + } else { │ │ │ │ + throw "Bad LineString point coordinates: " + │ │ │ │ + pointList[i]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (numPoints) { │ │ │ │ + if (ring) { │ │ │ │ + line = new OpenLayers.Geometry.LinearRing(points); │ │ │ │ + } else { │ │ │ │ + line = new OpenLayers.Geometry.LineString(points); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + throw "Bad LineString coordinates: " + coordString; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return line; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseGeometry.polygon │ │ │ │ + * Given a KML node representing a polygon geometry, create an │ │ │ │ + * OpenLayers polygon geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} A KML Polygon node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Polygon>} A polygon geometry. │ │ │ │ + */ │ │ │ │ + polygon: function(node) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, this.internalns, │ │ │ │ + "LinearRing"); │ │ │ │ + var numRings = nodeList.length; │ │ │ │ + var components = new Array(numRings); │ │ │ │ + if (numRings > 0) { │ │ │ │ + // this assumes exterior ring first, inner rings after │ │ │ │ + var ring; │ │ │ │ + for (var i = 0, len = nodeList.length; i < len; ++i) { │ │ │ │ + ring = this.parseGeometry.linestring.apply(this, │ │ │ │ + [nodeList[i], true]); │ │ │ │ + if (ring) { │ │ │ │ + components[i] = ring; │ │ │ │ + } else { │ │ │ │ + throw "Bad LinearRing geometry: " + i; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Polygon(components); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseGeometry.multigeometry │ │ │ │ + * Given a KML node representing a multigeometry, create an │ │ │ │ + * OpenLayers geometry collection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} A KML MultiGeometry node. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Collection>} A geometry collection. │ │ │ │ + */ │ │ │ │ + multigeometry: function(node) { │ │ │ │ + var child, parser; │ │ │ │ + var parts = []; │ │ │ │ + var children = node.childNodes; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + var type = (child.prefix) ? │ │ │ │ + child.nodeName.split(":")[1] : │ │ │ │ + child.nodeName; │ │ │ │ + var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ + if (parser) { │ │ │ │ + parts.push(parser.apply(this, [child])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Collection(parts); │ │ │ │ + } │ │ │ │ + │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: eTop │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: parseAttributes │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An attributes object. │ │ │ │ */ │ │ │ │ - eTop: null, │ │ │ │ + parseAttributes: function(node) { │ │ │ │ + var attributes = {}; │ │ │ │ + │ │ │ │ + // Extended Data is parsed first. │ │ │ │ + var edNodes = node.getElementsByTagName("ExtendedData"); │ │ │ │ + if (edNodes.length) { │ │ │ │ + attributes = this.parseExtendedData(edNodes[0]); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // assume attribute nodes are type 1 children with a type 3 or 4 child │ │ │ │ + var child, grandchildren, grandchild; │ │ │ │ + var children = node.childNodes; │ │ │ │ + │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + grandchildren = child.childNodes; │ │ │ │ + if (grandchildren.length >= 1 && grandchildren.length <= 3) { │ │ │ │ + var grandchild; │ │ │ │ + switch (grandchildren.length) { │ │ │ │ + case 1: │ │ │ │ + grandchild = grandchildren[0]; │ │ │ │ + break; │ │ │ │ + case 2: │ │ │ │ + var c1 = grandchildren[0]; │ │ │ │ + var c2 = grandchildren[1]; │ │ │ │ + grandchild = (c1.nodeType == 3 || c1.nodeType == 4) ? │ │ │ │ + c1 : c2; │ │ │ │ + break; │ │ │ │ + case 3: │ │ │ │ + default: │ │ │ │ + grandchild = grandchildren[1]; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + if (grandchild.nodeType == 3 || grandchild.nodeType == 4) { │ │ │ │ + var name = (child.prefix) ? │ │ │ │ + child.nodeName.split(":")[1] : │ │ │ │ + child.nodeName; │ │ │ │ + var value = OpenLayers.Util.getXmlNodeValue(grandchild); │ │ │ │ + if (value) { │ │ │ │ + value = value.replace(this.regExes.trimSpace, ""); │ │ │ │ + attributes[name] = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return attributes; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: eBottom │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: parseExtendedData │ │ │ │ + * Parse ExtendedData from KML. Limited support for schemas/datatypes. │ │ │ │ + * See http://code.google.com/apis/kml/documentation/kmlreference.html#extendeddata │ │ │ │ + * for more information on extendeddata. │ │ │ │ */ │ │ │ │ - eBottom: null, │ │ │ │ + parseExtendedData: function(node) { │ │ │ │ + var attributes = {}; │ │ │ │ + var i, len, data, key; │ │ │ │ + var dataNodes = node.getElementsByTagName("Data"); │ │ │ │ + for (i = 0, len = dataNodes.length; i < len; i++) { │ │ │ │ + data = dataNodes[i]; │ │ │ │ + key = data.getAttribute("name"); │ │ │ │ + var ed = {}; │ │ │ │ + var valueNode = data.getElementsByTagName("value"); │ │ │ │ + if (valueNode.length) { │ │ │ │ + ed['value'] = this.getChildValue(valueNode[0]); │ │ │ │ + } │ │ │ │ + if (this.kvpAttributes) { │ │ │ │ + attributes[key] = ed['value']; │ │ │ │ + } else { │ │ │ │ + var nameNode = data.getElementsByTagName("displayName"); │ │ │ │ + if (nameNode.length) { │ │ │ │ + ed['displayName'] = this.getChildValue(nameNode[0]); │ │ │ │ + } │ │ │ │ + attributes[key] = ed; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var simpleDataNodes = node.getElementsByTagName("SimpleData"); │ │ │ │ + for (i = 0, len = simpleDataNodes.length; i < len; i++) { │ │ │ │ + var ed = {}; │ │ │ │ + data = simpleDataNodes[i]; │ │ │ │ + key = data.getAttribute("name"); │ │ │ │ + ed['value'] = this.getChildValue(data); │ │ │ │ + if (this.kvpAttributes) { │ │ │ │ + attributes[key] = ed['value']; │ │ │ │ + } else { │ │ │ │ + ed['displayName'] = key; │ │ │ │ + attributes[key] = ed; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return attributes; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: geodesic │ │ │ │ - * {Boolean} Use geodesic measurement. Default is false. The recommended │ │ │ │ - * setting for maps in EPSG:4326 is false, and true EPSG:900913. If set to │ │ │ │ - * true, the scale will be calculated based on the horizontal size of the │ │ │ │ - * pixel in the center of the map viewport. │ │ │ │ + * Method: parseProperty │ │ │ │ + * Convenience method to find a node and return its value │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xmlNode - {<DOMElement>} │ │ │ │ + * namespace - {String} namespace of the node to find │ │ │ │ + * tagName - {String} name of the property to parse │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The value for the requested property (defaults to null) │ │ │ │ */ │ │ │ │ - geodesic: false, │ │ │ │ + parseProperty: function(xmlNode, namespace, tagName) { │ │ │ │ + var value; │ │ │ │ + var nodeList = this.getElementsByTagNameNS(xmlNode, namespace, tagName); │ │ │ │ + try { │ │ │ │ + value = OpenLayers.Util.getXmlNodeValue(nodeList[0]); │ │ │ │ + } catch (e) { │ │ │ │ + value = null; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return value; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.ScaleLine │ │ │ │ - * Create a new scale line control. │ │ │ │ + * APIMethod: write │ │ │ │ + * Accept Feature Collection, and return a string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} An array of features. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A KML string. │ │ │ │ */ │ │ │ │ + write: function(features) { │ │ │ │ + if (!(OpenLayers.Util.isArray(features))) { │ │ │ │ + features = [features]; │ │ │ │ + } │ │ │ │ + var kml = this.createElementNS(this.kmlns, "kml"); │ │ │ │ + var folder = this.createFolderXML(); │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + folder.appendChild(this.createPlacemarkXML(features[i])); │ │ │ │ + } │ │ │ │ + kml.appendChild(folder); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [kml]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * Method: createFolderXML │ │ │ │ + * Creates and returns a KML folder node │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.eTop) { │ │ │ │ - // 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"; │ │ │ │ - } │ │ │ │ + createFolderXML: function() { │ │ │ │ + // Folder │ │ │ │ + var folder = this.createElementNS(this.kmlns, "Folder"); │ │ │ │ │ │ │ │ - // 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"; │ │ │ │ - } │ │ │ │ + // Folder name │ │ │ │ + if (this.foldersName) { │ │ │ │ + var folderName = this.createElementNS(this.kmlns, "name"); │ │ │ │ + var folderNameText = this.createTextNode(this.foldersName); │ │ │ │ + folderName.appendChild(folderNameText); │ │ │ │ + folder.appendChild(folderName); │ │ │ │ } │ │ │ │ - this.map.events.register('moveend', this, this.update); │ │ │ │ - this.update(); │ │ │ │ - return this.div; │ │ │ │ + │ │ │ │ + // Folder description │ │ │ │ + if (this.foldersDesc) { │ │ │ │ + var folderDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ + var folderDescText = this.createTextNode(this.foldersDesc); │ │ │ │ + folderDesc.appendChild(folderDescText); │ │ │ │ + folder.appendChild(folderDesc); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return folder; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ + /** │ │ │ │ + * Method: createPlacemarkXML │ │ │ │ + * Creates and returns a KML placemark node representing the given feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * maxLen - {float} the number we're rounding down from │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Float} the rounded number (less than or equal to maxLen) │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - 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); │ │ │ │ + createPlacemarkXML: function(feature) { │ │ │ │ + // Placemark name │ │ │ │ + var placemarkName = this.createElementNS(this.kmlns, "name"); │ │ │ │ + var label = (feature.style && feature.style.label) ? feature.style.label : feature.id; │ │ │ │ + var name = feature.attributes.name || label; │ │ │ │ + placemarkName.appendChild(this.createTextNode(name)); │ │ │ │ │ │ │ │ - // ok, find first character │ │ │ │ - var firstChar = parseInt(maxLen / pow10); │ │ │ │ + // Placemark description │ │ │ │ + var placemarkDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ + var desc = feature.attributes.description || this.placemarksDesc; │ │ │ │ + placemarkDesc.appendChild(this.createTextNode(desc)); │ │ │ │ │ │ │ │ - // right, put it into the correct bracket │ │ │ │ - var barLen; │ │ │ │ - if (firstChar > 5) { │ │ │ │ - barLen = 5; │ │ │ │ - } else if (firstChar > 2) { │ │ │ │ - barLen = 2; │ │ │ │ - } else { │ │ │ │ - barLen = 1; │ │ │ │ + // Placemark │ │ │ │ + var placemarkNode = this.createElementNS(this.kmlns, "Placemark"); │ │ │ │ + if (feature.fid != null) { │ │ │ │ + placemarkNode.setAttribute("id", feature.fid); │ │ │ │ } │ │ │ │ + placemarkNode.appendChild(placemarkName); │ │ │ │ + placemarkNode.appendChild(placemarkDesc); │ │ │ │ │ │ │ │ - // scale it up the correct power of 10 │ │ │ │ - return barLen * pow10; │ │ │ │ + // Geometry node (Point, LineString, etc. nodes) │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + placemarkNode.appendChild(geometryNode); │ │ │ │ + │ │ │ │ + // output attributes as extendedData │ │ │ │ + if (feature.attributes) { │ │ │ │ + var edNode = this.buildExtendedData(feature.attributes); │ │ │ │ + if (edNode) { │ │ │ │ + placemarkNode.appendChild(edNode); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + return placemarkNode; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Update the size of the bars, and the labels they contain. │ │ │ │ + * Method: buildGeometryNode │ │ │ │ + * Builds and returns a KML geometry node with the given geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - update: function() { │ │ │ │ - var res = this.map.getResolution(); │ │ │ │ - if (!res) { │ │ │ │ - return; │ │ │ │ + buildGeometryNode: function(geometry) { │ │ │ │ + var className = geometry.CLASS_NAME; │ │ │ │ + var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ + var builder = this.buildGeometry[type.toLowerCase()]; │ │ │ │ + var node = null; │ │ │ │ + if (builder) { │ │ │ │ + node = builder.apply(this, [geometry]); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var curMapUnits = this.map.getUnits(); │ │ │ │ - var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ + /** │ │ │ │ + * Property: buildGeometry │ │ │ │ + * Object containing methods to do the actual geometry node building │ │ │ │ + * based on geometry type. │ │ │ │ + */ │ │ │ │ + buildGeometry: { │ │ │ │ + // TBD: Anybody care about namespace aliases here (these nodes have │ │ │ │ + // no prefixes)? │ │ │ │ │ │ │ │ - // convert maxWidth to map units │ │ │ │ - var maxSizeData = this.maxWidth * res * inches[curMapUnits]; │ │ │ │ - var geodesicRatio = 1; │ │ │ │ - if (this.geodesic === true) { │ │ │ │ - var maxSizeGeodesic = (this.map.getGeodesicPixelSize().w || │ │ │ │ - 0.000001) * this.maxWidth; │ │ │ │ - var maxSizeKilometers = maxSizeData / inches["km"]; │ │ │ │ - geodesicRatio = maxSizeGeodesic / maxSizeKilometers; │ │ │ │ - maxSizeData *= geodesicRatio; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.point │ │ │ │ + * Given an OpenLayers point geometry, create a KML point. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Point>} A point geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML point node. │ │ │ │ + */ │ │ │ │ + point: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "Point"); │ │ │ │ + kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + return kml; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // 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; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.multipoint │ │ │ │ + * Given an OpenLayers multipoint geometry, create a KML │ │ │ │ + * GeometryCollection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Point>} A multipoint geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML GeometryCollection node. │ │ │ │ + */ │ │ │ │ + multipoint: function(geometry) { │ │ │ │ + return this.buildGeometry.collection.apply(this, [geometry]); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // and to map units units │ │ │ │ - var topMax = maxSizeData / inches[topUnits]; │ │ │ │ - var bottomMax = maxSizeData / inches[bottomUnits]; │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.linestring │ │ │ │ + * Given an OpenLayers linestring geometry, create a KML linestring. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.LineString>} A linestring geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML linestring node. │ │ │ │ + */ │ │ │ │ + linestring: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "LineString"); │ │ │ │ + kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + return kml; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // now trim this down to useful block length │ │ │ │ - var topRounded = this.getBarLen(topMax); │ │ │ │ - var bottomRounded = this.getBarLen(bottomMax); │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.multilinestring │ │ │ │ + * Given an OpenLayers multilinestring geometry, create a KML │ │ │ │ + * GeometryCollection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Point>} A multilinestring geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML GeometryCollection node. │ │ │ │ + */ │ │ │ │ + multilinestring: function(geometry) { │ │ │ │ + return this.buildGeometry.collection.apply(this, [geometry]); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // and back to display units │ │ │ │ - topMax = topRounded / inches[curMapUnits] * inches[topUnits]; │ │ │ │ - bottomMax = bottomRounded / inches[curMapUnits] * inches[bottomUnits]; │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.linearring │ │ │ │ + * Given an OpenLayers linearring geometry, create a KML linearring. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.LinearRing>} A linearring geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML linearring node. │ │ │ │ + */ │ │ │ │ + linearring: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "LinearRing"); │ │ │ │ + kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + return kml; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // and to pixel units │ │ │ │ - var topPx = topMax / res / geodesicRatio; │ │ │ │ - var bottomPx = bottomMax / res / geodesicRatio; │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.polygon │ │ │ │ + * Given an OpenLayers polygon geometry, create a KML polygon. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Polygon>} A polygon geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML polygon node. │ │ │ │ + */ │ │ │ │ + polygon: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "Polygon"); │ │ │ │ + var rings = geometry.components; │ │ │ │ + var ringMember, ringGeom, type; │ │ │ │ + for (var i = 0, len = rings.length; i < len; ++i) { │ │ │ │ + type = (i == 0) ? "outerBoundaryIs" : "innerBoundaryIs"; │ │ │ │ + ringMember = this.createElementNS(this.kmlns, type); │ │ │ │ + ringGeom = this.buildGeometry.linearring.apply(this, │ │ │ │ + [rings[i]]); │ │ │ │ + ringMember.appendChild(ringGeom); │ │ │ │ + kml.appendChild(ringMember); │ │ │ │ + } │ │ │ │ + return kml; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // now set the pixel widths │ │ │ │ - // and the values inside them │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.multipolygon │ │ │ │ + * Given an OpenLayers multipolygon geometry, create a KML │ │ │ │ + * GeometryCollection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Point>} A multipolygon geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML GeometryCollection node. │ │ │ │ + */ │ │ │ │ + multipolygon: function(geometry) { │ │ │ │ + return this.buildGeometry.collection.apply(this, [geometry]); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.eBottom.style.visibility == "visible") { │ │ │ │ - this.eBottom.style.width = Math.round(bottomPx) + "px"; │ │ │ │ - this.eBottom.innerHTML = bottomRounded + " " + bottomUnits; │ │ │ │ + /** │ │ │ │ + * Method: buildGeometry.collection │ │ │ │ + * Given an OpenLayers geometry collection, create a KML MultiGeometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry.Collection>} A geometry collection. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A KML MultiGeometry node. │ │ │ │ + */ │ │ │ │ + collection: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "MultiGeometry"); │ │ │ │ + var child; │ │ │ │ + for (var i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ + child = this.buildGeometryNode.apply(this, │ │ │ │ + [geometry.components[i]]); │ │ │ │ + if (child) { │ │ │ │ + kml.appendChild(child); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return kml; │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.eTop.style.visibility == "visible") { │ │ │ │ - this.eTop.style.width = Math.round(topPx) + "px"; │ │ │ │ - this.eTop.innerHTML = topRounded + " " + topUnits; │ │ │ │ + /** │ │ │ │ + * Method: buildCoordinatesNode │ │ │ │ + * Builds and returns the KML coordinates node with the given geometry │ │ │ │ + * <coordinates>...</coordinates> │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + buildCoordinatesNode: function(geometry) { │ │ │ │ + var coordinatesNode = this.createElementNS(this.kmlns, "coordinates"); │ │ │ │ + │ │ │ │ + var path; │ │ │ │ + var points = geometry.components; │ │ │ │ + if (points) { │ │ │ │ + // LineString or LinearRing │ │ │ │ + var point; │ │ │ │ + var numPoints = points.length; │ │ │ │ + var parts = new Array(numPoints); │ │ │ │ + for (var i = 0; i < numPoints; ++i) { │ │ │ │ + point = points[i]; │ │ │ │ + parts[i] = this.buildCoordinates(point); │ │ │ │ + } │ │ │ │ + path = parts.join(" "); │ │ │ │ + } else { │ │ │ │ + // Point │ │ │ │ + path = this.buildCoordinates(geometry); │ │ │ │ } │ │ │ │ │ │ │ │ + var txtNode = this.createTextNode(path); │ │ │ │ + coordinatesNode.appendChild(txtNode); │ │ │ │ + │ │ │ │ + return coordinatesNode; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ScaleLine" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Method: buildCoordinates │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns │ │ │ │ + * {String} a coordinate pair │ │ │ │ + */ │ │ │ │ + buildCoordinates: function(point) { │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + point = point.clone(); │ │ │ │ + point.transform(this.internalProjection, │ │ │ │ + this.externalProjection); │ │ │ │ + } │ │ │ │ + return point.x + "," + point.y; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: buildExtendedData │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * attributes - {Object} │ │ │ │ + * │ │ │ │ + * Returns │ │ │ │ + * {DOMElement} A KML ExtendedData node or {null} if no attributes. │ │ │ │ + */ │ │ │ │ + buildExtendedData: function(attributes) { │ │ │ │ + var extendedData = this.createElementNS(this.kmlns, "ExtendedData"); │ │ │ │ + for (var attributeName in attributes) { │ │ │ │ + // empty, name, description, styleUrl attributes ignored │ │ │ │ + if (attributes[attributeName] && attributeName != "name" && attributeName != "description" && attributeName != "styleUrl") { │ │ │ │ + var data = this.createElementNS(this.kmlns, "Data"); │ │ │ │ + data.setAttribute("name", attributeName); │ │ │ │ + var value = this.createElementNS(this.kmlns, "value"); │ │ │ │ + if (typeof attributes[attributeName] == "object") { │ │ │ │ + // cater for object attributes with 'value' properties │ │ │ │ + // other object properties will output an empty node │ │ │ │ + if (attributes[attributeName].value) { │ │ │ │ + value.appendChild(this.createTextNode(attributes[attributeName].value)); │ │ │ │ + } │ │ │ │ + if (attributes[attributeName].displayName) { │ │ │ │ + var displayName = this.createElementNS(this.kmlns, "displayName"); │ │ │ │ + // displayName always written as CDATA │ │ │ │ + displayName.appendChild(this.getXMLDoc().createCDATASection(attributes[attributeName].displayName)); │ │ │ │ + data.appendChild(displayName); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + value.appendChild(this.createTextNode(attributes[attributeName])); │ │ │ │ + } │ │ │ │ + data.appendChild(value); │ │ │ │ + extendedData.appendChild(data); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.isSimpleContent(extendedData)) { │ │ │ │ + return null; │ │ │ │ + } else { │ │ │ │ + return extendedData; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Format.KML" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Hover.js │ │ │ │ + OpenLayers/Format/XLS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Hover │ │ │ │ - * The hover handler is to be used to emulate mouseovers on objects │ │ │ │ - * on the map that aren't DOM elements. For example one can use │ │ │ │ - * this handler to send WMS/GetFeatureInfo requests as the user │ │ │ │ - * moves the mouve over the map. │ │ │ │ + * Class: OpenLayers.Format.XLS │ │ │ │ + * Read/Write XLS (OpenLS). Create a new instance with the <OpenLayers.Format.XLS> │ │ │ │ + * constructor. Currently only implemented for Location Utility Services, more │ │ │ │ + * specifically only for Geocoding. No support for Reverse Geocoding as yet. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Hover = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: delay │ │ │ │ - * {Integer} - Number of milliseconds between mousemoves before │ │ │ │ - * the event is considered a hover. Default is 500. │ │ │ │ - */ │ │ │ │ - delay: 500, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: pixelTolerance │ │ │ │ - * {Integer} - Maximum number of pixels between mousemoves for │ │ │ │ - * an event to be considered a hover. Default is null. │ │ │ │ - */ │ │ │ │ - pixelTolerance: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: stopMove │ │ │ │ - * {Boolean} - Stop other listeners from being notified on mousemoves. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - stopMove: false, │ │ │ │ +OpenLayers.Format.XLS = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: px │ │ │ │ - * {<OpenLayers.Pixel>} - The location of the last mousemove, expressed │ │ │ │ - * in pixels. │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ */ │ │ │ │ - px: null, │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timerId │ │ │ │ - * {Number} - The id of the timer. │ │ │ │ + * APIProperty: stringifyOutput │ │ │ │ + * {Boolean} If true, write will return a string otherwise a DOMElement. │ │ │ │ + * Default is true. │ │ │ │ */ │ │ │ │ - timerId: null, │ │ │ │ + stringifyOutput: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Hover │ │ │ │ - * Construct a hover handler. │ │ │ │ + * Constructor: OpenLayers.Format.XLS │ │ │ │ + * Create a new parser for XLS. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.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 with keys corresponding to callbacks │ │ │ │ - * that will be called by the handler. The callbacks should │ │ │ │ - * expect to receive a single argument, the event. Callbacks for │ │ │ │ - * 'move', the mouse is moving, and 'pause', the mouse is pausing, │ │ │ │ - * are supported. │ │ │ │ * options - {Object} An optional object whose properties will be set on │ │ │ │ - * the handler. │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousemove │ │ │ │ - * Called when the mouse moves on the map. │ │ │ │ + * APIMethod: write │ │ │ │ + * Write out an XLS request. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * request - {Object} An object representing the LUS request. │ │ │ │ + * options - {Object} Optional configuration object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {String} An XLS document string. │ │ │ │ */ │ │ │ │ - mousemove: function(evt) { │ │ │ │ - if (this.passesTolerance(evt.xy)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.callback('move', [evt]); │ │ │ │ - this.px = evt.xy; │ │ │ │ - // clone the evt so original properties can be accessed even │ │ │ │ - // if the browser deletes them during the delay │ │ │ │ - evt = OpenLayers.Util.extend({}, evt); │ │ │ │ - this.timerId = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(this.delayedCall, this, evt), │ │ │ │ - this.delay │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return !this.stopMove; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mouseout │ │ │ │ - * Called when the mouse goes out of the map. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read an XLS doc and return an object representing the result. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * data - {String | DOMElement} Data to read. │ │ │ │ + * options - {Object} Options for the reader. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Object} An object representing the GeocodeResponse. │ │ │ │ */ │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.callback('move', [evt]); │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.XLS" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/SLD.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + * @requires OpenLayers/Style.js │ │ │ │ + * @requires OpenLayers/Rule.js │ │ │ │ + * @requires OpenLayers/Filter/FeatureId.js │ │ │ │ + * @requires OpenLayers/Filter/Logical.js │ │ │ │ + * @requires OpenLayers/Filter/Comparison.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.SLD │ │ │ │ + * Read/Write SLD. Create a new instance with the <OpenLayers.Format.SLD> │ │ │ │ + * constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.SLD = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: passesTolerance │ │ │ │ - * Determine whether the mouse move is within the optional pixel tolerance. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ + * APIProperty: profile │ │ │ │ + * {String} If provided, use a custom profile. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The mouse move is within the pixel tolerance. │ │ │ │ + * Currently supported profiles: │ │ │ │ + * - GeoServer - parses GeoServer vendor specific capabilities for SLD. │ │ │ │ */ │ │ │ │ - passesTolerance: function(px) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.pixelTolerance && this.px) { │ │ │ │ - var dpx = Math.sqrt( │ │ │ │ - Math.pow(this.px.x - px.x, 2) + │ │ │ │ - Math.pow(this.px.y - px.y, 2) │ │ │ │ - ); │ │ │ │ - if (dpx < this.pixelTolerance) { │ │ │ │ - passes = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return passes; │ │ │ │ - }, │ │ │ │ + profile: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearTimer │ │ │ │ - * Clear the timer and set <timerId> to null. │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ */ │ │ │ │ - clearTimer: function() { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + defaultVersion: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: delayedCall │ │ │ │ - * Triggers pause callback. │ │ │ │ + * APIProperty: stringifyOutput │ │ │ │ + * {Boolean} If true, write will return a string otherwise a DOMElement. │ │ │ │ + * Default is true. │ │ │ │ + */ │ │ │ │ + stringifyOutput: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: namedLayersAsArray │ │ │ │ + * {Boolean} Generate a namedLayers array. If false, the namedLayers │ │ │ │ + * property value will be an object keyed by layer name. Default is │ │ │ │ + * false. │ │ │ │ + */ │ │ │ │ + namedLayersAsArray: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: write │ │ │ │ + * Write a SLD document given a list of styles. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * sld - {Object} An object representing the SLD. │ │ │ │ + * options - {Object} Optional configuration object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} An SLD document string. │ │ │ │ */ │ │ │ │ - delayedCall: function(evt) { │ │ │ │ - this.callback('pause', [evt]); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the handler. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read and SLD doc and return an object representing the SLD. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String | DOMElement} Data to read. │ │ │ │ + * options - {Object} Options for the reader. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated. │ │ │ │ + * {Object} An object representing the SLD. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - deactivated = true; │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ - }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Hover" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SLD" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Format/WMSGetFeatureInfo.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -54573,6242 +54067,8609 @@ │ │ │ │ }; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Format.WMSGetFeatureInfo" │ │ │ │ │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/WMSGetFeatureInfo.js │ │ │ │ + OpenLayers/Format/WFSDescribeFeatureType.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ - * @requires OpenLayers/Handler/Hover.js │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ - * @requires OpenLayers/Format/WMSGetFeatureInfo.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/OGCExceptionReport.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.WMSGetFeatureInfo │ │ │ │ - * The WMSGetFeatureInfo control uses a WMS query to get information about a point on the map. The │ │ │ │ - * information may be in a display-friendly format such as HTML, or a machine-friendly format such │ │ │ │ - * as GML, depending on the server's capabilities and the client's configuration. This control │ │ │ │ - * handles click or hover events, attempts to parse the results using an OpenLayers.Format, and │ │ │ │ - * fires a 'getfeatureinfo' event with the click position, the raw body of the response, and an │ │ │ │ - * array of features if it successfully read the response. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Format.WFSDescribeFeatureType │ │ │ │ + * Read WFS DescribeFeatureType response │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.WMSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.WFSDescribeFeatureType = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: hover │ │ │ │ - * {Boolean} Send GetFeatureInfo requests when mouse stops moving. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - hover: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: drillDown │ │ │ │ - * {Boolean} Drill down over all WMS layers in the map. When │ │ │ │ - * using drillDown mode, hover is not possible, and an infoFormat that │ │ │ │ - * returns parseable features is required. Default is false. │ │ │ │ - */ │ │ │ │ - drillDown: false, │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g) │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: maxFeatures │ │ │ │ - * {Integer} Maximum number of features to return from a WMS query. This │ │ │ │ - * sets the feature_count parameter on WMS GetFeatureInfo │ │ │ │ - * requests. │ │ │ │ - */ │ │ │ │ - maxFeatures: 10, │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + xsd: "http://www.w3.org/2001/XMLSchema" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: clickCallback │ │ │ │ - * {String} The click callback to register in the │ │ │ │ - * {<OpenLayers.Handler.Click>} object created when the hover │ │ │ │ - * option is set to false. Default is "click". │ │ │ │ - */ │ │ │ │ - clickCallback: "click", │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WFSDescribeFeatureType │ │ │ │ + * Create a new parser for WFS DescribeFeatureType responses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: output │ │ │ │ - * {String} Either "features" or "object". When triggering a getfeatureinfo │ │ │ │ - * request should we pass on an array of features or an object with with │ │ │ │ - * a "features" property and other properties (such as the url of the │ │ │ │ - * WMS). Default is "features". │ │ │ │ - */ │ │ │ │ - output: "features", │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "xsd": { │ │ │ │ + "schema": function(node, obj) { │ │ │ │ + var complexTypes = []; │ │ │ │ + var customTypes = {}; │ │ │ │ + var schema = { │ │ │ │ + complexTypes: complexTypes, │ │ │ │ + customTypes: customTypes │ │ │ │ + }; │ │ │ │ + var i, len; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * {Array(<OpenLayers.Layer.WMS>)} The layers to query for feature info. │ │ │ │ - * If omitted, all map WMS layers with a url that matches this <url> or │ │ │ │ - * <layerUrls> will be considered. │ │ │ │ - */ │ │ │ │ - layers: null, │ │ │ │ + this.readChildNodes(node, schema); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: queryVisible │ │ │ │ - * {Boolean} If true, filter out hidden layers when searching the map for │ │ │ │ - * layers to query. Default is false. │ │ │ │ - */ │ │ │ │ - queryVisible: false, │ │ │ │ + var attributes = node.attributes; │ │ │ │ + var attr, name; │ │ │ │ + for (i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ + attr = attributes[i]; │ │ │ │ + name = attr.name; │ │ │ │ + if (name.indexOf("xmlns") === 0) { │ │ │ │ + this.setNamespace(name.split(":")[1] || "", attr.value); │ │ │ │ + } else { │ │ │ │ + obj[name] = attr.value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + obj.featureTypes = complexTypes; │ │ │ │ + obj.targetPrefix = this.namespaceAlias[obj.targetNamespace]; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} The URL of the WMS service to use. If not provided, the url │ │ │ │ - * of the first eligible layer will be used. │ │ │ │ - */ │ │ │ │ - url: null, │ │ │ │ + // map complexTypes to names of customTypes │ │ │ │ + var complexType, customType; │ │ │ │ + for (i = 0, len = complexTypes.length; i < len; ++i) { │ │ │ │ + complexType = complexTypes[i]; │ │ │ │ + customType = customTypes[complexType.typeName]; │ │ │ │ + if (customTypes[complexType.typeName]) { │ │ │ │ + complexType.typeName = customType.name; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "complexType": function(node, obj) { │ │ │ │ + var complexType = { │ │ │ │ + // this is a temporary typeName, it will be overwritten by │ │ │ │ + // the schema reader with the metadata found in the │ │ │ │ + // customTypes hash │ │ │ │ + "typeName": node.getAttribute("name") │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, complexType); │ │ │ │ + obj.complexTypes.push(complexType); │ │ │ │ + }, │ │ │ │ + "complexContent": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "extension": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "sequence": function(node, obj) { │ │ │ │ + var sequence = { │ │ │ │ + elements: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, sequence); │ │ │ │ + obj.properties = sequence.elements; │ │ │ │ + }, │ │ │ │ + "element": function(node, obj) { │ │ │ │ + var type; │ │ │ │ + if (obj.elements) { │ │ │ │ + var element = {}; │ │ │ │ + var attributes = node.attributes; │ │ │ │ + var attr; │ │ │ │ + for (var i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ + attr = attributes[i]; │ │ │ │ + element[attr.name] = attr.value; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: layerUrls │ │ │ │ - * {Array(String)} Optional list of urls for layers that should be queried. │ │ │ │ - * This can be used when the layer url differs from the url used for │ │ │ │ - * making GetFeatureInfo requests (in the case of a layer using cached │ │ │ │ - * tiles). │ │ │ │ - */ │ │ │ │ - layerUrls: null, │ │ │ │ + type = element.type; │ │ │ │ + if (!type) { │ │ │ │ + type = {}; │ │ │ │ + this.readChildNodes(node, type); │ │ │ │ + element.restriction = type; │ │ │ │ + element.type = type.base; │ │ │ │ + } │ │ │ │ + var fullType = type.base || type; │ │ │ │ + element.localType = fullType.split(":").pop(); │ │ │ │ + obj.elements.push(element); │ │ │ │ + this.readChildNodes(node, element); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: infoFormat │ │ │ │ - * {String} The mimetype to request from the server. If you are using │ │ │ │ - * drillDown mode and have multiple servers that do not share a common │ │ │ │ - * infoFormat, you can override the control's infoFormat by providing an │ │ │ │ - * INFO_FORMAT parameter in your <OpenLayers.Layer.WMS> instance(s). │ │ │ │ - */ │ │ │ │ - infoFormat: 'text/html', │ │ │ │ + if (obj.complexTypes) { │ │ │ │ + type = node.getAttribute("type"); │ │ │ │ + var localType = type.split(":").pop(); │ │ │ │ + obj.customTypes[localType] = { │ │ │ │ + "name": node.getAttribute("name"), │ │ │ │ + "type": type │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "annotation": function(node, obj) { │ │ │ │ + obj.annotation = {}; │ │ │ │ + this.readChildNodes(node, obj.annotation); │ │ │ │ + }, │ │ │ │ + "appinfo": function(node, obj) { │ │ │ │ + if (!obj.appinfo) { │ │ │ │ + obj.appinfo = []; │ │ │ │ + } │ │ │ │ + obj.appinfo.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "documentation": function(node, obj) { │ │ │ │ + if (!obj.documentation) { │ │ │ │ + obj.documentation = []; │ │ │ │ + } │ │ │ │ + var value = this.getChildValue(node); │ │ │ │ + obj.documentation.push({ │ │ │ │ + lang: node.getAttribute("xml:lang"), │ │ │ │ + textContent: value.replace(this.regExes.trimSpace, "") │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "simpleType": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "restriction": function(node, obj) { │ │ │ │ + obj.base = node.getAttribute("base"); │ │ │ │ + this.readRestriction(node, obj); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: vendorParams │ │ │ │ - * {Object} Additional parameters that will be added to the request, for │ │ │ │ - * WMS implementations that support them. This could e.g. look like │ │ │ │ - * (start code) │ │ │ │ - * { │ │ │ │ - * radius: 5 │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ - vendorParams: {}, │ │ │ │ + /** │ │ │ │ + * Method: readRestriction │ │ │ │ + * Reads restriction defined in the child nodes of a restriction element │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} the node to parse │ │ │ │ + * obj - {Object} the object that receives the read result │ │ │ │ + */ │ │ │ │ + readRestriction: function(node, obj) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var child, nodeName, value; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + nodeName = child.nodeName.split(":").pop(); │ │ │ │ + value = child.getAttribute("value"); │ │ │ │ + if (!obj[nodeName]) { │ │ │ │ + obj[nodeName] = value; │ │ │ │ + } else { │ │ │ │ + if (typeof obj[nodeName] == "string") { │ │ │ │ + obj[nodeName] = [obj[nodeName]]; │ │ │ │ + } │ │ │ │ + obj[nodeName].push(value); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: format │ │ │ │ - * {<OpenLayers.Format>} A format for parsing GetFeatureInfo responses. │ │ │ │ - * Default is <OpenLayers.Format.WMSGetFeatureInfo>. │ │ │ │ - */ │ │ │ │ - format: null, │ │ │ │ + /** │ │ │ │ + * Method: read │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {DOMElement|String} A WFS DescribeFeatureType document. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object representing the WFS DescribeFeatureType response. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var schema = {}; │ │ │ │ + if (data.nodeName.split(":").pop() === 'ExceptionReport') { │ │ │ │ + // an exception must have occurred, so parse it │ │ │ │ + var parser = new OpenLayers.Format.OGCExceptionReport(); │ │ │ │ + schema.error = parser.read(data); │ │ │ │ + } else { │ │ │ │ + this.readNode(data, schema); │ │ │ │ + } │ │ │ │ + return schema; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: formatOptions │ │ │ │ - * {Object} Optional properties to set on the format (if one is not provided │ │ │ │ - * in the <format> property. │ │ │ │ - */ │ │ │ │ - formatOptions: null, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSDescribeFeatureType" │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Additional options for the handlers used by this control, e.g. │ │ │ │ - * (start code) │ │ │ │ - * { │ │ │ │ - * "click": {delay: 100}, │ │ │ │ - * "hover": {delay: 300} │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WCSCapabilities.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: handler │ │ │ │ - * {Object} Reference to the <OpenLayers.Handler> for this control │ │ │ │ - */ │ │ │ │ - handler: null, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: hoverRequest │ │ │ │ - * {<OpenLayers.Request>} contains the currently running hover request │ │ │ │ - * (if any). │ │ │ │ - */ │ │ │ │ - hoverRequest: null, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforegetfeatureinfo - Triggered before the request is sent. │ │ │ │ - * The event object has an *xy* property with the position of the │ │ │ │ - * mouse click or hover event that triggers the request. │ │ │ │ - * nogetfeatureinfo - no queryable layers were found. │ │ │ │ - * getfeatureinfo - Triggered when a GetFeatureInfo response is received. │ │ │ │ - * The event object has a *text* property with the body of the │ │ │ │ - * response (String), a *features* property with an array of the │ │ │ │ - * parsed features, an *xy* property with the position of the mouse │ │ │ │ - * click or hover event that triggered the request, and a *request* │ │ │ │ - * property with the request itself. If drillDown is set to true and │ │ │ │ - * multiple requests were issued to collect feature info from all │ │ │ │ - * layers, *text* and *request* will only contain the response body │ │ │ │ - * and request object of the last request. │ │ │ │ - */ │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WCSCapabilities │ │ │ │ + * Read WCS Capabilities. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WCSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: <OpenLayers.Control.WMSGetFeatureInfo> │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.handlerOptions = options.handlerOptions || {}; │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.WMSGetFeatureInfo( │ │ │ │ - options.formatOptions │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.drillDown === true) { │ │ │ │ - this.hover = false; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.hover) { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover( │ │ │ │ - this, { │ │ │ │ - 'move': this.cancelHover, │ │ │ │ - 'pause': this.getInfoForHover │ │ │ │ - }, │ │ │ │ - OpenLayers.Util.extend(this.handlerOptions.hover || {}, { │ │ │ │ - 'delay': 250 │ │ │ │ - })); │ │ │ │ - } else { │ │ │ │ - var callbacks = {}; │ │ │ │ - callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ - this.handler = new OpenLayers.Handler.Click( │ │ │ │ - this, callbacks, this.handlerOptions.click || {}); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getInfoForClick │ │ │ │ - * Called on click │ │ │ │ + * Constructor: OpenLayers.Format.WCSCapabilities │ │ │ │ + * Create a new parser for WCS capabilities. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - getInfoForClick: function(evt) { │ │ │ │ - this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ - xy: evt.xy │ │ │ │ - }); │ │ │ │ - // Set the cursor to "wait" to tell the user we're working on their │ │ │ │ - // click. │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - this.request(evt.xy, {}); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getInfoForHover │ │ │ │ - * Pause callback for the hover handler │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return a list of coverages. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ - */ │ │ │ │ - getInfoForHover: function(evt) { │ │ │ │ - this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ - xy: evt.xy │ │ │ │ - }); │ │ │ │ - this.request(evt.xy, { │ │ │ │ - hover: true │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: cancelHover │ │ │ │ - * Cancel callback for the hover handler │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named coverages. │ │ │ │ */ │ │ │ │ - cancelHover: function() { │ │ │ │ - if (this.hoverRequest) { │ │ │ │ - this.hoverRequest.abort(); │ │ │ │ - this.hoverRequest = null; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: findLayers │ │ │ │ - * Internal method to get the layers, independent of whether we are │ │ │ │ - * inspecting the map or using a client-provided array │ │ │ │ - */ │ │ │ │ - findLayers: function() { │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities" │ │ │ │ │ │ │ │ - var candidates = this.layers || this.map.layers; │ │ │ │ - var layers = []; │ │ │ │ - var layer, url; │ │ │ │ - for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ - layer = candidates[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMS && │ │ │ │ - (!this.queryVisible || layer.getVisibility())) { │ │ │ │ - url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ - // if the control was not configured with a url, set it │ │ │ │ - // to the first layer url │ │ │ │ - if (this.drillDown === false && !this.url) { │ │ │ │ - this.url = url; │ │ │ │ - } │ │ │ │ - if (this.drillDown === true || this.urlMatches(url)) { │ │ │ │ - layers.push(layer); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return layers; │ │ │ │ - }, │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WFSCapabilities.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: urlMatches │ │ │ │ - * Test to see if the provided url matches either the control <url> or one │ │ │ │ - * of the <layerUrls>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * url - {String} The url to test. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The provided url matches the control <url> or one of the │ │ │ │ - * <layerUrls>. │ │ │ │ - */ │ │ │ │ - urlMatches: function(url) { │ │ │ │ - var matches = OpenLayers.Util.isEquivalentUrl(this.url, url); │ │ │ │ - if (!matches && this.layerUrls) { │ │ │ │ - for (var i = 0, len = this.layerUrls.length; i < len; ++i) { │ │ │ │ - if (OpenLayers.Util.isEquivalentUrl(this.layerUrls[i], url)) { │ │ │ │ - matches = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return matches; │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: buildWMSOptions │ │ │ │ - * Build an object with the relevant WMS options for the GetFeatureInfo request │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * url - {String} The url to be used for sending the request │ │ │ │ - * layers - {Array(<OpenLayers.Layer.WMS)} An array of layers │ │ │ │ - * clickPosition - {<OpenLayers.Pixel>} The position on the map where the mouse │ │ │ │ - * event occurred. │ │ │ │ - * format - {String} The format from the corresponding GetMap request │ │ │ │ - */ │ │ │ │ - buildWMSOptions: function(url, layers, clickPosition, format) { │ │ │ │ - var layerNames = [], │ │ │ │ - styleNames = []; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - if (layers[i].params.LAYERS != null) { │ │ │ │ - layerNames = layerNames.concat(layers[i].params.LAYERS); │ │ │ │ - styleNames = styleNames.concat(this.getStyleNames(layers[i])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var firstLayer = layers[0]; │ │ │ │ - // use the firstLayer's projection if it matches the map projection - │ │ │ │ - // this assumes that all layers will be available in this projection │ │ │ │ - var projection = this.map.getProjection(); │ │ │ │ - var layerProj = firstLayer.projection; │ │ │ │ - if (layerProj && layerProj.equals(this.map.getProjectionObject())) { │ │ │ │ - projection = layerProj.getCode(); │ │ │ │ - } │ │ │ │ - var params = OpenLayers.Util.extend({ │ │ │ │ - service: "WMS", │ │ │ │ - version: firstLayer.params.VERSION, │ │ │ │ - request: "GetFeatureInfo", │ │ │ │ - exceptions: firstLayer.params.EXCEPTIONS, │ │ │ │ - bbox: this.map.getExtent().toBBOX(null, │ │ │ │ - firstLayer.reverseAxisOrder()), │ │ │ │ - feature_count: this.maxFeatures, │ │ │ │ - height: this.map.getSize().h, │ │ │ │ - width: this.map.getSize().w, │ │ │ │ - format: format, │ │ │ │ - info_format: firstLayer.params.INFO_FORMAT || this.infoFormat │ │ │ │ - }, (parseFloat(firstLayer.params.VERSION) >= 1.3) ? { │ │ │ │ - crs: projection, │ │ │ │ - i: parseInt(clickPosition.x), │ │ │ │ - j: parseInt(clickPosition.y) │ │ │ │ - } : { │ │ │ │ - srs: projection, │ │ │ │ - x: parseInt(clickPosition.x), │ │ │ │ - y: parseInt(clickPosition.y) │ │ │ │ - }); │ │ │ │ - if (layerNames.length != 0) { │ │ │ │ - params = OpenLayers.Util.extend({ │ │ │ │ - layers: layerNames, │ │ │ │ - query_layers: layerNames, │ │ │ │ - styles: styleNames │ │ │ │ - }, params); │ │ │ │ - } │ │ │ │ - OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ - return { │ │ │ │ - url: url, │ │ │ │ - params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ - callback: function(request) { │ │ │ │ - this.handleResponse(clickPosition, request, url); │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getStyleNames │ │ │ │ - * Gets the STYLES parameter for the layer. Make sure the STYLES parameter │ │ │ │ - * matches the LAYERS parameter │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.WMS>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(String)} The STYLES parameter │ │ │ │ - */ │ │ │ │ - getStyleNames: function(layer) { │ │ │ │ - // in the event of a WMS layer bundling multiple layers but not │ │ │ │ - // specifying styles,we need the same number of commas to specify │ │ │ │ - // the default style for each of the layers. We can't just leave it │ │ │ │ - // blank as we may be including other layers that do specify styles. │ │ │ │ - var styleNames; │ │ │ │ - if (layer.params.STYLES) { │ │ │ │ - styleNames = layer.params.STYLES; │ │ │ │ - } else { │ │ │ │ - if (OpenLayers.Util.isArray(layer.params.LAYERS)) { │ │ │ │ - styleNames = new Array(layer.params.LAYERS.length); │ │ │ │ - } else { // Assume it's a String │ │ │ │ - styleNames = layer.params.LAYERS.replace(/[^,]/g, ""); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return styleNames; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WFSCapabilities │ │ │ │ + * Read WFS Capabilities. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WFSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: request │ │ │ │ - * Sends a GetFeatureInfo request to the WMS │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * clickPosition - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ - * mouse event occurred. │ │ │ │ - * options - {Object} additional options for this method. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * - *hover* {Boolean} true if we do the request for the hover handler │ │ │ │ + * APIProperty: defaultVersion │ │ │ │ + * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ */ │ │ │ │ - request: function(clickPosition, options) { │ │ │ │ - var layers = this.findLayers(); │ │ │ │ - if (layers.length == 0) { │ │ │ │ - this.events.triggerEvent("nogetfeatureinfo"); │ │ │ │ - // Reset the cursor. │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - options = options || {}; │ │ │ │ - if (this.drillDown === false) { │ │ │ │ - var wmsOptions = this.buildWMSOptions(this.url, layers, │ │ │ │ - clickPosition, layers[0].params.FORMAT); │ │ │ │ - var request = OpenLayers.Request.GET(wmsOptions); │ │ │ │ - │ │ │ │ - if (options.hover === true) { │ │ │ │ - this.hoverRequest = request; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this._requestCount = 0; │ │ │ │ - this._numRequests = 0; │ │ │ │ - this.features = []; │ │ │ │ - // group according to service url to combine requests │ │ │ │ - var services = {}, │ │ │ │ - url; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - var service, found = false; │ │ │ │ - url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ - if (url in services) { │ │ │ │ - services[url].push(layer); │ │ │ │ - } else { │ │ │ │ - this._numRequests++; │ │ │ │ - services[url] = [layer]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var layers; │ │ │ │ - for (var url in services) { │ │ │ │ - layers = services[url]; │ │ │ │ - var wmsOptions = this.buildWMSOptions(url, layers, │ │ │ │ - clickPosition, layers[0].params.FORMAT); │ │ │ │ - OpenLayers.Request.GET(wmsOptions); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: triggerGetFeatureInfo │ │ │ │ - * Trigger the getfeatureinfo event when all is done │ │ │ │ + * Constructor: OpenLayers.Format.WFSCapabilities │ │ │ │ + * Create a new parser for WFS capabilities. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * request - {XMLHttpRequest} The request object │ │ │ │ - * xy - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ - * mouse event occurred. │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} or │ │ │ │ - * {Array({Object}) when output is "object". The object has a url and a │ │ │ │ - * features property which contains an array of features. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - triggerGetFeatureInfo: function(request, xy, features) { │ │ │ │ - this.events.triggerEvent("getfeatureinfo", { │ │ │ │ - text: request.responseText, │ │ │ │ - features: features, │ │ │ │ - request: request, │ │ │ │ - xy: xy │ │ │ │ - }); │ │ │ │ - │ │ │ │ - // Reset the cursor. │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleResponse │ │ │ │ - * Handler for the GetFeatureInfo response. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return a list of layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ - * mouse event occurred. │ │ │ │ - * request - {XMLHttpRequest} The request object. │ │ │ │ - * url - {String} The url which was used for this request. │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named layers. │ │ │ │ */ │ │ │ │ - handleResponse: function(xy, request, url) { │ │ │ │ │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - var features = this.format.read(doc); │ │ │ │ - if (this.drillDown === false) { │ │ │ │ - this.triggerGetFeatureInfo(request, xy, features); │ │ │ │ - } else { │ │ │ │ - this._requestCount++; │ │ │ │ - if (this.output === "object") { │ │ │ │ - this._features = (this._features || []).concat({ │ │ │ │ - url: url, │ │ │ │ - features: features │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - this._features = (this._features || []).concat(features); │ │ │ │ - } │ │ │ │ - if (this._requestCount === this._numRequests) { │ │ │ │ - this.triggerGetFeatureInfo(request, xy, this._features.concat()); │ │ │ │ - delete this._features; │ │ │ │ - delete this._requestCount; │ │ │ │ - delete this._numRequests; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.WMSGetFeatureInfo" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/OverviewMap.js │ │ │ │ + OpenLayers/Format/WMC/v1.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/BaseTypes.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ - * @requires OpenLayers/Map.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMC.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.OverviewMap │ │ │ │ - * The OverMap control creates a small overview map, useful to display the │ │ │ │ - * extent of a zoomed map and your main map and provide additional │ │ │ │ - * navigation options to the User. By default the overview map is drawn in │ │ │ │ - * the lower right corner of the main map. Create a new overview map with the │ │ │ │ - * <OpenLayers.Control.OverviewMap> constructor. │ │ │ │ + * Class: OpenLayers.Format.WMC.v1 │ │ │ │ + * Superclass for WMC version 1 parsers. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.OverviewMap = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: element │ │ │ │ - * {DOMElement} The DOM element that contains the overview map │ │ │ │ - */ │ │ │ │ - element: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: ovmap │ │ │ │ - * {<OpenLayers.Map>} A reference to the overview map itself. │ │ │ │ - */ │ │ │ │ - ovmap: null, │ │ │ │ +OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: size │ │ │ │ - * {<OpenLayers.Size>} The overvew map size in pixels. Note that this is │ │ │ │ - * the size of the map itself - the element that contains the map (default │ │ │ │ - * class name olControlOverviewMapElement) may have padding or other style │ │ │ │ - * attributes added via CSS. │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - size: { │ │ │ │ - w: 180, │ │ │ │ - h: 90 │ │ │ │ + namespaces: { │ │ │ │ + ol: "http://openlayers.org/context", │ │ │ │ + wmc: "http://www.opengis.net/context", │ │ │ │ + sld: "http://www.opengis.net/sld", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * {Array(<OpenLayers.Layer>)} Ordered list of layers in the overview map. │ │ │ │ - * If none are sent at construction, the base layer for the main map is used. │ │ │ │ - */ │ │ │ │ - layers: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: minRectSize │ │ │ │ - * {Integer} The minimum width or height (in pixels) of the extent │ │ │ │ - * rectangle on the overview map. When the extent rectangle reaches │ │ │ │ - * this size, it will be replaced depending on the value of the │ │ │ │ - * <minRectDisplayClass> property. Default is 15 pixels. │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location for a particular minor version. │ │ │ │ */ │ │ │ │ - minRectSize: 15, │ │ │ │ + schemaLocation: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: minRectDisplayClass │ │ │ │ - * {String} Replacement style class name for the extent rectangle when │ │ │ │ - * <minRectSize> is reached. This string will be suffixed on to the │ │ │ │ - * displayClass. Default is "RectReplacement". │ │ │ │ + * Method: getNamespacePrefix │ │ │ │ + * Get the namespace prefix for a given uri from the <namespaces> object. │ │ │ │ * │ │ │ │ - * Example CSS declaration: │ │ │ │ - * (code) │ │ │ │ - * .olControlOverviewMapRectReplacement { │ │ │ │ - * overflow: hidden; │ │ │ │ - * cursor: move; │ │ │ │ - * background-image: url("img/overview_replacement.gif"); │ │ │ │ - * background-repeat: no-repeat; │ │ │ │ - * background-position: center; │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ - minRectDisplayClass: "RectReplacement", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: minRatio │ │ │ │ - * {Float} The ratio of the overview map resolution to the main map │ │ │ │ - * resolution at which to zoom farther out on the overview map. │ │ │ │ - */ │ │ │ │ - minRatio: 8, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: maxRatio │ │ │ │ - * {Float} The ratio of the overview map resolution to the main map │ │ │ │ - * resolution at which to zoom farther in on the overview map. │ │ │ │ - */ │ │ │ │ - maxRatio: 32, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: mapOptions │ │ │ │ - * {Object} An object containing any non-default properties to be sent to │ │ │ │ - * the overview map's map constructor. These should include any │ │ │ │ - * non-default options that the main map was constructed with. │ │ │ │ - */ │ │ │ │ - mapOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoPan │ │ │ │ - * {Boolean} Always pan the overview map, so the extent marker remains in │ │ │ │ - * the center. Default is false. If true, when you drag the extent │ │ │ │ - * marker, the overview map will update itself so the marker returns │ │ │ │ - * to the center. │ │ │ │ - */ │ │ │ │ - autoPan: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: handlers │ │ │ │ - * {Object} │ │ │ │ + * Returns: │ │ │ │ + * {String} A namespace prefix or null if none found. │ │ │ │ */ │ │ │ │ - handlers: null, │ │ │ │ + getNamespacePrefix: function(uri) { │ │ │ │ + var prefix = null; │ │ │ │ + if (uri == null) { │ │ │ │ + prefix = this.namespaces[this.defaultPrefix]; │ │ │ │ + } else { │ │ │ │ + for (prefix in this.namespaces) { │ │ │ │ + if (this.namespaces[prefix] == uri) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return prefix; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: resolutionFactor │ │ │ │ - * {Object} │ │ │ │ + * Property: defaultPrefix │ │ │ │ */ │ │ │ │ - resolutionFactor: 1, │ │ │ │ + defaultPrefix: "wmc", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maximized │ │ │ │ - * {Boolean} Start as maximized (visible). Defaults to false. │ │ │ │ + * Property: rootPrefix │ │ │ │ + * {String} Prefix on the root node that maps to the context namespace URI. │ │ │ │ */ │ │ │ │ - maximized: false, │ │ │ │ + rootPrefix: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maximizeTitle │ │ │ │ - * {String} This property is used for showing a tooltip over the │ │ │ │ - * maximize div. Defaults to "" (no title). │ │ │ │ + * Property: defaultStyleName │ │ │ │ + * {String} Style name used if layer has no style param. Default is "". │ │ │ │ */ │ │ │ │ - maximizeTitle: "", │ │ │ │ + defaultStyleName: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: minimizeTitle │ │ │ │ - * {String} This property is used for showing a tooltip over the │ │ │ │ - * minimize div. Defaults to "" (no title). │ │ │ │ + * Property: defaultStyleTitle │ │ │ │ + * {String} Default style title. Default is "Default". │ │ │ │ */ │ │ │ │ - minimizeTitle: "", │ │ │ │ + defaultStyleTitle: "Default", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.OverviewMap │ │ │ │ - * Create a new overview map │ │ │ │ + * Constructor: OpenLayers.Format.WMC.v1 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.WMC> constructor instead. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Properties of this object will be set on the overview │ │ │ │ - * map object. Note, to set options on the map object contained in this │ │ │ │ - * control, set <mapOptions> as one of the options properties. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ - this.layers = []; │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Deconstruct the control │ │ │ │ + * Method: read │ │ │ │ + * Read capabilities data from a string, and return a list of layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named layers. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (!this.mapDiv) { // we've already been destroyed │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (this.handlers.click) { │ │ │ │ - this.handlers.click.destroy(); │ │ │ │ - } │ │ │ │ - if (this.handlers.drag) { │ │ │ │ - this.handlers.drag.destroy(); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.ovmap && this.ovmap.viewPortDiv.removeChild(this.extentRectangle); │ │ │ │ - this.extentRectangle = null; │ │ │ │ - │ │ │ │ - if (this.rectEvents) { │ │ │ │ - this.rectEvents.destroy(); │ │ │ │ - this.rectEvents = null; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.ovmap) { │ │ │ │ - this.ovmap.destroy(); │ │ │ │ - this.ovmap = null; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.element.removeChild(this.mapDiv); │ │ │ │ - this.mapDiv = null; │ │ │ │ - │ │ │ │ - this.div.removeChild(this.element); │ │ │ │ - this.element = null; │ │ │ │ - │ │ │ │ - if (this.maximizeDiv) { │ │ │ │ - this.div.removeChild(this.maximizeDiv); │ │ │ │ - this.maximizeDiv = null; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.minimizeDiv) { │ │ │ │ - this.div.removeChild(this.minimizeDiv); │ │ │ │ - this.minimizeDiv = null; │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ } │ │ │ │ - │ │ │ │ - this.map.events.un({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - moveend: this.update, │ │ │ │ - changebaselayer: this.baseLayerDraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + var root = data.documentElement; │ │ │ │ + this.rootPrefix = root.prefix; │ │ │ │ + var context = { │ │ │ │ + version: root.getAttribute("version") │ │ │ │ + }; │ │ │ │ + this.runChildNodes(context, root); │ │ │ │ + return context; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * Render the control in the browser. │ │ │ │ + * Method: runChildNodes │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.layers.length === 0) { │ │ │ │ - if (this.map.baseLayer) { │ │ │ │ - var layer = this.map.baseLayer.clone(); │ │ │ │ - this.layers = [layer]; │ │ │ │ - } else { │ │ │ │ - this.map.events.register("changebaselayer", this, this.baseLayerDraw); │ │ │ │ - return this.div; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // create overview map DOM elements │ │ │ │ - this.element = document.createElement('div'); │ │ │ │ - this.element.className = this.displayClass + 'Element'; │ │ │ │ - this.element.style.display = 'none'; │ │ │ │ - │ │ │ │ - this.mapDiv = document.createElement('div'); │ │ │ │ - this.mapDiv.style.width = this.size.w + 'px'; │ │ │ │ - this.mapDiv.style.height = this.size.h + 'px'; │ │ │ │ - this.mapDiv.style.position = 'relative'; │ │ │ │ - this.mapDiv.style.overflow = 'hidden'; │ │ │ │ - this.mapDiv.id = OpenLayers.Util.createUniqueID('overviewMap'); │ │ │ │ - │ │ │ │ - this.extentRectangle = document.createElement('div'); │ │ │ │ - this.extentRectangle.style.position = 'absolute'; │ │ │ │ - this.extentRectangle.style.zIndex = 1000; //HACK │ │ │ │ - this.extentRectangle.className = this.displayClass + 'ExtentRectangle'; │ │ │ │ - │ │ │ │ - this.element.appendChild(this.mapDiv); │ │ │ │ - │ │ │ │ - this.div.appendChild(this.element); │ │ │ │ - │ │ │ │ - // Optionally add min/max buttons if the control will go in the │ │ │ │ - // map viewport. │ │ │ │ - if (!this.outsideViewport) { │ │ │ │ - this.div.className += " " + this.displayClass + 'Container'; │ │ │ │ - // maximize button div │ │ │ │ - var img = OpenLayers.Util.getImageLocation('layer-switcher-maximize.png'); │ │ │ │ - this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - this.displayClass + 'MaximizeButton', │ │ │ │ - null, │ │ │ │ - null, │ │ │ │ - img, │ │ │ │ - 'absolute'); │ │ │ │ - this.maximizeDiv.style.display = 'none'; │ │ │ │ - this.maximizeDiv.className = this.displayClass + 'MaximizeButton olButton'; │ │ │ │ - if (this.maximizeTitle) { │ │ │ │ - this.maximizeDiv.title = this.maximizeTitle; │ │ │ │ - } │ │ │ │ - this.div.appendChild(this.maximizeDiv); │ │ │ │ - │ │ │ │ - // minimize button div │ │ │ │ - var img = OpenLayers.Util.getImageLocation('layer-switcher-minimize.png'); │ │ │ │ - this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - 'OpenLayers_Control_minimizeDiv', │ │ │ │ - null, │ │ │ │ - null, │ │ │ │ - img, │ │ │ │ - 'absolute'); │ │ │ │ - this.minimizeDiv.style.display = 'none'; │ │ │ │ - this.minimizeDiv.className = this.displayClass + 'MinimizeButton olButton'; │ │ │ │ - if (this.minimizeTitle) { │ │ │ │ - this.minimizeDiv.title = this.minimizeTitle; │ │ │ │ + runChildNodes: function(obj, node) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var childNode, processor, prefix, local; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + childNode = children[i]; │ │ │ │ + if (childNode.nodeType == 1) { │ │ │ │ + prefix = this.getNamespacePrefix(childNode.namespaceURI); │ │ │ │ + local = childNode.nodeName.split(":").pop(); │ │ │ │ + processor = this["read_" + prefix + "_" + local]; │ │ │ │ + if (processor) { │ │ │ │ + processor.apply(this, [obj, childNode]); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.div.appendChild(this.minimizeDiv); │ │ │ │ - this.minimizeControl(); │ │ │ │ - } else { │ │ │ │ - // show the overview map │ │ │ │ - this.element.style.display = ''; │ │ │ │ - } │ │ │ │ - if (this.map.getExtent()) { │ │ │ │ - this.update(); │ │ │ │ } │ │ │ │ - │ │ │ │ - this.map.events.on({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - moveend: this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - │ │ │ │ - if (this.maximized) { │ │ │ │ - this.maximizeControl(); │ │ │ │ - } │ │ │ │ - return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: baseLayerDraw │ │ │ │ - * Draw the base layer - called if unable to complete in the initial draw │ │ │ │ + * Method: read_wmc_General │ │ │ │ */ │ │ │ │ - baseLayerDraw: function() { │ │ │ │ - this.draw(); │ │ │ │ - this.map.events.unregister("changebaselayer", this, this.baseLayerDraw); │ │ │ │ + read_wmc_General: function(context, node) { │ │ │ │ + this.runChildNodes(context, node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: rectDrag │ │ │ │ - * Handle extent rectangle drag │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} The pixel location of the drag. │ │ │ │ + * Method: read_wmc_BoundingBox │ │ │ │ */ │ │ │ │ - rectDrag: function(px) { │ │ │ │ - var deltaX = this.handlers.drag.last.x - px.x; │ │ │ │ - var deltaY = this.handlers.drag.last.y - px.y; │ │ │ │ - if (deltaX != 0 || deltaY != 0) { │ │ │ │ - var rectTop = this.rectPxBounds.top; │ │ │ │ - var rectLeft = this.rectPxBounds.left; │ │ │ │ - var rectHeight = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ - var rectWidth = this.rectPxBounds.getWidth(); │ │ │ │ - // don't allow dragging off of parent element │ │ │ │ - var newTop = Math.max(0, (rectTop - deltaY)); │ │ │ │ - newTop = Math.min(newTop, │ │ │ │ - this.ovmap.size.h - this.hComp - rectHeight); │ │ │ │ - var newLeft = Math.max(0, (rectLeft - deltaX)); │ │ │ │ - newLeft = Math.min(newLeft, │ │ │ │ - this.ovmap.size.w - this.wComp - rectWidth); │ │ │ │ - this.setRectPxBounds(new OpenLayers.Bounds(newLeft, │ │ │ │ - newTop + rectHeight, │ │ │ │ - newLeft + rectWidth, │ │ │ │ - newTop)); │ │ │ │ - } │ │ │ │ + read_wmc_BoundingBox: function(context, node) { │ │ │ │ + context.projection = node.getAttribute("SRS"); │ │ │ │ + context.bounds = new OpenLayers.Bounds( │ │ │ │ + node.getAttribute("minx"), node.getAttribute("miny"), │ │ │ │ + node.getAttribute("maxx"), node.getAttribute("maxy") │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mapDivClick │ │ │ │ - * Handle browser events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} evt │ │ │ │ + * Method: read_wmc_LayerList │ │ │ │ */ │ │ │ │ - mapDivClick: function(evt) { │ │ │ │ - var pxCenter = this.rectPxBounds.getCenterPixel(); │ │ │ │ - var deltaX = evt.xy.x - pxCenter.x; │ │ │ │ - var deltaY = evt.xy.y - pxCenter.y; │ │ │ │ - var top = this.rectPxBounds.top; │ │ │ │ - var left = this.rectPxBounds.left; │ │ │ │ - var height = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ - var width = this.rectPxBounds.getWidth(); │ │ │ │ - var newTop = Math.max(0, (top + deltaY)); │ │ │ │ - newTop = Math.min(newTop, this.ovmap.size.h - height); │ │ │ │ - var newLeft = Math.max(0, (left + deltaX)); │ │ │ │ - newLeft = Math.min(newLeft, this.ovmap.size.w - width); │ │ │ │ - this.setRectPxBounds(new OpenLayers.Bounds(newLeft, │ │ │ │ - newTop + height, │ │ │ │ - newLeft + width, │ │ │ │ - newTop)); │ │ │ │ - this.updateMapToRect(); │ │ │ │ + read_wmc_LayerList: function(context, node) { │ │ │ │ + // layersContext is an array containing info for each layer │ │ │ │ + context.layersContext = []; │ │ │ │ + this.runChildNodes(context, node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onButtonClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: read_wmc_Layer │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - if (evt.buttonElement === this.minimizeDiv) { │ │ │ │ - this.minimizeControl(); │ │ │ │ - } else if (evt.buttonElement === this.maximizeDiv) { │ │ │ │ - this.maximizeControl(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + read_wmc_Layer: function(context, node) { │ │ │ │ + var layerContext = { │ │ │ │ + visibility: (node.getAttribute("hidden") != "1"), │ │ │ │ + queryable: (node.getAttribute("queryable") == "1"), │ │ │ │ + formats: [], │ │ │ │ + styles: [], │ │ │ │ + metadata: {} │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: maximizeControl │ │ │ │ - * Unhide the control. Called when the control is in the map viewport. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * e - {<OpenLayers.Event>} │ │ │ │ - */ │ │ │ │ - maximizeControl: function(e) { │ │ │ │ - this.element.style.display = ''; │ │ │ │ - this.showToggle(false); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ - } │ │ │ │ + this.runChildNodes(layerContext, node); │ │ │ │ + // set properties common to multiple objects on layer options/params │ │ │ │ + context.layersContext.push(layerContext); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: minimizeControl │ │ │ │ - * Hide all the contents of the control, shrink the size, │ │ │ │ - * add the maximize icon │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * e - {<OpenLayers.Event>} │ │ │ │ + * Method: read_wmc_Extension │ │ │ │ */ │ │ │ │ - minimizeControl: function(e) { │ │ │ │ - this.element.style.display = 'none'; │ │ │ │ - this.showToggle(true); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ - } │ │ │ │ + read_wmc_Extension: function(obj, node) { │ │ │ │ + this.runChildNodes(obj, node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: showToggle │ │ │ │ - * Hide/Show the toggle depending on whether the control is minimized │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * minimize - {Boolean} │ │ │ │ + * Method: read_ol_units │ │ │ │ */ │ │ │ │ - showToggle: function(minimize) { │ │ │ │ - if (this.maximizeDiv) { │ │ │ │ - this.maximizeDiv.style.display = minimize ? '' : 'none'; │ │ │ │ - } │ │ │ │ - if (this.minimizeDiv) { │ │ │ │ - this.minimizeDiv.style.display = minimize ? 'none' : ''; │ │ │ │ - } │ │ │ │ + read_ol_units: function(layerContext, node) { │ │ │ │ + layerContext.units = this.getChildValue(node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Update the overview map after layers move. │ │ │ │ + * Method: read_ol_maxExtent │ │ │ │ */ │ │ │ │ - update: function() { │ │ │ │ - if (this.ovmap == null) { │ │ │ │ - this.createMap(); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.autoPan || !this.isSuitableOverview()) { │ │ │ │ - this.updateOverview(); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // update extent rectangle │ │ │ │ - this.updateRectToMap(); │ │ │ │ + read_ol_maxExtent: function(obj, node) { │ │ │ │ + var bounds = new OpenLayers.Bounds( │ │ │ │ + node.getAttribute("minx"), node.getAttribute("miny"), │ │ │ │ + node.getAttribute("maxx"), node.getAttribute("maxy") │ │ │ │ + ); │ │ │ │ + obj.maxExtent = bounds; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: isSuitableOverview │ │ │ │ - * Determines if the overview map is suitable given the extent and │ │ │ │ - * resolution of the main map. │ │ │ │ + * Method: read_ol_transparent │ │ │ │ */ │ │ │ │ - isSuitableOverview: function() { │ │ │ │ - var mapExtent = this.map.getExtent(); │ │ │ │ - var maxExtent = this.map.getMaxExtent(); │ │ │ │ - var testExtent = new OpenLayers.Bounds( │ │ │ │ - Math.max(mapExtent.left, maxExtent.left), │ │ │ │ - Math.max(mapExtent.bottom, maxExtent.bottom), │ │ │ │ - Math.min(mapExtent.right, maxExtent.right), │ │ │ │ - Math.min(mapExtent.top, maxExtent.top)); │ │ │ │ - │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - testExtent = testExtent.transform( │ │ │ │ - this.map.getProjectionObject(), │ │ │ │ - this.ovmap.getProjectionObject()); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var resRatio = this.ovmap.getResolution() / this.map.getResolution(); │ │ │ │ - return ((resRatio > this.minRatio) && │ │ │ │ - (resRatio <= this.maxRatio) && │ │ │ │ - (this.ovmap.getExtent().containsBounds(testExtent))); │ │ │ │ + read_ol_transparent: function(layerContext, node) { │ │ │ │ + layerContext.transparent = this.getChildValue(node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method updateOverview │ │ │ │ - * Called by <update> if <isSuitableOverview> returns true │ │ │ │ + * Method: read_ol_numZoomLevels │ │ │ │ */ │ │ │ │ - updateOverview: function() { │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - var targetRes = this.ovmap.getResolution(); │ │ │ │ - var resRatio = targetRes / mapRes; │ │ │ │ - if (resRatio > this.maxRatio) { │ │ │ │ - // zoom in overview map │ │ │ │ - targetRes = this.minRatio * mapRes; │ │ │ │ - } else if (resRatio <= this.minRatio) { │ │ │ │ - // zoom out overview map │ │ │ │ - targetRes = this.maxRatio * mapRes; │ │ │ │ - } │ │ │ │ - var center; │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - center = this.map.center.clone(); │ │ │ │ - center.transform(this.map.getProjectionObject(), │ │ │ │ - this.ovmap.getProjectionObject()); │ │ │ │ - } else { │ │ │ │ - center = this.map.center; │ │ │ │ - } │ │ │ │ - this.ovmap.setCenter(center, this.ovmap.getZoomForResolution( │ │ │ │ - targetRes * this.resolutionFactor)); │ │ │ │ - this.updateRectToMap(); │ │ │ │ + read_ol_numZoomLevels: function(layerContext, node) { │ │ │ │ + layerContext.numZoomLevels = parseInt(this.getChildValue(node)); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createMap │ │ │ │ - * Construct the map that this control contains │ │ │ │ + * Method: read_ol_opacity │ │ │ │ */ │ │ │ │ - createMap: function() { │ │ │ │ - // create the overview map │ │ │ │ - var options = OpenLayers.Util.extend({ │ │ │ │ - controls: [], │ │ │ │ - maxResolution: 'auto', │ │ │ │ - fallThrough: false │ │ │ │ - }, this.mapOptions); │ │ │ │ - this.ovmap = new OpenLayers.Map(this.mapDiv, options); │ │ │ │ - this.ovmap.viewPortDiv.appendChild(this.extentRectangle); │ │ │ │ - │ │ │ │ - // prevent ovmap from being destroyed when the page unloads, because │ │ │ │ - // the OverviewMap control has to do this (and does it). │ │ │ │ - OpenLayers.Event.stopObserving(window, 'unload', this.ovmap.unloadDestroy); │ │ │ │ - │ │ │ │ - this.ovmap.addLayers(this.layers); │ │ │ │ - this.ovmap.zoomToMaxExtent(); │ │ │ │ - // check extent rectangle border width │ │ │ │ - this.wComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ - 'border-left-width')) + │ │ │ │ - parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ - 'border-right-width')); │ │ │ │ - this.wComp = (this.wComp) ? this.wComp : 2; │ │ │ │ - this.hComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ - 'border-top-width')) + │ │ │ │ - parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ - 'border-bottom-width')); │ │ │ │ - this.hComp = (this.hComp) ? this.hComp : 2; │ │ │ │ - │ │ │ │ - this.handlers.drag = new OpenLayers.Handler.Drag( │ │ │ │ - this, { │ │ │ │ - move: this.rectDrag, │ │ │ │ - done: this.updateMapToRect │ │ │ │ - }, { │ │ │ │ - map: this.ovmap │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ - this, { │ │ │ │ - "click": this.mapDivClick │ │ │ │ - }, { │ │ │ │ - "single": true, │ │ │ │ - "double": false, │ │ │ │ - "stopSingle": true, │ │ │ │ - "stopDouble": true, │ │ │ │ - "pixelTolerance": 1, │ │ │ │ - map: this.ovmap │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - │ │ │ │ - this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, │ │ │ │ - null, true); │ │ │ │ - this.rectEvents.register("mouseover", this, function(e) { │ │ │ │ - if (!this.handlers.drag.active && !this.map.dragging) { │ │ │ │ - this.handlers.drag.activate(); │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.rectEvents.register("mouseout", this, function(e) { │ │ │ │ - if (!this.handlers.drag.dragging) { │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - var sourceUnits = this.map.getProjectionObject().getUnits() || │ │ │ │ - this.map.units || this.map.baseLayer.units; │ │ │ │ - var targetUnits = this.ovmap.getProjectionObject().getUnits() || │ │ │ │ - this.ovmap.units || this.ovmap.baseLayer.units; │ │ │ │ - this.resolutionFactor = sourceUnits && targetUnits ? │ │ │ │ - OpenLayers.INCHES_PER_UNIT[sourceUnits] / │ │ │ │ - OpenLayers.INCHES_PER_UNIT[targetUnits] : 1; │ │ │ │ - } │ │ │ │ + read_ol_opacity: function(layerContext, node) { │ │ │ │ + layerContext.opacity = parseFloat(this.getChildValue(node)); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateRectToMap │ │ │ │ - * Updates the extent rectangle position and size to match the map extent │ │ │ │ + * Method: read_ol_singleTile │ │ │ │ */ │ │ │ │ - updateRectToMap: function() { │ │ │ │ - // If the projections differ we need to reproject │ │ │ │ - var bounds; │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - bounds = this.map.getExtent().transform( │ │ │ │ - this.map.getProjectionObject(), │ │ │ │ - this.ovmap.getProjectionObject()); │ │ │ │ - } else { │ │ │ │ - bounds = this.map.getExtent(); │ │ │ │ - } │ │ │ │ - var pxBounds = this.getRectBoundsFromMapBounds(bounds); │ │ │ │ - if (pxBounds) { │ │ │ │ - this.setRectPxBounds(pxBounds); │ │ │ │ - } │ │ │ │ + read_ol_singleTile: function(layerContext, node) { │ │ │ │ + layerContext.singleTile = (this.getChildValue(node) == "true"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateMapToRect │ │ │ │ - * Updates the map extent to match the extent rectangle position and size │ │ │ │ + * Method: read_ol_tileSize │ │ │ │ */ │ │ │ │ - updateMapToRect: function() { │ │ │ │ - var lonLatBounds = this.getMapBoundsFromRectBounds(this.rectPxBounds); │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - lonLatBounds = lonLatBounds.transform( │ │ │ │ - this.ovmap.getProjectionObject(), │ │ │ │ - this.map.getProjectionObject()); │ │ │ │ - } │ │ │ │ - this.map.panTo(lonLatBounds.getCenterLonLat()); │ │ │ │ + read_ol_tileSize: function(layerContext, node) { │ │ │ │ + var obj = { │ │ │ │ + "width": node.getAttribute("width"), │ │ │ │ + "height": node.getAttribute("height") │ │ │ │ + }; │ │ │ │ + layerContext.tileSize = obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setRectPxBounds │ │ │ │ - * Set extent rectangle pixel bounds. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pxBounds - {<OpenLayers.Bounds>} │ │ │ │ + * Method: read_ol_isBaseLayer │ │ │ │ */ │ │ │ │ - setRectPxBounds: function(pxBounds) { │ │ │ │ - var top = Math.max(pxBounds.top, 0); │ │ │ │ - var left = Math.max(pxBounds.left, 0); │ │ │ │ - var bottom = Math.min(pxBounds.top + Math.abs(pxBounds.getHeight()), │ │ │ │ - this.ovmap.size.h - this.hComp); │ │ │ │ - var right = Math.min(pxBounds.left + pxBounds.getWidth(), │ │ │ │ - this.ovmap.size.w - this.wComp); │ │ │ │ - var width = Math.max(right - left, 0); │ │ │ │ - var height = Math.max(bottom - top, 0); │ │ │ │ - if (width < this.minRectSize || height < this.minRectSize) { │ │ │ │ - this.extentRectangle.className = this.displayClass + │ │ │ │ - this.minRectDisplayClass; │ │ │ │ - var rLeft = left + (width / 2) - (this.minRectSize / 2); │ │ │ │ - var rTop = top + (height / 2) - (this.minRectSize / 2); │ │ │ │ - this.extentRectangle.style.top = Math.round(rTop) + 'px'; │ │ │ │ - this.extentRectangle.style.left = Math.round(rLeft) + 'px'; │ │ │ │ - this.extentRectangle.style.height = this.minRectSize + 'px'; │ │ │ │ - this.extentRectangle.style.width = this.minRectSize + 'px'; │ │ │ │ - } else { │ │ │ │ - this.extentRectangle.className = this.displayClass + │ │ │ │ - 'ExtentRectangle'; │ │ │ │ - this.extentRectangle.style.top = Math.round(top) + 'px'; │ │ │ │ - this.extentRectangle.style.left = Math.round(left) + 'px'; │ │ │ │ - this.extentRectangle.style.height = Math.round(height) + 'px'; │ │ │ │ - this.extentRectangle.style.width = Math.round(width) + 'px'; │ │ │ │ - } │ │ │ │ - this.rectPxBounds = new OpenLayers.Bounds( │ │ │ │ - Math.round(left), Math.round(bottom), │ │ │ │ - Math.round(right), Math.round(top) │ │ │ │ - ); │ │ │ │ + read_ol_isBaseLayer: function(layerContext, node) { │ │ │ │ + layerContext.isBaseLayer = (this.getChildValue(node) == "true"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getRectBoundsFromMapBounds │ │ │ │ - * Get the rect bounds from the map bounds. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * lonLatBounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>}A bounds which is the passed-in map lon/lat extent │ │ │ │ - * translated into pixel bounds for the overview map │ │ │ │ + * Method: read_ol_displayInLayerSwitcher │ │ │ │ */ │ │ │ │ - getRectBoundsFromMapBounds: function(lonLatBounds) { │ │ │ │ - var leftBottomPx = this.getOverviewPxFromLonLat({ │ │ │ │ - lon: lonLatBounds.left, │ │ │ │ - lat: lonLatBounds.bottom │ │ │ │ - }); │ │ │ │ - var rightTopPx = this.getOverviewPxFromLonLat({ │ │ │ │ - lon: lonLatBounds.right, │ │ │ │ - lat: lonLatBounds.top │ │ │ │ - }); │ │ │ │ - var bounds = null; │ │ │ │ - if (leftBottomPx && rightTopPx) { │ │ │ │ - bounds = new OpenLayers.Bounds(leftBottomPx.x, leftBottomPx.y, │ │ │ │ - rightTopPx.x, rightTopPx.y); │ │ │ │ - } │ │ │ │ - return bounds; │ │ │ │ + read_ol_displayInLayerSwitcher: function(layerContext, node) { │ │ │ │ + layerContext.displayInLayerSwitcher = (this.getChildValue(node) == "true"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getMapBoundsFromRectBounds │ │ │ │ - * Get the map bounds from the rect bounds. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * pxBounds - {<OpenLayers.Bounds>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} Bounds which is the passed-in overview rect bounds │ │ │ │ - * translated into lon/lat bounds for the overview map │ │ │ │ + * Method: read_wmc_Server │ │ │ │ */ │ │ │ │ - getMapBoundsFromRectBounds: function(pxBounds) { │ │ │ │ - var leftBottomLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ - x: pxBounds.left, │ │ │ │ - y: pxBounds.bottom │ │ │ │ - }); │ │ │ │ - var rightTopLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ - x: pxBounds.right, │ │ │ │ - y: pxBounds.top │ │ │ │ - }); │ │ │ │ - return new OpenLayers.Bounds(leftBottomLonLat.lon, leftBottomLonLat.lat, │ │ │ │ - rightTopLonLat.lon, rightTopLonLat.lat); │ │ │ │ + read_wmc_Server: function(layerContext, node) { │ │ │ │ + layerContext.version = node.getAttribute("version"); │ │ │ │ + layerContext.url = this.getOnlineResource_href(node); │ │ │ │ + layerContext.metadata.servertitle = node.getAttribute("title"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getLonLatFromOverviewPx │ │ │ │ - * Get a map location from a pixel location │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * overviewMapPx - {<OpenLayers.Pixel>|Object} OpenLayers.Pixel or │ │ │ │ - * an object with a │ │ │ │ - * 'x' and 'y' properties. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Location which is the passed-in overview map │ │ │ │ - * OpenLayers.Pixel, translated into lon/lat by the overview │ │ │ │ - * map. An object with a 'lon' and 'lat' properties. │ │ │ │ + * Method: read_wmc_FormatList │ │ │ │ */ │ │ │ │ - getLonLatFromOverviewPx: function(overviewMapPx) { │ │ │ │ - var size = this.ovmap.size; │ │ │ │ - var res = this.ovmap.getResolution(); │ │ │ │ - var center = this.ovmap.getExtent().getCenterLonLat(); │ │ │ │ - │ │ │ │ - var deltaX = overviewMapPx.x - (size.w / 2); │ │ │ │ - var deltaY = overviewMapPx.y - (size.h / 2); │ │ │ │ - │ │ │ │ - return { │ │ │ │ - lon: center.lon + deltaX * res, │ │ │ │ - lat: center.lat - deltaY * res │ │ │ │ - }; │ │ │ │ + read_wmc_FormatList: function(layerContext, node) { │ │ │ │ + this.runChildNodes(layerContext, node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getOverviewPxFromLonLat │ │ │ │ - * Get a pixel location from a map location │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * lonlat - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an │ │ │ │ - * object with a 'lon' and 'lat' properties. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Location which is the passed-in OpenLayers.LonLat, │ │ │ │ - * translated into overview map pixels │ │ │ │ + * Method: read_wmc_Format │ │ │ │ */ │ │ │ │ - getOverviewPxFromLonLat: function(lonlat) { │ │ │ │ - var res = this.ovmap.getResolution(); │ │ │ │ - var extent = this.ovmap.getExtent(); │ │ │ │ - if (extent) { │ │ │ │ - return { │ │ │ │ - x: Math.round(1 / res * (lonlat.lon - extent.left)), │ │ │ │ - y: Math.round(1 / res * (extent.top - lonlat.lat)) │ │ │ │ - }; │ │ │ │ + read_wmc_Format: function(layerContext, node) { │ │ │ │ + var format = { │ │ │ │ + value: this.getChildValue(node) │ │ │ │ + }; │ │ │ │ + if (node.getAttribute("current") == "1") { │ │ │ │ + format.current = true; │ │ │ │ } │ │ │ │ + layerContext.formats.push(format); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: 'OpenLayers.Control.OverviewMap' │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Scale.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Lang.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Scale │ │ │ │ - * The Scale control displays the current map scale as a ratio (e.g. Scale = │ │ │ │ - * 1:1M). By default it is displayed in the lower right corner of the map. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Scale = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: element │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - element: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: geodesic │ │ │ │ - * {Boolean} Use geodesic measurement. Default is false. The recommended │ │ │ │ - * setting for maps in EPSG:4326 is false, and true EPSG:900913. If set to │ │ │ │ - * true, the scale will be calculated based on the horizontal size of the │ │ │ │ - * pixel in the center of the map viewport. │ │ │ │ - */ │ │ │ │ - geodesic: false, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Scale │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * element - {DOMElement} │ │ │ │ - * options - {Object} │ │ │ │ + * Method: read_wmc_StyleList │ │ │ │ */ │ │ │ │ - initialize: function(element, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.element = OpenLayers.Util.getElement(element); │ │ │ │ + read_wmc_StyleList: function(layerContext, node) { │ │ │ │ + this.runChildNodes(layerContext, node); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: read_wmc_Style │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.element) { │ │ │ │ - this.element = document.createElement("div"); │ │ │ │ - this.div.appendChild(this.element); │ │ │ │ + read_wmc_Style: function(layerContext, node) { │ │ │ │ + var style = {}; │ │ │ │ + this.runChildNodes(style, node); │ │ │ │ + if (node.getAttribute("current") == "1") { │ │ │ │ + style.current = true; │ │ │ │ } │ │ │ │ - this.map.events.register('moveend', this, this.updateScale); │ │ │ │ - this.updateScale(); │ │ │ │ - return this.div; │ │ │ │ + layerContext.styles.push(style); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateScale │ │ │ │ + * Method: read_wmc_SLD │ │ │ │ */ │ │ │ │ - updateScale: function() { │ │ │ │ - var scale; │ │ │ │ - if (this.geodesic === true) { │ │ │ │ - var units = this.map.getUnits(); │ │ │ │ - if (!units) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ - scale = (this.map.getGeodesicPixelSize().w || 0.000001) * │ │ │ │ - inches["km"] * OpenLayers.DOTS_PER_INCH; │ │ │ │ - } else { │ │ │ │ - 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 = 1 : ${scaleDenom}", { │ │ │ │ - 'scaleDenom': scale │ │ │ │ - }); │ │ │ │ + read_wmc_SLD: function(style, node) { │ │ │ │ + this.runChildNodes(style, node); │ │ │ │ + // style either comes back with an href or a body property │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Scale" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Graticule.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Lang.js │ │ │ │ - * @requires OpenLayers/Rule.js │ │ │ │ - * @requires OpenLayers/StyleMap.js │ │ │ │ - * @requires OpenLayers/Layer/Vector.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Graticule │ │ │ │ - * The Graticule displays a grid of latitude/longitude lines reprojected on │ │ │ │ - * the map. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - * │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Graticule = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * Method: read_sld_StyledLayerDescriptor │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + read_sld_StyledLayerDescriptor: function(sld, node) { │ │ │ │ + var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + sld.body = xml; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: intervals │ │ │ │ - * {Array(Float)} A list of possible graticule widths in degrees. │ │ │ │ + * Method: read_sld_FeatureTypeStyle │ │ │ │ */ │ │ │ │ - intervals: [45, 30, 20, 10, 5, 2, 1, │ │ │ │ - 0.5, 0.2, 0.1, 0.05, 0.01, │ │ │ │ - 0.005, 0.002, 0.001 │ │ │ │ - ], │ │ │ │ + read_sld_FeatureTypeStyle: function(sld, node) { │ │ │ │ + var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + sld.body = xml; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: displayInLayerSwitcher │ │ │ │ - * {Boolean} Allows the Graticule control to be switched on and off by │ │ │ │ - * LayerSwitcher control. Defaults is true. │ │ │ │ + * Method: read_wmc_OnlineResource │ │ │ │ */ │ │ │ │ - displayInLayerSwitcher: true, │ │ │ │ + read_wmc_OnlineResource: function(obj, node) { │ │ │ │ + obj.href = this.getAttributeNS( │ │ │ │ + node, this.namespaces.xlink, "href" │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: visible │ │ │ │ - * {Boolean} should the graticule be initially visible (default=true) │ │ │ │ + * Method: read_wmc_Name │ │ │ │ */ │ │ │ │ - visible: true, │ │ │ │ + read_wmc_Name: function(obj, node) { │ │ │ │ + var name = this.getChildValue(node); │ │ │ │ + if (name) { │ │ │ │ + obj.name = name; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: numPoints │ │ │ │ - * {Integer} The number of points to use in each graticule line. Higher │ │ │ │ - * numbers result in a smoother curve for projected maps │ │ │ │ + * Method: read_wmc_Title │ │ │ │ */ │ │ │ │ - numPoints: 50, │ │ │ │ + read_wmc_Title: function(obj, node) { │ │ │ │ + var title = this.getChildValue(node); │ │ │ │ + if (title) { │ │ │ │ + obj.title = title; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: targetSize │ │ │ │ - * {Integer} The maximum size of the grid in pixels on the map │ │ │ │ + * Method: read_wmc_MetadataURL │ │ │ │ */ │ │ │ │ - targetSize: 200, │ │ │ │ + read_wmc_MetadataURL: function(layerContext, node) { │ │ │ │ + layerContext.metadataURL = this.getOnlineResource_href(node); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layerName │ │ │ │ - * {String} The name to be displayed in the layer switcher, default is set │ │ │ │ - * by {<OpenLayers.Lang>}. │ │ │ │ + * Method: read_wmc_KeywordList │ │ │ │ */ │ │ │ │ - layerName: null, │ │ │ │ + read_wmc_KeywordList: function(context, node) { │ │ │ │ + context.keywords = []; │ │ │ │ + this.runChildNodes(context.keywords, node); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: labelled │ │ │ │ - * {Boolean} Should the graticule lines be labelled?. default=true │ │ │ │ + * Method: read_wmc_Keyword │ │ │ │ */ │ │ │ │ - labelled: true, │ │ │ │ + read_wmc_Keyword: function(keywords, node) { │ │ │ │ + keywords.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: labelFormat │ │ │ │ - * {String} the format of the labels, default = 'dm'. See │ │ │ │ - * <OpenLayers.Util.getFormattedLonLat> for other options. │ │ │ │ + * Method: read_wmc_Abstract │ │ │ │ */ │ │ │ │ - labelFormat: 'dm', │ │ │ │ + read_wmc_Abstract: function(obj, node) { │ │ │ │ + var abst = this.getChildValue(node); │ │ │ │ + if (abst) { │ │ │ │ + obj["abstract"] = abst; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: lineSymbolizer │ │ │ │ - * {symbolizer} the symbolizer used to render lines │ │ │ │ + * Method: read_wmc_LogoURL │ │ │ │ */ │ │ │ │ - lineSymbolizer: { │ │ │ │ - strokeColor: "#333", │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeOpacity: 0.5 │ │ │ │ + read_wmc_LogoURL: function(context, node) { │ │ │ │ + context.logo = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height"), │ │ │ │ + format: node.getAttribute("format"), │ │ │ │ + href: this.getOnlineResource_href(node) │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: labelSymbolizer │ │ │ │ - * {symbolizer} the symbolizer used to render labels │ │ │ │ + * Method: read_wmc_DescriptionURL │ │ │ │ */ │ │ │ │ - labelSymbolizer: {}, │ │ │ │ + read_wmc_DescriptionURL: function(context, node) { │ │ │ │ + context.descriptionURL = this.getOnlineResource_href(node); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: gratLayer │ │ │ │ - * {<OpenLayers.Layer.Vector>} vector layer used to draw the graticule on │ │ │ │ + * Method: read_wmc_ContactInformation │ │ │ │ */ │ │ │ │ - gratLayer: null, │ │ │ │ + read_wmc_ContactInformation: function(obj, node) { │ │ │ │ + var contact = {}; │ │ │ │ + this.runChildNodes(contact, node); │ │ │ │ + obj.contactInformation = contact; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Graticule │ │ │ │ - * Create a new graticule control to display a grid of latitude longitude │ │ │ │ - * lines. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + * Method: read_wmc_ContactPersonPrimary │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.layerName = options.layerName || OpenLayers.i18n("Graticule"); │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - this.labelSymbolizer.stroke = false; │ │ │ │ - this.labelSymbolizer.fill = false; │ │ │ │ - this.labelSymbolizer.label = "${label}"; │ │ │ │ - this.labelSymbolizer.labelAlign = "${labelAlign}"; │ │ │ │ - this.labelSymbolizer.labelXOffset = "${xOffset}"; │ │ │ │ - this.labelSymbolizer.labelYOffset = "${yOffset}"; │ │ │ │ + read_wmc_ContactPersonPrimary: function(contact, node) { │ │ │ │ + var personPrimary = {}; │ │ │ │ + this.runChildNodes(personPrimary, node); │ │ │ │ + contact.personPrimary = personPrimary; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Method: read_wmc_ContactPerson │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.gratLayer) { │ │ │ │ - this.gratLayer.destroy(); │ │ │ │ - this.gratLayer = null; │ │ │ │ + read_wmc_ContactPerson: function(primaryPerson, node) { │ │ │ │ + var person = this.getChildValue(node); │ │ │ │ + if (person) { │ │ │ │ + primaryPerson.person = person; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * initializes the graticule layer and does the initial update │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: read_wmc_ContactOrganization │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.gratLayer) { │ │ │ │ - var gratStyle = new OpenLayers.Style({}, { │ │ │ │ - rules: [new OpenLayers.Rule({ │ │ │ │ - 'symbolizer': { │ │ │ │ - "Point": this.labelSymbolizer, │ │ │ │ - "Line": this.lineSymbolizer │ │ │ │ - } │ │ │ │ - })] │ │ │ │ - }); │ │ │ │ - this.gratLayer = new OpenLayers.Layer.Vector(this.layerName, { │ │ │ │ - styleMap: new OpenLayers.StyleMap({ │ │ │ │ - 'default': gratStyle │ │ │ │ - }), │ │ │ │ - visibility: this.visible, │ │ │ │ - displayInLayerSwitcher: this.displayInLayerSwitcher │ │ │ │ - }); │ │ │ │ + read_wmc_ContactOrganization: function(primaryPerson, node) { │ │ │ │ + var organization = this.getChildValue(node); │ │ │ │ + if (organization) { │ │ │ │ + primaryPerson.organization = organization; │ │ │ │ } │ │ │ │ - return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ + * Method: read_wmc_ContactPosition │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.map.addLayer(this.gratLayer); │ │ │ │ - this.map.events.register('moveend', this, this.update); │ │ │ │ - this.update(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + read_wmc_ContactPosition: function(contact, node) { │ │ │ │ + var position = this.getChildValue(node); │ │ │ │ + if (position) { │ │ │ │ + contact.position = position; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ + * Method: read_wmc_ContactAddress │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.map.events.unregister('moveend', this, this.update); │ │ │ │ - this.map.removeLayer(this.gratLayer); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + read_wmc_ContactAddress: function(contact, node) { │ │ │ │ + var contactAddress = {}; │ │ │ │ + this.runChildNodes(contactAddress, node); │ │ │ │ + contact.contactAddress = contactAddress; │ │ │ │ }, │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * │ │ │ │ - * calculates the grid to be displayed and actually draws it │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: read_wmc_AddressType │ │ │ │ */ │ │ │ │ - update: function() { │ │ │ │ - //wait for the map to be initialized before proceeding │ │ │ │ - var mapBounds = this.map.getExtent(); │ │ │ │ - if (!mapBounds) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - //clear out the old grid │ │ │ │ - this.gratLayer.destroyFeatures(); │ │ │ │ - │ │ │ │ - //get the projection objects required │ │ │ │ - var llProj = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - var mapProj = this.map.getProjectionObject(); │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - │ │ │ │ - //if the map is in lon/lat, then the lines are straight and only one │ │ │ │ - //point is required │ │ │ │ - if (mapProj.proj && mapProj.proj.projName == "longlat") { │ │ │ │ - this.numPoints = 1; │ │ │ │ - } │ │ │ │ - │ │ │ │ - //get the map center in EPSG:4326 │ │ │ │ - var mapCenter = this.map.getCenter(); //lon and lat here are really map x and y │ │ │ │ - var mapCenterLL = new OpenLayers.Pixel(mapCenter.lon, mapCenter.lat); │ │ │ │ - OpenLayers.Projection.transform(mapCenterLL, mapProj, llProj); │ │ │ │ - │ │ │ │ - /* This block of code determines the lon/lat interval to use for the │ │ │ │ - * grid by calculating the diagonal size of one grid cell at the map │ │ │ │ - * center. Iterates through the intervals array until the diagonal │ │ │ │ - * length is less than the targetSize option. │ │ │ │ - */ │ │ │ │ - //find lat/lon interval that results in a grid of less than the target size │ │ │ │ - var testSq = this.targetSize * mapRes; │ │ │ │ - testSq *= testSq; //compare squares rather than doing a square root to save time │ │ │ │ - var llInterval; │ │ │ │ - for (var i = 0; i < this.intervals.length; ++i) { │ │ │ │ - llInterval = this.intervals[i]; //could do this for both x and y?? │ │ │ │ - var delta = llInterval / 2; │ │ │ │ - var p1 = mapCenterLL.offset({ │ │ │ │ - x: -delta, │ │ │ │ - y: -delta │ │ │ │ - }); //test coords in EPSG:4326 space │ │ │ │ - var p2 = mapCenterLL.offset({ │ │ │ │ - x: delta, │ │ │ │ - y: delta │ │ │ │ - }); │ │ │ │ - OpenLayers.Projection.transform(p1, llProj, mapProj); // convert them back to map projection │ │ │ │ - OpenLayers.Projection.transform(p2, llProj, mapProj); │ │ │ │ - var distSq = (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y); │ │ │ │ - if (distSq <= testSq) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - //alert(llInterval); │ │ │ │ - │ │ │ │ - //round the LL center to an even number based on the interval │ │ │ │ - mapCenterLL.x = Math.floor(mapCenterLL.x / llInterval) * llInterval; │ │ │ │ - mapCenterLL.y = Math.floor(mapCenterLL.y / llInterval) * llInterval; │ │ │ │ - //TODO adjust for minutses/seconds? │ │ │ │ - │ │ │ │ - /* The following 2 blocks calculate the nodes of the grid along a │ │ │ │ - * line of constant longitude (then latitiude) running through the │ │ │ │ - * center of the map until it reaches the map edge. The calculation │ │ │ │ - * goes from the center in both directions to the edge. │ │ │ │ - */ │ │ │ │ - //get the central longitude line, increment the latitude │ │ │ │ - var iter = 0; │ │ │ │ - var centerLonPoints = [mapCenterLL.clone()]; │ │ │ │ - var newPoint = mapCenterLL.clone(); │ │ │ │ - var mapXY; │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: 0, │ │ │ │ - y: llInterval │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLonPoints.unshift(newPoint); │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ - newPoint = mapCenterLL.clone(); │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: 0, │ │ │ │ - y: -llInterval │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLonPoints.push(newPoint); │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ - │ │ │ │ - //get the central latitude line, increment the longitude │ │ │ │ - iter = 0; │ │ │ │ - var centerLatPoints = [mapCenterLL.clone()]; │ │ │ │ - newPoint = mapCenterLL.clone(); │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: -llInterval, │ │ │ │ - y: 0 │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLatPoints.unshift(newPoint); │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ - newPoint = mapCenterLL.clone(); │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: llInterval, │ │ │ │ - y: 0 │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLatPoints.push(newPoint); │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ - │ │ │ │ - //now generate a line for each node in the central lat and lon lines │ │ │ │ - //first loop over constant longitude │ │ │ │ - var lines = []; │ │ │ │ - for (var i = 0; i < centerLatPoints.length; ++i) { │ │ │ │ - var lon = centerLatPoints[i].x; │ │ │ │ - var pointList = []; │ │ │ │ - var labelPoint = null; │ │ │ │ - var latEnd = Math.min(centerLonPoints[0].y, 90); │ │ │ │ - var latStart = Math.max(centerLonPoints[centerLonPoints.length - 1].y, -90); │ │ │ │ - var latDelta = (latEnd - latStart) / this.numPoints; │ │ │ │ - var lat = latStart; │ │ │ │ - for (var j = 0; j <= this.numPoints; ++j) { │ │ │ │ - var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ - gridPoint.transform(llProj, mapProj); │ │ │ │ - pointList.push(gridPoint); │ │ │ │ - lat += latDelta; │ │ │ │ - if (gridPoint.y >= mapBounds.bottom && !labelPoint) { │ │ │ │ - labelPoint = gridPoint; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.labelled) { │ │ │ │ - //keep track of when this grid line crosses the map bounds to set │ │ │ │ - //the label position │ │ │ │ - //labels along the bottom, add 10 pixel offset up into the map │ │ │ │ - //TODO add option for labels on top │ │ │ │ - var labelPos = new OpenLayers.Geometry.Point(labelPoint.x, mapBounds.bottom); │ │ │ │ - var labelAttrs = { │ │ │ │ - value: lon, │ │ │ │ - label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lon, "lon", this.labelFormat) : "", │ │ │ │ - labelAlign: "cb", │ │ │ │ - xOffset: 0, │ │ │ │ - yOffset: 2 │ │ │ │ - }; │ │ │ │ - this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)); │ │ │ │ - } │ │ │ │ - var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ - lines.push(new OpenLayers.Feature.Vector(geom)); │ │ │ │ - } │ │ │ │ - │ │ │ │ - //now draw the lines of constant latitude │ │ │ │ - for (var j = 0; j < centerLonPoints.length; ++j) { │ │ │ │ - lat = centerLonPoints[j].y; │ │ │ │ - if (lat < -90 || lat > 90) { //latitudes only valid between -90 and 90 │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - var pointList = []; │ │ │ │ - var lonStart = centerLatPoints[0].x; │ │ │ │ - var lonEnd = centerLatPoints[centerLatPoints.length - 1].x; │ │ │ │ - var lonDelta = (lonEnd - lonStart) / this.numPoints; │ │ │ │ - var lon = lonStart; │ │ │ │ - var labelPoint = null; │ │ │ │ - for (var i = 0; i <= this.numPoints; ++i) { │ │ │ │ - var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ - gridPoint.transform(llProj, mapProj); │ │ │ │ - pointList.push(gridPoint); │ │ │ │ - lon += lonDelta; │ │ │ │ - if (gridPoint.x < mapBounds.right) { │ │ │ │ - labelPoint = gridPoint; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.labelled) { │ │ │ │ - //keep track of when this grid line crosses the map bounds to set │ │ │ │ - //the label position │ │ │ │ - //labels along the right, 30 pixel offset left into the map │ │ │ │ - //TODO add option for labels on left │ │ │ │ - var labelPos = new OpenLayers.Geometry.Point(mapBounds.right, labelPoint.y); │ │ │ │ - var labelAttrs = { │ │ │ │ - value: lat, │ │ │ │ - label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lat, "lat", this.labelFormat) : "", │ │ │ │ - labelAlign: "rb", │ │ │ │ - xOffset: -2, │ │ │ │ - yOffset: 2 │ │ │ │ - }; │ │ │ │ - this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)); │ │ │ │ - } │ │ │ │ - var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ - lines.push(new OpenLayers.Feature.Vector(geom)); │ │ │ │ + read_wmc_AddressType: function(contactAddress, node) { │ │ │ │ + var type = this.getChildValue(node); │ │ │ │ + if (type) { │ │ │ │ + contactAddress.type = type; │ │ │ │ } │ │ │ │ - this.gratLayer.addFeatures(lines); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Graticule" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/ArgParser.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.ArgParser │ │ │ │ - * The ArgParser control adds location bar query string parsing functionality │ │ │ │ - * to an OpenLayers Map. │ │ │ │ - * When added to a Map control, on a page load/refresh, the Map will │ │ │ │ - * automatically take the href string and parse it for lon, lat, zoom, and │ │ │ │ - * layers information. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ArgParser = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Property: center │ │ │ │ - * {<OpenLayers.LonLat>} │ │ │ │ + * Method: read_wmc_Address │ │ │ │ */ │ │ │ │ - center: null, │ │ │ │ + read_wmc_Address: function(contactAddress, node) { │ │ │ │ + var address = this.getChildValue(node); │ │ │ │ + if (address) { │ │ │ │ + contactAddress.address = address; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: zoom │ │ │ │ - * {int} │ │ │ │ + * Method: read_wmc_City │ │ │ │ */ │ │ │ │ - zoom: null, │ │ │ │ + read_wmc_City: function(contactAddress, node) { │ │ │ │ + var city = this.getChildValue(node); │ │ │ │ + if (city) { │ │ │ │ + contactAddress.city = city; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layers │ │ │ │ - * {String} Each character represents the state of the corresponding layer │ │ │ │ - * on the map. │ │ │ │ - */ │ │ │ │ - layers: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: displayProjection │ │ │ │ - * {<OpenLayers.Projection>} 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. │ │ │ │ + * Method: read_wmc_StateOrProvince │ │ │ │ */ │ │ │ │ - displayProjection: null, │ │ │ │ + read_wmc_StateOrProvince: function(contactAddress, node) { │ │ │ │ + var stateOrProvince = this.getChildValue(node); │ │ │ │ + if (stateOrProvince) { │ │ │ │ + contactAddress.stateOrProvince = stateOrProvince; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.ArgParser │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * Method: read_wmc_PostCode │ │ │ │ */ │ │ │ │ + read_wmc_PostCode: function(contactAddress, node) { │ │ │ │ + var postcode = this.getChildValue(node); │ │ │ │ + if (postcode) { │ │ │ │ + contactAddress.postcode = postcode; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getParameters │ │ │ │ + * Method: read_wmc_Country │ │ │ │ */ │ │ │ │ - getParameters: function(url) { │ │ │ │ - url = url || window.location.href; │ │ │ │ - var parameters = OpenLayers.Util.getParameters(url); │ │ │ │ - │ │ │ │ - // If we have an anchor in the url use it to split the url │ │ │ │ - var index = url.indexOf('#'); │ │ │ │ - if (index > 0) { │ │ │ │ - // create an url to parse on the getParameters │ │ │ │ - url = '?' + url.substring(index + 1, url.length); │ │ │ │ - │ │ │ │ - OpenLayers.Util.extend(parameters, │ │ │ │ - OpenLayers.Util.getParameters(url)); │ │ │ │ + read_wmc_Country: function(contactAddress, node) { │ │ │ │ + var country = this.getChildValue(node); │ │ │ │ + if (country) { │ │ │ │ + contactAddress.country = country; │ │ │ │ } │ │ │ │ - return parameters; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * Method: read_wmc_ContactVoiceTelephone │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - │ │ │ │ - //make sure we dont already have an arg parser attached │ │ │ │ - for (var i = 0, len = this.map.controls.length; i < len; 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 = this.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 = parseFloat(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(); │ │ │ │ - } │ │ │ │ + read_wmc_ContactVoiceTelephone: function(contact, node) { │ │ │ │ + var phone = this.getChildValue(node); │ │ │ │ + if (phone) { │ │ │ │ + contact.phone = phone; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setCenter │ │ │ │ - * As soon as a baseLayer has been loaded, we center and zoom │ │ │ │ - * ...and remove the handler. │ │ │ │ + /** │ │ │ │ + * Method: read_wmc_ContactFacsimileTelephone │ │ │ │ */ │ │ │ │ - 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); │ │ │ │ + read_wmc_ContactFacsimileTelephone: function(contact, node) { │ │ │ │ + var fax = this.getChildValue(node); │ │ │ │ + if (fax) { │ │ │ │ + contact.fax = fax; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: configureLayers │ │ │ │ - * As soon as all the layers are loaded, cycle through them and │ │ │ │ - * hide or show them. │ │ │ │ + /** │ │ │ │ + * Method: read_wmc_ContactElectronicMailAddress │ │ │ │ */ │ │ │ │ - configureLayers: function() { │ │ │ │ - │ │ │ │ - if (this.layers.length == this.map.layers.length) { │ │ │ │ - this.map.events.unregister('addlayer', this, this.configureLayers); │ │ │ │ - │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; 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"); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + read_wmc_ContactElectronicMailAddress: function(contact, node) { │ │ │ │ + var email = this.getChildValue(node); │ │ │ │ + if (email) { │ │ │ │ + contact.email = email; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ArgParser" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Permalink.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Control/ArgParser.js │ │ │ │ - * @requires OpenLayers/Lang.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Permalink │ │ │ │ - * The Permalink control is hyperlink that will return the user to the │ │ │ │ - * current map view. By default it is drawn in the lower right corner of the │ │ │ │ - * map. The href is updated as the map is zoomed, panned and whilst layers │ │ │ │ - * are switched. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: argParserClass │ │ │ │ - * {Class} The ArgParser control class (not instance) to use with this │ │ │ │ - * control. │ │ │ │ - */ │ │ │ │ - argParserClass: OpenLayers.Control.ArgParser, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: element │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - element: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: anchor │ │ │ │ - * {Boolean} This option changes 3 things: │ │ │ │ - * the character '#' is used in place of the character '?', │ │ │ │ - * the window.href is updated if no element is provided. │ │ │ │ - * When this option is set to true it's not recommend to provide │ │ │ │ - * a base without provide an element. │ │ │ │ - */ │ │ │ │ - anchor: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: base │ │ │ │ - * {String} │ │ │ │ + * Method: read_wmc_DataURL │ │ │ │ */ │ │ │ │ - base: '', │ │ │ │ + read_wmc_DataURL: function(layerContext, node) { │ │ │ │ + layerContext.dataURL = this.getOnlineResource_href(node); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: displayProjection │ │ │ │ - * {<OpenLayers.Projection>} 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. │ │ │ │ + /** │ │ │ │ + * Method: read_wmc_LegendURL │ │ │ │ */ │ │ │ │ - displayProjection: null, │ │ │ │ + read_wmc_LegendURL: function(style, node) { │ │ │ │ + var legend = { │ │ │ │ + width: node.getAttribute('width'), │ │ │ │ + height: node.getAttribute('height'), │ │ │ │ + format: node.getAttribute('format'), │ │ │ │ + href: this.getOnlineResource_href(node) │ │ │ │ + }; │ │ │ │ + style.legend = legend; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Permalink │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * element - {DOMElement} │ │ │ │ - * base - {String} │ │ │ │ - * options - {Object} options to the control. │ │ │ │ - * │ │ │ │ - * Or for anchor: │ │ │ │ - * options - {Object} options to the control. │ │ │ │ + * Method: read_wmc_DimensionList │ │ │ │ */ │ │ │ │ - initialize: function(element, base, options) { │ │ │ │ - if (element !== null && typeof element == 'object' && !OpenLayers.Util.isElement(element)) { │ │ │ │ - options = element; │ │ │ │ - this.base = document.location.href; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (this.element != null) { │ │ │ │ - this.element = OpenLayers.Util.getElement(this.element); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.element = OpenLayers.Util.getElement(element); │ │ │ │ - this.base = base || document.location.href; │ │ │ │ - } │ │ │ │ + read_wmc_DimensionList: function(layerContext, node) { │ │ │ │ + layerContext.dimensions = {}; │ │ │ │ + this.runChildNodes(layerContext.dimensions, node); │ │ │ │ }, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Method: read_wmc_Dimension │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.element && this.element.parentNode == this.div) { │ │ │ │ - this.div.removeChild(this.element); │ │ │ │ - this.element = null; │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister('moveend', this, this.updateLink); │ │ │ │ - } │ │ │ │ + read_wmc_Dimension: function(dimensions, node) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + var dim = { │ │ │ │ + name: name, │ │ │ │ + units: node.getAttribute("units") || "", │ │ │ │ + unitSymbol: node.getAttribute("unitSymbol") || "", │ │ │ │ + userValue: node.getAttribute("userValue") || "", │ │ │ │ + nearestValue: node.getAttribute("nearestValue") === "1", │ │ │ │ + multipleValues: node.getAttribute("multipleValues") === "1", │ │ │ │ + current: node.getAttribute("current") === "1", │ │ │ │ + "default": node.getAttribute("default") || "" │ │ │ │ + }; │ │ │ │ + var values = this.getChildValue(node); │ │ │ │ + dim.values = values.split(","); │ │ │ │ + │ │ │ │ + dimensions[dim.name] = dim; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ - * │ │ │ │ + * Method: write │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * context - {Object} An object representing the map context. │ │ │ │ + * options - {Object} Optional object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A WMC document string. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + write: function(context, options) { │ │ │ │ + var root = this.createElementDefaultNS("ViewContext"); │ │ │ │ + this.setAttributes(root, { │ │ │ │ + version: this.VERSION, │ │ │ │ + id: (options && typeof options.id == "string") ? │ │ │ │ + options.id : OpenLayers.Util.createUniqueID("OpenLayers_Context_") │ │ │ │ + }); │ │ │ │ │ │ │ │ - //make sure we have an arg parser attached │ │ │ │ - for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ - var control = this.map.controls[i]; │ │ │ │ - if (control.CLASS_NAME == this.argParserClass.CLASS_NAME) { │ │ │ │ + // add schemaLocation attribute │ │ │ │ + this.setAttributeNS( │ │ │ │ + root, this.namespaces.xsi, │ │ │ │ + "xsi:schemaLocation", this.schemaLocation │ │ │ │ + ); │ │ │ │ │ │ │ │ - // 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; │ │ │ │ - } │ │ │ │ + // required General element │ │ │ │ + root.appendChild(this.write_wmc_General(context)); │ │ │ │ │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i == this.map.controls.length) { │ │ │ │ - this.map.addControl(new this.argParserClass({ │ │ │ │ - 'displayProjection': this.displayProjection │ │ │ │ - })); │ │ │ │ - } │ │ │ │ + // required LayerList element │ │ │ │ + root.appendChild(this.write_wmc_LayerList(context)); │ │ │ │ │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * Method: createElementDefaultNS │ │ │ │ + * Shorthand for createElementNS with namespace from <defaultPrefix>. │ │ │ │ + * Can optionally be used to set attributes and a text child value. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} The qualified node name. │ │ │ │ + * childValue - {String} Optional value for text child node. │ │ │ │ + * attributes - {Object} Optional object representing attributes. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * {Element} An element node. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (!this.element && !this.anchor) { │ │ │ │ - this.element = document.createElement("a"); │ │ │ │ - this.element.innerHTML = OpenLayers.i18n("Permalink"); │ │ │ │ - this.element.href = ""; │ │ │ │ - this.div.appendChild(this.element); │ │ │ │ + createElementDefaultNS: function(name, childValue, attributes) { │ │ │ │ + var node = this.createElementNS( │ │ │ │ + this.namespaces[this.defaultPrefix], │ │ │ │ + name │ │ │ │ + ); │ │ │ │ + if (childValue) { │ │ │ │ + node.appendChild(this.createTextNode(childValue)); │ │ │ │ } │ │ │ │ - this.map.events.on({ │ │ │ │ - 'moveend': this.updateLink, │ │ │ │ - 'changelayer': this.updateLink, │ │ │ │ - 'changebaselayer': this.updateLink, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - │ │ │ │ - // Make it so there is at least a link even though the map may not have │ │ │ │ - // moved yet. │ │ │ │ - this.updateLink(); │ │ │ │ - │ │ │ │ - return this.div; │ │ │ │ + if (attributes) { │ │ │ │ + this.setAttributes(node, attributes); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateLink │ │ │ │ + * Method: setAttributes │ │ │ │ + * Set multiple attributes given key value pairs from an object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {Element} An element node. │ │ │ │ + * obj - {Object} An object whose properties represent attribute names and │ │ │ │ + * values represent attribute values. │ │ │ │ */ │ │ │ │ - updateLink: function() { │ │ │ │ - var separator = this.anchor ? '#' : '?'; │ │ │ │ - var href = this.base; │ │ │ │ - var anchor = null; │ │ │ │ - if (href.indexOf("#") != -1 && this.anchor == false) { │ │ │ │ - anchor = href.substring(href.indexOf("#"), href.length); │ │ │ │ - } │ │ │ │ - if (href.indexOf(separator) != -1) { │ │ │ │ - href = href.substring(0, href.indexOf(separator)); │ │ │ │ - } │ │ │ │ - var splits = href.split("#"); │ │ │ │ - href = splits[0] + separator + OpenLayers.Util.getParameterString(this.createParams()); │ │ │ │ - if (anchor) { │ │ │ │ - href += anchor; │ │ │ │ - } │ │ │ │ - if (this.anchor && !this.element) { │ │ │ │ - window.location.href = href; │ │ │ │ - } else { │ │ │ │ - this.element.href = href; │ │ │ │ + setAttributes: function(node, obj) { │ │ │ │ + var value; │ │ │ │ + for (var name in obj) { │ │ │ │ + value = obj[name].toString(); │ │ │ │ + if (value.match(/[A-Z]/)) { │ │ │ │ + // safari lowercases attributes with setAttribute │ │ │ │ + this.setAttributeNS(node, null, name, value); │ │ │ │ + } else { │ │ │ │ + node.setAttribute(name, value); │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: createParams │ │ │ │ - * Creates the parameters that need to be encoded into the permalink url. │ │ │ │ - * │ │ │ │ + * Method: write_wmc_General │ │ │ │ + * Create a General node given an context object. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * center - {<OpenLayers.LonLat>} center to encode in the permalink. │ │ │ │ - * Defaults to the current map center. │ │ │ │ - * zoom - {Integer} zoom level to encode in the permalink. Defaults to the │ │ │ │ - * current map zoom level. │ │ │ │ - * layers - {Array(<OpenLayers.Layer>)} layers to encode in the permalink. │ │ │ │ - * Defaults to the current map layers. │ │ │ │ - * │ │ │ │ + * context - {Object} Context object. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Object} Hash of parameters that will be url-encoded into the │ │ │ │ - * permalink. │ │ │ │ + * {Element} A WMC General element node. │ │ │ │ */ │ │ │ │ - createParams: function(center, zoom, layers) { │ │ │ │ - center = center || this.map.getCenter(); │ │ │ │ - │ │ │ │ - var params = OpenLayers.Util.getParameters(this.base); │ │ │ │ - │ │ │ │ - // If there's still no center, map is not initialized yet. │ │ │ │ - // Break out of this function, and simply return the params from the │ │ │ │ - // base link. │ │ │ │ - if (center) { │ │ │ │ - │ │ │ │ - //zoom │ │ │ │ - params.zoom = zoom || this.map.getZoom(); │ │ │ │ - │ │ │ │ - //lon,lat │ │ │ │ - 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; │ │ │ │ - │ │ │ │ - //layers │ │ │ │ - layers = layers || this.map.layers; │ │ │ │ - params.layers = ''; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ + write_wmc_General: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("General"); │ │ │ │ │ │ │ │ - if (layer.isBaseLayer) { │ │ │ │ - params.layers += (layer == this.map.baseLayer) ? "B" : "0"; │ │ │ │ - } else { │ │ │ │ - params.layers += (layer.getVisibility()) ? "T" : "F"; │ │ │ │ + // optional Window element │ │ │ │ + if (context.size) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Window", null, { │ │ │ │ + width: context.size.w, │ │ │ │ + height: context.size.h │ │ │ │ } │ │ │ │ - } │ │ │ │ + )); │ │ │ │ } │ │ │ │ │ │ │ │ - return params; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Permalink" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Measure.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + // required BoundingBox element │ │ │ │ + var bounds = context.bounds; │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "BoundingBox", null, { │ │ │ │ + minx: bounds.left.toPrecision(18), │ │ │ │ + miny: bounds.bottom.toPrecision(18), │ │ │ │ + maxx: bounds.right.toPrecision(18), │ │ │ │ + maxy: bounds.top.toPrecision(18), │ │ │ │ + SRS: context.projection │ │ │ │ + } │ │ │ │ + )); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - */ │ │ │ │ + // required Title element │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Title", context.title │ │ │ │ + )); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Measure │ │ │ │ - * Allows for drawing of features for measurements. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Measure = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + // optional KeywordList element │ │ │ │ + if (context.keywords) { │ │ │ │ + node.appendChild(this.write_wmc_KeywordList(context.keywords)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * measure - Triggered when a measurement sketch is complete. Listeners │ │ │ │ - * will receive an event with measure, units, order, and geometry │ │ │ │ - * properties. │ │ │ │ - * measurepartial - Triggered when a new point is added to the │ │ │ │ - * measurement sketch or if the <immediate> property is true and the │ │ │ │ - * measurement sketch is modified. Listeners receive an event with measure, │ │ │ │ - * units, order, and geometry. │ │ │ │ - */ │ │ │ │ + // optional Abstract element │ │ │ │ + if (context["abstract"]) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Abstract", context["abstract"] │ │ │ │ + )); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the control's handler │ │ │ │ - */ │ │ │ │ + // Optional LogoURL element │ │ │ │ + if (context.logo) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("LogoURL", context.logo.href, context.logo)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: callbacks │ │ │ │ - * {Object} The functions that are sent to the handler for callback │ │ │ │ - */ │ │ │ │ - callbacks: null, │ │ │ │ + // Optional DescriptionURL element │ │ │ │ + if (context.descriptionURL) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("DescriptionURL", context.descriptionURL)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: displaySystem │ │ │ │ - * {String} Display system for output measurements. Supported values │ │ │ │ - * are 'english', 'metric', and 'geographic'. Default is 'metric'. │ │ │ │ - */ │ │ │ │ - displaySystem: 'metric', │ │ │ │ + // Optional ContactInformation element │ │ │ │ + if (context.contactInformation) { │ │ │ │ + node.appendChild(this.write_wmc_ContactInformation(context.contactInformation)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: geodesic │ │ │ │ - * {Boolean} Calculate geodesic metrics instead of planar metrics. This │ │ │ │ - * requires that geometries can be transformed into Geographic/WGS84 │ │ │ │ - * (if that is not already the map projection). Default is false. │ │ │ │ - */ │ │ │ │ - geodesic: false, │ │ │ │ + // OpenLayers specific map properties │ │ │ │ + node.appendChild(this.write_ol_MapExtension(context)); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: displaySystemUnits │ │ │ │ - * {Object} Units for various measurement systems. Values are arrays │ │ │ │ - * of unit abbreviations (from OpenLayers.INCHES_PER_UNIT) in decreasing │ │ │ │ - * order of length. │ │ │ │ - */ │ │ │ │ - displaySystemUnits: { │ │ │ │ - geographic: ['dd'], │ │ │ │ - english: ['mi', 'ft', 'in'], │ │ │ │ - metric: ['km', 'm'] │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: delay │ │ │ │ - * {Number} Number of milliseconds between clicks before the event is │ │ │ │ - * considered a double-click. The "measurepartial" event will not │ │ │ │ - * be triggered if the sketch is completed within this time. This │ │ │ │ - * is required for IE where creating a browser reflow (if a listener │ │ │ │ - * is modifying the DOM by displaying the measurement values) messes │ │ │ │ - * with the dblclick listener in the sketch handler. │ │ │ │ - */ │ │ │ │ - partialDelay: 300, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: delayedTrigger │ │ │ │ - * {Number} Timeout id of trigger for measurepartial. │ │ │ │ - */ │ │ │ │ - delayedTrigger: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: persist │ │ │ │ - * {Boolean} Keep the temporary measurement sketch drawn after the │ │ │ │ - * measurement is complete. The geometry will persist until a new │ │ │ │ - * measurement is started, the control is deactivated, or <cancel> is │ │ │ │ - * called. │ │ │ │ - */ │ │ │ │ - persist: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: immediate │ │ │ │ - * {Boolean} Activates the immediate measurement so that the "measurepartial" │ │ │ │ - * event is also fired once the measurement sketch is modified. │ │ │ │ - * Default is false. │ │ │ │ + * Method: write_wmc_KeywordList │ │ │ │ */ │ │ │ │ - immediate: false, │ │ │ │ + write_wmc_KeywordList: function(keywords) { │ │ │ │ + var node = this.createElementDefaultNS("KeywordList"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Control.Measure │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * handler - {<OpenLayers.Handler>} │ │ │ │ - * options - {Object} │ │ │ │ - */ │ │ │ │ - initialize: function(handler, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - var callbacks = { │ │ │ │ - done: this.measureComplete, │ │ │ │ - point: this.measurePartial │ │ │ │ - }; │ │ │ │ - if (this.immediate) { │ │ │ │ - callbacks.modify = this.measureImmediate; │ │ │ │ + for (var i = 0, len = keywords.length; i < len; i++) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Keyword", keywords[i] │ │ │ │ + )); │ │ │ │ } │ │ │ │ - this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ - │ │ │ │ - // let the handler options override, so old code that passes 'persist' │ │ │ │ - // directly to the handler does not need an update │ │ │ │ - this.handlerOptions = OpenLayers.Util.extend({ │ │ │ │ - persist: this.persist │ │ │ │ - }, this.handlerOptions); │ │ │ │ - this.handler = new handler(this, this.callbacks, this.handlerOptions); │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ + * Method: write_wmc_ContactInformation │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - this.cancelDelay(); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + write_wmc_ContactInformation: function(contact) { │ │ │ │ + var node = this.createElementDefaultNS("ContactInformation"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: cancel │ │ │ │ - * Stop the control from measuring. If <persist> is true, the temporary │ │ │ │ - * sketch will be erased. │ │ │ │ - */ │ │ │ │ - cancel: function() { │ │ │ │ - this.cancelDelay(); │ │ │ │ - this.handler.cancel(); │ │ │ │ + if (contact.personPrimary) { │ │ │ │ + node.appendChild(this.write_wmc_ContactPersonPrimary(contact.personPrimary)); │ │ │ │ + } │ │ │ │ + if (contact.position) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "ContactPosition", contact.position │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contact.contactAddress) { │ │ │ │ + node.appendChild(this.write_wmc_ContactAddress(contact.contactAddress)); │ │ │ │ + } │ │ │ │ + if (contact.phone) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "ContactVoiceTelephone", contact.phone │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contact.fax) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "ContactFacsimileTelephone", contact.fax │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contact.email) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "ContactElectronicMailAddress", contact.email │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setImmediate │ │ │ │ - * Sets the <immediate> property. Changes the activity of immediate │ │ │ │ - * measurement. │ │ │ │ + * Method: write_wmc_ContactPersonPrimary │ │ │ │ */ │ │ │ │ - setImmediate: function(immediate) { │ │ │ │ - this.immediate = immediate; │ │ │ │ - if (this.immediate) { │ │ │ │ - this.callbacks.modify = this.measureImmediate; │ │ │ │ - } else { │ │ │ │ - delete this.callbacks.modify; │ │ │ │ + write_wmc_ContactPersonPrimary: function(personPrimary) { │ │ │ │ + var node = this.createElementDefaultNS("ContactPersonPrimary"); │ │ │ │ + if (personPrimary.person) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "ContactPerson", personPrimary.person │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (personPrimary.organization) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "ContactOrganization", personPrimary.organization │ │ │ │ + )); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateHandler │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * handler - {Function} One of the sketch handler constructors. │ │ │ │ - * options - {Object} Options for the handler. │ │ │ │ + * Method: write_wmc_ContactAddress │ │ │ │ */ │ │ │ │ - updateHandler: function(handler, options) { │ │ │ │ - var active = this.active; │ │ │ │ - if (active) { │ │ │ │ - this.deactivate(); │ │ │ │ + write_wmc_ContactAddress: function(contactAddress) { │ │ │ │ + var node = this.createElementDefaultNS("ContactAddress"); │ │ │ │ + if (contactAddress.type) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "AddressType", contactAddress.type │ │ │ │ + )); │ │ │ │ } │ │ │ │ - this.handler = new handler(this, this.callbacks, options); │ │ │ │ - if (active) { │ │ │ │ - this.activate(); │ │ │ │ + if (contactAddress.address) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Address", contactAddress.address │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contactAddress.city) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "City", contactAddress.city │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contactAddress.stateOrProvince) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "StateOrProvince", contactAddress.stateOrProvince │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contactAddress.postcode) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "PostCode", contactAddress.postcode │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + if (contactAddress.country) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Country", contactAddress.country │ │ │ │ + )); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: measureComplete │ │ │ │ - * Called when the measurement sketch is done. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * Method: write_ol_MapExtension │ │ │ │ */ │ │ │ │ - measureComplete: function(geometry) { │ │ │ │ - this.cancelDelay(); │ │ │ │ - this.measure(geometry, "measure"); │ │ │ │ - }, │ │ │ │ + write_ol_MapExtension: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("Extension"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: measurePartial │ │ │ │ - * Called each time a new point is added to the measurement sketch. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} The last point added. │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The sketch geometry. │ │ │ │ - */ │ │ │ │ - measurePartial: function(point, geometry) { │ │ │ │ - this.cancelDelay(); │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - // when we're wating for a dblclick, we have to trigger measurepartial │ │ │ │ - // after some delay to deal with reflow issues in IE │ │ │ │ - if (this.handler.freehandMode(this.handler.evt)) { │ │ │ │ - // no dblclick in freehand mode │ │ │ │ - this.measure(geometry, "measurepartial"); │ │ │ │ - } else { │ │ │ │ - this.delayedTrigger = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(function() { │ │ │ │ - this.delayedTrigger = null; │ │ │ │ - this.measure(geometry, "measurepartial"); │ │ │ │ - }, this), │ │ │ │ - this.partialDelay │ │ │ │ + var bounds = context.maxExtent; │ │ │ │ + if (bounds) { │ │ │ │ + var maxExtent = this.createElementNS( │ │ │ │ + this.namespaces.ol, "ol:maxExtent" │ │ │ │ ); │ │ │ │ + this.setAttributes(maxExtent, { │ │ │ │ + minx: bounds.left.toPrecision(18), │ │ │ │ + miny: bounds.bottom.toPrecision(18), │ │ │ │ + maxx: bounds.right.toPrecision(18), │ │ │ │ + maxy: bounds.top.toPrecision(18) │ │ │ │ + }); │ │ │ │ + node.appendChild(maxExtent); │ │ │ │ } │ │ │ │ + │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: measureImmediate │ │ │ │ - * Called each time the measurement sketch is modified. │ │ │ │ + * Method: write_wmc_LayerList │ │ │ │ + * Create a LayerList node given an context object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} The point at the mouse position. │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The sketch feature. │ │ │ │ - * drawing - {Boolean} Indicates whether we're currently drawing. │ │ │ │ + * context - {Object} Context object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC LayerList element node. │ │ │ │ */ │ │ │ │ - measureImmediate: function(point, feature, drawing) { │ │ │ │ - if (drawing && !this.handler.freehandMode(this.handler.evt)) { │ │ │ │ - this.cancelDelay(); │ │ │ │ - this.measure(feature.geometry, "measurepartial"); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + write_wmc_LayerList: function(context) { │ │ │ │ + var list = this.createElementDefaultNS("LayerList"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: cancelDelay │ │ │ │ - * Cancels the delay measurement that measurePartial began. │ │ │ │ - */ │ │ │ │ - cancelDelay: function() { │ │ │ │ - if (this.delayedTrigger !== null) { │ │ │ │ - window.clearTimeout(this.delayedTrigger); │ │ │ │ - this.delayedTrigger = null; │ │ │ │ + for (var i = 0, len = context.layersContext.length; i < len; ++i) { │ │ │ │ + list.appendChild(this.write_wmc_Layer(context.layersContext[i])); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: measure │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * eventType - {String} │ │ │ │ - */ │ │ │ │ - measure: function(geometry, eventType) { │ │ │ │ - var stat, order; │ │ │ │ - if (geometry.CLASS_NAME.indexOf('LineString') > -1) { │ │ │ │ - stat = this.getBestLength(geometry); │ │ │ │ - order = 1; │ │ │ │ - } else { │ │ │ │ - stat = this.getBestArea(geometry); │ │ │ │ - order = 2; │ │ │ │ - } │ │ │ │ - this.events.triggerEvent(eventType, { │ │ │ │ - measure: stat[0], │ │ │ │ - units: stat[1], │ │ │ │ - order: order, │ │ │ │ - geometry: geometry │ │ │ │ - }); │ │ │ │ + return list; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getBestArea │ │ │ │ - * Based on the <displaySystem> returns the area of a geometry. │ │ │ │ + * Method: write_wmc_Layer │ │ │ │ + * Create a Layer node given a layer context object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * context - {Object} A layer context object.} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array([Float, String])} Returns a two item array containing the │ │ │ │ - * area and the units abbreviation. │ │ │ │ + * {Element} A WMC Layer element node. │ │ │ │ */ │ │ │ │ - getBestArea: function(geometry) { │ │ │ │ - var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ - var unit, area; │ │ │ │ - for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ - unit = units[i]; │ │ │ │ - area = this.getArea(geometry, unit); │ │ │ │ - if (area > 1) { │ │ │ │ - break; │ │ │ │ + write_wmc_Layer: function(context) { │ │ │ │ + var node = this.createElementDefaultNS( │ │ │ │ + "Layer", null, { │ │ │ │ + queryable: context.queryable ? "1" : "0", │ │ │ │ + hidden: context.visibility ? "0" : "1" │ │ │ │ } │ │ │ │ + ); │ │ │ │ + │ │ │ │ + // required Server element │ │ │ │ + node.appendChild(this.write_wmc_Server(context)); │ │ │ │ + │ │ │ │ + // required Name element │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Name", context.name │ │ │ │ + )); │ │ │ │ + │ │ │ │ + // required Title element │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Title", context.title │ │ │ │ + )); │ │ │ │ + │ │ │ │ + // optional Abstract element │ │ │ │ + if (context["abstract"]) { │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Abstract", context["abstract"] │ │ │ │ + )); │ │ │ │ } │ │ │ │ - return [area, unit]; │ │ │ │ + │ │ │ │ + // optional DataURL element │ │ │ │ + if (context.dataURL) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("DataURL", context.dataURL)); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // optional MetadataURL element │ │ │ │ + if (context.metadataURL) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("MetadataURL", context.metadataURL)); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getArea │ │ │ │ + * Method: write_wmc_LayerExtension │ │ │ │ + * Add OpenLayers specific layer parameters to an Extension element. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * units - {String} Unit abbreviation │ │ │ │ + * context - {Object} A layer context object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Float} The geometry area in the given units. │ │ │ │ + * {Element} A WMC Extension element (for a layer). │ │ │ │ */ │ │ │ │ - getArea: function(geometry, units) { │ │ │ │ - var area, geomUnits; │ │ │ │ - if (this.geodesic) { │ │ │ │ - area = geometry.getGeodesicArea(this.map.getProjectionObject()); │ │ │ │ - geomUnits = "m"; │ │ │ │ - } else { │ │ │ │ - area = geometry.getArea(); │ │ │ │ - geomUnits = this.map.getUnits(); │ │ │ │ + write_wmc_LayerExtension: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("Extension"); │ │ │ │ + │ │ │ │ + var bounds = context.maxExtent; │ │ │ │ + var maxExtent = this.createElementNS( │ │ │ │ + this.namespaces.ol, "ol:maxExtent" │ │ │ │ + ); │ │ │ │ + this.setAttributes(maxExtent, { │ │ │ │ + minx: bounds.left.toPrecision(18), │ │ │ │ + miny: bounds.bottom.toPrecision(18), │ │ │ │ + maxx: bounds.right.toPrecision(18), │ │ │ │ + maxy: bounds.top.toPrecision(18) │ │ │ │ + }); │ │ │ │ + node.appendChild(maxExtent); │ │ │ │ + │ │ │ │ + if (context.tileSize && !context.singleTile) { │ │ │ │ + var size = this.createElementNS( │ │ │ │ + this.namespaces.ol, "ol:tileSize" │ │ │ │ + ); │ │ │ │ + this.setAttributes(size, context.tileSize); │ │ │ │ + node.appendChild(size); │ │ │ │ } │ │ │ │ - var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ - if (inPerDisplayUnit) { │ │ │ │ - var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ - area *= Math.pow((inPerMapUnit / inPerDisplayUnit), 2); │ │ │ │ + │ │ │ │ + var properties = [ │ │ │ │ + "transparent", "numZoomLevels", "units", "isBaseLayer", │ │ │ │ + "opacity", "displayInLayerSwitcher", "singleTile" │ │ │ │ + ]; │ │ │ │ + var child; │ │ │ │ + for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ + child = this.createOLPropertyNode(context, properties[i]); │ │ │ │ + if (child) { │ │ │ │ + node.appendChild(child); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return area; │ │ │ │ + │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getBestLength │ │ │ │ - * Based on the <displaySystem> returns the length of a geometry. │ │ │ │ + * Method: createOLPropertyNode │ │ │ │ + * Create a node representing an OpenLayers property. If the property is │ │ │ │ + * null or undefined, null will be returned. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * obj - {Object} An object. │ │ │ │ + * prop - {String} A property. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array([Float, String])} Returns a two item array containing the │ │ │ │ - * length and the units abbreviation. │ │ │ │ + * {Element} A property node. │ │ │ │ */ │ │ │ │ - getBestLength: function(geometry) { │ │ │ │ - var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ - var unit, length; │ │ │ │ - for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ - unit = units[i]; │ │ │ │ - length = this.getLength(geometry, unit); │ │ │ │ - if (length > 1) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + createOLPropertyNode: function(obj, prop) { │ │ │ │ + var node = null; │ │ │ │ + if (obj[prop] != null) { │ │ │ │ + node = this.createElementNS(this.namespaces.ol, "ol:" + prop); │ │ │ │ + node.appendChild(this.createTextNode(obj[prop].toString())); │ │ │ │ } │ │ │ │ - return [length, unit]; │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getLength │ │ │ │ + * Method: write_wmc_Server │ │ │ │ + * Create a Server node given a layer context object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * units - {String} Unit abbreviation │ │ │ │ + * context - {Object} Layer context object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Float} The geometry length in the given units. │ │ │ │ + * {Element} A WMC Server element node. │ │ │ │ */ │ │ │ │ - getLength: function(geometry, units) { │ │ │ │ - var length, geomUnits; │ │ │ │ - if (this.geodesic) { │ │ │ │ - length = geometry.getGeodesicLength(this.map.getProjectionObject()); │ │ │ │ - geomUnits = "m"; │ │ │ │ - } else { │ │ │ │ - length = geometry.getLength(); │ │ │ │ - geomUnits = this.map.getUnits(); │ │ │ │ - } │ │ │ │ - var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ - if (inPerDisplayUnit) { │ │ │ │ - var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ - length *= (inPerMapUnit / inPerDisplayUnit); │ │ │ │ + write_wmc_Server: function(context) { │ │ │ │ + var server = context.server; │ │ │ │ + var node = this.createElementDefaultNS("Server"); │ │ │ │ + var attributes = { │ │ │ │ + service: "OGC:WMS", │ │ │ │ + version: server.version │ │ │ │ + }; │ │ │ │ + if (server.title) { │ │ │ │ + attributes.title = server.title; │ │ │ │ } │ │ │ │ - return length; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Measure" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Handler/Box.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Handler.Box │ │ │ │ - * Handler for dragging a rectangle across the map. Box is displayed │ │ │ │ - * on mouse down, moves on mouse move, and is finished on mouse up. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: dragHandler │ │ │ │ - * {<OpenLayers.Handler.Drag>} │ │ │ │ - */ │ │ │ │ - dragHandler: null, │ │ │ │ + this.setAttributes(node, attributes); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: boxDivClassName │ │ │ │ - * {String} The CSS class to use for drawing the box. Default is │ │ │ │ - * olHandlerBoxZoomBox │ │ │ │ - */ │ │ │ │ - boxDivClassName: 'olHandlerBoxZoomBox', │ │ │ │ + // required OnlineResource element │ │ │ │ + node.appendChild(this.write_wmc_OnlineResource(server.url)); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: boxOffsets │ │ │ │ - * {Object} Caches box offsets from css. This is used by the getBoxOffsets │ │ │ │ - * method. │ │ │ │ - */ │ │ │ │ - boxOffsets: null, │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Box │ │ │ │ + * Method: write_wmc_URLType │ │ │ │ + * Create a LogoURL/DescriptionURL/MetadataURL/DataURL/LegendURL node given a object and elementName. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - * callbacks - {Object} An object with a properties whose values are │ │ │ │ - * functions. Various callbacks described below. │ │ │ │ - * options - {Object} │ │ │ │ + * elName - {String} Name of element (LogoURL/DescriptionURL/MetadataURL/LegendURL) │ │ │ │ + * url - {String} URL string value │ │ │ │ + * attr - {Object} Optional attributes (width, height, format) │ │ │ │ * │ │ │ │ - * Named callbacks: │ │ │ │ - * start - Called when the box drag operation starts. │ │ │ │ - * done - Called when the box drag operation is finished. │ │ │ │ - * The callback should expect to receive a single argument, the box │ │ │ │ - * bounds or a pixel. If the box dragging didn't span more than a 5 │ │ │ │ - * pixel distance, a pixel will be returned instead of a bounds object. │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC element node. │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.dragHandler = new OpenLayers.Handler.Drag( │ │ │ │ - this, { │ │ │ │ - down: this.startBox, │ │ │ │ - move: this.moveBox, │ │ │ │ - out: this.removeBox, │ │ │ │ - up: this.endBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ + write_wmc_URLType: function(elName, url, attr) { │ │ │ │ + var node = this.createElementDefaultNS(elName); │ │ │ │ + node.appendChild(this.write_wmc_OnlineResource(url)); │ │ │ │ + if (attr) { │ │ │ │ + var optionalAttributes = ["width", "height", "format"]; │ │ │ │ + for (var i = 0; i < optionalAttributes.length; i++) { │ │ │ │ + if (optionalAttributes[i] in attr) { │ │ │ │ + node.setAttribute(optionalAttributes[i], attr[optionalAttributes[i]]); │ │ │ │ + } │ │ │ │ } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.dragHandler) { │ │ │ │ - this.dragHandler.destroy(); │ │ │ │ - this.dragHandler = null; │ │ │ │ } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * Method: write_wmc_DimensionList │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Handler.prototype.setMap.apply(this, arguments); │ │ │ │ - if (this.dragHandler) { │ │ │ │ - this.dragHandler.setMap(map); │ │ │ │ + write_wmc_DimensionList: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("DimensionList"); │ │ │ │ + var required_attributes = { │ │ │ │ + name: true, │ │ │ │ + units: true, │ │ │ │ + unitSymbol: true, │ │ │ │ + userValue: true │ │ │ │ + }; │ │ │ │ + for (var dim in context.dimensions) { │ │ │ │ + var attributes = {}; │ │ │ │ + var dimension = context.dimensions[dim]; │ │ │ │ + for (var name in dimension) { │ │ │ │ + if (typeof dimension[name] == "boolean") { │ │ │ │ + attributes[name] = Number(dimension[name]); │ │ │ │ + } else { │ │ │ │ + attributes[name] = dimension[name]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var values = ""; │ │ │ │ + if (attributes.values) { │ │ │ │ + values = attributes.values.join(","); │ │ │ │ + delete attributes.values; │ │ │ │ + } │ │ │ │ + │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Dimension", values, attributes │ │ │ │ + )); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: startBox │ │ │ │ + * Method: write_wmc_FormatList │ │ │ │ + * Create a FormatList node given a layer context. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} │ │ │ │ + * context - {Object} Layer context object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC FormatList element node. │ │ │ │ */ │ │ │ │ - startBox: function(xy) { │ │ │ │ - this.callback("start", []); │ │ │ │ - this.zoomBox = OpenLayers.Util.createDiv('zoomBox', { │ │ │ │ - x: -9999, │ │ │ │ - y: -9999 │ │ │ │ - }); │ │ │ │ - this.zoomBox.className = this.boxDivClassName; │ │ │ │ - this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; │ │ │ │ - │ │ │ │ - this.map.viewPortDiv.appendChild(this.zoomBox); │ │ │ │ + write_wmc_FormatList: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("FormatList"); │ │ │ │ + for (var i = 0, len = context.formats.length; i < len; i++) { │ │ │ │ + var format = context.formats[i]; │ │ │ │ + node.appendChild(this.createElementDefaultNS( │ │ │ │ + "Format", │ │ │ │ + format.value, │ │ │ │ + (format.current && format.current == true) ? { │ │ │ │ + current: "1" │ │ │ │ + } : null │ │ │ │ + )); │ │ │ │ + } │ │ │ │ │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, "olDrawBox" │ │ │ │ - ); │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveBox │ │ │ │ + * Method: write_wmc_StyleList │ │ │ │ + * Create a StyleList node given a layer context. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {Object} Layer context object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC StyleList element node. │ │ │ │ */ │ │ │ │ - moveBox: function(xy) { │ │ │ │ - var startX = this.dragHandler.start.x; │ │ │ │ - var startY = this.dragHandler.start.y; │ │ │ │ - var deltaX = Math.abs(startX - xy.x); │ │ │ │ - var deltaY = Math.abs(startY - xy.y); │ │ │ │ - │ │ │ │ - var offset = this.getBoxOffsets(); │ │ │ │ - this.zoomBox.style.width = (deltaX + offset.width + 1) + "px"; │ │ │ │ - this.zoomBox.style.height = (deltaY + offset.height + 1) + "px"; │ │ │ │ - this.zoomBox.style.left = (xy.x < startX ? │ │ │ │ - startX - deltaX - offset.left : startX - offset.left) + "px"; │ │ │ │ - this.zoomBox.style.top = (xy.y < startY ? │ │ │ │ - startY - deltaY - offset.top : startY - offset.top) + "px"; │ │ │ │ - }, │ │ │ │ + write_wmc_StyleList: function(layer) { │ │ │ │ + var node = this.createElementDefaultNS("StyleList"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: endBox │ │ │ │ - */ │ │ │ │ - endBox: function(end) { │ │ │ │ - var result; │ │ │ │ - if (Math.abs(this.dragHandler.start.x - end.x) > 5 || │ │ │ │ - Math.abs(this.dragHandler.start.y - end.y) > 5) { │ │ │ │ - var start = this.dragHandler.start; │ │ │ │ - var top = Math.min(start.y, end.y); │ │ │ │ - var bottom = Math.max(start.y, end.y); │ │ │ │ - var left = Math.min(start.x, end.x); │ │ │ │ - var right = Math.max(start.x, end.x); │ │ │ │ - result = new OpenLayers.Bounds(left, bottom, right, top); │ │ │ │ - } else { │ │ │ │ - result = this.dragHandler.start.clone(); // i.e. OL.Pixel │ │ │ │ - } │ │ │ │ - this.removeBox(); │ │ │ │ + var styles = layer.styles; │ │ │ │ + if (styles && OpenLayers.Util.isArray(styles)) { │ │ │ │ + var sld; │ │ │ │ + for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ + var s = styles[i]; │ │ │ │ + // three style types to consider │ │ │ │ + // [1] linked SLD │ │ │ │ + // [2] inline SLD │ │ │ │ + // [3] named style │ │ │ │ + // running child nodes always gets name, optionally gets href or body │ │ │ │ + var style = this.createElementDefaultNS( │ │ │ │ + "Style", │ │ │ │ + null, │ │ │ │ + (s.current && s.current == true) ? { │ │ │ │ + current: "1" │ │ │ │ + } : null │ │ │ │ + ); │ │ │ │ + if (s.href) { // [1] │ │ │ │ + sld = this.createElementDefaultNS("SLD"); │ │ │ │ + // Name is optional. │ │ │ │ + if (s.name) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ + } │ │ │ │ + // Title is optional. │ │ │ │ + if (s.title) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ + } │ │ │ │ + // LegendURL is optional │ │ │ │ + if (s.legend) { │ │ │ │ + sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)); │ │ │ │ + } │ │ │ │ │ │ │ │ - this.callback("done", [result]); │ │ │ │ - }, │ │ │ │ + var link = this.write_wmc_OnlineResource(s.href); │ │ │ │ + sld.appendChild(link); │ │ │ │ + style.appendChild(sld); │ │ │ │ + } else if (s.body) { // [2] │ │ │ │ + sld = this.createElementDefaultNS("SLD"); │ │ │ │ + // Name is optional. │ │ │ │ + if (s.name) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ + } │ │ │ │ + // Title is optional. │ │ │ │ + if (s.title) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ + } │ │ │ │ + // LegendURL is optional │ │ │ │ + if (s.legend) { │ │ │ │ + sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeBox │ │ │ │ - * Remove the zoombox from the screen and nullify our reference to it. │ │ │ │ - */ │ │ │ │ - removeBox: function() { │ │ │ │ - this.map.viewPortDiv.removeChild(this.zoomBox); │ │ │ │ - this.zoomBox = null; │ │ │ │ - this.boxOffsets = null; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDrawBox" │ │ │ │ - ); │ │ │ │ + // read in body as xml doc - assume proper namespace declarations │ │ │ │ + var doc = OpenLayers.Format.XML.prototype.read.apply(this, [s.body]); │ │ │ │ + // append to StyledLayerDescriptor node │ │ │ │ + var imported = doc.documentElement; │ │ │ │ + if (sld.ownerDocument && sld.ownerDocument.importNode) { │ │ │ │ + imported = sld.ownerDocument.importNode(imported, true); │ │ │ │ + } │ │ │ │ + sld.appendChild(imported); │ │ │ │ + style.appendChild(sld); │ │ │ │ + } else { // [3] │ │ │ │ + // both Name and Title are required. │ │ │ │ + style.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ + style.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ + // Abstract is optional │ │ │ │ + if (s['abstract']) { // abstract is a js keyword │ │ │ │ + style.appendChild(this.createElementDefaultNS( │ │ │ │ + "Abstract", s['abstract'] │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + // LegendURL is optional │ │ │ │ + if (s.legend) { │ │ │ │ + style.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + node.appendChild(style); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ + * Method: write_wmc_OnlineResource │ │ │ │ + * Create an OnlineResource node given a URL. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * href - {String} URL for the resource. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC OnlineResource element node. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragHandler.activate(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + write_wmc_OnlineResource: function(href) { │ │ │ │ + var node = this.createElementDefaultNS("OnlineResource"); │ │ │ │ + this.setAttributeNS(node, this.namespaces.xlink, "xlink:type", "simple"); │ │ │ │ + this.setAttributeNS(node, this.namespaces.xlink, "xlink:href", href); │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ + * Method: getOnlineResource_href │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - if (this.dragHandler.deactivate()) { │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.removeBox(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + getOnlineResource_href: function(node) { │ │ │ │ + var object = {}; │ │ │ │ + var links = node.getElementsByTagName("OnlineResource"); │ │ │ │ + if (links.length > 0) { │ │ │ │ + this.read_wmc_OnlineResource(object, links[0]); │ │ │ │ } │ │ │ │ + return object.href; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getBoxOffsets │ │ │ │ - * Determines border offsets for a box, according to the box model. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} an object with the following offsets: │ │ │ │ - * - left │ │ │ │ - * - right │ │ │ │ - * - top │ │ │ │ - * - bottom │ │ │ │ - * - width │ │ │ │ - * - height │ │ │ │ - */ │ │ │ │ - getBoxOffsets: function() { │ │ │ │ - if (!this.boxOffsets) { │ │ │ │ - // Determine the box model. If the testDiv's clientWidth is 3, then │ │ │ │ - // the borders are outside and we are dealing with the w3c box │ │ │ │ - // model. Otherwise, the browser uses the traditional box model and │ │ │ │ - // the borders are inside the box bounds, leaving us with a │ │ │ │ - // clientWidth of 1. │ │ │ │ - var testDiv = document.createElement("div"); │ │ │ │ - //testDiv.style.visibility = "hidden"; │ │ │ │ - testDiv.style.position = "absolute"; │ │ │ │ - testDiv.style.border = "1px solid black"; │ │ │ │ - testDiv.style.width = "3px"; │ │ │ │ - document.body.appendChild(testDiv); │ │ │ │ - var w3cBoxModel = testDiv.clientWidth == 3; │ │ │ │ - document.body.removeChild(testDiv); │ │ │ │ │ │ │ │ - var left = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ - "border-left-width")); │ │ │ │ - var right = parseInt(OpenLayers.Element.getStyle( │ │ │ │ - this.zoomBox, "border-right-width")); │ │ │ │ - var top = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ - "border-top-width")); │ │ │ │ - var bottom = parseInt(OpenLayers.Element.getStyle( │ │ │ │ - this.zoomBox, "border-bottom-width")); │ │ │ │ - this.boxOffsets = { │ │ │ │ - left: left, │ │ │ │ - right: right, │ │ │ │ - top: top, │ │ │ │ - bottom: bottom, │ │ │ │ - width: w3cBoxModel === false ? left + right : 0, │ │ │ │ - height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - return this.boxOffsets; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC.v1" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/ZoomBox.js │ │ │ │ + OpenLayers/Format/WMC/v1_0_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Box.js │ │ │ │ + * @requires OpenLayers/Format/WMC/v1.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.ZoomBox │ │ │ │ - * The ZoomBox control enables zooming directly to a given extent, by drawing │ │ │ │ - * a box on the map. The box is drawn by holding down shift, whilst dragging │ │ │ │ - * the mouse. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Format.WMC.v1_0_0 │ │ │ │ + * Read and write WMC version 1.0.0. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.WMC.v1> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - /** │ │ │ │ - * Property: type │ │ │ │ - * {OpenLayers.Control.TYPE} │ │ │ │ - */ │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: out │ │ │ │ - * {Boolean} Should the control be used for zooming out? │ │ │ │ - */ │ │ │ │ - out: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: keyMask │ │ │ │ - * {Integer} Zoom only occurs if the keyMask matches the combination of │ │ │ │ - * keys down. Use bitwise operators and one or more of the │ │ │ │ - * <OpenLayers.Handler> constants to construct a keyMask. Leave null if │ │ │ │ - * not used mask. Default is null. │ │ │ │ - */ │ │ │ │ - keyMask: null, │ │ │ │ +OpenLayers.Format.WMC.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMC.v1, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: alwaysZoom │ │ │ │ - * {Boolean} Always zoom in/out when box drawn, even if the zoom level does │ │ │ │ - * not change. │ │ │ │ - */ │ │ │ │ - alwaysZoom: false, │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.0.0 │ │ │ │ + */ │ │ │ │ + VERSION: "1.0.0", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomOnClick │ │ │ │ - * {Boolean} Should we zoom when no box was dragged, i.e. the user only │ │ │ │ - * clicked? Default is true. │ │ │ │ - */ │ │ │ │ - zoomOnClick: true, │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/context │ │ │ │ + * http://schemas.opengis.net/context/1.0.0/context.xsd │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.0.0/context.xsd", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.zoomBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMC.v1_0_0 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.WMC> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.WMC.v1.prototype.initialize.apply( │ │ │ │ + this, [options] │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: zoomBox │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * position - {<OpenLayers.Bounds>} or {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - zoomBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var bounds, │ │ │ │ - targetCenterPx = position.getCenterPixel(); │ │ │ │ - if (!this.out) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, │ │ │ │ - maxXY.lon, maxXY.lat); │ │ │ │ - } else { │ │ │ │ - var pixWidth = position.right - position.left; │ │ │ │ - var pixHeight = position.bottom - position.top; │ │ │ │ - var zoomFactor = Math.min((this.map.size.h / pixHeight), │ │ │ │ - (this.map.size.w / pixWidth)); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ - var xmin = center.lon - (extent.getWidth() / 2) * zoomFactor; │ │ │ │ - var xmax = center.lon + (extent.getWidth() / 2) * zoomFactor; │ │ │ │ - var ymin = center.lat - (extent.getHeight() / 2) * zoomFactor; │ │ │ │ - var ymax = center.lat + (extent.getHeight() / 2) * zoomFactor; │ │ │ │ - bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax); │ │ │ │ + /** │ │ │ │ + * Method: read_wmc_SRS │ │ │ │ + */ │ │ │ │ + read_wmc_SRS: function(layerContext, node) { │ │ │ │ + var srs = this.getChildValue(node); │ │ │ │ + if (typeof layerContext.projections != "object") { │ │ │ │ + layerContext.projections = {}; │ │ │ │ } │ │ │ │ - // always zoom in/out │ │ │ │ - var lastZoom = this.map.getZoom(), │ │ │ │ - size = this.map.getSize(), │ │ │ │ - centerPx = { │ │ │ │ - x: size.w / 2, │ │ │ │ - y: size.h / 2 │ │ │ │ - }, │ │ │ │ - zoom = this.map.getZoomForExtent(bounds), │ │ │ │ - oldRes = this.map.getResolution(), │ │ │ │ - newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ - if (oldRes == newRes) { │ │ │ │ - this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)); │ │ │ │ - } else { │ │ │ │ - var zoomOriginPx = { │ │ │ │ - x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / │ │ │ │ - (oldRes - newRes), │ │ │ │ - y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / │ │ │ │ - (oldRes - newRes) │ │ │ │ - }; │ │ │ │ - this.map.zoomTo(zoom, zoomOriginPx); │ │ │ │ + var values = srs.split(/ +/); │ │ │ │ + for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ + layerContext.projections[values[i]] = true; │ │ │ │ } │ │ │ │ - if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ - this.map.zoomTo(lastZoom + (this.out ? -1 : 1)); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: write_wmc_Layer │ │ │ │ + * Create a Layer node given a layer context object. This method adds │ │ │ │ + * elements specific to version 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} A layer context object.} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC Layer element node. │ │ │ │ + */ │ │ │ │ + write_wmc_Layer: function(context) { │ │ │ │ + var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply( │ │ │ │ + this, [context] │ │ │ │ + ); │ │ │ │ + │ │ │ │ + // optional SRS element(s) │ │ │ │ + if (context.srs) { │ │ │ │ + var projections = []; │ │ │ │ + for (var name in context.srs) { │ │ │ │ + projections.push(name); │ │ │ │ + } │ │ │ │ + node.appendChild(this.createElementDefaultNS("SRS", projections.join(" "))); │ │ │ │ } │ │ │ │ - } else if (this.zoomOnClick) { // it's a pixel │ │ │ │ - if (!this.out) { │ │ │ │ - this.map.zoomTo(this.map.getZoom() + 1, position); │ │ │ │ - } else { │ │ │ │ - this.map.zoomTo(this.map.getZoom() - 1, position); │ │ │ │ + │ │ │ │ + // optional FormatList element │ │ │ │ + node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ + │ │ │ │ + // optional StyleList element │ │ │ │ + node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ + │ │ │ │ + // optional DimensionList element │ │ │ │ + if (context.dimensions) { │ │ │ │ + node.appendChild(this.write_wmc_DimensionList(context)); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ -}); │ │ │ │ + // OpenLayers specific properties go in an Extension element │ │ │ │ + node.appendChild(this.write_wmc_LayerExtension(context)); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC.v1_0_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/DragPan.js │ │ │ │ + OpenLayers/Format/WMC/v1_1_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ + * @requires OpenLayers/Format/WMC/v1.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.DragPan │ │ │ │ - * The DragPan control pans the map with a drag of the mouse. │ │ │ │ + * Class: OpenLayers.Format.WMC.v1_1_0 │ │ │ │ + * Read and write WMC version 1.1.0. │ │ │ │ * │ │ │ │ + * Differences between 1.1.0 and 1.0.0: │ │ │ │ + * - 1.1.0 Layers have optional sld:MinScaleDenominator and │ │ │ │ + * sld:MaxScaleDenominator │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.WMC.v1> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: type │ │ │ │ - * {OpenLayers.Control.TYPES} │ │ │ │ - */ │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: panned │ │ │ │ - * {Boolean} The map moved. │ │ │ │ - */ │ │ │ │ - panned: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: interval │ │ │ │ - * {Integer} The number of milliseconds that should ellapse before │ │ │ │ - * panning the map again. Defaults to 0 milliseconds, which means that │ │ │ │ - * no separate cycle is used for panning. In most cases you won't want │ │ │ │ - * to change this value. For slow machines/devices larger values can be │ │ │ │ - * tried out. │ │ │ │ - */ │ │ │ │ - interval: 0, │ │ │ │ +OpenLayers.Format.WMC.v1_1_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMC.v1, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} If set to true, mouse dragging will continue even if the │ │ │ │ - * mouse cursor leaves the map viewport. Default is false. │ │ │ │ - */ │ │ │ │ - documentDrag: false, │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.1.0 │ │ │ │ + */ │ │ │ │ + VERSION: "1.1.0", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: kinetic │ │ │ │ - * {<OpenLayers.Kinetic>} The OpenLayers.Kinetic object. │ │ │ │ - */ │ │ │ │ - kinetic: null, │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/context │ │ │ │ + * http://schemas.opengis.net/context/1.1.0/context.xsd │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.1.0/context.xsd", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: enableKinetic │ │ │ │ - * {Boolean} Set this option to enable "kinetic dragging". Can be │ │ │ │ - * set to true or to an object. If set to an object this │ │ │ │ - * object will be passed to the {<OpenLayers.Kinetic>} │ │ │ │ - * constructor. Defaults to true. │ │ │ │ - * To get kinetic dragging, ensure that OpenLayers/Kinetic.js is │ │ │ │ - * included in your build config. │ │ │ │ - */ │ │ │ │ - enableKinetic: true, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMC.v1_1_0 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.WMC> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.WMC.v1.prototype.initialize.apply( │ │ │ │ + this, [options] │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: kineticInterval │ │ │ │ - * {Integer} Interval in milliseconds between 2 steps in the "kinetic │ │ │ │ - * scrolling". Applies only if enableKinetic is set. Defaults │ │ │ │ - * to 10 milliseconds. │ │ │ │ - */ │ │ │ │ - kineticInterval: 10, │ │ │ │ + /** │ │ │ │ + * Method: read_sld_MinScaleDenominator │ │ │ │ + * Read a sld:MinScaleDenominator node. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layerContext - {Object} An object representing a layer. │ │ │ │ + * node - {Element} An element node. │ │ │ │ + */ │ │ │ │ + read_sld_MinScaleDenominator: function(layerContext, node) { │ │ │ │ + var minScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ + if (minScaleDenominator > 0) { │ │ │ │ + layerContext.maxScale = minScaleDenominator; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Method: read_sld_MaxScaleDenominator │ │ │ │ + * Read a sld:MaxScaleDenominator node. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layerContext - {Object} An object representing a layer. │ │ │ │ + * node - {Element} An element node. │ │ │ │ + */ │ │ │ │ + read_sld_MaxScaleDenominator: function(layerContext, node) { │ │ │ │ + layerContext.minScale = parseFloat(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * Creates a Drag handler, using <panMap> and │ │ │ │ - * <panMapDone> as callbacks. │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ - var config = { │ │ │ │ - interval: this.kineticInterval │ │ │ │ - }; │ │ │ │ - if (typeof this.enableKinetic === "object") { │ │ │ │ - config = OpenLayers.Util.extend(config, this.enableKinetic); │ │ │ │ + /** │ │ │ │ + * Method: read_wmc_SRS │ │ │ │ + */ │ │ │ │ + read_wmc_SRS: function(layerContext, node) { │ │ │ │ + if (!("srs" in layerContext)) { │ │ │ │ + layerContext.srs = {}; │ │ │ │ } │ │ │ │ - this.kinetic = new OpenLayers.Kinetic(config); │ │ │ │ - } │ │ │ │ - this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ - "move": this.panMap, │ │ │ │ - "done": this.panMapDone, │ │ │ │ - "down": this.panMapStart │ │ │ │ - }, { │ │ │ │ - interval: this.interval, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + layerContext.srs[this.getChildValue(node)] = true; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: panMapStart │ │ │ │ - */ │ │ │ │ - panMapStart: function() { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.begin(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: write_wmc_Layer │ │ │ │ + * Create a Layer node given a layer context object. This method adds │ │ │ │ + * elements specific to version 1.1.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} A layer context object.} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Element} A WMC Layer element node. │ │ │ │ + */ │ │ │ │ + write_wmc_Layer: function(context) { │ │ │ │ + var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply( │ │ │ │ + this, [context] │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: panMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ - */ │ │ │ │ - panMap: function(xy) { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.update(xy); │ │ │ │ - } │ │ │ │ - this.panned = true; │ │ │ │ - this.map.pan( │ │ │ │ - this.handler.last.x - xy.x, │ │ │ │ - this.handler.last.y - xy.y, { │ │ │ │ - dragging: true, │ │ │ │ - animate: false │ │ │ │ + // min/max scale denominator elements go before the 4th element in v1 │ │ │ │ + if (context.maxScale) { │ │ │ │ + var minSD = this.createElementNS( │ │ │ │ + this.namespaces.sld, "sld:MinScaleDenominator" │ │ │ │ + ); │ │ │ │ + minSD.appendChild(this.createTextNode(context.maxScale.toPrecision(16))); │ │ │ │ + node.appendChild(minSD); │ │ │ │ } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: panMapDone │ │ │ │ - * Finish the panning operation. Only call setCenter (through <panMap>) │ │ │ │ - * if the map has actually been moved. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ - */ │ │ │ │ - panMapDone: function(xy) { │ │ │ │ - if (this.panned) { │ │ │ │ - var res = null; │ │ │ │ - if (this.kinetic) { │ │ │ │ - res = this.kinetic.end(xy); │ │ │ │ + if (context.minScale) { │ │ │ │ + var maxSD = this.createElementNS( │ │ │ │ + this.namespaces.sld, "sld:MaxScaleDenominator" │ │ │ │ + ); │ │ │ │ + maxSD.appendChild(this.createTextNode(context.minScale.toPrecision(16))); │ │ │ │ + node.appendChild(maxSD); │ │ │ │ } │ │ │ │ - this.map.pan( │ │ │ │ - this.handler.last.x - xy.x, │ │ │ │ - this.handler.last.y - xy.y, { │ │ │ │ - dragging: !!res, │ │ │ │ - animate: false │ │ │ │ + │ │ │ │ + // optional SRS element(s) │ │ │ │ + if (context.srs) { │ │ │ │ + for (var name in context.srs) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("SRS", name)); │ │ │ │ } │ │ │ │ - ); │ │ │ │ - if (res) { │ │ │ │ - var self = this; │ │ │ │ - this.kinetic.move(res, function(x, y, end) { │ │ │ │ - self.map.pan(x, y, { │ │ │ │ - dragging: !end, │ │ │ │ - animate: false │ │ │ │ - }); │ │ │ │ - }); │ │ │ │ } │ │ │ │ - this.panned = false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ -}); │ │ │ │ + // optional FormatList element │ │ │ │ + node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ + │ │ │ │ + // optional StyleList element │ │ │ │ + node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ + │ │ │ │ + // optional DimensionList element │ │ │ │ + if (context.dimensions) { │ │ │ │ + node.appendChild(this.write_wmc_DimensionList(context)); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // OpenLayers specific properties go in an Extension element │ │ │ │ + node.appendChild(this.write_wmc_LayerExtension(context)); │ │ │ │ + │ │ │ │ + return node; │ │ │ │ + │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC.v1_1_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/MouseWheel.js │ │ │ │ + OpenLayers/Format/GML/v2.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Format/GML/Base.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.MouseWheel │ │ │ │ - * Handler for wheel up/down events. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Format.GML.v2 │ │ │ │ + * Parses GML version 2. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Format.GML.Base> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - /** │ │ │ │ - * Property: wheelListener │ │ │ │ - * {function} │ │ │ │ - */ │ │ │ │ - wheelListener: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: interval │ │ │ │ - * {Integer} In order to increase server performance, an interval (in │ │ │ │ - * milliseconds) can be set to reduce the number of up/down events │ │ │ │ - * called. If set, a new up/down event will not be set until the │ │ │ │ - * interval has passed. │ │ │ │ - * Defaults to 0, meaning no interval. │ │ │ │ - */ │ │ │ │ - interval: 0, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: maxDelta │ │ │ │ - * {Integer} Maximum delta to collect before breaking from the current │ │ │ │ - * interval. In cumulative mode, this also limits the maximum delta │ │ │ │ - * returned from the handler. Default is Number.POSITIVE_INFINITY. │ │ │ │ - */ │ │ │ │ - maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: delta │ │ │ │ - * {Integer} When interval is set, delta collects the mousewheel z-deltas │ │ │ │ - * of the events that occur within the interval. │ │ │ │ - * See also the cumulative option │ │ │ │ - */ │ │ │ │ - delta: 0, │ │ │ │ +OpenLayers.Format.GML.v2 = OpenLayers.Class(OpenLayers.Format.GML.Base, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: cumulative │ │ │ │ - * {Boolean} When interval is set: true to collect all the mousewheel │ │ │ │ - * z-deltas, false to only record the delta direction (positive or │ │ │ │ - * negative) │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location for a particular minor version. │ │ │ │ */ │ │ │ │ - cumulative: true, │ │ │ │ + schemaLocation: "http://www.opengis.net/gml http://schemas.opengis.net/gml/2.1.2/feature.xsd", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.MouseWheel │ │ │ │ + * Constructor: OpenLayers.Format.GML.v2 │ │ │ │ + * Create a parser for GML v2. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - * callbacks - {Object} An object containing a single function to be │ │ │ │ - * called when the drag operation is finished. │ │ │ │ - * The callback should expect to recieve a single │ │ │ │ - * argument, the point geometry. │ │ │ │ - * options - {Object} │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ + * featureNS - {String} Feature namespace (required). │ │ │ │ + * geometryName - {String} Geometry element name. │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.wheelListener = OpenLayers.Function.bindAsEventListener( │ │ │ │ - this.onWheelEvent, this │ │ │ │ - ); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.GML.Base.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ - this.wheelListener = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Mouse ScrollWheel code thanks to http://adomas.org/javascript-mouse-wheel/ │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ */ │ │ │ │ + readers: { │ │ │ │ + "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ + "outerBoundaryIs": function(node, container) { │ │ │ │ + var obj = {}; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + container.outer = obj.components[0]; │ │ │ │ + }, │ │ │ │ + "innerBoundaryIs": function(node, container) { │ │ │ │ + var obj = {}; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + container.inner.push(obj.components[0]); │ │ │ │ + }, │ │ │ │ + "Box": function(node, container) { │ │ │ │ + var obj = {}; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + if (!container.components) { │ │ │ │ + container.components = []; │ │ │ │ + } │ │ │ │ + var min = obj.points[0]; │ │ │ │ + var max = obj.points[1]; │ │ │ │ + container.components.push( │ │ │ │ + new OpenLayers.Bounds(min.x, min.y, max.x, max.y) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.GML.Base.prototype.readers["gml"]), │ │ │ │ + "feature": OpenLayers.Format.GML.Base.prototype.readers["feature"], │ │ │ │ + "wfs": OpenLayers.Format.GML.Base.prototype.readers["wfs"] │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onWheelEvent │ │ │ │ - * Catch the wheel event and handle it xbrowserly │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: write │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>) | OpenLayers.Feature.Vector} │ │ │ │ + * An array of features or a single feature. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} Given an array of features, a doc with a gml:featureMembers │ │ │ │ + * element will be returned. Given a single feature, a doc with a │ │ │ │ + * gml:featureMember element will be returned. │ │ │ │ */ │ │ │ │ - onWheelEvent: function(e) { │ │ │ │ - │ │ │ │ - // make sure we have a map and check keyboard modifiers │ │ │ │ - if (!this.map || !this.checkModifiers(e)) { │ │ │ │ - return; │ │ │ │ + write: function(features) { │ │ │ │ + var name; │ │ │ │ + if (OpenLayers.Util.isArray(features)) { │ │ │ │ + // GML2 only has abstract feature collections │ │ │ │ + // wfs provides a feature collection from a well-known schema │ │ │ │ + name = "wfs:FeatureCollection"; │ │ │ │ + } else { │ │ │ │ + name = "gml:featureMember"; │ │ │ │ } │ │ │ │ + var root = this.writeNode(name, features); │ │ │ │ + this.setAttributeNS( │ │ │ │ + root, this.namespaces["xsi"], │ │ │ │ + "xsi:schemaLocation", this.schemaLocation │ │ │ │ + ); │ │ │ │ │ │ │ │ - // Ride up the element's DOM hierarchy to determine if it or any of │ │ │ │ - // its ancestors was: │ │ │ │ - // * specifically marked as scrollable (CSS overflow property) │ │ │ │ - // * one of our layer divs or a div marked as scrollable │ │ │ │ - // ('olScrollable' CSS class) │ │ │ │ - // * the map div │ │ │ │ - // │ │ │ │ - var overScrollableDiv = false; │ │ │ │ - var allowScroll = false; │ │ │ │ - var overMapDiv = false; │ │ │ │ - │ │ │ │ - var elem = OpenLayers.Event.element(e); │ │ │ │ - while ((elem != null) && !overMapDiv && !overScrollableDiv) { │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root]); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!overScrollableDiv) { │ │ │ │ - try { │ │ │ │ - var overflow; │ │ │ │ - if (elem.currentStyle) { │ │ │ │ - overflow = elem.currentStyle["overflow"]; │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: { │ │ │ │ + "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ + "Point": function(geometry) { │ │ │ │ + var node = this.createElementNSPlus("gml:Point"); │ │ │ │ + this.writeNode("coordinates", [geometry], node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "coordinates": function(points) { │ │ │ │ + var numPoints = points.length; │ │ │ │ + var parts = new Array(numPoints); │ │ │ │ + var point; │ │ │ │ + for (var i = 0; i < numPoints; ++i) { │ │ │ │ + point = points[i]; │ │ │ │ + if (this.xy) { │ │ │ │ + parts[i] = point.x + "," + point.y; │ │ │ │ } else { │ │ │ │ - var style = │ │ │ │ - document.defaultView.getComputedStyle(elem, null); │ │ │ │ - overflow = style.getPropertyValue("overflow"); │ │ │ │ + parts[i] = point.y + "," + point.x; │ │ │ │ } │ │ │ │ - overScrollableDiv = (overflow && │ │ │ │ - (overflow == "auto") || (overflow == "scroll")); │ │ │ │ - } catch (err) { │ │ │ │ - //sometimes when scrolling in a popup, this causes │ │ │ │ - // obscure browser error │ │ │ │ + if (point.z != undefined) { // allow null or undefined │ │ │ │ + parts[i] += "," + point.z; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return this.createElementNSPlus("gml:coordinates", { │ │ │ │ + attributes: { │ │ │ │ + decimal: ".", │ │ │ │ + cs: ",", │ │ │ │ + ts: " " │ │ │ │ + }, │ │ │ │ + value: (numPoints == 1) ? parts[0] : parts.join(" ") │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "LineString": function(geometry) { │ │ │ │ + var node = this.createElementNSPlus("gml:LineString"); │ │ │ │ + this.writeNode("coordinates", geometry.components, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Polygon": function(geometry) { │ │ │ │ + var node = this.createElementNSPlus("gml:Polygon"); │ │ │ │ + this.writeNode("outerBoundaryIs", geometry.components[0], node); │ │ │ │ + for (var i = 1; i < geometry.components.length; ++i) { │ │ │ │ + this.writeNode( │ │ │ │ + "innerBoundaryIs", geometry.components[i], node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "outerBoundaryIs": function(ring) { │ │ │ │ + var node = this.createElementNSPlus("gml:outerBoundaryIs"); │ │ │ │ + this.writeNode("LinearRing", ring, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "innerBoundaryIs": function(ring) { │ │ │ │ + var node = this.createElementNSPlus("gml:innerBoundaryIs"); │ │ │ │ + this.writeNode("LinearRing", ring, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "LinearRing": function(ring) { │ │ │ │ + var node = this.createElementNSPlus("gml:LinearRing"); │ │ │ │ + this.writeNode("coordinates", ring.components, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Box": function(bounds) { │ │ │ │ + var node = this.createElementNSPlus("gml:Box"); │ │ │ │ + this.writeNode("coordinates", [{ │ │ │ │ + x: bounds.left, │ │ │ │ + y: bounds.bottom │ │ │ │ + }, { │ │ │ │ + x: bounds.right, │ │ │ │ + y: bounds.top │ │ │ │ + }], node); │ │ │ │ + // srsName attribute is optional for gml:Box │ │ │ │ + if (this.srsName) { │ │ │ │ + node.setAttribute("srsName", this.srsName); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ } │ │ │ │ + }, OpenLayers.Format.GML.Base.prototype.writers["gml"]), │ │ │ │ + "feature": OpenLayers.Format.GML.Base.prototype.writers["feature"], │ │ │ │ + "wfs": OpenLayers.Format.GML.Base.prototype.writers["wfs"] │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!allowScroll) { │ │ │ │ - allowScroll = OpenLayers.Element.hasClass(elem, 'olScrollable'); │ │ │ │ - if (!allowScroll) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - // Are we in the layer div? Note that we have two cases │ │ │ │ - // here: one is to catch EventPane layers, which have a │ │ │ │ - // pane above the layer (layer.pane) │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (elem == layer.div || elem == layer.pane) { │ │ │ │ - allowScroll = true; │ │ │ │ - break; │ │ │ │ + CLASS_NAME: "OpenLayers.Format.GML.v2" │ │ │ │ + │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/GML/v2.js │ │ │ │ + * @requires OpenLayers/Format/Filter/v1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.Filter.v1_0_0 │ │ │ │ + * Write ogc:Filter version 1.0.0. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.GML.v2> │ │ │ │ + * - <OpenLayers.Format.Filter.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.Filter.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.GML.v2, OpenLayers.Format.Filter.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.0.0 │ │ │ │ + */ │ │ │ │ + VERSION: "1.0.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/ogc/filter/1.0.0/filter.xsd │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/ogc/filter/1.0.0/filter.xsd", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.Filter.v1_0_0 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.Filter> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.GML.v2.prototype.initialize.apply( │ │ │ │ + this, [options] │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "ogc": OpenLayers.Util.applyDefaults({ │ │ │ │ + "PropertyIsEqualTo": function(node, obj) { │ │ │ │ + var filter = new OpenLayers.Filter.Comparison({ │ │ │ │ + type: OpenLayers.Filter.Comparison.EQUAL_TO │ │ │ │ + }); │ │ │ │ + this.readChildNodes(node, filter); │ │ │ │ + obj.filters.push(filter); │ │ │ │ + }, │ │ │ │ + "PropertyIsNotEqualTo": function(node, obj) { │ │ │ │ + var filter = new OpenLayers.Filter.Comparison({ │ │ │ │ + type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO │ │ │ │ + }); │ │ │ │ + this.readChildNodes(node, filter); │ │ │ │ + obj.filters.push(filter); │ │ │ │ + }, │ │ │ │ + "PropertyIsLike": function(node, obj) { │ │ │ │ + var filter = new OpenLayers.Filter.Comparison({ │ │ │ │ + type: OpenLayers.Filter.Comparison.LIKE │ │ │ │ + }); │ │ │ │ + this.readChildNodes(node, filter); │ │ │ │ + var wildCard = node.getAttribute("wildCard"); │ │ │ │ + var singleChar = node.getAttribute("singleChar"); │ │ │ │ + var esc = node.getAttribute("escape"); │ │ │ │ + filter.value2regex(wildCard, singleChar, esc); │ │ │ │ + obj.filters.push(filter); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.Filter.v1.prototype.readers["ogc"]), │ │ │ │ + "gml": OpenLayers.Format.GML.v2.prototype.readers["gml"], │ │ │ │ + "feature": OpenLayers.Format.GML.v2.prototype.readers["feature"] │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: { │ │ │ │ + "ogc": OpenLayers.Util.applyDefaults({ │ │ │ │ + "PropertyIsEqualTo": function(filter) { │ │ │ │ + var node = this.createElementNSPlus("ogc:PropertyIsEqualTo"); │ │ │ │ + // no ogc:expression handling for PropertyName for now │ │ │ │ + this.writeNode("PropertyName", filter, node); │ │ │ │ + // handle Literals or Functions for now │ │ │ │ + this.writeOgcExpression(filter.value, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "PropertyIsNotEqualTo": function(filter) { │ │ │ │ + var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo"); │ │ │ │ + // no ogc:expression handling for PropertyName for now │ │ │ │ + this.writeNode("PropertyName", filter, node); │ │ │ │ + // handle Literals or Functions for now │ │ │ │ + this.writeOgcExpression(filter.value, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "PropertyIsLike": function(filter) { │ │ │ │ + var node = this.createElementNSPlus("ogc:PropertyIsLike", { │ │ │ │ + attributes: { │ │ │ │ + wildCard: "*", │ │ │ │ + singleChar: ".", │ │ │ │ + escape: "!" │ │ │ │ } │ │ │ │ + }); │ │ │ │ + // no ogc:expression handling for now │ │ │ │ + this.writeNode("PropertyName", filter, node); │ │ │ │ + // convert regex string to ogc string │ │ │ │ + this.writeNode("Literal", filter.regex2value(), node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "BBOX": function(filter) { │ │ │ │ + var node = this.createElementNSPlus("ogc:BBOX"); │ │ │ │ + // PropertyName is mandatory in 1.0.0, but e.g. GeoServer also │ │ │ │ + // accepts filters without it. When this is used with │ │ │ │ + // OpenLayers.Protocol.WFS, OpenLayers.Format.WFST will set a │ │ │ │ + // missing filter.property to the geometryName that is │ │ │ │ + // configured with the protocol, which defaults to "the_geom". │ │ │ │ + // So the only way to omit this mandatory property is to not │ │ │ │ + // set the property on the filter and to set the geometryName │ │ │ │ + // on the WFS protocol to null. The latter also happens when │ │ │ │ + // the protocol is configured without a geometryName and a │ │ │ │ + // featureNS. │ │ │ │ + filter.property && this.writeNode("PropertyName", filter, node); │ │ │ │ + var box = this.writeNode("gml:Box", filter.value, node); │ │ │ │ + if (filter.projection) { │ │ │ │ + box.setAttribute("srsName", filter.projection); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ } │ │ │ │ + }, OpenLayers.Format.Filter.v1.prototype.writers["ogc"]), │ │ │ │ + "gml": OpenLayers.Format.GML.v2.prototype.writers["gml"], │ │ │ │ + "feature": OpenLayers.Format.GML.v2.prototype.writers["feature"] │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: writeSpatial │ │ │ │ + * │ │ │ │ + * Read a {<OpenLayers.Filter.Spatial>} filter and converts it into XML. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {<OpenLayers.Filter.Spatial>} The filter. │ │ │ │ + * name - {String} Name of the generated XML element. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The created XML element. │ │ │ │ + */ │ │ │ │ + writeSpatial: function(filter, name) { │ │ │ │ + var node = this.createElementNSPlus("ogc:" + name); │ │ │ │ + this.writeNode("PropertyName", filter, node); │ │ │ │ + if (filter.value instanceof OpenLayers.Filter.Function) { │ │ │ │ + this.writeNode("Function", filter.value, node); │ │ │ │ + } else { │ │ │ │ + var child; │ │ │ │ + if (filter.value instanceof OpenLayers.Geometry) { │ │ │ │ + child = this.writeNode("feature:_geometry", filter.value).firstChild; │ │ │ │ + } else { │ │ │ │ + child = this.writeNode("gml:Box", filter.value); │ │ │ │ + } │ │ │ │ + if (filter.projection) { │ │ │ │ + child.setAttribute("srsName", filter.projection); │ │ │ │ + } │ │ │ │ + node.appendChild(child); │ │ │ │ } │ │ │ │ - overMapDiv = (elem == this.map.div); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ │ │ │ │ - elem = elem.parentNode; │ │ │ │ - } │ │ │ │ │ │ │ │ - // Logic below is the following: │ │ │ │ - // │ │ │ │ - // If we are over a scrollable div or not over the map div: │ │ │ │ - // * do nothing (let the browser handle scrolling) │ │ │ │ - // │ │ │ │ - // otherwise │ │ │ │ - // │ │ │ │ - // If we are over the layer div or a 'olScrollable' div: │ │ │ │ - // * zoom/in out │ │ │ │ - // then │ │ │ │ - // * kill event (so as not to also scroll the page after zooming) │ │ │ │ - // │ │ │ │ - // otherwise │ │ │ │ - // │ │ │ │ - // Kill the event (dont scroll the page if we wheel over the │ │ │ │ - // layerswitcher or the pan/zoom control) │ │ │ │ - // │ │ │ │ - if (!overScrollableDiv && overMapDiv) { │ │ │ │ - if (allowScroll) { │ │ │ │ - var delta = 0; │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Filter.v1_0_0" │ │ │ │ │ │ │ │ - if (e.wheelDelta) { │ │ │ │ - delta = e.wheelDelta; │ │ │ │ - if (delta % 160 === 0) { │ │ │ │ - // opera have steps of 160 instead of 120 │ │ │ │ - delta = delta * 0.75; │ │ │ │ - } │ │ │ │ - delta = delta / 120; │ │ │ │ - } else if (e.detail) { │ │ │ │ - // detail in Firefox on OS X is 1/3 of Windows │ │ │ │ - // so force delta 1 / -1 │ │ │ │ - delta = -(e.detail / Math.abs(e.detail)); │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WFST/v1_0_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WFST/v1.js │ │ │ │ + * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WFST.v1_0_0 │ │ │ │ + * A format for creating WFS v1.0.0 transactions. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.WFST.v1_0_0> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.Filter.v1_0_0> │ │ │ │ + * - <OpenLayers.Format.WFST.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WFST.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.Filter.v1_0_0, OpenLayers.Format.WFST.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} WFS version number. │ │ │ │ + */ │ │ │ │ + version: "1.0.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: srsNameInQuery │ │ │ │ + * {Boolean} If true the reference system is passed in Query requests │ │ │ │ + * via the "srsName" attribute to the "wfs:Query" element, this │ │ │ │ + * property defaults to false as it isn't WFS 1.0.0 compliant. │ │ │ │ + */ │ │ │ │ + srsNameInQuery: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: schemaLocations │ │ │ │ + * {Object} Properties are namespace aliases, values are schema locations. │ │ │ │ + */ │ │ │ │ + schemaLocations: { │ │ │ │ + "wfs": "http://schemas.opengis.net/wfs/1.0.0/WFS-transaction.xsd" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WFST.v1_0_0 │ │ │ │ + * A class for parsing and generating WFS v1.0.0 transactions. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ + * featureNS - {String} Feature namespace (optional). │ │ │ │ + * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ + * if featureNS is provided). Default is 'feature'. │ │ │ │ + * geometryName - {String} Name of geometry attribute. Default is 'the_geom'. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.Filter.v1_0_0.prototype.initialize.apply(this, [options]); │ │ │ │ + OpenLayers.Format.WFST.v1.prototype.initialize.apply(this, [options]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: readNode │ │ │ │ + * Shorthand for applying one of the named readers given the node │ │ │ │ + * namespace and local name. Readers take two args (node, obj) and │ │ │ │ + * generally extend or modify the second. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} The node to be read (required). │ │ │ │ + * obj - {Object} The object to be modified (optional). │ │ │ │ + * first - {Boolean} Should be set to true for the first node read. This │ │ │ │ + * is usually the readNode call in the read method. Without this being │ │ │ │ + * set, auto-configured properties will stick on subsequent reads. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} The input object, modified (or a new one if none was provided). │ │ │ │ + */ │ │ │ │ + readNode: function(node, obj, first) { │ │ │ │ + // Not the superclass, only the mixin classes inherit from │ │ │ │ + // Format.GML.v2. We need this because we don't want to get readNode │ │ │ │ + // from the superclass's superclass, which is OpenLayers.Format.XML. │ │ │ │ + return OpenLayers.Format.GML.v2.prototype.readNode.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ + "WFS_TransactionResponse": function(node, obj) { │ │ │ │ + obj.insertIds = []; │ │ │ │ + obj.success = false; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "InsertResult": function(node, container) { │ │ │ │ + var obj = { │ │ │ │ + fids: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + container.insertIds = container.insertIds.concat(obj.fids); │ │ │ │ + }, │ │ │ │ + "TransactionResult": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Status": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "SUCCESS": function(node, obj) { │ │ │ │ + obj.success = true; │ │ │ │ } │ │ │ │ - this.delta += delta; │ │ │ │ + }, OpenLayers.Format.WFST.v1.prototype.readers["wfs"]), │ │ │ │ + "gml": OpenLayers.Format.GML.v2.prototype.readers["gml"], │ │ │ │ + "feature": OpenLayers.Format.GML.v2.prototype.readers["feature"], │ │ │ │ + "ogc": OpenLayers.Format.Filter.v1_0_0.prototype.readers["ogc"] │ │ │ │ + }, │ │ │ │ │ │ │ │ - window.clearTimeout(this._timeoutId); │ │ │ │ - if (this.interval && Math.abs(this.delta) < this.maxDelta) { │ │ │ │ - // store e because window.event might change during delay │ │ │ │ - var evt = OpenLayers.Util.extend({}, e); │ │ │ │ - this._timeoutId = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(function() { │ │ │ │ - this.wheelZoom(evt); │ │ │ │ - }, this), │ │ │ │ - this.interval │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.wheelZoom(e); │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: { │ │ │ │ + "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ + "Query": function(options) { │ │ │ │ + options = OpenLayers.Util.extend({ │ │ │ │ + featureNS: this.featureNS, │ │ │ │ + featurePrefix: this.featurePrefix, │ │ │ │ + featureType: this.featureType, │ │ │ │ + srsName: this.srsName, │ │ │ │ + srsNameInQuery: this.srsNameInQuery │ │ │ │ + }, options); │ │ │ │ + var prefix = options.featurePrefix; │ │ │ │ + var node = this.createElementNSPlus("wfs:Query", { │ │ │ │ + attributes: { │ │ │ │ + typeName: (prefix ? prefix + ":" : "") + │ │ │ │ + options.featureType │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.srsNameInQuery && options.srsName) { │ │ │ │ + node.setAttribute("srsName", options.srsName); │ │ │ │ + } │ │ │ │ + if (options.featureNS) { │ │ │ │ + node.setAttribute("xmlns:" + prefix, options.featureNS); │ │ │ │ + } │ │ │ │ + if (options.propertyNames) { │ │ │ │ + for (var i = 0, len = options.propertyNames.length; i < len; i++) { │ │ │ │ + this.writeNode( │ │ │ │ + "ogc:PropertyName", { │ │ │ │ + property: options.propertyNames[i] │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (options.filter) { │ │ │ │ + this.setFilterProperty(options.filter); │ │ │ │ + this.writeNode("ogc:Filter", options.filter, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ } │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + }, OpenLayers.Format.WFST.v1.prototype.writers["wfs"]), │ │ │ │ + "gml": OpenLayers.Format.GML.v2.prototype.writers["gml"], │ │ │ │ + "feature": OpenLayers.Format.GML.v2.prototype.writers["feature"], │ │ │ │ + "ogc": OpenLayers.Format.Filter.v1_0_0.prototype.writers["ogc"] │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: wheelZoom │ │ │ │ - * Given the wheel event, we carry out the appropriate zooming in or out, │ │ │ │ - * based on the 'wheelDelta' or 'detail' property of the event. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ - */ │ │ │ │ - wheelZoom: function(e) { │ │ │ │ - var delta = this.delta; │ │ │ │ - this.delta = 0; │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFST.v1_0_0" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WCSCapabilities/v1.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - if (delta) { │ │ │ │ - e.xy = this.map.events.getMousePosition(e); │ │ │ │ - if (delta < 0) { │ │ │ │ - this.callback("down", │ │ │ │ - [e, this.cumulative ? Math.max(-this.maxDelta, delta) : -1]); │ │ │ │ - } else { │ │ │ │ - this.callback("up", │ │ │ │ - [e, this.cumulative ? Math.min(this.maxDelta, delta) : 1]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: activate │ │ │ │ - */ │ │ │ │ - activate: function(evt) { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - //register mousewheel events specifically on the window and document │ │ │ │ - var wheelListener = this.wheelListener; │ │ │ │ - OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener); │ │ │ │ - OpenLayers.Event.observe(window, "mousewheel", wheelListener); │ │ │ │ - OpenLayers.Event.observe(document, "mousewheel", wheelListener); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WCSCapabilities.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - */ │ │ │ │ - deactivate: function(evt) { │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - // unregister mousewheel events specifically on the window and document │ │ │ │ - var wheelListener = this.wheelListener; │ │ │ │ - OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener); │ │ │ │ - OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WCSCapabilities.v1 │ │ │ │ + * Abstract class not to be instantiated directly. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WCSCapabilities.v1 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ -}); │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + splitSpace: (/\s+/) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + */ │ │ │ │ + defaultPrefix: "wcs", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return a list of coverages. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named coverages. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + var raw = data; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1" │ │ │ │ + │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Navigation.js │ │ │ │ + OpenLayers/Format/WCSCapabilities/v1_0_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/ZoomBox.js │ │ │ │ - * @requires OpenLayers/Control/DragPan.js │ │ │ │ - * @requires OpenLayers/Handler/MouseWheel.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Format/WCSCapabilities/v1.js │ │ │ │ + * @requires OpenLayers/Format/GML/v3.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Navigation │ │ │ │ - * The navigation control handles map browsing with mouse events (dragging, │ │ │ │ - * double-clicking, and scrolling the wheel). Create a new navigation │ │ │ │ - * control with the <OpenLayers.Control.Navigation> control. │ │ │ │ + * Class: OpenLayers.Format.WCSCapabilities/v1_0_0 │ │ │ │ + * Read WCS Capabilities version 1.0.0. │ │ │ │ * │ │ │ │ - * Note that this control is added to the map by default (if no controls │ │ │ │ - * array is sent in the options object to the <OpenLayers.Map> │ │ │ │ - * constructor). │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WCSCapabilities.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WCSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WCSCapabilities.v1_0_0 │ │ │ │ + * Create a new parser for WCS capabilities version 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + wcs: "http://www.opengis.net/wcs", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + ows: "http://www.opengis.net/ows" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: errorProperty │ │ │ │ + * {String} Which property of the returned object to check for in order to │ │ │ │ + * determine whether or not parsing has failed. In the case that the │ │ │ │ + * errorProperty is undefined on the returned object, the document will be │ │ │ │ + * run through an OGCExceptionReport parser. │ │ │ │ + */ │ │ │ │ + errorProperty: "service", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wcs": { │ │ │ │ + "WCS_Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Service": function(node, obj) { │ │ │ │ + obj.service = {}; │ │ │ │ + this.readChildNodes(node, obj.service); │ │ │ │ + }, │ │ │ │ + "name": function(node, service) { │ │ │ │ + service.name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "label": function(node, service) { │ │ │ │ + service.label = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "keywords": function(node, service) { │ │ │ │ + service.keywords = []; │ │ │ │ + this.readChildNodes(node, service.keywords); │ │ │ │ + }, │ │ │ │ + "keyword": function(node, keywords) { │ │ │ │ + // Append the keyword to the keywords list │ │ │ │ + keywords.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "responsibleParty": function(node, service) { │ │ │ │ + service.responsibleParty = {}; │ │ │ │ + this.readChildNodes(node, service.responsibleParty); │ │ │ │ + }, │ │ │ │ + "individualName": function(node, responsibleParty) { │ │ │ │ + responsibleParty.individualName = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "organisationName": function(node, responsibleParty) { │ │ │ │ + responsibleParty.organisationName = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "positionName": function(node, responsibleParty) { │ │ │ │ + responsibleParty.positionName = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "contactInfo": function(node, responsibleParty) { │ │ │ │ + responsibleParty.contactInfo = {}; │ │ │ │ + this.readChildNodes(node, responsibleParty.contactInfo); │ │ │ │ + }, │ │ │ │ + "phone": function(node, contactInfo) { │ │ │ │ + contactInfo.phone = {}; │ │ │ │ + this.readChildNodes(node, contactInfo.phone); │ │ │ │ + }, │ │ │ │ + "voice": function(node, phone) { │ │ │ │ + phone.voice = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "facsimile": function(node, phone) { │ │ │ │ + phone.facsimile = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "address": function(node, contactInfo) { │ │ │ │ + contactInfo.address = {}; │ │ │ │ + this.readChildNodes(node, contactInfo.address); │ │ │ │ + }, │ │ │ │ + "deliveryPoint": function(node, address) { │ │ │ │ + address.deliveryPoint = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "city": function(node, address) { │ │ │ │ + address.city = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "postalCode": function(node, address) { │ │ │ │ + address.postalCode = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "country": function(node, address) { │ │ │ │ + address.country = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "electronicMailAddress": function(node, address) { │ │ │ │ + address.electronicMailAddress = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "fees": function(node, service) { │ │ │ │ + service.fees = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "accessConstraints": function(node, service) { │ │ │ │ + service.accessConstraints = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContentMetadata": function(node, obj) { │ │ │ │ + obj.contentMetadata = []; │ │ │ │ + this.readChildNodes(node, obj.contentMetadata); │ │ │ │ + }, │ │ │ │ + "CoverageOfferingBrief": function(node, contentMetadata) { │ │ │ │ + var coverageOfferingBrief = {}; │ │ │ │ + this.readChildNodes(node, coverageOfferingBrief); │ │ │ │ + contentMetadata.push(coverageOfferingBrief); │ │ │ │ + }, │ │ │ │ + "name": function(node, coverageOfferingBrief) { │ │ │ │ + coverageOfferingBrief.name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "label": function(node, coverageOfferingBrief) { │ │ │ │ + coverageOfferingBrief.label = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "lonLatEnvelope": function(node, coverageOfferingBrief) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, "http://www.opengis.net/gml", "pos"); │ │ │ │ + │ │ │ │ + // We expect two nodes here, to create the corners of a bounding box │ │ │ │ + if (nodeList.length == 2) { │ │ │ │ + var min = {}; │ │ │ │ + var max = {}; │ │ │ │ + │ │ │ │ + OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[0], min]); │ │ │ │ + OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[1], max]); │ │ │ │ + │ │ │ │ + coverageOfferingBrief.lonLatEnvelope = {}; │ │ │ │ + coverageOfferingBrief.lonLatEnvelope.srsName = node.getAttribute("srsName"); │ │ │ │ + coverageOfferingBrief.lonLatEnvelope.min = min.points[0]; │ │ │ │ + coverageOfferingBrief.lonLatEnvelope.max = max.points[0]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_0_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WCSCapabilities/v1_1_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WCSCapabilities/v1.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WCSCapabilities/v1_1_0 │ │ │ │ + * Read WCS Capabilities version 1.1.0. │ │ │ │ * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WCSCapabilities.v1> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.WCSCapabilities.v1_1_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: dragPan │ │ │ │ - * {<OpenLayers.Control.DragPan>} │ │ │ │ - */ │ │ │ │ - dragPan: null, │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + wcs: "http://www.opengis.net/wcs/1.1", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + ows: "http://www.opengis.net/ows/1.1" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: dragPanOptions │ │ │ │ - * {Object} Options passed to the DragPan control. │ │ │ │ - */ │ │ │ │ - dragPanOptions: null, │ │ │ │ + /** │ │ │ │ + * APIProperty: errorProperty │ │ │ │ + * {String} Which property of the returned object to check for in order to │ │ │ │ + * determine whether or not parsing has failed. In the case that the │ │ │ │ + * errorProperty is undefined on the returned object, the document will be │ │ │ │ + * run through an OGCExceptionReport parser. │ │ │ │ + */ │ │ │ │ + errorProperty: "operationsMetadata", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: pinchZoom │ │ │ │ - * {<OpenLayers.Control.PinchZoom>} │ │ │ │ - */ │ │ │ │ - pinchZoom: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WCSCapabilities.v1_1_0 │ │ │ │ + * Create a new parser for WCS capabilities version 1.1.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: pinchZoomOptions │ │ │ │ - * {Object} Options passed to the PinchZoom control. │ │ │ │ - */ │ │ │ │ - pinchZoomOptions: null, │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wcs": OpenLayers.Util.applyDefaults({ │ │ │ │ + // In 1.0.0, this was WCS_Capabilties, in 1.1.0, it's Capabilities │ │ │ │ + "Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Contents": function(node, request) { │ │ │ │ + request.contentMetadata = []; │ │ │ │ + this.readChildNodes(node, request.contentMetadata); │ │ │ │ + }, │ │ │ │ + "CoverageSummary": function(node, contentMetadata) { │ │ │ │ + var coverageSummary = {}; │ │ │ │ + // Read the summary: │ │ │ │ + this.readChildNodes(node, coverageSummary); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} Allow panning of the map by dragging outside map viewport. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - documentDrag: false, │ │ │ │ + // Add it to the contentMetadata array: │ │ │ │ + contentMetadata.push(coverageSummary); │ │ │ │ + }, │ │ │ │ + "Identifier": function(node, coverageSummary) { │ │ │ │ + coverageSummary.identifier = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Title": function(node, coverageSummary) { │ │ │ │ + coverageSummary.title = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Abstract": function(node, coverageSummary) { │ │ │ │ + coverageSummary["abstract"] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "SupportedCRS": function(node, coverageSummary) { │ │ │ │ + var crs = this.getChildValue(node); │ │ │ │ + if (crs) { │ │ │ │ + if (!coverageSummary.supportedCRS) { │ │ │ │ + coverageSummary.supportedCRS = []; │ │ │ │ + } │ │ │ │ + coverageSummary.supportedCRS.push(crs); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "SupportedFormat": function(node, coverageSummary) { │ │ │ │ + var format = this.getChildValue(node); │ │ │ │ + if (format) { │ │ │ │ + if (!coverageSummary.supportedFormat) { │ │ │ │ + coverageSummary.supportedFormat = []; │ │ │ │ + } │ │ │ │ + coverageSummary.supportedFormat.push(format); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WCSCapabilities.v1.prototype.readers["wcs"]), │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: zoomBox │ │ │ │ - * {<OpenLayers.Control.ZoomBox>} │ │ │ │ - */ │ │ │ │ - zoomBox: null, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_1_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/CSWGetDomain/v2_0_2.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/CSWGetDomain.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.CSWGetDomain.v2_0_2 │ │ │ │ + * A format for creating CSWGetDomain v2.0.2 transactions. │ │ │ │ + * Create a new instance with the │ │ │ │ + * <OpenLayers.Format.CSWGetDomain.v2_0_2> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.CSWGetDomain.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomBoxEnabled │ │ │ │ - * {Boolean} Whether the user can draw a box to zoom │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - zoomBoxEnabled: true, │ │ │ │ + namespaces: { │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + csw: "http://www.opengis.net/cat/csw/2.0.2" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomWheelEnabled │ │ │ │ - * {Boolean} Whether the mousewheel should zoom the map │ │ │ │ + * Property: defaultPrefix │ │ │ │ + * {String} The default prefix (used by Format.XML). │ │ │ │ */ │ │ │ │ - zoomWheelEnabled: true, │ │ │ │ + defaultPrefix: "csw", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: mouseWheelOptions │ │ │ │ - * {Object} Options passed to the MouseWheel control (only useful if │ │ │ │ - * <zoomWheelEnabled> is set to true). Default is no options for maps │ │ │ │ - * with fractionalZoom set to true, otherwise │ │ │ │ - * {cumulative: false, interval: 50, maxDelta: 6} │ │ │ │ + * Property: version │ │ │ │ + * {String} CSW version number. │ │ │ │ */ │ │ │ │ - mouseWheelOptions: null, │ │ │ │ + version: "2.0.2", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handleRightClicks │ │ │ │ - * {Boolean} Whether or not to handle right clicks. Default is false. │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/cat/csw/2.0.2 │ │ │ │ + * http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd │ │ │ │ */ │ │ │ │ - handleRightClicks: false, │ │ │ │ + schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomBoxKeyMask │ │ │ │ - * {Integer} <OpenLayers.Handler> key code of the key, which has to be │ │ │ │ - * pressed, while drawing the zoom box with the mouse on the screen. │ │ │ │ - * You should probably set handleRightClicks to true if you use this │ │ │ │ - * with MOD_CTRL, to disable the context menu for machines which use │ │ │ │ - * CTRL-Click as a right click. │ │ │ │ - * Default: <OpenLayers.Handler.MOD_SHIFT> │ │ │ │ + * APIProperty: PropertyName │ │ │ │ + * {String} Value of the csw:PropertyName element, used when │ │ │ │ + * writing a GetDomain document. │ │ │ │ */ │ │ │ │ - zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ + PropertyName: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * APIProperty: ParameterName │ │ │ │ + * {String} Value of the csw:ParameterName element, used when │ │ │ │ + * writing a GetDomain document. │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + ParameterName: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Navigation │ │ │ │ - * Create a new navigation control │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Format.CSWGetDomain.v2_0_2 │ │ │ │ + * A class for parsing and generating CSWGetDomain v2.0.2 transactions. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * the control │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * - PropertyName │ │ │ │ + * - ParameterName │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * APIMethod: read │ │ │ │ + * Parse the response from a GetDomain request. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - │ │ │ │ - if (this.dragPan) { │ │ │ │ - this.dragPan.destroy(); │ │ │ │ - } │ │ │ │ - this.dragPan = null; │ │ │ │ - │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.zoomBox.destroy(); │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ } │ │ │ │ - this.zoomBox = null; │ │ │ │ - │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.destroy(); │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ } │ │ │ │ - this.pinchZoom = null; │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + var obj = {}; │ │ │ │ + this.readNode(data, obj); │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - this.dragPan.activate(); │ │ │ │ - if (this.zoomWheelEnabled) { │ │ │ │ - this.handlers.wheel.activate(); │ │ │ │ - } │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - if (this.zoomBoxEnabled) { │ │ │ │ - this.zoomBox.activate(); │ │ │ │ - } │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.activate(); │ │ │ │ + readers: { │ │ │ │ + "csw": { │ │ │ │ + "GetDomainResponse": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "DomainValues": function(node, obj) { │ │ │ │ + if (!(OpenLayers.Util.isArray(obj.DomainValues))) { │ │ │ │ + obj.DomainValues = []; │ │ │ │ + } │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var domainValue = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + domainValue[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, domainValue); │ │ │ │ + obj.DomainValues.push(domainValue); │ │ │ │ + }, │ │ │ │ + "PropertyName": function(node, obj) { │ │ │ │ + obj.PropertyName = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ParameterName": function(node, obj) { │ │ │ │ + obj.ParameterName = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ListOfValues": function(node, obj) { │ │ │ │ + if (!(OpenLayers.Util.isArray(obj.ListOfValues))) { │ │ │ │ + obj.ListOfValues = []; │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, obj.ListOfValues); │ │ │ │ + }, │ │ │ │ + "Value": function(node, obj) { │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var value = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + value[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + } │ │ │ │ + value.value = this.getChildValue(node); │ │ │ │ + obj.push({ │ │ │ │ + Value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "ConceptualScheme": function(node, obj) { │ │ │ │ + obj.ConceptualScheme = {}; │ │ │ │ + this.readChildNodes(node, obj.ConceptualScheme); │ │ │ │ + }, │ │ │ │ + "Name": function(node, obj) { │ │ │ │ + obj.Name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Document": function(node, obj) { │ │ │ │ + obj.Document = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Authority": function(node, obj) { │ │ │ │ + obj.Authority = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "RangeOfValues": function(node, obj) { │ │ │ │ + obj.RangeOfValues = {}; │ │ │ │ + this.readChildNodes(node, obj.RangeOfValues); │ │ │ │ + }, │ │ │ │ + "MinValue": function(node, obj) { │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var value = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + value[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + } │ │ │ │ + value.value = this.getChildValue(node); │ │ │ │ + obj.MinValue = value; │ │ │ │ + }, │ │ │ │ + "MaxValue": function(node, obj) { │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var value = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + value[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + } │ │ │ │ + value.value = this.getChildValue(node); │ │ │ │ + obj.MaxValue = value; │ │ │ │ + } │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ + * APIMethod: write │ │ │ │ + * Given an configuration js object, write a CSWGetDomain request. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} A object mapping the request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A serialized CSWGetDomain request. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.deactivate(); │ │ │ │ - } │ │ │ │ - this.zoomBox.deactivate(); │ │ │ │ - this.dragPan.deactivate(); │ │ │ │ - this.handlers.click.deactivate(); │ │ │ │ - this.handlers.wheel.deactivate(); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ + write: function(options) { │ │ │ │ + var node = this.writeNode("csw:GetDomain", options); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - // disable right mouse context menu for support of right click events │ │ │ │ - if (this.handleRightClicks) { │ │ │ │ - this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var clickCallbacks = { │ │ │ │ - 'click': this.defaultClick, │ │ │ │ - 'dblclick': this.defaultDblClick, │ │ │ │ - 'dblrightclick': this.defaultDblRightClick │ │ │ │ - }; │ │ │ │ - var clickOptions = { │ │ │ │ - 'double': true, │ │ │ │ - 'stopDouble': true │ │ │ │ - }; │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ - this, clickCallbacks, clickOptions │ │ │ │ - ); │ │ │ │ - this.dragPan = new OpenLayers.Control.DragPan( │ │ │ │ - OpenLayers.Util.extend({ │ │ │ │ - map: this.map, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }, this.dragPanOptions) │ │ │ │ - ); │ │ │ │ - this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ - map: this.map, │ │ │ │ - keyMask: this.zoomBoxKeyMask │ │ │ │ - }); │ │ │ │ - this.dragPan.draw(); │ │ │ │ - this.zoomBox.draw(); │ │ │ │ - var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ - cumulative: false, │ │ │ │ - interval: 50, │ │ │ │ - maxDelta: 6 │ │ │ │ - }; │ │ │ │ - this.handlers.wheel = new OpenLayers.Handler.MouseWheel( │ │ │ │ - this, { │ │ │ │ - up: this.wheelUp, │ │ │ │ - down: this.wheelDown │ │ │ │ + writers: { │ │ │ │ + "csw": { │ │ │ │ + "GetDomain": function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:GetDomain", { │ │ │ │ + attributes: { │ │ │ │ + service: "CSW", │ │ │ │ + version: this.version │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.PropertyName || this.PropertyName) { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:PropertyName", │ │ │ │ + options.PropertyName || this.PropertyName, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } else if (options.ParameterName || this.ParameterName) { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:ParameterName", │ │ │ │ + options.ParameterName || this.ParameterName, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, options); │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ - OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions) │ │ │ │ - ); │ │ │ │ - if (OpenLayers.Control.PinchZoom) { │ │ │ │ - this.pinchZoom = new OpenLayers.Control.PinchZoom( │ │ │ │ - OpenLayers.Util.extend({ │ │ │ │ - map: this.map │ │ │ │ - }, this.pinchZoomOptions)); │ │ │ │ + "PropertyName": function(value) { │ │ │ │ + var node = this.createElementNSPlus("csw:PropertyName", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ParameterName": function(value) { │ │ │ │ + var node = this.createElementNSPlus("csw:ParameterName", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Format.CSWGetDomain.v2_0_2" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/ArcXML/Features.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/ArcXML.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.ArcXML.Features │ │ │ │ + * Read/Write ArcXML features. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.ArcXML.Features> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.ArcXML.Features = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: defaultClick │ │ │ │ + * Constructor: OpenLayers.Format.ArcXML.Features │ │ │ │ + * Create a new parser/writer for ArcXML Features. Create an instance of this class │ │ │ │ + * to get a set of features from an ArcXML response. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - defaultClick: function(evt) { │ │ │ │ - if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ - this.map.zoomOut(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: defaultDblClick │ │ │ │ + * APIMethod: read │ │ │ │ + * Read data from a string of ArcXML, and return a set of OpenLayers features. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} A collection of features. │ │ │ │ */ │ │ │ │ - defaultDblClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom + 1, evt.xy); │ │ │ │ - }, │ │ │ │ + read: function(data) { │ │ │ │ + var axl = new OpenLayers.Format.ArcXML(); │ │ │ │ + var parsed = axl.read(data); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: defaultDblRightClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - defaultDblRightClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom - 1, evt.xy); │ │ │ │ - }, │ │ │ │ + return parsed.features.feature; │ │ │ │ + } │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WPSCapabilities/v1_0_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: wheelChange │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * deltaZ - {Integer} │ │ │ │ - */ │ │ │ │ - wheelChange: function(evt, deltaZ) { │ │ │ │ - if (!this.map.fractionalZoom) { │ │ │ │ - deltaZ = Math.round(deltaZ); │ │ │ │ - } │ │ │ │ - var currentZoom = this.map.getZoom(), │ │ │ │ - newZoom = currentZoom + deltaZ; │ │ │ │ - newZoom = Math.max(newZoom, 0); │ │ │ │ - newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ - if (newZoom === currentZoom) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - this.map.zoomTo(newZoom, evt.xy); │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: wheelUp │ │ │ │ - * User spun scroll wheel up │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * delta - {Integer} │ │ │ │ - */ │ │ │ │ - wheelUp: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || 1); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WPSCapabilities.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: wheelDown │ │ │ │ - * User spun scroll wheel down │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * delta - {Integer} │ │ │ │ - */ │ │ │ │ - wheelDown: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || -1); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WPSCapabilities.v1_0_0 │ │ │ │ + * Read WPS Capabilities version 1.0.0. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WPSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: disableZoomBox │ │ │ │ - */ │ │ │ │ - disableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = false; │ │ │ │ - this.zoomBox.deactivate(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: enableZoomBox │ │ │ │ - */ │ │ │ │ - enableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.zoomBox.activate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: disableZoomWheel │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WPSCapabilities.v1_0_0 │ │ │ │ + * Create a new parser for WPS capabilities version 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + }, │ │ │ │ │ │ │ │ - disableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = false; │ │ │ │ - this.handlers.wheel.deactivate(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return info about the WPS. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Information about the WPS service. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: enableZoomWheel │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wps": { │ │ │ │ + "Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "ProcessOfferings": function(node, obj) { │ │ │ │ + obj.processOfferings = {}; │ │ │ │ + this.readChildNodes(node, obj.processOfferings); │ │ │ │ + }, │ │ │ │ + "Process": function(node, processOfferings) { │ │ │ │ + var processVersion = this.getAttributeNS(node, this.namespaces.wps, "processVersion"); │ │ │ │ + var process = { │ │ │ │ + processVersion: processVersion │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, process); │ │ │ │ + processOfferings[process.identifier] = process; │ │ │ │ + }, │ │ │ │ + "Languages": function(node, obj) { │ │ │ │ + obj.languages = []; │ │ │ │ + this.readChildNodes(node, obj.languages); │ │ │ │ + }, │ │ │ │ + "Default": function(node, languages) { │ │ │ │ + var language = { │ │ │ │ + isDefault: true │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, language); │ │ │ │ + languages.push(language); │ │ │ │ + }, │ │ │ │ + "Supported": function(node, languages) { │ │ │ │ + var language = {}; │ │ │ │ + this.readChildNodes(node, language); │ │ │ │ + languages.push(language); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ │ │ │ │ - enableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.wheel.activate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WPSCapabilities.v1_0_0" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ -}); │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/NavToolbar.js │ │ │ │ + OpenLayers/Format/WFSCapabilities/v1.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/Panel.js │ │ │ │ - * @requires OpenLayers/Control/Navigation.js │ │ │ │ - * @requires OpenLayers/Control/ZoomBox.js │ │ │ │ + * @requires OpenLayers/Format/WFSCapabilities.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.NavToolbar │ │ │ │ - * This Toolbar is an alternative to the Navigation control that displays │ │ │ │ - * the state of the control, and provides a UI for changing state to │ │ │ │ - * use the zoomBox via a Panel control. │ │ │ │ - * │ │ │ │ - * If you wish to change the properties of the Navigation control used │ │ │ │ - * in the NavToolbar, see: │ │ │ │ - * http://trac.openlayers.org/wiki/Toolbars#SubclassingNavToolbar │ │ │ │ + * Class: OpenLayers.Format.WFSCapabilities.v1 │ │ │ │ + * Abstract class not to be instantiated directly. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WFSCapabilities.v1 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + wfs: "http://www.opengis.net/wfs", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + ows: "http://www.opengis.net/ows" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: errorProperty │ │ │ │ + * {String} Which property of the returned object to check for in order to │ │ │ │ + * determine whether or not parsing has failed. In the case that the │ │ │ │ + * errorProperty is undefined on the returned object, the document will be │ │ │ │ + * run through an OGCExceptionReport parser. │ │ │ │ + */ │ │ │ │ + errorProperty: "featureTypeList", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + */ │ │ │ │ + defaultPrefix: "wfs", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WFSCapabilities.v1_1 │ │ │ │ + * Create an instance of one of the subclasses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return a list of layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named layers. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + var raw = data; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wfs": { │ │ │ │ + "WFS_Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "FeatureTypeList": function(node, request) { │ │ │ │ + request.featureTypeList = { │ │ │ │ + featureTypes: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, request.featureTypeList); │ │ │ │ + }, │ │ │ │ + "FeatureType": function(node, featureTypeList) { │ │ │ │ + var featureType = {}; │ │ │ │ + this.readChildNodes(node, featureType); │ │ │ │ + featureTypeList.featureTypes.push(featureType); │ │ │ │ + }, │ │ │ │ + "Name": function(node, obj) { │ │ │ │ + var name = this.getChildValue(node); │ │ │ │ + if (name) { │ │ │ │ + var parts = name.split(":"); │ │ │ │ + obj.name = parts.pop(); │ │ │ │ + if (parts.length > 0) { │ │ │ │ + obj.featureNS = this.lookupNamespaceURI(node, parts[0]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Title": function(node, obj) { │ │ │ │ + var title = this.getChildValue(node); │ │ │ │ + if (title) { │ │ │ │ + obj.title = title; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Abstract": function(node, obj) { │ │ │ │ + var abst = this.getChildValue(node); │ │ │ │ + if (abst) { │ │ │ │ + obj["abstract"] = abst; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WFSCapabilities/v1_0_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WFSCapabilities/v1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WFSCapabilities/v1_0_0 │ │ │ │ + * Read WFS Capabilities version 1.0.0. │ │ │ │ * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WFSCapabilities.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WFSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WFSCapabilities.v1_0_0 │ │ │ │ + * Create a new parser for WFS capabilities version 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ + "Service": function(node, capabilities) { │ │ │ │ + capabilities.service = {}; │ │ │ │ + this.readChildNodes(node, capabilities.service); │ │ │ │ + }, │ │ │ │ + "Fees": function(node, service) { │ │ │ │ + var fees = this.getChildValue(node); │ │ │ │ + if (fees && fees.toLowerCase() != "none") { │ │ │ │ + service.fees = fees; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "AccessConstraints": function(node, service) { │ │ │ │ + var constraints = this.getChildValue(node); │ │ │ │ + if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ + service.accessConstraints = constraints; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "OnlineResource": function(node, service) { │ │ │ │ + var onlineResource = this.getChildValue(node); │ │ │ │ + if (onlineResource && onlineResource.toLowerCase() != "none") { │ │ │ │ + service.onlineResource = onlineResource; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Keywords": function(node, service) { │ │ │ │ + var keywords = this.getChildValue(node); │ │ │ │ + if (keywords && keywords.toLowerCase() != "none") { │ │ │ │ + service.keywords = keywords.split(', '); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Capability": function(node, capabilities) { │ │ │ │ + capabilities.capability = {}; │ │ │ │ + this.readChildNodes(node, capabilities.capability); │ │ │ │ + }, │ │ │ │ + "Request": function(node, obj) { │ │ │ │ + obj.request = {}; │ │ │ │ + this.readChildNodes(node, obj.request); │ │ │ │ + }, │ │ │ │ + "GetFeature": function(node, request) { │ │ │ │ + request.getfeature = { │ │ │ │ + href: {}, // DCPType │ │ │ │ + formats: [] // ResultFormat │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, request.getfeature); │ │ │ │ + }, │ │ │ │ + "ResultFormat": function(node, obj) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var childNode; │ │ │ │ + for (var i = 0; i < children.length; i++) { │ │ │ │ + childNode = children[i]; │ │ │ │ + if (childNode.nodeType == 1) { │ │ │ │ + obj.formats.push(childNode.nodeName); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "DCPType": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "HTTP": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj.href); │ │ │ │ + }, │ │ │ │ + "Get": function(node, obj) { │ │ │ │ + obj.get = node.getAttribute("onlineResource"); │ │ │ │ + }, │ │ │ │ + "Post": function(node, obj) { │ │ │ │ + obj.post = node.getAttribute("onlineResource"); │ │ │ │ + }, │ │ │ │ + "SRS": function(node, obj) { │ │ │ │ + var srs = this.getChildValue(node); │ │ │ │ + if (srs) { │ │ │ │ + obj.srs = srs; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_0_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WFSCapabilities/v1_1_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WFSCapabilities/v1.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WFSCapabilities/v1_1_0 │ │ │ │ + * Read WFS Capabilities version 1.1.0. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control.Panel> │ │ │ │ + * - <OpenLayers.Format.WFSCapabilities> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.NavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ +OpenLayers.Format.WFSCapabilities.v1_1_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Control.NavToolbar │ │ │ │ - * Add our two mousedefaults controls. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - this.addControls([ │ │ │ │ - new OpenLayers.Control.Navigation(), │ │ │ │ - new OpenLayers.Control.ZoomBox() │ │ │ │ - ]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * calls the default draw, and then activates mouse defaults. │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.defaultControl === null) { │ │ │ │ - this.defaultControl = this.controls[0]; │ │ │ │ - } │ │ │ │ - return div; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WFSCapabilities.v1_1_0 │ │ │ │ + * Create a new parser for WFS capabilities version 1.1.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.NavToolbar" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ + "DefaultSRS": function(node, obj) { │ │ │ │ + var defaultSRS = this.getChildValue(node); │ │ │ │ + if (defaultSRS) { │ │ │ │ + obj.srs = defaultSRS; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]), │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1.prototype.readers.ows │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_1_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/TransformFeature.js │ │ │ │ + OpenLayers/Format/WMTSCapabilities/v1_0_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMTSCapabilities.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Control/DragFeature.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * Class: OpenLayers.Format.WMTSCapabilities.v1_0_0 │ │ │ │ + * Read WMTS Capabilities version 1.0.0. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMTSCapabilities> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMTSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.OWSCommon.v1_1_0, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} The parser version ("1.0.0"). │ │ │ │ + */ │ │ │ │ + version: "1.0.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + wmts: "http://www.opengis.net/wmts/1.0", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: yx │ │ │ │ + * {Object} Members in the yx object are used to determine if a CRS URN │ │ │ │ + * corresponds to a CRS with y,x axis order. Member names are CRS URNs │ │ │ │ + * and values are boolean. Defaults come from the │ │ │ │ + * <OpenLayers.Format.WMTSCapabilities> prototype. │ │ │ │ + */ │ │ │ │ + yx: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + * {String} The default namespace alias for creating element nodes. │ │ │ │ + */ │ │ │ │ + defaultPrefix: "wmts", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMTSCapabilities.v1_0_0 │ │ │ │ + * Create a new parser for WMTS capabilities version 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options; │ │ │ │ + var yx = OpenLayers.Util.extend({}, OpenLayers.Format.WMTSCapabilities.prototype.yx); │ │ │ │ + this.yx = OpenLayers.Util.extend(yx, this.yx); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return info about the WMTS. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Information about the SOS service. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + capabilities.version = this.version; │ │ │ │ + return capabilities; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wmts": { │ │ │ │ + "Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Contents": function(node, obj) { │ │ │ │ + obj.contents = {}; │ │ │ │ + obj.contents.layers = []; │ │ │ │ + obj.contents.tileMatrixSets = {}; │ │ │ │ + this.readChildNodes(node, obj.contents); │ │ │ │ + }, │ │ │ │ + "Layer": function(node, obj) { │ │ │ │ + var layer = { │ │ │ │ + styles: [], │ │ │ │ + formats: [], │ │ │ │ + dimensions: [], │ │ │ │ + tileMatrixSetLinks: [] │ │ │ │ + }; │ │ │ │ + layer.layers = []; │ │ │ │ + this.readChildNodes(node, layer); │ │ │ │ + obj.layers.push(layer); │ │ │ │ + }, │ │ │ │ + "Style": function(node, obj) { │ │ │ │ + var style = {}; │ │ │ │ + style.isDefault = (node.getAttribute("isDefault") === "true"); │ │ │ │ + this.readChildNodes(node, style); │ │ │ │ + obj.styles.push(style); │ │ │ │ + }, │ │ │ │ + "Format": function(node, obj) { │ │ │ │ + obj.formats.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "TileMatrixSetLink": function(node, obj) { │ │ │ │ + var tileMatrixSetLink = {}; │ │ │ │ + this.readChildNodes(node, tileMatrixSetLink); │ │ │ │ + obj.tileMatrixSetLinks.push(tileMatrixSetLink); │ │ │ │ + }, │ │ │ │ + "TileMatrixSet": function(node, obj) { │ │ │ │ + // node could be child of wmts:Contents or wmts:TileMatrixSetLink │ │ │ │ + // duck type wmts:Contents by looking for layers │ │ │ │ + if (obj.layers) { │ │ │ │ + // TileMatrixSet as object type in schema │ │ │ │ + var tileMatrixSet = { │ │ │ │ + matrixIds: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, tileMatrixSet); │ │ │ │ + obj.tileMatrixSets[tileMatrixSet.identifier] = tileMatrixSet; │ │ │ │ + } else { │ │ │ │ + // TileMatrixSet as string type in schema │ │ │ │ + obj.tileMatrixSet = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "TileMatrix": function(node, obj) { │ │ │ │ + var tileMatrix = { │ │ │ │ + supportedCRS: obj.supportedCRS │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, tileMatrix); │ │ │ │ + obj.matrixIds.push(tileMatrix); │ │ │ │ + }, │ │ │ │ + "ScaleDenominator": function(node, obj) { │ │ │ │ + obj.scaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "TopLeftCorner": function(node, obj) { │ │ │ │ + var topLeftCorner = this.getChildValue(node); │ │ │ │ + var coords = topLeftCorner.split(" "); │ │ │ │ + // decide on axis order for the given CRS │ │ │ │ + var yx; │ │ │ │ + if (obj.supportedCRS) { │ │ │ │ + // extract out version from URN │ │ │ │ + var crs = obj.supportedCRS.replace( │ │ │ │ + /urn:ogc:def:crs:(\w+):.+:(\w+)$/, │ │ │ │ + "urn:ogc:def:crs:$1::$2" │ │ │ │ + ); │ │ │ │ + yx = !!this.yx[crs]; │ │ │ │ + } │ │ │ │ + if (yx) { │ │ │ │ + obj.topLeftCorner = new OpenLayers.LonLat( │ │ │ │ + coords[1], coords[0] │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + obj.topLeftCorner = new OpenLayers.LonLat( │ │ │ │ + coords[0], coords[1] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "TileWidth": function(node, obj) { │ │ │ │ + obj.tileWidth = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "TileHeight": function(node, obj) { │ │ │ │ + obj.tileHeight = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "MatrixWidth": function(node, obj) { │ │ │ │ + obj.matrixWidth = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "MatrixHeight": function(node, obj) { │ │ │ │ + obj.matrixHeight = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "ResourceURL": function(node, obj) { │ │ │ │ + obj.resourceUrl = obj.resourceUrl || {}; │ │ │ │ + var resourceType = node.getAttribute("resourceType"); │ │ │ │ + if (!obj.resourceUrls) { │ │ │ │ + obj.resourceUrls = []; │ │ │ │ + } │ │ │ │ + var resourceUrl = obj.resourceUrl[resourceType] = { │ │ │ │ + format: node.getAttribute("format"), │ │ │ │ + template: node.getAttribute("template"), │ │ │ │ + resourceType: resourceType │ │ │ │ + }; │ │ │ │ + obj.resourceUrls.push(resourceUrl); │ │ │ │ + }, │ │ │ │ + // not used for now, can be added in the future though │ │ │ │ + /*"Themes": function(node, obj) { │ │ │ │ + obj.themes = []; │ │ │ │ + this.readChildNodes(node, obj.themes); │ │ │ │ + }, │ │ │ │ + "Theme": function(node, obj) { │ │ │ │ + var theme = {}; │ │ │ │ + this.readChildNodes(node, theme); │ │ │ │ + obj.push(theme); │ │ │ │ + },*/ │ │ │ │ + "WSDL": function(node, obj) { │ │ │ │ + obj.wsdl = {}; │ │ │ │ + obj.wsdl.href = node.getAttribute("xlink:href"); │ │ │ │ + // TODO: other attributes of <WSDL> element │ │ │ │ + }, │ │ │ │ + "ServiceMetadataURL": function(node, obj) { │ │ │ │ + obj.serviceMetadataUrl = {}; │ │ │ │ + obj.serviceMetadataUrl.href = node.getAttribute("xlink:href"); │ │ │ │ + // TODO: other attributes of <ServiceMetadataURL> element │ │ │ │ + }, │ │ │ │ + "LegendURL": function(node, obj) { │ │ │ │ + obj.legend = {}; │ │ │ │ + obj.legend.href = node.getAttribute("xlink:href"); │ │ │ │ + obj.legend.format = node.getAttribute("format"); │ │ │ │ + }, │ │ │ │ + "Dimension": function(node, obj) { │ │ │ │ + var dimension = { │ │ │ │ + values: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, dimension); │ │ │ │ + obj.dimensions.push(dimension); │ │ │ │ + }, │ │ │ │ + "Default": function(node, obj) { │ │ │ │ + obj["default"] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Value": function(node, obj) { │ │ │ │ + obj.values.push(this.getChildValue(node)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMTSCapabilities.v1_0_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities.js │ │ │ │ + * @requires OpenLayers/Format/OGCExceptionReport.js │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.TransformFeature │ │ │ │ - * Control to transform features with a standard transformation box. │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities.v1 │ │ │ │ + * Abstract class not to be instantiated directly. Creates │ │ │ │ + * the common parts for both WMS 1.1.X and WMS 1.3.X. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XML, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + */ │ │ │ │ + namespaces: { │ │ │ │ + wms: "http://www.opengis.net/wms", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + */ │ │ │ │ + defaultPrefix: "wms", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMSCapabilities.v1 │ │ │ │ + * Create an instance of one of the subclasses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return a list of layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} List of named layers. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + var raw = data; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + if (capabilities.service === undefined) { │ │ │ │ + // an exception must have occurred, so parse it │ │ │ │ + var parser = new OpenLayers.Format.OGCExceptionReport(); │ │ │ │ + capabilities.error = parser.read(raw); │ │ │ │ + } │ │ │ │ + return capabilities; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wms": { │ │ │ │ + "Service": function(node, obj) { │ │ │ │ + obj.service = {}; │ │ │ │ + this.readChildNodes(node, obj.service); │ │ │ │ + }, │ │ │ │ + "Name": function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Title": function(node, obj) { │ │ │ │ + obj.title = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Abstract": function(node, obj) { │ │ │ │ + obj["abstract"] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "BoundingBox": function(node, obj) { │ │ │ │ + var bbox = {}; │ │ │ │ + bbox.bbox = [ │ │ │ │ + parseFloat(node.getAttribute("minx")), │ │ │ │ + parseFloat(node.getAttribute("miny")), │ │ │ │ + parseFloat(node.getAttribute("maxx")), │ │ │ │ + parseFloat(node.getAttribute("maxy")) │ │ │ │ + ]; │ │ │ │ + var res = { │ │ │ │ + x: parseFloat(node.getAttribute("resx")), │ │ │ │ + y: parseFloat(node.getAttribute("resy")) │ │ │ │ + }; │ │ │ │ + │ │ │ │ + if (!(isNaN(res.x) && isNaN(res.y))) { │ │ │ │ + bbox.res = res; │ │ │ │ + } │ │ │ │ + // return the bbox so that descendant classes can set the │ │ │ │ + // CRS and SRS and add it to the obj │ │ │ │ + return bbox; │ │ │ │ + }, │ │ │ │ + "OnlineResource": function(node, obj) { │ │ │ │ + obj.href = this.getAttributeNS(node, this.namespaces.xlink, │ │ │ │ + "href"); │ │ │ │ + }, │ │ │ │ + "ContactInformation": function(node, obj) { │ │ │ │ + obj.contactInformation = {}; │ │ │ │ + this.readChildNodes(node, obj.contactInformation); │ │ │ │ + }, │ │ │ │ + "ContactPersonPrimary": function(node, obj) { │ │ │ │ + obj.personPrimary = {}; │ │ │ │ + this.readChildNodes(node, obj.personPrimary); │ │ │ │ + }, │ │ │ │ + "ContactPerson": function(node, obj) { │ │ │ │ + obj.person = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContactOrganization": function(node, obj) { │ │ │ │ + obj.organization = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContactPosition": function(node, obj) { │ │ │ │ + obj.position = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContactAddress": function(node, obj) { │ │ │ │ + obj.contactAddress = {}; │ │ │ │ + this.readChildNodes(node, obj.contactAddress); │ │ │ │ + }, │ │ │ │ + "AddressType": function(node, obj) { │ │ │ │ + obj.type = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Address": function(node, obj) { │ │ │ │ + obj.address = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "City": function(node, obj) { │ │ │ │ + obj.city = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "StateOrProvince": function(node, obj) { │ │ │ │ + obj.stateOrProvince = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "PostCode": function(node, obj) { │ │ │ │ + obj.postcode = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Country": function(node, obj) { │ │ │ │ + obj.country = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContactVoiceTelephone": function(node, obj) { │ │ │ │ + obj.phone = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContactFacsimileTelephone": function(node, obj) { │ │ │ │ + obj.fax = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "ContactElectronicMailAddress": function(node, obj) { │ │ │ │ + obj.email = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Fees": function(node, obj) { │ │ │ │ + var fees = this.getChildValue(node); │ │ │ │ + if (fees && fees.toLowerCase() != "none") { │ │ │ │ + obj.fees = fees; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "AccessConstraints": function(node, obj) { │ │ │ │ + var constraints = this.getChildValue(node); │ │ │ │ + if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ + obj.accessConstraints = constraints; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Capability": function(node, obj) { │ │ │ │ + obj.capability = { │ │ │ │ + nestedLayers: [], │ │ │ │ + layers: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.capability); │ │ │ │ + }, │ │ │ │ + "Request": function(node, obj) { │ │ │ │ + obj.request = {}; │ │ │ │ + this.readChildNodes(node, obj.request); │ │ │ │ + }, │ │ │ │ + "GetCapabilities": function(node, obj) { │ │ │ │ + obj.getcapabilities = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getcapabilities); │ │ │ │ + }, │ │ │ │ + "Format": function(node, obj) { │ │ │ │ + if (OpenLayers.Util.isArray(obj.formats)) { │ │ │ │ + obj.formats.push(this.getChildValue(node)); │ │ │ │ + } else { │ │ │ │ + obj.format = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "DCPType": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "HTTP": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Get": function(node, obj) { │ │ │ │ + obj.get = {}; │ │ │ │ + this.readChildNodes(node, obj.get); │ │ │ │ + // backwards compatibility │ │ │ │ + if (!obj.href) { │ │ │ │ + obj.href = obj.get.href; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Post": function(node, obj) { │ │ │ │ + obj.post = {}; │ │ │ │ + this.readChildNodes(node, obj.post); │ │ │ │ + // backwards compatibility │ │ │ │ + if (!obj.href) { │ │ │ │ + obj.href = obj.get.href; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "GetMap": function(node, obj) { │ │ │ │ + obj.getmap = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getmap); │ │ │ │ + }, │ │ │ │ + "GetFeatureInfo": function(node, obj) { │ │ │ │ + obj.getfeatureinfo = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getfeatureinfo); │ │ │ │ + }, │ │ │ │ + "Exception": function(node, obj) { │ │ │ │ + obj.exception = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.exception); │ │ │ │ + }, │ │ │ │ + "Layer": function(node, obj) { │ │ │ │ + var parentLayer, capability; │ │ │ │ + if (obj.capability) { │ │ │ │ + capability = obj.capability; │ │ │ │ + parentLayer = obj; │ │ │ │ + } else { │ │ │ │ + capability = obj; │ │ │ │ + } │ │ │ │ + var attrNode = node.getAttributeNode("queryable"); │ │ │ │ + var queryable = (attrNode && attrNode.specified) ? │ │ │ │ + node.getAttribute("queryable") : null; │ │ │ │ + attrNode = node.getAttributeNode("cascaded"); │ │ │ │ + var cascaded = (attrNode && attrNode.specified) ? │ │ │ │ + node.getAttribute("cascaded") : null; │ │ │ │ + attrNode = node.getAttributeNode("opaque"); │ │ │ │ + var opaque = (attrNode && attrNode.specified) ? │ │ │ │ + node.getAttribute('opaque') : null; │ │ │ │ + var noSubsets = node.getAttribute('noSubsets'); │ │ │ │ + var fixedWidth = node.getAttribute('fixedWidth'); │ │ │ │ + var fixedHeight = node.getAttribute('fixedHeight'); │ │ │ │ + var parent = parentLayer || {}, │ │ │ │ + extend = OpenLayers.Util.extend; │ │ │ │ + var layer = { │ │ │ │ + nestedLayers: [], │ │ │ │ + styles: parentLayer ? [].concat(parentLayer.styles) : [], │ │ │ │ + srs: parentLayer ? extend({}, parent.srs) : {}, │ │ │ │ + metadataURLs: [], │ │ │ │ + bbox: parentLayer ? extend({}, parent.bbox) : {}, │ │ │ │ + llbbox: parent.llbbox, │ │ │ │ + dimensions: parentLayer ? extend({}, parent.dimensions) : {}, │ │ │ │ + authorityURLs: parentLayer ? extend({}, parent.authorityURLs) : {}, │ │ │ │ + identifiers: {}, │ │ │ │ + keywords: [], │ │ │ │ + queryable: (queryable && queryable !== "") ? │ │ │ │ + (queryable === "1" || queryable === "true") : (parent.queryable || false), │ │ │ │ + cascaded: (cascaded !== null) ? parseInt(cascaded) : (parent.cascaded || 0), │ │ │ │ + opaque: opaque ? │ │ │ │ + (opaque === "1" || opaque === "true") : (parent.opaque || false), │ │ │ │ + noSubsets: (noSubsets !== null) ? │ │ │ │ + (noSubsets === "1" || noSubsets === "true") : (parent.noSubsets || false), │ │ │ │ + fixedWidth: (fixedWidth != null) ? │ │ │ │ + parseInt(fixedWidth) : (parent.fixedWidth || 0), │ │ │ │ + fixedHeight: (fixedHeight != null) ? │ │ │ │ + parseInt(fixedHeight) : (parent.fixedHeight || 0), │ │ │ │ + minScale: parent.minScale, │ │ │ │ + maxScale: parent.maxScale, │ │ │ │ + attribution: parent.attribution │ │ │ │ + }; │ │ │ │ + obj.nestedLayers.push(layer); │ │ │ │ + layer.capability = capability; │ │ │ │ + this.readChildNodes(node, layer); │ │ │ │ + delete layer.capability; │ │ │ │ + if (layer.name) { │ │ │ │ + var parts = layer.name.split(":"), │ │ │ │ + request = capability.request, │ │ │ │ + gfi = request.getfeatureinfo; │ │ │ │ + if (parts.length > 0) { │ │ │ │ + layer.prefix = parts[0]; │ │ │ │ + } │ │ │ │ + capability.layers.push(layer); │ │ │ │ + if (layer.formats === undefined) { │ │ │ │ + layer.formats = request.getmap.formats; │ │ │ │ + } │ │ │ │ + if (layer.infoFormats === undefined && gfi) { │ │ │ │ + layer.infoFormats = gfi.formats; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Attribution": function(node, obj) { │ │ │ │ + obj.attribution = {}; │ │ │ │ + this.readChildNodes(node, obj.attribution); │ │ │ │ + }, │ │ │ │ + "LogoURL": function(node, obj) { │ │ │ │ + obj.logo = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height") │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.logo); │ │ │ │ + }, │ │ │ │ + "Style": function(node, obj) { │ │ │ │ + var style = {}; │ │ │ │ + obj.styles.push(style); │ │ │ │ + this.readChildNodes(node, style); │ │ │ │ + }, │ │ │ │ + "LegendURL": function(node, obj) { │ │ │ │ + var legend = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height") │ │ │ │ + }; │ │ │ │ + obj.legend = legend; │ │ │ │ + this.readChildNodes(node, legend); │ │ │ │ + }, │ │ │ │ + "MetadataURL": function(node, obj) { │ │ │ │ + var metadataURL = { │ │ │ │ + type: node.getAttribute("type") │ │ │ │ + }; │ │ │ │ + obj.metadataURLs.push(metadataURL); │ │ │ │ + this.readChildNodes(node, metadataURL); │ │ │ │ + }, │ │ │ │ + "DataURL": function(node, obj) { │ │ │ │ + obj.dataURL = {}; │ │ │ │ + this.readChildNodes(node, obj.dataURL); │ │ │ │ + }, │ │ │ │ + "FeatureListURL": function(node, obj) { │ │ │ │ + obj.featureListURL = {}; │ │ │ │ + this.readChildNodes(node, obj.featureListURL); │ │ │ │ + }, │ │ │ │ + "AuthorityURL": function(node, obj) { │ │ │ │ + var name = node.getAttribute("name"); │ │ │ │ + var authority = {}; │ │ │ │ + this.readChildNodes(node, authority); │ │ │ │ + obj.authorityURLs[name] = authority.href; │ │ │ │ + }, │ │ │ │ + "Identifier": function(node, obj) { │ │ │ │ + var authority = node.getAttribute("authority"); │ │ │ │ + obj.identifiers[authority] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "KeywordList": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "SRS": function(node, obj) { │ │ │ │ + obj.srs[this.getChildValue(node)] = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1_1.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities/v1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities.v1_1 │ │ │ │ + * Abstract class not to be instantiated directly. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSCapabilities.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ + "WMT_MS_Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Keyword": function(node, obj) { │ │ │ │ + if (obj.keywords) { │ │ │ │ + obj.keywords.push(this.getChildValue(node)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "DescribeLayer": function(node, obj) { │ │ │ │ + obj.describelayer = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.describelayer); │ │ │ │ + }, │ │ │ │ + "GetLegendGraphic": function(node, obj) { │ │ │ │ + obj.getlegendgraphic = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getlegendgraphic); │ │ │ │ + }, │ │ │ │ + "GetStyles": function(node, obj) { │ │ │ │ + obj.getstyles = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getstyles); │ │ │ │ + }, │ │ │ │ + "PutStyles": function(node, obj) { │ │ │ │ + obj.putstyles = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.putstyles); │ │ │ │ + }, │ │ │ │ + "UserDefinedSymbolization": function(node, obj) { │ │ │ │ + var userSymbols = { │ │ │ │ + supportSLD: parseInt(node.getAttribute("SupportSLD")) == 1, │ │ │ │ + userLayer: parseInt(node.getAttribute("UserLayer")) == 1, │ │ │ │ + userStyle: parseInt(node.getAttribute("UserStyle")) == 1, │ │ │ │ + remoteWFS: parseInt(node.getAttribute("RemoteWFS")) == 1 │ │ │ │ + }; │ │ │ │ + obj.userSymbols = userSymbols; │ │ │ │ + }, │ │ │ │ + "LatLonBoundingBox": function(node, obj) { │ │ │ │ + obj.llbbox = [ │ │ │ │ + parseFloat(node.getAttribute("minx")), │ │ │ │ + parseFloat(node.getAttribute("miny")), │ │ │ │ + parseFloat(node.getAttribute("maxx")), │ │ │ │ + parseFloat(node.getAttribute("maxy")) │ │ │ │ + ]; │ │ │ │ + }, │ │ │ │ + "BoundingBox": function(node, obj) { │ │ │ │ + var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ + bbox.srs = node.getAttribute("SRS"); │ │ │ │ + obj.bbox[bbox.srs] = bbox; │ │ │ │ + }, │ │ │ │ + "ScaleHint": function(node, obj) { │ │ │ │ + var min = node.getAttribute("min"); │ │ │ │ + var max = node.getAttribute("max"); │ │ │ │ + var rad2 = Math.pow(2, 0.5); │ │ │ │ + var ipm = OpenLayers.INCHES_PER_UNIT["m"]; │ │ │ │ + if (min != 0) { │ │ │ │ + obj.maxScale = parseFloat( │ │ │ │ + ((min / rad2) * ipm * │ │ │ │ + OpenLayers.DOTS_PER_INCH).toPrecision(13) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (max != Number.POSITIVE_INFINITY) { │ │ │ │ + obj.minScale = parseFloat( │ │ │ │ + ((max / rad2) * ipm * │ │ │ │ + OpenLayers.DOTS_PER_INCH).toPrecision(13) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Dimension": function(node, obj) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + var dim = { │ │ │ │ + name: name, │ │ │ │ + units: node.getAttribute("units"), │ │ │ │ + unitsymbol: node.getAttribute("unitSymbol") │ │ │ │ + }; │ │ │ │ + obj.dimensions[dim.name] = dim; │ │ │ │ + }, │ │ │ │ + "Extent": function(node, obj) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + if (name in obj["dimensions"]) { │ │ │ │ + var extent = obj.dimensions[name]; │ │ │ │ + extent.nearestVal = │ │ │ │ + node.getAttribute("nearestValue") === "1"; │ │ │ │ + extent.multipleVal = │ │ │ │ + node.getAttribute("multipleValues") === "1"; │ │ │ │ + extent.current = node.getAttribute("current") === "1"; │ │ │ │ + extent["default"] = node.getAttribute("default") || ""; │ │ │ │ + var values = this.getChildValue(node); │ │ │ │ + extent.values = values.split(","); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1_1_1.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities/v1_1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities/v1_1_1 │ │ │ │ + * Read WMS Capabilities version 1.1.1. │ │ │ │ * │ │ │ │ - * Inherits From: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Note on <ScaleHint> parsing: If the 'min' attribute is set to "0", no │ │ │ │ + * maxScale will be set on the layer object. If the 'max' attribute is set to │ │ │ │ + * "Infinity", no minScale will be set. This makes it easy to create proper │ │ │ │ + * {<OpenLayers.Layer.WMS>} configurations directly from the layer object │ │ │ │ + * literals returned by this format, because no minScale/maxScale modifications │ │ │ │ + * need to be made. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSCapabilities.v1_1> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.TransformFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1_1 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforesetfeature - Triggered before a feature is set for │ │ │ │ - * tranformation. The feature will not be set if a listener returns │ │ │ │ - * false. Listeners receive a *feature* property, with the feature │ │ │ │ - * that will be set for transformation. Listeners are allowed to │ │ │ │ - * set the control's *scale*, *ratio* and *rotation* properties, │ │ │ │ - * which will set the initial scale, ratio and rotation of the │ │ │ │ - * feature, like the <setFeature> method's initialParams argument. │ │ │ │ - * setfeature - Triggered when a feature is set for tranformation. │ │ │ │ - * Listeners receive a *feature* property, with the feature that │ │ │ │ - * is now set for transformation. │ │ │ │ - * beforetransform - Triggered while dragging, before a feature is │ │ │ │ - * transformed. The feature will not be transformed if a listener │ │ │ │ - * returns false (but the box still will). Listeners receive one or │ │ │ │ - * more of *center*, *scale*, *ratio* and *rotation*. The *center* │ │ │ │ - * property is an <OpenLayers.Geometry.Point> object with the new │ │ │ │ - * center of the transformed feature, the others are Floats with the │ │ │ │ - * scale, ratio or rotation change since the last transformation. │ │ │ │ - * transform - Triggered while dragging, when a feature is transformed. │ │ │ │ - * Listeners receive an event object with one or more of *center*, │ │ │ │ - * scale*, *ratio* and *rotation*. The *center* property is an │ │ │ │ - * <OpenLayers.Geometry.Point> object with the new center of the │ │ │ │ - * transformed feature, the others are Floats with the scale, ratio │ │ │ │ - * or rotation change of the feature since the last transformation. │ │ │ │ - * transformcomplete - Triggered after dragging. Listeners receive │ │ │ │ - * an event object with the transformed *feature*. │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} The specific parser version. │ │ │ │ + */ │ │ │ │ + version: "1.1.1", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: geometryTypes │ │ │ │ - * {Array(String)} To restrict transformation to a limited set of geometry │ │ │ │ - * types, send a list of strings corresponding to the geometry class │ │ │ │ - * names. │ │ │ │ - */ │ │ │ │ - geometryTypes: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMSCapabilities.v1_1_1 │ │ │ │ + * Create a new parser for WMS capabilities version 1.1.1. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} │ │ │ │ - */ │ │ │ │ - layer: null, │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ + "SRS": function(node, obj) { │ │ │ │ + obj.srs[this.getChildValue(node)] = true; │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: preserveAspectRatio │ │ │ │ - * {Boolean} set to true to not change the feature's aspect ratio. │ │ │ │ - */ │ │ │ │ - preserveAspectRatio: false, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1" │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: rotate │ │ │ │ - * {Boolean} set to false if rotation should be disabled. Default is true. │ │ │ │ - * To be passed with the constructor or set when the control is not │ │ │ │ - * active. │ │ │ │ - */ │ │ │ │ - rotate: true, │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1_1_1_WMSC.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} Feature currently available for │ │ │ │ - * transformation. Read-only, use <setFeature> to set it manually. │ │ │ │ - */ │ │ │ │ - feature: null, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: renderIntent │ │ │ │ - * {String|Object} Render intent for the transformation box and │ │ │ │ - * handles. A symbolizer object can also be provided here. │ │ │ │ - */ │ │ │ │ - renderIntent: "temporary", │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities/v1_1_1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities/v1_1_1_WMSC │ │ │ │ + * Read WMS-C Capabilities version 1.1.1. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSCapabilities.v1_1_1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSCapabilities.v1_1_1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} The specific parser version. │ │ │ │ + */ │ │ │ │ + version: "1.1.1", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: profile │ │ │ │ + * {String} The specific profile │ │ │ │ + */ │ │ │ │ + profile: "WMSC", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMSCapabilities.v1_1_1 │ │ │ │ + * Create a new parser for WMS-C capabilities version 1.1.1. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ + "VendorSpecificCapabilities": function(node, obj) { │ │ │ │ + obj.vendorSpecific = { │ │ │ │ + tileSets: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.vendorSpecific); │ │ │ │ + }, │ │ │ │ + "TileSet": function(node, vendorSpecific) { │ │ │ │ + var tileset = { │ │ │ │ + srs: {}, │ │ │ │ + bbox: {}, │ │ │ │ + resolutions: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, tileset); │ │ │ │ + vendorSpecific.tileSets.push(tileset); │ │ │ │ + }, │ │ │ │ + "Resolutions": function(node, tileset) { │ │ │ │ + var res = this.getChildValue(node).split(" "); │ │ │ │ + for (var i = 0, len = res.length; i < len; i++) { │ │ │ │ + if (res[i] != "") { │ │ │ │ + tileset.resolutions.push(parseFloat(res[i])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Width": function(node, tileset) { │ │ │ │ + tileset.width = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "Height": function(node, tileset) { │ │ │ │ + tileset.height = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "Layers": function(node, tileset) { │ │ │ │ + tileset.layers = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Styles": function(node, tileset) { │ │ │ │ + tileset.styles = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1_1_1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1_1_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities/v1_1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities/v1_1_0 │ │ │ │ + * Read WMS Capabilities version 1.1.0. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSCapabilities.v1_1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} The specific parser version. │ │ │ │ + */ │ │ │ │ + version: "1.1.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMSCapabilities.v1_1_0 │ │ │ │ + * Create a new parser for WMS capabilities version 1.1.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ + "SRS": function(node, obj) { │ │ │ │ + var srs = this.getChildValue(node); │ │ │ │ + var values = srs.split(/ +/); │ │ │ │ + for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ + obj.srs[values[i]] = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1_3.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities/v1.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities/v1_3 │ │ │ │ + * Abstract base class for WMS Capabilities version 1.3.X. │ │ │ │ + * SLD 1.1.0 adds in the extra operations DescribeLayer and GetLegendGraphic, │ │ │ │ + * see: http://schemas.opengis.net/sld/1.1.0/sld_capabilities.xsd │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSCapabilities.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_3 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ + "WMS_Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "LayerLimit": function(node, obj) { │ │ │ │ + obj.layerLimit = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "MaxWidth": function(node, obj) { │ │ │ │ + obj.maxWidth = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "MaxHeight": function(node, obj) { │ │ │ │ + obj.maxHeight = parseInt(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "BoundingBox": function(node, obj) { │ │ │ │ + var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ + bbox.srs = node.getAttribute("CRS"); │ │ │ │ + obj.bbox[bbox.srs] = bbox; │ │ │ │ + }, │ │ │ │ + "CRS": function(node, obj) { │ │ │ │ + // CRS is the synonym of SRS │ │ │ │ + this.readers.wms.SRS.apply(this, [node, obj]); │ │ │ │ + }, │ │ │ │ + "EX_GeographicBoundingBox": function(node, obj) { │ │ │ │ + // replacement of LatLonBoundingBox │ │ │ │ + obj.llbbox = []; │ │ │ │ + this.readChildNodes(node, obj.llbbox); │ │ │ │ + │ │ │ │ + }, │ │ │ │ + "westBoundLongitude": function(node, obj) { │ │ │ │ + obj[0] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "eastBoundLongitude": function(node, obj) { │ │ │ │ + obj[2] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "southBoundLatitude": function(node, obj) { │ │ │ │ + obj[1] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "northBoundLatitude": function(node, obj) { │ │ │ │ + obj[3] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "MinScaleDenominator": function(node, obj) { │ │ │ │ + obj.maxScale = parseFloat(this.getChildValue(node)).toPrecision(16); │ │ │ │ + }, │ │ │ │ + "MaxScaleDenominator": function(node, obj) { │ │ │ │ + obj.minScale = parseFloat(this.getChildValue(node)).toPrecision(16); │ │ │ │ + }, │ │ │ │ + "Dimension": function(node, obj) { │ │ │ │ + // dimension has extra attributes: default, multipleValues, │ │ │ │ + // nearestValue, current which used to be part of Extent. It now │ │ │ │ + // also contains the values. │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + var dim = { │ │ │ │ + name: name, │ │ │ │ + units: node.getAttribute("units"), │ │ │ │ + unitsymbol: node.getAttribute("unitSymbol"), │ │ │ │ + nearestVal: node.getAttribute("nearestValue") === "1", │ │ │ │ + multipleVal: node.getAttribute("multipleValues") === "1", │ │ │ │ + "default": node.getAttribute("default") || "", │ │ │ │ + current: node.getAttribute("current") === "1", │ │ │ │ + values: this.getChildValue(node).split(",") │ │ │ │ + │ │ │ │ + }; │ │ │ │ + // Theoretically there can be more dimensions with the same │ │ │ │ + // name, but with a different unit. Until we meet such a case, │ │ │ │ + // let's just keep the same structure as the WMS 1.1 │ │ │ │ + // GetCapabilities parser uses. We will store the last │ │ │ │ + // one encountered. │ │ │ │ + obj.dimensions[dim.name] = dim; │ │ │ │ + }, │ │ │ │ + "Keyword": function(node, obj) { │ │ │ │ + // TODO: should we change the structure of keyword in v1.js? │ │ │ │ + // Make it an object with a value instead of a string? │ │ │ │ + var keyword = { │ │ │ │ + value: this.getChildValue(node), │ │ │ │ + vocabulary: node.getAttribute("vocabulary") │ │ │ │ + }; │ │ │ │ + if (obj.keywords) { │ │ │ │ + obj.keywords.push(keyword); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]), │ │ │ │ + "sld": { │ │ │ │ + "UserDefinedSymbolization": function(node, obj) { │ │ │ │ + this.readers.wms.UserDefinedSymbolization.apply(this, [node, obj]); │ │ │ │ + // add the two extra attributes │ │ │ │ + obj.userSymbols.inlineFeature = parseInt(node.getAttribute("InlineFeature")) == 1; │ │ │ │ + obj.userSymbols.remoteWCS = parseInt(node.getAttribute("RemoteWCS")) == 1; │ │ │ │ + }, │ │ │ │ + "DescribeLayer": function(node, obj) { │ │ │ │ + this.readers.wms.DescribeLayer.apply(this, [node, obj]); │ │ │ │ + }, │ │ │ │ + "GetLegendGraphic": function(node, obj) { │ │ │ │ + this.readers.wms.GetLegendGraphic.apply(this, [node, obj]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/WMSCapabilities/v1_3_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/WMSCapabilities/v1_3.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.WMSCapabilities/v1_3_0 │ │ │ │ + * Read WMS Capabilities version 1.3.0. │ │ │ │ + * SLD 1.1.0 adds in the extra operations DescribeLayer and GetLegendGraphic, │ │ │ │ + * see: http://schemas.opengis.net/sld/1.1.0/sld_capabilities.xsd │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSCapabilities.v1_3> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_3_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSCapabilities.v1_3, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} The specific parser version. │ │ │ │ + */ │ │ │ │ + version: "1.3.0", │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/SLD/v1.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Rule.js │ │ │ │ + * @requires OpenLayers/Format/SLD.js │ │ │ │ + * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Point.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Line.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Polygon.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Text.js │ │ │ │ + * @requires OpenLayers/Symbolizer/Raster.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.SLD.v1 │ │ │ │ + * Superclass for SLD version 1 parsers. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.Filter.v1_0_0> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: rotationHandleSymbolizer │ │ │ │ - * {Object|String} Optional. A custom symbolizer for the rotation handles. │ │ │ │ - * A render intent can also be provided here. Defaults to │ │ │ │ - * (code) │ │ │ │ - * { │ │ │ │ - * stroke: false, │ │ │ │ - * pointRadius: 10, │ │ │ │ - * fillOpacity: 0, │ │ │ │ - * cursor: "pointer" │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - rotationHandleSymbolizer: null, │ │ │ │ + namespaces: { │ │ │ │ + sld: "http://www.opengis.net/sld", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: box │ │ │ │ - * {<OpenLayers.Feature.Vector>} The transformation box rectangle. │ │ │ │ - * Read-only. │ │ │ │ + * Property: defaultPrefix │ │ │ │ */ │ │ │ │ - box: null, │ │ │ │ + defaultPrefix: "sld", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: center │ │ │ │ - * {<OpenLayers.Geometry.Point>} The center of the feature bounds. │ │ │ │ - * Read-only. │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location for a particular minor version. │ │ │ │ */ │ │ │ │ - center: null, │ │ │ │ + schemaLocation: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: scale │ │ │ │ - * {Float} The scale of the feature, relative to the scale the time the │ │ │ │ - * feature was set. Read-only, except for *beforesetfeature* │ │ │ │ - * listeners. │ │ │ │ + /** │ │ │ │ + * APIProperty: multipleSymbolizers │ │ │ │ + * {Boolean} Support multiple symbolizers per rule. Default is false. if │ │ │ │ + * true, an OpenLayers.Style2 instance will be created to represent │ │ │ │ + * user styles instead of an OpenLayers.Style instace. The │ │ │ │ + * OpenLayers.Style2 class allows collections of rules with multiple │ │ │ │ + * symbolizers, but is not currently useful for client side rendering. │ │ │ │ + * If multiple symbolizers is true, multiple FeatureTypeStyle elements │ │ │ │ + * are preserved in reading/writing by setting symbolizer zIndex values. │ │ │ │ + * In addition, the <defaultSymbolizer> property is ignored if │ │ │ │ + * multiple symbolizers are supported (defaults should be applied │ │ │ │ + * when rendering). │ │ │ │ */ │ │ │ │ - scale: 1, │ │ │ │ + multipleSymbolizers: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ratio │ │ │ │ - * {Float} The ratio of the feature relative to the ratio the time the │ │ │ │ - * feature was set. Read-only, except for *beforesetfeature* │ │ │ │ - * listeners. │ │ │ │ + * Property: featureTypeCounter │ │ │ │ + * {Number} Private counter for multiple feature type styles. │ │ │ │ */ │ │ │ │ - ratio: 1, │ │ │ │ + featureTypeCounter: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: rotation │ │ │ │ - * {Integer} the current rotation angle of the box. Read-only, except for │ │ │ │ - * *beforesetfeature* listeners. │ │ │ │ + * APIProperty: defaultSymbolizer. │ │ │ │ + * {Object} A symbolizer with the SLD defaults. │ │ │ │ */ │ │ │ │ - rotation: 0, │ │ │ │ + defaultSymbolizer: { │ │ │ │ + fillColor: "#808080", │ │ │ │ + fillOpacity: 1, │ │ │ │ + strokeColor: "#000000", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + pointRadius: 3, │ │ │ │ + graphicName: "square" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handles │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} The 8 handles currently available │ │ │ │ - * for scaling/resizing. Numbered counterclockwise, starting from the │ │ │ │ - * southwest corner. Read-only. │ │ │ │ + * Constructor: OpenLayers.Format.SLD.v1 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.SLD> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - handles: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: rotationHandles │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} The 4 rotation handles currently │ │ │ │ - * available for rotating. Numbered counterclockwise, starting from │ │ │ │ - * the southwest corner. Read-only. │ │ │ │ + * Method: read │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {DOMElement} An SLD document element. │ │ │ │ + * options - {Object} Options for the reader. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * namedLayersAsArray - {Boolean} Generate a namedLayers array. If false, │ │ │ │ + * the namedLayers property value will be an object keyed by layer name. │ │ │ │ + * Default is false. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object representing the SLD. │ │ │ │ */ │ │ │ │ - rotationHandles: null, │ │ │ │ + read: function(data, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var sld = { │ │ │ │ + namedLayers: options.namedLayersAsArray === true ? [] : {} │ │ │ │ + }; │ │ │ │ + this.readChildNodes(data, sld); │ │ │ │ + return sld; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dragControl │ │ │ │ - * {<OpenLayers.Control.DragFeature>} │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ */ │ │ │ │ - dragControl: null, │ │ │ │ + readers: OpenLayers.Util.applyDefaults({ │ │ │ │ + "sld": { │ │ │ │ + "StyledLayerDescriptor": function(node, sld) { │ │ │ │ + sld.version = node.getAttribute("version"); │ │ │ │ + this.readChildNodes(node, sld); │ │ │ │ + }, │ │ │ │ + "Name": function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Title": function(node, obj) { │ │ │ │ + obj.title = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Abstract": function(node, obj) { │ │ │ │ + obj.description = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "NamedLayer": function(node, sld) { │ │ │ │ + var layer = { │ │ │ │ + userStyles: [], │ │ │ │ + namedStyles: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, layer); │ │ │ │ + // give each of the user styles this layer name │ │ │ │ + for (var i = 0, len = layer.userStyles.length; i < len; ++i) { │ │ │ │ + layer.userStyles[i].layerName = layer.name; │ │ │ │ + } │ │ │ │ + if (OpenLayers.Util.isArray(sld.namedLayers)) { │ │ │ │ + sld.namedLayers.push(layer); │ │ │ │ + } else { │ │ │ │ + sld.namedLayers[layer.name] = layer; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "NamedStyle": function(node, layer) { │ │ │ │ + layer.namedStyles.push( │ │ │ │ + this.getChildName(node.firstChild) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "UserStyle": function(node, layer) { │ │ │ │ + var obj = { │ │ │ │ + defaultsPerSymbolizer: true, │ │ │ │ + rules: [] │ │ │ │ + }; │ │ │ │ + this.featureTypeCounter = -1; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + var style; │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + delete obj.defaultsPerSymbolizer; │ │ │ │ + style = new OpenLayers.Style2(obj); │ │ │ │ + } else { │ │ │ │ + style = new OpenLayers.Style(this.defaultSymbolizer, obj); │ │ │ │ + } │ │ │ │ + layer.userStyles.push(style); │ │ │ │ + }, │ │ │ │ + "IsDefault": function(node, style) { │ │ │ │ + if (this.getChildValue(node) == "1") { │ │ │ │ + style.isDefault = true; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "FeatureTypeStyle": function(node, style) { │ │ │ │ + ++this.featureTypeCounter; │ │ │ │ + var obj = { │ │ │ │ + rules: this.multipleSymbolizers ? style.rules : [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + if (!this.multipleSymbolizers) { │ │ │ │ + style.rules = obj.rules; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Rule": function(node, obj) { │ │ │ │ + var config; │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config = { │ │ │ │ + symbolizers: [] │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + var rule = new OpenLayers.Rule(config); │ │ │ │ + this.readChildNodes(node, rule); │ │ │ │ + obj.rules.push(rule); │ │ │ │ + }, │ │ │ │ + "ElseFilter": function(node, rule) { │ │ │ │ + rule.elseFilter = true; │ │ │ │ + }, │ │ │ │ + "MinScaleDenominator": function(node, rule) { │ │ │ │ + rule.minScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "MaxScaleDenominator": function(node, rule) { │ │ │ │ + rule.maxScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "TextSymbolizer": function(node, rule) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push( │ │ │ │ + new OpenLayers.Symbolizer.Text(config) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Text"] = OpenLayers.Util.applyDefaults( │ │ │ │ + config, rule.symbolizer["Text"] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "LabelPlacement": function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "PointPlacement": function(node, symbolizer) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + config.labelRotation = config.rotation; │ │ │ │ + delete config.rotation; │ │ │ │ + var labelAlign, │ │ │ │ + x = symbolizer.labelAnchorPointX, │ │ │ │ + y = symbolizer.labelAnchorPointY; │ │ │ │ + if (x <= 1 / 3) { │ │ │ │ + labelAlign = 'l'; │ │ │ │ + } else if (x > 1 / 3 && x < 2 / 3) { │ │ │ │ + labelAlign = 'c'; │ │ │ │ + } else if (x >= 2 / 3) { │ │ │ │ + labelAlign = 'r'; │ │ │ │ + } │ │ │ │ + if (y <= 1 / 3) { │ │ │ │ + labelAlign += 'b'; │ │ │ │ + } else if (y > 1 / 3 && y < 2 / 3) { │ │ │ │ + labelAlign += 'm'; │ │ │ │ + } else if (y >= 2 / 3) { │ │ │ │ + labelAlign += 't'; │ │ │ │ + } │ │ │ │ + config.labelAlign = labelAlign; │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, config); │ │ │ │ + }, │ │ │ │ + "AnchorPoint": function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "AnchorPointX": function(node, symbolizer) { │ │ │ │ + var labelAnchorPointX = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (labelAnchorPointX) { │ │ │ │ + symbolizer.labelAnchorPointX = labelAnchorPointX; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "AnchorPointY": function(node, symbolizer) { │ │ │ │ + var labelAnchorPointY = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (labelAnchorPointY) { │ │ │ │ + symbolizer.labelAnchorPointY = labelAnchorPointY; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Displacement": function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "DisplacementX": function(node, symbolizer) { │ │ │ │ + var labelXOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (labelXOffset) { │ │ │ │ + symbolizer.labelXOffset = labelXOffset; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "DisplacementY": function(node, symbolizer) { │ │ │ │ + var labelYOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (labelYOffset) { │ │ │ │ + symbolizer.labelYOffset = labelYOffset; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "LinePlacement": function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "PerpendicularOffset": function(node, symbolizer) { │ │ │ │ + var labelPerpendicularOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (labelPerpendicularOffset) { │ │ │ │ + symbolizer.labelPerpendicularOffset = labelPerpendicularOffset; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Label": function(node, symbolizer) { │ │ │ │ + var value = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (value) { │ │ │ │ + symbolizer.label = value; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Font": function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "Halo": function(node, symbolizer) { │ │ │ │ + // halo has a fill, so send fresh object │ │ │ │ + var obj = {}; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + symbolizer.haloRadius = obj.haloRadius; │ │ │ │ + symbolizer.haloColor = obj.fillColor; │ │ │ │ + symbolizer.haloOpacity = obj.fillOpacity; │ │ │ │ + }, │ │ │ │ + "Radius": function(node, symbolizer) { │ │ │ │ + var radius = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (radius != null) { │ │ │ │ + // radius is only used for halo │ │ │ │ + symbolizer.haloRadius = radius; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "RasterSymbolizer": function(node, rule) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push( │ │ │ │ + new OpenLayers.Symbolizer.Raster(config) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Raster"] = OpenLayers.Util.applyDefaults( │ │ │ │ + config, rule.symbolizer["Raster"] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Geometry": function(node, obj) { │ │ │ │ + obj.geometry = {}; │ │ │ │ + this.readChildNodes(node, obj.geometry); │ │ │ │ + }, │ │ │ │ + "ColorMap": function(node, symbolizer) { │ │ │ │ + symbolizer.colorMap = []; │ │ │ │ + this.readChildNodes(node, symbolizer.colorMap); │ │ │ │ + }, │ │ │ │ + "ColorMapEntry": function(node, colorMap) { │ │ │ │ + var q = node.getAttribute("quantity"); │ │ │ │ + var o = node.getAttribute("opacity"); │ │ │ │ + colorMap.push({ │ │ │ │ + color: node.getAttribute("color"), │ │ │ │ + quantity: q !== null ? parseFloat(q) : undefined, │ │ │ │ + label: node.getAttribute("label") || undefined, │ │ │ │ + opacity: o !== null ? parseFloat(o) : undefined │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "LineSymbolizer": function(node, rule) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push( │ │ │ │ + new OpenLayers.Symbolizer.Line(config) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Line"] = OpenLayers.Util.applyDefaults( │ │ │ │ + config, rule.symbolizer["Line"] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "PolygonSymbolizer": function(node, rule) { │ │ │ │ + var config = { │ │ │ │ + fill: false, │ │ │ │ + stroke: false │ │ │ │ + }; │ │ │ │ + if (!this.multipleSymbolizers) { │ │ │ │ + config = rule.symbolizer["Polygon"] || config; │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push( │ │ │ │ + new OpenLayers.Symbolizer.Polygon(config) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Polygon"] = config; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "PointSymbolizer": function(node, rule) { │ │ │ │ + var config = { │ │ │ │ + fill: false, │ │ │ │ + stroke: false, │ │ │ │ + graphic: false │ │ │ │ + }; │ │ │ │ + if (!this.multipleSymbolizers) { │ │ │ │ + config = rule.symbolizer["Point"] || config; │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push( │ │ │ │ + new OpenLayers.Symbolizer.Point(config) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Point"] = config; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Stroke": function(node, symbolizer) { │ │ │ │ + symbolizer.stroke = true; │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "Fill": function(node, symbolizer) { │ │ │ │ + symbolizer.fill = true; │ │ │ │ + this.readChildNodes(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "CssParameter": function(node, symbolizer) { │ │ │ │ + var cssProperty = node.getAttribute("name"); │ │ │ │ + var symProperty = this.cssMap[cssProperty]; │ │ │ │ + // for labels, fill should map to fontColor and fill-opacity │ │ │ │ + // to fontOpacity │ │ │ │ + if (symbolizer.label) { │ │ │ │ + if (cssProperty === 'fill') { │ │ │ │ + symProperty = "fontColor"; │ │ │ │ + } else if (cssProperty === 'fill-opacity') { │ │ │ │ + symProperty = "fontOpacity"; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (symProperty) { │ │ │ │ + // Limited support for parsing of OGC expressions │ │ │ │ + var value = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be an empty string │ │ │ │ + if (value) { │ │ │ │ + symbolizer[symProperty] = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Graphic": function(node, symbolizer) { │ │ │ │ + symbolizer.graphic = true; │ │ │ │ + var graphic = {}; │ │ │ │ + // painter's order not respected here, clobber previous with next │ │ │ │ + this.readChildNodes(node, graphic); │ │ │ │ + // directly properties with names that match symbolizer properties │ │ │ │ + var properties = [ │ │ │ │ + "stroke", "strokeColor", "strokeWidth", "strokeOpacity", │ │ │ │ + "strokeLinecap", "fill", "fillColor", "fillOpacity", │ │ │ │ + "graphicName", "rotation", "graphicFormat" │ │ │ │ + ]; │ │ │ │ + var prop, value; │ │ │ │ + for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ + prop = properties[i]; │ │ │ │ + value = graphic[prop]; │ │ │ │ + if (value != undefined) { │ │ │ │ + symbolizer[prop] = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // set other generic properties with specific graphic property names │ │ │ │ + if (graphic.opacity != undefined) { │ │ │ │ + symbolizer.graphicOpacity = graphic.opacity; │ │ │ │ + } │ │ │ │ + if (graphic.size != undefined) { │ │ │ │ + var pointRadius = graphic.size / 2; │ │ │ │ + if (isNaN(pointRadius)) { │ │ │ │ + // likely a property name │ │ │ │ + symbolizer.graphicWidth = graphic.size; │ │ │ │ + } else { │ │ │ │ + symbolizer.pointRadius = graphic.size / 2; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (graphic.href != undefined) { │ │ │ │ + symbolizer.externalGraphic = graphic.href; │ │ │ │ + } │ │ │ │ + if (graphic.rotation != undefined) { │ │ │ │ + symbolizer.rotation = graphic.rotation; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ExternalGraphic": function(node, graphic) { │ │ │ │ + this.readChildNodes(node, graphic); │ │ │ │ + }, │ │ │ │ + "Mark": function(node, graphic) { │ │ │ │ + this.readChildNodes(node, graphic); │ │ │ │ + }, │ │ │ │ + "WellKnownName": function(node, graphic) { │ │ │ │ + graphic.graphicName = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "Opacity": function(node, obj) { │ │ │ │ + var opacity = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (opacity) { │ │ │ │ + obj.opacity = opacity; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Size": function(node, obj) { │ │ │ │ + var size = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (size) { │ │ │ │ + obj.size = size; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Rotation": function(node, obj) { │ │ │ │ + var rotation = this.readers.ogc._expression.call(this, node); │ │ │ │ + // always string, could be empty string │ │ │ │ + if (rotation) { │ │ │ │ + obj.rotation = rotation; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "OnlineResource": function(node, obj) { │ │ │ │ + obj.href = this.getAttributeNS( │ │ │ │ + node, this.namespaces.xlink, "href" │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "Format": function(node, graphic) { │ │ │ │ + graphic.graphicFormat = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.Filter.v1_0_0.prototype.readers), │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: irregular │ │ │ │ - * {Boolean} Make scaling/resizing work irregularly. If true then │ │ │ │ - * dragging a handle causes the feature to resize in the direction │ │ │ │ - * of movement. If false then the feature resizes symetrically │ │ │ │ - * about it's center. │ │ │ │ + * Property: cssMap │ │ │ │ + * {Object} Object mapping supported css property names to OpenLayers │ │ │ │ + * symbolizer property names. │ │ │ │ */ │ │ │ │ - irregular: false, │ │ │ │ + cssMap: { │ │ │ │ + "stroke": "strokeColor", │ │ │ │ + "stroke-opacity": "strokeOpacity", │ │ │ │ + "stroke-width": "strokeWidth", │ │ │ │ + "stroke-linecap": "strokeLinecap", │ │ │ │ + "stroke-dasharray": "strokeDashstyle", │ │ │ │ + "fill": "fillColor", │ │ │ │ + "fill-opacity": "fillOpacity", │ │ │ │ + "font-family": "fontFamily", │ │ │ │ + "font-size": "fontSize", │ │ │ │ + "font-weight": "fontWeight", │ │ │ │ + "font-style": "fontStyle" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.TransformFeature │ │ │ │ - * Create a new transform feature control. │ │ │ │ + * Method: getCssProperty │ │ │ │ + * Given a symbolizer property, get the corresponding CSS property │ │ │ │ + * from the <cssMap>. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} Layer that contains features that │ │ │ │ - * will be transformed. │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * control. │ │ │ │ + * sym - {String} A symbolizer property name. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A CSS property name or null if none found. │ │ │ │ */ │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - this.layer = layer; │ │ │ │ - │ │ │ │ - if (!this.rotationHandleSymbolizer) { │ │ │ │ - this.rotationHandleSymbolizer = { │ │ │ │ - stroke: false, │ │ │ │ - pointRadius: 10, │ │ │ │ - fillOpacity: 0, │ │ │ │ - cursor: "pointer" │ │ │ │ - }; │ │ │ │ + getCssProperty: function(sym) { │ │ │ │ + var css = null; │ │ │ │ + for (var prop in this.cssMap) { │ │ │ │ + if (this.cssMap[prop] == sym) { │ │ │ │ + css = prop; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ } │ │ │ │ - │ │ │ │ - this.createBox(); │ │ │ │ - this.createControl(); │ │ │ │ + return css; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activates the control. │ │ │ │ + * Method: getGraphicFormat │ │ │ │ + * Given a href for an external graphic, try to determine the mime-type. │ │ │ │ + * This method doesn't try too hard, and will fall back to │ │ │ │ + * <defaultGraphicFormat> if one of the known <graphicFormats> is not │ │ │ │ + * the file extension of the provided href. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * href - {String} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The graphic format. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragControl.activate(); │ │ │ │ - this.layer.addFeatures([this.box]); │ │ │ │ - this.rotate && this.layer.addFeatures(this.rotationHandles); │ │ │ │ - this.layer.addFeatures(this.handles); │ │ │ │ - activated = true; │ │ │ │ + getGraphicFormat: function(href) { │ │ │ │ + var format, regex; │ │ │ │ + for (var key in this.graphicFormats) { │ │ │ │ + if (this.graphicFormats[key].test(href)) { │ │ │ │ + format = key; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ + return format || this.defaultGraphicFormat; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivates the control. │ │ │ │ + * Property: defaultGraphicFormat │ │ │ │ + * {String} If none other can be determined from <getGraphicFormat>, this │ │ │ │ + * default will be returned. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.layer.removeFeatures(this.handles); │ │ │ │ - this.rotate && this.layer.removeFeatures(this.rotationHandles); │ │ │ │ - this.layer.removeFeatures([this.box]); │ │ │ │ - this.dragControl.deactivate(); │ │ │ │ - deactivated = true; │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ + defaultGraphicFormat: "image/png", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: graphicFormats │ │ │ │ + * {Object} Mapping of image mime-types to regular extensions matching │ │ │ │ + * well-known file extensions. │ │ │ │ + */ │ │ │ │ + graphicFormats: { │ │ │ │ + "image/jpeg": /\.jpe?g$/i, │ │ │ │ + "image/gif": /\.gif$/i, │ │ │ │ + "image/png": /\.png$/i │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ + * Method: write │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * sld - {Object} An object representing the SLD. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The root of an SLD document. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.dragControl.setMap(map); │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + write: function(sld) { │ │ │ │ + return this.writers.sld.StyledLayerDescriptor.apply(this, [sld]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setFeature │ │ │ │ - * Place the transformation box on a feature and start transforming it. │ │ │ │ - * If the control is not active, it will be activated. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * initialParams - {Object} Initial values for rotation, scale or ratio. │ │ │ │ - * Setting a rotation value here will cause the transformation box to │ │ │ │ - * start rotated. Setting a scale or ratio will not affect the │ │ │ │ - * transormation box, but applications may use this to keep track of │ │ │ │ - * scale and ratio of a feature across multiple transforms. │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ */ │ │ │ │ - setFeature: function(feature, initialParams) { │ │ │ │ - initialParams = OpenLayers.Util.applyDefaults(initialParams, { │ │ │ │ - rotation: 0, │ │ │ │ - scale: 1, │ │ │ │ - ratio: 1 │ │ │ │ - }); │ │ │ │ + writers: OpenLayers.Util.applyDefaults({ │ │ │ │ + "sld": { │ │ │ │ + "_OGCExpression": function(nodeName, value) { │ │ │ │ + // only the simplest of ogc:expression handled │ │ │ │ + // {label: "some text and a ${propertyName}"} │ │ │ │ + var node = this.createElementNSPlus(nodeName); │ │ │ │ + var tokens = typeof value == "string" ? │ │ │ │ + value.split("${") : [value]; │ │ │ │ + node.appendChild(this.createTextNode(tokens[0])); │ │ │ │ + var item, last; │ │ │ │ + for (var i = 1, len = tokens.length; i < len; i++) { │ │ │ │ + item = tokens[i]; │ │ │ │ + last = item.indexOf("}"); │ │ │ │ + if (last > 0) { │ │ │ │ + this.writeNode( │ │ │ │ + "ogc:PropertyName", { │ │ │ │ + property: item.substring(0, last) │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + node.appendChild( │ │ │ │ + this.createTextNode(item.substring(++last)) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + // no ending }, so this is a literal ${ │ │ │ │ + node.appendChild( │ │ │ │ + this.createTextNode("${" + item) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "StyledLayerDescriptor": function(sld) { │ │ │ │ + var root = this.createElementNSPlus( │ │ │ │ + "sld:StyledLayerDescriptor", { │ │ │ │ + attributes: { │ │ │ │ + "version": this.VERSION, │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ + } │ │ │ │ + } │ │ │ │ + ); │ │ │ │ │ │ │ │ - var oldRotation = this.rotation; │ │ │ │ - var oldCenter = this.center; │ │ │ │ - OpenLayers.Util.extend(this, initialParams); │ │ │ │ + // For ArcGIS Server it is necessary to define this │ │ │ │ + // at the root level (see ticket:2166). │ │ │ │ + root.setAttribute("xmlns:ogc", this.namespaces.ogc); │ │ │ │ + root.setAttribute("xmlns:gml", this.namespaces.gml); │ │ │ │ │ │ │ │ - var cont = this.events.triggerEvent("beforesetfeature", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont === false) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ + // add in optional name │ │ │ │ + if (sld.name) { │ │ │ │ + this.writeNode("Name", sld.name, root); │ │ │ │ + } │ │ │ │ + // add in optional title │ │ │ │ + if (sld.title) { │ │ │ │ + this.writeNode("Title", sld.title, root); │ │ │ │ + } │ │ │ │ + // add in optional description │ │ │ │ + if (sld.description) { │ │ │ │ + this.writeNode("Abstract", sld.description, root); │ │ │ │ + } │ │ │ │ + // add in named layers │ │ │ │ + // allow namedLayers to be an array │ │ │ │ + if (OpenLayers.Util.isArray(sld.namedLayers)) { │ │ │ │ + for (var i = 0, len = sld.namedLayers.length; i < len; ++i) { │ │ │ │ + this.writeNode("NamedLayer", sld.namedLayers[i], root); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + for (var name in sld.namedLayers) { │ │ │ │ + this.writeNode("NamedLayer", sld.namedLayers[name], root); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return root; │ │ │ │ + }, │ │ │ │ + "Name": function(name) { │ │ │ │ + return this.createElementNSPlus("sld:Name", { │ │ │ │ + value: name │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Title": function(title) { │ │ │ │ + return this.createElementNSPlus("sld:Title", { │ │ │ │ + value: title │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Abstract": function(description) { │ │ │ │ + return this.createElementNSPlus( │ │ │ │ + "sld:Abstract", { │ │ │ │ + value: description │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "NamedLayer": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("sld:NamedLayer"); │ │ │ │ │ │ │ │ - this.feature = feature; │ │ │ │ - this.activate(); │ │ │ │ + // add in required name │ │ │ │ + this.writeNode("Name", layer.name, node); │ │ │ │ │ │ │ │ - this._setfeature = true; │ │ │ │ + // optional sld:LayerFeatureConstraints here │ │ │ │ │ │ │ │ - var featureBounds = this.feature.geometry.getBounds(); │ │ │ │ - this.box.move(featureBounds.getCenterLonLat()); │ │ │ │ - this.box.geometry.rotate(-oldRotation, oldCenter); │ │ │ │ - this._angle = 0; │ │ │ │ + // add in named styles │ │ │ │ + if (layer.namedStyles) { │ │ │ │ + for (var i = 0, len = layer.namedStyles.length; i < len; ++i) { │ │ │ │ + this.writeNode( │ │ │ │ + "NamedStyle", layer.namedStyles[i], node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - var ll; │ │ │ │ - if (this.rotation) { │ │ │ │ - var geom = feature.geometry.clone(); │ │ │ │ - geom.rotate(-this.rotation, this.center); │ │ │ │ - var box = new OpenLayers.Feature.Vector( │ │ │ │ - geom.getBounds().toGeometry()); │ │ │ │ - box.geometry.rotate(this.rotation, this.center); │ │ │ │ - this.box.geometry.rotate(this.rotation, this.center); │ │ │ │ - this.box.move(box.geometry.getBounds().getCenterLonLat()); │ │ │ │ - var llGeom = box.geometry.components[0].components[0]; │ │ │ │ - ll = llGeom.getBounds().getCenterLonLat(); │ │ │ │ - } else { │ │ │ │ - ll = new OpenLayers.LonLat(featureBounds.left, featureBounds.bottom); │ │ │ │ - } │ │ │ │ - this.handles[0].move(ll); │ │ │ │ + // add in user styles │ │ │ │ + if (layer.userStyles) { │ │ │ │ + for (var i = 0, len = layer.userStyles.length; i < len; ++i) { │ │ │ │ + this.writeNode( │ │ │ │ + "UserStyle", layer.userStyles[i], node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - delete this._setfeature; │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "NamedStyle": function(name) { │ │ │ │ + var node = this.createElementNSPlus("sld:NamedStyle"); │ │ │ │ + this.writeNode("Name", name, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "UserStyle": function(style) { │ │ │ │ + var node = this.createElementNSPlus("sld:UserStyle"); │ │ │ │ │ │ │ │ - this.events.triggerEvent("setfeature", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + // add in optional name │ │ │ │ + if (style.name) { │ │ │ │ + this.writeNode("Name", style.name, node); │ │ │ │ + } │ │ │ │ + // add in optional title │ │ │ │ + if (style.title) { │ │ │ │ + this.writeNode("Title", style.title, node); │ │ │ │ + } │ │ │ │ + // add in optional description │ │ │ │ + if (style.description) { │ │ │ │ + this.writeNode("Abstract", style.description, node); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: unsetFeature │ │ │ │ - * Remove the transformation box off any feature. │ │ │ │ - * If the control is active, it will be deactivated first. │ │ │ │ - */ │ │ │ │ - unsetFeature: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - } else { │ │ │ │ - this.feature = null; │ │ │ │ - this.rotation = 0; │ │ │ │ - this.scale = 1; │ │ │ │ - this.ratio = 1; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + // add isdefault │ │ │ │ + if (style.isDefault) { │ │ │ │ + this.writeNode("IsDefault", style.isDefault, node); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createBox │ │ │ │ - * Creates the box with all handles and transformation handles. │ │ │ │ - */ │ │ │ │ - createBox: function() { │ │ │ │ - var control = this; │ │ │ │ + // add FeatureTypeStyles │ │ │ │ + if (this.multipleSymbolizers && style.rules) { │ │ │ │ + // group style objects by symbolizer zIndex │ │ │ │ + var rulesByZ = { │ │ │ │ + 0: [] │ │ │ │ + }; │ │ │ │ + var zValues = [0]; │ │ │ │ + var rule, ruleMap, symbolizer, zIndex, clone; │ │ │ │ + for (var i = 0, ii = style.rules.length; i < ii; ++i) { │ │ │ │ + rule = style.rules[i]; │ │ │ │ + if (rule.symbolizers) { │ │ │ │ + ruleMap = {}; │ │ │ │ + for (var j = 0, jj = rule.symbolizers.length; j < jj; ++j) { │ │ │ │ + symbolizer = rule.symbolizers[j]; │ │ │ │ + zIndex = symbolizer.zIndex; │ │ │ │ + if (!(zIndex in ruleMap)) { │ │ │ │ + clone = rule.clone(); │ │ │ │ + clone.symbolizers = []; │ │ │ │ + ruleMap[zIndex] = clone; │ │ │ │ + } │ │ │ │ + ruleMap[zIndex].symbolizers.push(symbolizer.clone()); │ │ │ │ + } │ │ │ │ + for (zIndex in ruleMap) { │ │ │ │ + if (!(zIndex in rulesByZ)) { │ │ │ │ + zValues.push(zIndex); │ │ │ │ + rulesByZ[zIndex] = []; │ │ │ │ + } │ │ │ │ + rulesByZ[zIndex].push(ruleMap[zIndex]); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // no symbolizers in rule │ │ │ │ + rulesByZ[0].push(rule.clone()); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // write one FeatureTypeStyle per zIndex │ │ │ │ + zValues.sort(); │ │ │ │ + var rules; │ │ │ │ + for (var i = 0, ii = zValues.length; i < ii; ++i) { │ │ │ │ + rules = rulesByZ[zValues[i]]; │ │ │ │ + if (rules.length > 0) { │ │ │ │ + clone = style.clone(); │ │ │ │ + clone.rules = rulesByZ[zValues[i]]; │ │ │ │ + this.writeNode("FeatureTypeStyle", clone, node); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.writeNode("FeatureTypeStyle", style, node); │ │ │ │ + } │ │ │ │ │ │ │ │ - this.center = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ - this.box = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.LineString([ │ │ │ │ - new OpenLayers.Geometry.Point(-1, -1), │ │ │ │ - new OpenLayers.Geometry.Point(0, -1), │ │ │ │ - new OpenLayers.Geometry.Point(1, -1), │ │ │ │ - new OpenLayers.Geometry.Point(1, 0), │ │ │ │ - new OpenLayers.Geometry.Point(1, 1), │ │ │ │ - new OpenLayers.Geometry.Point(0, 1), │ │ │ │ - new OpenLayers.Geometry.Point(-1, 1), │ │ │ │ - new OpenLayers.Geometry.Point(-1, 0), │ │ │ │ - new OpenLayers.Geometry.Point(-1, -1) │ │ │ │ - ]), null, │ │ │ │ - typeof this.renderIntent == "string" ? null : this.renderIntent │ │ │ │ - ); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "IsDefault": function(bool) { │ │ │ │ + return this.createElementNSPlus( │ │ │ │ + "sld:IsDefault", { │ │ │ │ + value: (bool) ? "1" : "0" │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "FeatureTypeStyle": function(style) { │ │ │ │ + var node = this.createElementNSPlus("sld:FeatureTypeStyle"); │ │ │ │ │ │ │ │ - // Override for box move - make sure that the center gets updated │ │ │ │ - this.box.geometry.move = function(x, y) { │ │ │ │ - control._moving = true; │ │ │ │ - OpenLayers.Geometry.LineString.prototype.move.apply(this, arguments); │ │ │ │ - control.center.move(x, y); │ │ │ │ - delete control._moving; │ │ │ │ - }; │ │ │ │ + // OpenLayers currently stores no Name, Title, Abstract, │ │ │ │ + // FeatureTypeName, or SemanticTypeIdentifier information │ │ │ │ + // related to FeatureTypeStyle │ │ │ │ │ │ │ │ - // Overrides for vertex move, resize and rotate - make sure that │ │ │ │ - // handle and rotationHandle geometries are also moved, resized and │ │ │ │ - // rotated. │ │ │ │ - var vertexMoveFn = function(x, y) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.apply(this, arguments); │ │ │ │ - this._rotationHandle && this._rotationHandle.geometry.move(x, y); │ │ │ │ - this._handle.geometry.move(x, y); │ │ │ │ - }; │ │ │ │ - var vertexResizeFn = function(scale, center, ratio) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.resize.apply(this, arguments); │ │ │ │ - this._rotationHandle && this._rotationHandle.geometry.resize( │ │ │ │ - scale, center, ratio); │ │ │ │ - this._handle.geometry.resize(scale, center, ratio); │ │ │ │ - }; │ │ │ │ - var vertexRotateFn = function(angle, center) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.rotate.apply(this, arguments); │ │ │ │ - this._rotationHandle && this._rotationHandle.geometry.rotate( │ │ │ │ - angle, center); │ │ │ │ - this._handle.geometry.rotate(angle, center); │ │ │ │ - }; │ │ │ │ + // add in rules │ │ │ │ + for (var i = 0, len = style.rules.length; i < len; ++i) { │ │ │ │ + this.writeNode("Rule", style.rules[i], node); │ │ │ │ + } │ │ │ │ │ │ │ │ - // Override for handle move - make sure that the box and other handles │ │ │ │ - // are updated, and finally transform the feature. │ │ │ │ - var handleMoveFn = function(x, y) { │ │ │ │ - var oldX = this.x, │ │ │ │ - oldY = this.y; │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - if (control._moving) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var evt = control.dragControl.handlers.drag.evt; │ │ │ │ - var preserveAspectRatio = !control._setfeature && │ │ │ │ - control.preserveAspectRatio; │ │ │ │ - var reshape = !preserveAspectRatio && !(evt && evt.shiftKey); │ │ │ │ - var oldGeom = new OpenLayers.Geometry.Point(oldX, oldY); │ │ │ │ - var centerGeometry = control.center; │ │ │ │ - this.rotate(-control.rotation, centerGeometry); │ │ │ │ - oldGeom.rotate(-control.rotation, centerGeometry); │ │ │ │ - var dx1 = this.x - centerGeometry.x; │ │ │ │ - var dy1 = this.y - centerGeometry.y; │ │ │ │ - var dx0 = dx1 - (this.x - oldGeom.x); │ │ │ │ - var dy0 = dy1 - (this.y - oldGeom.y); │ │ │ │ - if (control.irregular && !control._setfeature) { │ │ │ │ - dx1 -= (this.x - oldGeom.x) / 2; │ │ │ │ - dy1 -= (this.y - oldGeom.y) / 2; │ │ │ │ - } │ │ │ │ - this.x = oldX; │ │ │ │ - this.y = oldY; │ │ │ │ - var scale, ratio = 1; │ │ │ │ - if (reshape) { │ │ │ │ - scale = Math.abs(dy0) < 0.00001 ? 1 : dy1 / dy0; │ │ │ │ - ratio = (Math.abs(dx0) < 0.00001 ? 1 : (dx1 / dx0)) / scale; │ │ │ │ - } else { │ │ │ │ - var l0 = Math.sqrt((dx0 * dx0) + (dy0 * dy0)); │ │ │ │ - var l1 = Math.sqrt((dx1 * dx1) + (dy1 * dy1)); │ │ │ │ - scale = l1 / l0; │ │ │ │ - } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Rule": function(rule) { │ │ │ │ + var node = this.createElementNSPlus("sld:Rule"); │ │ │ │ │ │ │ │ - // rotate the box to 0 before resizing - saves us some │ │ │ │ - // calculations and is inexpensive because we don't drawFeature. │ │ │ │ - control._moving = true; │ │ │ │ - control.box.geometry.rotate(-control.rotation, centerGeometry); │ │ │ │ - delete control._moving; │ │ │ │ + // add in optional name │ │ │ │ + if (rule.name) { │ │ │ │ + this.writeNode("Name", rule.name, node); │ │ │ │ + } │ │ │ │ + // add in optional title │ │ │ │ + if (rule.title) { │ │ │ │ + this.writeNode("Title", rule.title, node); │ │ │ │ + } │ │ │ │ + // add in optional description │ │ │ │ + if (rule.description) { │ │ │ │ + this.writeNode("Abstract", rule.description, node); │ │ │ │ + } │ │ │ │ │ │ │ │ - control.box.geometry.resize(scale, centerGeometry, ratio); │ │ │ │ - control.box.geometry.rotate(control.rotation, centerGeometry); │ │ │ │ - control.transformFeature({ │ │ │ │ - scale: scale, │ │ │ │ - ratio: ratio │ │ │ │ - }); │ │ │ │ - if (control.irregular && !control._setfeature) { │ │ │ │ - var newCenter = centerGeometry.clone(); │ │ │ │ - newCenter.x += Math.abs(oldX - centerGeometry.x) < 0.00001 ? 0 : (this.x - oldX); │ │ │ │ - newCenter.y += Math.abs(oldY - centerGeometry.y) < 0.00001 ? 0 : (this.y - oldY); │ │ │ │ - control.box.geometry.move(this.x - oldX, this.y - oldY); │ │ │ │ - control.transformFeature({ │ │ │ │ - center: newCenter │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ + // add in LegendGraphic here │ │ │ │ │ │ │ │ - // Override for rotation handle move - make sure that the box and │ │ │ │ - // other handles are updated, and finally transform the feature. │ │ │ │ - var rotationHandleMoveFn = function(x, y) { │ │ │ │ - var oldX = this.x, │ │ │ │ - oldY = this.y; │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - if (control._moving) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var evt = control.dragControl.handlers.drag.evt; │ │ │ │ - var constrain = (evt && evt.shiftKey) ? 45 : 1; │ │ │ │ - var centerGeometry = control.center; │ │ │ │ - var dx1 = this.x - centerGeometry.x; │ │ │ │ - var dy1 = this.y - centerGeometry.y; │ │ │ │ - var dx0 = dx1 - x; │ │ │ │ - var dy0 = dy1 - y; │ │ │ │ - this.x = oldX; │ │ │ │ - this.y = oldY; │ │ │ │ - var a0 = Math.atan2(dy0, dx0); │ │ │ │ - var a1 = Math.atan2(dy1, dx1); │ │ │ │ - var angle = a1 - a0; │ │ │ │ - angle *= 180 / Math.PI; │ │ │ │ - control._angle = (control._angle + angle) % 360; │ │ │ │ - var diff = control.rotation % constrain; │ │ │ │ - if (Math.abs(control._angle) >= constrain || diff !== 0) { │ │ │ │ - angle = Math.round(control._angle / constrain) * constrain - │ │ │ │ - diff; │ │ │ │ - control._angle = 0; │ │ │ │ - control.box.geometry.rotate(angle, centerGeometry); │ │ │ │ - control.transformFeature({ │ │ │ │ - rotation: angle │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ + // add in optional filters │ │ │ │ + if (rule.elseFilter) { │ │ │ │ + this.writeNode("ElseFilter", null, node); │ │ │ │ + } else if (rule.filter) { │ │ │ │ + this.writeNode("ogc:Filter", rule.filter, node); │ │ │ │ + } │ │ │ │ │ │ │ │ - var handles = new Array(8); │ │ │ │ - var rotationHandles = new Array(4); │ │ │ │ - var geom, handle, rotationHandle; │ │ │ │ - var positions = ["sw", "s", "se", "e", "ne", "n", "nw", "w"]; │ │ │ │ - for (var i = 0; i < 8; ++i) { │ │ │ │ - geom = this.box.geometry.components[i]; │ │ │ │ - handle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ - role: positions[i] + "-resize" │ │ │ │ - }, typeof this.renderIntent == "string" ? null : │ │ │ │ - this.renderIntent); │ │ │ │ - if (i % 2 == 0) { │ │ │ │ - rotationHandle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ - role: positions[i] + "-rotate" │ │ │ │ - }, typeof this.rotationHandleSymbolizer == "string" ? │ │ │ │ - null : this.rotationHandleSymbolizer); │ │ │ │ - rotationHandle.geometry.move = rotationHandleMoveFn; │ │ │ │ - geom._rotationHandle = rotationHandle; │ │ │ │ - rotationHandles[i / 2] = rotationHandle; │ │ │ │ - } │ │ │ │ - geom.move = vertexMoveFn; │ │ │ │ - geom.resize = vertexResizeFn; │ │ │ │ - geom.rotate = vertexRotateFn; │ │ │ │ - handle.geometry.move = handleMoveFn; │ │ │ │ - geom._handle = handle; │ │ │ │ - handles[i] = handle; │ │ │ │ - } │ │ │ │ + // add in scale limits │ │ │ │ + if (rule.minScaleDenominator != undefined) { │ │ │ │ + this.writeNode( │ │ │ │ + "MinScaleDenominator", rule.minScaleDenominator, node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (rule.maxScaleDenominator != undefined) { │ │ │ │ + this.writeNode( │ │ │ │ + "MaxScaleDenominator", rule.maxScaleDenominator, node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ │ │ │ │ - this.rotationHandles = rotationHandles; │ │ │ │ - this.handles = handles; │ │ │ │ - }, │ │ │ │ + var type, symbolizer; │ │ │ │ + if (this.multipleSymbolizers && rule.symbolizers) { │ │ │ │ + var symbolizer; │ │ │ │ + for (var i = 0, ii = rule.symbolizers.length; i < ii; ++i) { │ │ │ │ + symbolizer = rule.symbolizers[i]; │ │ │ │ + type = symbolizer.CLASS_NAME.split(".").pop(); │ │ │ │ + this.writeNode( │ │ │ │ + type + "Symbolizer", symbolizer, node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // add in symbolizers (relies on geometry type keys) │ │ │ │ + var types = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ + for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ + type = types[i]; │ │ │ │ + symbolizer = rule.symbolizer[type]; │ │ │ │ + if (symbolizer) { │ │ │ │ + this.writeNode( │ │ │ │ + type + "Symbolizer", symbolizer, node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createControl │ │ │ │ - * Creates a DragFeature control for this control. │ │ │ │ - */ │ │ │ │ - createControl: function() { │ │ │ │ - var control = this; │ │ │ │ - this.dragControl = new OpenLayers.Control.DragFeature(this.layer, { │ │ │ │ - documentDrag: true, │ │ │ │ - // avoid moving the feature itself - move the box instead │ │ │ │ - moveFeature: function(pixel) { │ │ │ │ - if (this.feature === control.feature) { │ │ │ │ - this.feature = control.box; │ │ │ │ + }, │ │ │ │ + "ElseFilter": function() { │ │ │ │ + return this.createElementNSPlus("sld:ElseFilter"); │ │ │ │ + }, │ │ │ │ + "MinScaleDenominator": function(scale) { │ │ │ │ + return this.createElementNSPlus( │ │ │ │ + "sld:MinScaleDenominator", { │ │ │ │ + value: scale │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "MaxScaleDenominator": function(scale) { │ │ │ │ + return this.createElementNSPlus( │ │ │ │ + "sld:MaxScaleDenominator", { │ │ │ │ + value: scale │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "LineSymbolizer": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:LineSymbolizer"); │ │ │ │ + this.writeNode("Stroke", symbolizer, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Stroke": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Stroke"); │ │ │ │ + │ │ │ │ + // GraphicFill here │ │ │ │ + // GraphicStroke here │ │ │ │ + │ │ │ │ + // add in CssParameters │ │ │ │ + if (symbolizer.strokeColor != undefined) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "strokeColor" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ } │ │ │ │ - OpenLayers.Control.DragFeature.prototype.moveFeature.apply(this, │ │ │ │ - arguments); │ │ │ │ + if (symbolizer.strokeOpacity != undefined) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "strokeOpacity" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.strokeWidth != undefined) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "strokeWidth" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.strokeDashstyle != undefined && symbolizer.strokeDashstyle !== "solid") { │ │ │ │ + // assumes valid stroke-dasharray value │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "strokeDashstyle" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.strokeLinecap != undefined) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "strokeLinecap" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ - // transform while dragging │ │ │ │ - onDrag: function(feature, pixel) { │ │ │ │ - if (feature === control.box) { │ │ │ │ - control.transformFeature({ │ │ │ │ - center: control.center │ │ │ │ - }); │ │ │ │ + "CssParameter": function(obj) { │ │ │ │ + // not handling ogc:expressions for now │ │ │ │ + return this.createElementNSPlus("sld:CssParameter", { │ │ │ │ + attributes: { │ │ │ │ + name: this.getCssProperty(obj.key) │ │ │ │ + }, │ │ │ │ + value: obj.symbolizer[obj.key] │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "TextSymbolizer": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:TextSymbolizer"); │ │ │ │ + // add in optional Label │ │ │ │ + if (symbolizer.label != null) { │ │ │ │ + this.writeNode("Label", symbolizer.label, node); │ │ │ │ + } │ │ │ │ + // add in optional Font │ │ │ │ + if (symbolizer.fontFamily != null || │ │ │ │ + symbolizer.fontSize != null || │ │ │ │ + symbolizer.fontWeight != null || │ │ │ │ + symbolizer.fontStyle != null) { │ │ │ │ + this.writeNode("Font", symbolizer, node); │ │ │ │ + } │ │ │ │ + // add in optional LabelPlacement │ │ │ │ + if (symbolizer.labelAnchorPointX != null || │ │ │ │ + symbolizer.labelAnchorPointY != null || │ │ │ │ + symbolizer.labelAlign != null || │ │ │ │ + symbolizer.labelXOffset != null || │ │ │ │ + symbolizer.labelYOffset != null || │ │ │ │ + symbolizer.labelRotation != null || │ │ │ │ + symbolizer.labelPerpendicularOffset != null) { │ │ │ │ + this.writeNode("LabelPlacement", symbolizer, node); │ │ │ │ + } │ │ │ │ + // add in optional Halo │ │ │ │ + if (symbolizer.haloRadius != null || │ │ │ │ + symbolizer.haloColor != null || │ │ │ │ + symbolizer.haloOpacity != null) { │ │ │ │ + this.writeNode("Halo", symbolizer, node); │ │ │ │ } │ │ │ │ + // add in optional Fill │ │ │ │ + if (symbolizer.fontColor != null || │ │ │ │ + symbolizer.fontOpacity != null) { │ │ │ │ + this.writeNode("Fill", { │ │ │ │ + fillColor: symbolizer.fontColor, │ │ │ │ + fillOpacity: symbolizer.fontOpacity │ │ │ │ + }, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ - // set a new feature │ │ │ │ - onStart: function(feature, pixel) { │ │ │ │ - var eligible = !control.geometryTypes || │ │ │ │ - OpenLayers.Util.indexOf(control.geometryTypes, │ │ │ │ - feature.geometry.CLASS_NAME) !== -1; │ │ │ │ - var i = OpenLayers.Util.indexOf(control.handles, feature); │ │ │ │ - i += OpenLayers.Util.indexOf(control.rotationHandles, │ │ │ │ - feature); │ │ │ │ - if (feature !== control.feature && feature !== control.box && │ │ │ │ - i == -2 && eligible) { │ │ │ │ - control.setFeature(feature); │ │ │ │ + "LabelPlacement": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:LabelPlacement"); │ │ │ │ + // PointPlacement and LinePlacement are choices, so don't output both │ │ │ │ + if ((symbolizer.labelAnchorPointX != null || │ │ │ │ + symbolizer.labelAnchorPointY != null || │ │ │ │ + symbolizer.labelAlign != null || │ │ │ │ + symbolizer.labelXOffset != null || │ │ │ │ + symbolizer.labelYOffset != null || │ │ │ │ + symbolizer.labelRotation != null) && │ │ │ │ + symbolizer.labelPerpendicularOffset == null) { │ │ │ │ + this.writeNode("PointPlacement", symbolizer, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.labelPerpendicularOffset != null) { │ │ │ │ + this.writeNode("LinePlacement", symbolizer, node); │ │ │ │ } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ - onComplete: function(feature, pixel) { │ │ │ │ - control.events.triggerEvent("transformcomplete", { │ │ │ │ - feature: control.feature │ │ │ │ + "LinePlacement": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:LinePlacement"); │ │ │ │ + this.writeNode("PerpendicularOffset", symbolizer.labelPerpendicularOffset, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "PerpendicularOffset": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:PerpendicularOffset", { │ │ │ │ + value: value │ │ │ │ }); │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + }, │ │ │ │ + "PointPlacement": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:PointPlacement"); │ │ │ │ + if (symbolizer.labelAnchorPointX != null || │ │ │ │ + symbolizer.labelAnchorPointY != null || │ │ │ │ + symbolizer.labelAlign != null) { │ │ │ │ + this.writeNode("AnchorPoint", symbolizer, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.labelXOffset != null || │ │ │ │ + symbolizer.labelYOffset != null) { │ │ │ │ + this.writeNode("Displacement", symbolizer, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.labelRotation != null) { │ │ │ │ + this.writeNode("Rotation", symbolizer.labelRotation, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "AnchorPoint": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:AnchorPoint"); │ │ │ │ + var x = symbolizer.labelAnchorPointX, │ │ │ │ + y = symbolizer.labelAnchorPointY; │ │ │ │ + if (x != null) { │ │ │ │ + this.writeNode("AnchorPointX", x, node); │ │ │ │ + } │ │ │ │ + if (y != null) { │ │ │ │ + this.writeNode("AnchorPointY", y, node); │ │ │ │ + } │ │ │ │ + if (x == null && y == null) { │ │ │ │ + var xAlign = symbolizer.labelAlign.substr(0, 1), │ │ │ │ + yAlign = symbolizer.labelAlign.substr(1, 1); │ │ │ │ + if (xAlign === "l") { │ │ │ │ + x = 0; │ │ │ │ + } else if (xAlign === "c") { │ │ │ │ + x = 0.5; │ │ │ │ + } else if (xAlign === "r") { │ │ │ │ + x = 1; │ │ │ │ + } │ │ │ │ + if (yAlign === "b") { │ │ │ │ + y = 0; │ │ │ │ + } else if (yAlign === "m") { │ │ │ │ + y = 0.5; │ │ │ │ + } else if (yAlign === "t") { │ │ │ │ + y = 1; │ │ │ │ + } │ │ │ │ + this.writeNode("AnchorPointX", x, node); │ │ │ │ + this.writeNode("AnchorPointY", y, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "AnchorPointX": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:AnchorPointX", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "AnchorPointY": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:AnchorPointY", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Displacement": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Displacement"); │ │ │ │ + if (symbolizer.labelXOffset != null) { │ │ │ │ + this.writeNode("DisplacementX", symbolizer.labelXOffset, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.labelYOffset != null) { │ │ │ │ + this.writeNode("DisplacementY", symbolizer.labelYOffset, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "DisplacementX": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:DisplacementX", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "DisplacementY": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:DisplacementY", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Font": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Font"); │ │ │ │ + // add in CssParameters │ │ │ │ + if (symbolizer.fontFamily) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "fontFamily" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.fontSize) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "fontSize" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.fontWeight) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "fontWeight" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.fontStyle) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "fontStyle" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Label": function(label) { │ │ │ │ + return this.writers.sld._OGCExpression.call( │ │ │ │ + this, "sld:Label", label │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "Halo": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Halo"); │ │ │ │ + if (symbolizer.haloRadius) { │ │ │ │ + this.writeNode("Radius", symbolizer.haloRadius, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.haloColor || symbolizer.haloOpacity) { │ │ │ │ + this.writeNode("Fill", { │ │ │ │ + fillColor: symbolizer.haloColor, │ │ │ │ + fillOpacity: symbolizer.haloOpacity │ │ │ │ + }, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Radius": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:Radius", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "RasterSymbolizer": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:RasterSymbolizer"); │ │ │ │ + if (symbolizer.geometry) { │ │ │ │ + this.writeNode("Geometry", symbolizer.geometry, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.opacity) { │ │ │ │ + this.writeNode("Opacity", symbolizer.opacity, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.colorMap) { │ │ │ │ + this.writeNode("ColorMap", symbolizer.colorMap, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Geometry": function(geometry) { │ │ │ │ + var node = this.createElementNSPlus("sld:Geometry"); │ │ │ │ + if (geometry.property) { │ │ │ │ + this.writeNode("ogc:PropertyName", geometry, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ColorMap": function(colorMap) { │ │ │ │ + var node = this.createElementNSPlus("sld:ColorMap"); │ │ │ │ + for (var i = 0, len = colorMap.length; i < len; ++i) { │ │ │ │ + this.writeNode("ColorMapEntry", colorMap[i], node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ColorMapEntry": function(colorMapEntry) { │ │ │ │ + var node = this.createElementNSPlus("sld:ColorMapEntry"); │ │ │ │ + var a = colorMapEntry; │ │ │ │ + node.setAttribute("color", a.color); │ │ │ │ + a.opacity !== undefined && node.setAttribute("opacity", │ │ │ │ + parseFloat(a.opacity)); │ │ │ │ + a.quantity !== undefined && node.setAttribute("quantity", │ │ │ │ + parseFloat(a.quantity)); │ │ │ │ + a.label !== undefined && node.setAttribute("label", a.label); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "PolygonSymbolizer": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:PolygonSymbolizer"); │ │ │ │ + if (symbolizer.fill !== false) { │ │ │ │ + this.writeNode("Fill", symbolizer, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.stroke !== false) { │ │ │ │ + this.writeNode("Stroke", symbolizer, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Fill": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Fill"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: drawHandles │ │ │ │ - * Draws the handles to match the box. │ │ │ │ - */ │ │ │ │ - drawHandles: function() { │ │ │ │ - var layer = this.layer; │ │ │ │ - for (var i = 0; i < 8; ++i) { │ │ │ │ - if (this.rotate && i % 2 === 0) { │ │ │ │ - layer.drawFeature(this.rotationHandles[i / 2], │ │ │ │ - this.rotationHandleSymbolizer); │ │ │ │ - } │ │ │ │ - layer.drawFeature(this.handles[i], this.renderIntent); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + // GraphicFill here │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: transformFeature │ │ │ │ - * Transforms the feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * mods - {Object} An object with optional scale, ratio, rotation and │ │ │ │ - * center properties. │ │ │ │ - */ │ │ │ │ - transformFeature: function(mods) { │ │ │ │ - if (!this._setfeature) { │ │ │ │ - this.scale *= (mods.scale || 1); │ │ │ │ - this.ratio *= (mods.ratio || 1); │ │ │ │ - var oldRotation = this.rotation; │ │ │ │ - this.rotation = (this.rotation + (mods.rotation || 0)) % 360; │ │ │ │ + // add in CssParameters │ │ │ │ + if (symbolizer.fillColor) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "fillColor" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (symbolizer.fillOpacity != null) { │ │ │ │ + this.writeNode( │ │ │ │ + "CssParameter", { │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + key: "fillOpacity" │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "PointSymbolizer": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:PointSymbolizer"); │ │ │ │ + this.writeNode("Graphic", symbolizer, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Graphic": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Graphic"); │ │ │ │ + if (symbolizer.externalGraphic != undefined) { │ │ │ │ + this.writeNode("ExternalGraphic", symbolizer, node); │ │ │ │ + } else { │ │ │ │ + this.writeNode("Mark", symbolizer, node); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (this.events.triggerEvent("beforetransform", mods) !== false) { │ │ │ │ - var feature = this.feature; │ │ │ │ - var geom = feature.geometry; │ │ │ │ - var center = this.center; │ │ │ │ - geom.rotate(-oldRotation, center); │ │ │ │ - if (mods.scale || mods.ratio) { │ │ │ │ - geom.resize(mods.scale, center, mods.ratio); │ │ │ │ - } else if (mods.center) { │ │ │ │ - feature.move(mods.center.getBounds().getCenterLonLat()); │ │ │ │ + if (symbolizer.graphicOpacity != undefined) { │ │ │ │ + this.writeNode("Opacity", symbolizer.graphicOpacity, node); │ │ │ │ } │ │ │ │ - geom.rotate(this.rotation, center); │ │ │ │ - this.layer.drawFeature(feature); │ │ │ │ - feature.toState(OpenLayers.State.UPDATE); │ │ │ │ - this.events.triggerEvent("transform", mods); │ │ │ │ + if (symbolizer.pointRadius != undefined) { │ │ │ │ + this.writeNode("Size", symbolizer.pointRadius * 2, node); │ │ │ │ + } else if (symbolizer.graphicWidth != undefined) { │ │ │ │ + this.writeNode("Size", symbolizer.graphicWidth, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.rotation != undefined) { │ │ │ │ + this.writeNode("Rotation", symbolizer.rotation, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ExternalGraphic": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:ExternalGraphic"); │ │ │ │ + this.writeNode( │ │ │ │ + "OnlineResource", symbolizer.externalGraphic, node │ │ │ │ + ); │ │ │ │ + var format = symbolizer.graphicFormat || │ │ │ │ + this.getGraphicFormat(symbolizer.externalGraphic); │ │ │ │ + this.writeNode("Format", format, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Mark": function(symbolizer) { │ │ │ │ + var node = this.createElementNSPlus("sld:Mark"); │ │ │ │ + if (symbolizer.graphicName) { │ │ │ │ + this.writeNode("WellKnownName", symbolizer.graphicName, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.fill !== false) { │ │ │ │ + this.writeNode("Fill", symbolizer, node); │ │ │ │ + } │ │ │ │ + if (symbolizer.stroke !== false) { │ │ │ │ + this.writeNode("Stroke", symbolizer, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "WellKnownName": function(name) { │ │ │ │ + return this.createElementNSPlus("sld:WellKnownName", { │ │ │ │ + value: name │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Opacity": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:Opacity", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Size": function(value) { │ │ │ │ + return this.writers.sld._OGCExpression.call( │ │ │ │ + this, "sld:Size", value │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "Rotation": function(value) { │ │ │ │ + return this.createElementNSPlus("sld:Rotation", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "OnlineResource": function(href) { │ │ │ │ + return this.createElementNSPlus("sld:OnlineResource", { │ │ │ │ + attributes: { │ │ │ │ + "xlink:type": "simple", │ │ │ │ + "xlink:href": href │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Format": function(format) { │ │ │ │ + return this.createElementNSPlus("sld:Format", { │ │ │ │ + value: format │ │ │ │ + }); │ │ │ │ } │ │ │ │ } │ │ │ │ - this.layer.drawFeature(this.box, this.renderIntent); │ │ │ │ - this.drawHandles(); │ │ │ │ - }, │ │ │ │ + }, OpenLayers.Format.Filter.v1_0_0.prototype.writers), │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Take care of things that are not handled in superclass. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0; i < 8; ++i) { │ │ │ │ - geom = this.box.geometry.components[i]; │ │ │ │ - geom._handle.destroy(); │ │ │ │ - geom._handle = null; │ │ │ │ - geom._rotationHandle && geom._rotationHandle.destroy(); │ │ │ │ - geom._rotationHandle = null; │ │ │ │ - } │ │ │ │ - this.center = null; │ │ │ │ - this.feature = null; │ │ │ │ - this.handles = null; │ │ │ │ - this.rotationHandleSymbolizer = null; │ │ │ │ - this.rotationHandles = null; │ │ │ │ - this.box.destroy(); │ │ │ │ - this.box = null; │ │ │ │ - this.layer = null; │ │ │ │ - this.dragControl.destroy(); │ │ │ │ - this.dragControl = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SLD.v1" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.TransformFeature" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/DrawFeature.js │ │ │ │ + OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/SLD/v1.js │ │ │ │ + * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.SLD.v1_0_0 │ │ │ │ + * Write SLD version 1.0.0. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.SLD.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.SLD.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.SLD.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.0.0 │ │ │ │ + */ │ │ │ │ + VERSION: "1.0.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/sld │ │ │ │ + * http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.SLD.v1_0_0 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.SLD> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/SLD/v1_0_0_GeoServer.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.DrawFeature │ │ │ │ - * The DrawFeature control draws point, line or polygon features on a vector │ │ │ │ - * layer when active. │ │ │ │ + * Class: OpenLayers.Format.SLD/v1_0_0_GeoServer │ │ │ │ + * Read and write SLD version 1.0.0 with GeoServer-specific enhanced options. │ │ │ │ + * See http://svn.osgeo.org/geotools/trunk/modules/extension/xsd/xsd-sld/src/main/resources/org/geotools/sld/bindings/StyledLayerDescriptor.xsd │ │ │ │ + * for more information. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.SLD.v1_0_0> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.DrawFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.SLD.v1_0_0_GeoServer = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.SLD.v1_0_0, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} The specific parser version. │ │ │ │ + */ │ │ │ │ + version: "1.0.0", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: profile │ │ │ │ + * {String} The specific profile │ │ │ │ + */ │ │ │ │ + profile: "GeoServer", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.SLD.v1_0_0_GeoServer │ │ │ │ + * Create a new parser for GeoServer-enhanced SLD version 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: OpenLayers.Util.applyDefaults({ │ │ │ │ + "sld": OpenLayers.Util.applyDefaults({ │ │ │ │ + "Priority": function(node, obj) { │ │ │ │ + var value = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (value) { │ │ │ │ + obj.priority = value; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "VendorOption": function(node, obj) { │ │ │ │ + if (!obj.vendorOptions) { │ │ │ │ + obj.vendorOptions = {}; │ │ │ │ + } │ │ │ │ + obj.vendorOptions[node.getAttribute("name")] = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "TextSymbolizer": function(node, rule) { │ │ │ │ + OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld.TextSymbolizer.apply(this, arguments); │ │ │ │ + var symbolizer = this.multipleSymbolizers ? rule.symbolizers[rule.symbolizers.length - 1] : rule.symbolizer["Text"]; │ │ │ │ + if (symbolizer.graphic === undefined) { │ │ │ │ + symbolizer.graphic = false; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.readers["sld"]) │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.readers), │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: OpenLayers.Util.applyDefaults({ │ │ │ │ + "sld": OpenLayers.Util.applyDefaults({ │ │ │ │ + "Priority": function(priority) { │ │ │ │ + return this.writers.sld._OGCExpression.call( │ │ │ │ + this, "sld:Priority", priority │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + "VendorOption": function(option) { │ │ │ │ + return this.createElementNSPlus("sld:VendorOption", { │ │ │ │ + attributes: { │ │ │ │ + name: option.name │ │ │ │ + }, │ │ │ │ + value: option.value │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "TextSymbolizer": function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["TextSymbolizer"].apply(this, arguments); │ │ │ │ + if (symbolizer.graphic !== false && (symbolizer.externalGraphic || symbolizer.graphicName)) { │ │ │ │ + this.writeNode("Graphic", symbolizer, node); │ │ │ │ + } │ │ │ │ + if ("priority" in symbolizer) { │ │ │ │ + this.writeNode("Priority", symbolizer.priority, node); │ │ │ │ + } │ │ │ │ + return this.addVendorOptions(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "PointSymbolizer": function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["PointSymbolizer"].apply(this, arguments); │ │ │ │ + return this.addVendorOptions(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "LineSymbolizer": function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["LineSymbolizer"].apply(this, arguments); │ │ │ │ + return this.addVendorOptions(node, symbolizer); │ │ │ │ + }, │ │ │ │ + "PolygonSymbolizer": function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["PolygonSymbolizer"].apply(this, arguments); │ │ │ │ + return this.addVendorOptions(node, symbolizer); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.writers["sld"]) │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.writers), │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: addVendorOptions │ │ │ │ + * Add in the VendorOption tags and return the node again. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} A DOM node. │ │ │ │ + * symbolizer - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A DOM node. │ │ │ │ + */ │ │ │ │ + addVendorOptions: function(node, symbolizer) { │ │ │ │ + var options = symbolizer.vendorOptions; │ │ │ │ + if (options) { │ │ │ │ + for (var key in symbolizer.vendorOptions) { │ │ │ │ + this.writeNode("VendorOption", { │ │ │ │ + name: key, │ │ │ │ + value: symbolizer.vendorOptions[key] │ │ │ │ + }, node); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0_GeoServer" │ │ │ │ + │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/OWSContext/v0_3_1.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/KML.js │ │ │ │ + * @requires OpenLayers/Format/GML.js │ │ │ │ + * @requires OpenLayers/Format/GML/v2.js │ │ │ │ + * @requires OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ + * @requires OpenLayers/Format/OWSContext.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_0_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.OWSContext.v0_3_1 │ │ │ │ + * Read and write OWSContext version 0.3.1. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.OWSContext.v0_3_1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + namespaces: { │ │ │ │ + owc: "http://www.opengis.net/ows-context", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + kml: "http://www.opengis.net/kml/2.2", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + ows: "http://www.opengis.net/ows", │ │ │ │ + sld: "http://www.opengis.net/sld", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: callbacks │ │ │ │ - * {Object} The functions that are sent to the handler for callback │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 0.3.1 │ │ │ │ */ │ │ │ │ - callbacks: null, │ │ │ │ + VERSION: "0.3.1", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * featureadded - Triggered when a feature is added │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location │ │ │ │ */ │ │ │ │ + schemaLocation: "http://www.opengis.net/ows-context http://www.ogcnetwork.net/schemas/owc/0.3.1/owsContext.xsd", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: multi │ │ │ │ - * {Boolean} Cast features to multi-part geometries before passing to the │ │ │ │ - * layer. Default is false. │ │ │ │ + * Property: defaultPrefix │ │ │ │ + * {String} Default namespace prefix to use. │ │ │ │ */ │ │ │ │ - multi: false, │ │ │ │ + defaultPrefix: "owc", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: featureAdded │ │ │ │ - * {Function} Called after each feature is added │ │ │ │ + * APIProperty: extractAttributes │ │ │ │ + * {Boolean} Extract attributes from GML. Default is true. │ │ │ │ */ │ │ │ │ - featureAdded: function() {}, │ │ │ │ + extractAttributes: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the control's handler │ │ │ │ + * APIProperty: xy │ │ │ │ + * {Boolean} Order of the GML coordinate true:(x,y) or false:(y,x) │ │ │ │ + * Changing is not recommended, a new Format should be instantiated. │ │ │ │ */ │ │ │ │ + xy: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.DrawFeature │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ - * handler - {<OpenLayers.Handler>} │ │ │ │ - * options - {Object} │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ */ │ │ │ │ - initialize: function(layer, handler, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.callbacks = OpenLayers.Util.extend({ │ │ │ │ - done: this.drawFeature, │ │ │ │ - modify: function(vertex, feature) { │ │ │ │ - this.layer.events.triggerEvent( │ │ │ │ - "sketchmodified", { │ │ │ │ - vertex: vertex, │ │ │ │ - feature: feature │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - create: function(vertex, feature) { │ │ │ │ - this.layer.events.triggerEvent( │ │ │ │ - "sketchstarted", { │ │ │ │ - vertex: vertex, │ │ │ │ - feature: feature │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - this.callbacks │ │ │ │ - ); │ │ │ │ - this.layer = layer; │ │ │ │ - this.handlerOptions = this.handlerOptions || {}; │ │ │ │ - this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults( │ │ │ │ - this.handlerOptions.layerOptions, { │ │ │ │ - renderers: layer.renderers, │ │ │ │ - rendererOptions: layer.rendererOptions │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - if (!("multi" in this.handlerOptions)) { │ │ │ │ - this.handlerOptions.multi = this.multi; │ │ │ │ - } │ │ │ │ - var sketchStyle = this.layer.styleMap && this.layer.styleMap.styles.temporary; │ │ │ │ - if (sketchStyle) { │ │ │ │ - this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults( │ │ │ │ - this.handlerOptions.layerOptions, { │ │ │ │ - styleMap: new OpenLayers.StyleMap({ │ │ │ │ - "default": sketchStyle │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.handler = new handler(this, this.callbacks, this.handlerOptions); │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: drawFeature │ │ │ │ + * Property: featureNS │ │ │ │ + * {String} The namespace uri to use for writing InlineGeometry │ │ │ │ */ │ │ │ │ - drawFeature: function(geometry) { │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - var proceed = this.layer.events.triggerEvent( │ │ │ │ - "sketchcomplete", { │ │ │ │ - feature: feature │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - if (proceed !== false) { │ │ │ │ - feature.state = OpenLayers.State.INSERT; │ │ │ │ - this.layer.addFeatures([feature]); │ │ │ │ - this.featureAdded(feature); │ │ │ │ - this.events.triggerEvent("featureadded", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: insertXY │ │ │ │ - * Insert a point in the current sketch given x & y coordinates. │ │ │ │ + * Property: featureType │ │ │ │ + * {String} The name to use as the feature type when writing out │ │ │ │ + * InlineGeometry │ │ │ │ + */ │ │ │ │ + featureType: 'vector', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: geometryName │ │ │ │ + * {String} The name to use for the geometry attribute when writing out │ │ │ │ + * InlineGeometry │ │ │ │ + */ │ │ │ │ + geometryName: 'geometry', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: nestingLayerLookup │ │ │ │ + * {Object} Hashtable lookup for nesting layer nodes. Used while writing │ │ │ │ + * the OWS context document. It is necessary to keep track of the │ │ │ │ + * nestingPaths for which nesting layer nodes have already been │ │ │ │ + * created, so (nesting) layer nodes are added to those nodes. │ │ │ │ + * │ │ │ │ + * For example: │ │ │ │ + * │ │ │ │ + * If there are three layers with nestingPaths: │ │ │ │ + * layer1.metadata.nestingPath = "a/b/" │ │ │ │ + * layer2.metadata.nestingPath = "a/b/" │ │ │ │ + * layer2.metadata.nestingPath = "a/c" │ │ │ │ + * │ │ │ │ + * then a nesting layer node "a" should be created once and added │ │ │ │ + * to the resource list, a nesting layer node "b" should be created │ │ │ │ + * once and added under "a", and a nesting layer node "c" should be │ │ │ │ + * created and added under "a". The lookup paths for these nodes │ │ │ │ + * will be "a", "a/b", and "a/c" respectively. │ │ │ │ + */ │ │ │ │ + nestingLayerLookup: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.OWSContext.v0_3_1 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.OWSContext> constructor instead. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * x - {Number} The x-coordinate of the point. │ │ │ │ - * y - {Number} The y-coordinate of the point. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - insertXY: function(x, y) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertXY(x, y); │ │ │ │ - } │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + OpenLayers.Format.GML.v2.prototype.setGeometryTypes.call(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: insertDeltaXY │ │ │ │ - * Insert a point given offsets from the previously inserted point. │ │ │ │ + * Method: setNestingPath │ │ │ │ + * Set the nestingPath property of the layer depending on the position │ │ │ │ + * of the layer in hierarchy of layers. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * dx - {Number} The x-coordinate offset of the point. │ │ │ │ - * dy - {Number} The y-coordinate offset of the point. │ │ │ │ + * l - {Object} An object that may have a layersContext array property. │ │ │ │ + * │ │ │ │ */ │ │ │ │ - insertDeltaXY: function(dx, dy) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertDeltaXY(dx, dy); │ │ │ │ + setNestingPath: function(l) { │ │ │ │ + if (l.layersContext) { │ │ │ │ + for (var i = 0, len = l.layersContext.length; i < len; i++) { │ │ │ │ + var layerContext = l.layersContext[i]; │ │ │ │ + var nPath = []; │ │ │ │ + var nTitle = l.title || ""; │ │ │ │ + if (l.metadata && l.metadata.nestingPath) { │ │ │ │ + nPath = l.metadata.nestingPath.slice(); │ │ │ │ + } │ │ │ │ + if (nTitle != "") { │ │ │ │ + nPath.push(nTitle); │ │ │ │ + } │ │ │ │ + layerContext.metadata.nestingPath = nPath; │ │ │ │ + if (layerContext.layersContext) { │ │ │ │ + this.setNestingPath(layerContext); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: insertDirectionLength │ │ │ │ - * Insert a point in the current sketch given a direction and a length. │ │ │ │ + * Function: decomposeNestingPath │ │ │ │ + * Takes a nestingPath like "a/b/c" and decomposes it into subpaths: │ │ │ │ + * "a", "a/b", "a/b/c" │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * direction - {Number} Degrees clockwise from the positive x-axis. │ │ │ │ - * length - {Number} Distance from the previously drawn point. │ │ │ │ + * nPath - {Array} the nesting path │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * Array({String}) Array with subpaths, or empty array if there is nothing │ │ │ │ + * to decompose │ │ │ │ */ │ │ │ │ - insertDirectionLength: function(direction, length) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertDirectionLength(direction, length); │ │ │ │ + decomposeNestingPath: function(nPath) { │ │ │ │ + var a = []; │ │ │ │ + if (OpenLayers.Util.isArray(nPath)) { │ │ │ │ + var path = nPath.slice(); │ │ │ │ + while (path.length > 0) { │ │ │ │ + a.push(path.slice()); │ │ │ │ + path.pop(); │ │ │ │ + } │ │ │ │ + a.reverse(); │ │ │ │ } │ │ │ │ + return a; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: insertDeflectionLength │ │ │ │ - * Insert a point in the current sketch given a deflection and a length. │ │ │ │ - * The deflection should be degrees clockwise from the previously │ │ │ │ - * digitized segment. │ │ │ │ + * APIMethod: read │ │ │ │ + * Read OWS context data from a string or DOMElement, and return a list │ │ │ │ + * of layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * deflection - {Number} Degrees clockwise from the previous segment. │ │ │ │ - * length - {Number} Distance from the previously drawn point. │ │ │ │ + * Returns: │ │ │ │ + * {Object} The context object with a flat layer list as a property named │ │ │ │ + * layersContext. │ │ │ │ */ │ │ │ │ - insertDeflectionLength: function(deflection, length) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertDeflectionLength(deflection, length); │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var context = {}; │ │ │ │ + this.readNode(data, context); │ │ │ │ + // since an OWSContext can be nested we need to go through this │ │ │ │ + // structure recursively │ │ │ │ + this.setNestingPath({ │ │ │ │ + layersContext: context.layersContext │ │ │ │ + }); │ │ │ │ + // after nesting path has been set, create a flat list of layers │ │ │ │ + var layers = []; │ │ │ │ + this.processLayer(layers, context); │ │ │ │ + delete context.layersContext; │ │ │ │ + context.layersContext = layers; │ │ │ │ + return context; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: undo │ │ │ │ - * Remove the most recently added point in the current sketch geometry. │ │ │ │ + * Method: processLayer │ │ │ │ + * Recursive function to get back a flat list of layers from the hierarchic │ │ │ │ + * layer structure. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} An edit was undone. │ │ │ │ + * Parameters: │ │ │ │ + * layerArray - {Array({Object})} Array of layerContext objects │ │ │ │ + * layer - {Object} layerContext object │ │ │ │ */ │ │ │ │ - undo: function() { │ │ │ │ - return this.handler.undo && this.handler.undo(); │ │ │ │ + processLayer: function(layerArray, layer) { │ │ │ │ + if (layer.layersContext) { │ │ │ │ + for (var i = 0, len = layer.layersContext.length; i < len; i++) { │ │ │ │ + var l = layer.layersContext[i]; │ │ │ │ + layerArray.push(l); │ │ │ │ + if (l.layersContext) { │ │ │ │ + this.processLayer(layerArray, l); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: redo │ │ │ │ - * Reinsert the most recently removed point resulting from an <undo> call. │ │ │ │ - * The undo stack is deleted whenever a point is added by other means. │ │ │ │ + * APIMethod: write │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} An edit was redone. │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} An object representing the map context. │ │ │ │ + * options - {Object} Optional object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} An OWS Context document string. │ │ │ │ */ │ │ │ │ - redo: function() { │ │ │ │ - return this.handler.redo && this.handler.redo(); │ │ │ │ + write: function(context, options) { │ │ │ │ + var name = "OWSContext"; │ │ │ │ + this.nestingLayerLookup = {}; //start with empty lookup │ │ │ │ + options = options || {}; │ │ │ │ + OpenLayers.Util.applyDefaults(options, context); │ │ │ │ + var root = this.writeNode(name, options); │ │ │ │ + this.nestingLayerLookup = null; //clear lookup │ │ │ │ + this.setAttributeNS( │ │ │ │ + root, this.namespaces["xsi"], │ │ │ │ + "xsi:schemaLocation", this.schemaLocation │ │ │ │ + ); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: finishSketch │ │ │ │ - * Finishes the sketch without including the currently drawn point. │ │ │ │ - * This method can be called to terminate drawing programmatically │ │ │ │ - * instead of waiting for the user to end the sketch. │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ */ │ │ │ │ - finishSketch: function() { │ │ │ │ - this.handler.finishGeometry(); │ │ │ │ + readers: { │ │ │ │ + "kml": { │ │ │ │ + "Document": function(node, obj) { │ │ │ │ + obj.features = new OpenLayers.Format.KML({ │ │ │ │ + kmlns: this.namespaces.kml, │ │ │ │ + extractStyles: true │ │ │ │ + }).read(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "owc": { │ │ │ │ + "OWSContext": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "General": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "ResourceList": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Layer": function(node, obj) { │ │ │ │ + var layerContext = { │ │ │ │ + metadata: {}, │ │ │ │ + visibility: (node.getAttribute("hidden") != "1"), │ │ │ │ + queryable: (node.getAttribute("queryable") == "1"), │ │ │ │ + opacity: ((node.getAttribute("opacity") != null) ? │ │ │ │ + parseFloat(node.getAttribute("opacity")) : null), │ │ │ │ + name: node.getAttribute("name"), │ │ │ │ + /* A category layer is a dummy layer meant for creating │ │ │ │ + hierarchies. It is not a physical layer in the │ │ │ │ + OpenLayers sense. The assumption we make here is that │ │ │ │ + category layers do not have a name attribute */ │ │ │ │ + categoryLayer: (node.getAttribute("name") == null), │ │ │ │ + formats: [], │ │ │ │ + styles: [] │ │ │ │ + }; │ │ │ │ + if (!obj.layersContext) { │ │ │ │ + obj.layersContext = []; │ │ │ │ + } │ │ │ │ + obj.layersContext.push(layerContext); │ │ │ │ + this.readChildNodes(node, layerContext); │ │ │ │ + }, │ │ │ │ + "InlineGeometry": function(node, obj) { │ │ │ │ + obj.features = []; │ │ │ │ + var elements = this.getElementsByTagNameNS(node, │ │ │ │ + this.namespaces.gml, "featureMember"); │ │ │ │ + var el; │ │ │ │ + if (elements.length >= 1) { │ │ │ │ + el = elements[0]; │ │ │ │ + } │ │ │ │ + if (el && el.firstChild) { │ │ │ │ + var featurenode = (el.firstChild.nextSibling) ? │ │ │ │ + el.firstChild.nextSibling : el.firstChild; │ │ │ │ + this.setNamespace("feature", featurenode.namespaceURI); │ │ │ │ + this.featureType = featurenode.localName || │ │ │ │ + featurenode.nodeName.split(":").pop(); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Server": function(node, obj) { │ │ │ │ + // when having multiple Server types, we prefer WMS │ │ │ │ + if ((!obj.service && !obj.version) || │ │ │ │ + (obj.service != │ │ │ │ + OpenLayers.Format.Context.serviceTypes.WMS)) { │ │ │ │ + obj.service = node.getAttribute("service"); │ │ │ │ + obj.version = node.getAttribute("version"); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "Name": function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Title": function(node, obj) { │ │ │ │ + obj.title = this.getChildValue(node); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "StyleList": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj.styles); │ │ │ │ + }, │ │ │ │ + "Style": function(node, obj) { │ │ │ │ + var style = {}; │ │ │ │ + obj.push(style); │ │ │ │ + this.readChildNodes(node, style); │ │ │ │ + }, │ │ │ │ + "LegendURL": function(node, obj) { │ │ │ │ + var legend = {}; │ │ │ │ + obj.legend = legend; │ │ │ │ + this.readChildNodes(node, legend); │ │ │ │ + }, │ │ │ │ + "OnlineResource": function(node, obj) { │ │ │ │ + obj.url = this.getAttributeNS(node, this.namespaces.xlink, │ │ │ │ + "href"); │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers.ows, │ │ │ │ + "gml": OpenLayers.Format.GML.v2.prototype.readers.gml, │ │ │ │ + "sld": OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld, │ │ │ │ + "feature": OpenLayers.Format.GML.v2.prototype.readers.feature │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: cancel │ │ │ │ - * Cancel the current sketch. This removes the current sketch and keeps │ │ │ │ - * the drawing control active. │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ */ │ │ │ │ - cancel: function() { │ │ │ │ - this.handler.cancel(); │ │ │ │ + writers: { │ │ │ │ + "owc": { │ │ │ │ + "OWSContext": function(options) { │ │ │ │ + var node = this.createElementNSPlus("OWSContext", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + id: options.id || OpenLayers.Util.createUniqueID("OpenLayers_OWSContext_") │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("General", options, node); │ │ │ │ + this.writeNode("ResourceList", options, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "General": function(options) { │ │ │ │ + var node = this.createElementNSPlus("General"); │ │ │ │ + this.writeNode("ows:BoundingBox", options, node); │ │ │ │ + this.writeNode("ows:Title", options.title || 'OpenLayers OWSContext', node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ResourceList": function(options) { │ │ │ │ + var node = this.createElementNSPlus("ResourceList"); │ │ │ │ + for (var i = 0, len = options.layers.length; i < len; i++) { │ │ │ │ + var layer = options.layers[i]; │ │ │ │ + var decomposedPath = this.decomposeNestingPath(layer.metadata.nestingPath); │ │ │ │ + this.writeNode("_Layer", { │ │ │ │ + layer: layer, │ │ │ │ + subPaths: decomposedPath │ │ │ │ + }, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Server": function(options) { │ │ │ │ + var node = this.createElementNSPlus("Server", { │ │ │ │ + attributes: { │ │ │ │ + version: options.version, │ │ │ │ + service: options.service │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("OnlineResource", options, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "OnlineResource": function(options) { │ │ │ │ + var node = this.createElementNSPlus("OnlineResource", { │ │ │ │ + attributes: { │ │ │ │ + "xlink:href": options.url │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "InlineGeometry": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("InlineGeometry"), │ │ │ │ + dataExtent = layer.getDataExtent(); │ │ │ │ + if (dataExtent !== null) { │ │ │ │ + this.writeNode("gml:boundedBy", dataExtent, node); │ │ │ │ + } │ │ │ │ + for (var i = 0, len = layer.features.length; i < len; i++) { │ │ │ │ + this.writeNode("gml:featureMember", layer.features[i], node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "StyleList": function(styles) { │ │ │ │ + var node = this.createElementNSPlus("StyleList"); │ │ │ │ + for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ + this.writeNode("Style", styles[i], node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Style": function(style) { │ │ │ │ + var node = this.createElementNSPlus("Style"); │ │ │ │ + this.writeNode("Name", style, node); │ │ │ │ + this.writeNode("Title", style, node); │ │ │ │ + if (style.legend) { │ │ │ │ + this.writeNode("LegendURL", style, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Name": function(obj) { │ │ │ │ + var node = this.createElementNSPlus("Name", { │ │ │ │ + value: obj.name │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Title": function(obj) { │ │ │ │ + var node = this.createElementNSPlus("Title", { │ │ │ │ + value: obj.title │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "LegendURL": function(style) { │ │ │ │ + var node = this.createElementNSPlus("LegendURL"); │ │ │ │ + this.writeNode("OnlineResource", style.legend, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "_WMS": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer", { │ │ │ │ + attributes: { │ │ │ │ + name: layer.params.LAYERS, │ │ │ │ + queryable: layer.queryable ? "1" : "0", │ │ │ │ + hidden: layer.visibility ? "0" : "1", │ │ │ │ + opacity: layer.hasOwnProperty("opacity") ? layer.opacity : null │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("ows:OutputFormat", layer.params.FORMAT, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.WMS, │ │ │ │ + version: layer.params.VERSION, │ │ │ │ + url: layer.url │ │ │ │ + }, node); │ │ │ │ + if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ + this.writeNode("StyleList", layer.metadata.styles, node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "_Layer": function(options) { │ │ │ │ + var layer, subPaths, node, title; │ │ │ │ + layer = options.layer; │ │ │ │ + subPaths = options.subPaths; │ │ │ │ + node = null; │ │ │ │ + title = null; │ │ │ │ + // subPaths is an array of an array │ │ │ │ + // recursively calling _Layer writer eats up subPaths, until a │ │ │ │ + // real writer is called and nodes are returned. │ │ │ │ + if (subPaths.length > 0) { │ │ │ │ + var path = subPaths[0].join("/"); │ │ │ │ + var index = path.lastIndexOf("/"); │ │ │ │ + node = this.nestingLayerLookup[path]; │ │ │ │ + title = (index > 0) ? path.substring(index + 1, path.length) : path; │ │ │ │ + if (!node) { │ │ │ │ + // category layer │ │ │ │ + node = this.createElementNSPlus("Layer"); │ │ │ │ + this.writeNode("ows:Title", title, node); │ │ │ │ + this.nestingLayerLookup[path] = node; │ │ │ │ + } │ │ │ │ + options.subPaths.shift(); //remove a path after each call │ │ │ │ + this.writeNode("_Layer", options, node); │ │ │ │ + return node; │ │ │ │ + } else { │ │ │ │ + // write out the actual layer │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ + node = this.writeNode("_WMS", layer); │ │ │ │ + } else if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ + if (layer.protocol instanceof OpenLayers.Protocol.WFS.v1) { │ │ │ │ + node = this.writeNode("_WFS", layer); │ │ │ │ + } else if (layer.protocol instanceof OpenLayers.Protocol.HTTP) { │ │ │ │ + if (layer.protocol.format instanceof OpenLayers.Format.GML) { │ │ │ │ + layer.protocol.format.version = "2.1.2"; │ │ │ │ + node = this.writeNode("_GML", layer); │ │ │ │ + } else if (layer.protocol.format instanceof OpenLayers.Format.KML) { │ │ │ │ + layer.protocol.format.version = "2.2"; │ │ │ │ + node = this.writeNode("_KML", layer); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // write out as inline GML since we have no idea │ │ │ │ + // about the original Format │ │ │ │ + this.setNamespace("feature", this.featureNS); │ │ │ │ + node = this.writeNode("_InlineGeometry", layer); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (layer.options.maxScale) { │ │ │ │ + this.writeNode("sld:MinScaleDenominator", │ │ │ │ + layer.options.maxScale, node); │ │ │ │ + } │ │ │ │ + if (layer.options.minScale) { │ │ │ │ + this.writeNode("sld:MaxScaleDenominator", │ │ │ │ + layer.options.minScale, node); │ │ │ │ + } │ │ │ │ + this.nestingLayerLookup[layer.name] = node; │ │ │ │ + return node; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "_WFS": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer", { │ │ │ │ + attributes: { │ │ │ │ + name: layer.protocol.featurePrefix + ":" + layer.protocol.featureType, │ │ │ │ + hidden: layer.visibility ? "0" : "1" │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.WFS, │ │ │ │ + version: layer.protocol.version, │ │ │ │ + url: layer.protocol.url │ │ │ │ + }, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "_InlineGeometry": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer", { │ │ │ │ + attributes: { │ │ │ │ + name: this.featureType, │ │ │ │ + hidden: layer.visibility ? "0" : "1" │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("InlineGeometry", layer, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "_GML": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer"); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.GML, │ │ │ │ + url: layer.protocol.url, │ │ │ │ + version: layer.protocol.format.version │ │ │ │ + }, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "_KML": function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer"); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.KML, │ │ │ │ + version: layer.protocol.format.version, │ │ │ │ + url: layer.protocol.url │ │ │ │ + }, node); │ │ │ │ + return node; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ + "boundedBy": function(bounds) { │ │ │ │ + var node = this.createElementNSPlus("gml:boundedBy"); │ │ │ │ + this.writeNode("gml:Box", bounds, node); │ │ │ │ + return node; │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.GML.v2.prototype.writers.gml), │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_0_0.prototype.writers.ows, │ │ │ │ + "sld": OpenLayers.Format.SLD.v1_0_0.prototype.writers.sld, │ │ │ │ + "feature": OpenLayers.Format.GML.v2.prototype.writers.feature │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DrawFeature" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.OWSContext.v0_3_1" │ │ │ │ + │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/ZoomOut.js │ │ │ │ + OpenLayers/Format/XLS/v1.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/Button.js │ │ │ │ + * @requires OpenLayers/Format/XLS.js │ │ │ │ + * @requires OpenLayers/Format/GML/v3.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.ZoomOut │ │ │ │ - * The ZoomOut control is a button to decrease the zoom level of a map. │ │ │ │ + * Class: OpenLayers.Format.XLS.v1 │ │ │ │ + * Superclass for XLS version 1 parsers. Only supports GeocodeRequest for now. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.ZoomOut = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ +OpenLayers.Format.XLS.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: trigger │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.zoomOut(); │ │ │ │ + namespaces: { │ │ │ │ + xls: "http://www.opengis.net/xls", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: xy │ │ │ │ + * {Boolean} Order of the GML coordinate true:(x,y) or false:(y,x) │ │ │ │ + * Changing is not recommended, a new Format should be instantiated. │ │ │ │ + */ │ │ │ │ + xy: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + */ │ │ │ │ + defaultPrefix: "xls", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} Schema location for a particular minor version. │ │ │ │ + */ │ │ │ │ + schemaLocation: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.XLS.v1 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.XLS> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: read │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {DOMElement} An XLS document element. │ │ │ │ + * options - {Object} Options for the reader. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object representing the XLSResponse. │ │ │ │ + */ │ │ │ │ + read: function(data, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var xls = {}; │ │ │ │ + this.readChildNodes(data, xls); │ │ │ │ + return xls; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "xls": { │ │ │ │ + "XLS": function(node, xls) { │ │ │ │ + xls.version = node.getAttribute("version"); │ │ │ │ + this.readChildNodes(node, xls); │ │ │ │ + }, │ │ │ │ + "Response": function(node, xls) { │ │ │ │ + this.readChildNodes(node, xls); │ │ │ │ + }, │ │ │ │ + "GeocodeResponse": function(node, xls) { │ │ │ │ + xls.responseLists = []; │ │ │ │ + this.readChildNodes(node, xls); │ │ │ │ + }, │ │ │ │ + "GeocodeResponseList": function(node, xls) { │ │ │ │ + var responseList = { │ │ │ │ + features: [], │ │ │ │ + numberOfGeocodedAddresses: parseInt(node.getAttribute("numberOfGeocodedAddresses")) │ │ │ │ + }; │ │ │ │ + xls.responseLists.push(responseList); │ │ │ │ + this.readChildNodes(node, responseList); │ │ │ │ + }, │ │ │ │ + "GeocodedAddress": function(node, responseList) { │ │ │ │ + var feature = new OpenLayers.Feature.Vector(); │ │ │ │ + responseList.features.push(feature); │ │ │ │ + this.readChildNodes(node, feature); │ │ │ │ + // post-process geometry │ │ │ │ + feature.geometry = feature.components[0]; │ │ │ │ + }, │ │ │ │ + "GeocodeMatchCode": function(node, feature) { │ │ │ │ + feature.attributes.matchCode = { │ │ │ │ + accuracy: parseFloat(node.getAttribute("accuracy")), │ │ │ │ + matchType: node.getAttribute("matchType") │ │ │ │ + }; │ │ │ │ + }, │ │ │ │ + "Address": function(node, feature) { │ │ │ │ + var address = { │ │ │ │ + countryCode: node.getAttribute("countryCode"), │ │ │ │ + addressee: node.getAttribute("addressee"), │ │ │ │ + street: [], │ │ │ │ + place: [] │ │ │ │ + }; │ │ │ │ + feature.attributes.address = address; │ │ │ │ + this.readChildNodes(node, address); │ │ │ │ + }, │ │ │ │ + "freeFormAddress": function(node, address) { │ │ │ │ + address.freeFormAddress = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "StreetAddress": function(node, address) { │ │ │ │ + this.readChildNodes(node, address); │ │ │ │ + }, │ │ │ │ + "Building": function(node, address) { │ │ │ │ + address.building = { │ │ │ │ + 'number': node.getAttribute("number"), │ │ │ │ + subdivision: node.getAttribute("subdivision"), │ │ │ │ + buildingName: node.getAttribute("buildingName") │ │ │ │ + }; │ │ │ │ + }, │ │ │ │ + "Street": function(node, address) { │ │ │ │ + // only support the built-in primitive type for now │ │ │ │ + address.street.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "Place": function(node, address) { │ │ │ │ + // type is one of CountrySubdivision, │ │ │ │ + // CountrySecondarySubdivision, Municipality or │ │ │ │ + // MunicipalitySubdivision │ │ │ │ + address.place[node.getAttribute("type")] = │ │ │ │ + this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "PostalCode": function(node, address) { │ │ │ │ + address.postalCode = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "gml": OpenLayers.Format.GML.v3.prototype.readers.gml │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: write │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * request - {Object} An object representing the geocode request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The root of an XLS document. │ │ │ │ + */ │ │ │ │ + write: function(request) { │ │ │ │ + return this.writers.xls.XLS.apply(this, [request]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: { │ │ │ │ + "xls": { │ │ │ │ + "XLS": function(request) { │ │ │ │ + var root = this.createElementNSPlus( │ │ │ │ + "xls:XLS", { │ │ │ │ + attributes: { │ │ │ │ + "version": this.VERSION, │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ + } │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + this.writeNode("RequestHeader", request.header, root); │ │ │ │ + this.writeNode("Request", request, root); │ │ │ │ + return root; │ │ │ │ + }, │ │ │ │ + "RequestHeader": function(header) { │ │ │ │ + return this.createElementNSPlus("xls:RequestHeader"); │ │ │ │ + }, │ │ │ │ + "Request": function(request) { │ │ │ │ + var node = this.createElementNSPlus("xls:Request", { │ │ │ │ + attributes: { │ │ │ │ + methodName: "GeocodeRequest", │ │ │ │ + requestID: request.requestID || "", │ │ │ │ + version: this.VERSION │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("GeocodeRequest", request.addresses, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "GeocodeRequest": function(addresses) { │ │ │ │ + var node = this.createElementNSPlus("xls:GeocodeRequest"); │ │ │ │ + for (var i = 0, len = addresses.length; i < len; i++) { │ │ │ │ + this.writeNode("Address", addresses[i], node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Address": function(address) { │ │ │ │ + var node = this.createElementNSPlus("xls:Address", { │ │ │ │ + attributes: { │ │ │ │ + countryCode: address.countryCode │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (address.freeFormAddress) { │ │ │ │ + this.writeNode("freeFormAddress", address.freeFormAddress, node); │ │ │ │ + } else { │ │ │ │ + if (address.street) { │ │ │ │ + this.writeNode("StreetAddress", address, node); │ │ │ │ + } │ │ │ │ + if (address.municipality) { │ │ │ │ + this.writeNode("Municipality", address.municipality, node); │ │ │ │ + } │ │ │ │ + if (address.countrySubdivision) { │ │ │ │ + this.writeNode("CountrySubdivision", address.countrySubdivision, node); │ │ │ │ + } │ │ │ │ + if (address.postalCode) { │ │ │ │ + this.writeNode("PostalCode", address.postalCode, node); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "freeFormAddress": function(freeFormAddress) { │ │ │ │ + return this.createElementNSPlus("freeFormAddress", { │ │ │ │ + value: freeFormAddress │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "StreetAddress": function(address) { │ │ │ │ + var node = this.createElementNSPlus("xls:StreetAddress"); │ │ │ │ + if (address.building) { │ │ │ │ + this.writeNode(node, "Building", address.building); │ │ │ │ + } │ │ │ │ + var street = address.street; │ │ │ │ + if (!(OpenLayers.Util.isArray(street))) { │ │ │ │ + street = [street]; │ │ │ │ + } │ │ │ │ + for (var i = 0, len = street.length; i < len; i++) { │ │ │ │ + this.writeNode("Street", street[i], node); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Building": function(building) { │ │ │ │ + return this.createElementNSPlus("xls:Building", { │ │ │ │ + attributes: { │ │ │ │ + "number": building["number"], │ │ │ │ + "subdivision": building.subdivision, │ │ │ │ + "buildingName": building.buildingName │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Street": function(street) { │ │ │ │ + return this.createElementNSPlus("xls:Street", { │ │ │ │ + value: street │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "Municipality": function(municipality) { │ │ │ │ + return this.createElementNSPlus("xls:Place", { │ │ │ │ + attributes: { │ │ │ │ + type: "Municipality" │ │ │ │ + }, │ │ │ │ + value: municipality │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "CountrySubdivision": function(countrySubdivision) { │ │ │ │ + return this.createElementNSPlus("xls:Place", { │ │ │ │ + attributes: { │ │ │ │ + type: "CountrySubdivision" │ │ │ │ + }, │ │ │ │ + value: countrySubdivision │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + "PostalCode": function(postalCode) { │ │ │ │ + return this.createElementNSPlus("xls:PostalCode", { │ │ │ │ + value: postalCode │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomOut" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.XLS.v1" │ │ │ │ + │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/UTFGrid.js │ │ │ │ + OpenLayers/Format/XLS/v1_1_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Hover.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Format/XLS/v1.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.UTFGrid │ │ │ │ - * │ │ │ │ - * This Control provides behavior associated with UTFGrid Layers. │ │ │ │ - * These 'hit grids' provide underlying feature attributes without │ │ │ │ - * calling the server (again). This control allows Mousemove, Hovering │ │ │ │ - * and Click events to trigger callbacks that use the attributes in │ │ │ │ - * whatever way you need. │ │ │ │ - * │ │ │ │ - * The most common example may be a UTFGrid layer containing feature │ │ │ │ - * attributes that are displayed in a div as you mouseover. │ │ │ │ - * │ │ │ │ - * Example Code: │ │ │ │ - * │ │ │ │ - * (start code) │ │ │ │ - * var world_utfgrid = new OpenLayers.Layer.UTFGrid( │ │ │ │ - * 'UTFGrid Layer', │ │ │ │ - * "http://tiles/world_utfgrid/${z}/${x}/${y}.json" │ │ │ │ - * ); │ │ │ │ - * map.addLayer(world_utfgrid); │ │ │ │ + * Class: OpenLayers.Format.XLS.v1_1_0 │ │ │ │ + * Read / write XLS version 1.1.0. │ │ │ │ * │ │ │ │ - * var control = new OpenLayers.Control.UTFGrid({ │ │ │ │ - * layers: [world_utfgrid], │ │ │ │ - * handlerMode: 'move', │ │ │ │ - * callback: function(infoLookup) { │ │ │ │ - * // do something with returned data │ │ │ │ - * │ │ │ │ - * } │ │ │ │ - * }) │ │ │ │ - * (end code) │ │ │ │ - * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.XLS.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.XLS.v1_1_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.XLS.v1, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constant: VERSION │ │ │ │ + * {String} 1.1 │ │ │ │ + */ │ │ │ │ + VERSION: "1.1", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/xls │ │ │ │ + * http://schemas.opengis.net/ols/1.1.0/LocationUtilityService.xsd │ │ │ │ + */ │ │ │ │ + schemaLocation: "http://www.opengis.net/xls http://schemas.opengis.net/ols/1.1.0/LocationUtilityService.xsd", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.XLS.v1_1_0 │ │ │ │ + * Instances of this class are not created directly. Use the │ │ │ │ + * <OpenLayers.Format.XLS> constructor instead. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.XLS.v1_1_0" │ │ │ │ + │ │ │ │ + }); │ │ │ │ + │ │ │ │ +// Support non standard implementation │ │ │ │ +OpenLayers.Format.XLS.v1_1 = OpenLayers.Format.XLS.v1_1_0; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/CSWGetRecords/v2_0_2.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Format/CSWGetRecords.js │ │ │ │ + * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ + * @requires OpenLayers/Format/Filter/v1_1_0.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_0_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.CSWGetRecords.v2_0_2 │ │ │ │ + * A format for creating CSWGetRecords v2.0.2 transactions. │ │ │ │ + * Create a new instance with the │ │ │ │ + * <OpenLayers.Format.CSWGetRecords.v2_0_2> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Format.XML> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.UTFGrid = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Format.CSWGetRecords.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + namespaces: { │ │ │ │ + csw: "http://www.opengis.net/cat/csw/2.0.2", │ │ │ │ + dc: "http://purl.org/dc/elements/1.1/", │ │ │ │ + dct: "http://purl.org/dc/terms/", │ │ │ │ + gmd: "http://www.isotc211.org/2005/gmd", │ │ │ │ + geonet: "http://www.fao.org/geonetwork", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + ows: "http://www.opengis.net/ows", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: Layers │ │ │ │ - * List of layers to consider. Must be Layer.UTFGrids │ │ │ │ - * `null` is the default indicating all UTFGrid Layers are queried. │ │ │ │ - * {Array} <OpenLayers.Layer.UTFGrid> │ │ │ │ + /** │ │ │ │ + * Property: defaultPrefix │ │ │ │ + * {String} The default prefix (used by Format.XML). │ │ │ │ */ │ │ │ │ - layers: null, │ │ │ │ + defaultPrefix: "csw", │ │ │ │ │ │ │ │ - /* Property: defaultHandlerOptions │ │ │ │ - * The default opts passed to the handler constructors │ │ │ │ + /** │ │ │ │ + * Property: version │ │ │ │ + * {String} CSW version number. │ │ │ │ */ │ │ │ │ - defaultHandlerOptions: { │ │ │ │ - 'delay': 300, │ │ │ │ - 'pixelTolerance': 4, │ │ │ │ - 'stopMove': false, │ │ │ │ - 'single': true, │ │ │ │ - 'double': false, │ │ │ │ - 'stopSingle': false, │ │ │ │ - 'stopDouble': false │ │ │ │ - }, │ │ │ │ + version: "2.0.2", │ │ │ │ │ │ │ │ - /* APIProperty: handlerMode │ │ │ │ - * Defaults to 'click'. Can be 'hover' or 'move'. │ │ │ │ + /** │ │ │ │ + * Property: schemaLocation │ │ │ │ + * {String} http://www.opengis.net/cat/csw/2.0.2 │ │ │ │ + * http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd │ │ │ │ */ │ │ │ │ - handlerMode: 'click', │ │ │ │ + schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setHandler │ │ │ │ - * sets this.handlerMode and calls resetHandler() │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * hm - {String} Handler Mode string; 'click', 'hover' or 'move'. │ │ │ │ + * APIProperty: requestId │ │ │ │ + * {String} Value of the requestId attribute of the GetRecords element. │ │ │ │ */ │ │ │ │ - setHandler: function(hm) { │ │ │ │ - this.handlerMode = hm; │ │ │ │ - this.resetHandler(); │ │ │ │ - }, │ │ │ │ + requestId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: resetHandler │ │ │ │ - * Deactivates the old hanlder and creates a new │ │ │ │ - * <OpenLayers.Handler> based on the mode specified in │ │ │ │ - * this.handlerMode │ │ │ │ - * │ │ │ │ + * APIProperty: resultType │ │ │ │ + * {String} Value of the resultType attribute of the GetRecords element, │ │ │ │ + * specifies the result type in the GetRecords response, "hits" is │ │ │ │ + * the default. │ │ │ │ */ │ │ │ │ - resetHandler: function() { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate(); │ │ │ │ - this.handler.destroy(); │ │ │ │ - this.handler = null; │ │ │ │ - } │ │ │ │ + resultType: null, │ │ │ │ │ │ │ │ - if (this.handlerMode == 'hover') { │ │ │ │ - // Handle this event on hover │ │ │ │ - this.handler = new OpenLayers.Handler.Hover( │ │ │ │ - this, { │ │ │ │ - 'pause': this.handleEvent, │ │ │ │ - 'move': this.reset │ │ │ │ - }, │ │ │ │ - this.handlerOptions │ │ │ │ - ); │ │ │ │ - } else if (this.handlerMode == 'click') { │ │ │ │ - // Handle this event on click │ │ │ │ - this.handler = new OpenLayers.Handler.Click( │ │ │ │ - this, { │ │ │ │ - 'click': this.handleEvent │ │ │ │ - }, this.handlerOptions │ │ │ │ - ); │ │ │ │ - } else if (this.handlerMode == 'move') { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover( │ │ │ │ - this, │ │ │ │ - // Handle this event while hovering OR moving │ │ │ │ - { │ │ │ │ - 'pause': this.handleEvent, │ │ │ │ - 'move': this.handleEvent │ │ │ │ - }, │ │ │ │ - this.handlerOptions │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (this.handler) { │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: outputFormat │ │ │ │ + * {String} Value of the outputFormat attribute of the GetRecords element, │ │ │ │ + * specifies the format of the GetRecords response, │ │ │ │ + * "application/xml" is the default. │ │ │ │ + */ │ │ │ │ + outputFormat: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: <OpenLayers.Control.UTFGrid> │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * APIProperty: outputSchema │ │ │ │ + * {String} Value of the outputSchema attribute of the GetRecords element, │ │ │ │ + * specifies the schema of the GetRecords response. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.handlerOptions = options.handlerOptions || this.defaultHandlerOptions; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.resetHandler(); │ │ │ │ - }, │ │ │ │ + outputSchema: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleEvent │ │ │ │ - * Internal method called when specified event is triggered. │ │ │ │ - * │ │ │ │ - * This method does several things: │ │ │ │ - * │ │ │ │ - * Gets the lonLat of the event. │ │ │ │ - * │ │ │ │ - * Loops through the appropriate hit grid layers and gathers the attributes. │ │ │ │ - * │ │ │ │ - * Passes the attributes to the callback │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * APIProperty: startPosition │ │ │ │ + * {String} Value of the startPosition attribute of the GetRecords element, │ │ │ │ + * specifies the start position (offset+1) for the GetRecords response, │ │ │ │ + * 1 is the default. │ │ │ │ */ │ │ │ │ - handleEvent: function(evt) { │ │ │ │ - if (evt == null) { │ │ │ │ - this.reset(); │ │ │ │ - return; │ │ │ │ - } │ │ │ │ + startPosition: null, │ │ │ │ │ │ │ │ - var lonLat = this.map.getLonLatFromPixel(evt.xy); │ │ │ │ - if (!lonLat) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: maxRecords │ │ │ │ + * {String} Value of the maxRecords attribute of the GetRecords element, │ │ │ │ + * specifies the maximum number of records in the GetRecords response, │ │ │ │ + * 10 is the default. │ │ │ │ + */ │ │ │ │ + maxRecords: null, │ │ │ │ │ │ │ │ - var layers = this.findLayers(); │ │ │ │ - if (layers.length > 0) { │ │ │ │ - var infoLookup = {}; │ │ │ │ - var layer, idx; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - layer = layers[i]; │ │ │ │ - idx = OpenLayers.Util.indexOf(this.map.layers, layer); │ │ │ │ - infoLookup[idx] = layer.getFeatureInfo(lonLat); │ │ │ │ - } │ │ │ │ - this.callback(infoLookup, lonLat, evt.xy); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: DistributedSearch │ │ │ │ + * {String} Value of the csw:DistributedSearch element, used when writing │ │ │ │ + * a csw:GetRecords document. │ │ │ │ + */ │ │ │ │ + DistributedSearch: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: ResponseHandler │ │ │ │ + * {Array({String})} Values of the csw:ResponseHandler elements, used when │ │ │ │ + * writting a csw:GetRecords document. │ │ │ │ + */ │ │ │ │ + ResponseHandler: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: Query │ │ │ │ + * {String} Value of the csw:Query element, used when writing a csw:GetRecords │ │ │ │ + * document. │ │ │ │ + */ │ │ │ │ + Query: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: callback │ │ │ │ - * Function to be called when a mouse event corresponds with a location that │ │ │ │ - * includes data in one of the configured UTFGrid layers. │ │ │ │ + * Constructor: OpenLayers.Format.CSWGetRecords.v2_0_2 │ │ │ │ + * A class for parsing and generating CSWGetRecords v2.0.2 transactions. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * infoLookup - {Object} Keys of this object are layer indexes and can be │ │ │ │ - * used to resolve a layer in the map.layers array. The structure of │ │ │ │ - * the property values depend on the data included in the underlying │ │ │ │ - * UTFGrid and may be any valid JSON type. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + * │ │ │ │ + * Valid options properties (documented as class properties): │ │ │ │ + * - requestId │ │ │ │ + * - resultType │ │ │ │ + * - outputFormat │ │ │ │ + * - outputSchema │ │ │ │ + * - startPosition │ │ │ │ + * - maxRecords │ │ │ │ + * - DistributedSearch │ │ │ │ + * - ResponseHandler │ │ │ │ + * - Query │ │ │ │ */ │ │ │ │ - callback: function(infoLookup) { │ │ │ │ - // to be provided in the constructor │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: reset │ │ │ │ - * Calls the callback with null. │ │ │ │ + * APIMethod: read │ │ │ │ + * Parse the response from a GetRecords request. │ │ │ │ */ │ │ │ │ - reset: function(evt) { │ │ │ │ - this.callback(null); │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var obj = {}; │ │ │ │ + this.readNode(data, obj); │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: findLayers │ │ │ │ - * Internal method to get the layers, independent of whether we are │ │ │ │ - * inspecting the map or using a client-provided array │ │ │ │ - * │ │ │ │ - * The default value of this.layers is null; this causes the │ │ │ │ - * findLayers method to return ALL UTFGrid layers encountered. │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "csw": { │ │ │ │ + "GetRecordsResponse": function(node, obj) { │ │ │ │ + obj.records = []; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + var version = this.getAttributeNS(node, "", 'version'); │ │ │ │ + if (version != "") { │ │ │ │ + obj.version = version; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "RequestId": function(node, obj) { │ │ │ │ + obj.RequestId = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "SearchStatus": function(node, obj) { │ │ │ │ + obj.SearchStatus = {}; │ │ │ │ + var timestamp = this.getAttributeNS(node, "", 'timestamp'); │ │ │ │ + if (timestamp != "") { │ │ │ │ + obj.SearchStatus.timestamp = timestamp; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "SearchResults": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var SearchResults = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + if ((attrs[i].name == "numberOfRecordsMatched") || │ │ │ │ + (attrs[i].name == "numberOfRecordsReturned") || │ │ │ │ + (attrs[i].name == "nextRecord")) { │ │ │ │ + SearchResults[attrs[i].name] = parseInt(attrs[i].nodeValue); │ │ │ │ + } else { │ │ │ │ + SearchResults[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + obj.SearchResults = SearchResults; │ │ │ │ + }, │ │ │ │ + "SummaryRecord": function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "SummaryRecord" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record); │ │ │ │ + }, │ │ │ │ + "BriefRecord": function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "BriefRecord" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record); │ │ │ │ + }, │ │ │ │ + "DCMIRecord": function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "DCMIRecord" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record); │ │ │ │ + }, │ │ │ │ + "Record": function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "Record" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record); │ │ │ │ + }, │ │ │ │ + "*": function(node, obj) { │ │ │ │ + var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ + obj[name] = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "geonet": { │ │ │ │ + "info": function(node, obj) { │ │ │ │ + var gninfo = {}; │ │ │ │ + this.readChildNodes(node, gninfo); │ │ │ │ + obj.gninfo = gninfo; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "dc": { │ │ │ │ + // audience, contributor, coverage, creator, date, description, format, │ │ │ │ + // identifier, language, provenance, publisher, relation, rights, │ │ │ │ + // rightsHolder, source, subject, title, type, URI │ │ │ │ + "*": function(node, obj) { │ │ │ │ + var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ + if (!(OpenLayers.Util.isArray(obj[name]))) { │ │ │ │ + obj[name] = []; │ │ │ │ + } │ │ │ │ + var dc_element = {}; │ │ │ │ + var attrs = node.attributes; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + dc_element[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + } │ │ │ │ + dc_element.value = this.getChildValue(node); │ │ │ │ + if (dc_element.value != "") { │ │ │ │ + obj[name].push(dc_element); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "dct": { │ │ │ │ + // abstract, modified, spatial │ │ │ │ + "*": function(node, obj) { │ │ │ │ + var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ + if (!(OpenLayers.Util.isArray(obj[name]))) { │ │ │ │ + obj[name] = []; │ │ │ │ + } │ │ │ │ + obj[name].push(this.getChildValue(node)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ows": OpenLayers.Util.applyDefaults({ │ │ │ │ + "BoundingBox": function(node, obj) { │ │ │ │ + if (obj.bounds) { │ │ │ │ + obj.BoundingBox = [{ │ │ │ │ + crs: obj.projection, │ │ │ │ + value: [ │ │ │ │ + obj.bounds.left, │ │ │ │ + obj.bounds.bottom, │ │ │ │ + obj.bounds.right, │ │ │ │ + obj.bounds.top │ │ │ │ + ] │ │ │ │ + }]; │ │ │ │ + delete obj.projection; │ │ │ │ + delete obj.bounds; │ │ │ │ + } │ │ │ │ + OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]["BoundingBox"].apply( │ │ │ │ + this, arguments); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: write │ │ │ │ + * Given an configuration js object, write a CSWGetRecords request. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * None │ │ │ │ + * options - {Object} A object mapping the request. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array} Layers to handle on each event │ │ │ │ + * {String} A serialized CSWGetRecords request. │ │ │ │ */ │ │ │ │ - findLayers: function() { │ │ │ │ - var candidates = this.layers || this.map.layers; │ │ │ │ - var layers = []; │ │ │ │ - var layer; │ │ │ │ - for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ - layer = candidates[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.UTFGrid) { │ │ │ │ - layers.push(layer); │ │ │ │ + write: function(options) { │ │ │ │ + var node = this.writeNode("csw:GetRecords", options); │ │ │ │ + node.setAttribute("xmlns:gmd", this.namespaces.gmd); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: writers │ │ │ │ + * As a compliment to the readers property, this structure contains public │ │ │ │ + * writing functions grouped by namespace alias and named like the │ │ │ │ + * node names they produce. │ │ │ │ + */ │ │ │ │ + writers: { │ │ │ │ + "csw": { │ │ │ │ + "GetRecords": function(options) { │ │ │ │ + if (!options) { │ │ │ │ + options = {}; │ │ │ │ + } │ │ │ │ + var node = this.createElementNSPlus("csw:GetRecords", { │ │ │ │ + attributes: { │ │ │ │ + service: "CSW", │ │ │ │ + version: this.version, │ │ │ │ + requestId: options.requestId || this.requestId, │ │ │ │ + resultType: options.resultType || this.resultType, │ │ │ │ + outputFormat: options.outputFormat || this.outputFormat, │ │ │ │ + outputSchema: options.outputSchema || this.outputSchema, │ │ │ │ + startPosition: options.startPosition || this.startPosition, │ │ │ │ + maxRecords: options.maxRecords || this.maxRecords │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.DistributedSearch || this.DistributedSearch) { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:DistributedSearch", │ │ │ │ + options.DistributedSearch || this.DistributedSearch, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + var ResponseHandler = options.ResponseHandler || this.ResponseHandler; │ │ │ │ + if (OpenLayers.Util.isArray(ResponseHandler) && ResponseHandler.length > 0) { │ │ │ │ + // ResponseHandler must be a non-empty array │ │ │ │ + for (var i = 0, len = ResponseHandler.length; i < len; i++) { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:ResponseHandler", │ │ │ │ + ResponseHandler[i], │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.writeNode("Query", options.Query || this.Query, node); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "DistributedSearch": function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:DistributedSearch", { │ │ │ │ + attributes: { │ │ │ │ + hopCount: options.hopCount │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ResponseHandler": function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:ResponseHandler", { │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Query": function(options) { │ │ │ │ + if (!options) { │ │ │ │ + options = {}; │ │ │ │ + } │ │ │ │ + var node = this.createElementNSPlus("csw:Query", { │ │ │ │ + attributes: { │ │ │ │ + typeNames: options.typeNames || "csw:Record" │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + var ElementName = options.ElementName; │ │ │ │ + if (OpenLayers.Util.isArray(ElementName) && ElementName.length > 0) { │ │ │ │ + // ElementName must be a non-empty array │ │ │ │ + for (var i = 0, len = ElementName.length; i < len; i++) { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:ElementName", │ │ │ │ + ElementName[i], │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:ElementSetName", │ │ │ │ + options.ElementSetName || { │ │ │ │ + value: 'summary' │ │ │ │ + }, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (options.Constraint) { │ │ │ │ + this.writeNode( │ │ │ │ + "csw:Constraint", │ │ │ │ + options.Constraint, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (options.SortBy) { │ │ │ │ + this.writeNode( │ │ │ │ + "ogc:SortBy", │ │ │ │ + options.SortBy, │ │ │ │ + node │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ElementName": function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:ElementName", { │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "ElementSetName": function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:ElementSetName", { │ │ │ │ + attributes: { │ │ │ │ + typeNames: options.typeNames │ │ │ │ + }, │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + "Constraint": function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:Constraint", { │ │ │ │ + attributes: { │ │ │ │ + version: options.version │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.Filter) { │ │ │ │ + var format = new OpenLayers.Format.Filter({ │ │ │ │ + version: options.version │ │ │ │ + }); │ │ │ │ + node.appendChild(format.write(options.Filter)); │ │ │ │ + } else if (options.CqlText) { │ │ │ │ + var child = this.createElementNSPlus("CqlText", { │ │ │ │ + value: options.CqlText.value │ │ │ │ + }); │ │ │ │ + node.appendChild(child); │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ } │ │ │ │ - } │ │ │ │ - return layers; │ │ │ │ + }, │ │ │ │ + "ogc": OpenLayers.Format.Filter.v1_1_0.prototype.writers["ogc"] │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.UTFGrid" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.CSWGetRecords.v2_0_2" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/EditingToolbar.js │ │ │ │ + OpenLayers/Format/WMSDescribeLayer/v1_1.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/Panel.js │ │ │ │ - * @requires OpenLayers/Control/Navigation.js │ │ │ │ - * @requires OpenLayers/Control/DrawFeature.js │ │ │ │ - * @requires OpenLayers/Handler/Point.js │ │ │ │ - * @requires OpenLayers/Handler/Path.js │ │ │ │ - * @requires OpenLayers/Handler/Polygon.js │ │ │ │ + * @requires OpenLayers/Format/WMSDescribeLayer.js │ │ │ │ + * @requires OpenLayers/Format/OGCExceptionReport.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.EditingToolbar │ │ │ │ - * The EditingToolbar is a panel of 4 controls to draw polygons, lines, │ │ │ │ - * points, or to navigate the map by panning. By default it appears in the │ │ │ │ - * upper right corner of the map. │ │ │ │ + * Class: OpenLayers.Format.WMSDescribeLayer.v1_1_1 │ │ │ │ + * Read SLD WMS DescribeLayer response for WMS 1.1.X │ │ │ │ + * WMS 1.1.X is tightly coupled to SLD 1.0.0 │ │ │ │ + * │ │ │ │ + * Example DescribeLayer request: │ │ │ │ + * http://demo.opengeo.org/geoserver/wms?request=DescribeLayer&version=1.1.1&layers=topp:states │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.WMSDescribeLayer> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.WMSDescribeLayer.v1_1_1 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.WMSDescribeLayer, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.WMSDescribeLayer │ │ │ │ + * Create a new parser for WMS DescribeLayer responses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.WMSDescribeLayer.prototype.initialize.apply(this, │ │ │ │ + [options]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read DescribeLayer data from a string, and return the response. │ │ │ │ + * The OGC defines 2 formats which are allowed for output, │ │ │ │ + * so we need to parse these 2 types for version 1.1.X │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Object with a layerDescriptions property, which holds an Array │ │ │ │ + * of {<LayerDescription>} objects which have: │ │ │ │ + * - {String} owsType: WFS/WCS │ │ │ │ + * - {String} owsURL: the online resource │ │ │ │ + * - {String} typeName: the name of the typename on the owsType service │ │ │ │ + * - {String} layerName: the name of the WMS layer we did a lookup for │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + var root = data.documentElement; │ │ │ │ + var children = root.childNodes; │ │ │ │ + var describelayer = { │ │ │ │ + layerDescriptions: [] │ │ │ │ + }; │ │ │ │ + var childNode, nodeName; │ │ │ │ + for (var i = 0; i < children.length; ++i) { │ │ │ │ + childNode = children[i]; │ │ │ │ + nodeName = childNode.nodeName; │ │ │ │ + if (nodeName == 'LayerDescription') { │ │ │ │ + var layerName = childNode.getAttribute('name'); │ │ │ │ + var owsType = ''; │ │ │ │ + var owsURL = ''; │ │ │ │ + var typeName = ''; │ │ │ │ + // check for owsType and owsURL attributes │ │ │ │ + if (childNode.getAttribute('owsType')) { │ │ │ │ + owsType = childNode.getAttribute('owsType'); │ │ │ │ + owsURL = childNode.getAttribute('owsURL'); │ │ │ │ + } else { │ │ │ │ + // look for wfs or wcs attribute │ │ │ │ + if (childNode.getAttribute('wfs') != '') { │ │ │ │ + owsType = 'WFS'; │ │ │ │ + owsURL = childNode.getAttribute('wfs'); │ │ │ │ + } else if (childNode.getAttribute('wcs') != '') { │ │ │ │ + owsType = 'WCS'; │ │ │ │ + owsURL = childNode.getAttribute('wcs'); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // look for Query child │ │ │ │ + var query = childNode.getElementsByTagName('Query'); │ │ │ │ + if (query.length > 0) { │ │ │ │ + typeName = query[0].getAttribute('typeName'); │ │ │ │ + if (!typeName) { │ │ │ │ + // because of Ionic bug │ │ │ │ + typeName = query[0].getAttribute('typename'); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var layerDescription = { │ │ │ │ + layerName: layerName, │ │ │ │ + owsType: owsType, │ │ │ │ + owsURL: owsURL, │ │ │ │ + typeName: typeName │ │ │ │ + }; │ │ │ │ + describelayer.layerDescriptions.push(layerDescription); │ │ │ │ + │ │ │ │ + //TODO do this in deprecated.js instead: │ │ │ │ + // array style index for backwards compatibility │ │ │ │ + describelayer.length = describelayer.layerDescriptions.length; │ │ │ │ + describelayer[describelayer.length - 1] = layerDescription; │ │ │ │ + │ │ │ │ + } else if (nodeName == 'ServiceException') { │ │ │ │ + // an exception must have occurred, so parse it │ │ │ │ + var parser = new OpenLayers.Format.OGCExceptionReport(); │ │ │ │ + return { │ │ │ │ + error: parser.read(data) │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return describelayer; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer.v1_1_1" │ │ │ │ + │ │ │ │ + }); │ │ │ │ + │ │ │ │ +// Version alias - workaround for http://trac.osgeo.org/mapserver/ticket/2257 │ │ │ │ +OpenLayers.Format.WMSDescribeLayer.v1_1_0 = │ │ │ │ + OpenLayers.Format.WMSDescribeLayer.v1_1_1; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/SOSCapabilities/v1_0_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/SOSCapabilities.js │ │ │ │ + * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + * @requires OpenLayers/Format/GML/v3.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.SOSCapabilities.v1_0_0 │ │ │ │ + * Read SOS Capabilities version 1.0.0. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control.Panel> │ │ │ │ + * - <OpenLayers.Format.SOSCapabilities> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.EditingToolbar = OpenLayers.Class( │ │ │ │ - OpenLayers.Control.Panel, { │ │ │ │ +OpenLayers.Format.SOSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ + OpenLayers.Format.SOSCapabilities, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: citeCompliant │ │ │ │ - * {Boolean} If set to true, coordinates of features drawn in a map extent │ │ │ │ - * crossing the date line won't exceed the world bounds. Default is false. │ │ │ │ + * Property: namespaces │ │ │ │ + * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ */ │ │ │ │ - citeCompliant: false, │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + sos: "http://www.opengis.net/sos/1.0", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink" │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.EditingToolbar │ │ │ │ - * Create an editing toolbar for a given layer. │ │ │ │ + * Property: regExes │ │ │ │ + * Compiled regular expressions for manipulating strings. │ │ │ │ + */ │ │ │ │ + regExes: { │ │ │ │ + trimSpace: (/^\s*|\s*$/g), │ │ │ │ + removeSpace: (/\s*/g), │ │ │ │ + splitSpace: (/\s+/), │ │ │ │ + trimComma: (/\s*,\s*/g) │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Format.SOSCapabilities.v1_0_0 │ │ │ │ + * Create a new parser for SOS capabilities version 1.0.0. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ - * options - {Object} │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options; │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.addControls( │ │ │ │ - [new OpenLayers.Control.Navigation()] │ │ │ │ - ); │ │ │ │ - var controls = [ │ │ │ │ - new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Point, { │ │ │ │ - displayClass: 'olControlDrawFeaturePoint', │ │ │ │ - handlerOptions: { │ │ │ │ - citeCompliant: this.citeCompliant │ │ │ │ - } │ │ │ │ - }), │ │ │ │ - new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Path, { │ │ │ │ - displayClass: 'olControlDrawFeaturePath', │ │ │ │ - handlerOptions: { │ │ │ │ - citeCompliant: this.citeCompliant │ │ │ │ - } │ │ │ │ - }), │ │ │ │ - new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Polygon, { │ │ │ │ - displayClass: 'olControlDrawFeaturePolygon', │ │ │ │ - handlerOptions: { │ │ │ │ - citeCompliant: this.citeCompliant │ │ │ │ - } │ │ │ │ - }) │ │ │ │ - ]; │ │ │ │ - this.addControls(controls); │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Read capabilities data from a string, and return info about the SOS. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Information about the SOS service. │ │ │ │ + */ │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement; │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readers │ │ │ │ + * Contains public functions, grouped by namespace prefix, that will │ │ │ │ + * be applied when a namespaced node is found matching the function │ │ │ │ + * name. The function will be applied in the scope of this parser │ │ │ │ + * with two arguments: the node being read and a context object passed │ │ │ │ + * from the parent. │ │ │ │ + */ │ │ │ │ + readers: { │ │ │ │ + "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ + "name": function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "TimePeriod": function(node, obj) { │ │ │ │ + obj.timePeriod = {}; │ │ │ │ + this.readChildNodes(node, obj.timePeriod); │ │ │ │ + }, │ │ │ │ + "beginPosition": function(node, timePeriod) { │ │ │ │ + timePeriod.beginPosition = this.getChildValue(node); │ │ │ │ + }, │ │ │ │ + "endPosition": function(node, timePeriod) { │ │ │ │ + timePeriod.endPosition = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.GML.v3.prototype.readers["gml"]), │ │ │ │ + "sos": { │ │ │ │ + "Capabilities": function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + }, │ │ │ │ + "Contents": function(node, obj) { │ │ │ │ + obj.contents = {}; │ │ │ │ + this.readChildNodes(node, obj.contents); │ │ │ │ + }, │ │ │ │ + "ObservationOfferingList": function(node, contents) { │ │ │ │ + contents.offeringList = {}; │ │ │ │ + this.readChildNodes(node, contents.offeringList); │ │ │ │ + }, │ │ │ │ + "ObservationOffering": function(node, offeringList) { │ │ │ │ + var id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ + offeringList[id] = { │ │ │ │ + procedures: [], │ │ │ │ + observedProperties: [], │ │ │ │ + featureOfInterestIds: [], │ │ │ │ + responseFormats: [], │ │ │ │ + resultModels: [], │ │ │ │ + responseModes: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, offeringList[id]); │ │ │ │ + }, │ │ │ │ + "time": function(node, offering) { │ │ │ │ + offering.time = {}; │ │ │ │ + this.readChildNodes(node, offering.time); │ │ │ │ + }, │ │ │ │ + "procedure": function(node, offering) { │ │ │ │ + offering.procedures.push(this.getAttributeNS(node, │ │ │ │ + this.namespaces.xlink, "href")); │ │ │ │ + }, │ │ │ │ + "observedProperty": function(node, offering) { │ │ │ │ + offering.observedProperties.push(this.getAttributeNS(node, │ │ │ │ + this.namespaces.xlink, "href")); │ │ │ │ + }, │ │ │ │ + "featureOfInterest": function(node, offering) { │ │ │ │ + offering.featureOfInterestIds.push(this.getAttributeNS(node, │ │ │ │ + this.namespaces.xlink, "href")); │ │ │ │ + }, │ │ │ │ + "responseFormat": function(node, offering) { │ │ │ │ + offering.responseFormats.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "resultModel": function(node, offering) { │ │ │ │ + offering.resultModels.push(this.getChildValue(node)); │ │ │ │ + }, │ │ │ │ + "responseMode": function(node, offering) { │ │ │ │ + offering.responseModes.push(this.getChildValue(node)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * calls the default draw, and then activates mouse defaults. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.defaultControl === null) { │ │ │ │ - this.defaultControl = this.controls[0]; │ │ │ │ - } │ │ │ │ - return div; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSCapabilities.v1_0_0" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.EditingToolbar" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Zoom.js │ │ │ │ + OpenLayers/Handler/Hover.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Zoom │ │ │ │ - * The Zoom control is a pair of +/- links for zooming in and out. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Handler.Hover │ │ │ │ + * The hover handler is to be used to emulate mouseovers on objects │ │ │ │ + * on the map that aren't DOM elements. For example one can use │ │ │ │ + * this handler to send WMS/GetFeatureInfo requests as the user │ │ │ │ + * moves the mouve over the map. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Handler.Hover = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomInText │ │ │ │ - * {String} │ │ │ │ - * Text for zoom-in link. Default is "+". │ │ │ │ + * APIProperty: delay │ │ │ │ + * {Integer} - Number of milliseconds between mousemoves before │ │ │ │ + * the event is considered a hover. Default is 500. │ │ │ │ */ │ │ │ │ - zoomInText: "+", │ │ │ │ + delay: 500, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomInId │ │ │ │ - * {String} │ │ │ │ - * Instead of having the control create a zoom in link, you can provide │ │ │ │ - * the identifier for an anchor element already added to the document. │ │ │ │ - * By default, an element with id "olZoomInLink" will be searched for │ │ │ │ - * and used if it exists. │ │ │ │ + * APIProperty: pixelTolerance │ │ │ │ + * {Integer} - Maximum number of pixels between mousemoves for │ │ │ │ + * an event to be considered a hover. Default is null. │ │ │ │ */ │ │ │ │ - zoomInId: "olZoomInLink", │ │ │ │ + pixelTolerance: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomOutText │ │ │ │ - * {String} │ │ │ │ - * Text for zoom-out link. Default is "\u2212". │ │ │ │ + * APIProperty: stopMove │ │ │ │ + * {Boolean} - Stop other listeners from being notified on mousemoves. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - zoomOutText: "\u2212", │ │ │ │ + stopMove: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomOutId │ │ │ │ - * {String} │ │ │ │ - * Instead of having the control create a zoom out link, you can provide │ │ │ │ - * the identifier for an anchor element already added to the document. │ │ │ │ - * By default, an element with id "olZoomOutLink" will be searched for │ │ │ │ - * and used if it exists. │ │ │ │ + * Property: px │ │ │ │ + * {<OpenLayers.Pixel>} - The location of the last mousemove, expressed │ │ │ │ + * in pixels. │ │ │ │ */ │ │ │ │ - zoomOutId: "olZoomOutLink", │ │ │ │ + px: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A reference to the DOMElement containing the zoom links. │ │ │ │ + * Property: timerId │ │ │ │ + * {Number} - The id of the timer. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ - links = this.getOrCreateLinks(div), │ │ │ │ - zoomIn = links.zoomIn, │ │ │ │ - zoomOut = links.zoomOut, │ │ │ │ - eventsInstance = this.map.events; │ │ │ │ - │ │ │ │ - if (zoomOut.parentNode !== div) { │ │ │ │ - eventsInstance = this.events; │ │ │ │ - eventsInstance.attachToElement(zoomOut.parentNode); │ │ │ │ - } │ │ │ │ - eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ - │ │ │ │ - this.zoomInLink = zoomIn; │ │ │ │ - this.zoomOutLink = zoomOut; │ │ │ │ - return div; │ │ │ │ - }, │ │ │ │ + timerId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getOrCreateLinks │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * el - {DOMElement} │ │ │ │ + * Constructor: OpenLayers.Handler.Hover │ │ │ │ + * Construct a hover handler. │ │ │ │ * │ │ │ │ - * Return: │ │ │ │ - * {Object} Object with zoomIn and zoomOut properties referencing links. │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.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 with keys corresponding to callbacks │ │ │ │ + * that will be called by the handler. The callbacks should │ │ │ │ + * expect to receive a single argument, the event. Callbacks for │ │ │ │ + * 'move', the mouse is moving, and 'pause', the mouse is pausing, │ │ │ │ + * are supported. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * the handler. │ │ │ │ */ │ │ │ │ - getOrCreateLinks: function(el) { │ │ │ │ - var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ - zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ - if (!zoomIn) { │ │ │ │ - zoomIn = document.createElement("a"); │ │ │ │ - zoomIn.href = "#zoomIn"; │ │ │ │ - zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ - zoomIn.className = "olControlZoomIn"; │ │ │ │ - el.appendChild(zoomIn); │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ - if (!zoomOut) { │ │ │ │ - zoomOut = document.createElement("a"); │ │ │ │ - zoomOut.href = "#zoomOut"; │ │ │ │ - zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ - zoomOut.className = "olControlZoomOut"; │ │ │ │ - el.appendChild(zoomOut); │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ - return { │ │ │ │ - zoomIn: zoomIn, │ │ │ │ - zoomOut: zoomOut │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onZoomClick │ │ │ │ - * Called when zoomin/out link is clicked. │ │ │ │ + * Method: mousemove │ │ │ │ + * Called when the mouse moves on the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - onZoomClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.zoomInLink) { │ │ │ │ - this.map.zoomIn(); │ │ │ │ - } else if (button === this.zoomOutLink) { │ │ │ │ - this.map.zoomOut(); │ │ │ │ + mousemove: function(evt) { │ │ │ │ + if (this.passesTolerance(evt.xy)) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.callback('move', [evt]); │ │ │ │ + this.px = evt.xy; │ │ │ │ + // clone the evt so original properties can be accessed even │ │ │ │ + // if the browser deletes them during the delay │ │ │ │ + evt = OpenLayers.Util.extend({}, evt); │ │ │ │ + this.timerId = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(this.delayedCall, this, evt), │ │ │ │ + this.delay │ │ │ │ + ); │ │ │ │ } │ │ │ │ + return !this.stopMove; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * Clean up. │ │ │ │ + /** │ │ │ │ + * Method: mouseout │ │ │ │ + * Called when the mouse goes out of the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onZoomClick); │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.callback('move', [evt]); │ │ │ │ } │ │ │ │ - delete this.zoomInLink; │ │ │ │ - delete this.zoomOutLink; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Handler/Keyboard.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.handler.Keyboard │ │ │ │ - * A handler for keyboard events. Create a new instance with the │ │ │ │ - * <OpenLayers.Handler.Keyboard> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.Keyboard = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - │ │ │ │ - /* http://www.quirksmode.org/js/keys.html explains key x-browser │ │ │ │ - key handling quirks in pretty nice detail */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: KEY_EVENTS │ │ │ │ - * keydown, keypress, keyup │ │ │ │ - */ │ │ │ │ - KEY_EVENTS: ["keydown", "keyup"], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: eventListener │ │ │ │ - * {Function} │ │ │ │ - */ │ │ │ │ - eventListener: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: observeElement │ │ │ │ - * {DOMElement|String} The DOM element on which we listen for │ │ │ │ - * key events. Default to the document. │ │ │ │ - */ │ │ │ │ - observeElement: null, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Keyboard │ │ │ │ - * Returns a new keyboard handler. │ │ │ │ - * │ │ │ │ + * Method: passesTolerance │ │ │ │ + * Determine whether the mouse move is within the optional pixel tolerance. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ - * this handler. If a handler is being used without a control, the │ │ │ │ - * handlers setMap method must be overridden to deal properly with │ │ │ │ - * the map. │ │ │ │ - * callbacks - {Object} An object containing a single function to be │ │ │ │ - * called when the drag operation is finished. The callback should │ │ │ │ - * expect to recieve a single argument, the pixel location of the event. │ │ │ │ - * Callbacks for 'keydown', 'keypress', and 'keyup' are supported. │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * handler. │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The mouse move is within the pixel tolerance. │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - // cache the bound event listener method so it can be unobserved later │ │ │ │ - this.eventListener = OpenLayers.Function.bindAsEventListener( │ │ │ │ - this.handleKeyEvent, this │ │ │ │ - ); │ │ │ │ + passesTolerance: function(px) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.pixelTolerance && this.px) { │ │ │ │ + var dpx = Math.sqrt( │ │ │ │ + Math.pow(this.px.x - px.x, 2) + │ │ │ │ + Math.pow(this.px.y - px.y, 2) │ │ │ │ + ); │ │ │ │ + if (dpx < this.pixelTolerance) { │ │ │ │ + passes = false; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return passes; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * Method: clearTimer │ │ │ │ + * Clear the timer and set <timerId> to null. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.eventListener = null; │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + clearTimer: function() { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ + * Method: delayedCall │ │ │ │ + * Triggers pause callback. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.observeElement = this.observeElement || document; │ │ │ │ - for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ - OpenLayers.Event.observe( │ │ │ │ - this.observeElement, this.KEY_EVENTS[i], this.eventListener); │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + delayedCall: function(evt) { │ │ │ │ + this.callback('pause', [evt]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully deactivated. │ │ │ │ */ │ │ │ │ deactivate: function() { │ │ │ │ var deactivated = false; │ │ │ │ if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ - OpenLayers.Event.stopObserving( │ │ │ │ - this.observeElement, this.KEY_EVENTS[i], this.eventListener); │ │ │ │ - } │ │ │ │ + this.clearTimer(); │ │ │ │ deactivated = true; │ │ │ │ } │ │ │ │ return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleKeyEvent │ │ │ │ - */ │ │ │ │ - handleKeyEvent: function(evt) { │ │ │ │ - if (this.checkModifiers(evt)) { │ │ │ │ - this.callback(evt.type, [evt]); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Keyboard" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Hover" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/ModifyFeature.js │ │ │ │ + OpenLayers/Handler/Feature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ - * @requires OpenLayers/Handler/Keyboard.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.ModifyFeature │ │ │ │ - * Control to modify features. When activated, a click renders the vertices │ │ │ │ - * of a feature - these vertices can then be dragged. By default, the │ │ │ │ - * delete key will delete the vertex under the mouse. New features are │ │ │ │ - * added by dragging "virtual vertices" between vertices. Create a new │ │ │ │ - * control with the <OpenLayers.Control.ModifyFeature> constructor. │ │ │ │ + * Class: OpenLayers.Handler.Feature │ │ │ │ + * Handler to respond to mouse events related to a drawn feature. Callbacks │ │ │ │ + * with the following keys will be notified of the following events │ │ │ │ + * associated with features: click, clickout, over, out, and dblclick. │ │ │ │ * │ │ │ │ - * Inherits From: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * This handler stops event propagation for mousedown and mouseup if those │ │ │ │ + * browser events target features that can be selected. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} If set to true, dragging vertices will continue even if the │ │ │ │ - * mouse cursor leaves the map viewport. Default is false. │ │ │ │ - */ │ │ │ │ - documentDrag: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: geometryTypes │ │ │ │ - * {Array(String)} To restrict modification to a limited set of geometry │ │ │ │ - * types, send a list of strings corresponding to the geometry class │ │ │ │ - * names. │ │ │ │ - */ │ │ │ │ - geometryTypes: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: clickout │ │ │ │ - * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ - * Default is true. │ │ │ │ - */ │ │ │ │ - clickout: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: toggle │ │ │ │ - * {Boolean} Unselect a selected feature on click. │ │ │ │ - * Default is true. │ │ │ │ - */ │ │ │ │ - toggle: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: standalone │ │ │ │ - * {Boolean} Set to true to create a control without SelectFeature │ │ │ │ - * capabilities. Default is false. If standalone is true, to modify │ │ │ │ - * a feature, call the <selectFeature> method with the target feature. │ │ │ │ - * Note that you must call the <unselectFeature> method to finish │ │ │ │ - * feature modification in standalone mode (before starting to modify │ │ │ │ - * another feature). │ │ │ │ - */ │ │ │ │ - standalone: false, │ │ │ │ +OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} │ │ │ │ + * Property: EVENTMAP │ │ │ │ + * {Object} A object mapping the browser events to objects with callback │ │ │ │ + * keys for in and out. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + EVENTMAP: { │ │ │ │ + 'click': { │ │ │ │ + 'in': 'click', │ │ │ │ + 'out': 'clickout' │ │ │ │ + }, │ │ │ │ + 'mousemove': { │ │ │ │ + 'in': 'over', │ │ │ │ + 'out': 'out' │ │ │ │ + }, │ │ │ │ + 'dblclick': { │ │ │ │ + 'in': 'dblclick', │ │ │ │ + 'out': null │ │ │ │ + }, │ │ │ │ + 'mousedown': { │ │ │ │ + 'in': null, │ │ │ │ + 'out': null │ │ │ │ + }, │ │ │ │ + 'mouseup': { │ │ │ │ + 'in': null, │ │ │ │ + 'out': null │ │ │ │ + }, │ │ │ │ + 'touchstart': { │ │ │ │ + 'in': 'click', │ │ │ │ + 'out': 'clickout' │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Property: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} Feature currently available for modification. │ │ │ │ + * {<OpenLayers.Feature.Vector>} The last feature that was hovered. │ │ │ │ */ │ │ │ │ feature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: vertex │ │ │ │ - * {<OpenLayers.Feature.Vector>} Vertex currently being modified. │ │ │ │ - */ │ │ │ │ - vertex: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: vertices │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} Verticies currently available │ │ │ │ - * for dragging. │ │ │ │ - */ │ │ │ │ - vertices: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: virtualVertices │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} Virtual vertices in the middle │ │ │ │ - * of each edge. │ │ │ │ - */ │ │ │ │ - virtualVertices: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: handlers │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ - handlers: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: deleteCodes │ │ │ │ - * {Array(Integer)} Keycodes for deleting verticies. Set to null to disable │ │ │ │ - * vertex deltion by keypress. If non-null, keypresses with codes │ │ │ │ - * in this array will delete vertices under the mouse. Default │ │ │ │ - * is 46 and 68, the 'delete' and lowercase 'd' keys. │ │ │ │ + * Property: lastFeature │ │ │ │ + * {<OpenLayers.Feature.Vector>} The last feature that was handled. │ │ │ │ */ │ │ │ │ - deleteCodes: null, │ │ │ │ + lastFeature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: virtualStyle │ │ │ │ - * {Object} A symbolizer to be used for virtual vertices. │ │ │ │ + * Property: down │ │ │ │ + * {<OpenLayers.Pixel>} The location of the last mousedown. │ │ │ │ */ │ │ │ │ - virtualStyle: null, │ │ │ │ + down: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: vertexRenderIntent │ │ │ │ - * {String} The renderIntent to use for vertices. If no <virtualStyle> is │ │ │ │ - * provided, this renderIntent will also be used for virtual vertices, with │ │ │ │ - * a fillOpacity and strokeOpacity of 0.3. Default is null, which means │ │ │ │ - * that the layer's default style will be used for vertices. │ │ │ │ + * Property: up │ │ │ │ + * {<OpenLayers.Pixel>} The location of the last mouseup. │ │ │ │ */ │ │ │ │ - vertexRenderIntent: null, │ │ │ │ + up: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: mode │ │ │ │ - * {Integer} Bitfields specifying the modification mode. Defaults to │ │ │ │ - * OpenLayers.Control.ModifyFeature.RESHAPE. To set the mode to a │ │ │ │ - * combination of options, use the | operator. For example, to allow │ │ │ │ - * the control to both resize and rotate features, use the following │ │ │ │ - * syntax │ │ │ │ - * (code) │ │ │ │ - * control.mode = OpenLayers.Control.ModifyFeature.RESIZE | │ │ │ │ - * OpenLayers.Control.ModifyFeature.ROTATE; │ │ │ │ - * (end) │ │ │ │ + * Property: clickTolerance │ │ │ │ + * {Number} The number of pixels the mouse can move between mousedown │ │ │ │ + * and mouseup for the event to still be considered a click. │ │ │ │ + * Dragging the map should not trigger the click and clickout callbacks │ │ │ │ + * unless the map is moved by less than this tolerance. Defaults to 4. │ │ │ │ */ │ │ │ │ - mode: null, │ │ │ │ + clickTolerance: 4, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: createVertices │ │ │ │ - * {Boolean} Create new vertices by dragging the virtual vertices │ │ │ │ - * in the middle of each edge. Default is true. │ │ │ │ + * Property: geometryTypes │ │ │ │ + * To restrict dragging to a limited set of geometry types, send a list │ │ │ │ + * of strings corresponding to the geometry class names. │ │ │ │ + * │ │ │ │ + * @type Array(String) │ │ │ │ */ │ │ │ │ - createVertices: true, │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: modified │ │ │ │ - * {Boolean} The currently selected feature has been modified. │ │ │ │ + * Property: stopClick │ │ │ │ + * {Boolean} If stopClick is set to true, handled clicks do not │ │ │ │ + * propagate to other click listeners. Otherwise, handled clicks │ │ │ │ + * do propagate. Unhandled clicks always propagate, whatever the │ │ │ │ + * value of stopClick. Defaults to true. │ │ │ │ */ │ │ │ │ - modified: false, │ │ │ │ + stopClick: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: radiusHandle │ │ │ │ - * {<OpenLayers.Feature.Vector>} A handle for rotating/resizing a feature. │ │ │ │ + * Property: stopDown │ │ │ │ + * {Boolean} If stopDown is set to true, handled mousedowns do not │ │ │ │ + * propagate to other mousedown listeners. Otherwise, handled │ │ │ │ + * mousedowns do propagate. Unhandled mousedowns always propagate, │ │ │ │ + * whatever the value of stopDown. Defaults to true. │ │ │ │ */ │ │ │ │ - radiusHandle: null, │ │ │ │ + stopDown: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dragHandle │ │ │ │ - * {<OpenLayers.Feature.Vector>} A handle for dragging a feature. │ │ │ │ + * Property: stopUp │ │ │ │ + * {Boolean} If stopUp is set to true, handled mouseups do not │ │ │ │ + * propagate to other mouseup listeners. Otherwise, handled mouseups │ │ │ │ + * do propagate. Unhandled mouseups always propagate, whatever the │ │ │ │ + * value of stopUp. Defaults to false. │ │ │ │ */ │ │ │ │ - dragHandle: null, │ │ │ │ + stopUp: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: onModificationStart │ │ │ │ - * {Function} *Deprecated*. Register for "beforefeaturemodified" instead. │ │ │ │ - * The "beforefeaturemodified" event is triggered on the layer before │ │ │ │ - * any modification begins. │ │ │ │ + * Constructor: OpenLayers.Handler.Feature │ │ │ │ * │ │ │ │ - * Optional function to be called when a feature is selected │ │ │ │ - * to be modified. The function should expect to be called with a │ │ │ │ - * feature. This could be used for example to allow to lock the │ │ │ │ - * feature on server-side. │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ + * callbacks - {Object} An object with a 'over' property whos value is │ │ │ │ + * a function to be called when the mouse is over a feature. The │ │ │ │ + * callback should expect to recieve a single argument, the feature. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - onModificationStart: function() {}, │ │ │ │ + initialize: function(control, layer, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ + this.layer = layer; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: onModification │ │ │ │ - * {Function} *Deprecated*. Register for "featuremodified" instead. │ │ │ │ - * The "featuremodified" event is triggered on the layer with each │ │ │ │ - * feature modification. │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart events │ │ │ │ * │ │ │ │ - * Optional function to be called when a feature has been │ │ │ │ - * modified. The function should expect to be called with a feature. │ │ │ │ - */ │ │ │ │ - onModification: function() {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: onModificationEnd │ │ │ │ - * {Function} *Deprecated*. Register for "afterfeaturemodified" instead. │ │ │ │ - * The "afterfeaturemodified" event is triggered on the layer after │ │ │ │ - * a feature has been modified. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ - * Optional function to be called when a feature is finished │ │ │ │ - * being modified. The function should expect to be called with a │ │ │ │ - * feature. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - onModificationEnd: function() {}, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return OpenLayers.Event.isMultiTouch(evt) ? │ │ │ │ + true : this.mousedown(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.ModifyFeature │ │ │ │ - * Create a new modify feature control. │ │ │ │ + * Method: touchmove │ │ │ │ + * Handle touchmove events. We just prevent the browser default behavior, │ │ │ │ + * for Android Webkit not to select text when moving the finger after │ │ │ │ + * selecting a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} Layer that contains features that │ │ │ │ - * will be modified. │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * control. │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - options = options || {}; │ │ │ │ - this.layer = layer; │ │ │ │ - this.vertices = []; │ │ │ │ - this.virtualVertices = []; │ │ │ │ - this.virtualStyle = OpenLayers.Util.extend({}, │ │ │ │ - this.layer.style || │ │ │ │ - this.layer.styleMap.createSymbolizer(null, options.vertexRenderIntent) │ │ │ │ - ); │ │ │ │ - this.virtualStyle.fillOpacity = 0.3; │ │ │ │ - this.virtualStyle.strokeOpacity = 0.3; │ │ │ │ - this.deleteCodes = [46, 68]; │ │ │ │ - this.mode = OpenLayers.Control.ModifyFeature.RESHAPE; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!(OpenLayers.Util.isArray(this.deleteCodes))) { │ │ │ │ - this.deleteCodes = [this.deleteCodes]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // configure the drag handler │ │ │ │ - var dragCallbacks = { │ │ │ │ - down: function(pixel) { │ │ │ │ - this.vertex = null; │ │ │ │ - var feature = this.layer.getFeatureFromEvent( │ │ │ │ - this.handlers.drag.evt); │ │ │ │ - if (feature) { │ │ │ │ - this.dragStart(feature); │ │ │ │ - } else if (this.clickout) { │ │ │ │ - this._unselect = this.feature; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - move: function(pixel) { │ │ │ │ - delete this._unselect; │ │ │ │ - if (this.vertex) { │ │ │ │ - this.dragVertex(this.vertex, pixel); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - up: function() { │ │ │ │ - this.handlers.drag.stopDown = false; │ │ │ │ - if (this._unselect) { │ │ │ │ - this.unselectFeature(this._unselect); │ │ │ │ - delete this._unselect; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - done: function(pixel) { │ │ │ │ - if (this.vertex) { │ │ │ │ - this.dragComplete(this.vertex); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - var dragOptions = { │ │ │ │ - documentDrag: this.documentDrag, │ │ │ │ - stopDown: false │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // configure the keyboard handler │ │ │ │ - var keyboardOptions = { │ │ │ │ - keydown: this.handleKeypress │ │ │ │ - }; │ │ │ │ - this.handlers = { │ │ │ │ - keyboard: new OpenLayers.Handler.Keyboard(this, keyboardOptions), │ │ │ │ - drag: new OpenLayers.Handler.Drag(this, dragCallbacks, dragOptions) │ │ │ │ - }; │ │ │ │ + touchmove: function(evt) { │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Take care of things that are not handled in superclass. │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mouse down. Stop propagation if a feature is targeted by this │ │ │ │ + * event (stops map dragging during feature selection). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.un({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + mousedown: function(evt) { │ │ │ │ + // Feature selection is only done with a left click. Other handlers may stop the │ │ │ │ + // propagation of left-click mousedown events but not right-click mousedown events. │ │ │ │ + // This mismatch causes problems when comparing the location of the down and up │ │ │ │ + // events in the click function so it is important ignore right-clicks. │ │ │ │ + if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ + this.down = evt.xy; │ │ │ │ } │ │ │ │ - this.layer = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, []); │ │ │ │ + return this.handle(evt) ? !this.stopDown : true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the control. │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouse up. Stop propagation if a feature is targeted by this │ │ │ │ + * event. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Successfully activated the control. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - this.map.events.on({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - return (this.handlers.keyboard.activate() && │ │ │ │ - this.handlers.drag.activate() && │ │ │ │ - OpenLayers.Control.prototype.activate.apply(this, arguments)); │ │ │ │ + mouseup: function(evt) { │ │ │ │ + this.up = evt.xy; │ │ │ │ + return this.handle(evt) ? !this.stopUp : true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the control. │ │ │ │ + * Method: click │ │ │ │ + * Handle click. Call the "click" callback if click on a feature, │ │ │ │ + * or the "clickout" callback if click outside any feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Successfully deactivated the control. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - // the return from the controls is unimportant in this case │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.moveLayerBack(); │ │ │ │ - this.map.events.un({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - this.handlers.keyboard.deactivate(); │ │ │ │ - var feature = this.feature; │ │ │ │ - if (feature && feature.geometry && feature.layer) { │ │ │ │ - this.unselectFeature(feature); │ │ │ │ - } │ │ │ │ - deactivated = true; │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ + click: function(evt) { │ │ │ │ + return this.handle(evt) ? !this.stopClick : true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: beforeSelectFeature │ │ │ │ - * Called before a feature is selected. │ │ │ │ - * │ │ │ │ + * Method: mousemove │ │ │ │ + * Handle mouse moves. Call the "over" callback if moving in to a feature, │ │ │ │ + * or the "out" callback if moving out of a feature. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature about to be selected. │ │ │ │ - */ │ │ │ │ - beforeSelectFeature: function(feature) { │ │ │ │ - return this.layer.events.triggerEvent( │ │ │ │ - "beforefeaturemodified", { │ │ │ │ - feature: feature │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: selectFeature │ │ │ │ - * Select a feature for modification in standalone mode. In non-standalone │ │ │ │ - * mode, this method is called when a feature is selected by clicking. │ │ │ │ - * Register a listener to the beforefeaturemodified event and return false │ │ │ │ - * to prevent feature modification. │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} the selected feature. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - selectFeature: function(feature) { │ │ │ │ - if (this.feature === feature || │ │ │ │ - (this.geometryTypes && OpenLayers.Util.indexOf(this.geometryTypes, │ │ │ │ - feature.geometry.CLASS_NAME) == -1)) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (this.beforeSelectFeature(feature) !== false) { │ │ │ │ - if (this.feature) { │ │ │ │ - this.unselectFeature(this.feature); │ │ │ │ - } │ │ │ │ - this.feature = feature; │ │ │ │ - this.layer.selectedFeatures.push(feature); │ │ │ │ - this.layer.drawFeature(feature, 'select'); │ │ │ │ - this.modified = false; │ │ │ │ - this.resetVertices(); │ │ │ │ - this.onModificationStart(this.feature); │ │ │ │ - } │ │ │ │ - // keep track of geometry modifications │ │ │ │ - var modified = feature.modified; │ │ │ │ - if (feature.geometry && !(modified && modified.geometry)) { │ │ │ │ - this._originalGeometry = feature.geometry.clone(); │ │ │ │ + mousemove: function(evt) { │ │ │ │ + if (!this.callbacks['over'] && !this.callbacks['out']) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ + this.handle(evt); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: unselectFeature │ │ │ │ - * Called when the select feature control unselects a feature. │ │ │ │ + * Method: dblclick │ │ │ │ + * Handle dblclick. Call the "dblclick" callback if dblclick on a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The unselected feature. │ │ │ │ - */ │ │ │ │ - unselectFeature: function(feature) { │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.virtualVertices = []; │ │ │ │ - if (this.dragHandle) { │ │ │ │ - this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - delete this.dragHandle; │ │ │ │ - } │ │ │ │ - if (this.radiusHandle) { │ │ │ │ - this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - delete this.radiusHandle; │ │ │ │ - } │ │ │ │ - this.layer.drawFeature(this.feature, 'default'); │ │ │ │ - this.feature = null; │ │ │ │ - OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); │ │ │ │ - this.onModificationEnd(feature); │ │ │ │ - this.layer.events.triggerEvent("afterfeaturemodified", { │ │ │ │ - feature: feature, │ │ │ │ - modified: this.modified │ │ │ │ - }); │ │ │ │ - this.modified = false; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: dragStart │ │ │ │ - * Called by the drag handler before a feature is dragged. This method is │ │ │ │ - * used to differentiate between points and vertices │ │ │ │ - * of higher order geometries. │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The point or vertex about to be │ │ │ │ - * dragged. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - dragStart: function(feature) { │ │ │ │ - var isPoint = feature.geometry.CLASS_NAME == │ │ │ │ - 'OpenLayers.Geometry.Point'; │ │ │ │ - if (!this.standalone && │ │ │ │ - ((!feature._sketch && isPoint) || !feature._sketch)) { │ │ │ │ - if (this.toggle && this.feature === feature) { │ │ │ │ - // mark feature for unselection │ │ │ │ - this._unselect = feature; │ │ │ │ - } │ │ │ │ - this.selectFeature(feature); │ │ │ │ - } │ │ │ │ - if (feature._sketch || isPoint) { │ │ │ │ - // feature is a drag or virtual handle or point │ │ │ │ - this.vertex = feature; │ │ │ │ - this.handlers.drag.stopDown = true; │ │ │ │ - } │ │ │ │ + dblclick: function(evt) { │ │ │ │ + return !this.handle(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragVertex │ │ │ │ - * Called by the drag handler with each drag move of a vertex. │ │ │ │ + * Method: geometryTypeMatches │ │ │ │ + * Return true if the geometry type of the passed feature matches │ │ │ │ + * one of the geometry types in the geometryTypes array. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged. │ │ │ │ - * pixel - {<OpenLayers.Pixel>} Pixel location of the mouse event. │ │ │ │ + * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - dragVertex: function(vertex, pixel) { │ │ │ │ - var pos = this.map.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geom = vertex.geometry; │ │ │ │ - geom.move(pos.lon - geom.x, pos.lat - geom.y); │ │ │ │ - this.modified = true; │ │ │ │ - /** │ │ │ │ - * Five cases: │ │ │ │ - * 1) dragging a simple point │ │ │ │ - * 2) dragging a virtual vertex │ │ │ │ - * 3) dragging a drag handle │ │ │ │ - * 4) dragging a real vertex │ │ │ │ - * 5) dragging a radius handle │ │ │ │ - */ │ │ │ │ - if (this.feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - // dragging a simple point │ │ │ │ - this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ - vertex: vertex.geometry, │ │ │ │ - feature: this.feature, │ │ │ │ - pixel: pixel │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - if (vertex._index) { │ │ │ │ - // dragging a virtual vertex │ │ │ │ - vertex.geometry.parent.addComponent(vertex.geometry, │ │ │ │ - vertex._index); │ │ │ │ - // move from virtual to real vertex │ │ │ │ - delete vertex._index; │ │ │ │ - OpenLayers.Util.removeItem(this.virtualVertices, vertex); │ │ │ │ - this.vertices.push(vertex); │ │ │ │ - } else if (vertex == this.dragHandle) { │ │ │ │ - // dragging a drag handle │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - if (this.radiusHandle) { │ │ │ │ - this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.radiusHandle = null; │ │ │ │ - } │ │ │ │ - } else if (vertex !== this.radiusHandle) { │ │ │ │ - // dragging a real vertex │ │ │ │ - this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ - vertex: vertex.geometry, │ │ │ │ - feature: this.feature, │ │ │ │ - pixel: pixel │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - // dragging a radius handle - no special treatment │ │ │ │ - if (this.virtualVertices.length > 0) { │ │ │ │ - this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.virtualVertices = []; │ │ │ │ - } │ │ │ │ - this.layer.drawFeature(this.feature, this.standalone ? undefined : │ │ │ │ - 'select'); │ │ │ │ - } │ │ │ │ - // keep the vertex on top so it gets the mouseout after dragging │ │ │ │ - // this should be removed in favor of an option to draw under or │ │ │ │ - // maintain node z-index │ │ │ │ - this.layer.drawFeature(vertex); │ │ │ │ + geometryTypeMatches: function(feature) { │ │ │ │ + return this.geometryTypes == null || │ │ │ │ + OpenLayers.Util.indexOf(this.geometryTypes, │ │ │ │ + feature.geometry.CLASS_NAME) > -1; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragComplete │ │ │ │ - * Called by the drag handler when the feature dragging is complete. │ │ │ │ + * Method: handle │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged. │ │ │ │ - */ │ │ │ │ - dragComplete: function(vertex) { │ │ │ │ - this.resetVertices(); │ │ │ │ - this.setFeatureState(); │ │ │ │ - this.onModification(this.feature); │ │ │ │ - this.layer.events.triggerEvent("featuremodified", { │ │ │ │ - feature: this.feature │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setFeatureState │ │ │ │ - * Called when the feature is modified. If the current state is not │ │ │ │ - * INSERT or DELETE, the state is set to UPDATE. │ │ │ │ - */ │ │ │ │ - setFeatureState: function() { │ │ │ │ - if (this.feature.state != OpenLayers.State.INSERT && │ │ │ │ - this.feature.state != OpenLayers.State.DELETE) { │ │ │ │ - this.feature.state = OpenLayers.State.UPDATE; │ │ │ │ - if (this.modified && this._originalGeometry) { │ │ │ │ - var feature = this.feature; │ │ │ │ - feature.modified = OpenLayers.Util.extend(feature.modified, { │ │ │ │ - geometry: this._originalGeometry │ │ │ │ - }); │ │ │ │ - delete this._originalGeometry; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: resetVertices │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The event occurred over a relevant feature. │ │ │ │ */ │ │ │ │ - resetVertices: function() { │ │ │ │ - if (this.vertices.length > 0) { │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - } │ │ │ │ - if (this.virtualVertices.length > 0) { │ │ │ │ - this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.virtualVertices = []; │ │ │ │ + handle: function(evt) { │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + // feature has been destroyed │ │ │ │ + this.feature = null; │ │ │ │ } │ │ │ │ - if (this.dragHandle) { │ │ │ │ - this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.dragHandle = null; │ │ │ │ + var type = evt.type; │ │ │ │ + var handled = false; │ │ │ │ + var previouslyIn = !!(this.feature); // previously in a feature │ │ │ │ + var click = (type == "click" || type == "dblclick" || type == "touchstart"); │ │ │ │ + this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + // feature has been destroyed │ │ │ │ + this.feature = null; │ │ │ │ } │ │ │ │ - if (this.radiusHandle) { │ │ │ │ - this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.radiusHandle = null; │ │ │ │ + if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ + // last feature has been destroyed │ │ │ │ + this.lastFeature = null; │ │ │ │ } │ │ │ │ - if (this.feature && │ │ │ │ - this.feature.geometry.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ - if ((this.mode & OpenLayers.Control.ModifyFeature.DRAG)) { │ │ │ │ - this.collectDragHandle(); │ │ │ │ - } │ │ │ │ - if ((this.mode & (OpenLayers.Control.ModifyFeature.ROTATE | │ │ │ │ - OpenLayers.Control.ModifyFeature.RESIZE))) { │ │ │ │ - this.collectRadiusHandle(); │ │ │ │ + if (this.feature) { │ │ │ │ + if (type === "touchstart") { │ │ │ │ + // stop the event to prevent Android Webkit from │ │ │ │ + // "flashing" the map div │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ } │ │ │ │ - if (this.mode & OpenLayers.Control.ModifyFeature.RESHAPE) { │ │ │ │ - // Don't collect vertices when we're resizing │ │ │ │ - if (!(this.mode & OpenLayers.Control.ModifyFeature.RESIZE)) { │ │ │ │ - this.collectVertices(); │ │ │ │ + var inNew = (this.feature != this.lastFeature); │ │ │ │ + if (this.geometryTypeMatches(this.feature)) { │ │ │ │ + // in to a feature │ │ │ │ + if (previouslyIn && inNew) { │ │ │ │ + // out of last feature and in to another │ │ │ │ + if (this.lastFeature) { │ │ │ │ + this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ + } │ │ │ │ + this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ + } else if (!previouslyIn || click) { │ │ │ │ + // in feature for the first time │ │ │ │ + this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ + } │ │ │ │ + this.lastFeature = this.feature; │ │ │ │ + handled = true; │ │ │ │ + } else { │ │ │ │ + // not in to a feature │ │ │ │ + if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ + // out of last feature for the first time │ │ │ │ + this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ } │ │ │ │ + // next time the mouse goes in a feature whose geometry type │ │ │ │ + // doesn't match we don't want to call the 'out' callback │ │ │ │ + // again, so let's set this.feature to null so that │ │ │ │ + // previouslyIn will evaluate to false the next time │ │ │ │ + // we enter handle. Yes, a bit hackish... │ │ │ │ + this.feature = null; │ │ │ │ } │ │ │ │ + } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ + this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ } │ │ │ │ + return handled; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleKeypress │ │ │ │ - * Called by the feature handler on keypress. This is used to delete │ │ │ │ - * vertices. If the <deleteCode> property is set, vertices will │ │ │ │ - * be deleted when a feature is selected for modification and │ │ │ │ - * the mouse is over a vertex. │ │ │ │ + * Method: triggerCallback │ │ │ │ + * Call the callback keyed in the event map with the supplied arguments. │ │ │ │ + * For click and clickout, the <clickTolerance> is checked first. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} Keypress event. │ │ │ │ - */ │ │ │ │ - handleKeypress: function(evt) { │ │ │ │ - var code = evt.keyCode; │ │ │ │ - │ │ │ │ - // check for delete key │ │ │ │ - if (this.feature && │ │ │ │ - OpenLayers.Util.indexOf(this.deleteCodes, code) != -1) { │ │ │ │ - var vertex = this.layer.getFeatureFromEvent(this.handlers.drag.evt); │ │ │ │ - if (vertex && │ │ │ │ - OpenLayers.Util.indexOf(this.vertices, vertex) != -1 && │ │ │ │ - !this.handlers.drag.dragging && vertex.geometry.parent) { │ │ │ │ - // remove the vertex │ │ │ │ - vertex.geometry.parent.removeComponent(vertex.geometry); │ │ │ │ - this.layer.events.triggerEvent("vertexremoved", { │ │ │ │ - vertex: vertex.geometry, │ │ │ │ - feature: this.feature, │ │ │ │ - pixel: evt.xy │ │ │ │ - }); │ │ │ │ - this.layer.drawFeature(this.feature, this.standalone ? │ │ │ │ - undefined : 'select'); │ │ │ │ - this.modified = true; │ │ │ │ - this.resetVertices(); │ │ │ │ - this.setFeatureState(); │ │ │ │ - this.onModification(this.feature); │ │ │ │ - this.layer.events.triggerEvent("featuremodified", { │ │ │ │ - feature: this.feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: collectVertices │ │ │ │ - * Collect the vertices from the modifiable feature's geometry and push │ │ │ │ - * them on to the control's vertices array. │ │ │ │ + * type - {String} │ │ │ │ */ │ │ │ │ - collectVertices: function() { │ │ │ │ - this.vertices = []; │ │ │ │ - this.virtualVertices = []; │ │ │ │ - var control = this; │ │ │ │ - │ │ │ │ - function collectComponentVertices(geometry) { │ │ │ │ - var i, vertex, component, len; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - vertex = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - vertex._sketch = true; │ │ │ │ - vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ - control.vertices.push(vertex); │ │ │ │ - } else { │ │ │ │ - var numVert = geometry.components.length; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ - numVert -= 1; │ │ │ │ - } │ │ │ │ - for (i = 0; i < numVert; ++i) { │ │ │ │ - component = geometry.components[i]; │ │ │ │ - if (component.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - vertex = new OpenLayers.Feature.Vector(component); │ │ │ │ - vertex._sketch = true; │ │ │ │ - vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ - control.vertices.push(vertex); │ │ │ │ - } else { │ │ │ │ - collectComponentVertices(component); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // add virtual vertices in the middle of each edge │ │ │ │ - if (control.createVertices && geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") { │ │ │ │ - for (i = 0, len = geometry.components.length; i < len - 1; ++i) { │ │ │ │ - var prevVertex = geometry.components[i]; │ │ │ │ - var nextVertex = geometry.components[i + 1]; │ │ │ │ - if (prevVertex.CLASS_NAME == "OpenLayers.Geometry.Point" && │ │ │ │ - nextVertex.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - var x = (prevVertex.x + nextVertex.x) / 2; │ │ │ │ - var y = (prevVertex.y + nextVertex.y) / 2; │ │ │ │ - var point = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.Point(x, y), │ │ │ │ - null, control.virtualStyle │ │ │ │ - ); │ │ │ │ - // set the virtual parent and intended index │ │ │ │ - point.geometry.parent = geometry; │ │ │ │ - point._index = i + 1; │ │ │ │ - point._sketch = true; │ │ │ │ - control.virtualVertices.push(point); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + triggerCallback: function(type, mode, args) { │ │ │ │ + var key = this.EVENTMAP[type][mode]; │ │ │ │ + if (key) { │ │ │ │ + if (type == 'click' && this.up && this.down) { │ │ │ │ + // for click/clickout, only trigger callback if tolerance is met │ │ │ │ + var dpx = Math.sqrt( │ │ │ │ + Math.pow(this.up.x - this.down.x, 2) + │ │ │ │ + Math.pow(this.up.y - this.down.y, 2) │ │ │ │ + ); │ │ │ │ + if (dpx <= this.clickTolerance) { │ │ │ │ + this.callback(key, args); │ │ │ │ } │ │ │ │ + // we're done with this set of events now: clear the cached │ │ │ │ + // positions so we can't trip over them later (this can occur │ │ │ │ + // if one of the up/down events gets eaten before it gets to us │ │ │ │ + // but we still get the click) │ │ │ │ + this.up = this.down = null; │ │ │ │ + } else { │ │ │ │ + this.callback(key, args); │ │ │ │ } │ │ │ │ } │ │ │ │ - collectComponentVertices.call(this, this.feature.geometry); │ │ │ │ - this.layer.addFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.layer.addFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: collectDragHandle │ │ │ │ - * Collect the drag handle for the selected geometry. │ │ │ │ - */ │ │ │ │ - collectDragHandle: function() { │ │ │ │ - var geometry = this.feature.geometry; │ │ │ │ - var center = geometry.getBounds().getCenterLonLat(); │ │ │ │ - var originGeometry = new OpenLayers.Geometry.Point( │ │ │ │ - center.lon, center.lat │ │ │ │ - ); │ │ │ │ - var origin = new OpenLayers.Feature.Vector(originGeometry); │ │ │ │ - originGeometry.move = function(x, y) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - geometry.move(x, y); │ │ │ │ - }; │ │ │ │ - origin._sketch = true; │ │ │ │ - this.dragHandle = origin; │ │ │ │ - this.dragHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ - this.layer.addFeatures([this.dragHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: collectRadiusHandle │ │ │ │ - * Collect the radius handle for the selected geometry. │ │ │ │ + * Method: activate │ │ │ │ + * Turn on the handler. Returns false if the handler was already active. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - collectRadiusHandle: function() { │ │ │ │ - var geometry = this.feature.geometry; │ │ │ │ - var bounds = geometry.getBounds(); │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var originGeometry = new OpenLayers.Geometry.Point( │ │ │ │ - center.lon, center.lat │ │ │ │ - ); │ │ │ │ - var radiusGeometry = new OpenLayers.Geometry.Point( │ │ │ │ - bounds.right, bounds.bottom │ │ │ │ - ); │ │ │ │ - var radius = new OpenLayers.Feature.Vector(radiusGeometry); │ │ │ │ - var resize = (this.mode & OpenLayers.Control.ModifyFeature.RESIZE); │ │ │ │ - var reshape = (this.mode & OpenLayers.Control.ModifyFeature.RESHAPE); │ │ │ │ - var rotate = (this.mode & OpenLayers.Control.ModifyFeature.ROTATE); │ │ │ │ - │ │ │ │ - radiusGeometry.move = function(x, y) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - var dx1 = this.x - originGeometry.x; │ │ │ │ - var dy1 = this.y - originGeometry.y; │ │ │ │ - var dx0 = dx1 - x; │ │ │ │ - var dy0 = dy1 - y; │ │ │ │ - if (rotate) { │ │ │ │ - var a0 = Math.atan2(dy0, dx0); │ │ │ │ - var a1 = Math.atan2(dy1, dx1); │ │ │ │ - var angle = a1 - a0; │ │ │ │ - angle *= 180 / Math.PI; │ │ │ │ - geometry.rotate(angle, originGeometry); │ │ │ │ - } │ │ │ │ - if (resize) { │ │ │ │ - var scale, ratio; │ │ │ │ - // 'resize' together with 'reshape' implies that the aspect │ │ │ │ - // ratio of the geometry will not be preserved whilst resizing │ │ │ │ - if (reshape) { │ │ │ │ - scale = dy1 / dy0; │ │ │ │ - ratio = (dx1 / dx0) / scale; │ │ │ │ - } else { │ │ │ │ - var l0 = Math.sqrt((dx0 * dx0) + (dy0 * dy0)); │ │ │ │ - var l1 = Math.sqrt((dx1 * dx1) + (dy1 * dy1)); │ │ │ │ - scale = l1 / l0; │ │ │ │ - } │ │ │ │ - geometry.resize(scale, originGeometry, ratio); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - radius._sketch = true; │ │ │ │ - this.radiusHandle = radius; │ │ │ │ - this.radiusHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ - this.layer.addFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + this.map.events.on({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + activated = true; │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control and all handlers. │ │ │ │ + * Method: deactivate │ │ │ │ + * Turn off the handler. Returns false if the handler was already active. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} The control's map. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.drag.setMap(map); │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.moveLayerBack(); │ │ │ │ + this.feature = null; │ │ │ │ + this.lastFeature = null; │ │ │ │ + this.down = null; │ │ │ │ + this.up = null; │ │ │ │ + this.map.events.un({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + deactivated = true; │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: handleMapEvents │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * evt - {Object} │ │ │ │ @@ -60842,5395 +62703,6371 @@ │ │ │ │ this.layer.setZIndex(index); │ │ │ │ } else { │ │ │ │ this.map.setLayerZIndex(this.layer, │ │ │ │ this.map.getLayerIndex(this.layer)); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ModifyFeature" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: RESHAPE │ │ │ │ - * {Integer} Constant used to make the control work in reshape mode │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ModifyFeature.RESHAPE = 1; │ │ │ │ -/** │ │ │ │ - * Constant: RESIZE │ │ │ │ - * {Integer} Constant used to make the control work in resize mode │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ModifyFeature.RESIZE = 2; │ │ │ │ -/** │ │ │ │ - * Constant: ROTATE │ │ │ │ - * {Integer} Constant used to make the control work in rotate mode │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ModifyFeature.ROTATE = 4; │ │ │ │ -/** │ │ │ │ - * Constant: DRAG │ │ │ │ - * {Integer} Constant used to make the control work in drag mode │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ModifyFeature.DRAG = 8; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Pan.js │ │ │ │ + OpenLayers/Handler/Point.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/Button.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Pan │ │ │ │ - * The Pan control is a single button to pan the map in one direction. For │ │ │ │ - * a more complete control see <OpenLayers.Control.PanPanel>. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Handler.Point │ │ │ │ + * Handler to draw a point on the map. Point is displayed on activation, │ │ │ │ + * moves on mouse move, and is finished on mouse up. The handler triggers │ │ │ │ + * callbacks for 'done', 'cancel', and 'modify'. The modify callback is │ │ │ │ + * called with each change in the sketch and will receive the latest point │ │ │ │ + * drawn. Create a new instance with the <OpenLayers.Handler.Point> │ │ │ │ + * constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Pan = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ +OpenLayers.Handler.Point = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: slideFactor │ │ │ │ - * {Integer} Number of pixels by which we'll pan the map in any direction │ │ │ │ - * on clicking the arrow buttons, defaults to 50. If you want to pan │ │ │ │ - * by some ratio of the map dimensions, use <slideRatio> instead. │ │ │ │ + /** │ │ │ │ + * Property: point │ │ │ │ + * {<OpenLayers.Feature.Vector>} The currently drawn point │ │ │ │ */ │ │ │ │ - slideFactor: 50, │ │ │ │ + point: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: slideRatio │ │ │ │ - * {Number} The fraction of map width/height by which we'll pan the map │ │ │ │ - * on clicking the arrow buttons. Default is null. If set, will │ │ │ │ - * override <slideFactor>. E.g. if slideRatio is .5, then Pan Up will │ │ │ │ - * pan up half the map height. │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The temporary drawing layer │ │ │ │ */ │ │ │ │ - slideRatio: null, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: direction │ │ │ │ - * {String} in {'North', 'South', 'East', 'West'} │ │ │ │ + /** │ │ │ │ + * APIProperty: multi │ │ │ │ + * {Boolean} Cast features to multi-part geometries before passing to the │ │ │ │ + * layer. Default is false. │ │ │ │ */ │ │ │ │ - direction: null, │ │ │ │ + multi: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Pan │ │ │ │ - * Control which handles the panning (in any of the cardinal directions) │ │ │ │ - * of the map by a set px distance. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * direction - {String} The direction this button should pan. │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + * APIProperty: citeCompliant │ │ │ │ + * {Boolean} If set to true, coordinates of features drawn in a map extent │ │ │ │ + * crossing the date line won't exceed the world bounds. Default is false. │ │ │ │ */ │ │ │ │ - initialize: function(direction, options) { │ │ │ │ - │ │ │ │ - this.direction = direction; │ │ │ │ - this.CLASS_NAME += this.direction; │ │ │ │ + citeCompliant: false, │ │ │ │ │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: mouseDown │ │ │ │ + * {Boolean} The mouse is down │ │ │ │ + */ │ │ │ │ + mouseDown: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: trigger │ │ │ │ + * Property: stoppedDown │ │ │ │ + * {Boolean} Indicate whether the last mousedown stopped the event │ │ │ │ + * propagation. │ │ │ │ */ │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - var getSlideFactor = OpenLayers.Function.bind(function(dim) { │ │ │ │ - return this.slideRatio ? │ │ │ │ - this.map.getSize()[dim] * this.slideRatio : │ │ │ │ - this.slideFactor; │ │ │ │ - }, this); │ │ │ │ + stoppedDown: null, │ │ │ │ │ │ │ │ - switch (this.direction) { │ │ │ │ - case OpenLayers.Control.Pan.NORTH: │ │ │ │ - this.map.pan(0, -getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Control.Pan.SOUTH: │ │ │ │ - this.map.pan(0, getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Control.Pan.WEST: │ │ │ │ - this.map.pan(-getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Control.Pan.EAST: │ │ │ │ - this.map.pan(getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: lastDown │ │ │ │ + * {<OpenLayers.Pixel>} Location of the last mouse down │ │ │ │ + */ │ │ │ │ + lastDown: null, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Pan" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Property: lastUp │ │ │ │ + * {<OpenLayers.Pixel>} │ │ │ │ + */ │ │ │ │ + lastUp: null, │ │ │ │ │ │ │ │ -OpenLayers.Control.Pan.NORTH = "North"; │ │ │ │ -OpenLayers.Control.Pan.SOUTH = "South"; │ │ │ │ -OpenLayers.Control.Pan.EAST = "East"; │ │ │ │ -OpenLayers.Control.Pan.WEST = "West"; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/PanPanel.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * APIProperty: persist │ │ │ │ + * {Boolean} Leave the feature rendered until destroyFeature is called. │ │ │ │ + * Default is false. If set to true, the feature remains rendered until │ │ │ │ + * destroyFeature is called, typically by deactivating the handler or │ │ │ │ + * starting another drawing. │ │ │ │ + */ │ │ │ │ + persist: false, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: stopDown │ │ │ │ + * {Boolean} Stop event propagation on mousedown. Must be false to │ │ │ │ + * allow "pan while drawing". Defaults to false. │ │ │ │ + */ │ │ │ │ + stopDown: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control/Panel.js │ │ │ │ - * @requires OpenLayers/Control/Pan.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIPropery: stopUp │ │ │ │ + * {Boolean} Stop event propagation on mouse. Must be false to │ │ │ │ + * allow "pan while dragging". Defaults to fase. │ │ │ │ + */ │ │ │ │ + stopUp: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.PanPanel │ │ │ │ - * The PanPanel is visible control for panning the map North, South, East or │ │ │ │ - * West in small steps. By default it is drawn in the top left corner of the │ │ │ │ - * map. │ │ │ │ - * │ │ │ │ - * Note: │ │ │ │ - * If you wish to use this class with the default images and you want │ │ │ │ - * it to look nice in ie6, you should add the following, conditionally │ │ │ │ - * added css stylesheet to your HTML file: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * <!--[if lte IE 6]> │ │ │ │ - * <link rel="stylesheet" href="../theme/default/ie6-style.css" type="text/css" /> │ │ │ │ - * <![endif]--> │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control.Panel> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.PanPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ + /** │ │ │ │ + * Property: layerOptions │ │ │ │ + * {Object} Any optional properties to be set on the sketch layer. │ │ │ │ + */ │ │ │ │ + layerOptions: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: slideFactor │ │ │ │ - * {Integer} Number of pixels by which we'll pan the map in any direction │ │ │ │ - * on clicking the arrow buttons, defaults to 50. If you want to pan │ │ │ │ - * by some ratio of the map dimensions, use <slideRatio> instead. │ │ │ │ + /** │ │ │ │ + * APIProperty: pixelTolerance │ │ │ │ + * {Number} Maximum number of pixels between down and up (mousedown │ │ │ │ + * and mouseup, or touchstart and touchend) for the handler to │ │ │ │ + * add a new point. If set to an integer value, if the │ │ │ │ + * displacement between down and up is great to this value │ │ │ │ + * no point will be added. Default value is 5. │ │ │ │ */ │ │ │ │ - slideFactor: 50, │ │ │ │ + pixelTolerance: 5, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: slideRatio │ │ │ │ - * {Number} The fraction of map width/height by which we'll pan the map │ │ │ │ - * on clicking the arrow buttons. Default is null. If set, will │ │ │ │ - * override <slideFactor>. E.g. if slideRatio is .5, then Pan Up will │ │ │ │ - * pan up half the map height. │ │ │ │ + /** │ │ │ │ + * Property: lastTouchPx │ │ │ │ + * {<OpenLayers.Pixel>} The last pixel used to know the distance between │ │ │ │ + * two touches (for double touch). │ │ │ │ */ │ │ │ │ - slideRatio: null, │ │ │ │ + lastTouchPx: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.PanPanel │ │ │ │ - * Add the four directional pan buttons. │ │ │ │ + * Constructor: OpenLayers.Handler.Point │ │ │ │ + * Create a new point handler. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ + * callbacks - {Object} An object with a properties whose values are │ │ │ │ + * functions. Various callbacks described below. │ │ │ │ + * options - {Object} An optional object with properties to be set on the │ │ │ │ + * handler │ │ │ │ + * │ │ │ │ + * Named callbacks: │ │ │ │ + * create - Called when a sketch is first created. Callback called with │ │ │ │ + * the creation point geometry and sketch feature. │ │ │ │ + * modify - Called with each move of a vertex with the vertex (point) │ │ │ │ + * geometry and the sketch feature. │ │ │ │ + * done - Called when the point drawing is finished. The callback will │ │ │ │ + * recieve a single argument, the point geometry. │ │ │ │ + * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ + * cancel callback will receive a geometry. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - var options = { │ │ │ │ - slideFactor: this.slideFactor, │ │ │ │ - slideRatio: this.slideRatio │ │ │ │ - }; │ │ │ │ - this.addControls([ │ │ │ │ - new OpenLayers.Control.Pan(OpenLayers.Control.Pan.NORTH, options), │ │ │ │ - new OpenLayers.Control.Pan(OpenLayers.Control.Pan.SOUTH, options), │ │ │ │ - new OpenLayers.Control.Pan(OpenLayers.Control.Pan.EAST, options), │ │ │ │ - new OpenLayers.Control.Pan(OpenLayers.Control.Pan.WEST, options) │ │ │ │ - ]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PanPanel" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/GetFeature.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ - * @requires OpenLayers/Handler/Box.js │ │ │ │ - * @requires OpenLayers/Handler/Hover.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ - */ │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ + this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {}); │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.GetFeature │ │ │ │ - * Gets vector features for locations underneath the mouse cursor. Can be │ │ │ │ - * configured to act on click, hover or dragged boxes. Uses an │ │ │ │ - * <OpenLayers.Protocol> that supports spatial filters to retrieve │ │ │ │ - * features from a server and fires events that notify applications of the │ │ │ │ - * selected features. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.GetFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: protocol │ │ │ │ - * {<OpenLayers.Protocol>} Required. The protocol used for fetching │ │ │ │ - * features. │ │ │ │ + * APIMethod: activate │ │ │ │ + * turn on the handler │ │ │ │ */ │ │ │ │ - protocol: null, │ │ │ │ + activate: function() { │ │ │ │ + if (!OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + // create temporary vector layer for rendering geometry sketch │ │ │ │ + // TBD: this could be moved to initialize/destroy - setting visibility here │ │ │ │ + var options = OpenLayers.Util.extend({ │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + // indicate that the temp vector layer will never be out of range │ │ │ │ + // without this, resolution properties must be specified at the │ │ │ │ + // map-level for this temporary layer to init its resolutions │ │ │ │ + // correctly │ │ │ │ + calculateInRange: OpenLayers.Function.True, │ │ │ │ + wrapDateLine: this.citeCompliant │ │ │ │ + }, this.layerOptions); │ │ │ │ + this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ + this.map.addLayer(this.layer); │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: multipleKey │ │ │ │ - * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ - * the <multiple> property to true. Default is null. │ │ │ │ + * Method: createFeature │ │ │ │ + * Add temporary features │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * pixel - {<OpenLayers.Pixel>} A pixel location on the map. │ │ │ │ */ │ │ │ │ - multipleKey: null, │ │ │ │ + createFeature: function(pixel) { │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point( │ │ │ │ + lonlat.lon, lonlat.lat │ │ │ │ + ); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + this.callback("create", [this.point.geometry, this.point]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.layer.addFeatures([this.point], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: toggleKey │ │ │ │ - * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ - * the <toggle> property to true. Default is null. │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * turn off the handler │ │ │ │ */ │ │ │ │ - toggleKey: null, │ │ │ │ + deactivate: function() { │ │ │ │ + if (!OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + this.cancel(); │ │ │ │ + // If a layer's map property is set to null, it means that that layer │ │ │ │ + // isn't added to the map. Since we ourself added the layer to the map │ │ │ │ + // in activate(), we can assume that if this.layer.map is null it means │ │ │ │ + // that the layer has been destroyed (as a result of map.destroy() for │ │ │ │ + // example. │ │ │ │ + if (this.layer.map != null) { │ │ │ │ + this.destroyFeature(true); │ │ │ │ + this.layer.destroy(false); │ │ │ │ + } │ │ │ │ + this.layer = null; │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: modifiers │ │ │ │ - * {Object} The event modifiers to use, according to the current event │ │ │ │ - * being handled by this control's handlers │ │ │ │ + * Method: destroyFeature │ │ │ │ + * Destroy the temporary geometries │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * force - {Boolean} Destroy even if persist is true. │ │ │ │ */ │ │ │ │ - modifiers: null, │ │ │ │ + destroyFeature: function(force) { │ │ │ │ + if (this.layer && (force || !this.persist)) { │ │ │ │ + this.layer.destroyFeatures(); │ │ │ │ + } │ │ │ │ + this.point = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: multiple │ │ │ │ - * {Boolean} Allow selection of multiple geometries. Default is false. │ │ │ │ + * Method: destroyPersistedFeature │ │ │ │ + * Destroy the persisted feature. │ │ │ │ */ │ │ │ │ - multiple: false, │ │ │ │ + destroyPersistedFeature: function() { │ │ │ │ + var layer = this.layer; │ │ │ │ + if (layer && layer.features.length > 1) { │ │ │ │ + this.layer.features[0].destroy(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: click │ │ │ │ - * {Boolean} Use a click handler for selecting/unselecting features. If │ │ │ │ - * both <click> and <box> are set to true, the click handler takes │ │ │ │ - * precedence over the box handler if a box with zero extent was │ │ │ │ - * selected. Default is true. │ │ │ │ + * Method: finalize │ │ │ │ + * Finish the geometry and call the "done" callback. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * cancel - {Boolean} Call cancel instead of done callback. Default │ │ │ │ + * is false. │ │ │ │ */ │ │ │ │ - click: true, │ │ │ │ + finalize: function(cancel) { │ │ │ │ + var key = cancel ? "cancel" : "done"; │ │ │ │ + this.mouseDown = false; │ │ │ │ + this.lastDown = null; │ │ │ │ + this.lastUp = null; │ │ │ │ + this.lastTouchPx = null; │ │ │ │ + this.callback(key, [this.geometryClone()]); │ │ │ │ + this.destroyFeature(cancel); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: single │ │ │ │ - * {Boolean} Tells whether select by click should select a single │ │ │ │ - * feature. If set to false, all matching features are selected. │ │ │ │ - * If set to true, only the best matching feature is selected. │ │ │ │ - * This option has an effect only of the <click> option is set │ │ │ │ - * to true. Default is true. │ │ │ │ + * APIMethod: cancel │ │ │ │ + * Finish the geometry and call the "cancel" callback. │ │ │ │ */ │ │ │ │ - single: true, │ │ │ │ + cancel: function() { │ │ │ │ + this.finalize(true); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: clickout │ │ │ │ - * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ - * Applies only if <click> is true. Default is true. │ │ │ │ + * Method: click │ │ │ │ + * Handle clicks. Clicks are stopped from propagating to other listeners │ │ │ │ + * on map.events or other dom elements. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - clickout: true, │ │ │ │ + click: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + return false; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: toggle │ │ │ │ - * {Boolean} Unselect a selected feature on click. Applies only if │ │ │ │ - * <click> is true. Default is false. │ │ │ │ + * Method: dblclick │ │ │ │ + * Handle double-clicks. Double-clicks are stopped from propagating to other │ │ │ │ + * listeners on map.events or other dom elements. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - toggle: false, │ │ │ │ + dblclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + return false; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: clickTolerance │ │ │ │ - * {Integer} Tolerance for the filter query in pixels. This has the │ │ │ │ - * same effect as the tolerance parameter on WMS GetFeatureInfo │ │ │ │ - * requests. Will be ignored for box selections. Applies only if │ │ │ │ - * <click> or <hover> is true. Default is 5. Note that this not │ │ │ │ - * only affects requests on click, but also on hover. │ │ │ │ + * Method: modifyFeature │ │ │ │ + * Modify the existing geometry given a pixel location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * pixel - {<OpenLayers.Pixel>} A pixel location on the map. │ │ │ │ */ │ │ │ │ - clickTolerance: 5, │ │ │ │ + modifyFeature: function(pixel) { │ │ │ │ + if (!this.point) { │ │ │ │ + this.createFeature(pixel); │ │ │ │ + } │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + this.point.geometry.x = lonlat.lon; │ │ │ │ + this.point.geometry.y = lonlat.lat; │ │ │ │ + this.callback("modify", [this.point.geometry, this.point, false]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.drawFeature(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: hover │ │ │ │ - * {Boolean} Send feature requests on mouse moves. Default is false. │ │ │ │ + * Method: drawFeature │ │ │ │ + * Render features on the temporary layer. │ │ │ │ */ │ │ │ │ - hover: false, │ │ │ │ + drawFeature: function() { │ │ │ │ + this.layer.drawFeature(this.point, this.style); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: box │ │ │ │ - * {Boolean} Allow feature selection by drawing a box. If set to │ │ │ │ - * true set <click> to false to disable the click handler and │ │ │ │ - * rely on the box handler only, even for "zero extent" boxes. │ │ │ │ - * See the description of the <click> option for additional │ │ │ │ - * information. Default is false. │ │ │ │ + * Method: getGeometry │ │ │ │ + * Return the sketch geometry. If <multi> is true, this will return │ │ │ │ + * a multi-part geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Point>} │ │ │ │ */ │ │ │ │ - box: false, │ │ │ │ + getGeometry: function() { │ │ │ │ + var geometry = this.point && this.point.geometry; │ │ │ │ + if (geometry && this.multi) { │ │ │ │ + geometry = new OpenLayers.Geometry.MultiPoint([geometry]); │ │ │ │ + } │ │ │ │ + return geometry; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxFeatures │ │ │ │ - * {Integer} Maximum number of features to return from a query in single mode │ │ │ │ - * if supported by the <protocol>. This set of features is then used to │ │ │ │ - * determine the best match client-side. Default is 10. │ │ │ │ + * Method: geometryClone │ │ │ │ + * Return a clone of the relevant geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - maxFeatures: 10, │ │ │ │ + geometryClone: function() { │ │ │ │ + var geom = this.getGeometry(); │ │ │ │ + return geom && geom.clone(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: features │ │ │ │ - * {Object} Hash of {<OpenLayers.Feature.Vector>}, keyed by fid, holding │ │ │ │ - * the currently selected features │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mousedown. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - features: null, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + return this.down(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Proeprty: hoverFeature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The feature currently selected by the │ │ │ │ - * hover handler │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - hoverFeature: null, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + this.lastTouchPx = evt.xy; │ │ │ │ + return this.down(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Additional options for the handlers used by this control. This │ │ │ │ - * is a hash with the keys "click", "box" and "hover". │ │ │ │ + * Method: mousemove │ │ │ │ + * Handle mousemove. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ + mousemove: function(evt) { │ │ │ │ + return this.move(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: handlers │ │ │ │ - * {Object} Object with references to multiple <OpenLayers.Handler> │ │ │ │ - * instances. │ │ │ │ + * Method: touchmove │ │ │ │ + * Handle touchmove. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - handlers: null, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + this.lastTouchPx = evt.xy; │ │ │ │ + return this.move(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: hoverResponse │ │ │ │ - * {<OpenLayers.Protocol.Response>} The response object associated with │ │ │ │ - * the currently running hover request (if any). │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouseup. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - hoverResponse: null, │ │ │ │ + mouseup: function(evt) { │ │ │ │ + return this.up(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: filterType │ │ │ │ - * {<String>} The type of filter to use when sending off a request. │ │ │ │ - * Possible values: │ │ │ │ - * OpenLayers.Filter.Spatial.<BBOX|INTERSECTS|WITHIN|CONTAINS> │ │ │ │ - * Defaults to: OpenLayers.Filter.Spatial.BBOX │ │ │ │ + * Method: touchend │ │ │ │ + * Handle touchend. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - filterType: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + touchend: function(evt) { │ │ │ │ + evt.xy = this.lastTouchPx; │ │ │ │ + return this.up(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ + /** │ │ │ │ + * Method: down │ │ │ │ + * Handle mousedown and touchstart. Adjust the geometry and redraw. │ │ │ │ + * Return determines whether to propagate the event on the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ + */ │ │ │ │ + down: function(evt) { │ │ │ │ + this.mouseDown = true; │ │ │ │ + this.lastDown = evt.xy; │ │ │ │ + if (!this.touch) { // no point displayed until up on touch devices │ │ │ │ + this.modifyFeature(evt.xy); │ │ │ │ + } │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + return !this.stopDown; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * Handle mousemove and touchmove. Adjust the geometry and redraw. │ │ │ │ + * Return determines whether to propagate the event on the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforefeatureselected - Triggered when <click> is true before a │ │ │ │ - * feature is selected. The event object has a feature property with │ │ │ │ - * the feature about to select │ │ │ │ - * featureselected - Triggered when <click> is true and a feature is │ │ │ │ - * selected. The event object has a feature property with the │ │ │ │ - * selected feature │ │ │ │ - * beforefeaturesselected - Triggered when <click> is true before a │ │ │ │ - * set of features is selected. The event object is an array of │ │ │ │ - * feature properties with the features about to be selected. │ │ │ │ - * Return false after receiving this event to discontinue processing │ │ │ │ - * of all featureselected events and the featuresselected event. │ │ │ │ - * featuresselected - Triggered when <click> is true and a set of │ │ │ │ - * features is selected. The event object is an array of feature │ │ │ │ - * properties of the selected features │ │ │ │ - * featureunselected - Triggered when <click> is true and a feature is │ │ │ │ - * unselected. The event object has a feature property with the │ │ │ │ - * unselected feature │ │ │ │ - * clickout - Triggered when when <click> is true and no feature was │ │ │ │ - * selected. │ │ │ │ - * hoverfeature - Triggered when <hover> is true and the mouse has │ │ │ │ - * stopped over a feature │ │ │ │ - * outfeature - Triggered when <hover> is true and the mouse moves │ │ │ │ - * moved away from a hover-selected feature │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ + move: function(evt) { │ │ │ │ + if (!this.touch // no point displayed until up on touch devices │ │ │ │ + && │ │ │ │ + (!this.mouseDown || this.stoppedDown)) { │ │ │ │ + this.modifyFeature(evt.xy); │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.GetFeature │ │ │ │ - * Create a new control for fetching remote features. │ │ │ │ + * Method: up │ │ │ │ + * Handle mouseup and touchend. Send the latest point in the geometry to the control. │ │ │ │ + * Return determines whether to propagate the event on the map. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} A configuration object which at least has to contain │ │ │ │ - * a <protocol> property (if not, it has to be set before a request is │ │ │ │ - * made) │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options.handlerOptions = options.handlerOptions || {}; │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - this.features = {}; │ │ │ │ - │ │ │ │ - this.handlers = {}; │ │ │ │ + up: function(evt) { │ │ │ │ + this.mouseDown = false; │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ │ │ │ │ - if (this.click) { │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click(this, { │ │ │ │ - click: this.selectClick │ │ │ │ - }, this.handlerOptions.click || {}); │ │ │ │ + // check keyboard modifiers │ │ │ │ + if (!this.checkModifiers(evt)) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ - │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box = new OpenLayers.Handler.Box( │ │ │ │ - this, { │ │ │ │ - done: this.selectBox │ │ │ │ - }, │ │ │ │ - OpenLayers.Util.extend(this.handlerOptions.box, { │ │ │ │ - boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ + // ignore double-clicks │ │ │ │ + if (this.lastUp && this.lastUp.equals(evt.xy)) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ - │ │ │ │ - if (this.hover) { │ │ │ │ - this.handlers.hover = new OpenLayers.Handler.Hover( │ │ │ │ - this, { │ │ │ │ - 'move': this.cancelHover, │ │ │ │ - 'pause': this.selectHover │ │ │ │ - }, │ │ │ │ - OpenLayers.Util.extend(this.handlerOptions.hover, { │ │ │ │ - 'delay': 250, │ │ │ │ - 'pixelTolerance': 2 │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ + if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy, │ │ │ │ + this.pixelTolerance)) { │ │ │ │ + if (this.touch) { │ │ │ │ + this.modifyFeature(evt.xy); │ │ │ │ + } │ │ │ │ + if (this.persist) { │ │ │ │ + this.destroyPersistedFeature(); │ │ │ │ + } │ │ │ │ + this.lastUp = evt.xy; │ │ │ │ + this.finalize(); │ │ │ │ + return !this.stopUp; │ │ │ │ + } else { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activates the control. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The control was effectively activated. │ │ │ │ + * Method: mouseout │ │ │ │ + * Handle mouse out. For better user experience reset mouseDown │ │ │ │ + * and stoppedDown when the mouse leaves the map viewport. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - for (var i in this.handlers) { │ │ │ │ - this.handlers[i].activate(); │ │ │ │ - } │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + this.mouseDown = false; │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivates the control. │ │ │ │ - * │ │ │ │ + * Method: passesTolerance │ │ │ │ + * Determine whether the event is within the optional pixel tolerance. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The control was effectively deactivated. │ │ │ │ + * {Boolean} The event is within the pixel tolerance (if specified). │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - for (var i in this.handlers) { │ │ │ │ - this.handlers[i].deactivate(); │ │ │ │ + passesTolerance: function(pixel1, pixel2, tolerance) { │ │ │ │ + var passes = true; │ │ │ │ + │ │ │ │ + if (tolerance != null && pixel1 && pixel2) { │ │ │ │ + var dist = pixel1.distanceTo(pixel2); │ │ │ │ + if (dist > tolerance) { │ │ │ │ + passes = false; │ │ │ │ } │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ + return passes; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Point" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Handler/Path.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Handler/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Handler.Path │ │ │ │ + * Handler to draw a path on the map. Path is displayed on mouse down, │ │ │ │ + * moves on mouse move, and is finished on mouse up. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler.Point> │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.Path = OpenLayers.Class(OpenLayers.Handler.Point, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: selectClick │ │ │ │ - * Called on click │ │ │ │ + * Property: line │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + line: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: maxVertices │ │ │ │ + * {Number} The maximum number of vertices which can be drawn by this │ │ │ │ + * handler. When the number of vertices reaches maxVertices, the │ │ │ │ + * geometry is automatically finalized. Default is null. │ │ │ │ + */ │ │ │ │ + maxVertices: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: doubleTouchTolerance │ │ │ │ + * {Number} Maximum number of pixels between two touches for │ │ │ │ + * the gesture to be considered a "finalize feature" action. │ │ │ │ + * Default is 20. │ │ │ │ + */ │ │ │ │ + doubleTouchTolerance: 20, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: freehand │ │ │ │ + * {Boolean} In freehand mode, the handler starts the path on mouse down, │ │ │ │ + * adds a point for every mouse move, and finishes the path on mouse up. │ │ │ │ + * Outside of freehand mode, a point is added to the path on every mouse │ │ │ │ + * click and double-click finishes the path. │ │ │ │ + */ │ │ │ │ + freehand: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: freehandToggle │ │ │ │ + * {String} If set, freehandToggle is checked on mouse events and will set │ │ │ │ + * the freehand mode to the opposite of this.freehand. To disallow │ │ │ │ + * toggling between freehand and non-freehand mode, set freehandToggle to │ │ │ │ + * null. Acceptable toggle values are 'shiftKey', 'ctrlKey', and 'altKey'. │ │ │ │ + */ │ │ │ │ + freehandToggle: 'shiftKey', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: timerId │ │ │ │ + * {Integer} The timer used to test the double touch. │ │ │ │ + */ │ │ │ │ + timerId: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: redoStack │ │ │ │ + * {Array} Stack containing points removed with <undo>. │ │ │ │ + */ │ │ │ │ + redoStack: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler.Path │ │ │ │ + * Create a new path hander │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ + * callbacks - {Object} An object with a properties whose values are │ │ │ │ + * functions. Various callbacks described below. │ │ │ │ + * options - {Object} An optional object with properties to be set on the │ │ │ │ + * handler │ │ │ │ + * │ │ │ │ + * Named callbacks: │ │ │ │ + * create - Called when a sketch is first created. Callback called with │ │ │ │ + * the creation point geometry and sketch feature. │ │ │ │ + * modify - Called with each move of a vertex with the vertex (point) │ │ │ │ + * geometry and the sketch feature. │ │ │ │ + * point - Called as each point is added. Receives the new point geometry. │ │ │ │ + * done - Called when the point drawing is finished. The callback will │ │ │ │ + * recieve a single argument, the linestring geometry. │ │ │ │ + * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ + * cancel callback will receive a geometry. │ │ │ │ */ │ │ │ │ - selectClick: function(evt) { │ │ │ │ - var bounds = this.pixelToBounds(evt.xy); │ │ │ │ │ │ │ │ - this.setModifiers(evt); │ │ │ │ - this.request(bounds, { │ │ │ │ - single: this.single │ │ │ │ + /** │ │ │ │ + * Method: createFeature │ │ │ │ + * Add temporary geometries │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The initial pixel location for the new │ │ │ │ + * feature. │ │ │ │ + */ │ │ │ │ + createFeature: function(pixel) { │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point( │ │ │ │ + lonlat.lon, lonlat.lat │ │ │ │ + ); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + this.line = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.LineString([this.point.geometry]) │ │ │ │ + ); │ │ │ │ + this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.layer.addFeatures([this.line, this.point], { │ │ │ │ + silent: true │ │ │ │ }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: selectBox │ │ │ │ - * Callback from the handlers.box set up when <box> selection is on │ │ │ │ + * Method: destroyFeature │ │ │ │ + * Destroy temporary geometries │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * position - {<OpenLayers.Bounds>|Object} An OpenLayers.Bounds or │ │ │ │ - * an object with a 'left', 'bottom', 'right' and 'top' properties. │ │ │ │ + * force - {Boolean} Destroy even if persist is true. │ │ │ │ */ │ │ │ │ - selectBox: function(position) { │ │ │ │ - var bounds; │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - bounds = new OpenLayers.Bounds( │ │ │ │ - minXY.lon, minXY.lat, maxXY.lon, maxXY.lat │ │ │ │ - ); │ │ │ │ + destroyFeature: function(force) { │ │ │ │ + OpenLayers.Handler.Point.prototype.destroyFeature.call( │ │ │ │ + this, force); │ │ │ │ + this.line = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - } else { │ │ │ │ - if (this.click) { │ │ │ │ - // box without extent - let the click handler take care of it │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - bounds = this.pixelToBounds(position); │ │ │ │ + /** │ │ │ │ + * Method: destroyPersistedFeature │ │ │ │ + * Destroy the persisted feature. │ │ │ │ + */ │ │ │ │ + destroyPersistedFeature: function() { │ │ │ │ + var layer = this.layer; │ │ │ │ + if (layer && layer.features.length > 2) { │ │ │ │ + this.layer.features[0].destroy(); │ │ │ │ } │ │ │ │ - this.setModifiers(this.handlers.box.dragHandler.evt); │ │ │ │ - this.request(bounds); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: selectHover │ │ │ │ - * Callback from the handlers.hover set up when <hover> selection is on │ │ │ │ + * Method: removePoint │ │ │ │ + * Destroy the temporary point. │ │ │ │ + */ │ │ │ │ + removePoint: function() { │ │ │ │ + if (this.point) { │ │ │ │ + this.layer.removeFeatures([this.point]); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: addPoint │ │ │ │ + * Add point to geometry. Send the point index to override │ │ │ │ + * the behavior of LinearRing that disregards adding duplicate points. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} event object with an xy property │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The pixel location for the new point. │ │ │ │ */ │ │ │ │ - selectHover: function(evt) { │ │ │ │ - var bounds = this.pixelToBounds(evt.xy); │ │ │ │ - this.request(bounds, { │ │ │ │ - single: true, │ │ │ │ - hover: true │ │ │ │ - }); │ │ │ │ + addPoint: function(pixel) { │ │ │ │ + this.layer.removeFeatures([this.point]); │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + this.point = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat) │ │ │ │ + ); │ │ │ │ + this.line.geometry.addComponent( │ │ │ │ + this.point.geometry, this.line.geometry.components.length │ │ │ │ + ); │ │ │ │ + this.layer.addFeatures([this.point]); │ │ │ │ + this.callback("point", [this.point.geometry, this.getGeometry()]); │ │ │ │ + this.callback("modify", [this.point.geometry, this.getSketch()]); │ │ │ │ + this.drawFeature(); │ │ │ │ + delete this.redoStack; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cancelHover │ │ │ │ - * Callback from the handlers.hover set up when <hover> selection is on │ │ │ │ + * Method: insertXY │ │ │ │ + * Insert a point in the current sketch given x & y coordinates. The new │ │ │ │ + * point is inserted immediately before the most recently drawn point. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Number} The x-coordinate of the point. │ │ │ │ + * y - {Number} The y-coordinate of the point. │ │ │ │ */ │ │ │ │ - cancelHover: function() { │ │ │ │ - if (this.hoverResponse) { │ │ │ │ - this.protocol.abort(this.hoverResponse); │ │ │ │ - this.hoverResponse = null; │ │ │ │ + insertXY: function(x, y) { │ │ │ │ + this.line.geometry.addComponent( │ │ │ │ + new OpenLayers.Geometry.Point(x, y), │ │ │ │ + this.getCurrentPointIndex() │ │ │ │ + ); │ │ │ │ + this.drawFeature(); │ │ │ │ + delete this.redoStack; │ │ │ │ + }, │ │ │ │ │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + /** │ │ │ │ + * Method: insertDeltaXY │ │ │ │ + * Insert a point given offsets from the previously inserted point. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * dx - {Number} The x-coordinate offset of the point. │ │ │ │ + * dy - {Number} The y-coordinate offset of the point. │ │ │ │ + */ │ │ │ │ + insertDeltaXY: function(dx, dy) { │ │ │ │ + var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ + var p0 = this.line.geometry.components[previousIndex]; │ │ │ │ + if (p0 && !isNaN(p0.x) && !isNaN(p0.y)) { │ │ │ │ + this.insertXY(p0.x + dx, p0.y + dy); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: request │ │ │ │ - * Sends a GetFeature request to the WFS │ │ │ │ - * │ │ │ │ + * Method: insertDirectionLength │ │ │ │ + * Insert a point in the current sketch given a direction and a length. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} bounds for the request's BBOX filter │ │ │ │ - * options - {Object} additional options for this method. │ │ │ │ - * │ │ │ │ - * Supported options include: │ │ │ │ - * single - {Boolean} A single feature should be returned. │ │ │ │ - * Note that this will be ignored if the protocol does not │ │ │ │ - * return the geometries of the features. │ │ │ │ - * hover - {Boolean} Do the request for the hover handler. │ │ │ │ + * direction - {Number} Degrees clockwise from the positive x-axis. │ │ │ │ + * length - {Number} Distance from the previously drawn point. │ │ │ │ */ │ │ │ │ - request: function(bounds, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: this.filterType, │ │ │ │ - value: bounds │ │ │ │ - }); │ │ │ │ - │ │ │ │ - // Set the cursor to "wait" to tell the user we're working. │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + insertDirectionLength: function(direction, length) { │ │ │ │ + direction *= Math.PI / 180; │ │ │ │ + var dx = length * Math.cos(direction); │ │ │ │ + var dy = length * Math.sin(direction); │ │ │ │ + this.insertDeltaXY(dx, dy); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var response = this.protocol.read({ │ │ │ │ - maxFeatures: options.single == true ? this.maxFeatures : undefined, │ │ │ │ - filter: filter, │ │ │ │ - callback: function(result) { │ │ │ │ - if (result.success()) { │ │ │ │ - if (result.features.length) { │ │ │ │ - if (options.single == true) { │ │ │ │ - this.selectBestFeature(result.features, │ │ │ │ - bounds.getCenterLonLat(), options); │ │ │ │ - } else { │ │ │ │ - this.select(result.features); │ │ │ │ - } │ │ │ │ - } else if (options.hover) { │ │ │ │ - this.hoverSelect(); │ │ │ │ - } else { │ │ │ │ - this.events.triggerEvent("clickout"); │ │ │ │ - if (this.clickout) { │ │ │ │ - this.unselectAll(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // Reset the cursor. │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (options.hover == true) { │ │ │ │ - this.hoverResponse = response; │ │ │ │ + /** │ │ │ │ + * Method: insertDeflectionLength │ │ │ │ + * Insert a point in the current sketch given a deflection and a length. │ │ │ │ + * The deflection should be degrees clockwise from the previously │ │ │ │ + * digitized segment. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * deflection - {Number} Degrees clockwise from the previous segment. │ │ │ │ + * length - {Number} Distance from the previously drawn point. │ │ │ │ + */ │ │ │ │ + insertDeflectionLength: function(deflection, length) { │ │ │ │ + var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ + if (previousIndex > 0) { │ │ │ │ + var p1 = this.line.geometry.components[previousIndex]; │ │ │ │ + var p0 = this.line.geometry.components[previousIndex - 1]; │ │ │ │ + var theta = Math.atan2(p1.y - p0.y, p1.x - p0.x); │ │ │ │ + this.insertDirectionLength( │ │ │ │ + (theta * 180 / Math.PI) + deflection, length │ │ │ │ + ); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: selectBestFeature │ │ │ │ - * Selects the feature from an array of features that is the best match │ │ │ │ - * for the click position. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ - * clickPosition - {<OpenLayers.LonLat>} │ │ │ │ - * options - {Object} additional options for this method │ │ │ │ + * Method: getCurrentPointIndex │ │ │ │ * │ │ │ │ - * Supported options include: │ │ │ │ - * hover - {Boolean} Do the selection for the hover handler. │ │ │ │ + * Returns: │ │ │ │ + * {Number} The index of the most recently drawn point. │ │ │ │ */ │ │ │ │ - selectBestFeature: function(features, clickPosition, options) { │ │ │ │ - options = options || {}; │ │ │ │ - if (features.length) { │ │ │ │ - var point = new OpenLayers.Geometry.Point(clickPosition.lon, │ │ │ │ - clickPosition.lat); │ │ │ │ - var feature, resultFeature, dist; │ │ │ │ - var minDist = Number.MAX_VALUE; │ │ │ │ - for (var i = 0; i < features.length; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (feature.geometry) { │ │ │ │ - dist = point.distanceTo(feature.geometry, { │ │ │ │ - edge: false │ │ │ │ - }); │ │ │ │ - if (dist < minDist) { │ │ │ │ - minDist = dist; │ │ │ │ - resultFeature = feature; │ │ │ │ - if (minDist == 0) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + getCurrentPointIndex: function() { │ │ │ │ + return this.line.geometry.components.length - 1; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (options.hover == true) { │ │ │ │ - this.hoverSelect(resultFeature); │ │ │ │ - } else { │ │ │ │ - this.select(resultFeature || features); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: undo │ │ │ │ + * Remove the most recently added point in the sketch geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} A point was removed. │ │ │ │ + */ │ │ │ │ + undo: function() { │ │ │ │ + var geometry = this.line.geometry; │ │ │ │ + var components = geometry.components; │ │ │ │ + var index = this.getCurrentPointIndex() - 1; │ │ │ │ + var target = components[index]; │ │ │ │ + var undone = geometry.removeComponent(target); │ │ │ │ + if (undone) { │ │ │ │ + // On touch devices, set the current ("mouse location") point to │ │ │ │ + // match the last digitized point. │ │ │ │ + if (this.touch && index > 0) { │ │ │ │ + components = geometry.components; // safety │ │ │ │ + var lastpt = components[index - 1]; │ │ │ │ + var curptidx = this.getCurrentPointIndex(); │ │ │ │ + var curpt = components[curptidx]; │ │ │ │ + curpt.x = lastpt.x; │ │ │ │ + curpt.y = lastpt.y; │ │ │ │ + } │ │ │ │ + if (!this.redoStack) { │ │ │ │ + this.redoStack = []; │ │ │ │ } │ │ │ │ + this.redoStack.push(target); │ │ │ │ + this.drawFeature(); │ │ │ │ } │ │ │ │ + return undone; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setModifiers │ │ │ │ - * Sets the multiple and toggle modifiers according to the current event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * Method: redo │ │ │ │ + * Reinsert the most recently removed point resulting from an <undo> call. │ │ │ │ + * The undo stack is deleted whenever a point is added by other means. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} A point was added. │ │ │ │ */ │ │ │ │ - setModifiers: function(evt) { │ │ │ │ - this.modifiers = { │ │ │ │ - multiple: this.multiple || (this.multipleKey && evt[this.multipleKey]), │ │ │ │ - toggle: this.toggle || (this.toggleKey && evt[this.toggleKey]) │ │ │ │ - }; │ │ │ │ + redo: function() { │ │ │ │ + var target = this.redoStack && this.redoStack.pop(); │ │ │ │ + if (target) { │ │ │ │ + this.line.geometry.addComponent(target, this.getCurrentPointIndex()); │ │ │ │ + this.drawFeature(); │ │ │ │ + } │ │ │ │ + return !!target; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: select │ │ │ │ - * Add feature to the hash of selected features and trigger the │ │ │ │ - * featureselected and featuresselected events. │ │ │ │ - * │ │ │ │ + * Method: freehandMode │ │ │ │ + * Determine whether to behave in freehand mode or not. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + freehandMode: function(evt) { │ │ │ │ + return (this.freehandToggle && evt[this.freehandToggle]) ? │ │ │ │ + !this.freehand : this.freehand; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: modifyFeature │ │ │ │ + * Modify the existing geometry given the new point │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * features - {<OpenLayers.Feature.Vector>} or an array of features │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The updated pixel location for the latest │ │ │ │ + * point. │ │ │ │ + * drawing - {Boolean} Indicate if we're currently drawing. │ │ │ │ */ │ │ │ │ - select: function(features) { │ │ │ │ - if (!this.modifiers.multiple && !this.modifiers.toggle) { │ │ │ │ - this.unselectAll(); │ │ │ │ - } │ │ │ │ - if (!(OpenLayers.Util.isArray(features))) { │ │ │ │ - features = [features]; │ │ │ │ + modifyFeature: function(pixel, drawing) { │ │ │ │ + if (!this.line) { │ │ │ │ + this.createFeature(pixel); │ │ │ │ } │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + this.point.geometry.x = lonlat.lon; │ │ │ │ + this.point.geometry.y = lonlat.lat; │ │ │ │ + this.callback("modify", [this.point.geometry, this.getSketch(), drawing]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.drawFeature(); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var cont = this.events.triggerEvent("beforefeaturesselected", { │ │ │ │ - features: features │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - var selectedFeatures = []; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (this.features[feature.fid || feature.id]) { │ │ │ │ - if (this.modifiers.toggle) { │ │ │ │ - this.unselect(this.features[feature.fid || feature.id]); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - cont = this.events.triggerEvent("beforefeatureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - this.features[feature.fid || feature.id] = feature; │ │ │ │ - selectedFeatures.push(feature); │ │ │ │ - │ │ │ │ - this.events.triggerEvent("featureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("featuresselected", { │ │ │ │ - features: selectedFeatures │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: drawFeature │ │ │ │ + * Render geometries on the temporary layer. │ │ │ │ + */ │ │ │ │ + drawFeature: function() { │ │ │ │ + this.layer.drawFeature(this.line, this.style); │ │ │ │ + this.layer.drawFeature(this.point, this.style); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: hoverSelect │ │ │ │ - * Sets/unsets the <hoverFeature> │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} the feature to hover-select. │ │ │ │ - * If none is provided, the current <hoverFeature> will be nulled and │ │ │ │ - * the outfeature event will be triggered. │ │ │ │ + * Method: getSketch │ │ │ │ + * Return the sketch feature. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - hoverSelect: function(feature) { │ │ │ │ - var fid = feature ? feature.fid || feature.id : null; │ │ │ │ - var hfid = this.hoverFeature ? │ │ │ │ - this.hoverFeature.fid || this.hoverFeature.id : null; │ │ │ │ + getSketch: function() { │ │ │ │ + return this.line; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (hfid && hfid != fid) { │ │ │ │ - this.events.triggerEvent("outfeature", { │ │ │ │ - feature: this.hoverFeature │ │ │ │ - }); │ │ │ │ - this.hoverFeature = null; │ │ │ │ - } │ │ │ │ - if (fid && fid != hfid) { │ │ │ │ - this.events.triggerEvent("hoverfeature", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.hoverFeature = feature; │ │ │ │ + /** │ │ │ │ + * Method: getGeometry │ │ │ │ + * Return the sketch geometry. If <multi> is true, this will return │ │ │ │ + * a multi-part geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.LineString>} │ │ │ │ + */ │ │ │ │ + getGeometry: function() { │ │ │ │ + var geometry = this.line && this.line.geometry; │ │ │ │ + if (geometry && this.multi) { │ │ │ │ + geometry = new OpenLayers.Geometry.MultiLineString([geometry]); │ │ │ │ } │ │ │ │ + return geometry; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unselect │ │ │ │ - * Remove feature from the hash of selected features and trigger the │ │ │ │ - * featureunselected event. │ │ │ │ + * method: touchstart │ │ │ │ + * handle touchstart. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * parameters: │ │ │ │ + * evt - {event} the browser event │ │ │ │ + * │ │ │ │ + * returns: │ │ │ │ + * {boolean} allow event propagation │ │ │ │ */ │ │ │ │ - unselect: function(feature) { │ │ │ │ - delete this.features[feature.fid || feature.id]; │ │ │ │ - this.events.triggerEvent("featureunselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ + touchstart: function(evt) { │ │ │ │ + if (this.timerId && │ │ │ │ + this.passesTolerance(this.lastTouchPx, evt.xy, │ │ │ │ + this.doubleTouchTolerance)) { │ │ │ │ + // double-tap, finalize the geometry │ │ │ │ + this.finishGeometry(); │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + return false; │ │ │ │ + } else { │ │ │ │ + if (this.timerId) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + } │ │ │ │ + this.timerId = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(function() { │ │ │ │ + this.timerId = null; │ │ │ │ + }, this), 300); │ │ │ │ + return OpenLayers.Handler.Point.prototype.touchstart.call(this, evt); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unselectAll │ │ │ │ - * Unselect all selected features. │ │ │ │ + * Method: down │ │ │ │ + * Handle mousedown and touchstart. Add a new point to the geometry and │ │ │ │ + * render it. Return determines whether to propagate the event on the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - unselectAll: function() { │ │ │ │ - // we'll want an option to supress notification here │ │ │ │ - for (var fid in this.features) { │ │ │ │ - this.unselect(this.features[fid]); │ │ │ │ + down: function(evt) { │ │ │ │ + var stopDown = this.stopDown; │ │ │ │ + if (this.freehandMode(evt)) { │ │ │ │ + stopDown = true; │ │ │ │ + if (this.touch) { │ │ │ │ + this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!this.touch && (!this.lastDown || │ │ │ │ + !this.passesTolerance(this.lastDown, evt.xy, │ │ │ │ + this.pixelTolerance))) { │ │ │ │ + this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ } │ │ │ │ + this.mouseDown = true; │ │ │ │ + this.lastDown = evt.xy; │ │ │ │ + this.stoppedDown = stopDown; │ │ │ │ + return !stopDown; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * Handle mousemove and touchmove. Adjust the geometry and redraw. │ │ │ │ + * Return determines whether to propagate the event on the map. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - for (var i in this.handlers) { │ │ │ │ - this.handlers[i].setMap(map); │ │ │ │ + move: function(evt) { │ │ │ │ + if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ + if (this.persist) { │ │ │ │ + this.destroyPersistedFeature(); │ │ │ │ + } │ │ │ │ + if (this.maxVertices && this.line && │ │ │ │ + this.line.geometry.components.length === this.maxVertices) { │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize(); │ │ │ │ + } else { │ │ │ │ + this.addPoint(evt.xy); │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + if (!this.touch && (!this.mouseDown || this.stoppedDown)) { │ │ │ │ + this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: pixelToBounds │ │ │ │ - * Takes a pixel as argument and creates bounds after adding the │ │ │ │ - * <clickTolerance>. │ │ │ │ + * Method: up │ │ │ │ + * Handle mouseup and touchend. Send the latest point in the geometry to │ │ │ │ + * the control. Return determines whether to propagate the event on the map. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * pixel - {<OpenLayers.Pixel>} │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - pixelToBounds: function(pixel) { │ │ │ │ - var llPx = pixel.add(-this.clickTolerance / 2, this.clickTolerance / 2); │ │ │ │ - var urPx = pixel.add(this.clickTolerance / 2, -this.clickTolerance / 2); │ │ │ │ - var ll = this.map.getLonLatFromPixel(llPx); │ │ │ │ - var ur = this.map.getLonLatFromPixel(urPx); │ │ │ │ - return new OpenLayers.Bounds(ll.lon, ll.lat, ur.lon, ur.lat); │ │ │ │ + up: function(evt) { │ │ │ │ + if (this.mouseDown && (!this.lastUp || !this.lastUp.equals(evt.xy))) { │ │ │ │ + if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ + if (this.persist) { │ │ │ │ + this.destroyPersistedFeature(); │ │ │ │ + } │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize(); │ │ │ │ + } else { │ │ │ │ + if (this.passesTolerance(this.lastDown, evt.xy, │ │ │ │ + this.pixelTolerance)) { │ │ │ │ + if (this.touch) { │ │ │ │ + this.modifyFeature(evt.xy); │ │ │ │ + } │ │ │ │ + if (this.lastUp == null && this.persist) { │ │ │ │ + this.destroyPersistedFeature(); │ │ │ │ + } │ │ │ │ + this.addPoint(evt.xy); │ │ │ │ + this.lastUp = evt.xy; │ │ │ │ + if (this.line.geometry.components.length === this.maxVertices + 1) { │ │ │ │ + this.finishGeometry(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + this.mouseDown = false; │ │ │ │ + return !this.stopUp; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.GetFeature" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/ZoomToMaxExtent.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control/Button.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.ZoomToMaxExtent │ │ │ │ - * The ZoomToMaxExtent control is a button that zooms out to the maximum │ │ │ │ - * extent of the map. It is designed to be used with a │ │ │ │ - * <OpenLayers.Control.Panel>. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ZoomToMaxExtent = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + /** │ │ │ │ + * APIMethod: finishGeometry │ │ │ │ + * Finish the geometry and send it back to the control. │ │ │ │ + */ │ │ │ │ + finishGeometry: function() { │ │ │ │ + var index = this.line.geometry.components.length - 1; │ │ │ │ + this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: trigger │ │ │ │ + * Method: dblclick │ │ │ │ + * Handle double-clicks. │ │ │ │ * │ │ │ │ - * Called whenever this control is being rendered inside of a panel and a │ │ │ │ - * click occurs on this controls element. Actually zooms to the maximum │ │ │ │ - * extent of this controls map. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow event propagation │ │ │ │ */ │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.zoomToMaxExtent(); │ │ │ │ + dblclick: function(evt) { │ │ │ │ + if (!this.freehandMode(evt)) { │ │ │ │ + this.finishGeometry(); │ │ │ │ } │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomToMaxExtent" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Path" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/CacheRead.js │ │ │ │ + OpenLayers/Handler/Polygon.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Path.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.CacheRead │ │ │ │ - * A control for using image tiles cached with <OpenLayers.Control.CacheWrite> │ │ │ │ - * from the browser's local storage. │ │ │ │ + * Class: OpenLayers.Handler.Polygon │ │ │ │ + * Handler to draw a polygon on the map. Polygon is displayed on mouse down, │ │ │ │ + * moves on mouse move, and is finished on mouse up. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler.Path> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.CacheRead = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Handler.Polygon = OpenLayers.Class(OpenLayers.Handler.Path, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: fetchEvent │ │ │ │ - * {String} The layer event to listen to for replacing remote resource tile │ │ │ │ - * URLs with cached data URIs. Supported values are "tileerror" (try │ │ │ │ - * remote first, fall back to cached) and "tileloadstart" (try cache │ │ │ │ - * first, fall back to remote). Default is "tileloadstart". │ │ │ │ - * │ │ │ │ - * Note that "tileerror" will not work for CORS enabled images (see │ │ │ │ - * https://developer.mozilla.org/en/CORS_Enabled_Image), i.e. layers │ │ │ │ - * configured with a <OpenLayers.Tile.Image.crossOriginKeyword> in │ │ │ │ - * <OpenLayers.Layer.Grid.tileOptions>. │ │ │ │ + /** │ │ │ │ + * APIProperty: holeModifier │ │ │ │ + * {String} Key modifier to trigger hole digitizing. Acceptable values are │ │ │ │ + * "altKey", "shiftKey", or "ctrlKey". If not set, no hole digitizing │ │ │ │ + * will take place. Default is null. │ │ │ │ */ │ │ │ │ - fetchEvent: "tileloadstart", │ │ │ │ + holeModifier: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * {Array(<OpenLayers.Layer.Grid>)}. Optional. If provided, only these │ │ │ │ - * layers will receive tiles from the cache. │ │ │ │ + * Property: drawingHole │ │ │ │ + * {Boolean} Currently drawing an interior ring. │ │ │ │ */ │ │ │ │ - layers: null, │ │ │ │ + drawingHole: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * Property: polygon │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + polygon: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.CacheRead │ │ │ │ + * Constructor: OpenLayers.Handler.Polygon │ │ │ │ + * Create a Polygon Handler. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Object with API properties for this control │ │ │ │ + * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ + * callbacks - {Object} An object with a properties whose values are │ │ │ │ + * functions. Various callbacks described below. │ │ │ │ + * options - {Object} An optional object with properties to be set on the │ │ │ │ + * handler │ │ │ │ + * │ │ │ │ + * Named callbacks: │ │ │ │ + * create - Called when a sketch is first created. Callback called with │ │ │ │ + * the creation point geometry and sketch feature. │ │ │ │ + * modify - Called with each move of a vertex with the vertex (point) │ │ │ │ + * geometry and the sketch feature. │ │ │ │ + * point - Called as each point is added. Receives the new point geometry. │ │ │ │ + * done - Called when the point drawing is finished. The callback will │ │ │ │ + * recieve a single argument, the polygon geometry. │ │ │ │ + * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ + * cancel callback will receive a geometry. │ │ │ │ */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: createFeature │ │ │ │ + * Add temporary geometries │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The initial pixel location for the new │ │ │ │ + * feature. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - var i, layers = this.layers || map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.addLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (!this.layers) { │ │ │ │ - map.events.on({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + createFeature: function(pixel) { │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point( │ │ │ │ + lonlat.lon, lonlat.lat │ │ │ │ + ); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + this.line = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.LinearRing([this.point.geometry]) │ │ │ │ + ); │ │ │ │ + this.polygon = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.Polygon([this.line.geometry]) │ │ │ │ + ); │ │ │ │ + this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.layer.addFeatures([this.polygon, this.point], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addLayer │ │ │ │ - * Adds a layer to the control. Once added, tiles requested for this layer │ │ │ │ - * will be cached. │ │ │ │ + * Method: addPoint │ │ │ │ + * Add point to geometry. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Object with a layer property referencing an │ │ │ │ - * <OpenLayers.Layer> instance │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The pixel location for the new point. │ │ │ │ */ │ │ │ │ - addLayer: function(evt) { │ │ │ │ - evt.layer.events.register(this.fetchEvent, this, this.fetch); │ │ │ │ + addPoint: function(pixel) { │ │ │ │ + if (!this.drawingHole && this.holeModifier && │ │ │ │ + this.evt && this.evt[this.holeModifier]) { │ │ │ │ + var geometry = this.point.geometry; │ │ │ │ + var features = this.control.layer.features; │ │ │ │ + var candidate, polygon; │ │ │ │ + // look for intersections, last drawn gets priority │ │ │ │ + for (var i = features.length - 1; i >= 0; --i) { │ │ │ │ + candidate = features[i].geometry; │ │ │ │ + if ((candidate instanceof OpenLayers.Geometry.Polygon || │ │ │ │ + candidate instanceof OpenLayers.Geometry.MultiPolygon) && │ │ │ │ + candidate.intersects(geometry)) { │ │ │ │ + polygon = features[i]; │ │ │ │ + this.control.layer.removeFeatures([polygon], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.control.layer.events.registerPriority( │ │ │ │ + "sketchcomplete", this, this.finalizeInteriorRing │ │ │ │ + ); │ │ │ │ + this.control.layer.events.registerPriority( │ │ │ │ + "sketchmodified", this, this.enforceTopology │ │ │ │ + ); │ │ │ │ + polygon.geometry.addComponent(this.line.geometry); │ │ │ │ + this.polygon = polygon; │ │ │ │ + this.drawingHole = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Handler.Path.prototype.addPoint.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeLayer │ │ │ │ - * Removes a layer from the control. Once removed, tiles requested for this │ │ │ │ - * layer will no longer be cached. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} Object with a layer property referencing an │ │ │ │ - * <OpenLayers.Layer> instance │ │ │ │ + * Method: getCurrentPointIndex │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} The index of the most recently drawn point. │ │ │ │ */ │ │ │ │ - removeLayer: function(evt) { │ │ │ │ - evt.layer.events.unregister(this.fetchEvent, this, this.fetch); │ │ │ │ + getCurrentPointIndex: function() { │ │ │ │ + return this.line.geometry.components.length - 2; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: fetch │ │ │ │ - * Listener to the <fetchEvent> event. Replaces a tile's url with a data │ │ │ │ - * URI from the cache. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} Event object with a tile property. │ │ │ │ + * Method: enforceTopology │ │ │ │ + * Simple topology enforcement for drawing interior rings. Ensures vertices │ │ │ │ + * of interior rings are contained by exterior ring. Other topology │ │ │ │ + * rules are enforced in <finalizeInteriorRing> to allow drawing of │ │ │ │ + * rings that intersect only during the sketch (e.g. a "C" shaped ring │ │ │ │ + * that nearly encloses another ring). │ │ │ │ */ │ │ │ │ - fetch: function(evt) { │ │ │ │ - if (this.active && window.localStorage && │ │ │ │ - evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ - var tile = evt.tile, │ │ │ │ - url = tile.url; │ │ │ │ - // deal with modified tile urls when both CacheWrite and CacheRead │ │ │ │ - // are active │ │ │ │ - if (!tile.layer.crossOriginKeyword && OpenLayers.ProxyHost && │ │ │ │ - url.indexOf(OpenLayers.ProxyHost) === 0) { │ │ │ │ - url = OpenLayers.Control.CacheWrite.urlMap[url]; │ │ │ │ + enforceTopology: function(event) { │ │ │ │ + var point = event.vertex; │ │ │ │ + var components = this.line.geometry.components; │ │ │ │ + // ensure that vertices of interior ring are contained by exterior ring │ │ │ │ + if (!this.polygon.geometry.intersects(point)) { │ │ │ │ + var last = components[components.length - 3]; │ │ │ │ + point.x = last.x; │ │ │ │ + point.y = last.y; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: finishGeometry │ │ │ │ + * Finish the geometry and send it back to the control. │ │ │ │ + */ │ │ │ │ + finishGeometry: function() { │ │ │ │ + var index = this.line.geometry.components.length - 2; │ │ │ │ + this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: finalizeInteriorRing │ │ │ │ + * Enforces that new ring has some area and doesn't contain vertices of any │ │ │ │ + * other rings. │ │ │ │ + */ │ │ │ │ + finalizeInteriorRing: function() { │ │ │ │ + var ring = this.line.geometry; │ │ │ │ + // ensure that ring has some area │ │ │ │ + var modified = (ring.getArea() !== 0); │ │ │ │ + if (modified) { │ │ │ │ + // ensure that new ring doesn't intersect any other rings │ │ │ │ + var rings = this.polygon.geometry.components; │ │ │ │ + for (var i = rings.length - 2; i >= 0; --i) { │ │ │ │ + if (ring.intersects(rings[i])) { │ │ │ │ + modified = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ } │ │ │ │ - var dataURI = window.localStorage.getItem("olCache_" + url); │ │ │ │ - if (dataURI) { │ │ │ │ - tile.url = dataURI; │ │ │ │ - if (evt.type === "tileerror") { │ │ │ │ - tile.setImgSrc(dataURI); │ │ │ │ + if (modified) { │ │ │ │ + // ensure that new ring doesn't contain any other rings │ │ │ │ + var target; │ │ │ │ + outer: for (var i = rings.length - 2; i > 0; --i) { │ │ │ │ + var points = rings[i].components; │ │ │ │ + for (var j = 0, jj = points.length; j < jj; ++j) { │ │ │ │ + if (ring.containsPoint(points[j])) { │ │ │ │ + modified = false; │ │ │ │ + break outer; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ + if (modified) { │ │ │ │ + if (this.polygon.state !== OpenLayers.State.INSERT) { │ │ │ │ + this.polygon.state = OpenLayers.State.UPDATE; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.polygon.geometry.removeComponent(ring); │ │ │ │ + } │ │ │ │ + this.restoreFeature(); │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * APIMethod: cancel │ │ │ │ + * Finish the geometry and call the "cancel" callback. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layers || this.map) { │ │ │ │ - var i, layers = this.layers || this.map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + cancel: function() { │ │ │ │ + if (this.drawingHole) { │ │ │ │ + this.polygon.geometry.removeComponent(this.line.geometry); │ │ │ │ + this.restoreFeature(true); │ │ │ │ } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.un({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + return OpenLayers.Handler.Path.prototype.cancel.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: restoreFeature │ │ │ │ + * Move the feature from the sketch layer to the target layer. │ │ │ │ + * │ │ │ │ + * Properties: │ │ │ │ + * cancel - {Boolean} Cancel drawing. If falsey, the "sketchcomplete" event │ │ │ │ + * will be fired. │ │ │ │ + */ │ │ │ │ + restoreFeature: function(cancel) { │ │ │ │ + this.control.layer.events.unregister( │ │ │ │ + "sketchcomplete", this, this.finalizeInteriorRing │ │ │ │ + ); │ │ │ │ + this.control.layer.events.unregister( │ │ │ │ + "sketchmodified", this, this.enforceTopology │ │ │ │ + ); │ │ │ │ + this.layer.removeFeatures([this.polygon], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.control.layer.addFeatures([this.polygon], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.drawingHole = false; │ │ │ │ + if (!cancel) { │ │ │ │ + // Re-trigger "sketchcomplete" so other listeners can do their │ │ │ │ + // business. While this is somewhat sloppy (if a listener is │ │ │ │ + // registered with registerPriority - not common - between the start │ │ │ │ + // and end of a single ring drawing - very uncommon - it will be │ │ │ │ + // called twice). │ │ │ │ + // TODO: In 3.0, collapse sketch handlers into geometry specific │ │ │ │ + // drawing controls. │ │ │ │ + this.control.layer.events.triggerEvent( │ │ │ │ + "sketchcomplete", { │ │ │ │ + feature: this.polygon │ │ │ │ + } │ │ │ │ + ); │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.CacheRead" │ │ │ │ + /** │ │ │ │ + * Method: destroyFeature │ │ │ │ + * Destroy temporary geometries │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * force - {Boolean} Destroy even if persist is true. │ │ │ │ + */ │ │ │ │ + destroyFeature: function(force) { │ │ │ │ + OpenLayers.Handler.Path.prototype.destroyFeature.call( │ │ │ │ + this, force); │ │ │ │ + this.polygon = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: drawFeature │ │ │ │ + * Render geometries on the temporary layer. │ │ │ │ + */ │ │ │ │ + drawFeature: function() { │ │ │ │ + this.layer.drawFeature(this.polygon, this.style); │ │ │ │ + this.layer.drawFeature(this.point, this.style); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getSketch │ │ │ │ + * Return the sketch feature. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + getSketch: function() { │ │ │ │ + return this.polygon; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getGeometry │ │ │ │ + * Return the sketch geometry. If <multi> is true, this will return │ │ │ │ + * a multi-part geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Polygon>} │ │ │ │ + */ │ │ │ │ + getGeometry: function() { │ │ │ │ + var geometry = this.polygon && this.polygon.geometry; │ │ │ │ + if (geometry && this.multi) { │ │ │ │ + geometry = new OpenLayers.Geometry.MultiPolygon([geometry]); │ │ │ │ + } │ │ │ │ + return geometry; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Polygon" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/LayerSwitcher.js │ │ │ │ + OpenLayers/Handler/Click.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Lang.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.LayerSwitcher │ │ │ │ - * The LayerSwitcher control displays a table of contents for the map. This │ │ │ │ - * allows the user interface to switch between BaseLasyers and to show or hide │ │ │ │ - * Overlays. By default the switcher is shown minimized on the right edge of │ │ │ │ - * the map, the user may expand it by clicking on the handle. │ │ │ │ - * │ │ │ │ - * To create the LayerSwitcher outside of the map, pass the Id of a html div │ │ │ │ - * as the first argument to the constructor. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Handler.Click │ │ │ │ + * A handler for mouse clicks. The intention of this handler is to give │ │ │ │ + * controls more flexibility with handling clicks. Browsers trigger │ │ │ │ + * click events twice for a double-click. In addition, the mousedown, │ │ │ │ + * mousemove, mouseup sequence fires a click event. With this handler, │ │ │ │ + * controls can decide whether to ignore clicks associated with a double │ │ │ │ + * click. By setting a <pixelTolerance>, controls can also ignore clicks │ │ │ │ + * that include a drag. Create a new instance with the │ │ │ │ + * <OpenLayers.Handler.Click> constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ +OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + /** │ │ │ │ + * APIProperty: delay │ │ │ │ + * {Number} Number of milliseconds between clicks before the event is │ │ │ │ + * considered a double-click. │ │ │ │ */ │ │ │ │ - layerStates: null, │ │ │ │ - │ │ │ │ - // DOM Elements │ │ │ │ + delay: 300, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layersDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * APIProperty: single │ │ │ │ + * {Boolean} Handle single clicks. Default is true. If false, clicks │ │ │ │ + * will not be reported. If true, single-clicks will be reported. │ │ │ │ */ │ │ │ │ - layersDiv: null, │ │ │ │ + single: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: baseLayersDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * APIProperty: double │ │ │ │ + * {Boolean} Handle double-clicks. Default is false. │ │ │ │ */ │ │ │ │ - baseLayersDiv: null, │ │ │ │ + 'double': false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: baseLayers │ │ │ │ - * {Array(Object)} │ │ │ │ + * APIProperty: pixelTolerance │ │ │ │ + * {Number} Maximum number of pixels between mouseup and mousedown for an │ │ │ │ + * event to be considered a click. Default is 0. If set to an │ │ │ │ + * integer value, clicks with a drag greater than the value will be │ │ │ │ + * ignored. This property can only be set when the handler is │ │ │ │ + * constructed. │ │ │ │ */ │ │ │ │ - baseLayers: null, │ │ │ │ + pixelTolerance: 0, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * APIProperty: dblclickTolerance │ │ │ │ + * {Number} Maximum distance in pixels between clicks for a sequence of │ │ │ │ + * events to be considered a double click. Default is 13. If the │ │ │ │ + * distance between two clicks is greater than this value, a double- │ │ │ │ + * click will not be fired. │ │ │ │ + */ │ │ │ │ + dblclickTolerance: 13, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dataLbl │ │ │ │ - * {DOMElement} │ │ │ │ + * APIProperty: stopSingle │ │ │ │ + * {Boolean} Stop other listeners from being notified of clicks. Default │ │ │ │ + * is false. If true, any listeners registered before this one for │ │ │ │ + * click or rightclick events will not be notified. │ │ │ │ */ │ │ │ │ - dataLbl: null, │ │ │ │ + stopSingle: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dataLayersDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * APIProperty: stopDouble │ │ │ │ + * {Boolean} Stop other listeners from being notified of double-clicks. │ │ │ │ + * Default is false. If true, any click listeners registered before │ │ │ │ + * this one will not be notified of *any* double-click events. │ │ │ │ + * │ │ │ │ + * The one caveat with stopDouble is that given a map with two click │ │ │ │ + * handlers, one with stopDouble true and the other with stopSingle │ │ │ │ + * true, the stopSingle handler should be activated last to get │ │ │ │ + * uniform cross-browser performance. Since IE triggers one click │ │ │ │ + * with a dblclick and FF triggers two, if a stopSingle handler is │ │ │ │ + * activated first, all it gets in IE is a single click when the │ │ │ │ + * second handler stops propagation on the dblclick. │ │ │ │ */ │ │ │ │ - dataLayersDiv: null, │ │ │ │ + stopDouble: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dataLayers │ │ │ │ - * {Array(Object)} │ │ │ │ + * Property: timerId │ │ │ │ + * {Number} The id of the timeout waiting to clear the <delayedCall>. │ │ │ │ */ │ │ │ │ - dataLayers: null, │ │ │ │ + timerId: null, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Property: down │ │ │ │ + * {Object} Object that store relevant information about the last │ │ │ │ + * mousedown or touchstart. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ + * the average location of the mouse/touch event. Its 'touches' │ │ │ │ + * property records clientX/clientY of each touches. │ │ │ │ + */ │ │ │ │ + down: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: minimizeDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * Property: last │ │ │ │ + * {Object} Object that store relevant information about the last │ │ │ │ + * mousemove or touchmove. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ + * the average location of the mouse/touch event. Its 'touches' │ │ │ │ + * property records clientX/clientY of each touches. │ │ │ │ */ │ │ │ │ - minimizeDiv: null, │ │ │ │ + last: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: first │ │ │ │ + * {Object} When waiting for double clicks, this object will store │ │ │ │ + * information about the first click in a two click sequence. │ │ │ │ + */ │ │ │ │ + first: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: maximizeDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * Property: rightclickTimerId │ │ │ │ + * {Number} The id of the right mouse timeout waiting to clear the │ │ │ │ + * <delayedEvent>. │ │ │ │ */ │ │ │ │ - maximizeDiv: null, │ │ │ │ + rightclickTimerId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ascending │ │ │ │ - * {Boolean} │ │ │ │ + * Constructor: OpenLayers.Handler.Click │ │ │ │ + * Create a new click handler. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ + * this handler. If a handler is being used without a control, the │ │ │ │ + * handler's setMap method must be overridden to deal properly with │ │ │ │ + * the map. │ │ │ │ + * callbacks - {Object} An object with keys corresponding to callbacks │ │ │ │ + * that will be called by the handler. The callbacks should │ │ │ │ + * expect to recieve a single argument, the click event. │ │ │ │ + * Callbacks for 'click' and 'dblclick' are supported. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * handler. │ │ │ │ */ │ │ │ │ - ascending: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.LayerSwitcher │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - this.layerStates = []; │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * Method: touchmove │ │ │ │ + * Store position of last move, because touchend event can have │ │ │ │ + * an empty "touches" property. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - │ │ │ │ - //clear out layers info and unregister their events │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ - │ │ │ │ - this.map.events.un({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - addlayer: this.redraw, │ │ │ │ - changelayer: this.redraw, │ │ │ │ - removelayer: this.redraw, │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + touchmove: function(evt) { │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * Method: touchend │ │ │ │ + * Correctly set event xy property, and add lastTouches to have │ │ │ │ + * touches property from last touchstart or touchmove │ │ │ │ * │ │ │ │ - * Properties: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - 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 │ │ │ │ - }); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + touchend: function(evt) { │ │ │ │ + // touchstart may not have been allowed to propagate │ │ │ │ + if (this.down) { │ │ │ │ + evt.xy = this.last.xy; │ │ │ │ + evt.lastTouches = this.last.touches; │ │ │ │ + this.handleSingle(evt); │ │ │ │ + this.down = null; │ │ │ │ } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mousedown. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the │ │ │ │ - * switcher tabs. │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ + mousedown: function(evt) { │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // create layout divs │ │ │ │ - this.loadContents(); │ │ │ │ + /** │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouseup. Installed to support collection of right mouse events. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ + */ │ │ │ │ + mouseup: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ │ │ │ │ - // set mode to minimize │ │ │ │ - if (!this.outsideViewport) { │ │ │ │ - this.minimizeControl(); │ │ │ │ + // Collect right mouse clicks from the mouseup │ │ │ │ + // IE - ignores the second right click in mousedown so using │ │ │ │ + // mouseup instead │ │ │ │ + if (this.checkModifiers(evt) && this.control.handleRightClicks && │ │ │ │ + OpenLayers.Event.isRightClick(evt)) { │ │ │ │ + propagate = this.rightclick(evt); │ │ │ │ } │ │ │ │ │ │ │ │ - // populate div with current info │ │ │ │ - this.redraw(); │ │ │ │ - │ │ │ │ - return this.div; │ │ │ │ + return propagate; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onButtonClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: rightclick │ │ │ │ + * Handle rightclick. For a dblrightclick, we get two clicks so we need │ │ │ │ + * to always register for dblrightclick to properly handle single │ │ │ │ + * clicks. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.minimizeDiv) { │ │ │ │ - this.minimizeControl(); │ │ │ │ - } else if (button === this.maximizeDiv) { │ │ │ │ - this.maximizeControl(); │ │ │ │ - } else if (button._layerSwitcher === this.id) { │ │ │ │ - if (button["for"]) { │ │ │ │ - button = document.getElementById(button["for"]); │ │ │ │ - } │ │ │ │ - if (!button.disabled) { │ │ │ │ - if (button.type == "radio") { │ │ │ │ - button.checked = true; │ │ │ │ - this.map.setBaseLayer(this.map.getLayer(button._layer)); │ │ │ │ - } else { │ │ │ │ - button.checked = !button.checked; │ │ │ │ - this.updateMap(); │ │ │ │ - } │ │ │ │ + rightclick: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + //Second click received before timeout this must be │ │ │ │ + // a double click │ │ │ │ + this.clearTimer(); │ │ │ │ + this.callback('dblrightclick', [evt]); │ │ │ │ + return !this.stopDouble; │ │ │ │ + } else { │ │ │ │ + //Set the rightclickTimerId, send evt only if double is │ │ │ │ + // true else trigger single │ │ │ │ + var clickEvent = this['double'] ? │ │ │ │ + OpenLayers.Util.extend({}, evt) : │ │ │ │ + this.callback('rightclick', [evt]); │ │ │ │ + │ │ │ │ + var delayedRightCall = OpenLayers.Function.bind( │ │ │ │ + this.delayedRightCall, │ │ │ │ + this, │ │ │ │ + clickEvent │ │ │ │ + ); │ │ │ │ + this.rightclickTimerId = window.setTimeout( │ │ │ │ + delayedRightCall, this.delay │ │ │ │ + ); │ │ │ │ } │ │ │ │ } │ │ │ │ + return !this.stopSingle; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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} │ │ │ │ + * Method: delayedRightCall │ │ │ │ + * Sets <rightclickTimerId> to null. And optionally triggers the │ │ │ │ + * rightclick callback if evt is set. │ │ │ │ */ │ │ │ │ - clearLayersArray: function(layersType) { │ │ │ │ - this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ - this[layersType + "Layers"] = []; │ │ │ │ + delayedRightCall: function(evt) { │ │ │ │ + this.rightclickTimerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback('rightclick', [evt]); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: checkRedraw │ │ │ │ - * Checks if the layer state has changed since the last redraw() call. │ │ │ │ + * Method: click │ │ │ │ + * Handle click events from the browser. This is registered as a listener │ │ │ │ + * for click events and should not be called from other events in this │ │ │ │ + * handler. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The layer state changed since the last redraw() call. │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - checkRedraw: function() { │ │ │ │ - if (!this.layerStates.length || │ │ │ │ - (this.map.layers.length != this.layerStates.length)) { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - │ │ │ │ - for (var i = 0, len = this.layerStates.length; i < len; 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)) { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ + click: function(evt) { │ │ │ │ + if (!this.last) { │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ } │ │ │ │ - │ │ │ │ - return false; │ │ │ │ + this.handleSingle(evt); │ │ │ │ + return !this.stopSingle; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ - * │ │ │ │ + * Method: dblclick │ │ │ │ + * Handle dblclick. For a dblclick, we get two clicks in some browsers │ │ │ │ + * (FF) and one in others (IE). So we need to always register for │ │ │ │ + * dblclick to properly handle single clicks. This method is registered │ │ │ │ + * as a listener for the dblclick browser event. It should *not* be │ │ │ │ + * called by other methods in this handler. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - 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. │ │ │ │ - var len = this.map.layers.length; │ │ │ │ - this.layerStates = new Array(len); │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - this.layerStates[i] = { │ │ │ │ - 'name': layer.name, │ │ │ │ - 'visibility': layer.visibility, │ │ │ │ - 'inRange': layer.inRange, │ │ │ │ - 'id': layer.id │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + dblclick: function(evt) { │ │ │ │ + this.handleDouble(evt); │ │ │ │ + return !this.stopDouble; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var layers = this.map.layers.slice(); │ │ │ │ - if (!this.ascending) { │ │ │ │ - layers.reverse(); │ │ │ │ + /** │ │ │ │ + * Method: handleDouble │ │ │ │ + * Handle double-click sequence. │ │ │ │ + */ │ │ │ │ + handleDouble: function(evt) { │ │ │ │ + if (this.passesDblclickTolerance(evt)) { │ │ │ │ + if (this["double"]) { │ │ │ │ + this.callback("dblclick", [evt]); │ │ │ │ + } │ │ │ │ + // to prevent a dblclick from firing the click callback in IE │ │ │ │ + this.clearTimer(); │ │ │ │ } │ │ │ │ - for (var i = 0, len = layers.length; i < len; 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"), │ │ │ │ - // The input shall have an id attribute so we can use │ │ │ │ - // labels to interact with them. │ │ │ │ - inputId = OpenLayers.Util.createUniqueID( │ │ │ │ - this.id + "_input_" │ │ │ │ - ); │ │ │ │ - │ │ │ │ - inputElem.id = inputId; │ │ │ │ - inputElem.name = (baseLayer) ? this.id + "_baseLayers" : layer.name; │ │ │ │ - inputElem.type = (baseLayer) ? "radio" : "checkbox"; │ │ │ │ - inputElem.value = layer.name; │ │ │ │ - inputElem.checked = checked; │ │ │ │ - inputElem.defaultChecked = checked; │ │ │ │ - inputElem.className = "olButton"; │ │ │ │ - inputElem._layer = layer.id; │ │ │ │ - inputElem._layerSwitcher = this.id; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - inputElem.disabled = true; │ │ │ │ + /** │ │ │ │ + * Method: handleSingle │ │ │ │ + * Handle single click sequence. │ │ │ │ + */ │ │ │ │ + handleSingle: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + // already received a click │ │ │ │ + if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ + // touch device, no dblclick event - this may be a double │ │ │ │ + if (this["double"]) { │ │ │ │ + // on Android don't let the browser zoom on the page │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + } │ │ │ │ + this.handleDouble(evt); │ │ │ │ } │ │ │ │ - │ │ │ │ - // create span │ │ │ │ - var labelSpan = document.createElement("label"); │ │ │ │ - // this isn't the DOM attribute 'for', but an arbitrary name we │ │ │ │ - // use to find the appropriate input element in <onButtonClick> │ │ │ │ - labelSpan["for"] = inputElem.id; │ │ │ │ - OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ - labelSpan._layer = layer.id; │ │ │ │ - labelSpan._layerSwitcher = this.id; │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - labelSpan.style.color = "gray"; │ │ │ │ + // if we're not in a touch environment we clear the click timer │ │ │ │ + // if we've got a second touch, we'll get two touchend events │ │ │ │ + if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ + this.clearTimer(); │ │ │ │ } │ │ │ │ - labelSpan.innerHTML = layer.name; │ │ │ │ - labelSpan.style.verticalAlign = (baseLayer) ? "bottom" : │ │ │ │ - "baseline"; │ │ │ │ - // 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); │ │ │ │ + } else { │ │ │ │ + // remember the first click info so we can compare to the second │ │ │ │ + this.first = this.getEventInfo(evt); │ │ │ │ + // set the timer, send evt only if single is true │ │ │ │ + //use a clone of the event object because it will no longer │ │ │ │ + //be a valid event object in IE in the timer callback │ │ │ │ + var clickEvent = this.single ? │ │ │ │ + OpenLayers.Util.extend({}, evt) : null; │ │ │ │ + this.queuePotentialClick(clickEvent); │ │ │ │ } │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - // 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: queuePotentialClick │ │ │ │ + * This method is separated out largely to make testing easier (so we │ │ │ │ + * don't have to override window.setTimeout) │ │ │ │ + */ │ │ │ │ + queuePotentialClick: function(evt) { │ │ │ │ + this.timerId = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(this.delayedCall, this, evt), │ │ │ │ + this.delay │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * Method: passesTolerance │ │ │ │ + * Determine whether the event is within the optional pixel tolerance. Note │ │ │ │ + * that the pixel tolerance check only works if mousedown events get to │ │ │ │ + * the listeners registered here. If they are stopped by other elements, │ │ │ │ + * the <pixelTolerance> will have no effect here (this method will always │ │ │ │ + * return true). │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The click is within the pixel tolerance (if specified). │ │ │ │ */ │ │ │ │ - updateMap: function() { │ │ │ │ - │ │ │ │ - // set the newly selected base layer │ │ │ │ - for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.baseLayers[i]; │ │ │ │ - if (layerEntry.inputElem.checked) { │ │ │ │ - this.map.setBaseLayer(layerEntry.layer, false); │ │ │ │ + passesTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ + passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ + // for touch environments, we also enforce that all touches │ │ │ │ + // start and end within the given tolerance to be considered a click │ │ │ │ + if (passes && this.touch && │ │ │ │ + this.down.touches.length === this.last.touches.length) { │ │ │ │ + // the touchend event doesn't come with touches, so we check │ │ │ │ + // down and last │ │ │ │ + for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ + if (this.getTouchDistance( │ │ │ │ + this.down.touches[i], │ │ │ │ + this.last.touches[i] │ │ │ │ + ) > this.pixelTolerance) { │ │ │ │ + passes = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + return passes; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // set the correct visibilities for the overlays │ │ │ │ - for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.dataLayers[i]; │ │ │ │ - layerEntry.layer.setVisibility(layerEntry.inputElem.checked); │ │ │ │ - } │ │ │ │ - │ │ │ │ + /** │ │ │ │ + * Method: getTouchDistance │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The pixel displacement between two touches. │ │ │ │ + */ │ │ │ │ + getTouchDistance: function(from, to) { │ │ │ │ + return Math.sqrt( │ │ │ │ + Math.pow(from.clientX - to.clientX, 2) + │ │ │ │ + Math.pow(from.clientY - to.clientY, 2) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: maximizeControl │ │ │ │ - * Set up the labels and divs for the control │ │ │ │ + * Method: passesDblclickTolerance │ │ │ │ + * Determine whether the event is within the optional double-cick pixel │ │ │ │ + * tolerance. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The click is within the double-click pixel tolerance. │ │ │ │ */ │ │ │ │ - maximizeControl: function(e) { │ │ │ │ - │ │ │ │ - // set the div's width and height to empty values, so │ │ │ │ - // the div dimensions can be controlled by CSS │ │ │ │ - this.div.style.width = ""; │ │ │ │ - this.div.style.height = ""; │ │ │ │ - │ │ │ │ - this.showControls(false); │ │ │ │ - │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ + passesDblclickTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.down && this.first) { │ │ │ │ + passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance; │ │ │ │ } │ │ │ │ + return passes; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: minimizeControl │ │ │ │ - * Hide all the contents of the control, shrink the size, │ │ │ │ - * add the maximize icon │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ + * Method: clearTimer │ │ │ │ + * Clear the timer and set <timerId> to null. │ │ │ │ */ │ │ │ │ - minimizeControl: function(e) { │ │ │ │ - │ │ │ │ - // to minimize the control we set its div's width │ │ │ │ - // and height to 0px, we cannot just set "display" │ │ │ │ - // to "none" because it would hide the maximize │ │ │ │ - // div │ │ │ │ - this.div.style.width = "0px"; │ │ │ │ - this.div.style.height = "0px"; │ │ │ │ - │ │ │ │ - this.showControls(true); │ │ │ │ + clearTimer: function() { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + } │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + window.clearTimeout(this.rightclickTimerId); │ │ │ │ + this.rightclickTimerId = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ + /** │ │ │ │ + * Method: delayedCall │ │ │ │ + * Sets <timerId> to null. And optionally triggers the click callback if │ │ │ │ + * evt is set. │ │ │ │ + */ │ │ │ │ + delayedCall: function(evt) { │ │ │ │ + this.timerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback("click", [evt]); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: showControls │ │ │ │ - * Hide/Show all LayerSwitcher controls depending on whether we are │ │ │ │ - * minimized or not │ │ │ │ + * Method: getEventInfo │ │ │ │ + * This method allows us to store event information without storing the │ │ │ │ + * actual event. In touch devices (at least), the same event is │ │ │ │ + * modified between touchstart, touchmove, and touchend. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * minimize - {Boolean} │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with event related info. │ │ │ │ */ │ │ │ │ - showControls: function(minimize) { │ │ │ │ - │ │ │ │ - this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ - this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ - │ │ │ │ - this.layersDiv.style.display = minimize ? "none" : ""; │ │ │ │ + getEventInfo: function(evt) { │ │ │ │ + var touches; │ │ │ │ + if (evt.touches) { │ │ │ │ + var len = evt.touches.length; │ │ │ │ + touches = new Array(len); │ │ │ │ + var touch; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + touch = evt.touches[i]; │ │ │ │ + touches[i] = { │ │ │ │ + clientX: touch.olClientX, │ │ │ │ + clientY: touch.olClientY │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + xy: evt.xy, │ │ │ │ + touches: touches │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: loadContents │ │ │ │ - * Set up the labels and divs for the control │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully deactivated. │ │ │ │ */ │ │ │ │ - loadContents: function() { │ │ │ │ - │ │ │ │ - // layers list div │ │ │ │ - this.layersDiv = document.createElement("div"); │ │ │ │ - this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ - OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ - │ │ │ │ - this.baseLbl = document.createElement("div"); │ │ │ │ - this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ - │ │ │ │ - this.baseLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ - │ │ │ │ - this.dataLbl = document.createElement("div"); │ │ │ │ - this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ - │ │ │ │ - this.dataLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ - │ │ │ │ - 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); │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.down = null; │ │ │ │ + this.first = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ } │ │ │ │ - │ │ │ │ - this.div.appendChild(this.layersDiv); │ │ │ │ - │ │ │ │ - // maximize button div │ │ │ │ - var img = OpenLayers.Util.getImageLocation('layer-switcher-maximize.png'); │ │ │ │ - this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - "OpenLayers_Control_MaximizeDiv", │ │ │ │ - null, │ │ │ │ - null, │ │ │ │ - img, │ │ │ │ - "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ - this.maximizeDiv.style.display = "none"; │ │ │ │ - │ │ │ │ - this.div.appendChild(this.maximizeDiv); │ │ │ │ - │ │ │ │ - // minimize button div │ │ │ │ - var img = OpenLayers.Util.getImageLocation('layer-switcher-minimize.png'); │ │ │ │ - this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - "OpenLayers_Control_MinimizeDiv", │ │ │ │ - null, │ │ │ │ - null, │ │ │ │ - img, │ │ │ │ - "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ - this.minimizeDiv.style.display = "none"; │ │ │ │ - │ │ │ │ - this.div.appendChild(this.minimizeDiv); │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/ZoomPanel.js │ │ │ │ + OpenLayers/Handler/Keyboard.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/Panel.js │ │ │ │ - * @requires OpenLayers/Control/ZoomIn.js │ │ │ │ - * @requires OpenLayers/Control/ZoomOut.js │ │ │ │ - * @requires OpenLayers/Control/ZoomToMaxExtent.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.ZoomPanel │ │ │ │ - * The ZoomPanel control is a compact collecton of 3 zoom controls: a │ │ │ │ - * <OpenLayers.Control.ZoomIn>, a <OpenLayers.Control.ZoomToMaxExtent>, and a │ │ │ │ - * <OpenLayers.Control.ZoomOut>. By default it is drawn in the upper left │ │ │ │ - * corner of the map. │ │ │ │ - * │ │ │ │ - * Note: │ │ │ │ - * If you wish to use this class with the default images and you want │ │ │ │ - * it to look nice in ie6, you should add the following, conditionally │ │ │ │ - * added css stylesheet to your HTML file: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * <!--[if lte IE 6]> │ │ │ │ - * <link rel="stylesheet" href="../theme/default/ie6-style.css" type="text/css" /> │ │ │ │ - * <![endif]--> │ │ │ │ - * (end) │ │ │ │ + * Class: OpenLayers.handler.Keyboard │ │ │ │ + * A handler for keyboard events. Create a new instance with the │ │ │ │ + * <OpenLayers.Handler.Keyboard> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control.Panel> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.ZoomPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ +OpenLayers.Handler.Keyboard = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + │ │ │ │ + /* http://www.quirksmode.org/js/keys.html explains key x-browser │ │ │ │ + key handling quirks in pretty nice detail */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constant: KEY_EVENTS │ │ │ │ + * keydown, keypress, keyup │ │ │ │ + */ │ │ │ │ + KEY_EVENTS: ["keydown", "keyup"], │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: eventListener │ │ │ │ + * {Function} │ │ │ │ + */ │ │ │ │ + eventListener: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: observeElement │ │ │ │ + * {DOMElement|String} The DOM element on which we listen for │ │ │ │ + * key events. Default to the document. │ │ │ │ + */ │ │ │ │ + observeElement: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler.Keyboard │ │ │ │ + * Returns a new keyboard handler. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ + * this handler. If a handler is being used without a control, the │ │ │ │ + * handlers setMap method must be overridden to deal properly with │ │ │ │ + * the map. │ │ │ │ + * callbacks - {Object} An object containing a single function to be │ │ │ │ + * called when the drag operation is finished. The callback should │ │ │ │ + * expect to recieve a single argument, the pixel location of the event. │ │ │ │ + * Callbacks for 'keydown', 'keypress', and 'keyup' are supported. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * handler. │ │ │ │ + */ │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + // cache the bound event listener method so it can be unobserved later │ │ │ │ + this.eventListener = OpenLayers.Function.bindAsEventListener( │ │ │ │ + this.handleKeyEvent, this │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.eventListener = null; │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.observeElement = this.observeElement || document; │ │ │ │ + for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ + OpenLayers.Event.observe( │ │ │ │ + this.observeElement, this.KEY_EVENTS[i], this.eventListener); │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.ZoomPanel │ │ │ │ - * Add the three zooming controls. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + * Method: deactivate │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - this.addControls([ │ │ │ │ - new OpenLayers.Control.ZoomIn(), │ │ │ │ - new OpenLayers.Control.ZoomToMaxExtent(), │ │ │ │ - new OpenLayers.Control.ZoomOut() │ │ │ │ - ]); │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ + OpenLayers.Event.stopObserving( │ │ │ │ + this.observeElement, this.KEY_EVENTS[i], this.eventListener); │ │ │ │ + } │ │ │ │ + deactivated = true; │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomPanel" │ │ │ │ + /** │ │ │ │ + * Method: handleKeyEvent │ │ │ │ + */ │ │ │ │ + handleKeyEvent: function(evt) { │ │ │ │ + if (this.checkModifiers(evt)) { │ │ │ │ + this.callback(evt.type, [evt]); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Keyboard" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/WMTSGetFeatureInfo.js │ │ │ │ + OpenLayers/Handler/Drag.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ - * @requires OpenLayers/Handler/Hover.js │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ - * @requires OpenLayers/Format/WMSGetFeatureInfo.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.WMTSGetFeatureInfo │ │ │ │ - * The WMTSGetFeatureInfo control uses a WMTS query to get information about a │ │ │ │ - * point on the map. The information may be in a display-friendly format │ │ │ │ - * such as HTML, or a machine-friendly format such as GML, depending on the │ │ │ │ - * server's capabilities and the client's configuration. This control │ │ │ │ - * handles click or hover events, attempts to parse the results using an │ │ │ │ - * OpenLayers.Format, and fires a 'getfeatureinfo' event for each layer │ │ │ │ - * queried. │ │ │ │ + * Class: OpenLayers.Handler.Drag │ │ │ │ + * The drag handler is used to deal with sequences of browser events related │ │ │ │ + * to dragging. The handler is used by controls that want to know when │ │ │ │ + * a drag sequence begins, when a drag is happening, and when it has │ │ │ │ + * finished. │ │ │ │ + * │ │ │ │ + * Controls that use the drag handler typically construct it with callbacks │ │ │ │ + * for 'down', 'move', and 'done'. Callbacks for these keys are called │ │ │ │ + * when the drag begins, with each move, and when the drag is done. In │ │ │ │ + * addition, controls can have callbacks keyed to 'up' and 'out' if they │ │ │ │ + * care to differentiate between the types of events that correspond with │ │ │ │ + * the end of a drag sequence. If no drag actually occurs (no mouse move) │ │ │ │ + * the 'down' and 'up' callbacks will be called, but not the 'done' │ │ │ │ + * callback. │ │ │ │ + * │ │ │ │ + * Create a new drag handler with the <OpenLayers.Handler.Drag> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.WMTSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: hover │ │ │ │ - * {Boolean} Send GetFeatureInfo requests when mouse stops moving. │ │ │ │ - * Default is false. │ │ │ │ + /** │ │ │ │ + * Property: started │ │ │ │ + * {Boolean} When a mousedown or touchstart event is received, we want to │ │ │ │ + * record it, but not set 'dragging' until the mouse moves after starting. │ │ │ │ */ │ │ │ │ - hover: false, │ │ │ │ + started: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: requestEncoding │ │ │ │ - * {String} One of "KVP" or "REST". Only KVP encoding is supported at this │ │ │ │ - * time. │ │ │ │ + * Property: stopDown │ │ │ │ + * {Boolean} Stop propagation of mousedown events from getting to listeners │ │ │ │ + * on the same element. Default is true. │ │ │ │ */ │ │ │ │ - requestEncoding: "KVP", │ │ │ │ + stopDown: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: dragging │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + dragging: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: last │ │ │ │ + * {<OpenLayers.Pixel>} The last pixel location of the drag. │ │ │ │ + */ │ │ │ │ + last: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: start │ │ │ │ + * {<OpenLayers.Pixel>} The first pixel location of the drag. │ │ │ │ + */ │ │ │ │ + start: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: drillDown │ │ │ │ - * {Boolean} Drill down over all WMTS layers in the map. When │ │ │ │ - * using drillDown mode, hover is not possible. A getfeatureinfo event │ │ │ │ - * will be fired for each layer queried. │ │ │ │ + * Property: lastMoveEvt │ │ │ │ + * {Object} The last mousemove event that occurred. Used to │ │ │ │ + * position the map correctly when our "delay drag" │ │ │ │ + * timeout expired. │ │ │ │ */ │ │ │ │ - drillDown: false, │ │ │ │ + lastMoveEvt: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxFeatures │ │ │ │ - * {Integer} Maximum number of features to return from a WMTS query. This │ │ │ │ - * sets the feature_count parameter on WMTS GetFeatureInfo │ │ │ │ - * requests. │ │ │ │ + * Property: oldOnselectstart │ │ │ │ + * {Function} │ │ │ │ */ │ │ │ │ - maxFeatures: 10, │ │ │ │ + oldOnselectstart: null, │ │ │ │ │ │ │ │ - /** APIProperty: clickCallback │ │ │ │ - * {String} The click callback to register in the │ │ │ │ - * {<OpenLayers.Handler.Click>} object created when the hover │ │ │ │ - * option is set to false. Default is "click". │ │ │ │ + /** │ │ │ │ + * Property: interval │ │ │ │ + * {Integer} In order to increase performance, an interval (in │ │ │ │ + * milliseconds) can be set to reduce the number of drag events │ │ │ │ + * called. If set, a new drag event will not be set until the │ │ │ │ + * interval has passed. │ │ │ │ + * Defaults to 0, meaning no interval. │ │ │ │ */ │ │ │ │ - clickCallback: "click", │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layers │ │ │ │ - * {Array(<OpenLayers.Layer.WMTS>)} The layers to query for feature info. │ │ │ │ - * If omitted, all map WMTS layers will be considered. │ │ │ │ + * Property: timeoutId │ │ │ │ + * {String} The id of the timeout used for the mousedown interval. │ │ │ │ + * This is "private", and should be left alone. │ │ │ │ */ │ │ │ │ - layers: null, │ │ │ │ + timeoutId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: queryVisible │ │ │ │ - * {Boolean} Filter out hidden layers when searching the map for layers to │ │ │ │ - * query. Default is true. │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} If set to true, the handler will also handle mouse moves when │ │ │ │ + * the cursor has moved out of the map viewport. Default is false. │ │ │ │ */ │ │ │ │ - queryVisible: true, │ │ │ │ + documentDrag: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: infoFormat │ │ │ │ - * {String} The mimetype to request from the server │ │ │ │ + * Property: documentEvents │ │ │ │ + * {Boolean} Are we currently observing document events? │ │ │ │ */ │ │ │ │ - infoFormat: 'text/html', │ │ │ │ + documentEvents: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: vendorParams │ │ │ │ - * {Object} Additional parameters that will be added to the request, for │ │ │ │ - * WMTS implementations that support them. This could e.g. look like │ │ │ │ - * (start code) │ │ │ │ - * { │ │ │ │ - * radius: 5 │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ + * Constructor: OpenLayers.Handler.Drag │ │ │ │ + * Returns OpenLayers.Handler.Drag │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ + * this handler. If a handler is being used without a control, the │ │ │ │ + * handlers setMap method must be overridden to deal properly with │ │ │ │ + * the map. │ │ │ │ + * callbacks - {Object} An object containing a single function to be │ │ │ │ + * called when the drag operation is finished. The callback should │ │ │ │ + * expect to recieve a single argument, the pixel location of the event. │ │ │ │ + * Callbacks for 'move' and 'done' are supported. You can also speficy │ │ │ │ + * callbacks for 'down', 'up', and 'out' to respond to those events. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - vendorParams: {}, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + var me = this; │ │ │ │ + this._docMove = function(evt) { │ │ │ │ + me.mousemove({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + }, │ │ │ │ + element: document │ │ │ │ + }); │ │ │ │ + }; │ │ │ │ + this._docUp = function(evt) { │ │ │ │ + me.mouseup({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: format │ │ │ │ - * {<OpenLayers.Format>} A format for parsing GetFeatureInfo responses. │ │ │ │ - * Default is <OpenLayers.Format.WMSGetFeatureInfo>. │ │ │ │ + * Method: dragstart │ │ │ │ + * This private method is factorized from mousedown and touchstart methods │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - format: null, │ │ │ │ + dragstart: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + this.dragging = false; │ │ │ │ + if (this.checkModifiers(evt) && │ │ │ │ + (OpenLayers.Event.isLeftClick(evt) || │ │ │ │ + OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ + this.started = true; │ │ │ │ + this.start = evt.xy; │ │ │ │ + this.last = evt.xy; │ │ │ │ + OpenLayers.Element.addClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + this.down(evt); │ │ │ │ + this.callback("down", [evt.xy]); │ │ │ │ + │ │ │ │ + // prevent document dragging │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart ? │ │ │ │ + document.onselectstart : OpenLayers.Function.True; │ │ │ │ + } │ │ │ │ + document.onselectstart = OpenLayers.Function.False; │ │ │ │ + │ │ │ │ + propagate = !this.stopDown; │ │ │ │ + } else { │ │ │ │ + this.started = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + } │ │ │ │ + return propagate; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: formatOptions │ │ │ │ - * {Object} Optional properties to set on the format (if one is not provided │ │ │ │ - * in the <format> property. │ │ │ │ + * Method: dragmove │ │ │ │ + * This private method is factorized from mousemove and touchmove methods │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - formatOptions: null, │ │ │ │ + dragmove: function(evt) { │ │ │ │ + this.lastMoveEvt = evt; │ │ │ │ + if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || │ │ │ │ + evt.xy.y != this.last.y)) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + if (evt.element === document) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + // do setEvent manually because the documentEvents are not │ │ │ │ + // registered with the map │ │ │ │ + this.setEvent(evt); │ │ │ │ + } else { │ │ │ │ + this.removeDocumentEvents(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.interval > 0) { │ │ │ │ + this.timeoutId = setTimeout( │ │ │ │ + OpenLayers.Function.bind(this.removeTimeout, this), │ │ │ │ + this.interval); │ │ │ │ + } │ │ │ │ + this.dragging = true; │ │ │ │ + │ │ │ │ + this.move(evt); │ │ │ │ + this.callback("move", [evt.xy]); │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart; │ │ │ │ + document.onselectstart = OpenLayers.Function.False; │ │ │ │ + } │ │ │ │ + this.last = evt.xy; │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: handlerOptions │ │ │ │ - * {Object} Additional options for the handlers used by this control, e.g. │ │ │ │ - * (start code) │ │ │ │ - * { │ │ │ │ - * "click": {delay: 100}, │ │ │ │ - * "hover": {delay: 300} │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ + * Method: dragend │ │ │ │ + * This private method is factorized from mouseup and touchend methods │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ + dragend: function(evt) { │ │ │ │ + if (this.started) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + this.removeDocumentEvents(); │ │ │ │ + } │ │ │ │ + var dragged = (this.start != this.last); │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + this.up(evt); │ │ │ │ + this.callback("up", [evt.xy]); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]); │ │ │ │ + } │ │ │ │ + document.onselectstart = this.oldOnselectstart; │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: handler │ │ │ │ - * {Object} Reference to the <OpenLayers.Handler> for this control │ │ │ │ + * The four methods below (down, move, up, and out) are used by subclasses │ │ │ │ + * to do their own processing related to these mouse events. │ │ │ │ */ │ │ │ │ - handler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: hoverRequest │ │ │ │ - * {<OpenLayers.Request>} contains the currently running hover request │ │ │ │ - * (if any). │ │ │ │ + * Method: down │ │ │ │ + * This method is called during the handling of the mouse down event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The mouse down event │ │ │ │ */ │ │ │ │ - hoverRequest: null, │ │ │ │ + down: function(evt) {}, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * This method is called during the handling of the mouse move event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The mouse move event │ │ │ │ * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforegetfeatureinfo - Triggered before each request is sent. │ │ │ │ - * The event object has an *xy* property with the position of the │ │ │ │ - * mouse click or hover event that triggers the request and a *layer* │ │ │ │ - * property referencing the layer about to be queried. If a listener │ │ │ │ - * returns false, the request will not be issued. │ │ │ │ - * getfeatureinfo - Triggered when a GetFeatureInfo response is received. │ │ │ │ - * The event object has a *text* property with the body of the │ │ │ │ - * response (String), a *features* property with an array of the │ │ │ │ - * parsed features, an *xy* property with the position of the mouse │ │ │ │ - * click or hover event that triggered the request, a *layer* property │ │ │ │ - * referencing the layer queried and a *request* property with the │ │ │ │ - * request itself. If drillDown is set to true, one event will be fired │ │ │ │ - * for each layer queried. │ │ │ │ - * exception - Triggered when a GetFeatureInfo request fails (with a │ │ │ │ - * status other than 200) or whenparsing fails. Listeners will receive │ │ │ │ - * an event with *request*, *xy*, and *layer* properties. In the case │ │ │ │ - * of a parsing error, the event will also contain an *error* property. │ │ │ │ */ │ │ │ │ + move: function(evt) {}, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: pending │ │ │ │ - * {Number} The number of pending requests. │ │ │ │ + /** │ │ │ │ + * Method: up │ │ │ │ + * This method is called during the handling of the mouse up event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The mouse up event │ │ │ │ */ │ │ │ │ - pending: 0, │ │ │ │ + up: function(evt) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: <OpenLayers.Control.WMTSGetFeatureInfo> │ │ │ │ + * Method: out │ │ │ │ + * This method is called during the handling of the mouse out event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * evt - {Event} The mouse out event │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.handlerOptions = options.handlerOptions || {}; │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + out: function(evt) {}, │ │ │ │ │ │ │ │ - if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.WMSGetFeatureInfo( │ │ │ │ - options.formatOptions │ │ │ │ - ); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * The methods below are part of the magic of event handling. Because │ │ │ │ + * they are named like browser events, they are registered as listeners │ │ │ │ + * for the events they represent. │ │ │ │ + */ │ │ │ │ │ │ │ │ - if (this.drillDown === true) { │ │ │ │ - this.hover = false; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mousedown events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ + */ │ │ │ │ + mousedown: function(evt) { │ │ │ │ + return this.dragstart(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.hover) { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover( │ │ │ │ - this, { │ │ │ │ - move: this.cancelHover, │ │ │ │ - pause: this.getInfoForHover │ │ │ │ - }, │ │ │ │ - OpenLayers.Util.extend( │ │ │ │ - this.handlerOptions.hover || {}, { │ │ │ │ - delay: 250 │ │ │ │ - } │ │ │ │ - ) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - var callbacks = {}; │ │ │ │ - callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ - this.handler = new OpenLayers.Handler.Click( │ │ │ │ - this, callbacks, this.handlerOptions.click || {} │ │ │ │ - ); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ + */ │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return this.dragstart(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getInfoForClick │ │ │ │ - * Called on click │ │ │ │ + * Method: mousemove │ │ │ │ + * Handle mousemove events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - getInfoForClick: function(evt) { │ │ │ │ - this.request(evt.xy, {}); │ │ │ │ + mousemove: function(evt) { │ │ │ │ + return this.dragmove(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getInfoForHover │ │ │ │ - * Pause callback for the hover handler │ │ │ │ + * Method: touchmove │ │ │ │ + * Handle touchmove events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - getInfoForHover: function(evt) { │ │ │ │ - this.request(evt.xy, { │ │ │ │ - hover: true │ │ │ │ - }); │ │ │ │ + touchmove: function(evt) { │ │ │ │ + return this.dragmove(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cancelHover │ │ │ │ - * Cancel callback for the hover handler │ │ │ │ + * Method: removeTimeout │ │ │ │ + * Private. Called by mousemove() to remove the drag timeout. │ │ │ │ */ │ │ │ │ - cancelHover: function() { │ │ │ │ - if (this.hoverRequest) { │ │ │ │ - --this.pending; │ │ │ │ - if (this.pending <= 0) { │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - this.pending = 0; │ │ │ │ - } │ │ │ │ - this.hoverRequest.abort(); │ │ │ │ - this.hoverRequest = null; │ │ │ │ + removeTimeout: function() { │ │ │ │ + this.timeoutId = null; │ │ │ │ + // if timeout expires while we're still dragging (mouseup │ │ │ │ + // hasn't occurred) then call mousemove to move to the │ │ │ │ + // correct position │ │ │ │ + if (this.dragging) { │ │ │ │ + this.mousemove(this.lastMoveEvt); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: findLayers │ │ │ │ - * Internal method to get the layers, independent of whether we are │ │ │ │ - * inspecting the map or using a client-provided array │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouseup events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - findLayers: function() { │ │ │ │ - var candidates = this.layers || this.map.layers; │ │ │ │ - var layers = []; │ │ │ │ - var layer; │ │ │ │ - for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ - layer = candidates[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMTS && │ │ │ │ - layer.requestEncoding === this.requestEncoding && │ │ │ │ - (!this.queryVisible || layer.getVisibility())) { │ │ │ │ - layers.push(layer); │ │ │ │ - if (!this.drillDown || this.hover) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return layers; │ │ │ │ + mouseup: function(evt) { │ │ │ │ + return this.dragend(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildRequestOptions │ │ │ │ - * Build an object with the relevant options for the GetFeatureInfo request. │ │ │ │ + * Method: touchend │ │ │ │ + * Handle touchend events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.WMTS>} A WMTS layer. │ │ │ │ - * xy - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ - * mouse event occurred. │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - buildRequestOptions: function(layer, xy) { │ │ │ │ - var loc = this.map.getLonLatFromPixel(xy); │ │ │ │ - var getTileUrl = layer.getURL( │ │ │ │ - new OpenLayers.Bounds(loc.lon, loc.lat, loc.lon, loc.lat) │ │ │ │ - ); │ │ │ │ - var params = OpenLayers.Util.getParameters(getTileUrl); │ │ │ │ - var tileInfo = layer.getTileInfo(loc); │ │ │ │ - OpenLayers.Util.extend(params, { │ │ │ │ - service: "WMTS", │ │ │ │ - version: layer.version, │ │ │ │ - request: "GetFeatureInfo", │ │ │ │ - infoFormat: this.infoFormat, │ │ │ │ - i: tileInfo.i, │ │ │ │ - j: tileInfo.j │ │ │ │ - }); │ │ │ │ - OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ - return { │ │ │ │ - url: OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url, │ │ │ │ - params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ - callback: function(request) { │ │ │ │ - this.handleResponse(xy, request, layer); │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }; │ │ │ │ + touchend: function(evt) { │ │ │ │ + // override evt.xy with last position since touchend does not have │ │ │ │ + // any touch position │ │ │ │ + evt.xy = this.last; │ │ │ │ + return this.dragend(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: request │ │ │ │ - * Sends a GetFeatureInfo request to the WMTS │ │ │ │ - * │ │ │ │ + * Method: mouseout │ │ │ │ + * Handle mouseout events │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The position on the map where the mouse event │ │ │ │ - * occurred. │ │ │ │ - * options - {Object} additional options for this method. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * - *hover* {Boolean} true if we do the request for the hover handler │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - request: function(xy, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var layers = this.findLayers(); │ │ │ │ - if (layers.length > 0) { │ │ │ │ - var issue, layer; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - layer = layers[i]; │ │ │ │ - issue = this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ - xy: xy, │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ - if (issue !== false) { │ │ │ │ - ++this.pending; │ │ │ │ - var requestOptions = this.buildRequestOptions(layer, xy); │ │ │ │ - var request = OpenLayers.Request.GET(requestOptions); │ │ │ │ - if (options.hover === true) { │ │ │ │ - this.hoverRequest = request; │ │ │ │ - } │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + this.addDocumentEvents(); │ │ │ │ + } else { │ │ │ │ + var dragged = (this.start != this.last); │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + this.out(evt); │ │ │ │ + this.callback("out", []); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]); │ │ │ │ + } │ │ │ │ + if (document.onselectstart) { │ │ │ │ + document.onselectstart = this.oldOnselectstart; │ │ │ │ } │ │ │ │ - } │ │ │ │ - if (this.pending > 0) { │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ } │ │ │ │ } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleResponse │ │ │ │ - * Handler for the GetFeatureInfo response. │ │ │ │ + * Method: click │ │ │ │ + * The drag handler captures the click event. If something else registers │ │ │ │ + * for clicks on the same element, its listener will not be called │ │ │ │ + * after a drag. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The position on the map where the mouse event │ │ │ │ - * occurred. │ │ │ │ - * request - {XMLHttpRequest} The request object. │ │ │ │ - * layer - {<OpenLayers.Layer.WMTS>} The queried layer. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - handleResponse: function(xy, request, layer) { │ │ │ │ - --this.pending; │ │ │ │ - if (this.pending <= 0) { │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - this.pending = 0; │ │ │ │ - } │ │ │ │ - if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ - this.events.triggerEvent("exception", { │ │ │ │ - xy: xy, │ │ │ │ - request: request, │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - var features, except; │ │ │ │ - try { │ │ │ │ - features = this.format.read(doc); │ │ │ │ - } catch (error) { │ │ │ │ - except = true; │ │ │ │ - this.events.triggerEvent("exception", { │ │ │ │ - xy: xy, │ │ │ │ - request: request, │ │ │ │ - error: error, │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (!except) { │ │ │ │ - this.events.triggerEvent("getfeatureinfo", { │ │ │ │ - text: request.responseText, │ │ │ │ - features: features, │ │ │ │ - request: request, │ │ │ │ - xy: xy, │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + click: function(evt) { │ │ │ │ + // let the click event propagate only if the mouse moved │ │ │ │ + return (this.start == this.last); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.WMTSGetFeatureInfo" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Attribution.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Attribution │ │ │ │ - * The attribution control adds attribution from layers to the map display. │ │ │ │ - * It uses 'attribution' property of each layer. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Attribution = │ │ │ │ - OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: separator │ │ │ │ - * {String} String used to separate layers. │ │ │ │ - */ │ │ │ │ - separator: ", ", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: template │ │ │ │ - * {String} Template for the attribution. This has to include the substring │ │ │ │ - * "${layers}", which will be replaced by the layer specific │ │ │ │ - * attributions, separated by <separator>. The default is "${layers}". │ │ │ │ - */ │ │ │ │ - template: "${layers}", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Control.Attribution │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Options for control. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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: activate │ │ │ │ + * Activate the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully activated. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragging = false; │ │ │ │ + activated = true; │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * Initialize control. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.map.events.on({ │ │ │ │ - 'changebaselayer': this.updateAttribution, │ │ │ │ - 'changelayer': this.updateAttribution, │ │ │ │ - 'addlayer': this.updateAttribution, │ │ │ │ - 'removelayer': this.updateAttribution, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.updateAttribution(); │ │ │ │ + /** │ │ │ │ + * Method: adjustXY │ │ │ │ + * Converts event coordinates that are relative to the document body to │ │ │ │ + * ones that are relative to the map viewport. The latter is the default in │ │ │ │ + * OpenLayers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} │ │ │ │ + */ │ │ │ │ + adjustXY: function(evt) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ + evt.xy.x -= pos[0]; │ │ │ │ + evt.xy.y -= pos[1]; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return this.div; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: addDocumentEvents │ │ │ │ + * Start observing document events when documentDrag is true and the mouse │ │ │ │ + * cursor leaves the map viewport while dragging. │ │ │ │ + */ │ │ │ │ + addDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = true; │ │ │ │ + OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.observe(document, "mouseup", this._docUp); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: updateAttribution │ │ │ │ - * Update attribution string. │ │ │ │ - */ │ │ │ │ - updateAttribution: function() { │ │ │ │ - var attributions = []; │ │ │ │ - if (this.map && this.map.layers) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (layer.attribution && layer.getVisibility()) { │ │ │ │ - // add attribution only if attribution text is unique │ │ │ │ - if (OpenLayers.Util.indexOf( │ │ │ │ - attributions, layer.attribution) === -1) { │ │ │ │ - attributions.push(layer.attribution); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ - layers: attributions.join(this.separator) │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: removeDocumentEvents │ │ │ │ + * Stops observing document events when documentDrag is true and the mouse │ │ │ │ + * cursor re-enters the map viewport while dragging. │ │ │ │ + */ │ │ │ │ + removeDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = false; │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mouseup", this._docUp); │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Split.js │ │ │ │ + OpenLayers/Handler/RegularPolygon.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Path.js │ │ │ │ - * @requires OpenLayers/Layer/Vector.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Split │ │ │ │ - * Acts as a split feature agent while editing vector features. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Handler.RegularPolygon │ │ │ │ + * Handler to draw a regular polygon on the map. Polygon is displayed on mouse │ │ │ │ + * down, moves or is modified on mouse move, and is finished on mouse up. │ │ │ │ + * The handler triggers callbacks for 'done' and 'cancel'. Create a new │ │ │ │ + * instance with the <OpenLayers.Handler.RegularPolygon> constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler.Drag> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Split = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Handler.RegularPolygon = OpenLayers.Class(OpenLayers.Handler.Drag, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforesplit - Triggered before a split occurs. Listeners receive an │ │ │ │ - * event object with *source* and *target* properties. │ │ │ │ - * split - Triggered when a split occurs. Listeners receive an event with │ │ │ │ - * an *original* property and a *features* property. The original │ │ │ │ - * is a reference to the target feature that the sketch or modified │ │ │ │ - * feature intersects. The features property is a list of all features │ │ │ │ - * that result from this single split. This event is triggered before │ │ │ │ - * the resulting features are added to the layer (while the layer still │ │ │ │ - * has a reference to the original). │ │ │ │ - * aftersplit - Triggered after all splits resulting from a single sketch │ │ │ │ - * or feature modification have occurred. The original features │ │ │ │ - * have been destroyed and features that result from the split │ │ │ │ - * have already been added to the layer. Listeners receive an event │ │ │ │ - * with a *source* and *features* property. The source references the │ │ │ │ - * sketch or modified feature used as a splitter. The features │ │ │ │ - * property is a list of all resulting features. │ │ │ │ + /** │ │ │ │ + * APIProperty: sides │ │ │ │ + * {Integer} Number of sides for the regular polygon. Needs to be greater │ │ │ │ + * than 2. Defaults to 4. │ │ │ │ */ │ │ │ │ + sides: 4, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The target layer with features to be split. │ │ │ │ - * Set at construction or after construction with <setLayer>. │ │ │ │ + * APIProperty: radius │ │ │ │ + * {Float} Optional radius in map units of the regular polygon. If this is │ │ │ │ + * set to some non-zero value, a polygon with a fixed radius will be │ │ │ │ + * drawn and dragged with mose movements. If this property is not │ │ │ │ + * set, dragging changes the radius of the polygon. Set to null by │ │ │ │ + * default. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + radius: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: source │ │ │ │ - * {<OpenLayers.Layer.Vector>} Optional source layer. Any newly created │ │ │ │ - * or modified features from this layer will be used to split features │ │ │ │ - * on the target layer. If not provided, a temporary sketch layer will │ │ │ │ - * be created. │ │ │ │ + * APIProperty: snapAngle │ │ │ │ + * {Float} If set to a non-zero value, the handler will snap the polygon │ │ │ │ + * rotation to multiples of the snapAngle. Value is an angle measured │ │ │ │ + * in degrees counterclockwise from the positive x-axis. │ │ │ │ */ │ │ │ │ - source: null, │ │ │ │ + snapAngle: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: sourceOptions │ │ │ │ - * {Options} If a temporary sketch layer is created, these layer options │ │ │ │ - * will be applied. │ │ │ │ + * APIProperty: snapToggle │ │ │ │ + * {String} If set, snapToggle is checked on mouse events and will set │ │ │ │ + * the snap mode to the opposite of what it currently is. To disallow │ │ │ │ + * toggling between snap and non-snap mode, set freehandToggle to │ │ │ │ + * null. Acceptable toggle values are 'shiftKey', 'ctrlKey', and │ │ │ │ + * 'altKey'. Snap mode is only possible if this.snapAngle is set to a │ │ │ │ + * non-zero value. │ │ │ │ */ │ │ │ │ - sourceOptions: null, │ │ │ │ + snapToggle: 'shiftKey', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: tolerance │ │ │ │ - * {Number} Distance between the calculated intersection and a vertex on │ │ │ │ - * the source geometry below which the existing vertex will be used │ │ │ │ - * for the split. Default is null. │ │ │ │ + * Property: layerOptions │ │ │ │ + * {Object} Any optional properties to be set on the sketch layer. │ │ │ │ */ │ │ │ │ - tolerance: null, │ │ │ │ + layerOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: edge │ │ │ │ - * {Boolean} Allow splits given intersection of edges only. Default is │ │ │ │ - * true. If false, a vertex on the source must be within the │ │ │ │ - * <tolerance> distance of the calculated intersection for a split │ │ │ │ - * to occur. │ │ │ │ + * APIProperty: persist │ │ │ │ + * {Boolean} Leave the feature rendered until clear is called. Default │ │ │ │ + * is false. If set to true, the feature remains rendered until │ │ │ │ + * clear is called, typically by deactivating the handler or starting │ │ │ │ + * another drawing. │ │ │ │ */ │ │ │ │ - edge: true, │ │ │ │ + persist: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: deferDelete │ │ │ │ - * {Boolean} Instead of removing features from the layer, set feature │ │ │ │ - * states of split features to DELETE. This assumes a save strategy │ │ │ │ - * or other component is in charge of removing features from the │ │ │ │ - * layer. Default is false. If false, split features will be │ │ │ │ - * immediately deleted from the layer. │ │ │ │ + * APIProperty: irregular │ │ │ │ + * {Boolean} Draw an irregular polygon instead of a regular polygon. │ │ │ │ + * Default is false. If true, the initial mouse down will represent │ │ │ │ + * one corner of the polygon bounds and with each mouse movement, the │ │ │ │ + * polygon will be stretched so the opposite corner of its bounds │ │ │ │ + * follows the mouse position. This property takes precedence over │ │ │ │ + * the radius property. If set to true, the radius property will │ │ │ │ + * be ignored. │ │ │ │ */ │ │ │ │ - deferDelete: false, │ │ │ │ + irregular: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: mutual │ │ │ │ - * {Boolean} If source and target layers are the same, split source │ │ │ │ - * features and target features where they intersect. Default is │ │ │ │ - * true. If false, only target features will be split. │ │ │ │ + * APIProperty: citeCompliant │ │ │ │ + * {Boolean} If set to true, coordinates of features drawn in a map extent │ │ │ │ + * crossing the date line won't exceed the world bounds. Default is false. │ │ │ │ */ │ │ │ │ - mutual: true, │ │ │ │ + citeCompliant: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: targetFilter │ │ │ │ - * {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ - * to determine if a feature from the target layer is eligible for │ │ │ │ - * splitting. │ │ │ │ + * Property: angle │ │ │ │ + * {Float} The angle from the origin (mouse down) to the current mouse │ │ │ │ + * position, in radians. This is measured counterclockwise from the │ │ │ │ + * positive x-axis. │ │ │ │ */ │ │ │ │ - targetFilter: null, │ │ │ │ + angle: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: sourceFilter │ │ │ │ - * {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ - * to determine if a feature from the source layer is eligible for │ │ │ │ - * splitting. │ │ │ │ + * Property: fixedRadius │ │ │ │ + * {Boolean} The polygon has a fixed radius. True if a radius is set before │ │ │ │ + * drawing begins. False otherwise. │ │ │ │ */ │ │ │ │ - sourceFilter: null, │ │ │ │ + fixedRadius: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: handler │ │ │ │ - * {<OpenLayers.Handler.Path>} The temporary sketch handler created if │ │ │ │ - * no source layer is provided. │ │ │ │ + * Property: feature │ │ │ │ + * {<OpenLayers.Feature.Vector>} The currently drawn polygon feature │ │ │ │ */ │ │ │ │ - handler: null, │ │ │ │ + feature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Split │ │ │ │ - * Creates a new split control. A control is constructed with a target │ │ │ │ - * layer and an optional source layer. While the control is active, │ │ │ │ - * creating new features or modifying existing features on the source │ │ │ │ - * layer will result in splitting any eligible features on the target │ │ │ │ - * layer. If no source layer is provided, a temporary sketch layer will │ │ │ │ - * be created to create lines for splitting features on the target. │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The temporary drawing layer │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: origin │ │ │ │ + * {<OpenLayers.Geometry.Point>} Location of the first mouse down │ │ │ │ + */ │ │ │ │ + origin: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler.RegularPolygon │ │ │ │ + * Create a new regular polygon handler. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An object containing all configuration properties for │ │ │ │ - * the control. │ │ │ │ + * control - {<OpenLayers.Control>} The control that owns this handler │ │ │ │ + * callbacks - {Object} An object with a properties whose values are │ │ │ │ + * functions. Various callbacks described below. │ │ │ │ + * options - {Object} An object with properties to be set on the handler. │ │ │ │ + * If the options.sides property is not specified, the number of sides │ │ │ │ + * will default to 4. │ │ │ │ * │ │ │ │ - * Valid options: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} The target layer. Features from this │ │ │ │ - * layer will be split by new or modified features on the source layer │ │ │ │ - * or temporary sketch layer. │ │ │ │ - * source - {<OpenLayers.Layer.Vector>} Optional source layer. If provided │ │ │ │ - * newly created features or modified features will be used to split │ │ │ │ - * features on the target layer. If not provided, a temporary sketch │ │ │ │ - * layer will be created for drawing lines. │ │ │ │ - * tolerance - {Number} Optional value for the distance between a source │ │ │ │ - * vertex and the calculated intersection below which the split will │ │ │ │ - * occur at the vertex. │ │ │ │ - * edge - {Boolean} Allow splits given intersection of edges only. Default │ │ │ │ - * is true. If false, a vertex on the source must be within the │ │ │ │ - * <tolerance> distance of the calculated intersection for a split │ │ │ │ - * to occur. │ │ │ │ - * mutual - {Boolean} If source and target are the same, split source │ │ │ │ - * features and target features where they intersect. Default is │ │ │ │ - * true. If false, only target features will be split. │ │ │ │ - * targetFilter - {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ - * to determine if a feature from the target layer is eligible for │ │ │ │ - * splitting. │ │ │ │ - * sourceFilter - {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ - * to determine if a feature from the target layer is eligible for │ │ │ │ - * splitting. │ │ │ │ + * Named callbacks: │ │ │ │ + * create - Called when a sketch is first created. Callback called with │ │ │ │ + * the creation point geometry and sketch feature. │ │ │ │ + * done - Called when the sketch drawing is finished. The callback will │ │ │ │ + * recieve a single argument, the sketch geometry. │ │ │ │ + * cancel - Called when the handler is deactivated while drawing. The │ │ │ │ + * cancel callback will receive a geometry. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options || {}; // TODO: this could be done by the super │ │ │ │ - │ │ │ │ - // set the source layer if provided │ │ │ │ - if (this.options.source) { │ │ │ │ - this.setSource(this.options.source); │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ + this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {}); │ │ │ │ } │ │ │ │ + │ │ │ │ + OpenLayers.Handler.Drag.prototype.initialize.apply(this, │ │ │ │ + [control, callbacks, options]); │ │ │ │ + this.options = (options) ? options : {}; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setSource │ │ │ │ - * Set the source layer for edits layer. │ │ │ │ - * │ │ │ │ + * APIMethod: setOptions │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} The new source layer layer. If │ │ │ │ - * null, a temporary sketch layer will be created. │ │ │ │ + * newOptions - {Object} │ │ │ │ */ │ │ │ │ - setSource: function(layer) { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.destroy(); │ │ │ │ - delete this.handler; │ │ │ │ - } │ │ │ │ - this.source = layer; │ │ │ │ - this.activate(); │ │ │ │ - } else { │ │ │ │ - this.source = layer; │ │ │ │ - } │ │ │ │ + setOptions: function(newOptions) { │ │ │ │ + OpenLayers.Util.extend(this.options, newOptions); │ │ │ │ + OpenLayers.Util.extend(this, newOptions); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: activate │ │ │ │ - * Activate the control. Activating the control registers listeners for │ │ │ │ - * editing related events so that during feature creation and │ │ │ │ - * modification, features in the target will be considered for │ │ │ │ - * splitting. │ │ │ │ + * Turn on the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully activated │ │ │ │ */ │ │ │ │ activate: function() { │ │ │ │ - var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (!this.source) { │ │ │ │ - if (!this.handler) { │ │ │ │ - this.handler = new OpenLayers.Handler.Path(this, { │ │ │ │ - done: function(geometry) { │ │ │ │ - this.onSketchComplete({ │ │ │ │ - feature: new OpenLayers.Feature.Vector(geometry) │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, { │ │ │ │ - layerOptions: this.sourceOptions │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - this.handler.activate(); │ │ │ │ - } else if (this.source.events) { │ │ │ │ - this.source.events.on({ │ │ │ │ - sketchcomplete: this.onSketchComplete, │ │ │ │ - afterfeaturemodified: this.afterFeatureModified, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.Drag.prototype.activate.apply(this, arguments)) { │ │ │ │ + // create temporary vector layer for rendering geometry sketch │ │ │ │ + var options = OpenLayers.Util.extend({ │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + // indicate that the temp vector layer will never be out of range │ │ │ │ + // without this, resolution properties must be specified at the │ │ │ │ + // map-level for this temporary layer to init its resolutions │ │ │ │ + // correctly │ │ │ │ + calculateInRange: OpenLayers.Function.True, │ │ │ │ + wrapDateLine: this.citeCompliant │ │ │ │ + }, this.layerOptions); │ │ │ │ + this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ + this.map.addLayer(this.layer); │ │ │ │ + activated = true; │ │ │ │ } │ │ │ │ return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: deactivate │ │ │ │ - * Deactivate the control. Deactivating the control unregisters listeners │ │ │ │ - * so feature editing may proceed without engaging the split agent. │ │ │ │ + * Turn off the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully deactivated │ │ │ │ */ │ │ │ │ deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - if (this.source && this.source.events) { │ │ │ │ - this.source.events.un({ │ │ │ │ - sketchcomplete: this.onSketchComplete, │ │ │ │ - afterfeaturemodified: this.afterFeatureModified, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.Drag.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + // call the cancel callback if mid-drawing │ │ │ │ + if (this.dragging) { │ │ │ │ + this.cancel(); │ │ │ │ } │ │ │ │ + // If a layer's map property is set to null, it means that that │ │ │ │ + // layer isn't added to the map. Since we ourself added the layer │ │ │ │ + // to the map in activate(), we can assume that if this.layer.map │ │ │ │ + // is null it means that the layer has been destroyed (as a result │ │ │ │ + // of map.destroy() for example. │ │ │ │ + if (this.layer.map != null) { │ │ │ │ + this.layer.destroy(false); │ │ │ │ + if (this.feature) { │ │ │ │ + this.feature.destroy(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer = null; │ │ │ │ + this.feature = null; │ │ │ │ + deactivated = true; │ │ │ │ } │ │ │ │ return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onSketchComplete │ │ │ │ - * Registered as a listener for the sketchcomplete event on the editable │ │ │ │ - * layer. │ │ │ │ + * Method: down │ │ │ │ + * Start drawing a new feature │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The sketch complete event. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Stop the sketch from being added to the layer (it has been │ │ │ │ - * split). │ │ │ │ + * evt - {Event} The drag start event │ │ │ │ */ │ │ │ │ - onSketchComplete: function(event) { │ │ │ │ - this.feature = null; │ │ │ │ - return !this.considerSplit(event.feature); │ │ │ │ + down: function(evt) { │ │ │ │ + this.fixedRadius = !!(this.radius); │ │ │ │ + var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ + this.origin = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ + // create the new polygon │ │ │ │ + if (!this.fixedRadius || this.irregular) { │ │ │ │ + // smallest radius should not be less one pixel in map units │ │ │ │ + // VML doesn't behave well with smaller │ │ │ │ + this.radius = this.map.getResolution(); │ │ │ │ + } │ │ │ │ + if (this.persist) { │ │ │ │ + this.clear(); │ │ │ │ + } │ │ │ │ + this.feature = new OpenLayers.Feature.Vector(); │ │ │ │ + this.createGeometry(); │ │ │ │ + this.callback("create", [this.origin, this.feature]); │ │ │ │ + this.layer.addFeatures([this.feature], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.layer.drawFeature(this.feature, this.style); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: afterFeatureModified │ │ │ │ - * Registered as a listener for the afterfeaturemodified event on the │ │ │ │ - * editable layer. │ │ │ │ + * Method: move │ │ │ │ + * Respond to drag move events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The after feature modified event. │ │ │ │ + * evt - {Evt} The move event │ │ │ │ */ │ │ │ │ - afterFeatureModified: function(event) { │ │ │ │ - if (event.modified) { │ │ │ │ - var feature = event.feature; │ │ │ │ - if (typeof feature.geometry.split === "function") { │ │ │ │ - this.feature = event.feature; │ │ │ │ - this.considerSplit(event.feature); │ │ │ │ + move: function(evt) { │ │ │ │ + var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ + var point = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ + if (this.irregular) { │ │ │ │ + var ry = Math.sqrt(2) * Math.abs(point.y - this.origin.y) / 2; │ │ │ │ + this.radius = Math.max(this.map.getResolution() / 2, ry); │ │ │ │ + } else if (this.fixedRadius) { │ │ │ │ + this.origin = point; │ │ │ │ + } else { │ │ │ │ + this.calculateAngle(point, evt); │ │ │ │ + this.radius = Math.max(this.map.getResolution() / 2, │ │ │ │ + point.distanceTo(this.origin)); │ │ │ │ + } │ │ │ │ + this.modifyGeometry(); │ │ │ │ + if (this.irregular) { │ │ │ │ + var dx = point.x - this.origin.x; │ │ │ │ + var dy = point.y - this.origin.y; │ │ │ │ + var ratio; │ │ │ │ + if (dy == 0) { │ │ │ │ + ratio = dx / (this.radius * Math.sqrt(2)); │ │ │ │ + } else { │ │ │ │ + ratio = dx / dy; │ │ │ │ } │ │ │ │ + this.feature.geometry.resize(1, this.origin, ratio); │ │ │ │ + this.feature.geometry.move(dx / 2, dy / 2); │ │ │ │ } │ │ │ │ + this.layer.drawFeature(this.feature, this.style); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: removeByGeometry │ │ │ │ - * Remove a feature from a list based on the given geometry. │ │ │ │ + * Method: up │ │ │ │ + * Finish drawing the feature │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} A list of features. │ │ │ │ - * geometry - {<OpenLayers.Geometry>} A geometry. │ │ │ │ + * evt - {Event} The mouse up event │ │ │ │ */ │ │ │ │ - removeByGeometry: function(features, geometry) { │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - if (features[i].geometry === geometry) { │ │ │ │ - features.splice(i, 1); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + up: function(evt) { │ │ │ │ + this.finalize(); │ │ │ │ + // the mouseup method of superclass doesn't call the │ │ │ │ + // "done" callback if there's been no move between │ │ │ │ + // down and up │ │ │ │ + if (this.start == this.last) { │ │ │ │ + this.callback("done", [evt.xy]); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: isEligible │ │ │ │ - * Test if a target feature is eligible for splitting. │ │ │ │ + * Method: out │ │ │ │ + * Finish drawing the feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * target - {<OpenLayers.Feature.Vector>} The target feature. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The target is eligible for splitting. │ │ │ │ + * evt - {Event} The mouse out event │ │ │ │ */ │ │ │ │ - isEligible: function(target) { │ │ │ │ - if (!target.geometry) { │ │ │ │ - return false; │ │ │ │ - } else { │ │ │ │ - return ( │ │ │ │ - target.state !== OpenLayers.State.DELETE │ │ │ │ - ) && ( │ │ │ │ - typeof target.geometry.split === "function" │ │ │ │ - ) && ( │ │ │ │ - this.feature !== target │ │ │ │ - ) && ( │ │ │ │ - !this.targetFilter || │ │ │ │ - this.targetFilter.evaluate(target.attributes) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ + out: function(evt) { │ │ │ │ + this.finalize(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: considerSplit │ │ │ │ - * Decide whether or not to split target features with the supplied │ │ │ │ - * feature. If <mutual> is true, both the source and target features │ │ │ │ - * will be split if eligible. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The newly created or modified │ │ │ │ - * feature. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The supplied feature was split (and destroyed). │ │ │ │ + * Method: createGeometry │ │ │ │ + * Create the new polygon geometry. This is called at the start of the │ │ │ │ + * drag and at any point during the drag if the number of sides │ │ │ │ + * changes. │ │ │ │ */ │ │ │ │ - considerSplit: function(feature) { │ │ │ │ - var sourceSplit = false; │ │ │ │ - var targetSplit = false; │ │ │ │ - if (!this.sourceFilter || │ │ │ │ - this.sourceFilter.evaluate(feature.attributes)) { │ │ │ │ - var features = this.layer && this.layer.features || []; │ │ │ │ - var target, results, proceed; │ │ │ │ - var additions = [], │ │ │ │ - removals = []; │ │ │ │ - var mutual = (this.layer === this.source) && this.mutual; │ │ │ │ - var options = { │ │ │ │ - edge: this.edge, │ │ │ │ - tolerance: this.tolerance, │ │ │ │ - mutual: mutual │ │ │ │ - }; │ │ │ │ - var sourceParts = [feature.geometry]; │ │ │ │ - var targetFeature, targetParts; │ │ │ │ - var source, parts; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - targetFeature = features[i]; │ │ │ │ - if (this.isEligible(targetFeature)) { │ │ │ │ - targetParts = [targetFeature.geometry]; │ │ │ │ - // work through source geoms - this array may change │ │ │ │ - for (var j = 0; j < sourceParts.length; ++j) { │ │ │ │ - source = sourceParts[j]; │ │ │ │ - // work through target parts - this array may change │ │ │ │ - for (var k = 0; k < targetParts.length; ++k) { │ │ │ │ - target = targetParts[k]; │ │ │ │ - if (source.getBounds().intersectsBounds(target.getBounds())) { │ │ │ │ - results = source.split(target, options); │ │ │ │ - if (results) { │ │ │ │ - proceed = this.events.triggerEvent( │ │ │ │ - "beforesplit", { │ │ │ │ - source: feature, │ │ │ │ - target: targetFeature │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - if (proceed !== false) { │ │ │ │ - if (mutual) { │ │ │ │ - parts = results[0]; │ │ │ │ - // handle parts that result from source splitting │ │ │ │ - if (parts.length > 1) { │ │ │ │ - // splice in new source parts │ │ │ │ - parts.unshift(j, 1); // add args for splice below │ │ │ │ - Array.prototype.splice.apply(sourceParts, parts); │ │ │ │ - j += parts.length - 3; │ │ │ │ - } │ │ │ │ - results = results[1]; │ │ │ │ - } │ │ │ │ - // handle parts that result from target splitting │ │ │ │ - if (results.length > 1) { │ │ │ │ - // splice in new target parts │ │ │ │ - results.unshift(k, 1); // add args for splice below │ │ │ │ - Array.prototype.splice.apply(targetParts, results); │ │ │ │ - k += results.length - 3; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (targetParts && targetParts.length > 1) { │ │ │ │ - this.geomsToFeatures(targetFeature, targetParts); │ │ │ │ - this.events.triggerEvent("split", { │ │ │ │ - original: targetFeature, │ │ │ │ - features: targetParts │ │ │ │ - }); │ │ │ │ - Array.prototype.push.apply(additions, targetParts); │ │ │ │ - removals.push(targetFeature); │ │ │ │ - targetSplit = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (sourceParts && sourceParts.length > 1) { │ │ │ │ - this.geomsToFeatures(feature, sourceParts); │ │ │ │ - this.events.triggerEvent("split", { │ │ │ │ - original: feature, │ │ │ │ - features: sourceParts │ │ │ │ - }); │ │ │ │ - Array.prototype.push.apply(additions, sourceParts); │ │ │ │ - removals.push(feature); │ │ │ │ - sourceSplit = true; │ │ │ │ - } │ │ │ │ - if (sourceSplit || targetSplit) { │ │ │ │ - // remove and add feature events are suppressed │ │ │ │ - // listen for split event on this control instead │ │ │ │ - if (this.deferDelete) { │ │ │ │ - // Set state instead of removing. Take care to avoid │ │ │ │ - // setting delete for features that have not yet been │ │ │ │ - // inserted - those should be destroyed immediately. │ │ │ │ - var feat, destroys = []; │ │ │ │ - for (var i = 0, len = removals.length; i < len; ++i) { │ │ │ │ - feat = removals[i]; │ │ │ │ - if (feat.state === OpenLayers.State.INSERT) { │ │ │ │ - destroys.push(feat); │ │ │ │ - } else { │ │ │ │ - feat.state = OpenLayers.State.DELETE; │ │ │ │ - this.layer.drawFeature(feat); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.layer.destroyFeatures(destroys, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - for (var i = 0, len = additions.length; i < len; ++i) { │ │ │ │ - additions[i].state = OpenLayers.State.INSERT; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.layer.destroyFeatures(removals, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - this.layer.addFeatures(additions, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.events.triggerEvent("aftersplit", { │ │ │ │ - source: feature, │ │ │ │ - features: additions │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + createGeometry: function() { │ │ │ │ + this.angle = Math.PI * ((1 / this.sides) - (1 / 2)); │ │ │ │ + if (this.snapAngle) { │ │ │ │ + this.angle += this.snapAngle * (Math.PI / 180); │ │ │ │ } │ │ │ │ - return sourceSplit; │ │ │ │ + this.feature.geometry = OpenLayers.Geometry.Polygon.createRegularPolygon( │ │ │ │ + this.origin, this.radius, this.sides, this.snapAngle │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: geomsToFeatures │ │ │ │ - * Create new features given a template feature and a list of geometries. │ │ │ │ - * The list of geometries is modified in place. The result will be │ │ │ │ - * a list of new features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} The feature to be cloned. │ │ │ │ - * geoms - {Array(<OpenLayers.Geometry>)} List of goemetries. This will │ │ │ │ - * become a list of new features. │ │ │ │ + * Method: modifyGeometry │ │ │ │ + * Modify the polygon geometry in place. │ │ │ │ */ │ │ │ │ - geomsToFeatures: function(feature, geoms) { │ │ │ │ - var clone = feature.clone(); │ │ │ │ - delete clone.geometry; │ │ │ │ - var newFeature; │ │ │ │ - for (var i = 0, len = geoms.length; i < len; ++i) { │ │ │ │ - // turn results list from geoms to features │ │ │ │ - newFeature = clone.clone(); │ │ │ │ - newFeature.geometry = geoms[i]; │ │ │ │ - newFeature.state = OpenLayers.State.INSERT; │ │ │ │ - geoms[i] = newFeature; │ │ │ │ + modifyGeometry: function() { │ │ │ │ + var angle, point; │ │ │ │ + var ring = this.feature.geometry.components[0]; │ │ │ │ + // if the number of sides ever changes, create a new geometry │ │ │ │ + if (ring.components.length != (this.sides + 1)) { │ │ │ │ + this.createGeometry(); │ │ │ │ + ring = this.feature.geometry.components[0]; │ │ │ │ + } │ │ │ │ + for (var i = 0; i < this.sides; ++i) { │ │ │ │ + point = ring.components[i]; │ │ │ │ + angle = this.angle + (i * 2 * Math.PI / this.sides); │ │ │ │ + point.x = this.origin.x + (this.radius * Math.cos(angle)); │ │ │ │ + point.y = this.origin.y + (this.radius * Math.sin(angle)); │ │ │ │ + point.clearBounds(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - * Clean up the control. │ │ │ │ + * Method: calculateAngle │ │ │ │ + * Calculate the angle based on settings. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); // TODO: this should be handled by the super │ │ │ │ + calculateAngle: function(point, evt) { │ │ │ │ + var alpha = Math.atan2(point.y - this.origin.y, │ │ │ │ + point.x - this.origin.x); │ │ │ │ + if (this.snapAngle && (this.snapToggle && !evt[this.snapToggle])) { │ │ │ │ + var snapAngleRad = (Math.PI / 180) * this.snapAngle; │ │ │ │ + this.angle = Math.round(alpha / snapAngleRad) * snapAngleRad; │ │ │ │ + } else { │ │ │ │ + this.angle = alpha; │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.call(this); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Split" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/KeyboardDefaults.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Keyboard.js │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.KeyboardDefaults │ │ │ │ - * The KeyboardDefaults control adds panning and zooming functions, controlled │ │ │ │ - * with the keyboard. By default arrow keys pan, +/- keys zoom & Page Up/Page │ │ │ │ - * Down/Home/End scroll by three quarters of a page. │ │ │ │ - * │ │ │ │ - * This control has no visible appearance. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.KeyboardDefaults = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ - */ │ │ │ │ - autoActivate: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: slideFactor │ │ │ │ - * Pixels to slide by. │ │ │ │ - */ │ │ │ │ - slideFactor: 75, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: observeElement │ │ │ │ - * {DOMelement|String} The DOM element to handle keys for. You │ │ │ │ - * can use the map div here, to have the navigation keys │ │ │ │ - * work when the map div has the focus. If undefined the │ │ │ │ - * document is used. │ │ │ │ + * APIMethod: cancel │ │ │ │ + * Finish the geometry and call the "cancel" callback. │ │ │ │ */ │ │ │ │ - observeElement: null, │ │ │ │ + cancel: function() { │ │ │ │ + // the polygon geometry gets cloned in the callback method │ │ │ │ + this.callback("cancel", null); │ │ │ │ + this.finalize(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.KeyboardDefaults │ │ │ │ + * Method: finalize │ │ │ │ + * Finish the geometry and call the "done" callback. │ │ │ │ */ │ │ │ │ + finalize: function() { │ │ │ │ + this.origin = null; │ │ │ │ + this.radius = this.options.radius; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * Create handler. │ │ │ │ + * APIMethod: clear │ │ │ │ + * Clear any rendered features on the temporary layer. This is called │ │ │ │ + * when the handler is deactivated, canceled, or done (unless persist │ │ │ │ + * is true). │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - var observeElement = this.observeElement || document; │ │ │ │ - this.handler = new OpenLayers.Handler.Keyboard(this, { │ │ │ │ - "keydown": this.defaultKeyPress │ │ │ │ - }, { │ │ │ │ - observeElement: observeElement │ │ │ │ - }); │ │ │ │ + clear: function() { │ │ │ │ + if (this.layer) { │ │ │ │ + this.layer.renderer.clear(); │ │ │ │ + this.layer.destroyFeatures(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: defaultKeyPress │ │ │ │ - * When handling the key event, we only use evt.keyCode. This holds │ │ │ │ - * some drawbacks, though we get around them below. When interpretting │ │ │ │ - * the keycodes below (including the comments associated with them), │ │ │ │ - * consult the URL below. For instance, the Safari browser returns │ │ │ │ - * "IE keycodes", and so is supported by any keycode labeled "IE". │ │ │ │ - * │ │ │ │ - * Very informative URL: │ │ │ │ - * http://unixpapa.com/js/key.html │ │ │ │ + * Method: callback │ │ │ │ + * Trigger the control's named callback with the given arguments │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * 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 with which to call the callback │ │ │ │ + * (defined by the control). │ │ │ │ */ │ │ │ │ - defaultKeyPress: function(evt) { │ │ │ │ - var size, handled = true; │ │ │ │ - │ │ │ │ - var target = OpenLayers.Event.element(evt); │ │ │ │ - if (target && │ │ │ │ - (target.tagName == 'INPUT' || │ │ │ │ - target.tagName == 'TEXTAREA' || │ │ │ │ - target.tagName == 'SELECT')) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_LEFT: │ │ │ │ - this.map.pan(-this.slideFactor, 0); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Event.KEY_RIGHT: │ │ │ │ - this.map.pan(this.slideFactor, 0); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Event.KEY_UP: │ │ │ │ - this.map.pan(0, -this.slideFactor); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Event.KEY_DOWN: │ │ │ │ - this.map.pan(0, this.slideFactor); │ │ │ │ - break; │ │ │ │ - │ │ │ │ - case 33: // Page Up. Same in all browsers. │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(0, -0.75 * size.h); │ │ │ │ - break; │ │ │ │ - case 34: // Page Down. Same in all browsers. │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(0, 0.75 * size.h); │ │ │ │ - break; │ │ │ │ - case 35: // End. Same in all browsers. │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(0.75 * size.w, 0); │ │ │ │ - break; │ │ │ │ - case 36: // Home. Same in all browsers. │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(-0.75 * size.w, 0); │ │ │ │ - break; │ │ │ │ - │ │ │ │ - case 43: // +/= (ASCII), keypad + (ASCII, Opera) │ │ │ │ - case 61: // +/= (Mozilla, Opera, some ASCII) │ │ │ │ - case 187: // +/= (IE) │ │ │ │ - case 107: // keypad + (IE, Mozilla) │ │ │ │ - this.map.zoomIn(); │ │ │ │ - break; │ │ │ │ - case 45: // -/_ (ASCII, Opera), keypad - (ASCII, Opera) │ │ │ │ - case 109: // -/_ (Mozilla), keypad - (Mozilla, IE) │ │ │ │ - case 189: // -/_ (IE) │ │ │ │ - case 95: // -/_ (some ASCII) │ │ │ │ - this.map.zoomOut(); │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - handled = false; │ │ │ │ + callback: function(name, args) { │ │ │ │ + // override the callback method to always send the polygon geometry │ │ │ │ + if (this.callbacks[name]) { │ │ │ │ + this.callbacks[name].apply(this.control, │ │ │ │ + [this.feature.geometry.clone()]); │ │ │ │ } │ │ │ │ - if (handled) { │ │ │ │ - // prevent browser default not to move the page │ │ │ │ - // when moving the page with the keyboard │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ + // since sketch features are added to the temporary layer │ │ │ │ + // they must be cleared here if done or cancel │ │ │ │ + if (!this.persist && (name == "done" || name == "cancel")) { │ │ │ │ + this.clear(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.KeyboardDefaults" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.RegularPolygon" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/SelectFeature.js │ │ │ │ + OpenLayers/Handler/Box.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Handler/Feature.js │ │ │ │ - * @requires OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.SelectFeature │ │ │ │ - * The SelectFeature control selects vector features from a given layer on │ │ │ │ - * click or hover. │ │ │ │ + * Class: OpenLayers.Handler.Box │ │ │ │ + * Handler for dragging a rectangle across the map. Box is displayed │ │ │ │ + * on mouse down, moves on mouse move, and is finished on mouse up. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforefeaturehighlighted - Triggered before a feature is highlighted │ │ │ │ - * featurehighlighted - Triggered when a feature is highlighted │ │ │ │ - * featureunhighlighted - Triggered when a feature is unhighlighted │ │ │ │ - * boxselectionstart - Triggered before box selection starts │ │ │ │ - * boxselectionend - Triggered after box selection ends │ │ │ │ + * Property: dragHandler │ │ │ │ + * {<OpenLayers.Handler.Drag>} │ │ │ │ */ │ │ │ │ + dragHandler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: multipleKey │ │ │ │ - * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ - * the <multiple> property to true. Default is null. │ │ │ │ + * APIProperty: boxDivClassName │ │ │ │ + * {String} The CSS class to use for drawing the box. Default is │ │ │ │ + * olHandlerBoxZoomBox │ │ │ │ */ │ │ │ │ - multipleKey: null, │ │ │ │ + boxDivClassName: 'olHandlerBoxZoomBox', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: toggleKey │ │ │ │ - * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ - * the <toggle> property to true. Default is null. │ │ │ │ + * Property: boxOffsets │ │ │ │ + * {Object} Caches box offsets from css. This is used by the getBoxOffsets │ │ │ │ + * method. │ │ │ │ */ │ │ │ │ - toggleKey: null, │ │ │ │ + boxOffsets: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: multiple │ │ │ │ - * {Boolean} Allow selection of multiple geometries. Default is false. │ │ │ │ + * Constructor: OpenLayers.Handler.Box │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ + * callbacks - {Object} An object with a properties whose values are │ │ │ │ + * functions. Various callbacks described below. │ │ │ │ + * options - {Object} │ │ │ │ + * │ │ │ │ + * Named callbacks: │ │ │ │ + * start - Called when the box drag operation starts. │ │ │ │ + * done - Called when the box drag operation is finished. │ │ │ │ + * The callback should expect to receive a single argument, the box │ │ │ │ + * bounds or a pixel. If the box dragging didn't span more than a 5 │ │ │ │ + * pixel distance, a pixel will be returned instead of a bounds object. │ │ │ │ */ │ │ │ │ - multiple: false, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.dragHandler = new OpenLayers.Handler.Drag( │ │ │ │ + this, { │ │ │ │ + down: this.startBox, │ │ │ │ + move: this.moveBox, │ │ │ │ + out: this.removeBox, │ │ │ │ + up: this.endBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: clickout │ │ │ │ - * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ - * Default is true. │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - clickout: true, │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.dragHandler) { │ │ │ │ + this.dragHandler.destroy(); │ │ │ │ + this.dragHandler = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: toggle │ │ │ │ - * {Boolean} Unselect a selected feature on click. Default is false. Only │ │ │ │ - * has meaning if hover is false. │ │ │ │ + * Method: setMap │ │ │ │ */ │ │ │ │ - toggle: false, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Handler.prototype.setMap.apply(this, arguments); │ │ │ │ + if (this.dragHandler) { │ │ │ │ + this.dragHandler.setMap(map); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: hover │ │ │ │ - * {Boolean} Select on mouse over and deselect on mouse out. If true, this │ │ │ │ - * ignores clicks and only listens to mouse moves. │ │ │ │ + * Method: startBox │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - hover: false, │ │ │ │ + startBox: function(xy) { │ │ │ │ + this.callback("start", []); │ │ │ │ + this.zoomBox = OpenLayers.Util.createDiv('zoomBox', { │ │ │ │ + x: -9999, │ │ │ │ + y: -9999 │ │ │ │ + }); │ │ │ │ + this.zoomBox.className = this.boxDivClassName; │ │ │ │ + this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: highlightOnly │ │ │ │ - * {Boolean} If true do not actually select features (that is place them in │ │ │ │ - * the layer's selected features array), just highlight them. This property │ │ │ │ - * has no effect if hover is false. Defaults to false. │ │ │ │ - */ │ │ │ │ - highlightOnly: false, │ │ │ │ + this.map.viewPortDiv.appendChild(this.zoomBox); │ │ │ │ + │ │ │ │ + OpenLayers.Element.addClass( │ │ │ │ + this.map.viewPortDiv, "olDrawBox" │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: box │ │ │ │ - * {Boolean} Allow feature selection by drawing a box. │ │ │ │ + * Method: moveBox │ │ │ │ */ │ │ │ │ - box: false, │ │ │ │ + moveBox: function(xy) { │ │ │ │ + var startX = this.dragHandler.start.x; │ │ │ │ + var startY = this.dragHandler.start.y; │ │ │ │ + var deltaX = Math.abs(startX - xy.x); │ │ │ │ + var deltaY = Math.abs(startY - xy.y); │ │ │ │ + │ │ │ │ + var offset = this.getBoxOffsets(); │ │ │ │ + this.zoomBox.style.width = (deltaX + offset.width + 1) + "px"; │ │ │ │ + this.zoomBox.style.height = (deltaY + offset.height + 1) + "px"; │ │ │ │ + this.zoomBox.style.left = (xy.x < startX ? │ │ │ │ + startX - deltaX - offset.left : startX - offset.left) + "px"; │ │ │ │ + this.zoomBox.style.top = (xy.y < startY ? │ │ │ │ + startY - deltaY - offset.top : startY - offset.top) + "px"; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: onBeforeSelect │ │ │ │ - * {Function} Optional function to be called before a feature is selected. │ │ │ │ - * The function should expect to be called with a feature. │ │ │ │ + * Method: endBox │ │ │ │ */ │ │ │ │ - onBeforeSelect: function() {}, │ │ │ │ + endBox: function(end) { │ │ │ │ + var result; │ │ │ │ + if (Math.abs(this.dragHandler.start.x - end.x) > 5 || │ │ │ │ + Math.abs(this.dragHandler.start.y - end.y) > 5) { │ │ │ │ + var start = this.dragHandler.start; │ │ │ │ + var top = Math.min(start.y, end.y); │ │ │ │ + var bottom = Math.max(start.y, end.y); │ │ │ │ + var left = Math.min(start.x, end.x); │ │ │ │ + var right = Math.max(start.x, end.x); │ │ │ │ + result = new OpenLayers.Bounds(left, bottom, right, top); │ │ │ │ + } else { │ │ │ │ + result = this.dragHandler.start.clone(); // i.e. OL.Pixel │ │ │ │ + } │ │ │ │ + this.removeBox(); │ │ │ │ + │ │ │ │ + this.callback("done", [result]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: onSelect │ │ │ │ - * {Function} Optional function to be called when a feature is selected. │ │ │ │ - * The function should expect to be called with a feature. │ │ │ │ + * Method: removeBox │ │ │ │ + * Remove the zoombox from the screen and nullify our reference to it. │ │ │ │ */ │ │ │ │ - onSelect: function() {}, │ │ │ │ + removeBox: function() { │ │ │ │ + this.map.viewPortDiv.removeChild(this.zoomBox); │ │ │ │ + this.zoomBox = null; │ │ │ │ + this.boxOffsets = null; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDrawBox" │ │ │ │ + ); │ │ │ │ + │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: onUnselect │ │ │ │ - * {Function} Optional function to be called when a feature is unselected. │ │ │ │ - * The function should expect to be called with a feature. │ │ │ │ + * Method: activate │ │ │ │ */ │ │ │ │ - onUnselect: function() {}, │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragHandler.activate(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: scope │ │ │ │ - * {Object} The scope to use with the onBeforeSelect, onSelect, onUnselect │ │ │ │ - * callbacks. If null the scope will be this control. │ │ │ │ + * Method: deactivate │ │ │ │ */ │ │ │ │ - scope: null, │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + if (this.dragHandler.deactivate()) { │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.removeBox(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: geometryTypes │ │ │ │ - * {Array(String)} To restrict selecting to a limited set of geometry types, │ │ │ │ - * send a list of strings corresponding to the geometry class names. │ │ │ │ + * Method: getBoxOffsets │ │ │ │ + * Determines border offsets for a box, according to the box model. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} an object with the following offsets: │ │ │ │ + * - left │ │ │ │ + * - right │ │ │ │ + * - top │ │ │ │ + * - bottom │ │ │ │ + * - width │ │ │ │ + * - height │ │ │ │ */ │ │ │ │ - geometryTypes: null, │ │ │ │ + getBoxOffsets: function() { │ │ │ │ + if (!this.boxOffsets) { │ │ │ │ + // Determine the box model. If the testDiv's clientWidth is 3, then │ │ │ │ + // the borders are outside and we are dealing with the w3c box │ │ │ │ + // model. Otherwise, the browser uses the traditional box model and │ │ │ │ + // the borders are inside the box bounds, leaving us with a │ │ │ │ + // clientWidth of 1. │ │ │ │ + var testDiv = document.createElement("div"); │ │ │ │ + //testDiv.style.visibility = "hidden"; │ │ │ │ + testDiv.style.position = "absolute"; │ │ │ │ + testDiv.style.border = "1px solid black"; │ │ │ │ + testDiv.style.width = "3px"; │ │ │ │ + document.body.appendChild(testDiv); │ │ │ │ + var w3cBoxModel = testDiv.clientWidth == 3; │ │ │ │ + document.body.removeChild(testDiv); │ │ │ │ + │ │ │ │ + var left = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ + "border-left-width")); │ │ │ │ + var right = parseInt(OpenLayers.Element.getStyle( │ │ │ │ + this.zoomBox, "border-right-width")); │ │ │ │ + var top = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ + "border-top-width")); │ │ │ │ + var bottom = parseInt(OpenLayers.Element.getStyle( │ │ │ │ + this.zoomBox, "border-bottom-width")); │ │ │ │ + this.boxOffsets = { │ │ │ │ + left: left, │ │ │ │ + right: right, │ │ │ │ + top: top, │ │ │ │ + bottom: bottom, │ │ │ │ + width: w3cBoxModel === false ? left + right : 0, │ │ │ │ + height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + return this.boxOffsets; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Handler/Pinch.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Handler.Pinch │ │ │ │ + * The pinch handler is used to deal with sequences of browser events related │ │ │ │ + * to pinch gestures. The handler is used by controls that want to know │ │ │ │ + * when a pinch sequence begins, when a pinch is happening, and when it has │ │ │ │ + * finished. │ │ │ │ + * │ │ │ │ + * Controls that use the pinch handler typically construct it with callbacks │ │ │ │ + * for 'start', 'move', and 'done'. Callbacks for these keys are │ │ │ │ + * called when the pinch begins, with each change, and when the pinch is │ │ │ │ + * done. │ │ │ │ + * │ │ │ │ + * Create a new pinch handler with the <OpenLayers.Handler.Pinch> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.Pinch = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The vector layer with a common renderer │ │ │ │ - * root for all layers this control is configured with (if an array of │ │ │ │ - * layers was passed to the constructor), or the vector layer the control │ │ │ │ - * was configured with (if a single layer was passed to the constructor). │ │ │ │ + * Property: started │ │ │ │ + * {Boolean} When a touchstart event is received, we want to record it, │ │ │ │ + * but not set 'pinching' until the touchmove get started after │ │ │ │ + * starting. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + started: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layers │ │ │ │ - * {Array(<OpenLayers.Layer.Vector>)} The layers this control will work on, │ │ │ │ - * or null if the control was configured with a single layer │ │ │ │ + * Property: stopDown │ │ │ │ + * {Boolean} Stop propagation of touchstart events from getting to │ │ │ │ + * listeners on the same element. Default is false. │ │ │ │ */ │ │ │ │ - layers: null, │ │ │ │ + stopDown: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: callbacks │ │ │ │ - * {Object} The functions that are sent to the handlers.feature for callback │ │ │ │ + * Property: pinching │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - callbacks: null, │ │ │ │ + pinching: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: selectStyle │ │ │ │ - * {Object} Hash of styles │ │ │ │ + * Property: last │ │ │ │ + * {Object} Object that store informations related to pinch last touch. │ │ │ │ */ │ │ │ │ - selectStyle: null, │ │ │ │ + last: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: renderIntent │ │ │ │ - * {String} key used to retrieve the select style from the layer's │ │ │ │ - * style map. │ │ │ │ + * Property: start │ │ │ │ + * {Object} Object that store informations related to pinch touchstart. │ │ │ │ */ │ │ │ │ - renderIntent: "select", │ │ │ │ + start: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: handlers │ │ │ │ - * {Object} Object with references to multiple <OpenLayers.Handler> │ │ │ │ - * instances. │ │ │ │ + * Constructor: OpenLayers.Handler.Pinch │ │ │ │ + * Returns OpenLayers.Handler.Pinch │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ + * this handler. If a handler is being used without a control, the │ │ │ │ + * handlers setMap method must be overridden to deal properly with │ │ │ │ + * the map. │ │ │ │ + * callbacks - {Object} An object containing functions to be called when │ │ │ │ + * the pinch operation start, change, or is finished. The callbacks │ │ │ │ + * should expect to receive an object argument, which contains │ │ │ │ + * information about scale, distance, and position of touch points. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - handlers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.SelectFeature │ │ │ │ - * Create a new control for selecting features. │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. The │ │ │ │ - * layer(s) this control will select features from. │ │ │ │ - * options - {Object} │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - initialize: function(layers, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - if (this.scope === null) { │ │ │ │ - this.scope = this; │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - var callbacks = { │ │ │ │ - click: this.clickFeature, │ │ │ │ - clickout: this.clickoutFeature │ │ │ │ - }; │ │ │ │ - if (this.hover) { │ │ │ │ - callbacks.over = this.overFeature; │ │ │ │ - callbacks.out = this.outFeature; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ - this.handlers = { │ │ │ │ - feature: new OpenLayers.Handler.Feature( │ │ │ │ - this, this.layer, this.callbacks, { │ │ │ │ - geometryTypes: this.geometryTypes │ │ │ │ - } │ │ │ │ - ) │ │ │ │ - }; │ │ │ │ - │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box = new OpenLayers.Handler.Box( │ │ │ │ - this, { │ │ │ │ - done: this.selectBox │ │ │ │ - }, { │ │ │ │ - boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ - } │ │ │ │ - ); │ │ │ │ + touchstart: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + this.pinching = false; │ │ │ │ + if (OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ + this.started = true; │ │ │ │ + this.last = this.start = { │ │ │ │ + distance: this.getDistance(evt.touches), │ │ │ │ + delta: 0, │ │ │ │ + scale: 1 │ │ │ │ + }; │ │ │ │ + this.callback("start", [evt, this.start]); │ │ │ │ + propagate = !this.stopDown; │ │ │ │ + } else if (this.started) { │ │ │ │ + // Some webkit versions send fake single-touch events during │ │ │ │ + // multitouch, which cause the drag handler to trigger │ │ │ │ + return false; │ │ │ │ + } else { │ │ │ │ + this.started = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ } │ │ │ │ + // prevent document dragging │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + return propagate; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: initLayer │ │ │ │ - * Assign the layer property. If layers is an array, we need to use │ │ │ │ - * a RootContainer. │ │ │ │ + * Method: touchmove │ │ │ │ + * Handle touchmove events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - initLayer: function(layers) { │ │ │ │ - if (OpenLayers.Util.isArray(layers)) { │ │ │ │ - this.layers = layers; │ │ │ │ - this.layer = new OpenLayers.Layer.Vector.RootContainer( │ │ │ │ - this.id + "_container", { │ │ │ │ - layers: layers │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.layer = layers; │ │ │ │ + touchmove: function(evt) { │ │ │ │ + if (this.started && OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ + this.pinching = true; │ │ │ │ + var current = this.getPinchData(evt); │ │ │ │ + this.callback("move", [evt, current]); │ │ │ │ + this.last = current; │ │ │ │ + // prevent document dragging │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + } else if (this.started) { │ │ │ │ + // Some webkit versions send fake single-touch events during │ │ │ │ + // multitouch, which cause the drag handler to trigger │ │ │ │ + return false; │ │ │ │ } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * Method: touchend │ │ │ │ + * Handle touchend events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active && this.layers) { │ │ │ │ - this.map.removeLayer(this.layer); │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy(); │ │ │ │ + touchend: function(evt) { │ │ │ │ + if (this.started && !OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ + this.started = false; │ │ │ │ + this.pinching = false; │ │ │ │ + this.callback("done", [evt, this.start, this.last]); │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + return false; │ │ │ │ } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: activate │ │ │ │ - * Activates the control. │ │ │ │ - * │ │ │ │ + * Activate the handler. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The control was effectively activated. │ │ │ │ + * {Boolean} The handler was successfully activated. │ │ │ │ */ │ │ │ │ activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.addLayer(this.layer); │ │ │ │ - } │ │ │ │ - this.handlers.feature.activate(); │ │ │ │ - if (this.box && this.handlers.box) { │ │ │ │ - this.handlers.box.activate(); │ │ │ │ - } │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.pinching = false; │ │ │ │ + activated = true; │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: deactivate │ │ │ │ - * Deactivates the control. │ │ │ │ - * │ │ │ │ + * Deactivate the handler. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The control was effectively deactivated. │ │ │ │ + * {Boolean} The handler was successfully deactivated. │ │ │ │ */ │ │ │ │ deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.feature.deactivate(); │ │ │ │ - if (this.handlers.box) { │ │ │ │ - this.handlers.box.deactivate(); │ │ │ │ - } │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.removeLayer(this.layer); │ │ │ │ - } │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.started = false; │ │ │ │ + this.pinching = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unselectAll │ │ │ │ - * Unselect all selected features. To unselect all except for a single │ │ │ │ - * feature, set the options.except property to the feature. │ │ │ │ + * Method: getDistance │ │ │ │ + * Get the distance in pixels between two touches. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional configuration object. │ │ │ │ + * touches - {Array(Object)} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} The distance in pixels. │ │ │ │ */ │ │ │ │ - unselectAll: function(options) { │ │ │ │ - // we'll want an option to supress notification here │ │ │ │ - var layers = this.layers || [this.layer], │ │ │ │ - layer, feature, l, numExcept; │ │ │ │ - for (l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - numExcept = 0; │ │ │ │ - //layer.selectedFeatures is null when layer is destroyed and │ │ │ │ - //one of it's preremovelayer listener calls setLayer │ │ │ │ - //with another layer on this control │ │ │ │ - if (layer.selectedFeatures != null) { │ │ │ │ - while (layer.selectedFeatures.length > numExcept) { │ │ │ │ - feature = layer.selectedFeatures[numExcept]; │ │ │ │ - if (!options || options.except != feature) { │ │ │ │ - this.unselect(feature); │ │ │ │ - } else { │ │ │ │ - ++numExcept; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + getDistance: function(touches) { │ │ │ │ + var t0 = touches[0]; │ │ │ │ + var t1 = touches[1]; │ │ │ │ + return Math.sqrt( │ │ │ │ + Math.pow(t0.olClientX - t1.olClientX, 2) + │ │ │ │ + Math.pow(t0.olClientY - t1.olClientY, 2) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: clickFeature │ │ │ │ - * Called on click in a feature │ │ │ │ - * Only responds if this.hover is false. │ │ │ │ + * Method: getPinchData │ │ │ │ + * Get informations about the pinch event. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - clickFeature: function(feature) { │ │ │ │ - if (!this.hover) { │ │ │ │ - var selected = (OpenLayers.Util.indexOf( │ │ │ │ - feature.layer.selectedFeatures, feature) > -1); │ │ │ │ - if (selected) { │ │ │ │ - if (this.toggleSelect()) { │ │ │ │ - this.unselect(feature); │ │ │ │ - } else if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - this.select(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: multipleSelect │ │ │ │ - * Allow for multiple selected features based on <multiple> property and │ │ │ │ - * <multipleKey> event modifier. │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Allow for multiple selected features. │ │ │ │ + * {Object} Object that contains data about the current pinch. │ │ │ │ */ │ │ │ │ - multipleSelect: function() { │ │ │ │ - return this.multiple || (this.handlers.feature.evt && │ │ │ │ - this.handlers.feature.evt[this.multipleKey]); │ │ │ │ + getPinchData: function(evt) { │ │ │ │ + var distance = this.getDistance(evt.touches); │ │ │ │ + var scale = distance / this.start.distance; │ │ │ │ + return { │ │ │ │ + distance: distance, │ │ │ │ + delta: this.last.distance - distance, │ │ │ │ + scale: scale │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: toggleSelect │ │ │ │ - * Event should toggle the selected state of a feature based on <toggle> │ │ │ │ - * property and <toggleKey> event modifier. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Toggle the selected state of a feature. │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Pinch" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Handler/MouseWheel.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Handler.MouseWheel │ │ │ │ + * Handler for wheel up/down events. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + /** │ │ │ │ + * Property: wheelListener │ │ │ │ + * {function} │ │ │ │ */ │ │ │ │ - toggleSelect: function() { │ │ │ │ - return this.toggle || (this.handlers.feature.evt && │ │ │ │ - this.handlers.feature.evt[this.toggleKey]); │ │ │ │ - }, │ │ │ │ + wheelListener: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clickoutFeature │ │ │ │ - * Called on click outside a previously clicked (selected) feature. │ │ │ │ - * Only responds if this.hover is false. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ + * Property: interval │ │ │ │ + * {Integer} In order to increase server performance, an interval (in │ │ │ │ + * milliseconds) can be set to reduce the number of up/down events │ │ │ │ + * called. If set, a new up/down event will not be set until the │ │ │ │ + * interval has passed. │ │ │ │ + * Defaults to 0, meaning no interval. │ │ │ │ */ │ │ │ │ - clickoutFeature: function(feature) { │ │ │ │ - if (!this.hover && this.clickout) { │ │ │ │ - this.unselectAll(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: overFeature │ │ │ │ - * Called on over a feature. │ │ │ │ - * Only responds if this.hover is true. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Property: maxDelta │ │ │ │ + * {Integer} Maximum delta to collect before breaking from the current │ │ │ │ + * interval. In cumulative mode, this also limits the maximum delta │ │ │ │ + * returned from the handler. Default is Number.POSITIVE_INFINITY. │ │ │ │ */ │ │ │ │ - overFeature: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - this.highlight(feature); │ │ │ │ - } else if (OpenLayers.Util.indexOf( │ │ │ │ - layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: outFeature │ │ │ │ - * Called on out of a selected feature. │ │ │ │ - * Only responds if this.hover is true. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Property: delta │ │ │ │ + * {Integer} When interval is set, delta collects the mousewheel z-deltas │ │ │ │ + * of the events that occur within the interval. │ │ │ │ + * See also the cumulative option │ │ │ │ */ │ │ │ │ - outFeature: function(feature) { │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - // we do nothing if we're not the last highlighter of the │ │ │ │ - // feature │ │ │ │ - if (feature._lastHighlighter == this.id) { │ │ │ │ - // if another select control had highlighted the feature before │ │ │ │ - // we did it ourself then we use that control to highlight the │ │ │ │ - // feature as it was before we highlighted it, else we just │ │ │ │ - // unhighlight it │ │ │ │ - if (feature._prevHighlighter && │ │ │ │ - feature._prevHighlighter != this.id) { │ │ │ │ - delete feature._lastHighlighter; │ │ │ │ - var control = this.map.getControl( │ │ │ │ - feature._prevHighlighter); │ │ │ │ - if (control) { │ │ │ │ - control.highlight(feature); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unhighlight(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unselect(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + delta: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: highlight │ │ │ │ - * Redraw feature with the select style. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Property: cumulative │ │ │ │ + * {Boolean} When interval is set: true to collect all the mousewheel │ │ │ │ + * z-deltas, false to only record the delta direction (positive or │ │ │ │ + * negative) │ │ │ │ */ │ │ │ │ - highlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ - feature._lastHighlighter = this.id; │ │ │ │ - var style = this.selectStyle || this.renderIntent; │ │ │ │ - layer.drawFeature(feature, style); │ │ │ │ - this.events.triggerEvent("featurehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + cumulative: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unhighlight │ │ │ │ - * Redraw feature with the "default" style │ │ │ │ + * Constructor: OpenLayers.Handler.MouseWheel │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ + * callbacks - {Object} An object containing a single function to be │ │ │ │ + * called when the drag operation is finished. │ │ │ │ + * The callback should expect to recieve a single │ │ │ │ + * argument, the point geometry. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - unhighlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - // three cases: │ │ │ │ - // 1. there's no other highlighter, in that case _prev is undefined, │ │ │ │ - // and we just need to undef _last │ │ │ │ - // 2. another control highlighted the feature after we did it, in │ │ │ │ - // that case _last references this other control, and we just │ │ │ │ - // need to undef _prev │ │ │ │ - // 3. another control highlighted the feature before we did it, in │ │ │ │ - // that case _prev references this other control, and we need to │ │ │ │ - // set _last to _prev and undef _prev │ │ │ │ - if (feature._prevHighlighter == undefined) { │ │ │ │ - delete feature._lastHighlighter; │ │ │ │ - } else if (feature._prevHighlighter == this.id) { │ │ │ │ - delete feature._prevHighlighter; │ │ │ │ - } else { │ │ │ │ - feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ - delete feature._prevHighlighter; │ │ │ │ - } │ │ │ │ - layer.drawFeature(feature, feature.style || feature.layer.style || │ │ │ │ - "default"); │ │ │ │ - this.events.triggerEvent("featureunhighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.wheelListener = OpenLayers.Function.bindAsEventListener( │ │ │ │ + this.onWheelEvent, this │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: select │ │ │ │ - * Add feature to the layer's selectedFeature array, render the feature as │ │ │ │ - * selected, and call the onSelect function. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - select: function(feature) { │ │ │ │ - var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (cont !== false) { │ │ │ │ - cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - layer.selectedFeatures.push(feature); │ │ │ │ - this.highlight(feature); │ │ │ │ - // if the feature handler isn't involved in the feature │ │ │ │ - // selection (because the box handler is used or the │ │ │ │ - // feature is selected programatically) we fake the │ │ │ │ - // feature handler to allow unselecting on click │ │ │ │ - if (!this.handlers.feature.lastFeature) { │ │ │ │ - this.handlers.feature.lastFeature = layer.selectedFeatures[0]; │ │ │ │ - } │ │ │ │ - layer.events.triggerEvent("featureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onSelect.call(this.scope, feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + this.wheelListener = null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unselect │ │ │ │ - * Remove feature from the layer's selectedFeature array, render the feature as │ │ │ │ - * normal, and call the onUnselect function. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Mouse ScrollWheel code thanks to http://adomas.org/javascript-mouse-wheel/ │ │ │ │ */ │ │ │ │ - unselect: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - // Store feature style for restoration later │ │ │ │ - this.unhighlight(feature); │ │ │ │ - OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ - layer.events.triggerEvent("featureunselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onUnselect.call(this.scope, feature); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: selectBox │ │ │ │ - * Callback from the handlers.box set up when <box> selection is true │ │ │ │ - * on. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: onWheelEvent │ │ │ │ + * Catch the wheel event and handle it xbrowserly │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * position - {<OpenLayers.Bounds> || <OpenLayers.Pixel> } │ │ │ │ + * e - {Event} │ │ │ │ */ │ │ │ │ - selectBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - var bounds = new OpenLayers.Bounds( │ │ │ │ - minXY.lon, minXY.lat, maxXY.lon, maxXY.lat │ │ │ │ - ); │ │ │ │ + onWheelEvent: function(e) { │ │ │ │ │ │ │ │ - // if multiple is false, first deselect currently selected features │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll(); │ │ │ │ - } │ │ │ │ + // make sure we have a map and check keyboard modifiers │ │ │ │ + if (!this.map || !this.checkModifiers(e)) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ │ │ │ │ - // because we're using a box, we consider we want multiple selection │ │ │ │ - var prevMultiple = this.multiple; │ │ │ │ - this.multiple = true; │ │ │ │ - var layers = this.layers || [this.layer]; │ │ │ │ - this.events.triggerEvent("boxselectionstart", { │ │ │ │ - layers: layers │ │ │ │ - }); │ │ │ │ - var layer; │ │ │ │ - for (var l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ - var feature = layer.features[i]; │ │ │ │ - // check if the feature is displayed │ │ │ │ - if (!feature.getVisibility()) { │ │ │ │ - continue; │ │ │ │ + // Ride up the element's DOM hierarchy to determine if it or any of │ │ │ │ + // its ancestors was: │ │ │ │ + // * specifically marked as scrollable (CSS overflow property) │ │ │ │ + // * one of our layer divs or a div marked as scrollable │ │ │ │ + // ('olScrollable' CSS class) │ │ │ │ + // * the map div │ │ │ │ + // │ │ │ │ + var overScrollableDiv = false; │ │ │ │ + var allowScroll = false; │ │ │ │ + var overMapDiv = false; │ │ │ │ + │ │ │ │ + var elem = OpenLayers.Event.element(e); │ │ │ │ + while ((elem != null) && !overMapDiv && !overScrollableDiv) { │ │ │ │ + │ │ │ │ + if (!overScrollableDiv) { │ │ │ │ + try { │ │ │ │ + var overflow; │ │ │ │ + if (elem.currentStyle) { │ │ │ │ + overflow = elem.currentStyle["overflow"]; │ │ │ │ + } else { │ │ │ │ + var style = │ │ │ │ + document.defaultView.getComputedStyle(elem, null); │ │ │ │ + overflow = style.getPropertyValue("overflow"); │ │ │ │ } │ │ │ │ + overScrollableDiv = (overflow && │ │ │ │ + (overflow == "auto") || (overflow == "scroll")); │ │ │ │ + } catch (err) { │ │ │ │ + //sometimes when scrolling in a popup, this causes │ │ │ │ + // obscure browser error │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - if (this.geometryTypes == null || OpenLayers.Util.indexOf( │ │ │ │ - this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ - if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ - if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature); │ │ │ │ - } │ │ │ │ + if (!allowScroll) { │ │ │ │ + allowScroll = OpenLayers.Element.hasClass(elem, 'olScrollable'); │ │ │ │ + if (!allowScroll) { │ │ │ │ + for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ + // Are we in the layer div? Note that we have two cases │ │ │ │ + // here: one is to catch EventPane layers, which have a │ │ │ │ + // pane above the layer (layer.pane) │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (elem == layer.div || elem == layer.pane) { │ │ │ │ + allowScroll = true; │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - this.multiple = prevMultiple; │ │ │ │ - this.events.triggerEvent("boxselectionend", { │ │ │ │ - layers: layers │ │ │ │ - }); │ │ │ │ + overMapDiv = (elem == this.map.div); │ │ │ │ + │ │ │ │ + elem = elem.parentNode; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // Logic below is the following: │ │ │ │ + // │ │ │ │ + // If we are over a scrollable div or not over the map div: │ │ │ │ + // * do nothing (let the browser handle scrolling) │ │ │ │ + // │ │ │ │ + // otherwise │ │ │ │ + // │ │ │ │ + // If we are over the layer div or a 'olScrollable' div: │ │ │ │ + // * zoom/in out │ │ │ │ + // then │ │ │ │ + // * kill event (so as not to also scroll the page after zooming) │ │ │ │ + // │ │ │ │ + // otherwise │ │ │ │ + // │ │ │ │ + // Kill the event (dont scroll the page if we wheel over the │ │ │ │ + // layerswitcher or the pan/zoom control) │ │ │ │ + // │ │ │ │ + if (!overScrollableDiv && overMapDiv) { │ │ │ │ + if (allowScroll) { │ │ │ │ + var delta = 0; │ │ │ │ + │ │ │ │ + if (e.wheelDelta) { │ │ │ │ + delta = e.wheelDelta; │ │ │ │ + if (delta % 160 === 0) { │ │ │ │ + // opera have steps of 160 instead of 120 │ │ │ │ + delta = delta * 0.75; │ │ │ │ + } │ │ │ │ + delta = delta / 120; │ │ │ │ + } else if (e.detail) { │ │ │ │ + // detail in Firefox on OS X is 1/3 of Windows │ │ │ │ + // so force delta 1 / -1 │ │ │ │ + delta = -(e.detail / Math.abs(e.detail)); │ │ │ │ + } │ │ │ │ + this.delta += delta; │ │ │ │ + │ │ │ │ + window.clearTimeout(this._timeoutId); │ │ │ │ + if (this.interval && Math.abs(this.delta) < this.maxDelta) { │ │ │ │ + // store e because window.event might change during delay │ │ │ │ + var evt = OpenLayers.Util.extend({}, e); │ │ │ │ + this._timeoutId = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(function() { │ │ │ │ + this.wheelZoom(evt); │ │ │ │ + }, this), │ │ │ │ + this.interval │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.wheelZoom(e); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ + /** │ │ │ │ + * Method: wheelZoom │ │ │ │ + * Given the wheel event, we carry out the appropriate zooming in or out, │ │ │ │ + * based on the 'wheelDelta' or 'detail' property of the event. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * e - {Event} │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.feature.setMap(map); │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box.setMap(map); │ │ │ │ + wheelZoom: function(e) { │ │ │ │ + var delta = this.delta; │ │ │ │ + this.delta = 0; │ │ │ │ + │ │ │ │ + if (delta) { │ │ │ │ + e.xy = this.map.events.getMousePosition(e); │ │ │ │ + if (delta < 0) { │ │ │ │ + this.callback("down", │ │ │ │ + [e, this.cumulative ? Math.max(-this.maxDelta, delta) : -1]); │ │ │ │ + } else { │ │ │ │ + this.callback("up", │ │ │ │ + [e, this.cumulative ? Math.min(this.maxDelta, delta) : 1]); │ │ │ │ + } │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setLayer │ │ │ │ - * Attach a new layer to the control, overriding any existing layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layers - Array of {<OpenLayers.Layer.Vector>} or a single │ │ │ │ - * {<OpenLayers.Layer.Vector>} │ │ │ │ + * Method: activate │ │ │ │ */ │ │ │ │ - setLayer: function(layers) { │ │ │ │ - var isActive = this.active; │ │ │ │ - this.unselectAll(); │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy(); │ │ │ │ - this.layers = null; │ │ │ │ + activate: function(evt) { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + //register mousewheel events specifically on the window and document │ │ │ │ + var wheelListener = this.wheelListener; │ │ │ │ + OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener); │ │ │ │ + OpenLayers.Event.observe(window, "mousewheel", wheelListener); │ │ │ │ + OpenLayers.Event.observe(document, "mousewheel", wheelListener); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - this.initLayer(layers); │ │ │ │ - this.handlers.feature.layer = this.layer; │ │ │ │ - if (isActive) { │ │ │ │ - this.activate(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + */ │ │ │ │ + deactivate: function(evt) { │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + // unregister mousewheel events specifically on the window and document │ │ │ │ + var wheelListener = this.wheelListener; │ │ │ │ + OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener); │ │ │ │ + OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/MousePosition.js │ │ │ │ + OpenLayers/Protocol/Script.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Protocol.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Format/GeoJSON.js │ │ │ │ + */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ + * if application uses the query string, for example, for BBOX parameters, │ │ │ │ + * OpenLayers/Format/QueryStringFilter.js should be included in the build config file │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.MousePosition │ │ │ │ - * The MousePosition control displays geographic coordinates of the mouse │ │ │ │ - * pointer, as it is moved about the map. │ │ │ │ - * │ │ │ │ - * You can use the <prefix>- or <suffix>-properties to provide more information │ │ │ │ - * about the displayed coordinates to the user: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * var mousePositionCtrl = new OpenLayers.Control.MousePosition({ │ │ │ │ - * prefix: '<a target="_blank" ' + │ │ │ │ - * 'href="http://spatialreference.org/ref/epsg/4326/">' + │ │ │ │ - * 'EPSG:4326</a> coordinates: ' │ │ │ │ - * } │ │ │ │ - * ); │ │ │ │ - * (end code) │ │ │ │ + * Class: OpenLayers.Protocol.Script │ │ │ │ + * A basic Script protocol for vector layers. Create a new instance with the │ │ │ │ + * <OpenLayers.Protocol.Script> constructor. A script protocol is used to │ │ │ │ + * get around the same origin policy. It works with services that return │ │ │ │ + * JSONP - that is, JSON wrapped in a client-specified callback. The │ │ │ │ + * protocol handles fetching and parsing of feature data and sends parsed │ │ │ │ + * features to the <callback> configured with the protocol. The protocol │ │ │ │ + * expects features serialized as GeoJSON by default, but can be configured │ │ │ │ + * to work with other formats by setting the <format> property. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Protocol> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.MousePosition = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} Service URL. The service is expected to return serialized │ │ │ │ + * features wrapped in a named callback (where the callback name is │ │ │ │ + * generated by this protocol). │ │ │ │ + * Read-only, set through the options passed to the constructor. │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: element │ │ │ │ - * {DOMElement} │ │ │ │ + * APIProperty: params │ │ │ │ + * {Object} Query string parameters to be appended to the URL. │ │ │ │ + * Read-only, set through the options passed to the constructor. │ │ │ │ + * Example: {maxFeatures: 50} │ │ │ │ */ │ │ │ │ - element: null, │ │ │ │ + params: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: prefix │ │ │ │ - * {String} A string to be prepended to the current pointers coordinates │ │ │ │ - * when it is rendered. Defaults to the empty string ''. │ │ │ │ + * APIProperty: callback │ │ │ │ + * {Object} Function to be called when the <read> operation completes. │ │ │ │ */ │ │ │ │ - prefix: '', │ │ │ │ + callback: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: separator │ │ │ │ - * {String} A string to be used to seperate the two coordinates from each │ │ │ │ - * other. Defaults to the string ', ', which will result in a │ │ │ │ - * rendered coordinate of e.g. '42.12, 21.22'. │ │ │ │ + * APIProperty: callbackTemplate │ │ │ │ + * {String} Template for creating a unique callback function name │ │ │ │ + * for the registry. Should include ${id}. The ${id} variable will be │ │ │ │ + * replaced with a string identifier prefixed with a "c" (e.g. c1, c2). │ │ │ │ + * Default is "OpenLayers.Protocol.Script.registry.${id}". │ │ │ │ */ │ │ │ │ - separator: ', ', │ │ │ │ + callbackTemplate: "OpenLayers.Protocol.Script.registry.${id}", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: suffix │ │ │ │ - * {String} A string to be appended to the current pointers coordinates │ │ │ │ - * when it is rendered. Defaults to the empty string ''. │ │ │ │ + * APIProperty: callbackKey │ │ │ │ + * {String} The name of the query string parameter that the service │ │ │ │ + * recognizes as the callback identifier. Default is "callback". │ │ │ │ + * This key is used to generate the URL for the script. For example │ │ │ │ + * setting <callbackKey> to "myCallback" would result in a URL like │ │ │ │ + * http://example.com/?myCallback=... │ │ │ │ */ │ │ │ │ - suffix: '', │ │ │ │ + callbackKey: "callback", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: numDigits │ │ │ │ - * {Integer} The number of digits each coordinate shall have when being │ │ │ │ - * rendered, Defaults to 5. │ │ │ │ + * APIProperty: callbackPrefix │ │ │ │ + * {String} Where a service requires that the callback query string │ │ │ │ + * parameter value is prefixed by some string, this value may be set. │ │ │ │ + * For example, setting <callbackPrefix> to "foo:" would result in a │ │ │ │ + * URL like http://example.com/?callback=foo:... Default is "". │ │ │ │ */ │ │ │ │ - numDigits: 5, │ │ │ │ + callbackPrefix: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: granularity │ │ │ │ - * {Integer} │ │ │ │ + * APIProperty: scope │ │ │ │ + * {Object} Optional ``this`` object for the callback. Read-only, set │ │ │ │ + * through the options passed to the constructor. │ │ │ │ */ │ │ │ │ - granularity: 10, │ │ │ │ + scope: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: emptyString │ │ │ │ - * {String} Set this to some value to set when the mouse is outside the │ │ │ │ - * map. │ │ │ │ + * APIProperty: format │ │ │ │ + * {<OpenLayers.Format>} Format for parsing features. Default is an │ │ │ │ + * <OpenLayers.Format.GeoJSON> format. If an alternative is provided, │ │ │ │ + * the format's read method must take an object and return an array │ │ │ │ + * of features. │ │ │ │ */ │ │ │ │ - emptyString: null, │ │ │ │ + format: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: lastXy │ │ │ │ - * {<OpenLayers.Pixel>} │ │ │ │ + * Property: pendingRequests │ │ │ │ + * {Object} References all pending requests. Property names are script │ │ │ │ + * identifiers and property values are script elements. │ │ │ │ */ │ │ │ │ - lastXy: null, │ │ │ │ + pendingRequests: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: displayProjection │ │ │ │ - * {<OpenLayers.Projection>} The projection in which the mouse position is │ │ │ │ - * displayed. │ │ │ │ + * APIProperty: srsInBBOX │ │ │ │ + * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ + * Setting this property has no effect if a custom filterToParams method │ │ │ │ + * is provided. Default is false. If true and the layer has a │ │ │ │ + * projection object set, any BBOX filter will be serialized with a │ │ │ │ + * fifth item identifying the projection. │ │ │ │ + * E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ */ │ │ │ │ - displayProjection: null, │ │ │ │ + srsInBBOX: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.MousePosition │ │ │ │ + * Constructor: OpenLayers.Protocol.Script │ │ │ │ + * A class for giving layers generic Script protocol. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Options for control. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + * │ │ │ │ + * Valid options include: │ │ │ │ + * url - {String} │ │ │ │ + * params - {Object} │ │ │ │ + * callback - {Function} │ │ │ │ + * scope - {Object} │ │ │ │ */ │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + this.params = {}; │ │ │ │ + this.pendingRequests = {}; │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + if (!this.format) { │ │ │ │ + this.format = new OpenLayers.Format.GeoJSON(); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ + var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ + srsInBBOX: this.srsInBBOX │ │ │ │ + }); │ │ │ │ + this.filterToParams = function(filter, params) { │ │ │ │ + return format.write(filter, params); │ │ │ │ + }; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * url - {String} Url for the request. │ │ │ │ + * params - {Object} Parameters to get serialized as a query string. │ │ │ │ + * filter - {<OpenLayers.Filter>} Filter to get serialized as a │ │ │ │ + * query string. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property │ │ │ │ + * references the injected script. This object is also passed to the │ │ │ │ + * callback function when the request completes, its "features" property │ │ │ │ + * is then populated with the features received from the server. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.map.events.register('mousemove', this, this.redraw); │ │ │ │ - this.map.events.register('mouseout', this, this.reset); │ │ │ │ - this.redraw(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + options.params = OpenLayers.Util.applyDefaults( │ │ │ │ + options.params, this.options.params │ │ │ │ + ); │ │ │ │ + if (options.filter && this.filterToParams) { │ │ │ │ + options.params = this.filterToParams( │ │ │ │ + options.filter, options.params │ │ │ │ + ); │ │ │ │ } │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + var request = this.createRequest( │ │ │ │ + options.url, │ │ │ │ + options.params, │ │ │ │ + OpenLayers.Function.bind(function(data) { │ │ │ │ + response.data = data; │ │ │ │ + this.handleRead(response, options); │ │ │ │ + }, this) │ │ │ │ + ); │ │ │ │ + response.priv = request; │ │ │ │ + return response; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ + /** │ │ │ │ + * APIMethod: filterToParams │ │ │ │ + * Optional method to translate an <OpenLayers.Filter> object into an object │ │ │ │ + * that can be serialized as request query string provided. If a custom │ │ │ │ + * method is not provided, any filter will not be serialized. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ + * params - {Object} The parameters object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} The resulting parameters object. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.map.events.unregister('mousemove', this, this.redraw); │ │ │ │ - this.map.events.unregister('mouseout', this, this.reset); │ │ │ │ - this.element.innerHTML = ""; │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createRequest │ │ │ │ + * Issues a request for features by creating injecting a script in the │ │ │ │ + * document head. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * url - {String} Service URL. │ │ │ │ + * params - {Object} Query string parameters. │ │ │ │ + * callback - {Function} Callback to be called with resulting data. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {HTMLScriptElement} The script pending execution. │ │ │ │ + */ │ │ │ │ + createRequest: function(url, params, callback) { │ │ │ │ + var id = OpenLayers.Protocol.Script.register(callback); │ │ │ │ + var name = OpenLayers.String.format(this.callbackTemplate, { │ │ │ │ + id: id │ │ │ │ + }); │ │ │ │ + params = OpenLayers.Util.extend({}, params); │ │ │ │ + params[this.callbackKey] = this.callbackPrefix + name; │ │ │ │ + url = OpenLayers.Util.urlAppend( │ │ │ │ + url, OpenLayers.Util.getParameterString(params) │ │ │ │ + ); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = "OpenLayers_Protocol_Script_" + id; │ │ │ │ + this.pendingRequests[script.id] = script; │ │ │ │ + var head = document.getElementsByTagName("head")[0]; │ │ │ │ + head.appendChild(script); │ │ │ │ + return script; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroyRequest │ │ │ │ + * Remove a script node associated with a response from the document. Also │ │ │ │ + * unregisters the callback and removes the script from the │ │ │ │ + * <pendingRequests> object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * script - {HTMLScriptElement} │ │ │ │ + */ │ │ │ │ + destroyRequest: function(script) { │ │ │ │ + OpenLayers.Protocol.Script.unregister(script.id.split("_").pop()); │ │ │ │ + delete this.pendingRequests[script.id]; │ │ │ │ + if (script.parentNode) { │ │ │ │ + script.parentNode.removeChild(script); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: handleRead │ │ │ │ + * Individual callbacks are created for read, create and update, should │ │ │ │ + * a subclass need to override each one separately. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * the user callback. │ │ │ │ + * options - {Object} The user options passed to the read call. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + this.handleResponse(response, options); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!this.element) { │ │ │ │ - this.div.left = ""; │ │ │ │ - this.div.top = ""; │ │ │ │ - this.element = this.div; │ │ │ │ + /** │ │ │ │ + * Method: handleResponse │ │ │ │ + * Called by CRUD specific handlers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the create, read, update, │ │ │ │ + * or delete call. │ │ │ │ + */ │ │ │ │ + handleResponse: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + if (response.data) { │ │ │ │ + response.features = this.parseFeatures(response.data); │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + } │ │ │ │ + this.destroyRequest(response.priv); │ │ │ │ + options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ - │ │ │ │ - return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: redraw │ │ │ │ + * Method: parseFeatures │ │ │ │ + * Read Script response body and return features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * data - {Object} The data sent to the callback function by the server. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} Array of features or a single feature. │ │ │ │ */ │ │ │ │ - redraw: function(evt) { │ │ │ │ - │ │ │ │ - var lonLat; │ │ │ │ + parseFeatures: function(data) { │ │ │ │ + return this.format.read(data); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (evt == null) { │ │ │ │ - this.reset(); │ │ │ │ - return; │ │ │ │ + /** │ │ │ │ + * APIMethod: abort │ │ │ │ + * Abort an ongoing request. If no response is provided, all pending │ │ │ │ + * requests will be aborted. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object returned │ │ │ │ + * from a <read> request. │ │ │ │ + */ │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + this.destroyRequest(response.priv); │ │ │ │ } 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); │ │ │ │ + for (var key in this.pendingRequests) { │ │ │ │ + this.destroyRequest(this.pendingRequests[key]); │ │ │ │ } │ │ │ │ - this.lastXy = evt.xy; │ │ │ │ - │ │ │ │ - } │ │ │ │ - │ │ │ │ - var newHtml = this.formatOutput(lonLat); │ │ │ │ - │ │ │ │ - if (newHtml != this.element.innerHTML) { │ │ │ │ - this.element.innerHTML = newHtml; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: reset │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ - reset: function(evt) { │ │ │ │ - if (this.emptyString != null) { │ │ │ │ - this.element.innerHTML = this.emptyString; │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + this.abort(); │ │ │ │ + delete this.params; │ │ │ │ + delete this.format; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.Script" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +(function() { │ │ │ │ + var o = OpenLayers.Protocol.Script; │ │ │ │ + var counter = 0; │ │ │ │ + o.registry = {}; │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: formatOutput │ │ │ │ - * Override to provide custom display output │ │ │ │ + * Function: OpenLayers.Protocol.Script.register │ │ │ │ + * Register a callback for a newly created script. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * lonLat - {<OpenLayers.LonLat>} Location to display │ │ │ │ + * callback - {Function} The callback to be executed when the newly added │ │ │ │ + * script loads. This callback will be called with a single argument │ │ │ │ + * that is the JSON returned by the service. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} An identifier for retrieving the registered callback. │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ - }, │ │ │ │ + o.register = function(callback) { │ │ │ │ + var id = "c" + (++counter); │ │ │ │ + o.registry[id] = function() { │ │ │ │ + callback.apply(this, arguments); │ │ │ │ + }; │ │ │ │ + return id; │ │ │ │ + }; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.MousePosition" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Function: OpenLayers.Protocol.Script.unregister │ │ │ │ + * Unregister a callback previously registered with the register function. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {Number} The identifer returned by the register function. │ │ │ │ + */ │ │ │ │ + o.unregister = function(id) { │ │ │ │ + delete o.registry[id]; │ │ │ │ + }; │ │ │ │ +})(); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/TouchNavigation.js │ │ │ │ + OpenLayers/Protocol/WFS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/DragPan.js │ │ │ │ - * @requires OpenLayers/Control/PinchZoom.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Protocol.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.TouchNavigation │ │ │ │ - * The navigation control handles map browsing with touch events (dragging, │ │ │ │ - * double-tapping, tap with two fingers, and pinch zoom). Create a new │ │ │ │ - * control with the <OpenLayers.Control.TouchNavigation> constructor. │ │ │ │ + * Class: OpenLayers.Protocol.WFS │ │ │ │ + * Used to create a versioned WFS protocol. Default version is 1.0.0. │ │ │ │ * │ │ │ │ - * If you’re only targeting touch enabled devices with your mapping application, │ │ │ │ - * you can create a map with only a TouchNavigation control. The │ │ │ │ - * <OpenLayers.Control.Navigation> control is mobile ready by default, but │ │ │ │ - * you can generate a smaller build of the library by only including this │ │ │ │ - * touch navigation control if you aren't concerned about mouse interaction. │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol>} A WFS protocol of the given version. │ │ │ │ * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var protocol = new OpenLayers.Protocol.WFS({ │ │ │ │ + * version: "1.1.0", │ │ │ │ + * url: "http://demo.opengeo.org/geoserver/wfs", │ │ │ │ + * featureType: "tasmania_roads", │ │ │ │ + * featureNS: "http://www.openplans.org/topp", │ │ │ │ + * geometryName: "the_geom" │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * See the protocols for specific WFS versions for more detail. │ │ │ │ */ │ │ │ │ -OpenLayers.Control.TouchNavigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Protocol.WFS = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults( │ │ │ │ + options, OpenLayers.Protocol.WFS.DEFAULTS │ │ │ │ + ); │ │ │ │ + var cls = OpenLayers.Protocol.WFS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported WFS version: " + options.version; │ │ │ │ + } │ │ │ │ + return new cls(options); │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: fromWMSLayer │ │ │ │ + * Convenience function to create a WFS protocol from a WMS layer. This makes │ │ │ │ + * the assumption that a WFS requests can be issued at the same URL as │ │ │ │ + * WMS requests and that a WFS featureType exists with the same name as the │ │ │ │ + * WMS layer. │ │ │ │ + * │ │ │ │ + * This function is designed to auto-configure <url>, <featureType>, │ │ │ │ + * <featurePrefix> and <srsName> for WFS <version> 1.1.0. Note that │ │ │ │ + * srsName matching with the WMS layer will not work with WFS 1.0.0. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.WMS>} WMS layer that has a matching WFS │ │ │ │ + * FeatureType at the same server url with the same typename. │ │ │ │ + * options - {Object} Default properties to be set on the protocol. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.WFS>} │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.WFS.fromWMSLayer = function(layer, options) { │ │ │ │ + var typeName, featurePrefix; │ │ │ │ + var param = layer.params["LAYERS"]; │ │ │ │ + var parts = (OpenLayers.Util.isArray(param) ? param[0] : param).split(":"); │ │ │ │ + if (parts.length > 1) { │ │ │ │ + featurePrefix = parts[0]; │ │ │ │ + } │ │ │ │ + typeName = parts.pop(); │ │ │ │ + var protocolOptions = { │ │ │ │ + url: layer.url, │ │ │ │ + featureType: typeName, │ │ │ │ + featurePrefix: featurePrefix, │ │ │ │ + srsName: layer.projection && layer.projection.getCode() || │ │ │ │ + layer.map && layer.map.getProjectionObject().getCode(), │ │ │ │ + version: "1.1.0" │ │ │ │ + }; │ │ │ │ + return new OpenLayers.Protocol.WFS(OpenLayers.Util.applyDefaults( │ │ │ │ + options, protocolOptions │ │ │ │ + )); │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Protocol.WFS.DEFAULTS │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.WFS.DEFAULTS = { │ │ │ │ + "version": "1.0.0" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Protocol/CSW.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Protocol.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol.CSW │ │ │ │ + * Used to create a versioned CSW protocol. Default version is 2.0.2. │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.CSW = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults( │ │ │ │ + options, OpenLayers.Protocol.CSW.DEFAULTS │ │ │ │ + ); │ │ │ │ + var cls = OpenLayers.Protocol.CSW["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported CSW version: " + options.version; │ │ │ │ + } │ │ │ │ + return new cls(options); │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Protocol.CSW.DEFAULTS │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.CSW.DEFAULTS = { │ │ │ │ + "version": "2.0.2" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Protocol/HTTP.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Protocol.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * if application uses the query string, for example, for BBOX parameters, │ │ │ │ + * OpenLayers/Format/QueryStringFilter.js should be included in the build config file │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol.HTTP │ │ │ │ + * A basic HTTP protocol for vector layers. Create a new instance with the │ │ │ │ + * <OpenLayers.Protocol.HTTP> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Protocol> │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dragPan │ │ │ │ - * {<OpenLayers.Control.DragPan>} │ │ │ │ + * Property: url │ │ │ │ + * {String} Service URL, read-only, set through the options │ │ │ │ + * passed to constructor. │ │ │ │ */ │ │ │ │ - dragPan: null, │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: dragPanOptions │ │ │ │ - * {Object} Options passed to the DragPan control. │ │ │ │ + * Property: headers │ │ │ │ + * {Object} HTTP request headers, read-only, set through the options │ │ │ │ + * passed to the constructor, │ │ │ │ + * Example: {'Content-Type': 'plain/text'} │ │ │ │ */ │ │ │ │ - dragPanOptions: null, │ │ │ │ + headers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: pinchZoom │ │ │ │ - * {<OpenLayers.Control.PinchZoom>} │ │ │ │ + * Property: params │ │ │ │ + * {Object} Parameters of GET requests, read-only, set through the options │ │ │ │ + * passed to the constructor, │ │ │ │ + * Example: {'bbox': '5,5,5,5'} │ │ │ │ */ │ │ │ │ - pinchZoom: null, │ │ │ │ + params: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: pinchZoomOptions │ │ │ │ - * {Object} Options passed to the PinchZoom control. │ │ │ │ + * Property: callback │ │ │ │ + * {Object} Function to be called when the <read>, <create>, │ │ │ │ + * <update>, <delete> or <commit> operation completes, read-only, │ │ │ │ + * set through the options passed to the constructor. │ │ │ │ */ │ │ │ │ - pinchZoomOptions: null, │ │ │ │ + callback: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: clickHandlerOptions │ │ │ │ - * {Object} Options passed to the Click handler. │ │ │ │ + * Property: scope │ │ │ │ + * {Object} Callback execution scope, read-only, set through the │ │ │ │ + * options passed to the constructor. │ │ │ │ */ │ │ │ │ - clickHandlerOptions: null, │ │ │ │ + scope: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} Allow panning of the map by dragging outside map viewport. │ │ │ │ - * Default is false. │ │ │ │ + * APIProperty: readWithPOST │ │ │ │ + * {Boolean} true if read operations are done with POST requests │ │ │ │ + * instead of GET, defaults to false. │ │ │ │ */ │ │ │ │ - documentDrag: false, │ │ │ │ + readWithPOST: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * APIProperty: updateWithPOST │ │ │ │ + * {Boolean} true if update operations are done with POST requests │ │ │ │ + * defaults to false. │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + updateWithPOST: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.TouchNavigation │ │ │ │ - * Create a new navigation control │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * the control │ │ │ │ + * APIProperty: deleteWithPOST │ │ │ │ + * {Boolean} true if delete operations are done with POST requests │ │ │ │ + * defaults to false. │ │ │ │ + * if true, POST data is set to output of format.write(). │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + deleteWithPOST: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * Property: wildcarded. │ │ │ │ + * {Boolean} If true percent signs are added around values │ │ │ │ + * read from LIKE filters, for example if the protocol │ │ │ │ + * read method is passed a LIKE filter whose property │ │ │ │ + * is "foo" and whose value is "bar" the string │ │ │ │ + * "foo__ilike=%bar%" will be sent in the query string; │ │ │ │ + * defaults to false. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.dragPan) { │ │ │ │ - this.dragPan.destroy(); │ │ │ │ - } │ │ │ │ - this.dragPan = null; │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.destroy(); │ │ │ │ - delete this.pinchZoom; │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + wildcarded: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ + * APIProperty: srsInBBOX │ │ │ │ + * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ + * Default is false. If true and the layer has a projection object set, │ │ │ │ + * any BBOX filter will be serialized with a fifth item identifying the │ │ │ │ + * projection. E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragPan.activate(); │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - this.pinchZoom.activate(); │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ + srsInBBOX: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ + * Constructor: OpenLayers.Protocol.HTTP │ │ │ │ + * A class for giving layers generic HTTP protocol. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + * │ │ │ │ + * Valid options include: │ │ │ │ + * url - {String} │ │ │ │ + * headers - {Object} │ │ │ │ + * params - {Object} URL parameters for GET requests │ │ │ │ + * format - {<OpenLayers.Format>} │ │ │ │ + * callback - {Function} │ │ │ │ + * scope - {Object} │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.dragPan.deactivate(); │ │ │ │ - this.handlers.click.deactivate(); │ │ │ │ - this.pinchZoom.deactivate(); │ │ │ │ - return true; │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + this.params = {}; │ │ │ │ + this.headers = {}; │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ + var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ + wildcarded: this.wildcarded, │ │ │ │ + srsInBBOX: this.srsInBBOX │ │ │ │ + }); │ │ │ │ + this.filterToParams = function(filter, params) { │ │ │ │ + return format.write(filter, params); │ │ │ │ + }; │ │ │ │ } │ │ │ │ - return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - var clickCallbacks = { │ │ │ │ - click: this.defaultClick, │ │ │ │ - dblclick: this.defaultDblClick │ │ │ │ - }; │ │ │ │ - var clickOptions = OpenLayers.Util.extend({ │ │ │ │ - "double": true, │ │ │ │ - stopDouble: true, │ │ │ │ - pixelTolerance: 2 │ │ │ │ - }, this.clickHandlerOptions); │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ - this, clickCallbacks, clickOptions │ │ │ │ - ); │ │ │ │ - this.dragPan = new OpenLayers.Control.DragPan( │ │ │ │ - OpenLayers.Util.extend({ │ │ │ │ - map: this.map, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }, this.dragPanOptions) │ │ │ │ - ); │ │ │ │ - this.dragPan.draw(); │ │ │ │ - this.pinchZoom = new OpenLayers.Control.PinchZoom( │ │ │ │ - OpenLayers.Util.extend({ │ │ │ │ - map: this.map │ │ │ │ - }, this.pinchZoomOptions) │ │ │ │ - ); │ │ │ │ + destroy: function() { │ │ │ │ + this.params = null; │ │ │ │ + this.headers = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: defaultClick │ │ │ │ + * APIMethod: filterToParams │ │ │ │ + * Optional method to translate an <OpenLayers.Filter> object into an object │ │ │ │ + * that can be serialized as request query string provided. If a custom │ │ │ │ + * method is not provided, the filter will be serialized using the │ │ │ │ + * <OpenLayers.Format.QueryStringFilter> class. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ + * params - {Object} The parameters object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} The resulting parameters object. │ │ │ │ */ │ │ │ │ - defaultClick: function(evt) { │ │ │ │ - if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ - this.map.zoomOut(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: defaultDblClick │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new features. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * url - {String} Url for the request. │ │ │ │ + * params - {Object} Parameters to get serialized as a query string. │ │ │ │ + * headers - {Object} Headers to be set on the request. │ │ │ │ + * filter - {<OpenLayers.Filter>} Filter to get serialized as a │ │ │ │ + * query string. │ │ │ │ + * readWithPOST - {Boolean} If the request should be done with POST. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property │ │ │ │ + * references the HTTP request, this object is also passed to the │ │ │ │ + * callback function when the request completes, its "features" property │ │ │ │ + * is then populated with the features received from the server. │ │ │ │ */ │ │ │ │ - defaultDblClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom + 1, evt.xy); │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = options || {}; │ │ │ │ + options.params = OpenLayers.Util.applyDefaults( │ │ │ │ + options.params, this.options.params); │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + if (options.filter && this.filterToParams) { │ │ │ │ + options.params = this.filterToParams( │ │ │ │ + options.filter, options.params │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + var readWithPOST = (options.readWithPOST !== undefined) ? │ │ │ │ + options.readWithPOST : this.readWithPOST; │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + if (readWithPOST) { │ │ │ │ + var headers = options.headers || {}; │ │ │ │ + headers["Content-Type"] = "application/x-www-form-urlencoded"; │ │ │ │ + resp.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ + data: OpenLayers.Util.getParameterString(options.params), │ │ │ │ + headers: headers │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + resp.priv = OpenLayers.Request.GET({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.TouchNavigation" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Cluster.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Strategy.Cluster │ │ │ │ - * Strategy for vector feature clustering. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ - */ │ │ │ │ -OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: distance │ │ │ │ - * {Integer} Pixel distance between features that should be considered a │ │ │ │ - * single cluster. Default is 20 pixels. │ │ │ │ - */ │ │ │ │ - distance: 20, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: threshold │ │ │ │ - * {Integer} Optional threshold below which original features will be │ │ │ │ - * added to the layer instead of clusters. For example, a threshold │ │ │ │ - * of 3 would mean that any time there are 2 or fewer features in │ │ │ │ - * a cluster, those features will be added directly to the layer instead │ │ │ │ - * of a cluster representing those features. Default is null (which is │ │ │ │ - * equivalent to 1 - meaning that clusters may contain just one feature). │ │ │ │ + * Method: handleRead │ │ │ │ + * Individual callbacks are created for read, create and update, should │ │ │ │ + * a subclass need to override each one separately. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * the user callback. │ │ │ │ + * options - {Object} The user options passed to the read call. │ │ │ │ */ │ │ │ │ - threshold: null, │ │ │ │ + handleRead: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: features │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} Cached features. │ │ │ │ + * APIMethod: create │ │ │ │ + * Construct a request for writing newly created features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, whose "priv" property references the HTTP request, this │ │ │ │ + * object is also passed to the callback function when the request │ │ │ │ + * completes, its "features" property is then populated with the │ │ │ │ + * the features received from the server. │ │ │ │ */ │ │ │ │ - features: null, │ │ │ │ + create: function(features, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: clusters │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} Calculated clusters. │ │ │ │ - */ │ │ │ │ - clusters: null, │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: features, │ │ │ │ + requestType: "create" │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: clustering │ │ │ │ - * {Boolean} The strategy is currently clustering features. │ │ │ │ - */ │ │ │ │ - clustering: false, │ │ │ │ + resp.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleCreate, resp, options), │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(features) │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: resolution │ │ │ │ - * {Float} The resolution (map units per pixel) of the current cluster set. │ │ │ │ - */ │ │ │ │ - resolution: null, │ │ │ │ + return resp; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Cluster │ │ │ │ - * Create a new clustering strategy. │ │ │ │ + * Method: handleCreate │ │ │ │ + * Called the the request issued by <create> is complete. May be overridden │ │ │ │ + * by subclasses. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the create call. │ │ │ │ */ │ │ │ │ + handleCreate: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ - * │ │ │ │ + * APIMethod: update │ │ │ │ + * Construct a request updating modified feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The strategy was successfully activated. │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, whose "priv" property references the HTTP request, this │ │ │ │ + * object is also passed to the callback function when the request │ │ │ │ + * completes, its "features" property is then populated with the │ │ │ │ + * the feature received from the server. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "beforefeaturesadded": this.cacheFeatures, │ │ │ │ - "featuresremoved": this.clearCache, │ │ │ │ - "moveend": this.cluster, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ + update: function(feature, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var url = options.url || │ │ │ │ + feature.url || │ │ │ │ + this.options.url + "/" + feature.fid; │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: feature, │ │ │ │ + requestType: "update" │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var method = this.updateWithPOST ? "POST" : "PUT"; │ │ │ │ + resp.priv = OpenLayers.Request[method]({ │ │ │ │ + url: url, │ │ │ │ + callback: this.createCallback(this.handleUpdate, resp, options), │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(feature) │ │ │ │ + }); │ │ │ │ + │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ - * tear-down. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ + * Method: handleUpdate │ │ │ │ + * Called the the request issued by <update> is complete. May be overridden │ │ │ │ + * by subclasses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the update call. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.layer.events.un({ │ │ │ │ - "beforefeaturesadded": this.cacheFeatures, │ │ │ │ - "featuresremoved": this.clearCache, │ │ │ │ - "moveend": this.cluster, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ + handleUpdate: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cacheFeatures │ │ │ │ - * Cache features before they are added to the layer. │ │ │ │ + * APIMethod: delete │ │ │ │ + * Construct a request deleting a removed feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The event that this was listening for. This will come │ │ │ │ - * with a batch of features to be clustered. │ │ │ │ - * │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} False to stop features from being added to the layer. │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, whose "priv" property references the HTTP request, this │ │ │ │ + * object is also passed to the callback function when the request │ │ │ │ + * completes. │ │ │ │ */ │ │ │ │ - cacheFeatures: function(event) { │ │ │ │ - var propagate = true; │ │ │ │ - if (!this.clustering) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.features = event.features; │ │ │ │ - this.cluster(); │ │ │ │ - propagate = false; │ │ │ │ + "delete": function(feature, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var url = options.url || │ │ │ │ + feature.url || │ │ │ │ + this.options.url + "/" + feature.fid; │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: feature, │ │ │ │ + requestType: "delete" │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var method = this.deleteWithPOST ? "POST" : "DELETE"; │ │ │ │ + var requestOptions = { │ │ │ │ + url: url, │ │ │ │ + callback: this.createCallback(this.handleDelete, resp, options), │ │ │ │ + headers: options.headers │ │ │ │ + }; │ │ │ │ + if (this.deleteWithPOST) { │ │ │ │ + requestOptions.data = this.format.write(feature); │ │ │ │ } │ │ │ │ - return propagate; │ │ │ │ + resp.priv = OpenLayers.Request[method](requestOptions); │ │ │ │ + │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearCache │ │ │ │ - * Clear out the cached features. │ │ │ │ + * Method: handleDelete │ │ │ │ + * Called the the request issued by <delete> is complete. May be overridden │ │ │ │ + * by subclasses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the delete call. │ │ │ │ */ │ │ │ │ - clearCache: function() { │ │ │ │ - if (!this.clustering) { │ │ │ │ - this.features = null; │ │ │ │ - } │ │ │ │ + handleDelete: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cluster │ │ │ │ - * Cluster features based on some threshold distance. │ │ │ │ + * Method: handleResponse │ │ │ │ + * Called by CRUD specific handlers. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The event received when cluster is called as a │ │ │ │ - * result of a moveend event. │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the create, read, update, │ │ │ │ + * or delete call. │ │ │ │ */ │ │ │ │ - cluster: function(event) { │ │ │ │ - if ((!event || event.zoomChanged) && this.features) { │ │ │ │ - var resolution = this.layer.map.getResolution(); │ │ │ │ - if (resolution != this.resolution || !this.clustersExist()) { │ │ │ │ - this.resolution = resolution; │ │ │ │ - var clusters = []; │ │ │ │ - var feature, clustered, cluster; │ │ │ │ - for (var i = 0; i < this.features.length; ++i) { │ │ │ │ - feature = this.features[i]; │ │ │ │ - if (feature.geometry) { │ │ │ │ - clustered = false; │ │ │ │ - for (var j = clusters.length - 1; j >= 0; --j) { │ │ │ │ - cluster = clusters[j]; │ │ │ │ - if (this.shouldCluster(cluster, feature)) { │ │ │ │ - this.addToCluster(cluster, feature); │ │ │ │ - clustered = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!clustered) { │ │ │ │ - clusters.push(this.createCluster(this.features[i])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.clustering = true; │ │ │ │ - this.layer.removeAllFeatures(); │ │ │ │ - this.clustering = false; │ │ │ │ - if (clusters.length > 0) { │ │ │ │ - if (this.threshold > 1) { │ │ │ │ - var clone = clusters.slice(); │ │ │ │ - clusters = []; │ │ │ │ - var candidate; │ │ │ │ - for (var i = 0, len = clone.length; i < len; ++i) { │ │ │ │ - candidate = clone[i]; │ │ │ │ - if (candidate.attributes.count < this.threshold) { │ │ │ │ - Array.prototype.push.apply(clusters, candidate.cluster); │ │ │ │ - } else { │ │ │ │ - clusters.push(candidate); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.clustering = true; │ │ │ │ - // A legitimate feature addition could occur during this │ │ │ │ - // addFeatures call. For clustering to behave well, features │ │ │ │ - // should be removed from a layer before requesting a new batch. │ │ │ │ - this.layer.addFeatures(clusters); │ │ │ │ - this.clustering = false; │ │ │ │ + handleResponse: function(resp, options) { │ │ │ │ + var request = resp.priv; │ │ │ │ + if (options.callback) { │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + // success │ │ │ │ + if (resp.requestType != "delete") { │ │ │ │ + resp.features = this.parseFeatures(request); │ │ │ │ } │ │ │ │ - this.clusters = clusters; │ │ │ │ + resp.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } else { │ │ │ │ + // failure │ │ │ │ + resp.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ } │ │ │ │ + options.callback.call(options.scope, resp); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clustersExist │ │ │ │ - * Determine whether calculated clusters are already on the layer. │ │ │ │ + * Method: parseFeatures │ │ │ │ + * Read HTTP response body and return features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * request - {XMLHttpRequest} The request object │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The calculated clusters are already on the layer. │ │ │ │ + * {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} Array of features or a single feature. │ │ │ │ */ │ │ │ │ - clustersExist: function() { │ │ │ │ - var exist = false; │ │ │ │ - if (this.clusters && this.clusters.length > 0 && │ │ │ │ - this.clusters.length == this.layer.features.length) { │ │ │ │ - exist = true; │ │ │ │ - for (var i = 0; i < this.clusters.length; ++i) { │ │ │ │ - if (this.clusters[i] != this.layer.features[i]) { │ │ │ │ - exist = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + parseFeatures: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ } │ │ │ │ - return exist; │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + return this.format.read(doc); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: shouldCluster │ │ │ │ - * Determine whether to include a feature in a given cluster. │ │ │ │ + * APIMethod: commit │ │ │ │ + * Iterate over each feature and take action based on the feature state. │ │ │ │ + * Possible actions are create, update and delete. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * cluster - {<OpenLayers.Feature.Vector>} A cluster. │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} A feature. │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} │ │ │ │ + * options - {Object} Optional object for setting up intermediate commit │ │ │ │ + * callbacks. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * create - {Object} Optional object to be passed to the <create> method. │ │ │ │ + * update - {Object} Optional object to be passed to the <update> method. │ │ │ │ + * delete - {Object} Optional object to be passed to the <delete> method. │ │ │ │ + * callback - {Function} Optional function to be called when the commit │ │ │ │ + * is complete. │ │ │ │ + * scope - {Object} Optional object to be set as the scope of the callback. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The feature should be included in the cluster. │ │ │ │ + * {Array(<OpenLayers.Protocol.Response>)} An array of response objects, │ │ │ │ + * one per request made to the server, each object's "priv" property │ │ │ │ + * references the corresponding HTTP request. │ │ │ │ */ │ │ │ │ - shouldCluster: function(cluster, feature) { │ │ │ │ - var cc = cluster.geometry.getBounds().getCenterLonLat(); │ │ │ │ - var fc = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ - var distance = ( │ │ │ │ - Math.sqrt( │ │ │ │ - Math.pow((cc.lon - fc.lon), 2) + Math.pow((cc.lat - fc.lat), 2) │ │ │ │ - ) / this.resolution │ │ │ │ - ); │ │ │ │ - return (distance <= this.distance); │ │ │ │ + commit: function(features, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var resp = [], │ │ │ │ + nResponses = 0; │ │ │ │ + │ │ │ │ + // Divide up features before issuing any requests. This properly │ │ │ │ + // counts requests in the event that any responses come in before │ │ │ │ + // all requests have been issued. │ │ │ │ + var types = {}; │ │ │ │ + types[OpenLayers.State.INSERT] = []; │ │ │ │ + types[OpenLayers.State.UPDATE] = []; │ │ │ │ + types[OpenLayers.State.DELETE] = []; │ │ │ │ + var feature, list, requestFeatures = []; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + list = types[feature.state]; │ │ │ │ + if (list) { │ │ │ │ + list.push(feature); │ │ │ │ + requestFeatures.push(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // tally up number of requests │ │ │ │ + var nRequests = (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) + │ │ │ │ + types[OpenLayers.State.UPDATE].length + │ │ │ │ + types[OpenLayers.State.DELETE].length; │ │ │ │ + │ │ │ │ + // This response will be sent to the final callback after all the others │ │ │ │ + // have been fired. │ │ │ │ + var success = true; │ │ │ │ + var finalResponse = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: requestFeatures │ │ │ │ + }); │ │ │ │ + │ │ │ │ + function insertCallback(response) { │ │ │ │ + var len = response.features ? response.features.length : 0; │ │ │ │ + var fids = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + fids[i] = response.features[i].fid; │ │ │ │ + } │ │ │ │ + finalResponse.insertIds = fids; │ │ │ │ + callback.apply(this, [response]); │ │ │ │ + } │ │ │ │ + │ │ │ │ + function callback(response) { │ │ │ │ + this.callUserCallback(response, options); │ │ │ │ + success = success && response.success(); │ │ │ │ + nResponses++; │ │ │ │ + if (nResponses >= nRequests) { │ │ │ │ + if (options.callback) { │ │ │ │ + finalResponse.code = success ? │ │ │ │ + OpenLayers.Protocol.Response.SUCCESS : │ │ │ │ + OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + options.callback.apply(options.scope, [finalResponse]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // start issuing requests │ │ │ │ + var queue = types[OpenLayers.State.INSERT]; │ │ │ │ + if (queue.length > 0) { │ │ │ │ + resp.push(this.create( │ │ │ │ + queue, OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: insertCallback, │ │ │ │ + scope: this │ │ │ │ + }, options.create) │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + queue = types[OpenLayers.State.UPDATE]; │ │ │ │ + for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ + resp.push(this.update( │ │ │ │ + queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: callback, │ │ │ │ + scope: this │ │ │ │ + }, options.update))); │ │ │ │ + } │ │ │ │ + queue = types[OpenLayers.State.DELETE]; │ │ │ │ + for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ + resp.push(this["delete"]( │ │ │ │ + queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: callback, │ │ │ │ + scope: this │ │ │ │ + }, options["delete"]))); │ │ │ │ + } │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addToCluster │ │ │ │ - * Add a feature to a cluster. │ │ │ │ + * APIMethod: abort │ │ │ │ + * Abort an ongoing request, the response object passed to │ │ │ │ + * this method must come from this HTTP protocol (as a result │ │ │ │ + * of a create, read, update, delete or commit operation). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * cluster - {<OpenLayers.Feature.Vector>} A cluster. │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} A feature. │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} │ │ │ │ */ │ │ │ │ - addToCluster: function(cluster, feature) { │ │ │ │ - cluster.cluster.push(feature); │ │ │ │ - cluster.attributes.count += 1; │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + response.priv.abort(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createCluster │ │ │ │ - * Given a feature, create a cluster. │ │ │ │ + * Method: callUserCallback │ │ │ │ + * This method is used from within the commit method each time an │ │ │ │ + * an HTTP response is received from the server, it is responsible │ │ │ │ + * for calling the user-supplied callbacks. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} A cluster. │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} │ │ │ │ + * options - {Object} The map of options passed to the commit call. │ │ │ │ */ │ │ │ │ - createCluster: function(feature) { │ │ │ │ - var center = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ - var cluster = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.Point(center.lon, center.lat), { │ │ │ │ - count: 1 │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - cluster.cluster = [feature]; │ │ │ │ - return cluster; │ │ │ │ + callUserCallback: function(resp, options) { │ │ │ │ + var opt = options[resp.requestType]; │ │ │ │ + if (opt && opt.callback) { │ │ │ │ + opt.callback.call(opt.scope, resp); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Cluster" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/BBOX.js │ │ │ │ + OpenLayers/Protocol/SOS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + * @requires OpenLayers/Protocol.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.BBOX │ │ │ │ - * A simple strategy that reads new features when the viewport invalidates │ │ │ │ - * some bounds. │ │ │ │ + * Function: OpenLayers.Protocol.SOS │ │ │ │ + * Used to create a versioned SOS protocol. Default version is 1.0.0. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol>} An SOS protocol for the given version. │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ +OpenLayers.Protocol.SOS = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults( │ │ │ │ + options, OpenLayers.Protocol.SOS.DEFAULTS │ │ │ │ + ); │ │ │ │ + var cls = OpenLayers.Protocol.SOS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported SOS version: " + options.version; │ │ │ │ + } │ │ │ │ + return new cls(options); │ │ │ │ +}; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: bounds │ │ │ │ - * {<OpenLayers.Bounds>} The current data bounds (in the same projection │ │ │ │ - * as the layer - not always the same projection as the map). │ │ │ │ - */ │ │ │ │ - bounds: null, │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Protocol.SOS.DEFAULTS │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.SOS.DEFAULTS = { │ │ │ │ + "version": "1.0.0" │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Protocol/CSW/v2_0_2.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: resolution │ │ │ │ - * {Float} The current data resolution. │ │ │ │ - */ │ │ │ │ - resolution: null, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: ratio │ │ │ │ - * {Float} The ratio of the data bounds to the viewport bounds (in each │ │ │ │ - * dimension). Default is 2. │ │ │ │ - */ │ │ │ │ - ratio: 2, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Protocol/CSW.js │ │ │ │ + * @requires OpenLayers/Format/CSWGetRecords/v2_0_2.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: resFactor │ │ │ │ - * {Float} Optional factor used to determine when previously requested │ │ │ │ - * features are invalid. If set, the resFactor will be compared to the │ │ │ │ - * resolution of the previous request to the current map resolution. │ │ │ │ - * If resFactor > (old / new) and 1/resFactor < (old / new). If you │ │ │ │ - * set a resFactor of 1, data will be requested every time the │ │ │ │ - * resolution changes. If you set a resFactor of 3, data will be │ │ │ │ - * requested if the old resolution is 3 times the new, or if the new is │ │ │ │ - * 3 times the old. If the old bounds do not contain the new bounds │ │ │ │ - * new data will always be requested (with or without considering │ │ │ │ - * resFactor). │ │ │ │ - */ │ │ │ │ - resFactor: null, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol.CSW.v2_0_2 │ │ │ │ + * CS-W (Catalogue services for the Web) version 2.0.2 protocol. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Protocol> │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.CSW.v2_0_2 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: response │ │ │ │ - * {<OpenLayers.Protocol.Response>} The protocol response object returned │ │ │ │ - * by the layer protocol. │ │ │ │ + * Property: formatOptions │ │ │ │ + * {Object} Optional options for the format. If a format is not provided, │ │ │ │ + * this property can be used to extend the default format options. │ │ │ │ */ │ │ │ │ - response: null, │ │ │ │ + formatOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.BBOX │ │ │ │ - * Create a new BBOX strategy. │ │ │ │ + * Constructor: OpenLayers.Protocol.CSW.v2_0_2 │ │ │ │ + * A class for CSW version 2.0.2 protocol management. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ * instance. │ │ │ │ */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: activate │ │ │ │ - * Set up strategy with regard to reading new batches of remote data. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully activated. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "moveend": this.update, │ │ │ │ - "refresh": this.update, │ │ │ │ - "visibilitychanged": this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.update(); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!options.format) { │ │ │ │ + this.format = new OpenLayers.Format.CSWGetRecords.v2_0_2(OpenLayers.Util.extend({}, this.formatOptions)); │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Tear down strategy with regard to reading new batches of remote data. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - "moveend": this.update, │ │ │ │ - "refresh": this.update, │ │ │ │ - "visibilitychanged": this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + destroy: function() { │ │ │ │ + if (this.options && !this.options.format) { │ │ │ │ + this.format.destroy(); │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + this.format = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Callback function called on "moveend" or "refresh" layer events. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will determine │ │ │ │ - * the behaviour of this Strategy │ │ │ │ - * │ │ │ │ - * Valid options include: │ │ │ │ - * force - {Boolean} if true, new data must be unconditionally read. │ │ │ │ - * noAbort - {Boolean} if true, do not abort previous requests. │ │ │ │ + * Method: read │ │ │ │ + * Construct a request for reading new records from the Catalogue. │ │ │ │ */ │ │ │ │ - update: function(options) { │ │ │ │ - var mapBounds = this.getMapBounds(); │ │ │ │ - if (mapBounds !== null && ((options && options.force) || │ │ │ │ - (this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds)))) { │ │ │ │ - this.calculateBounds(mapBounds); │ │ │ │ - this.resolution = this.layer.map.getResolution(); │ │ │ │ - this.triggerRead(options); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + read: function(options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getMapBounds │ │ │ │ - * Get the map bounds expressed in the same projection as this layer. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} Map bounds in the projection of the layer. │ │ │ │ - */ │ │ │ │ - getMapBounds: function() { │ │ │ │ - if (this.layer.map === null) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - var bounds = this.layer.map.getExtent(); │ │ │ │ - if (bounds && !this.layer.projection.equals( │ │ │ │ - this.layer.map.getProjectionObject())) { │ │ │ │ - bounds = bounds.clone().transform( │ │ │ │ - this.layer.map.getProjectionObject(), this.layer.projection │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return bounds; │ │ │ │ - }, │ │ │ │ + var data = this.format.write(options.params || options); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: invalidBounds │ │ │ │ - * Determine whether the previously requested set of features is invalid. │ │ │ │ - * This occurs when the new map bounds do not contain the previously │ │ │ │ - * requested bounds. In addition, if <resFactor> is set, it will be │ │ │ │ - * considered. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ - * retrieved from the map object if not provided │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - invalidBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds(); │ │ │ │ - } │ │ │ │ - var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ - if (!invalid && this.resFactor) { │ │ │ │ - var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ - invalid = (ratio >= this.resFactor || ratio <= (1 / this.resFactor)); │ │ │ │ - } │ │ │ │ - return invalid; │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, response, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers, │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + │ │ │ │ + return response; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: calculateBounds │ │ │ │ + * Method: handleRead │ │ │ │ + * Deal with response from the read request. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ - * retrieved from the map object if not provided │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ + * to the user callback. │ │ │ │ + * This response is given a code property, and optionally a data property. │ │ │ │ + * The latter represents the CSW records as returned by the call to │ │ │ │ + * the CSW format read method. │ │ │ │ + * options - {Object} The user options passed to the read call. │ │ │ │ */ │ │ │ │ - calculateBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds(); │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + // success │ │ │ │ + response.data = this.parseData(request); │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } else { │ │ │ │ + // failure │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + } │ │ │ │ + options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ - var center = mapBounds.getCenterLonLat(); │ │ │ │ - var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ - var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ - this.bounds = new OpenLayers.Bounds( │ │ │ │ - center.lon - (dataWidth / 2), │ │ │ │ - center.lat - (dataHeight / 2), │ │ │ │ - center.lon + (dataWidth / 2), │ │ │ │ - center.lat + (dataHeight / 2) │ │ │ │ - ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: triggerRead │ │ │ │ + * Method: parseData │ │ │ │ + * Read HTTP response body and return records │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Additional options for the protocol's read method │ │ │ │ - * (optional) │ │ │ │ + * request - {XMLHttpRequest} The request object │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} The protocol response object │ │ │ │ - * returned by the layer protocol. │ │ │ │ + * {Object} The CSW records as returned by the call to the format read method. │ │ │ │ */ │ │ │ │ - triggerRead: function(options) { │ │ │ │ - if (this.response && !(options && options.noAbort === true)) { │ │ │ │ - this.layer.protocol.abort(this.response); │ │ │ │ - this.layer.events.triggerEvent("loadend"); │ │ │ │ + parseData: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ } │ │ │ │ - var evt = { │ │ │ │ - filter: this.createFilter() │ │ │ │ - }; │ │ │ │ - this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ - this.response = this.layer.protocol.read( │ │ │ │ - OpenLayers.Util.applyDefaults({ │ │ │ │ - filter: evt.filter, │ │ │ │ - callback: this.merge, │ │ │ │ - scope: this │ │ │ │ - }, options)); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createFilter │ │ │ │ - * Creates a spatial BBOX filter. If the layer that this strategy belongs │ │ │ │ - * to has a filter property, this filter will be combined with the BBOX │ │ │ │ - * filter. │ │ │ │ - * │ │ │ │ - * Returns │ │ │ │ - * {<OpenLayers.Filter>} The filter object. │ │ │ │ - */ │ │ │ │ - createFilter: function() { │ │ │ │ - var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - value: this.bounds, │ │ │ │ - projection: this.layer.projection │ │ │ │ - }); │ │ │ │ - if (this.layer.filter) { │ │ │ │ - filter = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.layer.filter, filter] │ │ │ │ - }); │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null; │ │ │ │ } │ │ │ │ - return filter; │ │ │ │ + return this.format.read(doc); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: merge │ │ │ │ - * Given a list of features, determine which ones to add to the layer. │ │ │ │ - * If the layer projection differs from the map projection, features │ │ │ │ - * will be transformed from the layer projection to the map projection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ - * by the protocol. │ │ │ │ - */ │ │ │ │ - merge: function(resp) { │ │ │ │ - this.layer.destroyFeatures(); │ │ │ │ - if (resp.success()) { │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = this.layer.projection; │ │ │ │ - var local = this.layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.layer.addFeatures(features); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.bounds = null; │ │ │ │ - } │ │ │ │ - this.response = null; │ │ │ │ - this.layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.CSW.v2_0_2" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Save.js │ │ │ │ + OpenLayers/Protocol/WFS/v1.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Protocol/WFS.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.Save │ │ │ │ - * A strategy that commits newly created or modified features. By default │ │ │ │ - * the strategy waits for a call to <save> before persisting changes. By │ │ │ │ - * configuring the strategy with the <auto> option, changes can be saved │ │ │ │ - * automatically. │ │ │ │ + * Class: OpenLayers.Protocol.WFS.v1 │ │ │ │ + * Abstract class for for v1.0.0 and v1.1.0 protocol. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * - <OpenLayers.Protocol> │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.Save = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ +OpenLayers.Protocol.WFS.v1 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} An events object that handles all │ │ │ │ - * events on the strategy object. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * strategy.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types: │ │ │ │ - * start - Triggered before saving │ │ │ │ - * success - Triggered after a successful transaction │ │ │ │ - * fail - Triggered after a failed transaction │ │ │ │ - * │ │ │ │ + * Property: version │ │ │ │ + * {String} WFS version number. │ │ │ │ */ │ │ │ │ + version: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for triggering this protocol │ │ │ │ - * events. │ │ │ │ + /** │ │ │ │ + * Property: srsName │ │ │ │ + * {String} Name of spatial reference system. Default is "EPSG:4326". │ │ │ │ */ │ │ │ │ - events: null, │ │ │ │ + srsName: "EPSG:4326", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: auto │ │ │ │ - * {Boolean | Number} Auto-save. Default is false. If true, features will be │ │ │ │ - * saved immediately after being added to the layer and with each │ │ │ │ - * modification or deletion. If auto is a number, features will be │ │ │ │ - * saved on an interval provided by the value (in seconds). │ │ │ │ + * Property: featureType │ │ │ │ + * {String} Local feature typeName. │ │ │ │ */ │ │ │ │ - auto: false, │ │ │ │ + featureType: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timer │ │ │ │ - * {Number} The id of the timer. │ │ │ │ + * Property: featureNS │ │ │ │ + * {String} Feature namespace. │ │ │ │ */ │ │ │ │ - timer: null, │ │ │ │ + featureNS: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Save │ │ │ │ - * Create a new Save strategy. │ │ │ │ + * Property: geometryName │ │ │ │ + * {String} Name of the geometry attribute for features. Default is │ │ │ │ + * "the_geom" for WFS <version> 1.0, and null for higher versions. │ │ │ │ + */ │ │ │ │ + geometryName: "the_geom", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: maxFeatures │ │ │ │ + * {Integer} Optional maximum number of features to retrieve. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: schema │ │ │ │ + * {String} Optional schema location that will be included in the │ │ │ │ + * schemaLocation attribute value. Note that the feature type schema │ │ │ │ + * is required for a strict XML validator (on transactions with an │ │ │ │ + * insert for example), but is *not* required by the WFS specification │ │ │ │ + * (since the server is supposed to know about feature type schemas). │ │ │ │ + */ │ │ │ │ + schema: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: featurePrefix │ │ │ │ + * {String} Namespace alias for feature type. Default is "feature". │ │ │ │ + */ │ │ │ │ + featurePrefix: "feature", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: formatOptions │ │ │ │ + * {Object} Optional options for the format. If a format is not provided, │ │ │ │ + * this property can be used to extend the default format options. │ │ │ │ + */ │ │ │ │ + formatOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readFormat │ │ │ │ + * {<OpenLayers.Format>} For WFS requests it is possible to get a │ │ │ │ + * different output format than GML. In that case, we cannot parse │ │ │ │ + * the response with the default format (WFST) and we need a different │ │ │ │ + * format for reading. │ │ │ │ + */ │ │ │ │ + readFormat: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: readOptions │ │ │ │ + * {Object} Optional object to pass to format's read. │ │ │ │ + */ │ │ │ │ + readOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Protocol.WFS │ │ │ │ + * A class for giving layers WFS protocol. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ * instance. │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * url - {String} URL to send requests to (required). │ │ │ │ + * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ + * featureNS - {String} Feature namespace (required, but can be autodetected │ │ │ │ + * during the first query if GML is used as readFormat and │ │ │ │ + * featurePrefix is provided and matches the prefix used by the server │ │ │ │ + * for this featureType). │ │ │ │ + * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ + * for writing if featureNS is provided). Default is 'feature'. │ │ │ │ + * geometryName - {String} Name of geometry attribute. The default is │ │ │ │ + * 'the_geom' for WFS <version> 1.0, and null for higher versions. If │ │ │ │ + * null, it will be set to the name of the first geometry found in the │ │ │ │ + * first read operation. │ │ │ │ + * multi - {Boolean} If set to true, geometries will be casted to Multi │ │ │ │ + * geometries before they are written in a transaction. No casting will │ │ │ │ + * be done when reading features. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Strategy.prototype.initialize.apply(this, [options]); │ │ │ │ - this.events = new OpenLayers.Events(this); │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!options.format) { │ │ │ │ + this.format = OpenLayers.Format.WFST(OpenLayers.Util.extend({ │ │ │ │ + version: this.version, │ │ │ │ + featureType: this.featureType, │ │ │ │ + featureNS: this.featureNS, │ │ │ │ + featurePrefix: this.featurePrefix, │ │ │ │ + geometryName: this.geometryName, │ │ │ │ + srsName: this.srsName, │ │ │ │ + schema: this.schema │ │ │ │ + }, this.formatOptions)); │ │ │ │ + } │ │ │ │ + if (!options.geometryName && parseFloat(this.format.version) > 1.0) { │ │ │ │ + this.setGeometryName(null); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully activated. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (this.auto) { │ │ │ │ - if (typeof this.auto === "number") { │ │ │ │ - this.timer = window.setInterval( │ │ │ │ - OpenLayers.Function.bind(this.save, this), │ │ │ │ - this.auto * 1000 │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "featureadded": this.triggerSave, │ │ │ │ - "afterfeaturemodified": this.triggerSave, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + if (this.options && !this.options.format) { │ │ │ │ + this.format.destroy(); │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ + this.format = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ - * tear-down. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new features. Since WFS splits the │ │ │ │ + * basic CRUD operations into GetFeature requests (for read) and │ │ │ │ + * Transactions (for all others), this method does not make use of the │ │ │ │ + * format's read method (that is only about reading transaction │ │ │ │ + * responses). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Options for the read operation, in addition to the │ │ │ │ + * options set on the instance (options set here will take precedence). │ │ │ │ + * │ │ │ │ + * To use a configured protocol to get e.g. a WFS hit count, applications │ │ │ │ + * could do the following: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * protocol.read({ │ │ │ │ + * readOptions: {output: "object"}, │ │ │ │ + * resultType: "hits", │ │ │ │ + * maxFeatures: null, │ │ │ │ + * callback: function(resp) { │ │ │ │ + * // process resp.numberOfFeatures here │ │ │ │ + * } │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * To use a configured protocol to use WFS paging (if supported by the │ │ │ │ + * server), applications could do the following: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * protocol.read({ │ │ │ │ + * startIndex: 0, │ │ │ │ + * count: 50 │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * To limit the attributes returned by the GetFeature request, applications │ │ │ │ + * can use the propertyNames option to specify the properties to include in │ │ │ │ + * the response: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * protocol.read({ │ │ │ │ + * propertyNames: ["DURATION", "INTENSITY"] │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - if (this.auto) { │ │ │ │ - if (typeof this.auto === "number") { │ │ │ │ - window.clearInterval(this.timer); │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var data = OpenLayers.Format.XML.prototype.write.apply( │ │ │ │ + this.format, [this.format.writeNode("wfs:GetFeature", options)] │ │ │ │ + ); │ │ │ │ + │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, response, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers, │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + │ │ │ │ + return response; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setFeatureType │ │ │ │ + * Change the feature type on the fly. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * featureType - {String} Local (without prefix) feature typeName. │ │ │ │ + */ │ │ │ │ + setFeatureType: function(featureType) { │ │ │ │ + this.featureType = featureType; │ │ │ │ + this.format.featureType = featureType; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setGeometryName │ │ │ │ + * Sets the geometryName option after instantiation. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometryName - {String} Name of geometry attribute. │ │ │ │ + */ │ │ │ │ + setGeometryName: function(geometryName) { │ │ │ │ + this.geometryName = geometryName; │ │ │ │ + this.format.geometryName = geometryName; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: handleRead │ │ │ │ + * Deal with response from the read request. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ + * to the user callback. │ │ │ │ + * options - {Object} The user options passed to the read call. │ │ │ │ + */ │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + // success │ │ │ │ + var result = this.parseResponse(request, options.readOptions); │ │ │ │ + if (result && result.success !== false) { │ │ │ │ + if (options.readOptions && options.readOptions.output == "object") { │ │ │ │ + OpenLayers.Util.extend(response, result); │ │ │ │ + } else { │ │ │ │ + response.features = result; │ │ │ │ + } │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ } else { │ │ │ │ - this.layer.events.un({ │ │ │ │ - "featureadded": this.triggerSave, │ │ │ │ - "afterfeaturemodified": this.triggerSave, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + // failure (service exception) │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + response.error = result; │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + // failure │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ } │ │ │ │ + options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: triggerSave │ │ │ │ - * Registered as a listener. Calls save if a feature has insert, update, │ │ │ │ - * or delete state. │ │ │ │ + * Method: parseResponse │ │ │ │ + * Read HTTP response body and return features │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The event this function is listening for. │ │ │ │ + * request - {XMLHttpRequest} The request object │ │ │ │ + * options - {Object} Optional object to pass to format's read │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} or {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + * An object with a features property, an array of features or a single │ │ │ │ + * feature. │ │ │ │ */ │ │ │ │ - triggerSave: function(event) { │ │ │ │ - var feature = event.feature; │ │ │ │ - if (feature.state === OpenLayers.State.INSERT || │ │ │ │ - feature.state === OpenLayers.State.UPDATE || │ │ │ │ - feature.state === OpenLayers.State.DELETE) { │ │ │ │ - this.save([event.feature]); │ │ │ │ + parseResponse: function(request, options) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ + } │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + var result = (this.readFormat !== null) ? this.readFormat.read(doc) : │ │ │ │ + this.format.read(doc, options); │ │ │ │ + if (!this.featureNS) { │ │ │ │ + var format = this.readFormat || this.format; │ │ │ │ + this.featureNS = format.featureNS; │ │ │ │ + // no need to auto-configure again on subsequent reads │ │ │ │ + format.autoConfig = false; │ │ │ │ + if (!this.geometryName) { │ │ │ │ + this.setGeometryName(format.geometryName); │ │ │ │ + } │ │ │ │ } │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: save │ │ │ │ - * Tell the layer protocol to commit unsaved features. If the layer │ │ │ │ - * projection differs from the map projection, features will be │ │ │ │ - * transformed into the layer projection before being committed. │ │ │ │ + * Method: commit │ │ │ │ + * Given a list of feature, assemble a batch request for update, create, │ │ │ │ + * and delete transactions. A commit call on the prototype amounts │ │ │ │ + * to writing a WFS transaction - so the write method on the format │ │ │ │ + * is used. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array} Features to be saved. If null, then default is all │ │ │ │ - * features in the layer. Features are assumed to be in the map │ │ │ │ - * projection. │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ + * options - {Object} │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * nativeElements - {Array({Object})} Array of objects with information for writing │ │ │ │ + * out <Native> elements, these objects have vendorId, safeToIgnore and │ │ │ │ + * value properties. The <Native> element is intended to allow access to │ │ │ │ + * vendor specific capabilities of any particular web feature server or │ │ │ │ + * datastore. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} A response object with a features │ │ │ │ + * property containing any insertIds and a priv property referencing │ │ │ │ + * the XMLHttpRequest object. │ │ │ │ */ │ │ │ │ - save: function(features) { │ │ │ │ - if (!features) { │ │ │ │ - features = this.layer.features; │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("start", { │ │ │ │ - features: features │ │ │ │ + commit: function(features, options) { │ │ │ │ + │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "commit", │ │ │ │ + reqFeatures: features │ │ │ │ }); │ │ │ │ - var remote = this.layer.projection; │ │ │ │ - var local = this.layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var len = features.length; │ │ │ │ - var clones = new Array(len); │ │ │ │ - var orig, clone; │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - orig = features[i]; │ │ │ │ - clone = orig.clone(); │ │ │ │ - clone.fid = orig.fid; │ │ │ │ - clone.state = orig.state; │ │ │ │ - if (orig.url) { │ │ │ │ - clone.url = orig.url; │ │ │ │ - } │ │ │ │ - clone._original = orig; │ │ │ │ - clone.geometry.transform(local, remote); │ │ │ │ - clones[i] = clone; │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(features, options), │ │ │ │ + callback: this.createCallback(this.handleCommit, response, options) │ │ │ │ + }); │ │ │ │ + │ │ │ │ + return response; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: handleCommit │ │ │ │ + * Called when the commit request returns. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ + * to the user callback. │ │ │ │ + * options - {Object} The user options passed to the commit call. │ │ │ │ + */ │ │ │ │ + handleCommit: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + │ │ │ │ + // ensure that we have an xml doc │ │ │ │ + var data = request.responseXML; │ │ │ │ + if (!data || !data.documentElement) { │ │ │ │ + data = request.responseText; │ │ │ │ } │ │ │ │ - features = clones; │ │ │ │ + │ │ │ │ + var obj = this.format.read(data) || {}; │ │ │ │ + │ │ │ │ + response.insertIds = obj.insertIds || []; │ │ │ │ + if (obj.success) { │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + response.error = obj; │ │ │ │ + } │ │ │ │ + options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ - this.layer.protocol.commit(features, { │ │ │ │ - callback: this.onCommit, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onCommit │ │ │ │ - * Called after protocol commit. │ │ │ │ - * │ │ │ │ + * Method: filterDelete │ │ │ │ + * Send a request that deletes all features by their filter. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} A response object. │ │ │ │ + * filter - {<OpenLayers.Filter>} filter │ │ │ │ */ │ │ │ │ - onCommit: function(response) { │ │ │ │ - var evt = { │ │ │ │ - "response": response │ │ │ │ - }; │ │ │ │ - if (response.success()) { │ │ │ │ - var features = response.reqFeatures; │ │ │ │ - // deal with inserts, updates, and deletes │ │ │ │ - var state, feature; │ │ │ │ - var destroys = []; │ │ │ │ - var insertIds = response.insertIds || []; │ │ │ │ - var j = 0; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - // if projection was different, we may be dealing with clones │ │ │ │ - feature = feature._original || feature; │ │ │ │ - state = feature.state; │ │ │ │ - if (state) { │ │ │ │ - if (state == OpenLayers.State.DELETE) { │ │ │ │ - destroys.push(feature); │ │ │ │ - } else if (state == OpenLayers.State.INSERT) { │ │ │ │ - feature.fid = insertIds[j]; │ │ │ │ - ++j; │ │ │ │ - } │ │ │ │ - feature.state = null; │ │ │ │ - } │ │ │ │ + filterDelete: function(filter, options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "commit" │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var root = this.format.createElementNSPlus("wfs:Transaction", { │ │ │ │ + attributes: { │ │ │ │ + service: "WFS", │ │ │ │ + version: this.version │ │ │ │ } │ │ │ │ + }); │ │ │ │ │ │ │ │ - if (destroys.length > 0) { │ │ │ │ - this.layer.destroyFeatures(destroys); │ │ │ │ + var deleteNode = this.format.createElementNSPlus("wfs:Delete", { │ │ │ │ + attributes: { │ │ │ │ + typeName: (options.featureNS ? this.featurePrefix + ":" : "") + │ │ │ │ + options.featureType │ │ │ │ } │ │ │ │ + }); │ │ │ │ │ │ │ │ - this.events.triggerEvent("success", evt); │ │ │ │ + if (options.featureNS) { │ │ │ │ + deleteNode.setAttribute("xmlns:" + this.featurePrefix, options.featureNS); │ │ │ │ + } │ │ │ │ + var filterNode = this.format.writeNode("ogc:Filter", filter); │ │ │ │ │ │ │ │ - } else { │ │ │ │ - this.events.triggerEvent("fail", evt); │ │ │ │ + deleteNode.appendChild(filterNode); │ │ │ │ + │ │ │ │ + root.appendChild(deleteNode); │ │ │ │ + │ │ │ │ + var data = OpenLayers.Format.XML.prototype.write.apply( │ │ │ │ + this.format, [root] │ │ │ │ + ); │ │ │ │ + │ │ │ │ + return OpenLayers.Request.POST({ │ │ │ │ + url: this.url, │ │ │ │ + callback: options.callback || function() {}, │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: abort │ │ │ │ + * Abort an ongoing request, the response object passed to │ │ │ │ + * this method must come from this protocol (as a result │ │ │ │ + * of a read, or commit operation). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} │ │ │ │ + */ │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + response.priv.abort(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Save" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.WFS.v1" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Fixed.js │ │ │ │ + OpenLayers/Protocol/WFS/v1_0_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Protocol/WFS/v1.js │ │ │ │ + * @requires OpenLayers/Format/WFST/v1_0_0.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.Fixed │ │ │ │ - * A simple strategy that requests features once and never requests new data. │ │ │ │ + * Class: OpenLayers.Protocol.WFS.v1_0_0 │ │ │ │ + * A WFS v1.0.0 protocol for vector layers. Create a new instance with the │ │ │ │ + * <OpenLayers.Protocol.WFS.v1_0_0> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * - <OpenLayers.Protocol.WFS.v1> │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ +OpenLayers.Protocol.WFS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: preload │ │ │ │ - * {Boolean} Load data before layer made visible. Enabling this may result │ │ │ │ - * in considerable overhead if your application loads many data layers │ │ │ │ - * that are not visible by default. Default is false. │ │ │ │ + * Property: version │ │ │ │ + * {String} WFS version number. │ │ │ │ */ │ │ │ │ - preload: false, │ │ │ │ + version: "1.0.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Fixed │ │ │ │ - * Create a new Fixed strategy. │ │ │ │ + * Constructor: OpenLayers.Protocol.WFS.v1_0_0 │ │ │ │ + * A class for giving layers WFS v1.0.0 protocol. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ * instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the strategy: load data or add listener to load when visible │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ - * the strategy was already active. │ │ │ │ + * Valid options properties: │ │ │ │ + * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ + * featureNS - {String} Feature namespace (optional). │ │ │ │ + * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ + * if featureNS is provided). Default is 'feature'. │ │ │ │ + * geometryName - {String} Name of geometry attribute. Default is 'the_geom'. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "refresh": this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (this.layer.visibility == true || this.preload) { │ │ │ │ - this.load(); │ │ │ │ - } else { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "visibilitychanged": this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivate the strategy. Undo what is done in <activate>. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - "refresh": this.load, │ │ │ │ - "visibilitychanged": this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.WFS.v1_0_0" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Protocol/WFS/v1_1_0.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Protocol/WFS/v1.js │ │ │ │ + * @requires OpenLayers/Format/WFST/v1_1_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol.WFS.v1_1_0 │ │ │ │ + * A WFS v1.1.0 protocol for vector layers. Create a new instance with the │ │ │ │ + * <OpenLayers.Protocol.WFS.v1_1_0> constructor. │ │ │ │ + * │ │ │ │ + * Differences from the v1.0.0 protocol: │ │ │ │ + * - uses Filter Encoding 1.1.0 instead of 1.0.0 │ │ │ │ + * - uses GML 3 instead of 2 if no format is provided │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Protocol.WFS.v1> │ │ │ │ + */ │ │ │ │ +OpenLayers.Protocol.WFS.v1_1_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: load │ │ │ │ - * Tells protocol to load data and unhooks the visibilitychanged event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} options to pass to protocol read. │ │ │ │ + * Property: version │ │ │ │ + * {String} WFS version number. │ │ │ │ */ │ │ │ │ - load: function(options) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.events.triggerEvent("loadstart", { │ │ │ │ - filter: layer.filter │ │ │ │ - }); │ │ │ │ - layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: this.merge, │ │ │ │ - filter: layer.filter, │ │ │ │ - scope: this │ │ │ │ - }, options)); │ │ │ │ - layer.events.un({ │ │ │ │ - "visibilitychanged": this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + version: "1.1.0", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: merge │ │ │ │ - * Add all features to the layer. │ │ │ │ - * If the layer projection differs from the map projection, features │ │ │ │ - * will be transformed from the layer projection to the map projection. │ │ │ │ + * Constructor: OpenLayers.Protocol.WFS.v1_1_0 │ │ │ │ + * A class for giving layers WFS v1.1.0 protocol. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ - * by the protocol. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ + * featureNS - {String} Feature namespace (optional). │ │ │ │ + * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ + * if featureNS is provided). Default is 'feature'. │ │ │ │ + * geometryName - {String} Name of geometry attribute. Default is 'the_geom'. │ │ │ │ + * outputFormat - {String} Optional output format to use for WFS GetFeature │ │ │ │ + * requests. This can be any format advertized by the WFS's │ │ │ │ + * GetCapabilities response. If set, an appropriate readFormat also │ │ │ │ + * has to be provided, unless outputFormat is GML3, GML2 or JSON. │ │ │ │ + * readFormat - {<OpenLayers.Format>} An appropriate format parser if │ │ │ │ + * outputFormat is none of GML3, GML2 or JSON. │ │ │ │ */ │ │ │ │ - merge: function(resp) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.destroyFeatures(); │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = layer.projection; │ │ │ │ - var local = layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.WFS.v1.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.outputFormat && !this.readFormat) { │ │ │ │ + if (this.outputFormat.toLowerCase() == "gml2") { │ │ │ │ + this.readFormat = new OpenLayers.Format.GML.v2({ │ │ │ │ + featureType: this.featureType, │ │ │ │ + featureNS: this.featureNS, │ │ │ │ + geometryName: this.geometryName │ │ │ │ + }); │ │ │ │ + } else if (this.outputFormat.toLowerCase() == "json") { │ │ │ │ + this.readFormat = new OpenLayers.Format.GeoJSON(); │ │ │ │ } │ │ │ │ - layer.addFeatures(features); │ │ │ │ } │ │ │ │ - layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ - }); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.WFS.v1_1_0" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Refresh.js │ │ │ │ + OpenLayers/Protocol/SOS/v1_0_0.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Protocol/SOS.js │ │ │ │ + * @requires OpenLayers/Format/SOSGetFeatureOfInterest.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.Refresh │ │ │ │ - * A strategy that refreshes the layer. By default the strategy waits for a │ │ │ │ - * call to <refresh> before refreshing. By configuring the strategy with │ │ │ │ - * the <interval> option, refreshing can take place automatically. │ │ │ │ + * Class: OpenLayers.Protocol.SOS.v1_0_0 │ │ │ │ + * An SOS v1.0.0 Protocol for vector layers. Create a new instance with the │ │ │ │ + * <OpenLayers.Protocol.SOS.v1_0_0> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * - <OpenLayers.Protocol> │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.Refresh = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: force │ │ │ │ - * {Boolean} Force a refresh on the layer. Default is false. │ │ │ │ - */ │ │ │ │ - force: false, │ │ │ │ +OpenLayers.Protocol.SOS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: interval │ │ │ │ - * {Number} Auto-refresh. Default is 0. If > 0, layer will be refreshed │ │ │ │ - * every N milliseconds. │ │ │ │ + * APIProperty: fois │ │ │ │ + * {Array(String)} Array of features of interest (foi) │ │ │ │ */ │ │ │ │ - interval: 0, │ │ │ │ + fois: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timer │ │ │ │ - * {Number} The id of the timer. │ │ │ │ + * Property: formatOptions │ │ │ │ + * {Object} Optional options for the format. If a format is not provided, │ │ │ │ + * this property can be used to extend the default format options. │ │ │ │ */ │ │ │ │ - timer: null, │ │ │ │ + formatOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Refresh │ │ │ │ - * Create a new Refresh strategy. │ │ │ │ + * Constructor: OpenLayers.Protocol.SOS │ │ │ │ + * A class for giving layers an SOS protocol. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ * instance. │ │ │ │ + * │ │ │ │ + * Valid options properties: │ │ │ │ + * url - {String} URL to send requests to (required). │ │ │ │ + * fois - {Array} The features of interest (required). │ │ │ │ */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully activated. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (this.layer.visibility === true) { │ │ │ │ - this.start(); │ │ │ │ - } │ │ │ │ - this.layer.events.on({ │ │ │ │ - "visibilitychanged": this.reset, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!options.format) { │ │ │ │ + this.format = new OpenLayers.Format.SOSGetFeatureOfInterest( │ │ │ │ + this.formatOptions); │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ - * tear-down. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully deactivated. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.stop(); │ │ │ │ - this.layer.events.un({ │ │ │ │ - "visibilitychanged": this.reset, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + destroy: function() { │ │ │ │ + if (this.options && !this.options.format) { │ │ │ │ + this.format.destroy(); │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + this.format = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: reset │ │ │ │ - * Start or cancel the refresh interval depending on the visibility of │ │ │ │ - * the layer. │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new sensor positions. This is done by │ │ │ │ + * issuing one GetFeatureOfInterest request. │ │ │ │ */ │ │ │ │ - reset: function() { │ │ │ │ - if (this.layer.visibility === true) { │ │ │ │ - this.start(); │ │ │ │ - } else { │ │ │ │ - this.stop(); │ │ │ │ - } │ │ │ │ + read: function(options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + var format = this.format; │ │ │ │ + var data = OpenLayers.Format.XML.prototype.write.apply(format, │ │ │ │ + [format.writeNode("sos:GetFeatureOfInterest", { │ │ │ │ + fois: this.fois │ │ │ │ + })] │ │ │ │ + ); │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, response, options), │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + return response; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: start │ │ │ │ - * Start the refresh interval. │ │ │ │ + * Method: handleRead │ │ │ │ + * Deal with response from the read request. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ + * to the user callback. │ │ │ │ + * options - {Object} The user options passed to the read call. │ │ │ │ */ │ │ │ │ - start: function() { │ │ │ │ - if (this.interval && typeof this.interval === "number" && │ │ │ │ - this.interval > 0) { │ │ │ │ - │ │ │ │ - this.timer = window.setInterval( │ │ │ │ - OpenLayers.Function.bind(this.refresh, this), │ │ │ │ - this.interval); │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + // success │ │ │ │ + response.features = this.parseFeatures(request); │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } else { │ │ │ │ + // failure │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + } │ │ │ │ + options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: refresh │ │ │ │ - * Tell the strategy to refresh which will refresh the layer. │ │ │ │ + * Method: parseFeatures │ │ │ │ + * Read HTTP response body and return features │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * request - {XMLHttpRequest} The request object │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array({<OpenLayers.Feature.Vector>})} Array of features │ │ │ │ */ │ │ │ │ - refresh: function() { │ │ │ │ - if (this.layer && this.layer.refresh && │ │ │ │ - typeof this.layer.refresh == "function") { │ │ │ │ - │ │ │ │ - this.layer.refresh({ │ │ │ │ - force: this.force │ │ │ │ - }); │ │ │ │ + parseFeatures: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: stop │ │ │ │ - * Cancels the refresh interval. │ │ │ │ - */ │ │ │ │ - stop: function() { │ │ │ │ - if (this.timer !== null) { │ │ │ │ - window.clearInterval(this.timer); │ │ │ │ - this.timer = null; │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null; │ │ │ │ } │ │ │ │ + return this.format.read(doc); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Refresh" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.SOS.v1_0_0" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Paging.js │ │ │ │ + OpenLayers/Events/featureclick.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.Paging │ │ │ │ - * Strategy for vector feature paging │ │ │ │ + * Class: OpenLayers.Events.featureclick │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * Extension event type for handling feature click events, including overlapping │ │ │ │ + * features. │ │ │ │ + * │ │ │ │ + * Event types provided by this extension: │ │ │ │ + * - featureclick │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: features │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} Cached features. │ │ │ │ - */ │ │ │ │ - features: null, │ │ │ │ +OpenLayers.Events.featureclick = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: length │ │ │ │ - * {Integer} Number of features per page. Default is 10. │ │ │ │ + * Property: cache │ │ │ │ + * {Object} A cache of features under the mouse. │ │ │ │ */ │ │ │ │ - length: 10, │ │ │ │ + cache: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: num │ │ │ │ - * {Integer} The currently displayed page number. │ │ │ │ + * Property: map │ │ │ │ + * {<OpenLayers.Map>} The map to register browser events on. │ │ │ │ */ │ │ │ │ - num: null, │ │ │ │ + map: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: paging │ │ │ │ - * {Boolean} The strategy is currently changing pages. │ │ │ │ + * Property: provides │ │ │ │ + * {Array(String)} The event types provided by this extension. │ │ │ │ */ │ │ │ │ - paging: false, │ │ │ │ + provides: ["featureclick", "nofeatureclick", "featureover", "featureout"], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Paging │ │ │ │ - * Create a new paging strategy. │ │ │ │ + * Constructor: OpenLayers.Events.featureclick │ │ │ │ + * Create a new featureclick event type. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully activated. │ │ │ │ + * target - {<OpenLayers.Events>} The events instance to create the events │ │ │ │ + * for. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "beforefeaturesadded": this.cacheFeatures, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + initialize: function(target) { │ │ │ │ + this.target = target; │ │ │ │ + if (target.object instanceof OpenLayers.Map) { │ │ │ │ + this.setMap(target.object); │ │ │ │ + } else if (target.object instanceof OpenLayers.Layer.Vector) { │ │ │ │ + if (target.object.map) { │ │ │ │ + this.setMap(target.object.map); │ │ │ │ + } else { │ │ │ │ + target.object.events.register("added", this, function(evt) { │ │ │ │ + this.setMap(target.object.map); │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + throw ("Listeners for '" + this.provides.join("', '") + │ │ │ │ + "' events can only be registered for OpenLayers.Layer.Vector " + │ │ │ │ + "or OpenLayers.Map instances"); │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ - * tear-down. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.layer.events.un({ │ │ │ │ - "beforefeaturesadded": this.cacheFeatures, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ + target.extensions[this.provides[i]] = true; │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cacheFeatures │ │ │ │ - * Cache features before they are added to the layer. │ │ │ │ + * Method: setMap │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * event - {Object} The event that this was listening for. This will come │ │ │ │ - * with a batch of features to be paged. │ │ │ │ - */ │ │ │ │ - cacheFeatures: function(event) { │ │ │ │ - if (!this.paging) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.features = event.features; │ │ │ │ - this.pageNext(event); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clearCache │ │ │ │ - * Clear out the cached features. This destroys features, assuming │ │ │ │ - * nothing else has a reference. │ │ │ │ + * map - {<OpenLayers.Map>} The map to register browser events on. │ │ │ │ */ │ │ │ │ - clearCache: function() { │ │ │ │ - if (this.features) { │ │ │ │ - for (var i = 0; i < this.features.length; ++i) { │ │ │ │ - this.features[i].destroy(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.features = null; │ │ │ │ - this.num = null; │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + this.cache = {}; │ │ │ │ + map.events.register("mousedown", this, this.start, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("mouseup", this, this.onClick, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("touchstart", this, this.start, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("touchmove", this, this.cancel, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("touchend", this, this.onClick, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("mousemove", this, this.onMousemove, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: pageCount │ │ │ │ - * Get the total count of pages given the current cache of features. │ │ │ │ + * Method: start │ │ │ │ + * Sets startEvt = evt. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Integer} The page count. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - pageCount: function() { │ │ │ │ - var numFeatures = this.features ? this.features.length : 0; │ │ │ │ - return Math.ceil(numFeatures / this.length); │ │ │ │ + start: function(evt) { │ │ │ │ + this.startEvt = evt; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: pageNum │ │ │ │ - * Get the zero based page number. │ │ │ │ + * Method: cancel │ │ │ │ + * Deletes the start event. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Integer} The current page number being displayed. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - pageNum: function() { │ │ │ │ - return this.num; │ │ │ │ + cancel: function(evt) { │ │ │ │ + delete this.startEvt; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: pageLength │ │ │ │ - * Gets or sets page length. │ │ │ │ + * Method: onClick │ │ │ │ + * Listener for the click event. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * newLength - {Integer} Optional length to be set. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Integer} The length of a page (number of features per page). │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - pageLength: function(newLength) { │ │ │ │ - if (newLength && newLength > 0) { │ │ │ │ - this.length = newLength; │ │ │ │ + onClick: function(evt) { │ │ │ │ + if (!this.startEvt || evt.type !== "touchend" && │ │ │ │ + !OpenLayers.Event.isLeftClick(evt)) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var features = this.getFeatures(this.startEvt); │ │ │ │ + delete this.startEvt; │ │ │ │ + // fire featureclick events │ │ │ │ + var feature, layer, more, clicked = {}; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + layer = feature.layer; │ │ │ │ + clicked[layer.id] = true; │ │ │ │ + more = this.triggerEvent("featureclick", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (more === false) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // fire nofeatureclick events on all vector layers with no targets │ │ │ │ + for (i = 0, len = this.map.layers.length; i < len; ++i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector && !clicked[layer.id]) { │ │ │ │ + this.triggerEvent("nofeatureclick", { │ │ │ │ + layer: layer │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return this.length; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: pageNext │ │ │ │ - * Display the next page of features. │ │ │ │ + * Method: onMousemove │ │ │ │ + * Listener for the mousemove event. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} A new page was displayed. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - pageNext: function(event) { │ │ │ │ - var changed = false; │ │ │ │ - if (this.features) { │ │ │ │ - if (this.num === null) { │ │ │ │ - this.num = -1; │ │ │ │ + onMousemove: function(evt) { │ │ │ │ + delete this.startEvt; │ │ │ │ + var features = this.getFeatures(evt); │ │ │ │ + var over = {}, │ │ │ │ + newly = [], │ │ │ │ + feature; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + over[feature.id] = feature; │ │ │ │ + if (!this.cache[feature.id]) { │ │ │ │ + newly.push(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // check if already over features │ │ │ │ + var out = []; │ │ │ │ + for (var id in this.cache) { │ │ │ │ + feature = this.cache[id]; │ │ │ │ + if (feature.layer && feature.layer.map) { │ │ │ │ + if (!over[feature.id]) { │ │ │ │ + out.push(feature); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // removed │ │ │ │ + delete this.cache[id]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // fire featureover events │ │ │ │ + var more; │ │ │ │ + for (i = 0, len = newly.length; i < len; ++i) { │ │ │ │ + feature = newly[i]; │ │ │ │ + this.cache[feature.id] = feature; │ │ │ │ + more = this.triggerEvent("featureover", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (more === false) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // fire featureout events │ │ │ │ + for (i = 0, len = out.length; i < len; ++i) { │ │ │ │ + feature = out[i]; │ │ │ │ + delete this.cache[feature.id]; │ │ │ │ + more = this.triggerEvent("featureout", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (more === false) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ - var start = (this.num + 1) * this.length; │ │ │ │ - changed = this.page(start, event); │ │ │ │ } │ │ │ │ - return changed; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: pagePrevious │ │ │ │ - * Display the previous page of features. │ │ │ │ + * Method: triggerEvent │ │ │ │ + * Determines where to trigger the event and triggers it. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * type - {String} The event type to trigger │ │ │ │ + * evt - {Object} The listener argument │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} A new page was displayed. │ │ │ │ + * {Boolean} The last listener return. │ │ │ │ */ │ │ │ │ - pagePrevious: function() { │ │ │ │ - var changed = false; │ │ │ │ - if (this.features) { │ │ │ │ - if (this.num === null) { │ │ │ │ - this.num = this.pageCount(); │ │ │ │ - } │ │ │ │ - var start = (this.num - 1) * this.length; │ │ │ │ - changed = this.page(start); │ │ │ │ + triggerEvent: function(type, evt) { │ │ │ │ + var layer = evt.feature ? evt.feature.layer : evt.layer, │ │ │ │ + object = this.target.object; │ │ │ │ + if (object instanceof OpenLayers.Map || object === layer) { │ │ │ │ + return this.target.triggerEvent(type, evt); │ │ │ │ } │ │ │ │ - return changed; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: page │ │ │ │ - * Display the page starting at the given index from the cache. │ │ │ │ + * Method: getFeatures │ │ │ │ + * Get all features at the given screen location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} Event object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} A new page was displayed. │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} List of features at the given point. │ │ │ │ */ │ │ │ │ - page: function(start, event) { │ │ │ │ - var changed = false; │ │ │ │ - if (this.features) { │ │ │ │ - if (start >= 0 && start < this.features.length) { │ │ │ │ - var num = Math.floor(start / this.length); │ │ │ │ - if (num != this.num) { │ │ │ │ - this.paging = true; │ │ │ │ - var features = this.features.slice(start, start + this.length); │ │ │ │ - this.layer.removeFeatures(this.layer.features); │ │ │ │ - this.num = num; │ │ │ │ - // modify the event if any │ │ │ │ - if (event && event.features) { │ │ │ │ - // this.was called by an event listener │ │ │ │ - event.features = features; │ │ │ │ - } else { │ │ │ │ - // this was called directly on the strategy │ │ │ │ - this.layer.addFeatures(features); │ │ │ │ + getFeatures: function(evt) { │ │ │ │ + var x = evt.clientX, │ │ │ │ + y = evt.clientY, │ │ │ │ + features = [], │ │ │ │ + targets = [], │ │ │ │ + layers = [], │ │ │ │ + layer, target, feature, i, len; │ │ │ │ + // go through all layers looking for targets │ │ │ │ + for (i = this.map.layers.length - 1; i >= 0; --i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (layer.div.style.display !== "none") { │ │ │ │ + if (layer.renderer instanceof OpenLayers.Renderer.Elements) { │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ + target = document.elementFromPoint(x, y); │ │ │ │ + while (target && target._featureId) { │ │ │ │ + feature = layer.getFeatureById(target._featureId); │ │ │ │ + if (feature) { │ │ │ │ + features.push(feature); │ │ │ │ + target.style.display = "none"; │ │ │ │ + targets.push(target); │ │ │ │ + target = document.elementFromPoint(x, y); │ │ │ │ + } else { │ │ │ │ + // sketch, all bets off │ │ │ │ + target = false; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + layers.push(layer); │ │ │ │ + layer.div.style.display = "none"; │ │ │ │ + } else if (layer.renderer instanceof OpenLayers.Renderer.Canvas) { │ │ │ │ + feature = layer.renderer.getFeatureIdFromEvent(evt); │ │ │ │ + if (feature) { │ │ │ │ + features.push(feature); │ │ │ │ + layers.push(layer); │ │ │ │ } │ │ │ │ - this.paging = false; │ │ │ │ - changed = true; │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - return changed; │ │ │ │ + // restore feature visibility │ │ │ │ + for (i = 0, len = targets.length; i < len; ++i) { │ │ │ │ + targets[i].style.display = ""; │ │ │ │ + } │ │ │ │ + // restore layer visibility │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + layers[i].div.style.display = "block"; │ │ │ │ + } │ │ │ │ + return features; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Paging" │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ + delete this.target.extensions[this.provides[i]]; │ │ │ │ + } │ │ │ │ + this.map.events.un({ │ │ │ │ + mousemove: this.onMousemove, │ │ │ │ + mousedown: this.start, │ │ │ │ + mouseup: this.onClick, │ │ │ │ + touchstart: this.start, │ │ │ │ + touchmove: this.cancel, │ │ │ │ + touchend: this.onClick, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + delete this.cache; │ │ │ │ + delete this.map; │ │ │ │ + delete this.target; │ │ │ │ + } │ │ │ │ + │ │ │ │ }); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Events.nofeatureclick │ │ │ │ + * │ │ │ │ + * Extension event type for handling click events that do not hit a feature. │ │ │ │ + * │ │ │ │ + * Event types provided by this extension: │ │ │ │ + * - nofeatureclick │ │ │ │ + */ │ │ │ │ +OpenLayers.Events.nofeatureclick = OpenLayers.Events.featureclick; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Events.featureover │ │ │ │ + * │ │ │ │ + * Extension event type for handling hovering over a feature. │ │ │ │ + * │ │ │ │ + * Event types provided by this extension: │ │ │ │ + * - featureover │ │ │ │ + */ │ │ │ │ +OpenLayers.Events.featureover = OpenLayers.Events.featureclick; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Events.featureout │ │ │ │ + * │ │ │ │ + * Extension event type for handling leaving a feature. │ │ │ │ + * │ │ │ │ + * Event types provided by this extension: │ │ │ │ + * - featureout │ │ │ │ + */ │ │ │ │ +OpenLayers.Events.featureout = OpenLayers.Events.featureclick; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Filter.js │ │ │ │ + OpenLayers/Events/buttonclick.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ - * @requires OpenLayers/Filter.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.Filter │ │ │ │ - * Strategy for limiting features that get added to a layer by │ │ │ │ - * evaluating a filter. The strategy maintains a cache of │ │ │ │ - * all features until removeFeatures is called on the layer. │ │ │ │ + * Class: OpenLayers.Events.buttonclick │ │ │ │ + * Extension event type for handling buttons on top of a dom element. This │ │ │ │ + * event type fires "buttonclick" on its <target> when a button was │ │ │ │ + * clicked. Buttons are detected by the "olButton" class. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * This event type makes sure that button clicks do not interfere with other │ │ │ │ + * events that are registered on the same <element>. │ │ │ │ + * │ │ │ │ + * Event types provided by this extension: │ │ │ │ + * - *buttonclick* Triggered when a button is clicked. Listeners receive an │ │ │ │ + * object with a *buttonElement* property referencing the dom element of │ │ │ │ + * the clicked button, and an *buttonXY* property with the click position │ │ │ │ + * relative to the button. │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.Filter = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ +OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: filter │ │ │ │ - * {<OpenLayers.Filter>} Filter for limiting features sent to the layer. │ │ │ │ - * Use the <setFilter> method to update this filter after construction. │ │ │ │ + * Property: target │ │ │ │ + * {<OpenLayers.Events>} The events instance that the buttonclick event will │ │ │ │ + * be triggered on. │ │ │ │ */ │ │ │ │ - filter: null, │ │ │ │ + target: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: cache │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} List of currently cached │ │ │ │ - * features. │ │ │ │ + * Property: events │ │ │ │ + * {Array} Events to observe and conditionally stop from propagating when │ │ │ │ + * an element with the olButton class (or its olAlphaImg child) is │ │ │ │ + * clicked. │ │ │ │ */ │ │ │ │ - cache: null, │ │ │ │ + events: [ │ │ │ │ + 'mousedown', 'mouseup', 'click', 'dblclick', │ │ │ │ + 'touchstart', 'touchmove', 'touchend', 'keydown' │ │ │ │ + ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: caching │ │ │ │ - * {Boolean} The filter is currently caching features. │ │ │ │ + * Property: startRegEx │ │ │ │ + * {RegExp} Regular expression to test Event.type for events that start │ │ │ │ + * a buttonclick sequence. │ │ │ │ */ │ │ │ │ - caching: false, │ │ │ │ + startRegEx: /^mousedown|touchstart$/, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Filter │ │ │ │ - * Create a new filter strategy. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * Property: cancelRegEx │ │ │ │ + * {RegExp} Regular expression to test Event.type for events that cancel │ │ │ │ + * a buttonclick sequence. │ │ │ │ + */ │ │ │ │ + cancelRegEx: /^touchmove$/, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: completeRegEx │ │ │ │ + * {RegExp} Regular expression to test Event.type for events that complete │ │ │ │ + * a buttonclick sequence. │ │ │ │ */ │ │ │ │ + completeRegEx: /^mouseup|touchend$/, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ - * By default, this strategy automatically activates itself when a layer │ │ │ │ - * is added to a map. │ │ │ │ + * Property: startEvt │ │ │ │ + * {Event} The event that started the click sequence │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Events.buttonclick │ │ │ │ + * Construct a buttonclick event type. Applications are not supposed to │ │ │ │ + * create instances of this class - they are created on demand by │ │ │ │ + * <OpenLayers.Events> instances. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ - * the strategy was already active. │ │ │ │ + * Parameters: │ │ │ │ + * target - {<OpenLayers.Events>} The events instance that the buttonclick │ │ │ │ + * event will be triggered on. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ - if (activated) { │ │ │ │ - this.cache = []; │ │ │ │ - this.layer.events.on({ │ │ │ │ - "beforefeaturesadded": this.handleAdd, │ │ │ │ - "beforefeaturesremoved": this.handleRemove, │ │ │ │ - scope: this │ │ │ │ + initialize: function(target) { │ │ │ │ + this.target = target; │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ + extension: true │ │ │ │ }); │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the strategy. Clear the feature cache. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ - * the strategy was already inactive. │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - this.cache = null; │ │ │ │ - if (this.layer && this.layer.events) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - "beforefeaturesadded": this.handleAdd, │ │ │ │ - "beforefeaturesremoved": this.handleRemove, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.unregister(this.events[i], this, this.buttonClick); │ │ │ │ } │ │ │ │ - return OpenLayers.Strategy.prototype.deactivate.apply(this, arguments); │ │ │ │ + delete this.target; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleAdd │ │ │ │ + * Method: getPressedButton │ │ │ │ + * Get the pressed button, if any. Returns undefined if no button │ │ │ │ + * was pressed. │ │ │ │ + * │ │ │ │ + * Arguments: │ │ │ │ + * element - {DOMElement} The event target. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The button element, or undefined. │ │ │ │ */ │ │ │ │ - handleAdd: function(event) { │ │ │ │ - if (!this.caching && this.filter) { │ │ │ │ - var features = event.features; │ │ │ │ - event.features = []; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0, ii = features.length; i < ii; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (this.filter.evaluate(feature)) { │ │ │ │ - event.features.push(feature); │ │ │ │ - } else { │ │ │ │ - this.cache.push(feature); │ │ │ │ - } │ │ │ │ + getPressedButton: function(element) { │ │ │ │ + var depth = 3, // limit the search depth │ │ │ │ + button; │ │ │ │ + do { │ │ │ │ + if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ + // hit! │ │ │ │ + button = element; │ │ │ │ + break; │ │ │ │ } │ │ │ │ - } │ │ │ │ + element = element.parentNode; │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return button; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRemove │ │ │ │ + * Method: ignore │ │ │ │ + * Check for event target elements that should be ignored by OpenLayers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * element - {DOMElement} The event target. │ │ │ │ */ │ │ │ │ - handleRemove: function(event) { │ │ │ │ - if (!this.caching) { │ │ │ │ - this.cache = []; │ │ │ │ - } │ │ │ │ + ignore: function(element) { │ │ │ │ + var depth = 3, │ │ │ │ + ignore = false; │ │ │ │ + do { │ │ │ │ + if (element.nodeName.toLowerCase() === 'a') { │ │ │ │ + ignore = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + element = element.parentNode; │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return ignore; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setFilter │ │ │ │ - * Update the filter for this strategy. This will re-evaluate │ │ │ │ - * any features on the layer and in the cache. Only features │ │ │ │ - * for which filter.evalute(feature) returns true will be │ │ │ │ - * added to the layer. Others will be cached by the strategy. │ │ │ │ + /** │ │ │ │ + * Method: buttonClick │ │ │ │ + * Check if a button was clicked, and fire the buttonclick event │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} A filter for evaluating features. │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - setFilter: function(filter) { │ │ │ │ - this.filter = filter; │ │ │ │ - var previousCache = this.cache; │ │ │ │ - this.cache = []; │ │ │ │ - // look through layer for features to remove from layer │ │ │ │ - this.handleAdd({ │ │ │ │ - features: this.layer.features │ │ │ │ - }); │ │ │ │ - // cache now contains features to remove from layer │ │ │ │ - if (this.cache.length > 0) { │ │ │ │ - this.caching = true; │ │ │ │ - this.layer.removeFeatures(this.cache.slice()); │ │ │ │ - this.caching = false; │ │ │ │ - } │ │ │ │ - // now look through previous cache for features to add to layer │ │ │ │ - if (previousCache.length > 0) { │ │ │ │ - var event = { │ │ │ │ - features: previousCache │ │ │ │ - }; │ │ │ │ - this.handleAdd(event); │ │ │ │ - if (event.features.length > 0) { │ │ │ │ - // event has features to add to layer │ │ │ │ - this.caching = true; │ │ │ │ - this.layer.addFeatures(event.features); │ │ │ │ - this.caching = false; │ │ │ │ + buttonClick: function(evt) { │ │ │ │ + var propagate = true, │ │ │ │ + element = OpenLayers.Event.element(evt); │ │ │ │ + if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ + // was a button pressed? │ │ │ │ + var button = this.getPressedButton(element); │ │ │ │ + if (button) { │ │ │ │ + if (evt.type === "keydown") { │ │ │ │ + switch (evt.keyCode) { │ │ │ │ + case OpenLayers.Event.KEY_RETURN: │ │ │ │ + case OpenLayers.Event.KEY_SPACE: │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button │ │ │ │ + }); │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (this.startEvt) { │ │ │ │ + if (this.completeRegEx.test(evt.type)) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ + var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ + var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ + var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ + pos[0] = pos[0] - scrollLeft; │ │ │ │ + pos[1] = pos[1] - scrollTop; │ │ │ │ + │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button, │ │ │ │ + buttonXY: { │ │ │ │ + x: this.startEvt.clientX - pos[0], │ │ │ │ + y: this.startEvt.clientY - pos[1] │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (this.cancelRegEx.test(evt.type)) { │ │ │ │ + delete this.startEvt; │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + } │ │ │ │ + if (this.startRegEx.test(evt.type)) { │ │ │ │ + this.startEvt = evt; │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ + delete this.startEvt; │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Filter" │ │ │ │ + return propagate; │ │ │ │ + } │ │ │ │ │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Renderer/Elements.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ @@ -67281,1035 +70118,1004 @@ │ │ │ │ return (graphicName != "circle") && !!graphicName; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Renderer.Elements" │ │ │ │ }); │ │ │ │ │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Renderer/SVG.js │ │ │ │ + OpenLayers/Renderer/VML.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Renderer/Elements.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Renderer.SVG │ │ │ │ + * Class: OpenLayers.Renderer.VML │ │ │ │ + * Render vector features in browsers with VML capability. Construct a new │ │ │ │ + * VML renderer with the <OpenLayers.Renderer.VML> constructor. │ │ │ │ * │ │ │ │ - * Inherits: │ │ │ │ + * Note that for all calculations in this class, we use (num | 0) to truncate a │ │ │ │ + * float value to an integer. This is done because it seems that VML doesn't │ │ │ │ + * support float values. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ * - <OpenLayers.Renderer.Elements> │ │ │ │ */ │ │ │ │ -OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: xmlns │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - xmlns: "http://www.w3.org/2000/svg", │ │ │ │ +OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: xlinkns │ │ │ │ - * {String} │ │ │ │ + * Property: xmlns │ │ │ │ + * {String} XML Namespace URN │ │ │ │ */ │ │ │ │ - xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ + xmlns: "urn:schemas-microsoft-com:vml", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: MAX_PIXEL │ │ │ │ - * {Integer} Firefox has a limitation where values larger or smaller than │ │ │ │ - * about 15000 in an SVG document lock the browser up. This │ │ │ │ - * works around it. │ │ │ │ + * Property: symbolCache │ │ │ │ + * {DOMElement} node holding symbols. This hash is keyed by symbol name, │ │ │ │ + * and each value is a hash with a "path" and an "extent" property. │ │ │ │ */ │ │ │ │ - MAX_PIXEL: 15000, │ │ │ │ + symbolCache: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: translationParameters │ │ │ │ + * Property: offset │ │ │ │ * {Object} Hash with "x" and "y" properties │ │ │ │ */ │ │ │ │ - translationParameters: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: symbolMetrics │ │ │ │ - * {Object} Cache for symbol metrics according to their svg coordinate │ │ │ │ - * space. This is an object keyed by the symbol's id, and values are │ │ │ │ - * an array of [width, centerX, centerY]. │ │ │ │ - */ │ │ │ │ - symbolMetrics: null, │ │ │ │ + offset: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Renderer.SVG │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Renderer.VML │ │ │ │ + * Create a new VML renderer. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * containerID - {String} │ │ │ │ + * containerID - {String} The id for the element that contains the renderer │ │ │ │ */ │ │ │ │ initialize: function(containerID) { │ │ │ │ if (!this.supported()) { │ │ │ │ return; │ │ │ │ } │ │ │ │ + if (!document.namespaces.olv) { │ │ │ │ + document.namespaces.add("olv", this.xmlns); │ │ │ │ + var style = document.createStyleSheet(); │ │ │ │ + var shapes = ['shape', 'rect', 'oval', 'fill', 'stroke', 'imagedata', 'group', 'textbox']; │ │ │ │ + for (var i = 0, len = shapes.length; i < len; i++) { │ │ │ │ + │ │ │ │ + style.addRule('olv\\:' + shapes[i], "behavior: url(#default#VML); " + │ │ │ │ + "position: absolute; display: inline-block;"); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ OpenLayers.Renderer.Elements.prototype.initialize.apply(this, │ │ │ │ arguments); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: 0, │ │ │ │ - y: 0 │ │ │ │ - }; │ │ │ │ - │ │ │ │ - this.symbolMetrics = {}; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: supported │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the browser supports the SVG renderer │ │ │ │ - */ │ │ │ │ - supported: function() { │ │ │ │ - var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ - return (document.implementation && │ │ │ │ - (document.implementation.hasFeature("org.w3c.svg", "1.0") || │ │ │ │ - document.implementation.hasFeature(svgFeature + "SVG", "1.1") || │ │ │ │ - document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1"))); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: inValidRange │ │ │ │ - * See #669 for more information │ │ │ │ + * Determine whether a browser supports this renderer. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Integer} │ │ │ │ - * y - {Integer} │ │ │ │ - * xyOnly - {Boolean} whether or not to just check for x and y, which means │ │ │ │ - * to not take the current translation parameters into account if true. │ │ │ │ - * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Whether or not the 'x' and 'y' coordinates are in the │ │ │ │ - * valid range. │ │ │ │ + * {Boolean} The browser supports the VML renderer │ │ │ │ */ │ │ │ │ - inValidRange: function(x, y, xyOnly) { │ │ │ │ - var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ - var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ - return (left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && │ │ │ │ - top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL); │ │ │ │ + supported: function() { │ │ │ │ + return !!(document.namespaces); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: setExtent │ │ │ │ - * │ │ │ │ + * Set the renderer's extent │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * extent - {<OpenLayers.Bounds>} │ │ │ │ * resolutionChanged - {Boolean} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ * {Boolean} true to notify the layer that the new extent does not exceed │ │ │ │ * the coordinate range, and the features will not need to be redrawn. │ │ │ │ - * False otherwise. │ │ │ │ */ │ │ │ │ setExtent: function(extent, resolutionChanged) { │ │ │ │ var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ │ │ │ │ - var resolution = this.getResolution(), │ │ │ │ - left = -extent.left / resolution, │ │ │ │ - top = extent.top / resolution; │ │ │ │ - │ │ │ │ - // If the resolution has changed, start over changing the corner, because │ │ │ │ - // the features will redraw. │ │ │ │ - if (resolutionChanged) { │ │ │ │ - this.left = left; │ │ │ │ - this.top = top; │ │ │ │ - // Set the viewbox │ │ │ │ - var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ - │ │ │ │ - this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ - this.translate(this.xOffset, 0); │ │ │ │ - return true; │ │ │ │ + var left = (extent.left / resolution) | 0; │ │ │ │ + var top = (extent.top / resolution - this.size.h) | 0; │ │ │ │ + if (resolutionChanged || !this.offset) { │ │ │ │ + this.offset = { │ │ │ │ + x: left, │ │ │ │ + y: top │ │ │ │ + }; │ │ │ │ + left = 0; │ │ │ │ + top = 0; │ │ │ │ } else { │ │ │ │ - var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ - if (!inRange) { │ │ │ │ - // recenter the coordinate system │ │ │ │ - this.setExtent(extent, true); │ │ │ │ - } │ │ │ │ - return coordSysUnchanged && inRange; │ │ │ │ + left = left - this.offset.x; │ │ │ │ + top = top - this.offset.y; │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: translate │ │ │ │ - * Transforms the SVG coordinate system │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Float} │ │ │ │ - * y - {Float} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} true if the translation parameters are in the valid coordinates │ │ │ │ - * range, false otherwise. │ │ │ │ - */ │ │ │ │ - translate: function(x, y) { │ │ │ │ - if (!this.inValidRange(x, y, true)) { │ │ │ │ - return false; │ │ │ │ - } else { │ │ │ │ - var transformString = ""; │ │ │ │ - if (x || y) { │ │ │ │ - transformString = "translate(" + x + "," + y + ")"; │ │ │ │ - } │ │ │ │ - this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: x, │ │ │ │ - y: y │ │ │ │ - }; │ │ │ │ - return true; │ │ │ │ + │ │ │ │ + var org = (left - this.xOffset) + " " + top; │ │ │ │ + this.root.coordorigin = org; │ │ │ │ + var roots = [this.root, this.vectorRoot, this.textRoot]; │ │ │ │ + var root; │ │ │ │ + for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ + root = roots[i]; │ │ │ │ + │ │ │ │ + var size = this.size.w + " " + this.size.h; │ │ │ │ + root.coordsize = size; │ │ │ │ + │ │ │ │ } │ │ │ │ + // flip the VML display Y axis upside down so it │ │ │ │ + // matches the display Y axis of the map │ │ │ │ + this.root.style.flip = "y"; │ │ │ │ + │ │ │ │ + return coordSysUnchanged; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ * Method: setSize │ │ │ │ - * Sets the size of the drawing surface. │ │ │ │ - * │ │ │ │ + * Set the size of the drawing surface │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * size - {<OpenLayers.Size>} The size of the drawing surface │ │ │ │ + * size - {<OpenLayers.Size>} the size of the drawing surface │ │ │ │ */ │ │ │ │ setSize: function(size) { │ │ │ │ OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ │ │ │ │ - this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ - this.rendererRoot.setAttributeNS(null, "height", this.size.h); │ │ │ │ + // setting width and height on all roots to avoid flicker which we │ │ │ │ + // would get with 100% width and height on child roots │ │ │ │ + var roots = [ │ │ │ │ + this.rendererRoot, │ │ │ │ + this.root, │ │ │ │ + this.vectorRoot, │ │ │ │ + this.textRoot │ │ │ │ + ]; │ │ │ │ + var w = this.size.w + "px"; │ │ │ │ + var h = this.size.h + "px"; │ │ │ │ + var root; │ │ │ │ + for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ + root = roots[i]; │ │ │ │ + root.style.width = w; │ │ │ │ + root.style.height = h; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getNodeType │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: getNodeType │ │ │ │ + * Get the node type for a geometry and style │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * style - {Object} │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {String} The corresponding node type for the specified geometry │ │ │ │ */ │ │ │ │ getNodeType: function(geometry, style) { │ │ │ │ var nodeType = null; │ │ │ │ switch (geometry.CLASS_NAME) { │ │ │ │ case "OpenLayers.Geometry.Point": │ │ │ │ if (style.externalGraphic) { │ │ │ │ - nodeType = "image"; │ │ │ │ + nodeType = "olv:rect"; │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "svg"; │ │ │ │ + nodeType = "olv:shape"; │ │ │ │ } else { │ │ │ │ - nodeType = "circle"; │ │ │ │ + nodeType = "olv:oval"; │ │ │ │ } │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "rect"; │ │ │ │ + nodeType = "olv:rect"; │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.LineString": │ │ │ │ - nodeType = "polyline"; │ │ │ │ - break; │ │ │ │ case "OpenLayers.Geometry.LinearRing": │ │ │ │ - nodeType = "polygon"; │ │ │ │ - break; │ │ │ │ case "OpenLayers.Geometry.Polygon": │ │ │ │ case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "path"; │ │ │ │ + nodeType = "olv:shape"; │ │ │ │ break; │ │ │ │ default: │ │ │ │ break; │ │ │ │ } │ │ │ │ return nodeType; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: setStyle │ │ │ │ - * Use to set all the style attributes to a SVG node. │ │ │ │ - * │ │ │ │ - * Takes care to adjust stroke width and point radius to be │ │ │ │ - * resolution-relative │ │ │ │ + * Use to set all the style attributes to a VML node. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {SVGDomElement} An SVG element to decorate │ │ │ │ + * node - {DOMElement} An VML element to decorate │ │ │ │ * style - {Object} │ │ │ │ * options - {Object} Currently supported options include │ │ │ │ * 'isFilled' {Boolean} and │ │ │ │ * 'isStroked' {Boolean} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - setStyle: function(node, style, options) { │ │ │ │ + setStyle: function(node, style, options, geometry) { │ │ │ │ style = style || node._style; │ │ │ │ options = options || node._options; │ │ │ │ + var fillColor = style.fillColor; │ │ │ │ │ │ │ │ var title = style.title || style.graphicTitle; │ │ │ │ if (title) { │ │ │ │ - node.setAttributeNS(null, "title", title); │ │ │ │ - //Standards-conformant SVG │ │ │ │ - // Prevent duplicate nodes. See issue https://github.com/openlayers/openlayers/issues/92 │ │ │ │ - var titleNode = node.getElementsByTagName("title"); │ │ │ │ - if (titleNode.length > 0) { │ │ │ │ - titleNode[0].firstChild.textContent = title; │ │ │ │ - } else { │ │ │ │ - var label = this.nodeFactory(null, "title"); │ │ │ │ - label.textContent = title; │ │ │ │ - node.appendChild(label); │ │ │ │ - } │ │ │ │ + node.title = title; │ │ │ │ } │ │ │ │ │ │ │ │ - var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ - var widthFactor = 1; │ │ │ │ - var pos; │ │ │ │ - if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ - node.style.visibility = ""; │ │ │ │ - if (style.graphic === false) { │ │ │ │ - node.style.visibility = "hidden"; │ │ │ │ - } else if (style.externalGraphic) { │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - if (style.graphicWidth && style.graphicHeight) { │ │ │ │ - node.setAttributeNS(null, "preserveAspectRatio", "none"); │ │ │ │ - } │ │ │ │ + if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + options.isFilled = true; │ │ │ │ var width = style.graphicWidth || style.graphicHeight; │ │ │ │ var height = style.graphicHeight || style.graphicWidth; │ │ │ │ width = width ? width : style.pointRadius * 2; │ │ │ │ height = height ? height : style.pointRadius * 2; │ │ │ │ + │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ var xOffset = (style.graphicXOffset != undefined) ? │ │ │ │ style.graphicXOffset : -(0.5 * width); │ │ │ │ var yOffset = (style.graphicYOffset != undefined) ? │ │ │ │ style.graphicYOffset : -(0.5 * height); │ │ │ │ │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ + node.style.left = ((((geometry.x - this.featureDx) / resolution - this.offset.x) + xOffset) | 0) + "px"; │ │ │ │ + node.style.top = (((geometry.y / resolution - this.offset.y) - (yOffset + height)) | 0) + "px"; │ │ │ │ + node.style.width = width + "px"; │ │ │ │ + node.style.height = height + "px"; │ │ │ │ + node.style.flip = "y"; │ │ │ │ │ │ │ │ - node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "width", width); │ │ │ │ - node.setAttributeNS(null, "height", height); │ │ │ │ - node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ - node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ - node.onclick = OpenLayers.Event.preventDefault; │ │ │ │ + // modify fillColor and options for stroke styling below │ │ │ │ + fillColor = "none"; │ │ │ │ + options.isStroked = false; │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - // the symbol viewBox is three times as large as the symbol │ │ │ │ - var offset = style.pointRadius * 3; │ │ │ │ - var size = offset * 2; │ │ │ │ - var src = this.importSymbol(style.graphicName); │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ - │ │ │ │ - // remove the node from the dom before we modify it. This │ │ │ │ - // prevents various rendering issues in Safari and FF │ │ │ │ - var parent = node.parentNode; │ │ │ │ - var nextSibling = node.nextSibling; │ │ │ │ - if (parent) { │ │ │ │ - parent.removeChild(node); │ │ │ │ - } │ │ │ │ + var cache = this.importSymbol(style.graphicName); │ │ │ │ + node.path = cache.path; │ │ │ │ + node.coordorigin = cache.left + "," + cache.bottom; │ │ │ │ + var size = cache.size; │ │ │ │ + node.coordsize = size + "," + size; │ │ │ │ + this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ + node.style.flip = "y"; │ │ │ │ + } else { │ │ │ │ + this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - // The more appropriate way to implement this would be use/defs, │ │ │ │ - // but due to various issues in several browsers, it is safer to │ │ │ │ - // copy the symbols instead of referencing them. │ │ │ │ - // See e.g. ticket http://trac.osgeo.org/openlayers/ticket/2985 │ │ │ │ - // and this email thread │ │ │ │ - // http://osgeo-org.1803224.n2.nabble.com/Select-Control-Ctrl-click-on-Feature-with-a-graphicName-opens-new-browser-window-tc5846039.html │ │ │ │ - node.firstChild && node.removeChild(node.firstChild); │ │ │ │ - node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ - node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ + // fill │ │ │ │ + if (options.isFilled) { │ │ │ │ + node.fillcolor = fillColor; │ │ │ │ + } else { │ │ │ │ + node.filled = "false"; │ │ │ │ + } │ │ │ │ + var fills = node.getElementsByTagName("fill"); │ │ │ │ + var fill = (fills.length == 0) ? null : fills[0]; │ │ │ │ + if (!options.isFilled) { │ │ │ │ + if (fill) { │ │ │ │ + node.removeChild(fill); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!fill) { │ │ │ │ + fill = this.createNode('olv:fill', node.id + "_fill"); │ │ │ │ + } │ │ │ │ + fill.opacity = style.fillOpacity; │ │ │ │ │ │ │ │ - node.setAttributeNS(null, "width", size); │ │ │ │ - node.setAttributeNS(null, "height", size); │ │ │ │ - node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ - node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ + if (node._geometryClass === "OpenLayers.Geometry.Point" && │ │ │ │ + style.externalGraphic) { │ │ │ │ │ │ │ │ - // now that the node has all its new properties, insert it │ │ │ │ - // back into the dom where it was │ │ │ │ - if (nextSibling) { │ │ │ │ - parent.insertBefore(node, nextSibling); │ │ │ │ - } else if (parent) { │ │ │ │ - parent.appendChild(node); │ │ │ │ + // override fillOpacity │ │ │ │ + if (style.graphicOpacity) { │ │ │ │ + fill.opacity = style.graphicOpacity; │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "r", style.pointRadius); │ │ │ │ - } │ │ │ │ │ │ │ │ - var rotation = style.rotation; │ │ │ │ + fill.src = style.externalGraphic; │ │ │ │ + fill.type = "frame"; │ │ │ │ │ │ │ │ - if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - rotation |= 0; │ │ │ │ - if (node.nodeName !== "svg") { │ │ │ │ - node.setAttributeNS(null, "transform", │ │ │ │ - "rotate(" + rotation + " " + pos.x + " " + │ │ │ │ - pos.y + ")"); │ │ │ │ - } else { │ │ │ │ - var metrics = this.symbolMetrics[src.id]; │ │ │ │ - node.firstChild.setAttributeNS(null, "transform", "rotate(" + │ │ │ │ - rotation + " " + │ │ │ │ - metrics[1] + " " + │ │ │ │ - metrics[2] + ")"); │ │ │ │ + if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ + fill.aspect = "atmost"; │ │ │ │ } │ │ │ │ } │ │ │ │ + if (fill.parentNode != node) { │ │ │ │ + node.appendChild(fill); │ │ │ │ + } │ │ │ │ } │ │ │ │ │ │ │ │ - if (options.isFilled) { │ │ │ │ - node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ - node.setAttributeNS(null, "fill-opacity", style.fillOpacity); │ │ │ │ + // additional rendering for rotated graphics or symbols │ │ │ │ + var rotation = style.rotation; │ │ │ │ + if ((rotation !== undefined || node._rotation !== undefined)) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ + // make the fill fully transparent, because we now have │ │ │ │ + // the graphic as imagedata element. We cannot just remove │ │ │ │ + // the fill, because this is part of the hack described │ │ │ │ + // in graphicRotate │ │ │ │ + fill.opacity = 0; │ │ │ │ + } else if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ + node.style.rotation = rotation || 0; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // stroke │ │ │ │ + var strokes = node.getElementsByTagName("stroke"); │ │ │ │ + var stroke = (strokes.length == 0) ? null : strokes[0]; │ │ │ │ + if (!options.isStroked) { │ │ │ │ + node.stroked = false; │ │ │ │ + if (stroke) { │ │ │ │ + stroke.on = false; │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - node.setAttributeNS(null, "fill", "none"); │ │ │ │ + if (!stroke) { │ │ │ │ + stroke = this.createNode('olv:stroke', node.id + "_stroke"); │ │ │ │ + node.appendChild(stroke); │ │ │ │ + } │ │ │ │ + stroke.on = true; │ │ │ │ + stroke.color = style.strokeColor; │ │ │ │ + stroke.weight = style.strokeWidth + "px"; │ │ │ │ + stroke.opacity = style.strokeOpacity; │ │ │ │ + stroke.endcap = style.strokeLinecap == 'butt' ? 'flat' : │ │ │ │ + (style.strokeLinecap || 'round'); │ │ │ │ + if (style.strokeDashstyle) { │ │ │ │ + stroke.dashstyle = this.dashStyle(style); │ │ │ │ + } │ │ │ │ } │ │ │ │ │ │ │ │ - if (options.isStroked) { │ │ │ │ - node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ - node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ - node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ - node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ - // Hard-coded linejoin for now, to make it look the same as in VML. │ │ │ │ - // There is no strokeLinejoin property yet for symbolizers. │ │ │ │ - node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ - style.strokeDashstyle && node.setAttributeNS(null, │ │ │ │ - "stroke-dasharray", this.dashStyle(style, widthFactor)); │ │ │ │ + if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ + node.style.cursor = style.cursor; │ │ │ │ + } │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: graphicRotate │ │ │ │ + * If a point is to be styled with externalGraphic and rotation, VML fills │ │ │ │ + * cannot be used to display the graphic, because rotation of graphic │ │ │ │ + * fills is not supported by the VML implementation of Internet Explorer. │ │ │ │ + * This method creates a olv:imagedata element inside the VML node, │ │ │ │ + * DXImageTransform.Matrix and BasicImage filters for rotation and │ │ │ │ + * opacity, and a 3-step hack to remove rendering artefacts from the │ │ │ │ + * graphic and preserve the ability of graphics to trigger events. │ │ │ │ + * Finally, OpenLayers methods are used to determine the correct │ │ │ │ + * insertion point of the rotated image, because DXImageTransform.Matrix │ │ │ │ + * does the rotation without the ability to specify a rotation center │ │ │ │ + * point. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * xOffset - {Number} rotation center relative to image, x coordinate │ │ │ │ + * yOffset - {Number} rotation center relative to image, y coordinate │ │ │ │ + * style - {Object} │ │ │ │ + */ │ │ │ │ + graphicRotate: function(node, xOffset, yOffset, style) { │ │ │ │ + var style = style || node._style; │ │ │ │ + var rotation = style.rotation || 0; │ │ │ │ + │ │ │ │ + var aspectRatio, size; │ │ │ │ + if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ + // load the image to determine its size │ │ │ │ + var img = new Image(); │ │ │ │ + img.onreadystatechange = OpenLayers.Function.bind(function() { │ │ │ │ + if (img.readyState == "complete" || │ │ │ │ + img.readyState == "interactive") { │ │ │ │ + aspectRatio = img.width / img.height; │ │ │ │ + size = Math.max(style.pointRadius * 2, │ │ │ │ + style.graphicWidth || 0, │ │ │ │ + style.graphicHeight || 0); │ │ │ │ + xOffset = xOffset * aspectRatio; │ │ │ │ + style.graphicWidth = size * aspectRatio; │ │ │ │ + style.graphicHeight = size; │ │ │ │ + this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ + } │ │ │ │ + }, this); │ │ │ │ + img.src = style.externalGraphic; │ │ │ │ + │ │ │ │ + // will be called again by the onreadystate handler │ │ │ │ + return; │ │ │ │ } else { │ │ │ │ - node.setAttributeNS(null, "stroke", "none"); │ │ │ │ + size = Math.max(style.graphicWidth, style.graphicHeight); │ │ │ │ + aspectRatio = style.graphicWidth / style.graphicHeight; │ │ │ │ } │ │ │ │ │ │ │ │ - if (style.pointerEvents) { │ │ │ │ - node.setAttributeNS(null, "pointer-events", style.pointerEvents); │ │ │ │ + var width = Math.round(style.graphicWidth || size * aspectRatio); │ │ │ │ + var height = Math.round(style.graphicHeight || size); │ │ │ │ + node.style.width = width + "px"; │ │ │ │ + node.style.height = height + "px"; │ │ │ │ + │ │ │ │ + // Three steps are required to remove artefacts for images with │ │ │ │ + // transparent backgrounds (resulting from using DXImageTransform │ │ │ │ + // filters on svg objects), while preserving awareness for browser │ │ │ │ + // events on images: │ │ │ │ + // - Use the fill as usual (like for unrotated images) to handle │ │ │ │ + // events │ │ │ │ + // - specify an imagedata element with the same src as the fill │ │ │ │ + // - style the imagedata element with an AlphaImageLoader filter │ │ │ │ + // with empty src │ │ │ │ + var image = document.getElementById(node.id + "_image"); │ │ │ │ + if (!image) { │ │ │ │ + image = this.createNode("olv:imagedata", node.id + "_image"); │ │ │ │ + node.appendChild(image); │ │ │ │ } │ │ │ │ + image.style.width = width + "px"; │ │ │ │ + image.style.height = height + "px"; │ │ │ │ + image.src = style.externalGraphic; │ │ │ │ + image.style.filter = │ │ │ │ + "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + │ │ │ │ + "src='', sizingMethod='scale')"; │ │ │ │ │ │ │ │ - if (style.cursor != null) { │ │ │ │ - node.setAttributeNS(null, "cursor", style.cursor); │ │ │ │ + var rot = rotation * Math.PI / 180; │ │ │ │ + var sintheta = Math.sin(rot); │ │ │ │ + var costheta = Math.cos(rot); │ │ │ │ + │ │ │ │ + // do the rotation on the image │ │ │ │ + var filter = │ │ │ │ + "progid:DXImageTransform.Microsoft.Matrix(M11=" + costheta + │ │ │ │ + ",M12=" + (-sintheta) + ",M21=" + sintheta + ",M22=" + costheta + │ │ │ │ + ",SizingMethod='auto expand')\n"; │ │ │ │ + │ │ │ │ + // set the opacity (needed for the imagedata) │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ + if (opacity && opacity != 1) { │ │ │ │ + filter += │ │ │ │ + "progid:DXImageTransform.Microsoft.BasicImage(opacity=" + │ │ │ │ + opacity + ")\n"; │ │ │ │ } │ │ │ │ + node.style.filter = filter; │ │ │ │ │ │ │ │ - return node; │ │ │ │ + // do the rotation again on a box, so we know the insertion point │ │ │ │ + var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset); │ │ │ │ + var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry(); │ │ │ │ + imgBox.rotate(style.rotation, centerPoint); │ │ │ │ + var imgBounds = imgBox.getBounds(); │ │ │ │ + │ │ │ │ + node.style.left = Math.round( │ │ │ │ + parseInt(node.style.left) + imgBounds.left) + "px"; │ │ │ │ + node.style.top = Math.round( │ │ │ │ + parseInt(node.style.top) - imgBounds.bottom) + "px"; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: postDraw │ │ │ │ + * Does some node postprocessing to work around browser issues: │ │ │ │ + * - Some versions of Internet Explorer seem to be unable to set fillcolor │ │ │ │ + * and strokecolor to "none" correctly before the fill node is appended │ │ │ │ + * to a visible vml node. This method takes care of that and sets │ │ │ │ + * fillcolor and strokecolor again if needed. │ │ │ │ + * - In some cases, a node won't become visible after being drawn. Setting │ │ │ │ + * style.visibility to "visible" works around that. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + */ │ │ │ │ + postDraw: function(node) { │ │ │ │ + node.style.visibility = "visible"; │ │ │ │ + var fillColor = node._style.fillColor; │ │ │ │ + var strokeColor = node._style.strokeColor; │ │ │ │ + if (fillColor == "none" && │ │ │ │ + node.fillcolor != fillColor) { │ │ │ │ + node.fillcolor = fillColor; │ │ │ │ + } │ │ │ │ + if (strokeColor == "none" && │ │ │ │ + node.strokecolor != strokeColor) { │ │ │ │ + node.strokecolor = strokeColor; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setNodeDimension │ │ │ │ + * Get the geometry's bounds, convert it to our vml coordinate system, │ │ │ │ + * then set the node's position, size, and local coordinate system. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + */ │ │ │ │ + setNodeDimension: function(node, geometry) { │ │ │ │ + │ │ │ │ + var bbox = geometry.getBounds(); │ │ │ │ + if (bbox) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + │ │ │ │ + var scaledBox = │ │ │ │ + new OpenLayers.Bounds(((bbox.left - this.featureDx) / resolution - this.offset.x) | 0, │ │ │ │ + (bbox.bottom / resolution - this.offset.y) | 0, │ │ │ │ + ((bbox.right - this.featureDx) / resolution - this.offset.x) | 0, │ │ │ │ + (bbox.top / resolution - this.offset.y) | 0); │ │ │ │ + │ │ │ │ + // Set the internal coordinate system to draw the path │ │ │ │ + node.style.left = scaledBox.left + "px"; │ │ │ │ + node.style.top = scaledBox.top + "px"; │ │ │ │ + node.style.width = scaledBox.getWidth() + "px"; │ │ │ │ + node.style.height = scaledBox.getHeight() + "px"; │ │ │ │ + │ │ │ │ + node.coordorigin = scaledBox.left + " " + scaledBox.top; │ │ │ │ + node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: dashStyle │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * style - {Object} │ │ │ │ - * widthFactor - {Number} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A SVG compliant 'stroke-dasharray' value │ │ │ │ + * {String} A VML compliant 'stroke-dasharray' value │ │ │ │ */ │ │ │ │ - dashStyle: function(style, widthFactor) { │ │ │ │ - var w = style.strokeWidth * widthFactor; │ │ │ │ - var str = style.strokeDashstyle; │ │ │ │ - switch (str) { │ │ │ │ + dashStyle: function(style) { │ │ │ │ + var dash = style.strokeDashstyle; │ │ │ │ + switch (dash) { │ │ │ │ case 'solid': │ │ │ │ - return 'none'; │ │ │ │ case 'dot': │ │ │ │ - return [1, 4 * w].join(); │ │ │ │ case 'dash': │ │ │ │ - return [4 * w, 4 * w].join(); │ │ │ │ case 'dashdot': │ │ │ │ - return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ case 'longdash': │ │ │ │ - return [8 * w, 4 * w].join(); │ │ │ │ case 'longdashdot': │ │ │ │ - return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ + return dash; │ │ │ │ default: │ │ │ │ - return OpenLayers.String.trim(str).replace(/\s+/g, ","); │ │ │ │ + // very basic guessing of dash style patterns │ │ │ │ + var parts = dash.split(/[ ,]/); │ │ │ │ + if (parts.length == 2) { │ │ │ │ + if (1 * parts[0] >= 2 * parts[1]) { │ │ │ │ + return "longdash"; │ │ │ │ + } │ │ │ │ + return (parts[0] == 1 || parts[1] == 1) ? "dot" : "dash"; │ │ │ │ + } else if (parts.length == 4) { │ │ │ │ + return (1 * parts[0] >= 2 * parts[1]) ? "longdashdot" : │ │ │ │ + "dashdot"; │ │ │ │ + } │ │ │ │ + return "solid"; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: createNode │ │ │ │ - * │ │ │ │ + * Create a new node │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * type - {String} Kind of node to draw │ │ │ │ * id - {String} Id for node │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} A new node of the given type and id │ │ │ │ */ │ │ │ │ createNode: function(type, id) { │ │ │ │ - var node = document.createElementNS(this.xmlns, type); │ │ │ │ + var node = document.createElement(type); │ │ │ │ if (id) { │ │ │ │ - node.setAttributeNS(null, "id", id); │ │ │ │ + node.id = id; │ │ │ │ } │ │ │ │ + │ │ │ │ + // IE hack to make elements unselectable, to prevent 'blue flash' │ │ │ │ + // while dragging vectors; #1410 │ │ │ │ + node.unselectable = 'on'; │ │ │ │ + node.onselectstart = OpenLayers.Function.False; │ │ │ │ + │ │ │ │ return node; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: nodeTypeCompare │ │ │ │ - * │ │ │ │ + * Determine whether a node is of a given type │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * node - {SVGDomElement} An SVG element │ │ │ │ + * node - {DOMElement} An VML element │ │ │ │ * type - {String} Kind of node │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {Boolean} Whether or not the specified node is of the specified type │ │ │ │ */ │ │ │ │ nodeTypeCompare: function(node, type) { │ │ │ │ - return (type == node.nodeName); │ │ │ │ + │ │ │ │ + //split type │ │ │ │ + var subType = type; │ │ │ │ + var splitIndex = subType.indexOf(":"); │ │ │ │ + if (splitIndex != -1) { │ │ │ │ + subType = subType.substr(splitIndex + 1); │ │ │ │ + } │ │ │ │ + │ │ │ │ + //split nodeName │ │ │ │ + var nodeName = node.nodeName; │ │ │ │ + splitIndex = nodeName.indexOf(":"); │ │ │ │ + if (splitIndex != -1) { │ │ │ │ + nodeName = nodeName.substr(splitIndex + 1); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return (subType == nodeName); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: createRenderRoot │ │ │ │ - * │ │ │ │ + * Create the renderer root │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} The specific render engine's root element │ │ │ │ */ │ │ │ │ createRenderRoot: function() { │ │ │ │ - var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ - svg.style.display = "block"; │ │ │ │ - return svg; │ │ │ │ + return this.nodeFactory(this.container.id + "_vmlRoot", "div"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: createRoot │ │ │ │ + * Create the main root element │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * suffix - {String} suffix to append to the id │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} │ │ │ │ */ │ │ │ │ createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "g"); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createDefs │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The element to which we'll add the symbol definitions │ │ │ │ - */ │ │ │ │ - createDefs: function() { │ │ │ │ - var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ - this.rendererRoot.appendChild(defs); │ │ │ │ - return defs; │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "olv:group"); │ │ │ │ }, │ │ │ │ │ │ │ │ /************************************** │ │ │ │ * * │ │ │ │ * GEOMETRY DRAWING FUNCTIONS * │ │ │ │ * * │ │ │ │ **************************************/ │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawPoint │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ + * Render a point │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or false if the renderer could not draw the point │ │ │ │ + * {DOMElement} or false if the point could not be drawn │ │ │ │ */ │ │ │ │ drawPoint: function(node, geometry) { │ │ │ │ return this.drawCircle(node, geometry, 1); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawCircle │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ + * Render a circle. │ │ │ │ + * Size and Center a circle given geometry (x,y center) and radius │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * radius - {Float} │ │ │ │ + * radius - {float} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or false if the renderer could not draw the circle │ │ │ │ + * {DOMElement} or false if the circle could not ne drawn │ │ │ │ */ │ │ │ │ drawCircle: function(node, geometry, radius) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (this.top - geometry.y / resolution); │ │ │ │ + if (!isNaN(geometry.x) && !isNaN(geometry.y)) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "cx", x); │ │ │ │ - node.setAttributeNS(null, "cy", y); │ │ │ │ - node.setAttributeNS(null, "r", radius); │ │ │ │ + node.style.left = ((((geometry.x - this.featureDx) / resolution - this.offset.x) | 0) - radius) + "px"; │ │ │ │ + node.style.top = (((geometry.y / resolution - this.offset.y) | 0) - radius) + "px"; │ │ │ │ + │ │ │ │ + var diameter = radius * 2; │ │ │ │ + │ │ │ │ + node.style.width = diameter + "px"; │ │ │ │ + node.style.height = diameter + "px"; │ │ │ │ return node; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ } │ │ │ │ - │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ * Method: drawLineString │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ + * Render a linestring. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or null if the renderer could not draw all components of │ │ │ │ - * the linestring, or false if nothing could be drawn │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ drawLineString: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return (componentsResult.complete ? node : null); │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + return this.drawLine(node, geometry, false); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawLinearRing │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ + * Render a linearring │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or null if the renderer could not draw all components │ │ │ │ - * of the linear ring, or false if nothing could be drawn │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ drawLinearRing: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return (componentsResult.complete ? node : null); │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + return this.drawLine(node, geometry, true); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: DrawLine │ │ │ │ + * Render a line. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * closeLine - {Boolean} Close the line? (make it a ring?) │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + drawLine: function(node, geometry, closeLine) { │ │ │ │ + │ │ │ │ + this.setNodeDimension(node, geometry); │ │ │ │ + │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var numComponents = geometry.components.length; │ │ │ │ + var parts = new Array(numComponents); │ │ │ │ + │ │ │ │ + var comp, x, y; │ │ │ │ + for (var i = 0; i < numComponents; i++) { │ │ │ │ + comp = geometry.components[i]; │ │ │ │ + x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0; │ │ │ │ + y = (comp.y / resolution - this.offset.y) | 0; │ │ │ │ + parts[i] = " " + x + "," + y + " l "; │ │ │ │ } │ │ │ │ + var end = (closeLine) ? " x e" : " e"; │ │ │ │ + node.path = "m" + parts.join("") + end; │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawPolygon │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ + * Render a polygon │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or null if the renderer could not draw all components │ │ │ │ - * of the polygon, or false if nothing could be drawn │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ drawPolygon: function(node, geometry) { │ │ │ │ - var d = ""; │ │ │ │ - var draw = true; │ │ │ │ - var complete = true; │ │ │ │ - var linearRingResult, path; │ │ │ │ - for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ - d += " M"; │ │ │ │ - linearRingResult = this.getComponentsString( │ │ │ │ - geometry.components[j].components, " "); │ │ │ │ - path = linearRingResult.path; │ │ │ │ - if (path) { │ │ │ │ - d += " " + path; │ │ │ │ - complete = linearRingResult.complete && complete; │ │ │ │ - } else { │ │ │ │ - draw = false; │ │ │ │ + this.setNodeDimension(node, geometry); │ │ │ │ + │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + │ │ │ │ + var path = []; │ │ │ │ + var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y; │ │ │ │ + for (j = 0, jj = geometry.components.length; j < jj; j++) { │ │ │ │ + path.push("m"); │ │ │ │ + points = geometry.components[j].components; │ │ │ │ + // we only close paths of interior rings with area │ │ │ │ + area = (j === 0); │ │ │ │ + first = null; │ │ │ │ + second = null; │ │ │ │ + for (i = 0, ii = points.length; i < ii; i++) { │ │ │ │ + comp = points[i]; │ │ │ │ + x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0; │ │ │ │ + y = (comp.y / resolution - this.offset.y) | 0; │ │ │ │ + pathComp = " " + x + "," + y; │ │ │ │ + path.push(pathComp); │ │ │ │ + if (i == 0) { │ │ │ │ + path.push(" l"); │ │ │ │ + } │ │ │ │ + if (!area) { │ │ │ │ + // IE improperly renders sub-paths that have no area. │ │ │ │ + // Instead of checking the area of every ring, we confirm │ │ │ │ + // the ring has at least three distinct points. This does │ │ │ │ + // not catch all non-zero area cases, but it greatly improves │ │ │ │ + // interior ring digitizing and is a minor performance hit │ │ │ │ + // when rendering rings with many points. │ │ │ │ + if (!first) { │ │ │ │ + first = pathComp; │ │ │ │ + } else if (first != pathComp) { │ │ │ │ + if (!second) { │ │ │ │ + second = pathComp; │ │ │ │ + } else if (second != pathComp) { │ │ │ │ + // stop looking │ │ │ │ + area = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + path.push(area ? " x " : " "); │ │ │ │ } │ │ │ │ - d += " z"; │ │ │ │ - if (draw) { │ │ │ │ - node.setAttributeNS(null, "d", d); │ │ │ │ - node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ - return complete ? node : null; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + path.push("e"); │ │ │ │ + node.path = path.join(""); │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawRectangle │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ + * Render a rectangle │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or false if the renderer could not draw the rectangle │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ drawRectangle: function(node, geometry) { │ │ │ │ var resolution = this.getResolution(); │ │ │ │ - var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (this.top - geometry.y / resolution); │ │ │ │ │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "x", x); │ │ │ │ - node.setAttributeNS(null, "y", y); │ │ │ │ - node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ - node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ - return node; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + node.style.left = (((geometry.x - this.featureDx) / resolution - this.offset.x) | 0) + "px"; │ │ │ │ + node.style.top = ((geometry.y / resolution - this.offset.y) | 0) + "px"; │ │ │ │ + node.style.width = ((geometry.width / resolution) | 0) + "px"; │ │ │ │ + node.style.height = ((geometry.height / resolution) | 0) + "px"; │ │ │ │ + │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawText │ │ │ │ * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ * featureId - {String} │ │ │ │ * style - │ │ │ │ * location - {<OpenLayers.Geometry.Point>} │ │ │ │ */ │ │ │ │ drawText: function(featureId, style, location) { │ │ │ │ - var drawOutline = (!!style.labelOutlineWidth); │ │ │ │ - // First draw text in halo color and size and overlay the │ │ │ │ - // normal text afterwards │ │ │ │ - if (drawOutline) { │ │ │ │ - var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ - outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ - if (style.labelOutlineOpacity) { │ │ │ │ - outlineStyle.fontOpacity = style.labelOutlineOpacity; │ │ │ │ - } │ │ │ │ - delete outlineStyle.labelOutlineWidth; │ │ │ │ - this.drawText(featureId, outlineStyle, location); │ │ │ │ - } │ │ │ │ + var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect"); │ │ │ │ + var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox"); │ │ │ │ │ │ │ │ var resolution = this.getResolution(); │ │ │ │ + label.style.left = (((location.x - this.featureDx) / resolution - this.offset.x) | 0) + "px"; │ │ │ │ + label.style.top = ((location.y / resolution - this.offset.y) | 0) + "px"; │ │ │ │ + label.style.flip = "y"; │ │ │ │ │ │ │ │ - var x = ((location.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (location.y / resolution - this.top); │ │ │ │ - │ │ │ │ - var suffix = (drawOutline) ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ - var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ - │ │ │ │ - label.setAttributeNS(null, "x", x); │ │ │ │ - label.setAttributeNS(null, "y", -y); │ │ │ │ + textbox.innerText = style.label; │ │ │ │ │ │ │ │ - if (style.fontColor) { │ │ │ │ - label.setAttributeNS(null, "fill", style.fontColor); │ │ │ │ - } │ │ │ │ - if (style.fontStrokeColor) { │ │ │ │ - label.setAttributeNS(null, "stroke", style.fontStrokeColor); │ │ │ │ + if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ + textbox.style.cursor = style.cursor; │ │ │ │ } │ │ │ │ - if (style.fontStrokeWidth) { │ │ │ │ - label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth); │ │ │ │ + if (style.fontColor) { │ │ │ │ + textbox.style.color = style.fontColor; │ │ │ │ } │ │ │ │ if (style.fontOpacity) { │ │ │ │ - label.setAttributeNS(null, "opacity", style.fontOpacity); │ │ │ │ + textbox.style.filter = 'alpha(opacity=' + (style.fontOpacity * 100) + ')'; │ │ │ │ } │ │ │ │ if (style.fontFamily) { │ │ │ │ - label.setAttributeNS(null, "font-family", style.fontFamily); │ │ │ │ + textbox.style.fontFamily = style.fontFamily; │ │ │ │ } │ │ │ │ if (style.fontSize) { │ │ │ │ - label.setAttributeNS(null, "font-size", style.fontSize); │ │ │ │ + textbox.style.fontSize = style.fontSize; │ │ │ │ } │ │ │ │ if (style.fontWeight) { │ │ │ │ - label.setAttributeNS(null, "font-weight", style.fontWeight); │ │ │ │ + textbox.style.fontWeight = style.fontWeight; │ │ │ │ } │ │ │ │ if (style.fontStyle) { │ │ │ │ - label.setAttributeNS(null, "font-style", style.fontStyle); │ │ │ │ + textbox.style.fontStyle = style.fontStyle; │ │ │ │ } │ │ │ │ if (style.labelSelect === true) { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ label._featureId = featureId; │ │ │ │ - } else { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "none"); │ │ │ │ - } │ │ │ │ - var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ - label.setAttributeNS(null, "text-anchor", │ │ │ │ - OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ - │ │ │ │ - if (OpenLayers.IS_GECKO === true) { │ │ │ │ - label.setAttributeNS(null, "dominant-baseline", │ │ │ │ - OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var labelRows = style.label.split('\n'); │ │ │ │ - var numRows = labelRows.length; │ │ │ │ - while (label.childNodes.length > numRows) { │ │ │ │ - label.removeChild(label.lastChild); │ │ │ │ - } │ │ │ │ - for (var i = 0; i < numRows; i++) { │ │ │ │ - var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - tspan._featureId = featureId; │ │ │ │ - tspan._geometry = location; │ │ │ │ - tspan._geometryClass = location.CLASS_NAME; │ │ │ │ - } │ │ │ │ - if (OpenLayers.IS_GECKO === false) { │ │ │ │ - tspan.setAttributeNS(null, "baseline-shift", │ │ │ │ - OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%"); │ │ │ │ - } │ │ │ │ - tspan.setAttribute("x", x); │ │ │ │ - if (i == 0) { │ │ │ │ - var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ - if (vfactor == null) { │ │ │ │ - vfactor = -.5; │ │ │ │ - } │ │ │ │ - tspan.setAttribute("dy", (vfactor * (numRows - 1)) + "em"); │ │ │ │ - } else { │ │ │ │ - tspan.setAttribute("dy", "1em"); │ │ │ │ - } │ │ │ │ - tspan.textContent = (labelRows[i] === '') ? ' ' : labelRows[i]; │ │ │ │ - if (!tspan.parentNode) { │ │ │ │ - label.appendChild(tspan); │ │ │ │ - } │ │ │ │ + textbox._featureId = featureId; │ │ │ │ + textbox._geometry = location; │ │ │ │ + textbox._geometryClass = location.CLASS_NAME; │ │ │ │ } │ │ │ │ + textbox.style.whiteSpace = "nowrap"; │ │ │ │ + // fun with IE: IE7 in standards compliant mode does not display any │ │ │ │ + // text with a left inset of 0. So we set this to 1px and subtract one │ │ │ │ + // pixel later when we set label.style.left │ │ │ │ + textbox.inset = "1px,0px,0px,0px"; │ │ │ │ │ │ │ │ if (!label.parentNode) { │ │ │ │ + label.appendChild(textbox); │ │ │ │ this.textRoot.appendChild(label); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getComponentString │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry.Point>)} Array of points │ │ │ │ - * separator - {String} character between coordinate pairs. Defaults to "," │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} hash with properties "path" (the string created from the │ │ │ │ - * components and "complete" (false if the renderer was unable to │ │ │ │ - * draw all components) │ │ │ │ - */ │ │ │ │ - getComponentsString: function(components, separator) { │ │ │ │ - var renderCmp = []; │ │ │ │ - var complete = true; │ │ │ │ - var len = components.length; │ │ │ │ - var strings = []; │ │ │ │ - var str, component; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - component = components[i]; │ │ │ │ - renderCmp.push(component); │ │ │ │ - str = this.getShortString(component); │ │ │ │ - if (str) { │ │ │ │ - strings.push(str); │ │ │ │ - } else { │ │ │ │ - // The current component is outside the valid range. Let's │ │ │ │ - // see if the previous or next component is inside the range. │ │ │ │ - // If so, add the coordinate of the intersection with the │ │ │ │ - // valid range bounds. │ │ │ │ - if (i > 0) { │ │ │ │ - if (this.getShortString(components[i - 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], │ │ │ │ - components[i - 1])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i < len - 1) { │ │ │ │ - if (this.getShortString(components[i + 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], │ │ │ │ - components[i + 1])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - complete = false; │ │ │ │ - } │ │ │ │ + var align = style.labelAlign || "cm"; │ │ │ │ + if (align.length == 1) { │ │ │ │ + align += "m"; │ │ │ │ } │ │ │ │ + var xshift = textbox.clientWidth * │ │ │ │ + (OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)]); │ │ │ │ + var yshift = textbox.clientHeight * │ │ │ │ + (OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)]); │ │ │ │ + label.style.left = parseInt(label.style.left) - xshift - 1 + "px"; │ │ │ │ + label.style.top = parseInt(label.style.top) + yshift + "px"; │ │ │ │ │ │ │ │ - return { │ │ │ │ - path: strings.join(separator || ","), │ │ │ │ - complete: complete │ │ │ │ - }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clipLine │ │ │ │ - * Given two points (one inside the valid range, and one outside), │ │ │ │ - * clips the line betweeen the two points so that the new points are both │ │ │ │ - * inside the valid range. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * badComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ - * invalid point │ │ │ │ - * goodComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ - * valid point │ │ │ │ - * Returns │ │ │ │ - * {String} the SVG coordinate pair of the clipped point (like │ │ │ │ - * getShortString), or an empty string if both passed componets are at │ │ │ │ - * the same point. │ │ │ │ - */ │ │ │ │ - clipLine: function(badComponent, goodComponent) { │ │ │ │ - if (goodComponent.equals(badComponent)) { │ │ │ │ - return ""; │ │ │ │ - } │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ - var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ - var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y1 = this.top - goodComponent.y / resolution; │ │ │ │ - var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y2 = this.top - badComponent.y / resolution; │ │ │ │ - var k; │ │ │ │ - if (x2 < -maxX || x2 > maxX) { │ │ │ │ - k = (y2 - y1) / (x2 - x1); │ │ │ │ - x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ - y2 = y1 + (x2 - x1) * k; │ │ │ │ - } │ │ │ │ - if (y2 < -maxY || y2 > maxY) { │ │ │ │ - k = (x2 - x1) / (y2 - y1); │ │ │ │ - y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ - x2 = x1 + (y2 - y1) * k; │ │ │ │ - } │ │ │ │ - return x2 + "," + y2; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getShortString │ │ │ │ + * Method: moveRoot │ │ │ │ + * moves this renderer's root to a different renderer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * renderer - {<OpenLayers.Renderer>} target renderer for the moved root │ │ │ │ + * root - {DOMElement} optional root node. To be used when this renderer │ │ │ │ + * holds roots from multiple layers to tell this method which one to │ │ │ │ + * detach │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} or false if point is outside the valid range │ │ │ │ + * {Boolean} true if successful, false otherwise │ │ │ │ */ │ │ │ │ - getShortString: function(point) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = ((point.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (this.top - point.y / resolution); │ │ │ │ - │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - return x + "," + y; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + moveRoot: function(renderer) { │ │ │ │ + var layer = this.map.getLayer(renderer.container.id); │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector.RootContainer) { │ │ │ │ + layer = this.map.getLayer(this.container.id); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getPosition │ │ │ │ - * Finds the position of an svg node. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} hash with x and y properties, representing the coordinates │ │ │ │ - * within the svg coordinate system │ │ │ │ - */ │ │ │ │ - getPosition: function(node) { │ │ │ │ - return ({ │ │ │ │ - x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ - y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ - }); │ │ │ │ + layer && layer.renderer.clear(); │ │ │ │ + OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments); │ │ │ │ + layer && layer.redraw(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: importSymbol │ │ │ │ * add a new symbol definition from the rendererer's symbol hash │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * graphicName - {String} name of the symbol to import │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} - the imported symbol │ │ │ │ + * {Object} - hash of {DOMElement} "symbol" and {Number} "size" │ │ │ │ */ │ │ │ │ importSymbol: function(graphicName) { │ │ │ │ - if (!this.defs) { │ │ │ │ - // create svg defs tag │ │ │ │ - this.defs = this.createDefs(); │ │ │ │ - } │ │ │ │ var id = this.container.id + "-" + graphicName; │ │ │ │ │ │ │ │ - // check if symbol already exists in the defs │ │ │ │ - var existing = document.getElementById(id); │ │ │ │ - if (existing != null) { │ │ │ │ - return existing; │ │ │ │ + // check if symbol already exists in the cache │ │ │ │ + var cache = this.symbolCache[id]; │ │ │ │ + if (cache) { │ │ │ │ + return cache; │ │ │ │ } │ │ │ │ │ │ │ │ var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ if (!symbol) { │ │ │ │ throw new Error(graphicName + ' is not a valid symbol name'); │ │ │ │ } │ │ │ │ │ │ │ │ - var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ - var node = this.nodeFactory(null, "polygon"); │ │ │ │ - symbolNode.appendChild(node); │ │ │ │ var symbolExtent = new OpenLayers.Bounds( │ │ │ │ Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ │ │ │ │ - var points = []; │ │ │ │ - var x, y; │ │ │ │ + var pathitems = ["m"]; │ │ │ │ for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - x = symbol[i]; │ │ │ │ - y = symbol[i + 1]; │ │ │ │ + var x = symbol[i]; │ │ │ │ + var y = symbol[i + 1]; │ │ │ │ symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - points.push(x, ",", y); │ │ │ │ - } │ │ │ │ │ │ │ │ - node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ + pathitems.push(x); │ │ │ │ + pathitems.push(y); │ │ │ │ + if (i == 0) { │ │ │ │ + pathitems.push("l"); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + pathitems.push("x e"); │ │ │ │ + var path = pathitems.join(" "); │ │ │ │ │ │ │ │ - var width = symbolExtent.getWidth(); │ │ │ │ - var height = symbolExtent.getHeight(); │ │ │ │ - // create a viewBox three times as large as the symbol itself, │ │ │ │ - // to allow for strokeWidth being displayed correctly at the corners. │ │ │ │ - var viewBox = [symbolExtent.left - width, │ │ │ │ - symbolExtent.bottom - height, width * 3, height * 3 │ │ │ │ - ]; │ │ │ │ - symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ - this.symbolMetrics[id] = [ │ │ │ │ - Math.max(width, height), │ │ │ │ - symbolExtent.getCenterLonLat().lon, │ │ │ │ - symbolExtent.getCenterLonLat().lat │ │ │ │ - ]; │ │ │ │ + var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2; │ │ │ │ + if (diff > 0) { │ │ │ │ + symbolExtent.bottom = symbolExtent.bottom - diff; │ │ │ │ + symbolExtent.top = symbolExtent.top + diff; │ │ │ │ + } else { │ │ │ │ + symbolExtent.left = symbolExtent.left + diff; │ │ │ │ + symbolExtent.right = symbolExtent.right - diff; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.defs.appendChild(symbolNode); │ │ │ │ - return symbolNode; │ │ │ │ - }, │ │ │ │ + cache = { │ │ │ │ + path: path, │ │ │ │ + size: symbolExtent.getWidth(), // equals getHeight() now │ │ │ │ + left: symbolExtent.left, │ │ │ │ + bottom: symbolExtent.bottom │ │ │ │ + }; │ │ │ │ + this.symbolCache[id] = cache; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getFeatureIdFromEvent │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} An <OpenLayers.Event> object │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A feature id or undefined. │ │ │ │ - */ │ │ │ │ - getFeatureIdFromEvent: function(evt) { │ │ │ │ - var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ - if (!featureId) { │ │ │ │ - var target = evt.target; │ │ │ │ - featureId = target.parentNode && target != this.rendererRoot ? │ │ │ │ - target.parentNode._featureId : undefined; │ │ │ │ - } │ │ │ │ - return featureId; │ │ │ │ + return cache; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.VML" │ │ │ │ }); │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: OpenLayers.Renderer.SVG.LABEL_ALIGN │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ - "l": "start", │ │ │ │ - "r": "end", │ │ │ │ - "b": "bottom", │ │ │ │ - "t": "hanging" │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Renderer.SVG.LABEL_VSHIFT │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ - // according to │ │ │ │ - // http://www.w3.org/Graphics/SVG/Test/20061213/htmlObjectHarness/full-text-align-02-b.html │ │ │ │ - // a baseline-shift of -70% shifts the text exactly from the │ │ │ │ - // bottom to the top of the baseline, so -35% moves the text to │ │ │ │ - // the center of the baseline. │ │ │ │ - "t": "-70%", │ │ │ │ - "b": "0" │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Renderer.SVG.LABEL_VFACTOR │ │ │ │ + * Constant: OpenLayers.Renderer.VML.LABEL_SHIFT │ │ │ │ * {Object} │ │ │ │ */ │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ +OpenLayers.Renderer.VML.LABEL_SHIFT = { │ │ │ │ + "l": 0, │ │ │ │ + "c": .5, │ │ │ │ + "r": 1, │ │ │ │ "t": 0, │ │ │ │ - "b": -1 │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Renderer.SVG.preventDefault │ │ │ │ - * *Deprecated*. Use <OpenLayers.Event.preventDefault> method instead. │ │ │ │ - * Used to prevent default events (especially opening images in a new tab on │ │ │ │ - * ctrl-click) from being executed for externalGraphic symbols │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ - OpenLayers.Event.preventDefault(e); │ │ │ │ + "m": .5, │ │ │ │ + "b": 1 │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Renderer/Canvas.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -69239,17354 +72045,14548 @@ │ │ │ │ * Constant: OpenLayers.Renderer.Canvas.drawImageScaleFactor │ │ │ │ * {Number} Scale factor to apply to the canvas drawImage arguments. This │ │ │ │ * is always 1 except for Android 2.1 devices, to work around │ │ │ │ * http://code.google.com/p/android/issues/detail?id=5141. │ │ │ │ */ │ │ │ │ OpenLayers.Renderer.Canvas.drawImageScaleFactor = null; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Renderer/VML.js │ │ │ │ + OpenLayers/Renderer/SVG.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Renderer/Elements.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Renderer.VML │ │ │ │ - * Render vector features in browsers with VML capability. Construct a new │ │ │ │ - * VML renderer with the <OpenLayers.Renderer.VML> constructor. │ │ │ │ + * Class: OpenLayers.Renderer.SVG │ │ │ │ * │ │ │ │ - * Note that for all calculations in this class, we use (num | 0) to truncate a │ │ │ │ - * float value to an integer. This is done because it seems that VML doesn't │ │ │ │ - * support float values. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ + * Inherits: │ │ │ │ * - <OpenLayers.Renderer.Elements> │ │ │ │ */ │ │ │ │ -OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ +OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Property: xmlns │ │ │ │ - * {String} XML Namespace URN │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - xmlns: "urn:schemas-microsoft-com:vml", │ │ │ │ + xmlns: "http://www.w3.org/2000/svg", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: symbolCache │ │ │ │ - * {DOMElement} node holding symbols. This hash is keyed by symbol name, │ │ │ │ - * and each value is a hash with a "path" and an "extent" property. │ │ │ │ + * Property: xlinkns │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - symbolCache: {}, │ │ │ │ + xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: offset │ │ │ │ + * Constant: MAX_PIXEL │ │ │ │ + * {Integer} Firefox has a limitation where values larger or smaller than │ │ │ │ + * about 15000 in an SVG document lock the browser up. This │ │ │ │ + * works around it. │ │ │ │ + */ │ │ │ │ + MAX_PIXEL: 15000, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: translationParameters │ │ │ │ * {Object} Hash with "x" and "y" properties │ │ │ │ */ │ │ │ │ - offset: null, │ │ │ │ + translationParameters: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Renderer.VML │ │ │ │ - * Create a new VML renderer. │ │ │ │ - * │ │ │ │ + * Property: symbolMetrics │ │ │ │ + * {Object} Cache for symbol metrics according to their svg coordinate │ │ │ │ + * space. This is an object keyed by the symbol's id, and values are │ │ │ │ + * an array of [width, centerX, centerY]. │ │ │ │ + */ │ │ │ │ + symbolMetrics: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Renderer.SVG │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * containerID - {String} The id for the element that contains the renderer │ │ │ │ + * containerID - {String} │ │ │ │ */ │ │ │ │ initialize: function(containerID) { │ │ │ │ if (!this.supported()) { │ │ │ │ return; │ │ │ │ } │ │ │ │ - if (!document.namespaces.olv) { │ │ │ │ - document.namespaces.add("olv", this.xmlns); │ │ │ │ - var style = document.createStyleSheet(); │ │ │ │ - var shapes = ['shape', 'rect', 'oval', 'fill', 'stroke', 'imagedata', 'group', 'textbox']; │ │ │ │ - for (var i = 0, len = shapes.length; i < len; i++) { │ │ │ │ - │ │ │ │ - style.addRule('olv\\:' + shapes[i], "behavior: url(#default#VML); " + │ │ │ │ - "position: absolute; display: inline-block;"); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ OpenLayers.Renderer.Elements.prototype.initialize.apply(this, │ │ │ │ arguments); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: 0, │ │ │ │ + y: 0 │ │ │ │ + }; │ │ │ │ + │ │ │ │ + this.symbolMetrics = {}; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: supported │ │ │ │ - * Determine whether a browser supports this renderer. │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The browser supports the VML renderer │ │ │ │ + * {Boolean} Whether or not the browser supports the SVG renderer │ │ │ │ */ │ │ │ │ supported: function() { │ │ │ │ - return !!(document.namespaces); │ │ │ │ + var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ + return (document.implementation && │ │ │ │ + (document.implementation.hasFeature("org.w3c.svg", "1.0") || │ │ │ │ + document.implementation.hasFeature(svgFeature + "SVG", "1.1") || │ │ │ │ + document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1"))); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setExtent │ │ │ │ - * Set the renderer's extent │ │ │ │ + * Method: inValidRange │ │ │ │ + * See #669 for more information │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ + * x - {Integer} │ │ │ │ + * y - {Integer} │ │ │ │ + * xyOnly - {Boolean} whether or not to just check for x and y, which means │ │ │ │ + * to not take the current translation parameters into account if true. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the 'x' and 'y' coordinates are in the │ │ │ │ + * valid range. │ │ │ │ + */ │ │ │ │ + inValidRange: function(x, y, xyOnly) { │ │ │ │ + var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ + var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ + return (left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && │ │ │ │ + top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setExtent │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ * extent - {<OpenLayers.Bounds>} │ │ │ │ * resolutionChanged - {Boolean} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ * {Boolean} true to notify the layer that the new extent does not exceed │ │ │ │ * the coordinate range, and the features will not need to be redrawn. │ │ │ │ + * False otherwise. │ │ │ │ */ │ │ │ │ setExtent: function(extent, resolutionChanged) { │ │ │ │ var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - │ │ │ │ - var left = (extent.left / resolution) | 0; │ │ │ │ - var top = (extent.top / resolution - this.size.h) | 0; │ │ │ │ - if (resolutionChanged || !this.offset) { │ │ │ │ - this.offset = { │ │ │ │ - x: left, │ │ │ │ - y: top │ │ │ │ - }; │ │ │ │ - left = 0; │ │ │ │ - top = 0; │ │ │ │ - } else { │ │ │ │ - left = left - this.offset.x; │ │ │ │ - top = top - this.offset.y; │ │ │ │ - } │ │ │ │ │ │ │ │ + var resolution = this.getResolution(), │ │ │ │ + left = -extent.left / resolution, │ │ │ │ + top = extent.top / resolution; │ │ │ │ │ │ │ │ - var org = (left - this.xOffset) + " " + top; │ │ │ │ - this.root.coordorigin = org; │ │ │ │ - var roots = [this.root, this.vectorRoot, this.textRoot]; │ │ │ │ - var root; │ │ │ │ - for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ - root = roots[i]; │ │ │ │ - │ │ │ │ - var size = this.size.w + " " + this.size.h; │ │ │ │ - root.coordsize = size; │ │ │ │ + // If the resolution has changed, start over changing the corner, because │ │ │ │ + // the features will redraw. │ │ │ │ + if (resolutionChanged) { │ │ │ │ + this.left = left; │ │ │ │ + this.top = top; │ │ │ │ + // Set the viewbox │ │ │ │ + var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ │ │ │ │ + this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ + this.translate(this.xOffset, 0); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ + if (!inRange) { │ │ │ │ + // recenter the coordinate system │ │ │ │ + this.setExtent(extent, true); │ │ │ │ + } │ │ │ │ + return coordSysUnchanged && inRange; │ │ │ │ } │ │ │ │ - // flip the VML display Y axis upside down so it │ │ │ │ - // matches the display Y axis of the map │ │ │ │ - this.root.style.flip = "y"; │ │ │ │ - │ │ │ │ - return coordSysUnchanged; │ │ │ │ }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Method: translate │ │ │ │ + * Transforms the SVG coordinate system │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Float} │ │ │ │ + * y - {Float} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} true if the translation parameters are in the valid coordinates │ │ │ │ + * range, false otherwise. │ │ │ │ + */ │ │ │ │ + translate: function(x, y) { │ │ │ │ + if (!this.inValidRange(x, y, true)) { │ │ │ │ + return false; │ │ │ │ + } else { │ │ │ │ + var transformString = ""; │ │ │ │ + if (x || y) { │ │ │ │ + transformString = "translate(" + x + "," + y + ")"; │ │ │ │ + } │ │ │ │ + this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: x, │ │ │ │ + y: y │ │ │ │ + }; │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: setSize │ │ │ │ - * Set the size of the drawing surface │ │ │ │ - * │ │ │ │ + * Sets the size of the drawing surface. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * size - {<OpenLayers.Size>} the size of the drawing surface │ │ │ │ + * size - {<OpenLayers.Size>} The size of the drawing surface │ │ │ │ */ │ │ │ │ setSize: function(size) { │ │ │ │ OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ │ │ │ │ - // setting width and height on all roots to avoid flicker which we │ │ │ │ - // would get with 100% width and height on child roots │ │ │ │ - var roots = [ │ │ │ │ - this.rendererRoot, │ │ │ │ - this.root, │ │ │ │ - this.vectorRoot, │ │ │ │ - this.textRoot │ │ │ │ - ]; │ │ │ │ - var w = this.size.w + "px"; │ │ │ │ - var h = this.size.h + "px"; │ │ │ │ - var root; │ │ │ │ - for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ - root = roots[i]; │ │ │ │ - root.style.width = w; │ │ │ │ - root.style.height = h; │ │ │ │ - } │ │ │ │ + this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ + this.rendererRoot.setAttributeNS(null, "height", this.size.h); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getNodeType │ │ │ │ - * Get the node type for a geometry and style │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: getNodeType │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * style - {Object} │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {String} The corresponding node type for the specified geometry │ │ │ │ */ │ │ │ │ getNodeType: function(geometry, style) { │ │ │ │ var nodeType = null; │ │ │ │ switch (geometry.CLASS_NAME) { │ │ │ │ case "OpenLayers.Geometry.Point": │ │ │ │ if (style.externalGraphic) { │ │ │ │ - nodeType = "olv:rect"; │ │ │ │ + nodeType = "image"; │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "olv:shape"; │ │ │ │ + nodeType = "svg"; │ │ │ │ } else { │ │ │ │ - nodeType = "olv:oval"; │ │ │ │ + nodeType = "circle"; │ │ │ │ } │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "olv:rect"; │ │ │ │ + nodeType = "rect"; │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.LineString": │ │ │ │ + nodeType = "polyline"; │ │ │ │ + break; │ │ │ │ case "OpenLayers.Geometry.LinearRing": │ │ │ │ + nodeType = "polygon"; │ │ │ │ + break; │ │ │ │ case "OpenLayers.Geometry.Polygon": │ │ │ │ case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "olv:shape"; │ │ │ │ + nodeType = "path"; │ │ │ │ break; │ │ │ │ default: │ │ │ │ break; │ │ │ │ } │ │ │ │ return nodeType; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: setStyle │ │ │ │ - * Use to set all the style attributes to a VML node. │ │ │ │ + * Use to set all the style attributes to a SVG node. │ │ │ │ + * │ │ │ │ + * Takes care to adjust stroke width and point radius to be │ │ │ │ + * resolution-relative │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} An VML element to decorate │ │ │ │ + * node - {SVGDomElement} An SVG element to decorate │ │ │ │ * style - {Object} │ │ │ │ * options - {Object} Currently supported options include │ │ │ │ * 'isFilled' {Boolean} and │ │ │ │ * 'isStroked' {Boolean} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - setStyle: function(node, style, options, geometry) { │ │ │ │ + setStyle: function(node, style, options) { │ │ │ │ style = style || node._style; │ │ │ │ options = options || node._options; │ │ │ │ - var fillColor = style.fillColor; │ │ │ │ │ │ │ │ var title = style.title || style.graphicTitle; │ │ │ │ if (title) { │ │ │ │ - node.title = title; │ │ │ │ + node.setAttributeNS(null, "title", title); │ │ │ │ + //Standards-conformant SVG │ │ │ │ + // Prevent duplicate nodes. See issue https://github.com/openlayers/openlayers/issues/92 │ │ │ │ + var titleNode = node.getElementsByTagName("title"); │ │ │ │ + if (titleNode.length > 0) { │ │ │ │ + titleNode[0].firstChild.textContent = title; │ │ │ │ + } else { │ │ │ │ + var label = this.nodeFactory(null, "title"); │ │ │ │ + label.textContent = title; │ │ │ │ + node.appendChild(label); │ │ │ │ + } │ │ │ │ } │ │ │ │ │ │ │ │ - if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - options.isFilled = true; │ │ │ │ + var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ + var widthFactor = 1; │ │ │ │ + var pos; │ │ │ │ + if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ + node.style.visibility = ""; │ │ │ │ + if (style.graphic === false) { │ │ │ │ + node.style.visibility = "hidden"; │ │ │ │ + } else if (style.externalGraphic) { │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + if (style.graphicWidth && style.graphicHeight) { │ │ │ │ + node.setAttributeNS(null, "preserveAspectRatio", "none"); │ │ │ │ + } │ │ │ │ var width = style.graphicWidth || style.graphicHeight; │ │ │ │ var height = style.graphicHeight || style.graphicWidth; │ │ │ │ width = width ? width : style.pointRadius * 2; │ │ │ │ height = height ? height : style.pointRadius * 2; │ │ │ │ - │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ var xOffset = (style.graphicXOffset != undefined) ? │ │ │ │ style.graphicXOffset : -(0.5 * width); │ │ │ │ var yOffset = (style.graphicYOffset != undefined) ? │ │ │ │ style.graphicYOffset : -(0.5 * height); │ │ │ │ │ │ │ │ - node.style.left = ((((geometry.x - this.featureDx) / resolution - this.offset.x) + xOffset) | 0) + "px"; │ │ │ │ - node.style.top = (((geometry.y / resolution - this.offset.y) - (yOffset + height)) | 0) + "px"; │ │ │ │ - node.style.width = width + "px"; │ │ │ │ - node.style.height = height + "px"; │ │ │ │ - node.style.flip = "y"; │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ │ │ │ │ - // modify fillColor and options for stroke styling below │ │ │ │ - fillColor = "none"; │ │ │ │ - options.isStroked = false; │ │ │ │ + node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "width", width); │ │ │ │ + node.setAttributeNS(null, "height", height); │ │ │ │ + node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ + node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ + node.onclick = OpenLayers.Event.preventDefault; │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - var cache = this.importSymbol(style.graphicName); │ │ │ │ - node.path = cache.path; │ │ │ │ - node.coordorigin = cache.left + "," + cache.bottom; │ │ │ │ - var size = cache.size; │ │ │ │ - node.coordsize = size + "," + size; │ │ │ │ - this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ - node.style.flip = "y"; │ │ │ │ - } else { │ │ │ │ - this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // fill │ │ │ │ - if (options.isFilled) { │ │ │ │ - node.fillcolor = fillColor; │ │ │ │ - } else { │ │ │ │ - node.filled = "false"; │ │ │ │ - } │ │ │ │ - var fills = node.getElementsByTagName("fill"); │ │ │ │ - var fill = (fills.length == 0) ? null : fills[0]; │ │ │ │ - if (!options.isFilled) { │ │ │ │ - if (fill) { │ │ │ │ - node.removeChild(fill); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!fill) { │ │ │ │ - fill = this.createNode('olv:fill', node.id + "_fill"); │ │ │ │ - } │ │ │ │ - fill.opacity = style.fillOpacity; │ │ │ │ - │ │ │ │ - if (node._geometryClass === "OpenLayers.Geometry.Point" && │ │ │ │ - style.externalGraphic) { │ │ │ │ + // the symbol viewBox is three times as large as the symbol │ │ │ │ + var offset = style.pointRadius * 3; │ │ │ │ + var size = offset * 2; │ │ │ │ + var src = this.importSymbol(style.graphicName); │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ │ │ │ │ - // override fillOpacity │ │ │ │ - if (style.graphicOpacity) { │ │ │ │ - fill.opacity = style.graphicOpacity; │ │ │ │ + // remove the node from the dom before we modify it. This │ │ │ │ + // prevents various rendering issues in Safari and FF │ │ │ │ + var parent = node.parentNode; │ │ │ │ + var nextSibling = node.nextSibling; │ │ │ │ + if (parent) { │ │ │ │ + parent.removeChild(node); │ │ │ │ } │ │ │ │ │ │ │ │ - fill.src = style.externalGraphic; │ │ │ │ - fill.type = "frame"; │ │ │ │ + // The more appropriate way to implement this would be use/defs, │ │ │ │ + // but due to various issues in several browsers, it is safer to │ │ │ │ + // copy the symbols instead of referencing them. │ │ │ │ + // See e.g. ticket http://trac.osgeo.org/openlayers/ticket/2985 │ │ │ │ + // and this email thread │ │ │ │ + // http://osgeo-org.1803224.n2.nabble.com/Select-Control-Ctrl-click-on-Feature-with-a-graphicName-opens-new-browser-window-tc5846039.html │ │ │ │ + node.firstChild && node.removeChild(node.firstChild); │ │ │ │ + node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ + node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ │ │ │ │ - if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ - fill.aspect = "atmost"; │ │ │ │ + node.setAttributeNS(null, "width", size); │ │ │ │ + node.setAttributeNS(null, "height", size); │ │ │ │ + node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ + node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ + │ │ │ │ + // now that the node has all its new properties, insert it │ │ │ │ + // back into the dom where it was │ │ │ │ + if (nextSibling) { │ │ │ │ + parent.insertBefore(node, nextSibling); │ │ │ │ + } else if (parent) { │ │ │ │ + parent.appendChild(node); │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "r", style.pointRadius); │ │ │ │ } │ │ │ │ - if (fill.parentNode != node) { │ │ │ │ - node.appendChild(fill); │ │ │ │ - } │ │ │ │ - } │ │ │ │ │ │ │ │ - // additional rendering for rotated graphics or symbols │ │ │ │ - var rotation = style.rotation; │ │ │ │ - if ((rotation !== undefined || node._rotation !== undefined)) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ - // make the fill fully transparent, because we now have │ │ │ │ - // the graphic as imagedata element. We cannot just remove │ │ │ │ - // the fill, because this is part of the hack described │ │ │ │ - // in graphicRotate │ │ │ │ - fill.opacity = 0; │ │ │ │ - } else if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ - node.style.rotation = rotation || 0; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var rotation = style.rotation; │ │ │ │ │ │ │ │ - // stroke │ │ │ │ - var strokes = node.getElementsByTagName("stroke"); │ │ │ │ - var stroke = (strokes.length == 0) ? null : strokes[0]; │ │ │ │ - if (!options.isStroked) { │ │ │ │ - node.stroked = false; │ │ │ │ - if (stroke) { │ │ │ │ - stroke.on = false; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!stroke) { │ │ │ │ - stroke = this.createNode('olv:stroke', node.id + "_stroke"); │ │ │ │ - node.appendChild(stroke); │ │ │ │ - } │ │ │ │ - stroke.on = true; │ │ │ │ - stroke.color = style.strokeColor; │ │ │ │ - stroke.weight = style.strokeWidth + "px"; │ │ │ │ - stroke.opacity = style.strokeOpacity; │ │ │ │ - stroke.endcap = style.strokeLinecap == 'butt' ? 'flat' : │ │ │ │ - (style.strokeLinecap || 'round'); │ │ │ │ - if (style.strokeDashstyle) { │ │ │ │ - stroke.dashstyle = this.dashStyle(style); │ │ │ │ + if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + rotation |= 0; │ │ │ │ + if (node.nodeName !== "svg") { │ │ │ │ + node.setAttributeNS(null, "transform", │ │ │ │ + "rotate(" + rotation + " " + pos.x + " " + │ │ │ │ + pos.y + ")"); │ │ │ │ + } else { │ │ │ │ + var metrics = this.symbolMetrics[src.id]; │ │ │ │ + node.firstChild.setAttributeNS(null, "transform", "rotate(" + │ │ │ │ + rotation + " " + │ │ │ │ + metrics[1] + " " + │ │ │ │ + metrics[2] + ")"); │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ │ │ │ │ - if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ - node.style.cursor = style.cursor; │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: graphicRotate │ │ │ │ - * If a point is to be styled with externalGraphic and rotation, VML fills │ │ │ │ - * cannot be used to display the graphic, because rotation of graphic │ │ │ │ - * fills is not supported by the VML implementation of Internet Explorer. │ │ │ │ - * This method creates a olv:imagedata element inside the VML node, │ │ │ │ - * DXImageTransform.Matrix and BasicImage filters for rotation and │ │ │ │ - * opacity, and a 3-step hack to remove rendering artefacts from the │ │ │ │ - * graphic and preserve the ability of graphics to trigger events. │ │ │ │ - * Finally, OpenLayers methods are used to determine the correct │ │ │ │ - * insertion point of the rotated image, because DXImageTransform.Matrix │ │ │ │ - * does the rotation without the ability to specify a rotation center │ │ │ │ - * point. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * xOffset - {Number} rotation center relative to image, x coordinate │ │ │ │ - * yOffset - {Number} rotation center relative to image, y coordinate │ │ │ │ - * style - {Object} │ │ │ │ - */ │ │ │ │ - graphicRotate: function(node, xOffset, yOffset, style) { │ │ │ │ - var style = style || node._style; │ │ │ │ - var rotation = style.rotation || 0; │ │ │ │ - │ │ │ │ - var aspectRatio, size; │ │ │ │ - if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ - // load the image to determine its size │ │ │ │ - var img = new Image(); │ │ │ │ - img.onreadystatechange = OpenLayers.Function.bind(function() { │ │ │ │ - if (img.readyState == "complete" || │ │ │ │ - img.readyState == "interactive") { │ │ │ │ - aspectRatio = img.width / img.height; │ │ │ │ - size = Math.max(style.pointRadius * 2, │ │ │ │ - style.graphicWidth || 0, │ │ │ │ - style.graphicHeight || 0); │ │ │ │ - xOffset = xOffset * aspectRatio; │ │ │ │ - style.graphicWidth = size * aspectRatio; │ │ │ │ - style.graphicHeight = size; │ │ │ │ - this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ - } │ │ │ │ - }, this); │ │ │ │ - img.src = style.externalGraphic; │ │ │ │ - │ │ │ │ - // will be called again by the onreadystate handler │ │ │ │ - return; │ │ │ │ + if (options.isFilled) { │ │ │ │ + node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ + node.setAttributeNS(null, "fill-opacity", style.fillOpacity); │ │ │ │ } else { │ │ │ │ - size = Math.max(style.graphicWidth, style.graphicHeight); │ │ │ │ - aspectRatio = style.graphicWidth / style.graphicHeight; │ │ │ │ + node.setAttributeNS(null, "fill", "none"); │ │ │ │ } │ │ │ │ │ │ │ │ - var width = Math.round(style.graphicWidth || size * aspectRatio); │ │ │ │ - var height = Math.round(style.graphicHeight || size); │ │ │ │ - node.style.width = width + "px"; │ │ │ │ - node.style.height = height + "px"; │ │ │ │ - │ │ │ │ - // Three steps are required to remove artefacts for images with │ │ │ │ - // transparent backgrounds (resulting from using DXImageTransform │ │ │ │ - // filters on svg objects), while preserving awareness for browser │ │ │ │ - // events on images: │ │ │ │ - // - Use the fill as usual (like for unrotated images) to handle │ │ │ │ - // events │ │ │ │ - // - specify an imagedata element with the same src as the fill │ │ │ │ - // - style the imagedata element with an AlphaImageLoader filter │ │ │ │ - // with empty src │ │ │ │ - var image = document.getElementById(node.id + "_image"); │ │ │ │ - if (!image) { │ │ │ │ - image = this.createNode("olv:imagedata", node.id + "_image"); │ │ │ │ - node.appendChild(image); │ │ │ │ + if (options.isStroked) { │ │ │ │ + node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ + node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ + node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ + node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ + // Hard-coded linejoin for now, to make it look the same as in VML. │ │ │ │ + // There is no strokeLinejoin property yet for symbolizers. │ │ │ │ + node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ + style.strokeDashstyle && node.setAttributeNS(null, │ │ │ │ + "stroke-dasharray", this.dashStyle(style, widthFactor)); │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "stroke", "none"); │ │ │ │ } │ │ │ │ - image.style.width = width + "px"; │ │ │ │ - image.style.height = height + "px"; │ │ │ │ - image.src = style.externalGraphic; │ │ │ │ - image.style.filter = │ │ │ │ - "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + │ │ │ │ - "src='', sizingMethod='scale')"; │ │ │ │ - │ │ │ │ - var rot = rotation * Math.PI / 180; │ │ │ │ - var sintheta = Math.sin(rot); │ │ │ │ - var costheta = Math.cos(rot); │ │ │ │ - │ │ │ │ - // do the rotation on the image │ │ │ │ - var filter = │ │ │ │ - "progid:DXImageTransform.Microsoft.Matrix(M11=" + costheta + │ │ │ │ - ",M12=" + (-sintheta) + ",M21=" + sintheta + ",M22=" + costheta + │ │ │ │ - ",SizingMethod='auto expand')\n"; │ │ │ │ │ │ │ │ - // set the opacity (needed for the imagedata) │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ - if (opacity && opacity != 1) { │ │ │ │ - filter += │ │ │ │ - "progid:DXImageTransform.Microsoft.BasicImage(opacity=" + │ │ │ │ - opacity + ")\n"; │ │ │ │ + if (style.pointerEvents) { │ │ │ │ + node.setAttributeNS(null, "pointer-events", style.pointerEvents); │ │ │ │ } │ │ │ │ - node.style.filter = filter; │ │ │ │ - │ │ │ │ - // do the rotation again on a box, so we know the insertion point │ │ │ │ - var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset); │ │ │ │ - var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry(); │ │ │ │ - imgBox.rotate(style.rotation, centerPoint); │ │ │ │ - var imgBounds = imgBox.getBounds(); │ │ │ │ - │ │ │ │ - node.style.left = Math.round( │ │ │ │ - parseInt(node.style.left) + imgBounds.left) + "px"; │ │ │ │ - node.style.top = Math.round( │ │ │ │ - parseInt(node.style.top) - imgBounds.bottom) + "px"; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: postDraw │ │ │ │ - * Does some node postprocessing to work around browser issues: │ │ │ │ - * - Some versions of Internet Explorer seem to be unable to set fillcolor │ │ │ │ - * and strokecolor to "none" correctly before the fill node is appended │ │ │ │ - * to a visible vml node. This method takes care of that and sets │ │ │ │ - * fillcolor and strokecolor again if needed. │ │ │ │ - * - In some cases, a node won't become visible after being drawn. Setting │ │ │ │ - * style.visibility to "visible" works around that. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - */ │ │ │ │ - postDraw: function(node) { │ │ │ │ - node.style.visibility = "visible"; │ │ │ │ - var fillColor = node._style.fillColor; │ │ │ │ - var strokeColor = node._style.strokeColor; │ │ │ │ - if (fillColor == "none" && │ │ │ │ - node.fillcolor != fillColor) { │ │ │ │ - node.fillcolor = fillColor; │ │ │ │ - } │ │ │ │ - if (strokeColor == "none" && │ │ │ │ - node.strokecolor != strokeColor) { │ │ │ │ - node.strokecolor = strokeColor; │ │ │ │ + if (style.cursor != null) { │ │ │ │ + node.setAttributeNS(null, "cursor", style.cursor); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setNodeDimension │ │ │ │ - * Get the geometry's bounds, convert it to our vml coordinate system, │ │ │ │ - * then set the node's position, size, and local coordinate system. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - */ │ │ │ │ - setNodeDimension: function(node, geometry) { │ │ │ │ - │ │ │ │ - var bbox = geometry.getBounds(); │ │ │ │ - if (bbox) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - │ │ │ │ - var scaledBox = │ │ │ │ - new OpenLayers.Bounds(((bbox.left - this.featureDx) / resolution - this.offset.x) | 0, │ │ │ │ - (bbox.bottom / resolution - this.offset.y) | 0, │ │ │ │ - ((bbox.right - this.featureDx) / resolution - this.offset.x) | 0, │ │ │ │ - (bbox.top / resolution - this.offset.y) | 0); │ │ │ │ - │ │ │ │ - // Set the internal coordinate system to draw the path │ │ │ │ - node.style.left = scaledBox.left + "px"; │ │ │ │ - node.style.top = scaledBox.top + "px"; │ │ │ │ - node.style.width = scaledBox.getWidth() + "px"; │ │ │ │ - node.style.height = scaledBox.getHeight() + "px"; │ │ │ │ │ │ │ │ - node.coordorigin = scaledBox.left + " " + scaledBox.top; │ │ │ │ - node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight(); │ │ │ │ - } │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: dashStyle │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * style - {Object} │ │ │ │ + * widthFactor - {Number} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A VML compliant 'stroke-dasharray' value │ │ │ │ + * {String} A SVG compliant 'stroke-dasharray' value │ │ │ │ */ │ │ │ │ - dashStyle: function(style) { │ │ │ │ - var dash = style.strokeDashstyle; │ │ │ │ - switch (dash) { │ │ │ │ + dashStyle: function(style, widthFactor) { │ │ │ │ + var w = style.strokeWidth * widthFactor; │ │ │ │ + var str = style.strokeDashstyle; │ │ │ │ + switch (str) { │ │ │ │ case 'solid': │ │ │ │ + return 'none'; │ │ │ │ case 'dot': │ │ │ │ + return [1, 4 * w].join(); │ │ │ │ case 'dash': │ │ │ │ + return [4 * w, 4 * w].join(); │ │ │ │ case 'dashdot': │ │ │ │ + return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ case 'longdash': │ │ │ │ + return [8 * w, 4 * w].join(); │ │ │ │ case 'longdashdot': │ │ │ │ - return dash; │ │ │ │ + return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ default: │ │ │ │ - // very basic guessing of dash style patterns │ │ │ │ - var parts = dash.split(/[ ,]/); │ │ │ │ - if (parts.length == 2) { │ │ │ │ - if (1 * parts[0] >= 2 * parts[1]) { │ │ │ │ - return "longdash"; │ │ │ │ - } │ │ │ │ - return (parts[0] == 1 || parts[1] == 1) ? "dot" : "dash"; │ │ │ │ - } else if (parts.length == 4) { │ │ │ │ - return (1 * parts[0] >= 2 * parts[1]) ? "longdashdot" : │ │ │ │ - "dashdot"; │ │ │ │ - } │ │ │ │ - return "solid"; │ │ │ │ + return OpenLayers.String.trim(str).replace(/\s+/g, ","); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: createNode │ │ │ │ - * Create a new node │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * type - {String} Kind of node to draw │ │ │ │ * id - {String} Id for node │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} A new node of the given type and id │ │ │ │ */ │ │ │ │ createNode: function(type, id) { │ │ │ │ - var node = document.createElement(type); │ │ │ │ + var node = document.createElementNS(this.xmlns, type); │ │ │ │ if (id) { │ │ │ │ - node.id = id; │ │ │ │ + node.setAttributeNS(null, "id", id); │ │ │ │ } │ │ │ │ - │ │ │ │ - // IE hack to make elements unselectable, to prevent 'blue flash' │ │ │ │ - // while dragging vectors; #1410 │ │ │ │ - node.unselectable = 'on'; │ │ │ │ - node.onselectstart = OpenLayers.Function.False; │ │ │ │ - │ │ │ │ return node; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: nodeTypeCompare │ │ │ │ - * Determine whether a node is of a given type │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} An VML element │ │ │ │ + * node - {SVGDomElement} An SVG element │ │ │ │ * type - {String} Kind of node │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {Boolean} Whether or not the specified node is of the specified type │ │ │ │ */ │ │ │ │ nodeTypeCompare: function(node, type) { │ │ │ │ - │ │ │ │ - //split type │ │ │ │ - var subType = type; │ │ │ │ - var splitIndex = subType.indexOf(":"); │ │ │ │ - if (splitIndex != -1) { │ │ │ │ - subType = subType.substr(splitIndex + 1); │ │ │ │ - } │ │ │ │ - │ │ │ │ - //split nodeName │ │ │ │ - var nodeName = node.nodeName; │ │ │ │ - splitIndex = nodeName.indexOf(":"); │ │ │ │ - if (splitIndex != -1) { │ │ │ │ - nodeName = nodeName.substr(splitIndex + 1); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return (subType == nodeName); │ │ │ │ + return (type == node.nodeName); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: createRenderRoot │ │ │ │ - * Create the renderer root │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} The specific render engine's root element │ │ │ │ */ │ │ │ │ createRenderRoot: function() { │ │ │ │ - return this.nodeFactory(this.container.id + "_vmlRoot", "div"); │ │ │ │ + var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ + svg.style.display = "block"; │ │ │ │ + return svg; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: createRoot │ │ │ │ - * Create the main root element │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * suffix - {String} suffix to append to the id │ │ │ │ - * │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ * {DOMElement} │ │ │ │ */ │ │ │ │ createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "olv:group"); │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "g"); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createDefs │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The element to which we'll add the symbol definitions │ │ │ │ + */ │ │ │ │ + createDefs: function() { │ │ │ │ + var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ + this.rendererRoot.appendChild(defs); │ │ │ │ + return defs; │ │ │ │ }, │ │ │ │ │ │ │ │ /************************************** │ │ │ │ * * │ │ │ │ * GEOMETRY DRAWING FUNCTIONS * │ │ │ │ * * │ │ │ │ **************************************/ │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawPoint │ │ │ │ - * Render a point │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or false if the point could not be drawn │ │ │ │ + * {DOMElement} or false if the renderer could not draw the point │ │ │ │ */ │ │ │ │ drawPoint: function(node, geometry) { │ │ │ │ return this.drawCircle(node, geometry, 1); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawCircle │ │ │ │ - * Render a circle. │ │ │ │ - * Size and Center a circle given geometry (x,y center) and radius │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * radius - {float} │ │ │ │ + * radius - {Float} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} or false if the circle could not ne drawn │ │ │ │ + * {DOMElement} or false if the renderer could not draw the circle │ │ │ │ */ │ │ │ │ drawCircle: function(node, geometry, radius) { │ │ │ │ - if (!isNaN(geometry.x) && !isNaN(geometry.y)) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - │ │ │ │ - node.style.left = ((((geometry.x - this.featureDx) / resolution - this.offset.x) | 0) - radius) + "px"; │ │ │ │ - node.style.top = (((geometry.y / resolution - this.offset.y) | 0) - radius) + "px"; │ │ │ │ - │ │ │ │ - var diameter = radius * 2; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (this.top - geometry.y / resolution); │ │ │ │ │ │ │ │ - node.style.width = diameter + "px"; │ │ │ │ - node.style.height = diameter + "px"; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "cx", x); │ │ │ │ + node.setAttributeNS(null, "cy", y); │ │ │ │ + node.setAttributeNS(null, "r", radius); │ │ │ │ return node; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawLineString │ │ │ │ - * Render a linestring. │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * {DOMElement} or null if the renderer could not draw all components of │ │ │ │ + * the linestring, or false if nothing could be drawn │ │ │ │ */ │ │ │ │ drawLineString: function(node, geometry) { │ │ │ │ - return this.drawLine(node, geometry, false); │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return (componentsResult.complete ? node : null); │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawLinearRing │ │ │ │ - * Render a linearring │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * {DOMElement} or null if the renderer could not draw all components │ │ │ │ + * of the linear ring, or false if nothing could be drawn │ │ │ │ */ │ │ │ │ drawLinearRing: function(node, geometry) { │ │ │ │ - return this.drawLine(node, geometry, true); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: DrawLine │ │ │ │ - * Render a line. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * closeLine - {Boolean} Close the line? (make it a ring?) │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - drawLine: function(node, geometry, closeLine) { │ │ │ │ - │ │ │ │ - this.setNodeDimension(node, geometry); │ │ │ │ - │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var numComponents = geometry.components.length; │ │ │ │ - var parts = new Array(numComponents); │ │ │ │ - │ │ │ │ - var comp, x, y; │ │ │ │ - for (var i = 0; i < numComponents; i++) { │ │ │ │ - comp = geometry.components[i]; │ │ │ │ - x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0; │ │ │ │ - y = (comp.y / resolution - this.offset.y) | 0; │ │ │ │ - parts[i] = " " + x + "," + y + " l "; │ │ │ │ - } │ │ │ │ - var end = (closeLine) ? " x e" : " e"; │ │ │ │ - node.path = "m" + parts.join("") + end; │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawPolygon │ │ │ │ - * Render a polygon │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - drawPolygon: function(node, geometry) { │ │ │ │ - this.setNodeDimension(node, geometry); │ │ │ │ - │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - │ │ │ │ - var path = []; │ │ │ │ - var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y; │ │ │ │ - for (j = 0, jj = geometry.components.length; j < jj; j++) { │ │ │ │ - path.push("m"); │ │ │ │ - points = geometry.components[j].components; │ │ │ │ - // we only close paths of interior rings with area │ │ │ │ - area = (j === 0); │ │ │ │ - first = null; │ │ │ │ - second = null; │ │ │ │ - for (i = 0, ii = points.length; i < ii; i++) { │ │ │ │ - comp = points[i]; │ │ │ │ - x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0; │ │ │ │ - y = (comp.y / resolution - this.offset.y) | 0; │ │ │ │ - pathComp = " " + x + "," + y; │ │ │ │ - path.push(pathComp); │ │ │ │ - if (i == 0) { │ │ │ │ - path.push(" l"); │ │ │ │ - } │ │ │ │ - if (!area) { │ │ │ │ - // IE improperly renders sub-paths that have no area. │ │ │ │ - // Instead of checking the area of every ring, we confirm │ │ │ │ - // the ring has at least three distinct points. This does │ │ │ │ - // not catch all non-zero area cases, but it greatly improves │ │ │ │ - // interior ring digitizing and is a minor performance hit │ │ │ │ - // when rendering rings with many points. │ │ │ │ - if (!first) { │ │ │ │ - first = pathComp; │ │ │ │ - } else if (first != pathComp) { │ │ │ │ - if (!second) { │ │ │ │ - second = pathComp; │ │ │ │ - } else if (second != pathComp) { │ │ │ │ - // stop looking │ │ │ │ - area = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return (componentsResult.complete ? node : null); │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: drawPolygon │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} or null if the renderer could not draw all components │ │ │ │ + * of the polygon, or false if nothing could be drawn │ │ │ │ + */ │ │ │ │ + drawPolygon: function(node, geometry) { │ │ │ │ + var d = ""; │ │ │ │ + var draw = true; │ │ │ │ + var complete = true; │ │ │ │ + var linearRingResult, path; │ │ │ │ + for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ + d += " M"; │ │ │ │ + linearRingResult = this.getComponentsString( │ │ │ │ + geometry.components[j].components, " "); │ │ │ │ + path = linearRingResult.path; │ │ │ │ + if (path) { │ │ │ │ + d += " " + path; │ │ │ │ + complete = linearRingResult.complete && complete; │ │ │ │ + } else { │ │ │ │ + draw = false; │ │ │ │ } │ │ │ │ - path.push(area ? " x " : " "); │ │ │ │ } │ │ │ │ - path.push("e"); │ │ │ │ - node.path = path.join(""); │ │ │ │ - return node; │ │ │ │ + d += " z"; │ │ │ │ + if (draw) { │ │ │ │ + node.setAttributeNS(null, "d", d); │ │ │ │ + node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ + return complete ? node : null; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawRectangle │ │ │ │ - * Render a rectangle │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ + * Parameters: │ │ │ │ * node - {DOMElement} │ │ │ │ * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * {DOMElement} or false if the renderer could not draw the rectangle │ │ │ │ */ │ │ │ │ drawRectangle: function(node, geometry) { │ │ │ │ var resolution = this.getResolution(); │ │ │ │ + var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (this.top - geometry.y / resolution); │ │ │ │ │ │ │ │ - node.style.left = (((geometry.x - this.featureDx) / resolution - this.offset.x) | 0) + "px"; │ │ │ │ - node.style.top = ((geometry.y / resolution - this.offset.y) | 0) + "px"; │ │ │ │ - node.style.width = ((geometry.width / resolution) | 0) + "px"; │ │ │ │ - node.style.height = ((geometry.height / resolution) | 0) + "px"; │ │ │ │ - │ │ │ │ - return node; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "x", x); │ │ │ │ + node.setAttributeNS(null, "y", y); │ │ │ │ + node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ + node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ + return node; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: drawText │ │ │ │ * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ * featureId - {String} │ │ │ │ * style - │ │ │ │ * location - {<OpenLayers.Geometry.Point>} │ │ │ │ */ │ │ │ │ drawText: function(featureId, style, location) { │ │ │ │ - var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect"); │ │ │ │ - var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox"); │ │ │ │ + var drawOutline = (!!style.labelOutlineWidth); │ │ │ │ + // First draw text in halo color and size and overlay the │ │ │ │ + // normal text afterwards │ │ │ │ + if (drawOutline) { │ │ │ │ + var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ + outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ + if (style.labelOutlineOpacity) { │ │ │ │ + outlineStyle.fontOpacity = style.labelOutlineOpacity; │ │ │ │ + } │ │ │ │ + delete outlineStyle.labelOutlineWidth; │ │ │ │ + this.drawText(featureId, outlineStyle, location); │ │ │ │ + } │ │ │ │ │ │ │ │ var resolution = this.getResolution(); │ │ │ │ - label.style.left = (((location.x - this.featureDx) / resolution - this.offset.x) | 0) + "px"; │ │ │ │ - label.style.top = ((location.y / resolution - this.offset.y) | 0) + "px"; │ │ │ │ - label.style.flip = "y"; │ │ │ │ │ │ │ │ - textbox.innerText = style.label; │ │ │ │ + var x = ((location.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (location.y / resolution - this.top); │ │ │ │ + │ │ │ │ + var suffix = (drawOutline) ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ + var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ + │ │ │ │ + label.setAttributeNS(null, "x", x); │ │ │ │ + label.setAttributeNS(null, "y", -y); │ │ │ │ │ │ │ │ - if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ - textbox.style.cursor = style.cursor; │ │ │ │ - } │ │ │ │ if (style.fontColor) { │ │ │ │ - textbox.style.color = style.fontColor; │ │ │ │ + label.setAttributeNS(null, "fill", style.fontColor); │ │ │ │ + } │ │ │ │ + if (style.fontStrokeColor) { │ │ │ │ + label.setAttributeNS(null, "stroke", style.fontStrokeColor); │ │ │ │ + } │ │ │ │ + if (style.fontStrokeWidth) { │ │ │ │ + label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth); │ │ │ │ } │ │ │ │ if (style.fontOpacity) { │ │ │ │ - textbox.style.filter = 'alpha(opacity=' + (style.fontOpacity * 100) + ')'; │ │ │ │ + label.setAttributeNS(null, "opacity", style.fontOpacity); │ │ │ │ } │ │ │ │ if (style.fontFamily) { │ │ │ │ - textbox.style.fontFamily = style.fontFamily; │ │ │ │ + label.setAttributeNS(null, "font-family", style.fontFamily); │ │ │ │ } │ │ │ │ if (style.fontSize) { │ │ │ │ - textbox.style.fontSize = style.fontSize; │ │ │ │ + label.setAttributeNS(null, "font-size", style.fontSize); │ │ │ │ } │ │ │ │ if (style.fontWeight) { │ │ │ │ - textbox.style.fontWeight = style.fontWeight; │ │ │ │ + label.setAttributeNS(null, "font-weight", style.fontWeight); │ │ │ │ } │ │ │ │ if (style.fontStyle) { │ │ │ │ - textbox.style.fontStyle = style.fontStyle; │ │ │ │ + label.setAttributeNS(null, "font-style", style.fontStyle); │ │ │ │ } │ │ │ │ if (style.labelSelect === true) { │ │ │ │ + label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ label._featureId = featureId; │ │ │ │ - textbox._featureId = featureId; │ │ │ │ - textbox._geometry = location; │ │ │ │ - textbox._geometryClass = location.CLASS_NAME; │ │ │ │ + } else { │ │ │ │ + label.setAttributeNS(null, "pointer-events", "none"); │ │ │ │ + } │ │ │ │ + var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ + label.setAttributeNS(null, "text-anchor", │ │ │ │ + OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ + │ │ │ │ + if (OpenLayers.IS_GECKO === true) { │ │ │ │ + label.setAttributeNS(null, "dominant-baseline", │ │ │ │ + OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central"); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var labelRows = style.label.split('\n'); │ │ │ │ + var numRows = labelRows.length; │ │ │ │ + while (label.childNodes.length > numRows) { │ │ │ │ + label.removeChild(label.lastChild); │ │ │ │ + } │ │ │ │ + for (var i = 0; i < numRows; i++) { │ │ │ │ + var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + tspan._featureId = featureId; │ │ │ │ + tspan._geometry = location; │ │ │ │ + tspan._geometryClass = location.CLASS_NAME; │ │ │ │ + } │ │ │ │ + if (OpenLayers.IS_GECKO === false) { │ │ │ │ + tspan.setAttributeNS(null, "baseline-shift", │ │ │ │ + OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%"); │ │ │ │ + } │ │ │ │ + tspan.setAttribute("x", x); │ │ │ │ + if (i == 0) { │ │ │ │ + var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ + if (vfactor == null) { │ │ │ │ + vfactor = -.5; │ │ │ │ + } │ │ │ │ + tspan.setAttribute("dy", (vfactor * (numRows - 1)) + "em"); │ │ │ │ + } else { │ │ │ │ + tspan.setAttribute("dy", "1em"); │ │ │ │ + } │ │ │ │ + tspan.textContent = (labelRows[i] === '') ? ' ' : labelRows[i]; │ │ │ │ + if (!tspan.parentNode) { │ │ │ │ + label.appendChild(tspan); │ │ │ │ + } │ │ │ │ } │ │ │ │ - textbox.style.whiteSpace = "nowrap"; │ │ │ │ - // fun with IE: IE7 in standards compliant mode does not display any │ │ │ │ - // text with a left inset of 0. So we set this to 1px and subtract one │ │ │ │ - // pixel later when we set label.style.left │ │ │ │ - textbox.inset = "1px,0px,0px,0px"; │ │ │ │ │ │ │ │ if (!label.parentNode) { │ │ │ │ - label.appendChild(textbox); │ │ │ │ this.textRoot.appendChild(label); │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var align = style.labelAlign || "cm"; │ │ │ │ - if (align.length == 1) { │ │ │ │ - align += "m"; │ │ │ │ + /** │ │ │ │ + * Method: getComponentString │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry.Point>)} Array of points │ │ │ │ + * separator - {String} character between coordinate pairs. Defaults to "," │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} hash with properties "path" (the string created from the │ │ │ │ + * components and "complete" (false if the renderer was unable to │ │ │ │ + * draw all components) │ │ │ │ + */ │ │ │ │ + getComponentsString: function(components, separator) { │ │ │ │ + var renderCmp = []; │ │ │ │ + var complete = true; │ │ │ │ + var len = components.length; │ │ │ │ + var strings = []; │ │ │ │ + var str, component; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + component = components[i]; │ │ │ │ + renderCmp.push(component); │ │ │ │ + str = this.getShortString(component); │ │ │ │ + if (str) { │ │ │ │ + strings.push(str); │ │ │ │ + } else { │ │ │ │ + // The current component is outside the valid range. Let's │ │ │ │ + // see if the previous or next component is inside the range. │ │ │ │ + // If so, add the coordinate of the intersection with the │ │ │ │ + // valid range bounds. │ │ │ │ + if (i > 0) { │ │ │ │ + if (this.getShortString(components[i - 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], │ │ │ │ + components[i - 1])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (i < len - 1) { │ │ │ │ + if (this.getShortString(components[i + 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], │ │ │ │ + components[i + 1])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + complete = false; │ │ │ │ + } │ │ │ │ } │ │ │ │ - var xshift = textbox.clientWidth * │ │ │ │ - (OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)]); │ │ │ │ - var yshift = textbox.clientHeight * │ │ │ │ - (OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)]); │ │ │ │ - label.style.left = parseInt(label.style.left) - xshift - 1 + "px"; │ │ │ │ - label.style.top = parseInt(label.style.top) + yshift + "px"; │ │ │ │ │ │ │ │ + return { │ │ │ │ + path: strings.join(separator || ","), │ │ │ │ + complete: complete │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveRoot │ │ │ │ - * moves this renderer's root to a different renderer. │ │ │ │ + * Method: clipLine │ │ │ │ + * Given two points (one inside the valid range, and one outside), │ │ │ │ + * clips the line betweeen the two points so that the new points are both │ │ │ │ + * inside the valid range. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * renderer - {<OpenLayers.Renderer>} target renderer for the moved root │ │ │ │ - * root - {DOMElement} optional root node. To be used when this renderer │ │ │ │ - * holds roots from multiple layers to tell this method which one to │ │ │ │ - * detach │ │ │ │ + * badComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ + * invalid point │ │ │ │ + * goodComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ + * valid point │ │ │ │ + * Returns │ │ │ │ + * {String} the SVG coordinate pair of the clipped point (like │ │ │ │ + * getShortString), or an empty string if both passed componets are at │ │ │ │ + * the same point. │ │ │ │ + */ │ │ │ │ + clipLine: function(badComponent, goodComponent) { │ │ │ │ + if (goodComponent.equals(badComponent)) { │ │ │ │ + return ""; │ │ │ │ + } │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ + var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ + var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y1 = this.top - goodComponent.y / resolution; │ │ │ │ + var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y2 = this.top - badComponent.y / resolution; │ │ │ │ + var k; │ │ │ │ + if (x2 < -maxX || x2 > maxX) { │ │ │ │ + k = (y2 - y1) / (x2 - x1); │ │ │ │ + x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ + y2 = y1 + (x2 - x1) * k; │ │ │ │ + } │ │ │ │ + if (y2 < -maxY || y2 > maxY) { │ │ │ │ + k = (x2 - x1) / (y2 - y1); │ │ │ │ + y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ + x2 = x1 + (y2 - y1) * k; │ │ │ │ + } │ │ │ │ + return x2 + "," + y2; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getShortString │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} true if successful, false otherwise │ │ │ │ + * {String} or false if point is outside the valid range │ │ │ │ */ │ │ │ │ - moveRoot: function(renderer) { │ │ │ │ - var layer = this.map.getLayer(renderer.container.id); │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector.RootContainer) { │ │ │ │ - layer = this.map.getLayer(this.container.id); │ │ │ │ + getShortString: function(point) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = ((point.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (this.top - point.y / resolution); │ │ │ │ + │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + return x + "," + y; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - layer && layer.renderer.clear(); │ │ │ │ - OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments); │ │ │ │ - layer && layer.redraw(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getPosition │ │ │ │ + * Finds the position of an svg node. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} hash with x and y properties, representing the coordinates │ │ │ │ + * within the svg coordinate system │ │ │ │ + */ │ │ │ │ + getPosition: function(node) { │ │ │ │ + return ({ │ │ │ │ + x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ + y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: importSymbol │ │ │ │ * add a new symbol definition from the rendererer's symbol hash │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * graphicName - {String} name of the symbol to import │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} - hash of {DOMElement} "symbol" and {Number} "size" │ │ │ │ + * {DOMElement} - the imported symbol │ │ │ │ */ │ │ │ │ importSymbol: function(graphicName) { │ │ │ │ + if (!this.defs) { │ │ │ │ + // create svg defs tag │ │ │ │ + this.defs = this.createDefs(); │ │ │ │ + } │ │ │ │ var id = this.container.id + "-" + graphicName; │ │ │ │ │ │ │ │ - // check if symbol already exists in the cache │ │ │ │ - var cache = this.symbolCache[id]; │ │ │ │ - if (cache) { │ │ │ │ - return cache; │ │ │ │ + // check if symbol already exists in the defs │ │ │ │ + var existing = document.getElementById(id); │ │ │ │ + if (existing != null) { │ │ │ │ + return existing; │ │ │ │ } │ │ │ │ │ │ │ │ var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ if (!symbol) { │ │ │ │ throw new Error(graphicName + ' is not a valid symbol name'); │ │ │ │ } │ │ │ │ │ │ │ │ + var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ + var node = this.nodeFactory(null, "polygon"); │ │ │ │ + symbolNode.appendChild(node); │ │ │ │ var symbolExtent = new OpenLayers.Bounds( │ │ │ │ Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ │ │ │ │ - var pathitems = ["m"]; │ │ │ │ + var points = []; │ │ │ │ + var x, y; │ │ │ │ for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - var x = symbol[i]; │ │ │ │ - var y = symbol[i + 1]; │ │ │ │ + x = symbol[i]; │ │ │ │ + y = symbol[i + 1]; │ │ │ │ symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - │ │ │ │ - pathitems.push(x); │ │ │ │ - pathitems.push(y); │ │ │ │ - if (i == 0) { │ │ │ │ - pathitems.push("l"); │ │ │ │ - } │ │ │ │ + points.push(x, ",", y); │ │ │ │ } │ │ │ │ - pathitems.push("x e"); │ │ │ │ - var path = pathitems.join(" "); │ │ │ │ │ │ │ │ - var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2; │ │ │ │ - if (diff > 0) { │ │ │ │ - symbolExtent.bottom = symbolExtent.bottom - diff; │ │ │ │ - symbolExtent.top = symbolExtent.top + diff; │ │ │ │ - } else { │ │ │ │ - symbolExtent.left = symbolExtent.left + diff; │ │ │ │ - symbolExtent.right = symbolExtent.right - diff; │ │ │ │ - } │ │ │ │ + node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ │ │ │ │ - cache = { │ │ │ │ - path: path, │ │ │ │ - size: symbolExtent.getWidth(), // equals getHeight() now │ │ │ │ - left: symbolExtent.left, │ │ │ │ - bottom: symbolExtent.bottom │ │ │ │ - }; │ │ │ │ - this.symbolCache[id] = cache; │ │ │ │ + var width = symbolExtent.getWidth(); │ │ │ │ + var height = symbolExtent.getHeight(); │ │ │ │ + // create a viewBox three times as large as the symbol itself, │ │ │ │ + // to allow for strokeWidth being displayed correctly at the corners. │ │ │ │ + var viewBox = [symbolExtent.left - width, │ │ │ │ + symbolExtent.bottom - height, width * 3, height * 3 │ │ │ │ + ]; │ │ │ │ + symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ + this.symbolMetrics[id] = [ │ │ │ │ + Math.max(width, height), │ │ │ │ + symbolExtent.getCenterLonLat().lon, │ │ │ │ + symbolExtent.getCenterLonLat().lat │ │ │ │ + ]; │ │ │ │ │ │ │ │ - return cache; │ │ │ │ + this.defs.appendChild(symbolNode); │ │ │ │ + return symbolNode; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.VML" │ │ │ │ + /** │ │ │ │ + * Method: getFeatureIdFromEvent │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} An <OpenLayers.Event> object │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A feature id or undefined. │ │ │ │ + */ │ │ │ │ + getFeatureIdFromEvent: function(evt) { │ │ │ │ + var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ + if (!featureId) { │ │ │ │ + var target = evt.target; │ │ │ │ + featureId = target.parentNode && target != this.rendererRoot ? │ │ │ │ + target.parentNode._featureId : undefined; │ │ │ │ + } │ │ │ │ + return featureId; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ }); │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: OpenLayers.Renderer.VML.LABEL_SHIFT │ │ │ │ + * Constant: OpenLayers.Renderer.SVG.LABEL_ALIGN │ │ │ │ * {Object} │ │ │ │ */ │ │ │ │ -OpenLayers.Renderer.VML.LABEL_SHIFT = { │ │ │ │ - "l": 0, │ │ │ │ - "c": .5, │ │ │ │ - "r": 1, │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ + "l": "start", │ │ │ │ + "r": "end", │ │ │ │ + "b": "bottom", │ │ │ │ + "t": "hanging" │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Renderer.SVG.LABEL_VSHIFT │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ + // according to │ │ │ │ + // http://www.w3.org/Graphics/SVG/Test/20061213/htmlObjectHarness/full-text-align-02-b.html │ │ │ │ + // a baseline-shift of -70% shifts the text exactly from the │ │ │ │ + // bottom to the top of the baseline, so -35% moves the text to │ │ │ │ + // the center of the baseline. │ │ │ │ + "t": "-70%", │ │ │ │ + "b": "0" │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Renderer.SVG.LABEL_VFACTOR │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ "t": 0, │ │ │ │ - "m": .5, │ │ │ │ - "b": 1 │ │ │ │ + "b": -1 │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Renderer.SVG.preventDefault │ │ │ │ + * *Deprecated*. Use <OpenLayers.Event.preventDefault> method instead. │ │ │ │ + * Used to prevent default events (especially opening images in a new tab on │ │ │ │ + * ctrl-click) from being executed for externalGraphic symbols │ │ │ │ + */ │ │ │ │ +OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ + OpenLayers.Event.preventDefault(e); │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Marker/Box.js │ │ │ │ + OpenLayers/Control/Panel.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Marker.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Marker.Box │ │ │ │ + * Class: OpenLayers.Control.Panel │ │ │ │ + * The Panel control is a container for other controls. With it toolbars │ │ │ │ + * may be composed. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Marker> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Marker.Box = OpenLayers.Class(OpenLayers.Marker, { │ │ │ │ +OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + /** │ │ │ │ + * Property: controls │ │ │ │ + * {Array(<OpenLayers.Control>)} │ │ │ │ + */ │ │ │ │ + controls: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: bounds │ │ │ │ - * {<OpenLayers.Bounds>} │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - bounds: null, │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: div │ │ │ │ - * {DOMElement} │ │ │ │ + * APIProperty: defaultControl │ │ │ │ + * {<OpenLayers.Control>} The control which is activated when the control is │ │ │ │ + * activated (turned on), which also happens at instantiation. │ │ │ │ + * If <saveState> is true, <defaultControl> will be nullified after the │ │ │ │ + * first activation of the panel. │ │ │ │ */ │ │ │ │ - div: null, │ │ │ │ + defaultControl: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Marker.Box │ │ │ │ + /** │ │ │ │ + * APIProperty: saveState │ │ │ │ + * {Boolean} If set to true, the active state of this panel's controls will │ │ │ │ + * be stored on panel deactivation, and restored on reactivation. Default │ │ │ │ + * is false. │ │ │ │ + */ │ │ │ │ + saveState: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: allowDepress │ │ │ │ + * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can │ │ │ │ + * be deactivated by clicking the icon that represents them. Default │ │ │ │ + * is false. │ │ │ │ + */ │ │ │ │ + allowDepress: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: activeState │ │ │ │ + * {Object} stores the active state of this panel's controls. │ │ │ │ + */ │ │ │ │ + activeState: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.Panel │ │ │ │ + * Create a new control panel. │ │ │ │ + * │ │ │ │ + * Each control in the panel is represented by an icon. When clicking │ │ │ │ + * on an icon, the <activateControl> method is called. │ │ │ │ + * │ │ │ │ + * Specific properties for controls on a panel: │ │ │ │ + * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>, │ │ │ │ + * <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>. │ │ │ │ + * If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed. │ │ │ │ + * title - {string} Text displayed when mouse is over the icon that │ │ │ │ + * represents the control. │ │ │ │ + * │ │ │ │ + * The <OpenLayers.Control.type> of a control determines the behavior when │ │ │ │ + * clicking its icon: │ │ │ │ + * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other │ │ │ │ + * controls of this type in the same panel are deactivated. This is │ │ │ │ + * the default type. │ │ │ │ + * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is │ │ │ │ + * toggled. │ │ │ │ + * <OpenLayers.Control.TYPE_BUTTON> - The │ │ │ │ + * <OpenLayers.Control.Button.trigger> method of the control is called, │ │ │ │ + * but its active state is not changed. │ │ │ │ + * │ │ │ │ + * If a control is <OpenLayers.Control.active>, it will be drawn with the │ │ │ │ + * olControl[Name]ItemActive class, otherwise with the │ │ │ │ + * olControl[Name]ItemInactive class. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - * borderColor - {String} │ │ │ │ - * borderWidth - {int} │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ */ │ │ │ │ - initialize: function(bounds, borderColor, borderWidth) { │ │ │ │ - this.bounds = bounds; │ │ │ │ - this.div = OpenLayers.Util.createDiv(); │ │ │ │ - this.div.style.overflow = 'hidden'; │ │ │ │ - this.events = new OpenLayers.Events(this, this.div); │ │ │ │ - this.setBorder(borderColor, borderWidth); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.controls = []; │ │ │ │ + this.activeState = {}; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - │ │ │ │ - this.bounds = null; │ │ │ │ - this.div = null; │ │ │ │ - │ │ │ │ - OpenLayers.Marker.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ + ctl = this.controls[i]; │ │ │ │ + if (ctl.events) { │ │ │ │ + ctl.events.un({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + ctl.panel_div = null; │ │ │ │ + } │ │ │ │ + this.activeState = null; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setBorder │ │ │ │ - * Allow the user to change the box's color and border width │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * color - {String} Default is "red" │ │ │ │ - * width - {int} Default is 2 │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ */ │ │ │ │ - setBorder: function(color, width) { │ │ │ │ - if (!color) { │ │ │ │ - color = "red"; │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + if (control === this.defaultControl || │ │ │ │ + (this.saveState && this.activeState[control.id])) { │ │ │ │ + control.activate(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.saveState === true) { │ │ │ │ + this.defaultControl = null; │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - if (!width) { │ │ │ │ - width = 2; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + this.activeState[control.id] = control.deactivate(); │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - this.div.style.border = width + "px solid " + color; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ + /** │ │ │ │ * Method: draw │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - * sz - {<OpenLayers.Size>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A new DOM Image with this marker's icon set at the │ │ │ │ - * location passed-in │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - draw: function(px, sz) { │ │ │ │ - OpenLayers.Util.modifyDOMElement(this.div, null, px, sz); │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + } │ │ │ │ + this.addControlsToMap(this.controls); │ │ │ │ return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onScreen │ │ │ │ - * │ │ │ │ - * Rreturn: │ │ │ │ - * {Boolean} Whether or not the marker is currently visible on screen. │ │ │ │ + * Method: redraw │ │ │ │ */ │ │ │ │ - onScreen: function() { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.map) { │ │ │ │ - var screenBounds = this.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsBounds(this.bounds, true, true); │ │ │ │ + redraw: function() { │ │ │ │ + for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ + this.div.removeChild(this.div.childNodes[i]); │ │ │ │ + } │ │ │ │ + this.div.innerHTML = ""; │ │ │ │ + if (this.active) { │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + this.div.appendChild(this.controls[i].panel_div); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return onScreen; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: display │ │ │ │ - * Hide or show the icon │ │ │ │ - * │ │ │ │ + * APIMethod: activateControl │ │ │ │ + * This method is called when the user click on the icon representing a │ │ │ │ + * control in the panel. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * display - {Boolean} │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ */ │ │ │ │ - display: function(display) { │ │ │ │ - this.div.style.display = (display) ? "" : "none"; │ │ │ │ + activateControl: function(control) { │ │ │ │ + if (!this.active) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ + control.trigger(); │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ + if (control.active) { │ │ │ │ + control.deactivate(); │ │ │ │ + } else { │ │ │ │ + control.activate(); │ │ │ │ + } │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + if (this.allowDepress && control.active) { │ │ │ │ + control.deactivate(); │ │ │ │ + } else { │ │ │ │ + var c; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + c = this.controls[i]; │ │ │ │ + if (c != control && │ │ │ │ + (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ + c.deactivate(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + control.activate(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Marker.Box" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/QueryStringFilter.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Console.js │ │ │ │ - * @requires OpenLayers/Format.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ - * @requires OpenLayers/Filter/Comparison.js │ │ │ │ - * @requires OpenLayers/Filter/Logical.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIMethod: addControls │ │ │ │ + * To build a toolbar, you add a set of controls to it. addControls │ │ │ │ + * lets you add a single control or a list of controls to the │ │ │ │ + * Control Panel. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * controls - {<OpenLayers.Control>} Controls to add in the panel. │ │ │ │ + */ │ │ │ │ + addControls: function(controls) { │ │ │ │ + if (!(OpenLayers.Util.isArray(controls))) { │ │ │ │ + controls = [controls]; │ │ │ │ + } │ │ │ │ + this.controls = this.controls.concat(controls); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.QueryStringFilter │ │ │ │ - * Parser for reading a query string and creating a simple filter. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.QueryStringFilter = (function() { │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + var control = controls[i], │ │ │ │ + element = this.createControlMarkup(control); │ │ │ │ + OpenLayers.Element.addClass(element, │ │ │ │ + control.displayClass + "ItemInactive"); │ │ │ │ + OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ + if (control.title != "" && !element.title) { │ │ │ │ + element.title = control.title; │ │ │ │ + } │ │ │ │ + control.panel_div = element; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Map the OpenLayers.Filter.Comparison types to the operation strings of │ │ │ │ - * the protocol. │ │ │ │ - */ │ │ │ │ - var cmpToStr = {}; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.EQUAL_TO] = "eq"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.NOT_EQUAL_TO] = "ne"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN] = "lt"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO] = "lte"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN] = "gt"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO] = "gte"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.LIKE] = "ilike"; │ │ │ │ + if (this.map) { // map.addControl() has already been called on the panel │ │ │ │ + this.addControlsToMap(controls); │ │ │ │ + this.redraw(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Function: regex2value │ │ │ │ - * Convert the value from a regular expression string to a LIKE/ILIKE │ │ │ │ - * string known to the web service. │ │ │ │ + * APIMethod: createControlMarkup │ │ │ │ + * This function just creates a div for the control. If specific HTML │ │ │ │ + * markup is needed this function can be overridden in specific classes, │ │ │ │ + * or at panel instantiation time: │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var panel = new OpenLayers.Control.Panel({ │ │ │ │ + * defaultControl: control, │ │ │ │ + * // ovverride createControlMarkup to create actual buttons │ │ │ │ + * // including texts wrapped into span elements. │ │ │ │ + * createControlMarkup: function(control) { │ │ │ │ + * var button = document.createElement('button'), │ │ │ │ + * span = document.createElement('span'); │ │ │ │ + * if (control.text) { │ │ │ │ + * span.innerHTML = control.text; │ │ │ │ + * } │ │ │ │ + * return button; │ │ │ │ + * } │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * value - {String} The regex string. │ │ │ │ + * control - {<OpenLayers.Control>} The control to create the HTML │ │ │ │ + * markup for. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} The converted string. │ │ │ │ + * {DOMElement} The markup. │ │ │ │ */ │ │ │ │ - function regex2value(value) { │ │ │ │ - │ │ │ │ - // highly sensitive!! Do not change this without running the │ │ │ │ - // Protocol/HTTP.html unit tests │ │ │ │ - │ │ │ │ - // convert % to \% │ │ │ │ - value = value.replace(/%/g, "\\%"); │ │ │ │ - │ │ │ │ - // convert \\. to \\_ (\\.* occurences converted later) │ │ │ │ - value = value.replace(/\\\\\.(\*)?/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "\\\\_"; │ │ │ │ - }); │ │ │ │ + createControlMarkup: function(control) { │ │ │ │ + return document.createElement("div"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // convert \\.* to \\% │ │ │ │ - value = value.replace(/\\\\\.\*/g, "\\\\%"); │ │ │ │ + /** │ │ │ │ + * Method: addControlsToMap │ │ │ │ + * Only for internal use in draw() and addControls() methods. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * controls - {Array(<OpenLayers.Control>)} Controls to add into map. │ │ │ │ + */ │ │ │ │ + addControlsToMap: function(controls) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + control = controls[i]; │ │ │ │ + if (control.autoActivate === true) { │ │ │ │ + control.autoActivate = false; │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.autoActivate = true; │ │ │ │ + } else { │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.deactivate(); │ │ │ │ + } │ │ │ │ + control.events.on({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - // convert . to _ (\. and .* occurences converted later) │ │ │ │ - value = value.replace(/(\\)?\.(\*)?/g, function($0, $1, $2) { │ │ │ │ - return $1 || $2 ? $0 : "_"; │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: iconOn │ │ │ │ + * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ + */ │ │ │ │ + iconOn: function() { │ │ │ │ + var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Active"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // convert .* to % (\.* occurnces converted later) │ │ │ │ - value = value.replace(/(\\)?\.\*/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "%"; │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: iconOff │ │ │ │ + * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ + */ │ │ │ │ + iconOff: function() { │ │ │ │ + var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Inactive"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // convert \. to . │ │ │ │ - value = value.replace(/\\\./g, "."); │ │ │ │ + /** │ │ │ │ + * Method: onButtonClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var controls = this.controls, │ │ │ │ + button = evt.buttonElement; │ │ │ │ + for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ + if (controls[i].panel_div === button) { │ │ │ │ + this.activateControl(controls[i]); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - // replace \* with * (watching out for \\*) │ │ │ │ - value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "*"; │ │ │ │ + /** │ │ │ │ + * APIMethod: getControlsBy │ │ │ │ + * Get a list of controls with properties matching the given criteria. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * property - {String} A control property to be matched. │ │ │ │ + * match - {String | Object} A string to match. Can also be a regular │ │ │ │ + * expression literal or object. In addition, it can be any object │ │ │ │ + * with a method named test. For reqular expressions or other, if │ │ │ │ + * match.test(control[property]) evaluates to true, the control will be │ │ │ │ + * included in the array returned. If no controls are found, an empty │ │ │ │ + * array is returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Control>)} A list of controls matching the given criteria. │ │ │ │ + * An empty array is returned if no matches are found. │ │ │ │ + */ │ │ │ │ + getControlsBy: function(property, match) { │ │ │ │ + var test = (typeof match.test == "function"); │ │ │ │ + var found = OpenLayers.Array.filter(this.controls, function(item) { │ │ │ │ + return item[property] == match || (test && match.test(item[property])); │ │ │ │ }); │ │ │ │ + return found; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return value; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: wildcarded. │ │ │ │ - * {Boolean} If true percent signs are added around values │ │ │ │ - * read from LIKE filters, for example if the protocol │ │ │ │ - * read method is passed a LIKE filter whose property │ │ │ │ - * is "foo" and whose value is "bar" the string │ │ │ │ - * "foo__ilike=%bar%" will be sent in the query string; │ │ │ │ - * defaults to false. │ │ │ │ - */ │ │ │ │ - wildcarded: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: srsInBBOX │ │ │ │ - * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ - * Default is false. If true and the layer has a projection object set, │ │ │ │ - * any BBOX filter will be serialized with a fifth item identifying the │ │ │ │ - * projection. E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ - */ │ │ │ │ - srsInBBOX: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Serialize an <OpenLayers.Filter> objects using the "simple" filter syntax for │ │ │ │ - * query string parameters. This function must be called as a method of │ │ │ │ - * a protocol instance. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ - * params - {Object} The parameters object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The resulting parameters object. │ │ │ │ - */ │ │ │ │ - write: function(filter, params) { │ │ │ │ - params = params || {}; │ │ │ │ - var className = filter.CLASS_NAME; │ │ │ │ - var filterType = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ - switch (filterType) { │ │ │ │ - case "Spatial": │ │ │ │ - switch (filter.type) { │ │ │ │ - case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ - params.bbox = filter.value.toArray(); │ │ │ │ - if (this.srsInBBOX && filter.projection) { │ │ │ │ - params.bbox.push(filter.projection.getCode()); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ - params.tolerance = filter.distance; │ │ │ │ - // no break here │ │ │ │ - case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ - params.lon = filter.value.x; │ │ │ │ - params.lat = filter.value.y; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - OpenLayers.Console.warn( │ │ │ │ - "Unknown spatial filter type " + filter.type); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "Comparison": │ │ │ │ - var op = cmpToStr[filter.type]; │ │ │ │ - if (op !== undefined) { │ │ │ │ - var value = filter.value; │ │ │ │ - if (filter.type == OpenLayers.Filter.Comparison.LIKE) { │ │ │ │ - value = regex2value(value); │ │ │ │ - if (this.wildcarded) { │ │ │ │ - value = "%" + value + "%"; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - params[filter.property + "__" + op] = value; │ │ │ │ - params.queryable = params.queryable || []; │ │ │ │ - params.queryable.push(filter.property); │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.warn( │ │ │ │ - "Unknown comparison filter type " + filter.type); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "Logical": │ │ │ │ - if (filter.type === OpenLayers.Filter.Logical.AND) { │ │ │ │ - for (var i = 0, len = filter.filters.length; i < len; i++) { │ │ │ │ - params = this.write(filter.filters[i], params); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.warn( │ │ │ │ - "Unsupported logical filter type " + filter.type); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - OpenLayers.Console.warn("Unknown filter type " + filterType); │ │ │ │ - } │ │ │ │ - return params; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.QueryStringFilter" │ │ │ │ + /** │ │ │ │ + * APIMethod: getControlsByName │ │ │ │ + * Get a list of contorls with names matching the given name. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * match - {String | Object} A control name. The name can also be a regular │ │ │ │ + * expression literal or object. In addition, it can be any object │ │ │ │ + * with a method named test. For reqular expressions or other, if │ │ │ │ + * name.test(control.name) evaluates to true, the control will be included │ │ │ │ + * in the list of controls returned. If no controls are found, an empty │ │ │ │ + * array is returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Control>)} A list of controls matching the given name. │ │ │ │ + * An empty array is returned if no matches are found. │ │ │ │ + */ │ │ │ │ + getControlsByName: function(match) { │ │ │ │ + return this.getControlsBy("name", match); │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * APIMethod: getControlsByClass │ │ │ │ + * Get a list of controls of a given type (CLASS_NAME). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * match - {String | Object} A control class name. The type can also be a │ │ │ │ + * regular expression literal or object. In addition, it can be any │ │ │ │ + * object with a method named test. For reqular expressions or other, │ │ │ │ + * if type.test(control.CLASS_NAME) evaluates to true, the control will │ │ │ │ + * be included in the list of controls returned. If no controls are │ │ │ │ + * found, an empty array is returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Control>)} A list of controls matching the given type. │ │ │ │ + * An empty array is returned if no matches are found. │ │ │ │ + */ │ │ │ │ + getControlsByClass: function(match) { │ │ │ │ + return this.getControlsBy("CLASS_NAME", match); │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ +}); │ │ │ │ │ │ │ │ -})(); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WFSDescribeFeatureType.js │ │ │ │ + OpenLayers/Control/ZoomBox.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/OGCExceptionReport.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Box.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WFSDescribeFeatureType │ │ │ │ - * Read WFS DescribeFeatureType response │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.ZoomBox │ │ │ │ + * The ZoomBox control enables zooming directly to a given extent, by drawing │ │ │ │ + * a box on the map. The box is drawn by holding down shift, whilst dragging │ │ │ │ + * the mouse. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WFSDescribeFeatureType = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - xsd: "http://www.w3.org/2001/XMLSchema" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WFSDescribeFeatureType │ │ │ │ - * Create a new parser for WFS DescribeFeatureType responses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "xsd": { │ │ │ │ - "schema": function(node, obj) { │ │ │ │ - var complexTypes = []; │ │ │ │ - var customTypes = {}; │ │ │ │ - var schema = { │ │ │ │ - complexTypes: complexTypes, │ │ │ │ - customTypes: customTypes │ │ │ │ - }; │ │ │ │ - var i, len; │ │ │ │ +OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + /** │ │ │ │ + * Property: type │ │ │ │ + * {OpenLayers.Control.TYPE} │ │ │ │ + */ │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ │ │ │ │ - this.readChildNodes(node, schema); │ │ │ │ + /** │ │ │ │ + * Property: out │ │ │ │ + * {Boolean} Should the control be used for zooming out? │ │ │ │ + */ │ │ │ │ + out: false, │ │ │ │ │ │ │ │ - var attributes = node.attributes; │ │ │ │ - var attr, name; │ │ │ │ - for (i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ - attr = attributes[i]; │ │ │ │ - name = attr.name; │ │ │ │ - if (name.indexOf("xmlns") === 0) { │ │ │ │ - this.setNamespace(name.split(":")[1] || "", attr.value); │ │ │ │ - } else { │ │ │ │ - obj[name] = attr.value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - obj.featureTypes = complexTypes; │ │ │ │ - obj.targetPrefix = this.namespaceAlias[obj.targetNamespace]; │ │ │ │ + /** │ │ │ │ + * APIProperty: keyMask │ │ │ │ + * {Integer} Zoom only occurs if the keyMask matches the combination of │ │ │ │ + * keys down. Use bitwise operators and one or more of the │ │ │ │ + * <OpenLayers.Handler> constants to construct a keyMask. Leave null if │ │ │ │ + * not used mask. Default is null. │ │ │ │ + */ │ │ │ │ + keyMask: null, │ │ │ │ │ │ │ │ - // map complexTypes to names of customTypes │ │ │ │ - var complexType, customType; │ │ │ │ - for (i = 0, len = complexTypes.length; i < len; ++i) { │ │ │ │ - complexType = complexTypes[i]; │ │ │ │ - customType = customTypes[complexType.typeName]; │ │ │ │ - if (customTypes[complexType.typeName]) { │ │ │ │ - complexType.typeName = customType.name; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "complexType": function(node, obj) { │ │ │ │ - var complexType = { │ │ │ │ - // this is a temporary typeName, it will be overwritten by │ │ │ │ - // the schema reader with the metadata found in the │ │ │ │ - // customTypes hash │ │ │ │ - "typeName": node.getAttribute("name") │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, complexType); │ │ │ │ - obj.complexTypes.push(complexType); │ │ │ │ - }, │ │ │ │ - "complexContent": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "extension": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "sequence": function(node, obj) { │ │ │ │ - var sequence = { │ │ │ │ - elements: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, sequence); │ │ │ │ - obj.properties = sequence.elements; │ │ │ │ - }, │ │ │ │ - "element": function(node, obj) { │ │ │ │ - var type; │ │ │ │ - if (obj.elements) { │ │ │ │ - var element = {}; │ │ │ │ - var attributes = node.attributes; │ │ │ │ - var attr; │ │ │ │ - for (var i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ - attr = attributes[i]; │ │ │ │ - element[attr.name] = attr.value; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: alwaysZoom │ │ │ │ + * {Boolean} Always zoom in/out when box drawn, even if the zoom level does │ │ │ │ + * not change. │ │ │ │ + */ │ │ │ │ + alwaysZoom: false, │ │ │ │ │ │ │ │ - type = element.type; │ │ │ │ - if (!type) { │ │ │ │ - type = {}; │ │ │ │ - this.readChildNodes(node, type); │ │ │ │ - element.restriction = type; │ │ │ │ - element.type = type.base; │ │ │ │ - } │ │ │ │ - var fullType = type.base || type; │ │ │ │ - element.localType = fullType.split(":").pop(); │ │ │ │ - obj.elements.push(element); │ │ │ │ - this.readChildNodes(node, element); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomOnClick │ │ │ │ + * {Boolean} Should we zoom when no box was dragged, i.e. the user only │ │ │ │ + * clicked? Default is true. │ │ │ │ + */ │ │ │ │ + zoomOnClick: true, │ │ │ │ │ │ │ │ - if (obj.complexTypes) { │ │ │ │ - type = node.getAttribute("type"); │ │ │ │ - var localType = type.split(":").pop(); │ │ │ │ - obj.customTypes[localType] = { │ │ │ │ - "name": node.getAttribute("name"), │ │ │ │ - "type": type │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "annotation": function(node, obj) { │ │ │ │ - obj.annotation = {}; │ │ │ │ - this.readChildNodes(node, obj.annotation); │ │ │ │ - }, │ │ │ │ - "appinfo": function(node, obj) { │ │ │ │ - if (!obj.appinfo) { │ │ │ │ - obj.appinfo = []; │ │ │ │ - } │ │ │ │ - obj.appinfo.push(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "documentation": function(node, obj) { │ │ │ │ - if (!obj.documentation) { │ │ │ │ - obj.documentation = []; │ │ │ │ - } │ │ │ │ - var value = this.getChildValue(node); │ │ │ │ - obj.documentation.push({ │ │ │ │ - lang: node.getAttribute("xml:lang"), │ │ │ │ - textContent: value.replace(this.regExes.trimSpace, "") │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "simpleType": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "restriction": function(node, obj) { │ │ │ │ - obj.base = node.getAttribute("base"); │ │ │ │ - this.readRestriction(node, obj); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.zoomBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: readRestriction │ │ │ │ - * Reads restriction defined in the child nodes of a restriction element │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} the node to parse │ │ │ │ - * obj - {Object} the object that receives the read result │ │ │ │ - */ │ │ │ │ - readRestriction: function(node, obj) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var child, nodeName, value; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - nodeName = child.nodeName.split(":").pop(); │ │ │ │ - value = child.getAttribute("value"); │ │ │ │ - if (!obj[nodeName]) { │ │ │ │ - obj[nodeName] = value; │ │ │ │ - } else { │ │ │ │ - if (typeof obj[nodeName] == "string") { │ │ │ │ - obj[nodeName] = [obj[nodeName]]; │ │ │ │ - } │ │ │ │ - obj[nodeName].push(value); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: zoomBox │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * position - {<OpenLayers.Bounds>} or {<OpenLayers.Pixel>} │ │ │ │ + */ │ │ │ │ + zoomBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var bounds, │ │ │ │ + targetCenterPx = position.getCenterPixel(); │ │ │ │ + if (!this.out) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, │ │ │ │ + maxXY.lon, maxXY.lat); │ │ │ │ + } else { │ │ │ │ + var pixWidth = position.right - position.left; │ │ │ │ + var pixHeight = position.bottom - position.top; │ │ │ │ + var zoomFactor = Math.min((this.map.size.h / pixHeight), │ │ │ │ + (this.map.size.w / pixWidth)); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ + var xmin = center.lon - (extent.getWidth() / 2) * zoomFactor; │ │ │ │ + var xmax = center.lon + (extent.getWidth() / 2) * zoomFactor; │ │ │ │ + var ymin = center.lat - (extent.getHeight() / 2) * zoomFactor; │ │ │ │ + var ymax = center.lat + (extent.getHeight() / 2) * zoomFactor; │ │ │ │ + bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: read │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {DOMElement|String} A WFS DescribeFeatureType document. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object representing the WFS DescribeFeatureType response. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + // always zoom in/out │ │ │ │ + var lastZoom = this.map.getZoom(), │ │ │ │ + size = this.map.getSize(), │ │ │ │ + centerPx = { │ │ │ │ + x: size.w / 2, │ │ │ │ + y: size.h / 2 │ │ │ │ + }, │ │ │ │ + zoom = this.map.getZoomForExtent(bounds), │ │ │ │ + oldRes = this.map.getResolution(), │ │ │ │ + newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ + if (oldRes == newRes) { │ │ │ │ + this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)); │ │ │ │ + } else { │ │ │ │ + var zoomOriginPx = { │ │ │ │ + x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / │ │ │ │ + (oldRes - newRes), │ │ │ │ + y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / │ │ │ │ + (oldRes - newRes) │ │ │ │ + }; │ │ │ │ + this.map.zoomTo(zoom, zoomOriginPx); │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ + if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ + this.map.zoomTo(lastZoom + (this.out ? -1 : 1)); │ │ │ │ } │ │ │ │ - var schema = {}; │ │ │ │ - if (data.nodeName.split(":").pop() === 'ExceptionReport') { │ │ │ │ - // an exception must have occurred, so parse it │ │ │ │ - var parser = new OpenLayers.Format.OGCExceptionReport(); │ │ │ │ - schema.error = parser.read(data); │ │ │ │ + } else if (this.zoomOnClick) { // it's a pixel │ │ │ │ + if (!this.out) { │ │ │ │ + this.map.zoomTo(this.map.getZoom() + 1, position); │ │ │ │ } else { │ │ │ │ - this.readNode(data, schema); │ │ │ │ + this.map.zoomTo(this.map.getZoom() - 1, position); │ │ │ │ } │ │ │ │ - return schema; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSDescribeFeatureType" │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WFS.js │ │ │ │ + OpenLayers/Control/DragPan.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/GML.js │ │ │ │ - * @requires OpenLayers/Console.js │ │ │ │ - * @requires OpenLayers/Lang.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WFS │ │ │ │ - * Read/Write WFS. │ │ │ │ + * Class: OpenLayers.Control.DragPan │ │ │ │ + * The DragPan control pans the map with a drag of the mouse. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.GML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WFS = OpenLayers.Class(OpenLayers.Format.GML, { │ │ │ │ +OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer>} │ │ │ │ + * Property: type │ │ │ │ + * {OpenLayers.Control.TYPES} │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: wfsns │ │ │ │ - * {String} │ │ │ │ + * Property: panned │ │ │ │ + * {Boolean} The map moved. │ │ │ │ */ │ │ │ │ - wfsns: "http://www.opengis.net/wfs", │ │ │ │ + panned: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: ogcns │ │ │ │ - * {String} │ │ │ │ + * Property: interval │ │ │ │ + * {Integer} The number of milliseconds that should ellapse before │ │ │ │ + * panning the map again. Defaults to 0 milliseconds, which means that │ │ │ │ + * no separate cycle is used for panning. In most cases you won't want │ │ │ │ + * to change this value. For slow machines/devices larger values can be │ │ │ │ + * tried out. │ │ │ │ */ │ │ │ │ - ogcns: "http://www.opengis.net/ogc", │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WFS │ │ │ │ - * Create a WFS-T formatter. This requires a layer: that layer should │ │ │ │ - * have two properties: geometry_column and typename. The parser │ │ │ │ - * for this format is subclassed entirely from GML: There is a writer │ │ │ │ - * only, which uses most of the code from the GML layer, and wraps │ │ │ │ - * it in transactional elements. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ - * layer - {<OpenLayers.Layer>} │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} If set to true, mouse dragging will continue even if the │ │ │ │ + * mouse cursor leaves the map viewport. Default is false. │ │ │ │ */ │ │ │ │ - initialize: function(options, layer) { │ │ │ │ - OpenLayers.Format.GML.prototype.initialize.apply(this, [options]); │ │ │ │ - this.layer = layer; │ │ │ │ - if (this.layer.featureNS) { │ │ │ │ - this.featureNS = this.layer.featureNS; │ │ │ │ - } │ │ │ │ - if (this.layer.options.geometry_column) { │ │ │ │ - this.geometryName = this.layer.options.geometry_column; │ │ │ │ - } │ │ │ │ - if (this.layer.options.typename) { │ │ │ │ - this.featureName = this.layer.options.typename; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + documentDrag: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ - * Takes a feature list, and generates a WFS-T Transaction │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ + * Property: kinetic │ │ │ │ + * {<OpenLayers.Kinetic>} The OpenLayers.Kinetic object. │ │ │ │ */ │ │ │ │ - write: function(features) { │ │ │ │ + kinetic: null, │ │ │ │ │ │ │ │ - var transaction = this.createElementNS(this.wfsns, 'wfs:Transaction'); │ │ │ │ - transaction.setAttribute("version", "1.0.0"); │ │ │ │ - transaction.setAttribute("service", "WFS"); │ │ │ │ - for (var i = 0; i < features.length; i++) { │ │ │ │ - switch (features[i].state) { │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - transaction.appendChild(this.insert(features[i])); │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - transaction.appendChild(this.update(features[i])); │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - transaction.appendChild(this.remove(features[i])); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: enableKinetic │ │ │ │ + * {Boolean} Set this option to enable "kinetic dragging". Can be │ │ │ │ + * set to true or to an object. If set to an object this │ │ │ │ + * object will be passed to the {<OpenLayers.Kinetic>} │ │ │ │ + * constructor. Defaults to true. │ │ │ │ + * To get kinetic dragging, ensure that OpenLayers/Kinetic.js is │ │ │ │ + * included in your build config. │ │ │ │ + */ │ │ │ │ + enableKinetic: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: kineticInterval │ │ │ │ + * {Integer} Interval in milliseconds between 2 steps in the "kinetic │ │ │ │ + * scrolling". Applies only if enableKinetic is set. Defaults │ │ │ │ + * to 10 milliseconds. │ │ │ │ + */ │ │ │ │ + kineticInterval: 10, │ │ │ │ │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [transaction]); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFeatureXML │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Method: draw │ │ │ │ + * Creates a Drag handler, using <panMap> and │ │ │ │ + * <panMapDone> as callbacks. │ │ │ │ */ │ │ │ │ - createFeatureXML: function(feature) { │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - var geomContainer = this.createElementNS(this.featureNS, "feature:" + this.geometryName); │ │ │ │ - geomContainer.appendChild(geometryNode); │ │ │ │ - var featureContainer = this.createElementNS(this.featureNS, "feature:" + this.featureName); │ │ │ │ - featureContainer.appendChild(geomContainer); │ │ │ │ - for (var attr in feature.attributes) { │ │ │ │ - var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ - var nodename = attr; │ │ │ │ - if (attr.search(":") != -1) { │ │ │ │ - nodename = attr.split(":")[1]; │ │ │ │ + draw: function() { │ │ │ │ + if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ + var config = { │ │ │ │ + interval: this.kineticInterval │ │ │ │ + }; │ │ │ │ + if (typeof this.enableKinetic === "object") { │ │ │ │ + config = OpenLayers.Util.extend(config, this.enableKinetic); │ │ │ │ } │ │ │ │ - var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ - attrContainer.appendChild(attrText); │ │ │ │ - featureContainer.appendChild(attrContainer); │ │ │ │ + this.kinetic = new OpenLayers.Kinetic(config); │ │ │ │ } │ │ │ │ - return featureContainer; │ │ │ │ + this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ + "move": this.panMap, │ │ │ │ + "done": this.panMapDone, │ │ │ │ + "down": this.panMapStart │ │ │ │ + }, { │ │ │ │ + interval: this.interval, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: insert │ │ │ │ - * Takes a feature, and generates a WFS-T Transaction "Insert" │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Method: panMapStart │ │ │ │ */ │ │ │ │ - insert: function(feature) { │ │ │ │ - var insertNode = this.createElementNS(this.wfsns, 'wfs:Insert'); │ │ │ │ - insertNode.appendChild(this.createFeatureXML(feature)); │ │ │ │ - return insertNode; │ │ │ │ + panMapStart: function() { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.begin(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Takes a feature, and generates a WFS-T Transaction "Update" │ │ │ │ + * Method: panMap │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ */ │ │ │ │ - update: function(feature) { │ │ │ │ - if (!feature.fid) { │ │ │ │ - OpenLayers.Console.userError(OpenLayers.i18n("noFID")); │ │ │ │ - } │ │ │ │ - var updateNode = this.createElementNS(this.wfsns, 'wfs:Update'); │ │ │ │ - updateNode.setAttribute("typeName", this.featurePrefix + ':' + this.featureName); │ │ │ │ - updateNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ - │ │ │ │ - var propertyNode = this.createElementNS(this.wfsns, 'wfs:Property'); │ │ │ │ - var nameNode = this.createElementNS(this.wfsns, 'wfs:Name'); │ │ │ │ - │ │ │ │ - var txtNode = this.createTextNode(this.geometryName); │ │ │ │ - nameNode.appendChild(txtNode); │ │ │ │ - propertyNode.appendChild(nameNode); │ │ │ │ - │ │ │ │ - var valueNode = this.createElementNS(this.wfsns, 'wfs:Value'); │ │ │ │ - │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - │ │ │ │ - if (feature.layer) { │ │ │ │ - geometryNode.setAttribute( │ │ │ │ - "srsName", feature.layer.projection.getCode() │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - valueNode.appendChild(geometryNode); │ │ │ │ - │ │ │ │ - propertyNode.appendChild(valueNode); │ │ │ │ - updateNode.appendChild(propertyNode); │ │ │ │ - │ │ │ │ - // add in attributes │ │ │ │ - for (var propName in feature.attributes) { │ │ │ │ - propertyNode = this.createElementNS(this.wfsns, 'wfs:Property'); │ │ │ │ - nameNode = this.createElementNS(this.wfsns, 'wfs:Name'); │ │ │ │ - nameNode.appendChild(this.createTextNode(propName)); │ │ │ │ - propertyNode.appendChild(nameNode); │ │ │ │ - valueNode = this.createElementNS(this.wfsns, 'wfs:Value'); │ │ │ │ - valueNode.appendChild(this.createTextNode(feature.attributes[propName])); │ │ │ │ - propertyNode.appendChild(valueNode); │ │ │ │ - updateNode.appendChild(propertyNode); │ │ │ │ + panMap: function(xy) { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.update(xy); │ │ │ │ } │ │ │ │ - │ │ │ │ - │ │ │ │ - var filterNode = this.createElementNS(this.ogcns, 'ogc:Filter'); │ │ │ │ - var filterIdNode = this.createElementNS(this.ogcns, 'ogc:FeatureId'); │ │ │ │ - filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ - filterNode.appendChild(filterIdNode); │ │ │ │ - updateNode.appendChild(filterNode); │ │ │ │ - │ │ │ │ - return updateNode; │ │ │ │ + this.panned = true; │ │ │ │ + this.map.pan( │ │ │ │ + this.handler.last.x - xy.x, │ │ │ │ + this.handler.last.y - xy.y, { │ │ │ │ + dragging: true, │ │ │ │ + animate: false │ │ │ │ + } │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: remove │ │ │ │ - * Takes a feature, and generates a WFS-T Transaction "Delete" │ │ │ │ + * Method: panMapDone │ │ │ │ + * Finish the panning operation. Only call setCenter (through <panMap>) │ │ │ │ + * if the map has actually been moved. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ */ │ │ │ │ - remove: function(feature) { │ │ │ │ - if (!feature.fid) { │ │ │ │ - OpenLayers.Console.userError(OpenLayers.i18n("noFID")); │ │ │ │ - return false; │ │ │ │ + panMapDone: function(xy) { │ │ │ │ + if (this.panned) { │ │ │ │ + var res = null; │ │ │ │ + if (this.kinetic) { │ │ │ │ + res = this.kinetic.end(xy); │ │ │ │ + } │ │ │ │ + this.map.pan( │ │ │ │ + this.handler.last.x - xy.x, │ │ │ │ + this.handler.last.y - xy.y, { │ │ │ │ + dragging: !!res, │ │ │ │ + animate: false │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + if (res) { │ │ │ │ + var self = this; │ │ │ │ + this.kinetic.move(res, function(x, y, end) { │ │ │ │ + self.map.pan(x, y, { │ │ │ │ + dragging: !end, │ │ │ │ + animate: false │ │ │ │ + }); │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.panned = false; │ │ │ │ } │ │ │ │ - var deleteNode = this.createElementNS(this.wfsns, 'wfs:Delete'); │ │ │ │ - deleteNode.setAttribute("typeName", this.featurePrefix + ':' + this.featureName); │ │ │ │ - deleteNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ - │ │ │ │ - var filterNode = this.createElementNS(this.ogcns, 'ogc:Filter'); │ │ │ │ - var filterIdNode = this.createElementNS(this.ogcns, 'ogc:FeatureId'); │ │ │ │ - filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ - filterNode.appendChild(filterIdNode); │ │ │ │ - deleteNode.appendChild(filterNode); │ │ │ │ - │ │ │ │ - return deleteNode; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Remove ciruclar ref to layer │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.layer = null; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFS" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WMTSCapabilities.js │ │ │ │ + OpenLayers/Control/Navigation.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + * @requires OpenLayers/Control/ZoomBox.js │ │ │ │ + * @requires OpenLayers/Control/DragPan.js │ │ │ │ + * @requires OpenLayers/Handler/MouseWheel.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WMTSCapabilities │ │ │ │ - * Read WMTS Capabilities. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + * Class: OpenLayers.Control.Navigation │ │ │ │ + * The navigation control handles map browsing with mouse events (dragging, │ │ │ │ + * double-clicking, and scrolling the wheel). Create a new navigation │ │ │ │ + * control with the <OpenLayers.Control.Navigation> control. │ │ │ │ + * │ │ │ │ + * Note that this control is added to the map by default (if no controls │ │ │ │ + * array is sent in the options object to the <OpenLayers.Map> │ │ │ │ + * constructor). │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WMTSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ +OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: dragPan │ │ │ │ + * {<OpenLayers.Control.DragPan>} │ │ │ │ + */ │ │ │ │ + dragPan: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ + * APIProperty: dragPanOptions │ │ │ │ + * {Object} Options passed to the DragPan control. │ │ │ │ */ │ │ │ │ - defaultVersion: "1.0.0", │ │ │ │ + dragPanOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: yx │ │ │ │ - * {Object} Members in the yx object are used to determine if a CRS URN │ │ │ │ - * corresponds to a CRS with y,x axis order. Member names are CRS URNs │ │ │ │ - * and values are boolean. By default, the following CRS URN are │ │ │ │ - * assumed to correspond to a CRS with y,x axis order: │ │ │ │ - * │ │ │ │ - * * urn:ogc:def:crs:EPSG::4326 │ │ │ │ + * Property: pinchZoom │ │ │ │ + * {<OpenLayers.Control.PinchZoom>} │ │ │ │ */ │ │ │ │ - yx: { │ │ │ │ - "urn:ogc:def:crs:EPSG::4326": true │ │ │ │ - }, │ │ │ │ + pinchZoom: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WMTSCapabilities │ │ │ │ - * Create a new parser for WMTS capabilities. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIProperty: pinchZoomOptions │ │ │ │ + * {Object} Options passed to the PinchZoom control. │ │ │ │ */ │ │ │ │ + pinchZoomOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return information about │ │ │ │ - * the service (offering and observedProperty mostly). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Info about the WMTS Capabilities │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} Allow panning of the map by dragging outside map viewport. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ + documentDrag: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: zoomBox │ │ │ │ + * {<OpenLayers.Control.ZoomBox>} │ │ │ │ + */ │ │ │ │ + zoomBox: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: createLayer │ │ │ │ - * Create a WMTS layer given a capabilities object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * capabilities - {Object} The object returned from a <read> call to this │ │ │ │ - * format. │ │ │ │ - * config - {Object} Configuration properties for the layer. Defaults for │ │ │ │ - * the layer will apply if not provided. │ │ │ │ - * │ │ │ │ - * Required config properties: │ │ │ │ - * layer - {String} The layer identifier. │ │ │ │ - * │ │ │ │ - * Optional config properties: │ │ │ │ - * matrixSet - {String} The matrix set identifier, required if there is │ │ │ │ - * more than one matrix set in the layer capabilities. │ │ │ │ - * style - {String} The name of the style │ │ │ │ - * format - {String} Image format for the layer. Default is the first │ │ │ │ - * format returned in the GetCapabilities response. │ │ │ │ - * param - {Object} The dimensions values eg: {"Year": "2012"} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.WMTS>} A properly configured WMTS layer. Throws an │ │ │ │ - * error if an incomplete config is provided. Returns undefined if no │ │ │ │ - * layer could be created with the provided config. │ │ │ │ + * APIProperty: zoomBoxEnabled │ │ │ │ + * {Boolean} Whether the user can draw a box to zoom │ │ │ │ */ │ │ │ │ - createLayer: function(capabilities, config) { │ │ │ │ - var layer; │ │ │ │ + zoomBoxEnabled: true, │ │ │ │ │ │ │ │ - // confirm required properties are supplied in config │ │ │ │ - if (!('layer' in config)) { │ │ │ │ - throw new Error("Missing property 'layer' in configuration."); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomWheelEnabled │ │ │ │ + * {Boolean} Whether the mousewheel should zoom the map │ │ │ │ + */ │ │ │ │ + zoomWheelEnabled: true, │ │ │ │ │ │ │ │ - var contents = capabilities.contents; │ │ │ │ + /** │ │ │ │ + * Property: mouseWheelOptions │ │ │ │ + * {Object} Options passed to the MouseWheel control (only useful if │ │ │ │ + * <zoomWheelEnabled> is set to true). Default is no options for maps │ │ │ │ + * with fractionalZoom set to true, otherwise │ │ │ │ + * {cumulative: false, interval: 50, maxDelta: 6} │ │ │ │ + */ │ │ │ │ + mouseWheelOptions: null, │ │ │ │ │ │ │ │ - // find the layer definition with the given identifier │ │ │ │ - var layers = contents.layers; │ │ │ │ - var layerDef; │ │ │ │ - for (var i = 0, ii = contents.layers.length; i < ii; ++i) { │ │ │ │ - if (contents.layers[i].identifier === config.layer) { │ │ │ │ - layerDef = contents.layers[i]; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: handleRightClicks │ │ │ │ + * {Boolean} Whether or not to handle right clicks. Default is false. │ │ │ │ + */ │ │ │ │ + handleRightClicks: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomBoxKeyMask │ │ │ │ + * {Integer} <OpenLayers.Handler> key code of the key, which has to be │ │ │ │ + * pressed, while drawing the zoom box with the mouse on the screen. │ │ │ │ + * You should probably set handleRightClicks to true if you use this │ │ │ │ + * with MOD_CTRL, to disable the context menu for machines which use │ │ │ │ + * CTRL-Click as a right click. │ │ │ │ + * Default: <OpenLayers.Handler.MOD_SHIFT> │ │ │ │ + */ │ │ │ │ + zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoActivate: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.Navigation │ │ │ │ + * Create a new navigation control │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * the control │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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() { │ │ │ │ + this.deactivate(); │ │ │ │ + │ │ │ │ + if (this.dragPan) { │ │ │ │ + this.dragPan.destroy(); │ │ │ │ } │ │ │ │ - if (!layerDef) { │ │ │ │ - throw new Error("Layer not found"); │ │ │ │ + this.dragPan = null; │ │ │ │ + │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.zoomBox.destroy(); │ │ │ │ } │ │ │ │ + this.zoomBox = null; │ │ │ │ │ │ │ │ - var format = config.format; │ │ │ │ - if (!format && layerDef.formats && layerDef.formats.length) { │ │ │ │ - format = layerDef.formats[0]; │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.destroy(); │ │ │ │ } │ │ │ │ + this.pinchZoom = null; │ │ │ │ │ │ │ │ - // find the matrixSet definition │ │ │ │ - var matrixSet; │ │ │ │ - if (config.matrixSet) { │ │ │ │ - matrixSet = contents.tileMatrixSets[config.matrixSet]; │ │ │ │ - } else if (layerDef.tileMatrixSetLinks.length >= 1) { │ │ │ │ - matrixSet = contents.tileMatrixSets[ │ │ │ │ - layerDef.tileMatrixSetLinks[0].tileMatrixSet]; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + this.dragPan.activate(); │ │ │ │ + if (this.zoomWheelEnabled) { │ │ │ │ + this.handlers.wheel.activate(); │ │ │ │ } │ │ │ │ - if (!matrixSet) { │ │ │ │ - throw new Error("matrixSet not found"); │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + if (this.zoomBoxEnabled) { │ │ │ │ + this.zoomBox.activate(); │ │ │ │ + } │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.activate(); │ │ │ │ } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // get the default style for the layer │ │ │ │ - var style; │ │ │ │ - for (var i = 0, ii = layerDef.styles.length; i < ii; ++i) { │ │ │ │ - style = layerDef.styles[i]; │ │ │ │ - if (style.isDefault) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.deactivate(); │ │ │ │ } │ │ │ │ + this.zoomBox.deactivate(); │ │ │ │ + this.dragPan.deactivate(); │ │ │ │ + this.handlers.click.deactivate(); │ │ │ │ + this.handlers.wheel.deactivate(); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var requestEncoding = config.requestEncoding; │ │ │ │ - if (!requestEncoding) { │ │ │ │ - requestEncoding = "KVP"; │ │ │ │ - if (capabilities.operationsMetadata.GetTile.dcp.http) { │ │ │ │ - var http = capabilities.operationsMetadata.GetTile.dcp.http; │ │ │ │ - // Get first get method │ │ │ │ - if (http.get[0].constraints) { │ │ │ │ - var constraints = http.get[0].constraints; │ │ │ │ - var allowedValues = constraints.GetEncoding.allowedValues; │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + // disable right mouse context menu for support of right click events │ │ │ │ + if (this.handleRightClicks) { │ │ │ │ + this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False; │ │ │ │ + } │ │ │ │ │ │ │ │ - // The OGC documentation is not clear if we should use │ │ │ │ - // REST or RESTful, ArcGis use RESTful, │ │ │ │ - // and OpenLayers use REST. │ │ │ │ - if (!allowedValues.KVP && │ │ │ │ - (allowedValues.REST || allowedValues.RESTful)) { │ │ │ │ - requestEncoding = "REST"; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var clickCallbacks = { │ │ │ │ + 'click': this.defaultClick, │ │ │ │ + 'dblclick': this.defaultDblClick, │ │ │ │ + 'dblrightclick': this.defaultDblRightClick │ │ │ │ + }; │ │ │ │ + var clickOptions = { │ │ │ │ + 'double': true, │ │ │ │ + 'stopDouble': true │ │ │ │ + }; │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ + this, clickCallbacks, clickOptions │ │ │ │ + ); │ │ │ │ + this.dragPan = new OpenLayers.Control.DragPan( │ │ │ │ + OpenLayers.Util.extend({ │ │ │ │ + map: this.map, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }, this.dragPanOptions) │ │ │ │ + ); │ │ │ │ + this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ + map: this.map, │ │ │ │ + keyMask: this.zoomBoxKeyMask │ │ │ │ + }); │ │ │ │ + this.dragPan.draw(); │ │ │ │ + this.zoomBox.draw(); │ │ │ │ + var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ + cumulative: false, │ │ │ │ + interval: 50, │ │ │ │ + maxDelta: 6 │ │ │ │ + }; │ │ │ │ + this.handlers.wheel = new OpenLayers.Handler.MouseWheel( │ │ │ │ + this, { │ │ │ │ + up: this.wheelUp, │ │ │ │ + down: this.wheelDown │ │ │ │ + }, │ │ │ │ + OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions) │ │ │ │ + ); │ │ │ │ + if (OpenLayers.Control.PinchZoom) { │ │ │ │ + this.pinchZoom = new OpenLayers.Control.PinchZoom( │ │ │ │ + OpenLayers.Util.extend({ │ │ │ │ + map: this.map │ │ │ │ + }, this.pinchZoomOptions)); │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var dimensions = []; │ │ │ │ - var params = config.params || {}; │ │ │ │ - // to don't overwrite the changes in the applyDefaults │ │ │ │ - delete config.params; │ │ │ │ - for (var id = 0, ld = layerDef.dimensions.length; id < ld; id++) { │ │ │ │ - var dimension = layerDef.dimensions[id]; │ │ │ │ - dimensions.push(dimension.identifier); │ │ │ │ - if (!params.hasOwnProperty(dimension.identifier)) { │ │ │ │ - params[dimension.identifier] = dimension['default']; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: defaultClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + defaultClick: function(evt) { │ │ │ │ + if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ + this.map.zoomOut(); │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var projection = config.projection || matrixSet.supportedCRS.replace( │ │ │ │ - /urn:ogc:def:crs:(\w+):(.*:)?(\w+)$/, "$1:$3"); │ │ │ │ - var units = config.units || │ │ │ │ - (projection === "EPSG:4326" ? "degrees" : "m"); │ │ │ │ + /** │ │ │ │ + * Method: defaultDblClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + defaultDblClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom + 1, evt.xy); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var resolutions = []; │ │ │ │ - for (var mid in matrixSet.matrixIds) { │ │ │ │ - if (matrixSet.matrixIds.hasOwnProperty(mid)) { │ │ │ │ - resolutions.push( │ │ │ │ - matrixSet.matrixIds[mid].scaleDenominator * 0.28E-3 / │ │ │ │ - OpenLayers.METERS_PER_INCH / │ │ │ │ - OpenLayers.INCHES_PER_UNIT[units]); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: defaultDblRightClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + defaultDblRightClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom - 1, evt.xy); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: wheelChange │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * deltaZ - {Integer} │ │ │ │ + */ │ │ │ │ + wheelChange: function(evt, deltaZ) { │ │ │ │ + if (!this.map.fractionalZoom) { │ │ │ │ + deltaZ = Math.round(deltaZ); │ │ │ │ + } │ │ │ │ + var currentZoom = this.map.getZoom(), │ │ │ │ + newZoom = currentZoom + deltaZ; │ │ │ │ + newZoom = Math.max(newZoom, 0); │ │ │ │ + newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ + if (newZoom === currentZoom) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ + this.map.zoomTo(newZoom, evt.xy); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var url; │ │ │ │ - if (requestEncoding === "REST" && layerDef.resourceUrls) { │ │ │ │ - url = []; │ │ │ │ - var resourceUrls = layerDef.resourceUrls, │ │ │ │ - resourceUrl; │ │ │ │ - for (var t = 0, tt = layerDef.resourceUrls.length; t < tt; ++t) { │ │ │ │ - resourceUrl = layerDef.resourceUrls[t]; │ │ │ │ - if (resourceUrl.format === format && resourceUrl.resourceType === "tile") { │ │ │ │ - url.push(resourceUrl.template); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - var httpGet = capabilities.operationsMetadata.GetTile.dcp.http.get; │ │ │ │ - url = []; │ │ │ │ - var constraint; │ │ │ │ - for (var i = 0, ii = httpGet.length; i < ii; i++) { │ │ │ │ - constraint = httpGet[i].constraints; │ │ │ │ - if (!constraint || (constraint && constraint.GetEncoding.allowedValues[requestEncoding])) { │ │ │ │ - url.push(httpGet[i].url); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: wheelUp │ │ │ │ + * User spun scroll wheel up │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * delta - {Integer} │ │ │ │ + */ │ │ │ │ + wheelUp: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || 1); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: wheelDown │ │ │ │ + * User spun scroll wheel down │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * delta - {Integer} │ │ │ │ + */ │ │ │ │ + wheelDown: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || -1); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: disableZoomBox │ │ │ │ + */ │ │ │ │ + disableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = false; │ │ │ │ + this.zoomBox.deactivate(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: enableZoomBox │ │ │ │ + */ │ │ │ │ + enableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.zoomBox.activate(); │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - return new OpenLayers.Layer.WMTS( │ │ │ │ - OpenLayers.Util.applyDefaults(config, { │ │ │ │ - url: url, │ │ │ │ - requestEncoding: requestEncoding, │ │ │ │ - name: layerDef.title, │ │ │ │ - style: style.identifier, │ │ │ │ - format: format, │ │ │ │ - matrixIds: matrixSet.matrixIds, │ │ │ │ - matrixSet: matrixSet.identifier, │ │ │ │ - projection: projection, │ │ │ │ - units: units, │ │ │ │ - resolutions: config.isBaseLayer === false ? undefined : resolutions, │ │ │ │ - serverResolutions: resolutions, │ │ │ │ - tileFullExtent: matrixSet.bounds, │ │ │ │ - dimensions: dimensions, │ │ │ │ - params: params │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * Method: disableZoomWheel │ │ │ │ + */ │ │ │ │ + │ │ │ │ + disableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = false; │ │ │ │ + this.handlers.wheel.deactivate(); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMTSCapabilities" │ │ │ │ + /** │ │ │ │ + * Method: enableZoomWheel │ │ │ │ + */ │ │ │ │ + │ │ │ │ + enableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.wheel.activate(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/CSWGetRecords.js │ │ │ │ + OpenLayers/Control/NavToolbar.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format.js │ │ │ │ + * @requires OpenLayers/Control/Panel.js │ │ │ │ + * @requires OpenLayers/Control/Navigation.js │ │ │ │ + * @requires OpenLayers/Control/ZoomBox.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.CSWGetRecords │ │ │ │ - * Default version is 2.0.2. │ │ │ │ + * Class: OpenLayers.Control.NavToolbar │ │ │ │ + * This Toolbar is an alternative to the Navigation control that displays │ │ │ │ + * the state of the control, and provides a UI for changing state to │ │ │ │ + * use the zoomBox via a Panel control. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Format>} A CSWGetRecords format of the given version. │ │ │ │ + * If you wish to change the properties of the Navigation control used │ │ │ │ + * in the NavToolbar, see: │ │ │ │ + * http://trac.openlayers.org/wiki/Toolbars#SubclassingNavToolbar │ │ │ │ + * │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control.Panel> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.CSWGetRecords = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults( │ │ │ │ - options, OpenLayers.Format.CSWGetRecords.DEFAULTS │ │ │ │ - ); │ │ │ │ - var cls = OpenLayers.Format.CSWGetRecords["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported CSWGetRecords version: " + options.version; │ │ │ │ - } │ │ │ │ - return new cls(options); │ │ │ │ -}; │ │ │ │ +OpenLayers.Control.NavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: DEFAULTS │ │ │ │ - * {Object} Default properties for the CSWGetRecords format. │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.CSWGetRecords.DEFAULTS = { │ │ │ │ - "version": "2.0.2" │ │ │ │ -}; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.NavToolbar │ │ │ │ + * Add our two mousedefaults controls. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + this.addControls([ │ │ │ │ + new OpenLayers.Control.Navigation(), │ │ │ │ + new OpenLayers.Control.ZoomBox() │ │ │ │ + ]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * calls the default draw, and then activates mouse defaults. │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.defaultControl === null) { │ │ │ │ + this.defaultControl = this.controls[0]; │ │ │ │ + } │ │ │ │ + return div; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.NavToolbar" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/Context.js │ │ │ │ + OpenLayers/Control/CacheRead.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.Context │ │ │ │ - * Base class for both Format.WMC and Format.OWSContext │ │ │ │ + * Class: OpenLayers.Control.CacheRead │ │ │ │ + * A control for using image tiles cached with <OpenLayers.Control.CacheWrite> │ │ │ │ + * from the browser's local storage. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.Context = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ +OpenLayers.Control.CacheRead = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layerOptions │ │ │ │ - * {Object} Default options for layers created by the parser. These │ │ │ │ - * options are overridden by the options which are read from the │ │ │ │ - * capabilities document. │ │ │ │ + * APIProperty: fetchEvent │ │ │ │ + * {String} The layer event to listen to for replacing remote resource tile │ │ │ │ + * URLs with cached data URIs. Supported values are "tileerror" (try │ │ │ │ + * remote first, fall back to cached) and "tileloadstart" (try cache │ │ │ │ + * first, fall back to remote). Default is "tileloadstart". │ │ │ │ + * │ │ │ │ + * Note that "tileerror" will not work for CORS enabled images (see │ │ │ │ + * https://developer.mozilla.org/en/CORS_Enabled_Image), i.e. layers │ │ │ │ + * configured with a <OpenLayers.Tile.Image.crossOriginKeyword> in │ │ │ │ + * <OpenLayers.Layer.Grid.tileOptions>. │ │ │ │ */ │ │ │ │ - layerOptions: null, │ │ │ │ + fetchEvent: "tileloadstart", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layerParams │ │ │ │ - * {Object} Default parameters for layers created by the parser. This │ │ │ │ - * can be used e.g. to override DEFAULT_PARAMS for │ │ │ │ - * OpenLayers.Layer.WMS. │ │ │ │ + * APIProperty: layers │ │ │ │ + * {Array(<OpenLayers.Layer.Grid>)}. Optional. If provided, only these │ │ │ │ + * layers will receive tiles from the cache. │ │ │ │ */ │ │ │ │ - layerParams: null, │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.Context │ │ │ │ - * Create a new parser for Context documents. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read Context data from a string, and return an object with map │ │ │ │ - * properties and a list of layers. │ │ │ │ + * Constructor: OpenLayers.Control.CacheRead │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * options - {Object} The options object must contain a map property. If │ │ │ │ - * the map property is a string, it must be the id of a dom element │ │ │ │ - * where the new map will be placed. If the map property is an │ │ │ │ - * <OpenLayers.Map>, the layers from the context document will be added │ │ │ │ - * to the map. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Map>} A map based on the context. │ │ │ │ + * options - {Object} Object with API properties for this control │ │ │ │ */ │ │ │ │ - read: function(data, options) { │ │ │ │ - var context = OpenLayers.Format.XML.VersionedOGC.prototype.read.apply(this, │ │ │ │ - arguments); │ │ │ │ - var map; │ │ │ │ - if (options && options.map) { │ │ │ │ - this.context = context; │ │ │ │ - if (options.map instanceof OpenLayers.Map) { │ │ │ │ - map = this.mergeContextToMap(context, options.map); │ │ │ │ - } else { │ │ │ │ - var mapOptions = options.map; │ │ │ │ - if (OpenLayers.Util.isElement(mapOptions) || │ │ │ │ - typeof mapOptions == "string") { │ │ │ │ - // we assume mapOptions references a div │ │ │ │ - // element │ │ │ │ - mapOptions = { │ │ │ │ - div: mapOptions │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - map = this.contextToMap(context, mapOptions); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // not documented as part of the API, provided as a non-API option │ │ │ │ - map = context; │ │ │ │ - } │ │ │ │ - return map; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getLayerFromContext │ │ │ │ - * Create a WMS layer from a layerContext object. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * layerContext - {Object} An object representing a WMS layer. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.WMS>} A WMS layer. │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - getLayerFromContext: function(layerContext) { │ │ │ │ - var i, len; │ │ │ │ - // fill initial options object from layerContext │ │ │ │ - var options = { │ │ │ │ - queryable: layerContext.queryable, //keep queryable for api compatibility │ │ │ │ - visibility: layerContext.visibility, │ │ │ │ - maxExtent: layerContext.maxExtent, │ │ │ │ - metadata: OpenLayers.Util.applyDefaults(layerContext.metadata, { │ │ │ │ - styles: layerContext.styles, │ │ │ │ - formats: layerContext.formats, │ │ │ │ - "abstract": layerContext["abstract"], │ │ │ │ - dataURL: layerContext.dataURL │ │ │ │ - }), │ │ │ │ - numZoomLevels: layerContext.numZoomLevels, │ │ │ │ - units: layerContext.units, │ │ │ │ - isBaseLayer: layerContext.isBaseLayer, │ │ │ │ - opacity: layerContext.opacity, │ │ │ │ - displayInLayerSwitcher: layerContext.displayInLayerSwitcher, │ │ │ │ - singleTile: layerContext.singleTile, │ │ │ │ - tileSize: (layerContext.tileSize) ? │ │ │ │ - new OpenLayers.Size( │ │ │ │ - layerContext.tileSize.width, │ │ │ │ - layerContext.tileSize.height │ │ │ │ - ) : undefined, │ │ │ │ - minScale: layerContext.minScale || layerContext.maxScaleDenominator, │ │ │ │ - maxScale: layerContext.maxScale || layerContext.minScaleDenominator, │ │ │ │ - srs: layerContext.srs, │ │ │ │ - dimensions: layerContext.dimensions, │ │ │ │ - metadataURL: layerContext.metadataURL │ │ │ │ - }; │ │ │ │ - if (this.layerOptions) { │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.layerOptions); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var params = { │ │ │ │ - layers: layerContext.name, │ │ │ │ - transparent: layerContext.transparent, │ │ │ │ - version: layerContext.version │ │ │ │ - }; │ │ │ │ - if (layerContext.formats && layerContext.formats.length > 0) { │ │ │ │ - // set default value for params if current attribute is not positionned │ │ │ │ - params.format = layerContext.formats[0].value; │ │ │ │ - for (i = 0, len = layerContext.formats.length; i < len; i++) { │ │ │ │ - var format = layerContext.formats[i]; │ │ │ │ - if (format.current == true) { │ │ │ │ - params.format = format.value; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (layerContext.styles && layerContext.styles.length > 0) { │ │ │ │ - for (i = 0, len = layerContext.styles.length; i < len; i++) { │ │ │ │ - var style = layerContext.styles[i]; │ │ │ │ - if (style.current == true) { │ │ │ │ - // three style types to consider │ │ │ │ - // 1) linked SLD │ │ │ │ - // 2) inline SLD │ │ │ │ - // 3) named style │ │ │ │ - if (style.href) { │ │ │ │ - params.sld = style.href; │ │ │ │ - } else if (style.body) { │ │ │ │ - params.sld_body = style.body; │ │ │ │ - } else { │ │ │ │ - params.styles = style.name; │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.layerParams) { │ │ │ │ - OpenLayers.Util.applyDefaults(params, this.layerParams); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var layer = null; │ │ │ │ - var service = layerContext.service; │ │ │ │ - if (service == OpenLayers.Format.Context.serviceTypes.WFS) { │ │ │ │ - options.strategies = [new OpenLayers.Strategy.BBOX()]; │ │ │ │ - options.protocol = new OpenLayers.Protocol.WFS({ │ │ │ │ - url: layerContext.url, │ │ │ │ - // since we do not know featureNS, let the protocol │ │ │ │ - // determine it automagically using featurePrefix │ │ │ │ - featurePrefix: layerContext.name.split(":")[0], │ │ │ │ - featureType: layerContext.name.split(":").pop() │ │ │ │ - }); │ │ │ │ - layer = new OpenLayers.Layer.Vector( │ │ │ │ - layerContext.title || layerContext.name, │ │ │ │ - options │ │ │ │ - ); │ │ │ │ - } else if (service == OpenLayers.Format.Context.serviceTypes.KML) { │ │ │ │ - // use a vector layer with an HTTP Protcol and a Fixed strategy │ │ │ │ - options.strategies = [new OpenLayers.Strategy.Fixed()]; │ │ │ │ - options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ - url: layerContext.url, │ │ │ │ - format: new OpenLayers.Format.KML() │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + var i, layers = this.layers || map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.addLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ }); │ │ │ │ - layer = new OpenLayers.Layer.Vector( │ │ │ │ - layerContext.title || layerContext.name, │ │ │ │ - options │ │ │ │ - ); │ │ │ │ - } else if (service == OpenLayers.Format.Context.serviceTypes.GML) { │ │ │ │ - // use a vector layer with a HTTP Protocol and a Fixed strategy │ │ │ │ - options.strategies = [new OpenLayers.Strategy.Fixed()]; │ │ │ │ - options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ - url: layerContext.url, │ │ │ │ - format: new OpenLayers.Format.GML() │ │ │ │ + } │ │ │ │ + if (!this.layers) { │ │ │ │ + map.events.on({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ }); │ │ │ │ - layer = new OpenLayers.Layer.Vector( │ │ │ │ - layerContext.title || layerContext.name, │ │ │ │ - options │ │ │ │ - ); │ │ │ │ - } else if (layerContext.features) { │ │ │ │ - // inline GML or KML features │ │ │ │ - layer = new OpenLayers.Layer.Vector( │ │ │ │ - layerContext.title || layerContext.name, │ │ │ │ - options │ │ │ │ - ); │ │ │ │ - layer.addFeatures(layerContext.features); │ │ │ │ - } else if (layerContext.categoryLayer !== true) { │ │ │ │ - layer = new OpenLayers.Layer.WMS( │ │ │ │ - layerContext.title || layerContext.name, │ │ │ │ - layerContext.url, │ │ │ │ - params, │ │ │ │ - options │ │ │ │ - ); │ │ │ │ } │ │ │ │ - return layer; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getLayersFromContext │ │ │ │ - * Create an array of layers from an array of layerContext objects. │ │ │ │ + * Method: addLayer │ │ │ │ + * Adds a layer to the control. Once added, tiles requested for this layer │ │ │ │ + * will be cached. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layersContext - {Array(Object)} An array of objects representing layers. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Layer>)} An array of layers. │ │ │ │ + * evt - {Object} Object with a layer property referencing an │ │ │ │ + * <OpenLayers.Layer> instance │ │ │ │ */ │ │ │ │ - getLayersFromContext: function(layersContext) { │ │ │ │ - var layers = []; │ │ │ │ - for (var i = 0, len = layersContext.length; i < len; i++) { │ │ │ │ - var layer = this.getLayerFromContext(layersContext[i]); │ │ │ │ - if (layer !== null) { │ │ │ │ - layers.push(layer); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return layers; │ │ │ │ + addLayer: function(evt) { │ │ │ │ + evt.layer.events.register(this.fetchEvent, this, this.fetch); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: contextToMap │ │ │ │ - * Create a map given a context object. │ │ │ │ + * Method: removeLayer │ │ │ │ + * Removes a layer from the control. Once removed, tiles requested for this │ │ │ │ + * layer will no longer be cached. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * context - {Object} The context object. │ │ │ │ - * options - {Object} Default map options. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Map>} A map based on the context object. │ │ │ │ + * evt - {Object} Object with a layer property referencing an │ │ │ │ + * <OpenLayers.Layer> instance │ │ │ │ */ │ │ │ │ - contextToMap: function(context, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - maxExtent: context.maxExtent, │ │ │ │ - projection: context.projection, │ │ │ │ - units: context.units │ │ │ │ - }, options); │ │ │ │ - │ │ │ │ - if (options.maxExtent) { │ │ │ │ - options.maxResolution = │ │ │ │ - options.maxExtent.getWidth() / OpenLayers.Map.TILE_WIDTH; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var metadata = { │ │ │ │ - contactInformation: context.contactInformation, │ │ │ │ - "abstract": context["abstract"], │ │ │ │ - keywords: context.keywords, │ │ │ │ - logo: context.logo, │ │ │ │ - descriptionURL: context.descriptionURL │ │ │ │ - }; │ │ │ │ - │ │ │ │ - options.metadata = metadata; │ │ │ │ - │ │ │ │ - var map = new OpenLayers.Map(options); │ │ │ │ - map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ - map.setCenter( │ │ │ │ - context.bounds.getCenterLonLat(), │ │ │ │ - map.getZoomForExtent(context.bounds, true) │ │ │ │ - ); │ │ │ │ - return map; │ │ │ │ + removeLayer: function(evt) { │ │ │ │ + evt.layer.events.unregister(this.fetchEvent, this, this.fetch); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mergeContextToMap │ │ │ │ - * Add layers from a context object to a map. │ │ │ │ + * Method: fetch │ │ │ │ + * Listener to the <fetchEvent> event. Replaces a tile's url with a data │ │ │ │ + * URI from the cache. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * context - {Object} The context object. │ │ │ │ - * map - {<OpenLayers.Map>} The map. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Map>} The same map with layers added. │ │ │ │ + * evt - {Object} Event object with a tile property. │ │ │ │ */ │ │ │ │ - mergeContextToMap: function(context, map) { │ │ │ │ - map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ - return map; │ │ │ │ + fetch: function(evt) { │ │ │ │ + if (this.active && window.localStorage && │ │ │ │ + evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ + var tile = evt.tile, │ │ │ │ + url = tile.url; │ │ │ │ + // deal with modified tile urls when both CacheWrite and CacheRead │ │ │ │ + // are active │ │ │ │ + if (!tile.layer.crossOriginKeyword && OpenLayers.ProxyHost && │ │ │ │ + url.indexOf(OpenLayers.ProxyHost) === 0) { │ │ │ │ + url = OpenLayers.Control.CacheWrite.urlMap[url]; │ │ │ │ + } │ │ │ │ + var dataURI = window.localStorage.getItem("olCache_" + url); │ │ │ │ + if (dataURI) { │ │ │ │ + tile.url = dataURI; │ │ │ │ + if (evt.type === "tileerror") { │ │ │ │ + tile.setImgSrc(dataURI); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Write a context document given a map. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {<OpenLayers.Map> | Object} A map or context object. │ │ │ │ - * options - {Object} Optional configuration object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A context document string. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - write: function(obj, options) { │ │ │ │ - obj = this.toContext(obj); │ │ │ │ - return OpenLayers.Format.XML.VersionedOGC.prototype.write.apply(this, │ │ │ │ - arguments); │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layers || this.map) { │ │ │ │ + var i, layers = this.layers || this.map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.un({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Context" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.CacheRead" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Format.Context.serviceTypes │ │ │ │ - * Enumeration for service types │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.Context.serviceTypes = { │ │ │ │ - "WMS": "urn:ogc:serviceType:WMS", │ │ │ │ - "WFS": "urn:ogc:serviceType:WFS", │ │ │ │ - "WCS": "urn:ogc:serviceType:WCS", │ │ │ │ - "GML": "urn:ogc:serviceType:GML", │ │ │ │ - "SLD": "urn:ogc:serviceType:SLD", │ │ │ │ - "FES": "urn:ogc:serviceType:FES", │ │ │ │ - "KML": "urn:ogc:serviceType:KML" │ │ │ │ -}; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/SOSGetFeatureOfInterest.js │ │ │ │ + OpenLayers/Control/Split.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/GML/v3.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Path.js │ │ │ │ + * @requires OpenLayers/Layer/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.SOSGetFeatureOfInterest │ │ │ │ - * Read and write SOS GetFeatureOfInterest. This is used to get to │ │ │ │ - * the location of the features (stations). The stations can have 1 or more │ │ │ │ - * sensors. │ │ │ │ + * Class: OpenLayers.Control.Split │ │ │ │ + * Acts as a split feature agent while editing vector features. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.SOSGetFeatureOfInterest = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.0.0 │ │ │ │ - */ │ │ │ │ - VERSION: "1.0.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - sos: "http://www.opengis.net/sos/1.0", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosAll.xsd", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - */ │ │ │ │ - defaultPrefix: "sos", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.SOSGetFeatureOfInterest │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Parse a GetFeatureOfInterest response and return an array of features │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} An array of features. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var info = { │ │ │ │ - features: [] │ │ │ │ - }; │ │ │ │ - this.readNode(data, info); │ │ │ │ - │ │ │ │ - var features = []; │ │ │ │ - for (var i = 0, len = info.features.length; i < len; i++) { │ │ │ │ - var container = info.features[i]; │ │ │ │ - // reproject features if needed │ │ │ │ - if (this.internalProjection && this.externalProjection && │ │ │ │ - container.components[0]) { │ │ │ │ - container.components[0].transform( │ │ │ │ - this.externalProjection, this.internalProjection │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - var feature = new OpenLayers.Feature.Vector( │ │ │ │ - container.components[0], container.attributes); │ │ │ │ - features.push(feature); │ │ │ │ - } │ │ │ │ - return features; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "sa": { │ │ │ │ - "SamplingPoint": function(node, obj) { │ │ │ │ - // sampling point can also be without a featureMember if │ │ │ │ - // there is only 1 │ │ │ │ - if (!obj.attributes) { │ │ │ │ - var feature = { │ │ │ │ - attributes: {} │ │ │ │ - }; │ │ │ │ - obj.features.push(feature); │ │ │ │ - obj = feature; │ │ │ │ - } │ │ │ │ - obj.attributes.id = this.getAttributeNS(node, │ │ │ │ - this.namespaces.gml, "id"); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "position": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ - "FeatureCollection": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "featureMember": function(node, obj) { │ │ │ │ - var feature = { │ │ │ │ - attributes: {} │ │ │ │ - }; │ │ │ │ - obj.features.push(feature); │ │ │ │ - this.readChildNodes(node, feature); │ │ │ │ - }, │ │ │ │ - "name": function(node, obj) { │ │ │ │ - obj.attributes.name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "pos": function(node, obj) { │ │ │ │ - // we need to parse the srsName to get to the │ │ │ │ - // externalProjection, that's why we cannot use │ │ │ │ - // GML v3 for this │ │ │ │ - if (!this.externalProjection) { │ │ │ │ - this.externalProjection = new OpenLayers.Projection( │ │ │ │ - node.getAttribute("srsName")); │ │ │ │ - } │ │ │ │ - OpenLayers.Format.GML.v3.prototype.readers.gml.pos.apply( │ │ │ │ - this, [node, obj]); │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.v3.prototype.readers.gml) │ │ │ │ - }, │ │ │ │ +OpenLayers.Control.Split = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ - */ │ │ │ │ - writers: { │ │ │ │ - "sos": { │ │ │ │ - "GetFeatureOfInterest": function(options) { │ │ │ │ - var node = this.createElementNSPlus("GetFeatureOfInterest", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - service: 'SOS', │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - for (var i = 0, len = options.fois.length; i < len; i++) { │ │ │ │ - this.writeNode("FeatureOfInterestId", { │ │ │ │ - foi: options.fois[i] │ │ │ │ - }, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "FeatureOfInterestId": function(options) { │ │ │ │ - var node = this.createElementNSPlus("FeatureOfInterestId", { │ │ │ │ - value: options.foi │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforesplit - Triggered before a split occurs. Listeners receive an │ │ │ │ + * event object with *source* and *target* properties. │ │ │ │ + * split - Triggered when a split occurs. Listeners receive an event with │ │ │ │ + * an *original* property and a *features* property. The original │ │ │ │ + * is a reference to the target feature that the sketch or modified │ │ │ │ + * feature intersects. The features property is a list of all features │ │ │ │ + * that result from this single split. This event is triggered before │ │ │ │ + * the resulting features are added to the layer (while the layer still │ │ │ │ + * has a reference to the original). │ │ │ │ + * aftersplit - Triggered after all splits resulting from a single sketch │ │ │ │ + * or feature modification have occurred. The original features │ │ │ │ + * have been destroyed and features that result from the split │ │ │ │ + * have already been added to the layer. Listeners receive an event │ │ │ │ + * with a *source* and *features* property. The source references the │ │ │ │ + * sketch or modified feature used as a splitter. The features │ │ │ │ + * property is a list of all resulting features. │ │ │ │ + */ │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSGetFeatureOfInterest" │ │ │ │ + /** │ │ │ │ + * APIProperty: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The target layer with features to be split. │ │ │ │ + * Set at construction or after construction with <setLayer>. │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/SOSGetObservation.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Property: source │ │ │ │ + * {<OpenLayers.Layer.Vector>} Optional source layer. Any newly created │ │ │ │ + * or modified features from this layer will be used to split features │ │ │ │ + * on the target layer. If not provided, a temporary sketch layer will │ │ │ │ + * be created. │ │ │ │ + */ │ │ │ │ + source: null, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * Property: sourceOptions │ │ │ │ + * {Options} If a temporary sketch layer is created, these layer options │ │ │ │ + * will be applied. │ │ │ │ + */ │ │ │ │ + sourceOptions: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/SOSGetFeatureOfInterest.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: tolerance │ │ │ │ + * {Number} Distance between the calculated intersection and a vertex on │ │ │ │ + * the source geometry below which the existing vertex will be used │ │ │ │ + * for the split. Default is null. │ │ │ │ + */ │ │ │ │ + tolerance: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.SOSGetObservation │ │ │ │ - * Read and write SOS GetObersation (to get the actual values from a sensor) │ │ │ │ - * version 1.0.0 │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.SOSGetObservation = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + /** │ │ │ │ + * APIProperty: edge │ │ │ │ + * {Boolean} Allow splits given intersection of edges only. Default is │ │ │ │ + * true. If false, a vertex on the source must be within the │ │ │ │ + * <tolerance> distance of the calculated intersection for a split │ │ │ │ + * to occur. │ │ │ │ + */ │ │ │ │ + edge: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * APIProperty: deferDelete │ │ │ │ + * {Boolean} Instead of removing features from the layer, set feature │ │ │ │ + * states of split features to DELETE. This assumes a save strategy │ │ │ │ + * or other component is in charge of removing features from the │ │ │ │ + * layer. Default is false. If false, split features will be │ │ │ │ + * immediately deleted from the layer. │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - sos: "http://www.opengis.net/sos/1.0", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - om: "http://www.opengis.net/om/1.0", │ │ │ │ - sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ + deferDelete: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ + * APIProperty: mutual │ │ │ │ + * {Boolean} If source and target layers are the same, split source │ │ │ │ + * features and target features where they intersect. Default is │ │ │ │ + * true. If false, only target features will be split. │ │ │ │ */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ + mutual: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.0.0 │ │ │ │ + * APIProperty: targetFilter │ │ │ │ + * {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ + * to determine if a feature from the target layer is eligible for │ │ │ │ + * splitting. │ │ │ │ */ │ │ │ │ - VERSION: "1.0.0", │ │ │ │ + targetFilter: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location │ │ │ │ + * APIProperty: sourceFilter │ │ │ │ + * {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ + * to determine if a feature from the source layer is eligible for │ │ │ │ + * splitting. │ │ │ │ */ │ │ │ │ - schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosGetObservation.xsd", │ │ │ │ + sourceFilter: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ + * Property: handler │ │ │ │ + * {<OpenLayers.Handler.Path>} The temporary sketch handler created if │ │ │ │ + * no source layer is provided. │ │ │ │ */ │ │ │ │ - defaultPrefix: "sos", │ │ │ │ + handler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.SOSGetObservation │ │ │ │ + * Constructor: OpenLayers.Control.Split │ │ │ │ + * Creates a new split control. A control is constructed with a target │ │ │ │ + * layer and an optional source layer. While the control is active, │ │ │ │ + * creating new features or modifying existing features on the source │ │ │ │ + * layer will result in splitting any eligible features on the target │ │ │ │ + * layer. If no source layer is provided, a temporary sketch layer will │ │ │ │ + * be created to create lines for splitting features on the target. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * options - {Object} An object containing all configuration properties for │ │ │ │ + * the control. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} The target layer. Features from this │ │ │ │ + * layer will be split by new or modified features on the source layer │ │ │ │ + * or temporary sketch layer. │ │ │ │ + * source - {<OpenLayers.Layer.Vector>} Optional source layer. If provided │ │ │ │ + * newly created features or modified features will be used to split │ │ │ │ + * features on the target layer. If not provided, a temporary sketch │ │ │ │ + * layer will be created for drawing lines. │ │ │ │ + * tolerance - {Number} Optional value for the distance between a source │ │ │ │ + * vertex and the calculated intersection below which the split will │ │ │ │ + * occur at the vertex. │ │ │ │ + * edge - {Boolean} Allow splits given intersection of edges only. Default │ │ │ │ + * is true. If false, a vertex on the source must be within the │ │ │ │ + * <tolerance> distance of the calculated intersection for a split │ │ │ │ + * to occur. │ │ │ │ + * mutual - {Boolean} If source and target are the same, split source │ │ │ │ + * features and target features where they intersect. Default is │ │ │ │ + * true. If false, only target features will be split. │ │ │ │ + * targetFilter - {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ + * to determine if a feature from the target layer is eligible for │ │ │ │ + * splitting. │ │ │ │ + * sourceFilter - {<OpenLayers.Filter>} Optional filter that will be evaluated │ │ │ │ + * to determine if a feature from the target layer is eligible for │ │ │ │ + * splitting. │ │ │ │ */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options || {}; // TODO: this could be done by the super │ │ │ │ + │ │ │ │ + // set the source layer if provided │ │ │ │ + if (this.options.source) { │ │ │ │ + this.setSource(this.options.source); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * APIMethod: setSource │ │ │ │ + * Set the source layer for edits layer. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object containing the measurements │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} The new source layer layer. If │ │ │ │ + * null, a temporary sketch layer will be created. │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + setSource: function(layer) { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.destroy(); │ │ │ │ + delete this.handler; │ │ │ │ + } │ │ │ │ + this.source = layer; │ │ │ │ + this.activate(); │ │ │ │ + } else { │ │ │ │ + this.source = layer; │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the control. Activating the control registers listeners for │ │ │ │ + * editing related events so that during feature creation and │ │ │ │ + * modification, features in the target will be considered for │ │ │ │ + * splitting. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (!this.source) { │ │ │ │ + if (!this.handler) { │ │ │ │ + this.handler = new OpenLayers.Handler.Path(this, { │ │ │ │ + done: function(geometry) { │ │ │ │ + this.onSketchComplete({ │ │ │ │ + feature: new OpenLayers.Feature.Vector(geometry) │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, { │ │ │ │ + layerOptions: this.sourceOptions │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.handler.activate(); │ │ │ │ + } else if (this.source.events) { │ │ │ │ + this.source.events.on({ │ │ │ │ + sketchcomplete: this.onSketchComplete, │ │ │ │ + afterfeaturemodified: this.afterFeatureModified, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - var info = { │ │ │ │ - measurements: [], │ │ │ │ - observations: [] │ │ │ │ - }; │ │ │ │ - this.readNode(data, info); │ │ │ │ - return info; │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the control. Deactivating the control unregisters listeners │ │ │ │ + * so feature editing may proceed without engaging the split agent. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + if (this.source && this.source.events) { │ │ │ │ + this.source.events.un({ │ │ │ │ + sketchcomplete: this.onSketchComplete, │ │ │ │ + afterfeaturemodified: this.afterFeatureModified, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: onSketchComplete │ │ │ │ + * Registered as a listener for the sketchcomplete event on the editable │ │ │ │ + * layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object. │ │ │ │ + * event - {Object} The sketch complete event. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} An SOS GetObservation request XML string. │ │ │ │ + * {Boolean} Stop the sketch from being added to the layer (it has been │ │ │ │ + * split). │ │ │ │ */ │ │ │ │ - write: function(options) { │ │ │ │ - var node = this.writeNode("sos:GetObservation", options); │ │ │ │ - node.setAttribute("xmlns:om", this.namespaces.om); │ │ │ │ - node.setAttribute("xmlns:ogc", this.namespaces.ogc); │ │ │ │ - this.setAttributeNS( │ │ │ │ - node, this.namespaces.xsi, │ │ │ │ - "xsi:schemaLocation", this.schemaLocation │ │ │ │ - ); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + onSketchComplete: function(event) { │ │ │ │ + this.feature = null; │ │ │ │ + return !this.considerSplit(event.feature); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ + * Method: afterFeatureModified │ │ │ │ + * Registered as a listener for the afterfeaturemodified event on the │ │ │ │ + * editable layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * event - {Object} The after feature modified event. │ │ │ │ */ │ │ │ │ - readers: { │ │ │ │ - "om": { │ │ │ │ - "ObservationCollection": function(node, obj) { │ │ │ │ - obj.id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "member": function(node, observationCollection) { │ │ │ │ - this.readChildNodes(node, observationCollection); │ │ │ │ - }, │ │ │ │ - "Measurement": function(node, observationCollection) { │ │ │ │ - var measurement = {}; │ │ │ │ - observationCollection.measurements.push(measurement); │ │ │ │ - this.readChildNodes(node, measurement); │ │ │ │ - }, │ │ │ │ - "Observation": function(node, observationCollection) { │ │ │ │ - var observation = {}; │ │ │ │ - observationCollection.observations.push(observation); │ │ │ │ - this.readChildNodes(node, observation); │ │ │ │ - }, │ │ │ │ - "samplingTime": function(node, measurement) { │ │ │ │ - var samplingTime = {}; │ │ │ │ - measurement.samplingTime = samplingTime; │ │ │ │ - this.readChildNodes(node, samplingTime); │ │ │ │ - }, │ │ │ │ - "observedProperty": function(node, measurement) { │ │ │ │ - measurement.observedProperty = │ │ │ │ - this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ - this.readChildNodes(node, measurement); │ │ │ │ - }, │ │ │ │ - "procedure": function(node, measurement) { │ │ │ │ - measurement.procedure = │ │ │ │ - this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ - this.readChildNodes(node, measurement); │ │ │ │ - }, │ │ │ │ - "featureOfInterest": function(node, observation) { │ │ │ │ - var foi = { │ │ │ │ - features: [] │ │ │ │ - }; │ │ │ │ - observation.fois = []; │ │ │ │ - observation.fois.push(foi); │ │ │ │ - this.readChildNodes(node, foi); │ │ │ │ - // postprocessing to get actual features │ │ │ │ - var features = []; │ │ │ │ - for (var i = 0, len = foi.features.length; i < len; i++) { │ │ │ │ - var feature = foi.features[i]; │ │ │ │ - features.push(new OpenLayers.Feature.Vector( │ │ │ │ - feature.components[0], feature.attributes)); │ │ │ │ - } │ │ │ │ - foi.features = features; │ │ │ │ - }, │ │ │ │ - "result": function(node, measurement) { │ │ │ │ - var result = {}; │ │ │ │ - measurement.result = result; │ │ │ │ - if (this.getChildValue(node) !== '') { │ │ │ │ - result.value = this.getChildValue(node); │ │ │ │ - result.uom = node.getAttribute("uom"); │ │ │ │ - } else { │ │ │ │ - this.readChildNodes(node, result); │ │ │ │ - } │ │ │ │ + afterFeatureModified: function(event) { │ │ │ │ + if (event.modified) { │ │ │ │ + var feature = event.feature; │ │ │ │ + if (typeof feature.geometry.split === "function") { │ │ │ │ + this.feature = event.feature; │ │ │ │ + this.considerSplit(event.feature); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - "sa": OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.sa, │ │ │ │ - "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ - "TimeInstant": function(node, samplingTime) { │ │ │ │ - var timeInstant = {}; │ │ │ │ - samplingTime.timeInstant = timeInstant; │ │ │ │ - this.readChildNodes(node, timeInstant); │ │ │ │ - }, │ │ │ │ - "timePosition": function(node, timeInstant) { │ │ │ │ - timeInstant.timePosition = this.getChildValue(node); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: removeByGeometry │ │ │ │ + * Remove a feature from a list based on the given geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} A list of features. │ │ │ │ + * geometry - {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + removeByGeometry: function(features, geometry) { │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + if (features[i].geometry === geometry) { │ │ │ │ + features.splice(i, 1); │ │ │ │ + break; │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.gml) │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * Method: isEligible │ │ │ │ + * Test if a target feature is eligible for splitting. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * target - {<OpenLayers.Feature.Vector>} The target feature. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The target is eligible for splitting. │ │ │ │ */ │ │ │ │ - writers: { │ │ │ │ - "sos": { │ │ │ │ - "GetObservation": function(options) { │ │ │ │ - var node = this.createElementNSPlus("GetObservation", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - service: 'SOS' │ │ │ │ + isEligible: function(target) { │ │ │ │ + if (!target.geometry) { │ │ │ │ + return false; │ │ │ │ + } else { │ │ │ │ + return ( │ │ │ │ + target.state !== OpenLayers.State.DELETE │ │ │ │ + ) && ( │ │ │ │ + typeof target.geometry.split === "function" │ │ │ │ + ) && ( │ │ │ │ + this.feature !== target │ │ │ │ + ) && ( │ │ │ │ + !this.targetFilter || │ │ │ │ + this.targetFilter.evaluate(target.attributes) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: considerSplit │ │ │ │ + * Decide whether or not to split target features with the supplied │ │ │ │ + * feature. If <mutual> is true, both the source and target features │ │ │ │ + * will be split if eligible. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The newly created or modified │ │ │ │ + * feature. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The supplied feature was split (and destroyed). │ │ │ │ + */ │ │ │ │ + considerSplit: function(feature) { │ │ │ │ + var sourceSplit = false; │ │ │ │ + var targetSplit = false; │ │ │ │ + if (!this.sourceFilter || │ │ │ │ + this.sourceFilter.evaluate(feature.attributes)) { │ │ │ │ + var features = this.layer && this.layer.features || []; │ │ │ │ + var target, results, proceed; │ │ │ │ + var additions = [], │ │ │ │ + removals = []; │ │ │ │ + var mutual = (this.layer === this.source) && this.mutual; │ │ │ │ + var options = { │ │ │ │ + edge: this.edge, │ │ │ │ + tolerance: this.tolerance, │ │ │ │ + mutual: mutual │ │ │ │ + }; │ │ │ │ + var sourceParts = [feature.geometry]; │ │ │ │ + var targetFeature, targetParts; │ │ │ │ + var source, parts; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + targetFeature = features[i]; │ │ │ │ + if (this.isEligible(targetFeature)) { │ │ │ │ + targetParts = [targetFeature.geometry]; │ │ │ │ + // work through source geoms - this array may change │ │ │ │ + for (var j = 0; j < sourceParts.length; ++j) { │ │ │ │ + source = sourceParts[j]; │ │ │ │ + // work through target parts - this array may change │ │ │ │ + for (var k = 0; k < targetParts.length; ++k) { │ │ │ │ + target = targetParts[k]; │ │ │ │ + if (source.getBounds().intersectsBounds(target.getBounds())) { │ │ │ │ + results = source.split(target, options); │ │ │ │ + if (results) { │ │ │ │ + proceed = this.events.triggerEvent( │ │ │ │ + "beforesplit", { │ │ │ │ + source: feature, │ │ │ │ + target: targetFeature │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + if (proceed !== false) { │ │ │ │ + if (mutual) { │ │ │ │ + parts = results[0]; │ │ │ │ + // handle parts that result from source splitting │ │ │ │ + if (parts.length > 1) { │ │ │ │ + // splice in new source parts │ │ │ │ + parts.unshift(j, 1); // add args for splice below │ │ │ │ + Array.prototype.splice.apply(sourceParts, parts); │ │ │ │ + j += parts.length - 3; │ │ │ │ + } │ │ │ │ + results = results[1]; │ │ │ │ + } │ │ │ │ + // handle parts that result from target splitting │ │ │ │ + if (results.length > 1) { │ │ │ │ + // splice in new target parts │ │ │ │ + results.unshift(k, 1); // add args for splice below │ │ │ │ + Array.prototype.splice.apply(targetParts, results); │ │ │ │ + k += results.length - 3; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (targetParts && targetParts.length > 1) { │ │ │ │ + this.geomsToFeatures(targetFeature, targetParts); │ │ │ │ + this.events.triggerEvent("split", { │ │ │ │ + original: targetFeature, │ │ │ │ + features: targetParts │ │ │ │ + }); │ │ │ │ + Array.prototype.push.apply(additions, targetParts); │ │ │ │ + removals.push(targetFeature); │ │ │ │ + targetSplit = true; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - this.writeNode("offering", options, node); │ │ │ │ - if (options.eventTime) { │ │ │ │ - this.writeNode("eventTime", options, node); │ │ │ │ - } │ │ │ │ - for (var procedure in options.procedures) { │ │ │ │ - this.writeNode("procedure", options.procedures[procedure], node); │ │ │ │ - } │ │ │ │ - for (var observedProperty in options.observedProperties) { │ │ │ │ - this.writeNode("observedProperty", options.observedProperties[observedProperty], node); │ │ │ │ - } │ │ │ │ - if (options.foi) { │ │ │ │ - this.writeNode("featureOfInterest", options.foi, node); │ │ │ │ - } │ │ │ │ - this.writeNode("responseFormat", options, node); │ │ │ │ - if (options.resultModel) { │ │ │ │ - this.writeNode("resultModel", options, node); │ │ │ │ - } │ │ │ │ - if (options.responseMode) { │ │ │ │ - this.writeNode("responseMode", options, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "featureOfInterest": function(foi) { │ │ │ │ - var node = this.createElementNSPlus("featureOfInterest"); │ │ │ │ - this.writeNode("ObjectID", foi.objectId, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ObjectID": function(options) { │ │ │ │ - return this.createElementNSPlus("ObjectID", { │ │ │ │ - value: options │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "responseFormat": function(options) { │ │ │ │ - return this.createElementNSPlus("responseFormat", { │ │ │ │ - value: options.responseFormat │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "procedure": function(procedure) { │ │ │ │ - return this.createElementNSPlus("procedure", { │ │ │ │ - value: procedure │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "offering": function(options) { │ │ │ │ - return this.createElementNSPlus("offering", { │ │ │ │ - value: options.offering │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "observedProperty": function(observedProperty) { │ │ │ │ - return this.createElementNSPlus("observedProperty", { │ │ │ │ - value: observedProperty │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "eventTime": function(options) { │ │ │ │ - var node = this.createElementNSPlus("eventTime"); │ │ │ │ - if (options.eventTime === 'latest') { │ │ │ │ - this.writeNode("ogc:TM_Equals", options, node); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "resultModel": function(options) { │ │ │ │ - return this.createElementNSPlus("resultModel", { │ │ │ │ - value: options.resultModel │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "responseMode": function(options) { │ │ │ │ - return this.createElementNSPlus("responseMode", { │ │ │ │ - value: options.responseMode │ │ │ │ + } │ │ │ │ + if (sourceParts && sourceParts.length > 1) { │ │ │ │ + this.geomsToFeatures(feature, sourceParts); │ │ │ │ + this.events.triggerEvent("split", { │ │ │ │ + original: feature, │ │ │ │ + features: sourceParts │ │ │ │ }); │ │ │ │ + Array.prototype.push.apply(additions, sourceParts); │ │ │ │ + removals.push(feature); │ │ │ │ + sourceSplit = true; │ │ │ │ } │ │ │ │ - }, │ │ │ │ - "ogc": { │ │ │ │ - "TM_Equals": function(options) { │ │ │ │ - var node = this.createElementNSPlus("ogc:TM_Equals"); │ │ │ │ - this.writeNode("ogc:PropertyName", { │ │ │ │ - property: "urn:ogc:data:time:iso8601" │ │ │ │ - }, node); │ │ │ │ - if (options.eventTime === 'latest') { │ │ │ │ - this.writeNode("gml:TimeInstant", { │ │ │ │ - value: 'latest' │ │ │ │ - }, node); │ │ │ │ + if (sourceSplit || targetSplit) { │ │ │ │ + // remove and add feature events are suppressed │ │ │ │ + // listen for split event on this control instead │ │ │ │ + if (this.deferDelete) { │ │ │ │ + // Set state instead of removing. Take care to avoid │ │ │ │ + // setting delete for features that have not yet been │ │ │ │ + // inserted - those should be destroyed immediately. │ │ │ │ + var feat, destroys = []; │ │ │ │ + for (var i = 0, len = removals.length; i < len; ++i) { │ │ │ │ + feat = removals[i]; │ │ │ │ + if (feat.state === OpenLayers.State.INSERT) { │ │ │ │ + destroys.push(feat); │ │ │ │ + } else { │ │ │ │ + feat.state = OpenLayers.State.DELETE; │ │ │ │ + this.layer.drawFeature(feat); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.destroyFeatures(destroys, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + for (var i = 0, len = additions.length; i < len; ++i) { │ │ │ │ + additions[i].state = OpenLayers.State.INSERT; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.layer.destroyFeatures(removals, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PropertyName": function(options) { │ │ │ │ - return this.createElementNSPlus("ogc:PropertyName", { │ │ │ │ - value: options.property │ │ │ │ + this.layer.addFeatures(additions, { │ │ │ │ + silent: true │ │ │ │ }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "gml": { │ │ │ │ - "TimeInstant": function(options) { │ │ │ │ - var node = this.createElementNSPlus("gml:TimeInstant"); │ │ │ │ - this.writeNode("gml:timePosition", options, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "timePosition": function(options) { │ │ │ │ - var node = this.createElementNSPlus("gml:timePosition", { │ │ │ │ - value: options.value │ │ │ │ + this.events.triggerEvent("aftersplit", { │ │ │ │ + source: feature, │ │ │ │ + features: additions │ │ │ │ }); │ │ │ │ - return node; │ │ │ │ } │ │ │ │ } │ │ │ │ + return sourceSplit; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSGetObservation" │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities │ │ │ │ - * Read WMS Capabilities. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.1.1". │ │ │ │ - */ │ │ │ │ - defaultVersion: "1.1.1", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: profile │ │ │ │ - * {String} If provided, use a custom profile. │ │ │ │ - * │ │ │ │ - * Currently supported profiles: │ │ │ │ - * - WMSC - parses vendor specific capabilities for WMS-C. │ │ │ │ - */ │ │ │ │ - profile: null, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSCapabilities │ │ │ │ - * Create a new parser for WMS capabilities. │ │ │ │ + * Method: geomsToFeatures │ │ │ │ + * Create new features given a template feature and a list of geometries. │ │ │ │ + * The list of geometries is modified in place. The result will be │ │ │ │ + * a list of new features. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature to be cloned. │ │ │ │ + * geoms - {Array(<OpenLayers.Geometry>)} List of goemetries. This will │ │ │ │ + * become a list of new features. │ │ │ │ */ │ │ │ │ + geomsToFeatures: function(feature, geoms) { │ │ │ │ + var clone = feature.clone(); │ │ │ │ + delete clone.geometry; │ │ │ │ + var newFeature; │ │ │ │ + for (var i = 0, len = geoms.length; i < len; ++i) { │ │ │ │ + // turn results list from geoms to features │ │ │ │ + newFeature = clone.clone(); │ │ │ │ + newFeature.geometry = geoms[i]; │ │ │ │ + newFeature.state = OpenLayers.State.INSERT; │ │ │ │ + geoms[i] = newFeature; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return a list of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} List of named layers. │ │ │ │ + * Method: destroy │ │ │ │ + * Clean up the control. │ │ │ │ */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); // TODO: this should be handled by the super │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.call(this); │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities" │ │ │ │ - │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Split" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/CQL.js │ │ │ │ + OpenLayers/Control/Attribution.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/WKT.js │ │ │ │ - * @requires OpenLayers/Filter/Comparison.js │ │ │ │ - * @requires OpenLayers/Filter/Logical.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.CQL │ │ │ │ - * Read CQL strings to get <OpenLayers.Filter> objects. Write │ │ │ │ - * <OpenLayers.Filter> objects to get CQL strings. Create a new parser with │ │ │ │ - * the <OpenLayers.Format.CQL> constructor. │ │ │ │ + * Class: OpenLayers.Control.Attribution │ │ │ │ + * The attribution control adds attribution from layers to the map display. │ │ │ │ + * It uses 'attribution' property of each layer. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.CQL = (function() { │ │ │ │ - │ │ │ │ - var tokens = [ │ │ │ │ - "PROPERTY", "COMPARISON", "VALUE", "LOGICAL" │ │ │ │ - ], │ │ │ │ +OpenLayers.Control.Attribution = │ │ │ │ + OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - patterns = { │ │ │ │ - PROPERTY: /^[_a-zA-Z]\w*/, │ │ │ │ - COMPARISON: /^(=|<>|<=|<|>=|>|LIKE)/i, │ │ │ │ - IS_NULL: /^IS NULL/i, │ │ │ │ - COMMA: /^,/, │ │ │ │ - LOGICAL: /^(AND|OR)/i, │ │ │ │ - VALUE: /^('([^']|'')*'|\d+(\.\d*)?|\.\d+)/, │ │ │ │ - LPAREN: /^\(/, │ │ │ │ - RPAREN: /^\)/, │ │ │ │ - SPATIAL: /^(BBOX|INTERSECTS|DWITHIN|WITHIN|CONTAINS)/i, │ │ │ │ - NOT: /^NOT/i, │ │ │ │ - BETWEEN: /^BETWEEN/i, │ │ │ │ - GEOMETRY: function(text) { │ │ │ │ - var type = /^(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)/.exec(text); │ │ │ │ - if (type) { │ │ │ │ - var len = text.length; │ │ │ │ - var idx = text.indexOf("(", type[0].length); │ │ │ │ - if (idx > -1) { │ │ │ │ - var depth = 1; │ │ │ │ - while (idx < len && depth > 0) { │ │ │ │ - idx++; │ │ │ │ - switch (text.charAt(idx)) { │ │ │ │ - case '(': │ │ │ │ - depth++; │ │ │ │ - break; │ │ │ │ - case ')': │ │ │ │ - depth--; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - // in default case, do nothing │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return [text.substr(0, idx + 1)]; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - END: /^$/ │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: separator │ │ │ │ + * {String} String used to separate layers. │ │ │ │ + */ │ │ │ │ + separator: ", ", │ │ │ │ │ │ │ │ - follows = { │ │ │ │ - LPAREN: ['GEOMETRY', 'SPATIAL', 'PROPERTY', 'VALUE', 'LPAREN'], │ │ │ │ - RPAREN: ['NOT', 'LOGICAL', 'END', 'RPAREN'], │ │ │ │ - PROPERTY: ['COMPARISON', 'BETWEEN', 'COMMA', 'IS_NULL'], │ │ │ │ - BETWEEN: ['VALUE'], │ │ │ │ - IS_NULL: ['END'], │ │ │ │ - COMPARISON: ['VALUE'], │ │ │ │ - COMMA: ['GEOMETRY', 'VALUE', 'PROPERTY'], │ │ │ │ - VALUE: ['LOGICAL', 'COMMA', 'RPAREN', 'END'], │ │ │ │ - SPATIAL: ['LPAREN'], │ │ │ │ - LOGICAL: ['NOT', 'VALUE', 'SPATIAL', 'PROPERTY', 'LPAREN'], │ │ │ │ - NOT: ['PROPERTY', 'LPAREN'], │ │ │ │ - GEOMETRY: ['COMMA', 'RPAREN'] │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: template │ │ │ │ + * {String} Template for the attribution. This has to include the substring │ │ │ │ + * "${layers}", which will be replaced by the layer specific │ │ │ │ + * attributions, separated by <separator>. The default is "${layers}". │ │ │ │ + */ │ │ │ │ + template: "${layers}", │ │ │ │ │ │ │ │ - operators = { │ │ │ │ - '=': OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ - '<>': OpenLayers.Filter.Comparison.NOT_EQUAL_TO, │ │ │ │ - '<': OpenLayers.Filter.Comparison.LESS_THAN, │ │ │ │ - '<=': OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO, │ │ │ │ - '>': OpenLayers.Filter.Comparison.GREATER_THAN, │ │ │ │ - '>=': OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO, │ │ │ │ - 'LIKE': OpenLayers.Filter.Comparison.LIKE, │ │ │ │ - 'BETWEEN': OpenLayers.Filter.Comparison.BETWEEN, │ │ │ │ - 'IS NULL': OpenLayers.Filter.Comparison.IS_NULL │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.Attribution │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Options for control. │ │ │ │ + */ │ │ │ │ │ │ │ │ - operatorReverse = {}, │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Destroy control. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.map.events.un({ │ │ │ │ + "removelayer": this.updateAttribution, │ │ │ │ + "addlayer": this.updateAttribution, │ │ │ │ + "changelayer": this.updateAttribution, │ │ │ │ + "changebaselayer": this.updateAttribution, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ │ │ │ │ - logicals = { │ │ │ │ - 'AND': OpenLayers.Filter.Logical.AND, │ │ │ │ - 'OR': OpenLayers.Filter.Logical.OR │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - logicalReverse = {}, │ │ │ │ - │ │ │ │ - precedence = { │ │ │ │ - 'RPAREN': 3, │ │ │ │ - 'LOGICAL': 2, │ │ │ │ - 'COMPARISON': 1 │ │ │ │ - }; │ │ │ │ - │ │ │ │ - var i; │ │ │ │ - for (i in operators) { │ │ │ │ - if (operators.hasOwnProperty(i)) { │ │ │ │ - operatorReverse[operators[i]] = i; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * Initialize control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ │ │ │ │ - for (i in logicals) { │ │ │ │ - if (logicals.hasOwnProperty(i)) { │ │ │ │ - logicalReverse[logicals[i]] = i; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.map.events.on({ │ │ │ │ + 'changebaselayer': this.updateAttribution, │ │ │ │ + 'changelayer': this.updateAttribution, │ │ │ │ + 'addlayer': this.updateAttribution, │ │ │ │ + 'removelayer': this.updateAttribution, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.updateAttribution(); │ │ │ │ │ │ │ │ - function tryToken(text, pattern) { │ │ │ │ - if (pattern instanceof RegExp) { │ │ │ │ - return pattern.exec(text); │ │ │ │ - } else { │ │ │ │ - return pattern(text); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + return this.div; │ │ │ │ + }, │ │ │ │ │ │ │ │ - function nextToken(text, tokens) { │ │ │ │ - var i, token, len = tokens.length; │ │ │ │ - for (i = 0; i < len; i++) { │ │ │ │ - token = tokens[i]; │ │ │ │ - var pat = patterns[token]; │ │ │ │ - var matches = tryToken(text, pat); │ │ │ │ - if (matches) { │ │ │ │ - var match = matches[0]; │ │ │ │ - var remainder = text.substr(match.length).replace(/^\s*/, ""); │ │ │ │ - return { │ │ │ │ - type: token, │ │ │ │ - text: match, │ │ │ │ - remainder: remainder │ │ │ │ - }; │ │ │ │ + /** │ │ │ │ + * Method: updateAttribution │ │ │ │ + * Update attribution string. │ │ │ │ + */ │ │ │ │ + updateAttribution: function() { │ │ │ │ + var attributions = []; │ │ │ │ + if (this.map && this.map.layers) { │ │ │ │ + for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (layer.attribution && layer.getVisibility()) { │ │ │ │ + // add attribution only if attribution text is unique │ │ │ │ + if (OpenLayers.Util.indexOf( │ │ │ │ + attributions, layer.attribution) === -1) { │ │ │ │ + attributions.push(layer.attribution); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ + layers: attributions.join(this.separator) │ │ │ │ + }); │ │ │ │ } │ │ │ │ - } │ │ │ │ - │ │ │ │ - var msg = "ERROR: In parsing: [" + text + "], expected one of: "; │ │ │ │ - for (i = 0; i < len; i++) { │ │ │ │ - token = tokens[i]; │ │ │ │ - msg += "\n " + token + ": " + patterns[token]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - throw new Error(msg); │ │ │ │ - } │ │ │ │ - │ │ │ │ - function tokenize(text) { │ │ │ │ - var results = []; │ │ │ │ - var token, expect = ["NOT", "GEOMETRY", "SPATIAL", "PROPERTY", "LPAREN"]; │ │ │ │ + }, │ │ │ │ │ │ │ │ - do { │ │ │ │ - token = nextToken(text, expect); │ │ │ │ - text = token.remainder; │ │ │ │ - expect = follows[token.type]; │ │ │ │ - if (token.type != "END" && !expect) { │ │ │ │ - throw new Error("No follows list for " + token.type); │ │ │ │ - } │ │ │ │ - results.push(token); │ │ │ │ - } while (token.type != "END"); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/KeyboardDefaults.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - return results; │ │ │ │ - } │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - function buildAst(tokens) { │ │ │ │ - var operatorStack = [], │ │ │ │ - postfix = []; │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Keyboard.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - while (tokens.length) { │ │ │ │ - var tok = tokens.shift(); │ │ │ │ - switch (tok.type) { │ │ │ │ - case "PROPERTY": │ │ │ │ - case "GEOMETRY": │ │ │ │ - case "VALUE": │ │ │ │ - postfix.push(tok); │ │ │ │ - break; │ │ │ │ - case "COMPARISON": │ │ │ │ - case "BETWEEN": │ │ │ │ - case "IS_NULL": │ │ │ │ - case "LOGICAL": │ │ │ │ - var p = precedence[tok.type]; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.KeyboardDefaults │ │ │ │ + * The KeyboardDefaults control adds panning and zooming functions, controlled │ │ │ │ + * with the keyboard. By default arrow keys pan, +/- keys zoom & Page Up/Page │ │ │ │ + * Down/Home/End scroll by three quarters of a page. │ │ │ │ + * │ │ │ │ + * This control has no visible appearance. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.KeyboardDefaults = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - while (operatorStack.length > 0 && │ │ │ │ - (precedence[operatorStack[operatorStack.length - 1].type] <= p) │ │ │ │ - ) { │ │ │ │ - postfix.push(operatorStack.pop()); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ - operatorStack.push(tok); │ │ │ │ - break; │ │ │ │ - case "SPATIAL": │ │ │ │ - case "NOT": │ │ │ │ - case "LPAREN": │ │ │ │ - operatorStack.push(tok); │ │ │ │ - break; │ │ │ │ - case "RPAREN": │ │ │ │ - while (operatorStack.length > 0 && │ │ │ │ - (operatorStack[operatorStack.length - 1].type != "LPAREN") │ │ │ │ - ) { │ │ │ │ - postfix.push(operatorStack.pop()); │ │ │ │ - } │ │ │ │ - operatorStack.pop(); // toss out the LPAREN │ │ │ │ + /** │ │ │ │ + * APIProperty: slideFactor │ │ │ │ + * Pixels to slide by. │ │ │ │ + */ │ │ │ │ + slideFactor: 75, │ │ │ │ │ │ │ │ - if (operatorStack.length > 0 && │ │ │ │ - operatorStack[operatorStack.length - 1].type == "SPATIAL") { │ │ │ │ - postfix.push(operatorStack.pop()); │ │ │ │ - } │ │ │ │ - case "COMMA": │ │ │ │ - case "END": │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - throw new Error("Unknown token type " + tok.type); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: observeElement │ │ │ │ + * {DOMelement|String} The DOM element to handle keys for. You │ │ │ │ + * can use the map div here, to have the navigation keys │ │ │ │ + * work when the map div has the focus. If undefined the │ │ │ │ + * document is used. │ │ │ │ + */ │ │ │ │ + observeElement: null, │ │ │ │ │ │ │ │ - while (operatorStack.length > 0) { │ │ │ │ - postfix.push(operatorStack.pop()); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.KeyboardDefaults │ │ │ │ + */ │ │ │ │ │ │ │ │ - function buildTree() { │ │ │ │ - var tok = postfix.pop(); │ │ │ │ - switch (tok.type) { │ │ │ │ - case "LOGICAL": │ │ │ │ - var rhs = buildTree(), │ │ │ │ - lhs = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Logical({ │ │ │ │ - filters: [lhs, rhs], │ │ │ │ - type: logicals[tok.text.toUpperCase()] │ │ │ │ - }); │ │ │ │ - case "NOT": │ │ │ │ - var operand = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Logical({ │ │ │ │ - filters: [operand], │ │ │ │ - type: OpenLayers.Filter.Logical.NOT │ │ │ │ - }); │ │ │ │ - case "BETWEEN": │ │ │ │ - var min, max, property; │ │ │ │ - postfix.pop(); // unneeded AND token here │ │ │ │ - max = buildTree(); │ │ │ │ - min = buildTree(); │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Comparison({ │ │ │ │ - property: property, │ │ │ │ - lowerBoundary: min, │ │ │ │ - upperBoundary: max, │ │ │ │ - type: OpenLayers.Filter.Comparison.BETWEEN │ │ │ │ - }); │ │ │ │ - case "COMPARISON": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Comparison({ │ │ │ │ - property: property, │ │ │ │ - value: value, │ │ │ │ - type: operators[tok.text.toUpperCase()] │ │ │ │ - }); │ │ │ │ - case "IS_NULL": │ │ │ │ - var property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Comparison({ │ │ │ │ - property: property, │ │ │ │ - type: operators[tok.text.toUpperCase()] │ │ │ │ - }); │ │ │ │ - case "VALUE": │ │ │ │ - var match = tok.text.match(/^'(.*)'$/); │ │ │ │ - if (match) { │ │ │ │ - return match[1].replace(/''/g, "'"); │ │ │ │ - } else { │ │ │ │ - return Number(tok.text); │ │ │ │ - } │ │ │ │ - case "SPATIAL": │ │ │ │ - switch (tok.text.toUpperCase()) { │ │ │ │ - case "BBOX": │ │ │ │ - var maxy = buildTree(), │ │ │ │ - maxx = buildTree(), │ │ │ │ - miny = buildTree(), │ │ │ │ - minx = buildTree(), │ │ │ │ - prop = buildTree(); │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * Create handler. │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + var observeElement = this.observeElement || document; │ │ │ │ + this.handler = new OpenLayers.Handler.Keyboard(this, { │ │ │ │ + "keydown": this.defaultKeyPress │ │ │ │ + }, { │ │ │ │ + observeElement: observeElement │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - property: prop, │ │ │ │ - value: OpenLayers.Bounds.fromArray( │ │ │ │ - [minx, miny, maxx, maxy] │ │ │ │ - ) │ │ │ │ - }); │ │ │ │ - case "INTERSECTS": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - case "WITHIN": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.WITHIN, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - case "CONTAINS": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.CONTAINS, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - case "DWITHIN": │ │ │ │ - var distance = buildTree(), │ │ │ │ - value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ - value: value, │ │ │ │ - property: property, │ │ │ │ - distance: Number(distance) │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - case "GEOMETRY": │ │ │ │ - return OpenLayers.Geometry.fromWKT(tok.text); │ │ │ │ - default: │ │ │ │ - return tok.text; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: defaultKeyPress │ │ │ │ + * When handling the key event, we only use evt.keyCode. This holds │ │ │ │ + * some drawbacks, though we get around them below. When interpretting │ │ │ │ + * the keycodes below (including the comments associated with them), │ │ │ │ + * consult the URL below. For instance, the Safari browser returns │ │ │ │ + * "IE keycodes", and so is supported by any keycode labeled "IE". │ │ │ │ + * │ │ │ │ + * Very informative URL: │ │ │ │ + * http://unixpapa.com/js/key.html │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + defaultKeyPress: function(evt) { │ │ │ │ + var size, handled = true; │ │ │ │ │ │ │ │ - var result = buildTree(); │ │ │ │ - if (postfix.length > 0) { │ │ │ │ - var msg = "Remaining tokens after building AST: \n"; │ │ │ │ - for (var i = postfix.length - 1; i >= 0; i--) { │ │ │ │ - msg += postfix[i].type + ": " + postfix[i].text + "\n"; │ │ │ │ - } │ │ │ │ - throw new Error(msg); │ │ │ │ + var target = OpenLayers.Event.element(evt); │ │ │ │ + if (target && │ │ │ │ + (target.tagName == 'INPUT' || │ │ │ │ + target.tagName == 'TEXTAREA' || │ │ │ │ + target.tagName == 'SELECT')) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ │ │ │ │ - return result; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Generate a filter from a CQL string. │ │ │ │ - │ │ │ │ - * Parameters: │ │ │ │ - * text - {String} The CQL text. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter>} A filter based on the CQL text. │ │ │ │ - */ │ │ │ │ - read: function(text) { │ │ │ │ - var result = buildAst(tokenize(text)); │ │ │ │ - if (this.keepData) { │ │ │ │ - this.data = result; │ │ │ │ - } │ │ │ │ - return result; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Convert a filter into a CQL string. │ │ │ │ - │ │ │ │ - * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} The filter. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A CQL string based on the filter. │ │ │ │ - */ │ │ │ │ - write: function(filter) { │ │ │ │ - if (filter instanceof OpenLayers.Geometry) { │ │ │ │ - return filter.toString(); │ │ │ │ - } │ │ │ │ - switch (filter.CLASS_NAME) { │ │ │ │ - case "OpenLayers.Filter.Spatial": │ │ │ │ - switch (filter.type) { │ │ │ │ - case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ - return "BBOX(" + │ │ │ │ - filter.property + "," + │ │ │ │ - filter.value.toBBOX() + │ │ │ │ - ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ - return "DWITHIN(" + │ │ │ │ - filter.property + ", " + │ │ │ │ - this.write(filter.value) + ", " + │ │ │ │ - filter.distance + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ - return "WITHIN(" + │ │ │ │ - filter.property + ", " + │ │ │ │ - this.write(filter.value) + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ - return "INTERSECTS(" + │ │ │ │ - filter.property + ", " + │ │ │ │ - this.write(filter.value) + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.CONTAINS: │ │ │ │ - return "CONTAINS(" + │ │ │ │ - filter.property + ", " + │ │ │ │ - this.write(filter.value) + ")"; │ │ │ │ - default: │ │ │ │ - throw new Error("Unknown spatial filter type: " + filter.type); │ │ │ │ - } │ │ │ │ - case "OpenLayers.Filter.Logical": │ │ │ │ - if (filter.type == OpenLayers.Filter.Logical.NOT) { │ │ │ │ - // TODO: deal with precedence of logical operators to │ │ │ │ - // avoid extra parentheses (not urgent) │ │ │ │ - return "NOT (" + this.write(filter.filters[0]) + ")"; │ │ │ │ - } else { │ │ │ │ - var res = "("; │ │ │ │ - var first = true; │ │ │ │ - for (var i = 0; i < filter.filters.length; i++) { │ │ │ │ - if (first) { │ │ │ │ - first = false; │ │ │ │ - } else { │ │ │ │ - res += ") " + logicalReverse[filter.type] + " ("; │ │ │ │ - } │ │ │ │ - res += this.write(filter.filters[i]); │ │ │ │ - } │ │ │ │ - return res + ")"; │ │ │ │ - } │ │ │ │ - case "OpenLayers.Filter.Comparison": │ │ │ │ - if (filter.type == OpenLayers.Filter.Comparison.BETWEEN) { │ │ │ │ - return filter.property + " BETWEEN " + │ │ │ │ - this.write(filter.lowerBoundary) + " AND " + │ │ │ │ - this.write(filter.upperBoundary); │ │ │ │ - } else { │ │ │ │ - return (filter.value !== null) ? filter.property + │ │ │ │ - " " + operatorReverse[filter.type] + " " + │ │ │ │ - this.write(filter.value) : filter.property + │ │ │ │ - " " + operatorReverse[filter.type]; │ │ │ │ - } │ │ │ │ - case undefined: │ │ │ │ - if (typeof filter === "string") { │ │ │ │ - return "'" + filter.replace(/'/g, "''") + "'"; │ │ │ │ - } else if (typeof filter === "number") { │ │ │ │ - return String(filter); │ │ │ │ - } │ │ │ │ - default: │ │ │ │ - throw new Error("Can't encode: " + filter.CLASS_NAME + " " + filter); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + switch (evt.keyCode) { │ │ │ │ + case OpenLayers.Event.KEY_LEFT: │ │ │ │ + this.map.pan(-this.slideFactor, 0); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Event.KEY_RIGHT: │ │ │ │ + this.map.pan(this.slideFactor, 0); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Event.KEY_UP: │ │ │ │ + this.map.pan(0, -this.slideFactor); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Event.KEY_DOWN: │ │ │ │ + this.map.pan(0, this.slideFactor); │ │ │ │ + break; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.CQL" │ │ │ │ + case 33: // Page Up. Same in all browsers. │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(0, -0.75 * size.h); │ │ │ │ + break; │ │ │ │ + case 34: // Page Down. Same in all browsers. │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(0, 0.75 * size.h); │ │ │ │ + break; │ │ │ │ + case 35: // End. Same in all browsers. │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(0.75 * size.w, 0); │ │ │ │ + break; │ │ │ │ + case 36: // Home. Same in all browsers. │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(-0.75 * size.w, 0); │ │ │ │ + break; │ │ │ │ │ │ │ │ - }); │ │ │ │ -})(); │ │ │ │ + case 43: // +/= (ASCII), keypad + (ASCII, Opera) │ │ │ │ + case 61: // +/= (Mozilla, Opera, some ASCII) │ │ │ │ + case 187: // +/= (IE) │ │ │ │ + case 107: // keypad + (IE, Mozilla) │ │ │ │ + this.map.zoomIn(); │ │ │ │ + break; │ │ │ │ + case 45: // -/_ (ASCII, Opera), keypad - (ASCII, Opera) │ │ │ │ + case 109: // -/_ (Mozilla), keypad - (Mozilla, IE) │ │ │ │ + case 189: // -/_ (IE) │ │ │ │ + case 95: // -/_ (some ASCII) │ │ │ │ + this.map.zoomOut(); │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + handled = false; │ │ │ │ + } │ │ │ │ + if (handled) { │ │ │ │ + // prevent browser default not to move the page │ │ │ │ + // when moving the page with the keyboard │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.KeyboardDefaults" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WMC.js │ │ │ │ + OpenLayers/Control/Button.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/Context.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WMC │ │ │ │ - * Read and write Web Map Context documents. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.Button │ │ │ │ + * The Button control is a very simple push-button, for use with │ │ │ │ + * <OpenLayers.Control.Panel>. │ │ │ │ + * When clicked, the function trigger() is executed. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.Context> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + * │ │ │ │ + * 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.Format.WMC = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ - */ │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMC │ │ │ │ - * Create a new parser for Web Map Context documents. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ +OpenLayers.Control.Button = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ /** │ │ │ │ - * Method: layerToContext │ │ │ │ - * Create a layer context object given a wms layer object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.WMS>} The layer. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} A layer context object. │ │ │ │ + * Property: type │ │ │ │ + * {Integer} OpenLayers.Control.TYPE_BUTTON. │ │ │ │ */ │ │ │ │ - layerToContext: function(layer) { │ │ │ │ - var parser = this.getParser(); │ │ │ │ - var layerContext = { │ │ │ │ - queryable: layer.queryable, │ │ │ │ - visibility: layer.visibility, │ │ │ │ - name: layer.params["LAYERS"], │ │ │ │ - title: layer.name, │ │ │ │ - "abstract": layer.metadata["abstract"], │ │ │ │ - dataURL: layer.metadata.dataURL, │ │ │ │ - metadataURL: layer.metadataURL, │ │ │ │ - server: { │ │ │ │ - version: layer.params["VERSION"], │ │ │ │ - url: layer.url │ │ │ │ - }, │ │ │ │ - maxExtent: layer.maxExtent, │ │ │ │ - transparent: layer.params["TRANSPARENT"], │ │ │ │ - numZoomLevels: layer.numZoomLevels, │ │ │ │ - units: layer.units, │ │ │ │ - isBaseLayer: layer.isBaseLayer, │ │ │ │ - opacity: layer.opacity == 1 ? undefined : layer.opacity, │ │ │ │ - displayInLayerSwitcher: layer.displayInLayerSwitcher, │ │ │ │ - singleTile: layer.singleTile, │ │ │ │ - tileSize: (layer.singleTile || !layer.tileSize) ? │ │ │ │ - undefined : { │ │ │ │ - width: layer.tileSize.w, │ │ │ │ - height: layer.tileSize.h │ │ │ │ - }, │ │ │ │ - minScale: (layer.options.resolutions || │ │ │ │ - layer.options.scales || │ │ │ │ - layer.options.maxResolution || │ │ │ │ - layer.options.minScale) ? │ │ │ │ - layer.minScale : undefined, │ │ │ │ - maxScale: (layer.options.resolutions || │ │ │ │ - layer.options.scales || │ │ │ │ - layer.options.minResolution || │ │ │ │ - layer.options.maxScale) ? │ │ │ │ - layer.maxScale : undefined, │ │ │ │ - formats: [], │ │ │ │ - styles: [], │ │ │ │ - srs: layer.srs, │ │ │ │ - dimensions: layer.dimensions │ │ │ │ - }; │ │ │ │ - │ │ │ │ - │ │ │ │ - if (layer.metadata.servertitle) { │ │ │ │ - layerContext.server.title = layer.metadata.servertitle; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (layer.metadata.formats && layer.metadata.formats.length > 0) { │ │ │ │ - for (var i = 0, len = layer.metadata.formats.length; i < len; i++) { │ │ │ │ - var format = layer.metadata.formats[i]; │ │ │ │ - layerContext.formats.push({ │ │ │ │ - value: format.value, │ │ │ │ - current: (format.value == layer.params["FORMAT"]) │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - layerContext.formats.push({ │ │ │ │ - value: layer.params["FORMAT"], │ │ │ │ - current: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ - for (var i = 0, len = layer.metadata.styles.length; i < len; i++) { │ │ │ │ - var style = layer.metadata.styles[i]; │ │ │ │ - if ((style.href == layer.params["SLD"]) || │ │ │ │ - (style.body == layer.params["SLD_BODY"]) || │ │ │ │ - (style.name == layer.params["STYLES"])) { │ │ │ │ - style.current = true; │ │ │ │ - } else { │ │ │ │ - style.current = false; │ │ │ │ - } │ │ │ │ - layerContext.styles.push(style); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - layerContext.styles.push({ │ │ │ │ - href: layer.params["SLD"], │ │ │ │ - body: layer.params["SLD_BODY"], │ │ │ │ - name: layer.params["STYLES"] || parser.defaultStyleName, │ │ │ │ - title: parser.defaultStyleTitle, │ │ │ │ - current: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return layerContext; │ │ │ │ - }, │ │ │ │ + type: OpenLayers.Control.TYPE_BUTTON, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: toContext │ │ │ │ - * Create a context object free from layer given a map or a │ │ │ │ - * context object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {<OpenLayers.Map> | Object} The map or context. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} A context object. │ │ │ │ + * Method: trigger │ │ │ │ + * Called by a control panel when the button is clicked. │ │ │ │ */ │ │ │ │ - toContext: function(obj) { │ │ │ │ - var context = {}; │ │ │ │ - var layers = obj.layers; │ │ │ │ - if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ - var metadata = obj.metadata || {}; │ │ │ │ - context.size = obj.getSize(); │ │ │ │ - context.bounds = obj.getExtent(); │ │ │ │ - context.projection = obj.projection; │ │ │ │ - context.title = obj.title; │ │ │ │ - context.keywords = metadata.keywords; │ │ │ │ - context["abstract"] = metadata["abstract"]; │ │ │ │ - context.logo = metadata.logo; │ │ │ │ - context.descriptionURL = metadata.descriptionURL; │ │ │ │ - context.contactInformation = metadata.contactInformation; │ │ │ │ - context.maxExtent = obj.maxExtent; │ │ │ │ - } else { │ │ │ │ - // copy all obj properties except the "layers" property │ │ │ │ - OpenLayers.Util.applyDefaults(context, obj); │ │ │ │ - if (context.layers != undefined) { │ │ │ │ - delete(context.layers); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (context.layersContext == undefined) { │ │ │ │ - context.layersContext = []; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // let's convert layers into layersContext object (if any) │ │ │ │ - if (layers != undefined && OpenLayers.Util.isArray(layers)) { │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ - context.layersContext.push(this.layerToContext(layer)); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return context; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC" │ │ │ │ + trigger: function() {}, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Button" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WPSCapabilities.js │ │ │ │ + OpenLayers/Control/Pan.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + * @requires OpenLayers/Control/Button.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WPSCapabilities │ │ │ │ - * Read WPS Capabilities. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.Pan │ │ │ │ + * The Pan control is a single button to pan the map in one direction. For │ │ │ │ + * a more complete control see <OpenLayers.Control.PanPanel>. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WPSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ +OpenLayers.Control.Pan = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ + /** │ │ │ │ + * APIProperty: slideFactor │ │ │ │ + * {Integer} Number of pixels by which we'll pan the map in any direction │ │ │ │ + * on clicking the arrow buttons, defaults to 50. If you want to pan │ │ │ │ + * by some ratio of the map dimensions, use <slideRatio> instead. │ │ │ │ */ │ │ │ │ - defaultVersion: "1.0.0", │ │ │ │ + slideFactor: 50, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: slideRatio │ │ │ │ + * {Number} The fraction of map width/height by which we'll pan the map │ │ │ │ + * on clicking the arrow buttons. Default is null. If set, will │ │ │ │ + * override <slideFactor>. E.g. if slideRatio is .5, then Pan Up will │ │ │ │ + * pan up half the map height. │ │ │ │ + */ │ │ │ │ + slideRatio: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: direction │ │ │ │ + * {String} in {'North', 'South', 'East', 'West'} │ │ │ │ + */ │ │ │ │ + direction: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WPSCapabilities │ │ │ │ - * Create a new parser for WPS Capabilities. │ │ │ │ + * Constructor: OpenLayers.Control.Pan │ │ │ │ + * Control which handles the panning (in any of the cardinal directions) │ │ │ │ + * of the map by a set px distance. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * direction - {String} The direction this button should pan. │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ */ │ │ │ │ + initialize: function(direction, options) { │ │ │ │ + │ │ │ │ + this.direction = direction; │ │ │ │ + this.CLASS_NAME += this.direction; │ │ │ │ + │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return information about │ │ │ │ - * the service. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Info about the WPS │ │ │ │ + * Method: trigger │ │ │ │ */ │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + var getSlideFactor = OpenLayers.Function.bind(function(dim) { │ │ │ │ + return this.slideRatio ? │ │ │ │ + this.map.getSize()[dim] * this.slideRatio : │ │ │ │ + this.slideFactor; │ │ │ │ + }, this); │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WPSCapabilities" │ │ │ │ + switch (this.direction) { │ │ │ │ + case OpenLayers.Control.Pan.NORTH: │ │ │ │ + this.map.pan(0, -getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Control.Pan.SOUTH: │ │ │ │ + this.map.pan(0, getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Control.Pan.WEST: │ │ │ │ + this.map.pan(-getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Control.Pan.EAST: │ │ │ │ + this.map.pan(getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Pan" │ │ │ │ }); │ │ │ │ + │ │ │ │ +OpenLayers.Control.Pan.NORTH = "North"; │ │ │ │ +OpenLayers.Control.Pan.SOUTH = "South"; │ │ │ │ +OpenLayers.Control.Pan.EAST = "East"; │ │ │ │ +OpenLayers.Control.Pan.WEST = "West"; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/EncodedPolyline.js │ │ │ │ + OpenLayers/Control/UTFGrid.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Hover.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.EncodedPolyline │ │ │ │ - * Class for reading and writing encoded polylines. Create a new instance │ │ │ │ - * with the <OpenLayers.Format.EncodedPolyline> constructor. │ │ │ │ + * Class: OpenLayers.Control.UTFGrid │ │ │ │ + * │ │ │ │ + * This Control provides behavior associated with UTFGrid Layers. │ │ │ │ + * These 'hit grids' provide underlying feature attributes without │ │ │ │ + * calling the server (again). This control allows Mousemove, Hovering │ │ │ │ + * and Click events to trigger callbacks that use the attributes in │ │ │ │ + * whatever way you need. │ │ │ │ + * │ │ │ │ + * The most common example may be a UTFGrid layer containing feature │ │ │ │ + * attributes that are displayed in a div as you mouseover. │ │ │ │ + * │ │ │ │ + * Example Code: │ │ │ │ + * │ │ │ │ + * (start code) │ │ │ │ + * var world_utfgrid = new OpenLayers.Layer.UTFGrid( │ │ │ │ + * 'UTFGrid Layer', │ │ │ │ + * "http://tiles/world_utfgrid/${z}/${x}/${y}.json" │ │ │ │ + * ); │ │ │ │ + * map.addLayer(world_utfgrid); │ │ │ │ + * │ │ │ │ + * var control = new OpenLayers.Control.UTFGrid({ │ │ │ │ + * layers: [world_utfgrid], │ │ │ │ + * handlerMode: 'move', │ │ │ │ + * callback: function(infoLookup) { │ │ │ │ + * // do something with returned data │ │ │ │ + * │ │ │ │ + * } │ │ │ │ + * }) │ │ │ │ + * (end code) │ │ │ │ + * │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ +OpenLayers.Control.UTFGrid = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: geometryType │ │ │ │ - * {String} Geometry type to output. One of: linestring (default), │ │ │ │ - * linearring, point, multipoint or polygon. If the geometryType is │ │ │ │ - * point, only the first point of the string is returned. │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - geometryType: "linestring", │ │ │ │ + autoActivate: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: Layers │ │ │ │ + * List of layers to consider. Must be Layer.UTFGrids │ │ │ │ + * `null` is the default indicating all UTFGrid Layers are queried. │ │ │ │ + * {Array} <OpenLayers.Layer.UTFGrid> │ │ │ │ + */ │ │ │ │ + layers: null, │ │ │ │ + │ │ │ │ + /* Property: defaultHandlerOptions │ │ │ │ + * The default opts passed to the handler constructors │ │ │ │ + */ │ │ │ │ + defaultHandlerOptions: { │ │ │ │ + 'delay': 300, │ │ │ │ + 'pixelTolerance': 4, │ │ │ │ + 'stopMove': false, │ │ │ │ + 'single': true, │ │ │ │ + 'double': false, │ │ │ │ + 'stopSingle': false, │ │ │ │ + 'stopDouble': false │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /* APIProperty: handlerMode │ │ │ │ + * Defaults to 'click'. Can be 'hover' or 'move'. │ │ │ │ + */ │ │ │ │ + handlerMode: 'click', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.EncodedPolyline │ │ │ │ - * Create a new parser for encoded polylines │ │ │ │ + * APIMethod: setHandler │ │ │ │ + * sets this.handlerMode and calls resetHandler() │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Format.EncodedPolyline>} A new encoded polylines parser. │ │ │ │ + * hm - {String} Handler Mode string; 'click', 'hover' or 'move'. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.prototype.initialize.apply(this, [options]); │ │ │ │ + setHandler: function(hm) { │ │ │ │ + this.handlerMode = hm; │ │ │ │ + this.resetHandler(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Deserialize an encoded polyline string and return a vector feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * encoded - {String} An encoded polyline string │ │ │ │ + * Method: resetHandler │ │ │ │ + * Deactivates the old hanlder and creates a new │ │ │ │ + * <OpenLayers.Handler> based on the mode specified in │ │ │ │ + * this.handlerMode │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} A vector feature with a linestring. │ │ │ │ */ │ │ │ │ - read: function(encoded) { │ │ │ │ - var geomType; │ │ │ │ - if (this.geometryType == "linestring") │ │ │ │ - geomType = OpenLayers.Geometry.LineString; │ │ │ │ - else if (this.geometryType == "linearring") │ │ │ │ - geomType = OpenLayers.Geometry.LinearRing; │ │ │ │ - else if (this.geometryType == "multipoint") │ │ │ │ - geomType = OpenLayers.Geometry.MultiPoint; │ │ │ │ - else if (this.geometryType != "point" && this.geometryType != "polygon") │ │ │ │ - return null; │ │ │ │ - │ │ │ │ - var flatPoints = this.decodeDeltas(encoded, 2); │ │ │ │ - var flatPointsLength = flatPoints.length; │ │ │ │ - │ │ │ │ - var pointGeometries = []; │ │ │ │ - for (var i = 0; i + 1 < flatPointsLength;) { │ │ │ │ - var y = flatPoints[i++], │ │ │ │ - x = flatPoints[i++]; │ │ │ │ - pointGeometries.push(new OpenLayers.Geometry.Point(x, y)); │ │ │ │ + resetHandler: function() { │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.deactivate(); │ │ │ │ + this.handler.destroy(); │ │ │ │ + this.handler = null; │ │ │ │ } │ │ │ │ │ │ │ │ - │ │ │ │ - if (this.geometryType == "point") │ │ │ │ - return new OpenLayers.Feature.Vector( │ │ │ │ - pointGeometries[0] │ │ │ │ + if (this.handlerMode == 'hover') { │ │ │ │ + // Handle this event on hover │ │ │ │ + this.handler = new OpenLayers.Handler.Hover( │ │ │ │ + this, { │ │ │ │ + 'pause': this.handleEvent, │ │ │ │ + 'move': this.reset │ │ │ │ + }, │ │ │ │ + this.handlerOptions │ │ │ │ ); │ │ │ │ - │ │ │ │ - if (this.geometryType == "polygon") │ │ │ │ - return new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.Polygon([ │ │ │ │ - new OpenLayers.Geometry.LinearRing(pointGeometries) │ │ │ │ - ]) │ │ │ │ + } else if (this.handlerMode == 'click') { │ │ │ │ + // Handle this event on click │ │ │ │ + this.handler = new OpenLayers.Handler.Click( │ │ │ │ + this, { │ │ │ │ + 'click': this.handleEvent │ │ │ │ + }, this.handlerOptions │ │ │ │ ); │ │ │ │ - │ │ │ │ - return new OpenLayers.Feature.Vector( │ │ │ │ - new geomType(pointGeometries) │ │ │ │ - ); │ │ │ │ + } else if (this.handlerMode == 'move') { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover( │ │ │ │ + this, │ │ │ │ + // Handle this event while hovering OR moving │ │ │ │ + { │ │ │ │ + 'pause': this.handleEvent, │ │ │ │ + 'move': this.handleEvent │ │ │ │ + }, │ │ │ │ + this.handlerOptions │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + if (this.handler) { │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: decode │ │ │ │ - * Deserialize an encoded string and return an array of n-dimensional │ │ │ │ - * points. │ │ │ │ + * Constructor: <OpenLayers.Control.UTFGrid> │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * encoded - {String} An encoded string │ │ │ │ - * dims - {int} The dimension of the points that are returned │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(Array(int))} An array containing n-dimensional arrays of │ │ │ │ - * coordinates. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - decode: function(encoded, dims, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var flatPoints = this.decodeDeltas(encoded, dims, factor); │ │ │ │ - var flatPointsLength = flatPoints.length; │ │ │ │ - │ │ │ │ - var points = []; │ │ │ │ - for (var i = 0; i + (dims - 1) < flatPointsLength;) { │ │ │ │ - var point = []; │ │ │ │ - │ │ │ │ - for (var dim = 0; dim < dims; ++dim) { │ │ │ │ - point.push(flatPoints[i++]) │ │ │ │ - } │ │ │ │ - │ │ │ │ - points.push(point); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return points; │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.handlerOptions = options.handlerOptions || this.defaultHandlerOptions; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.resetHandler(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Serialize a feature or array of features into a WKT string. │ │ │ │ + * Method: handleEvent │ │ │ │ + * Internal method called when specified event is triggered. │ │ │ │ + * │ │ │ │ + * This method does several things: │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * features - {<OpenLayers.Feature.Vector>|Array} A feature or array of │ │ │ │ - * features │ │ │ │ + * Gets the lonLat of the event. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {String} The WKT string representation of the input geometries │ │ │ │ + * Loops through the appropriate hit grid layers and gathers the attributes. │ │ │ │ + * │ │ │ │ + * Passes the attributes to the callback │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - write: function(features) { │ │ │ │ - var feature; │ │ │ │ - if (features.constructor == Array) │ │ │ │ - feature = features[0]; │ │ │ │ - else │ │ │ │ - feature = features; │ │ │ │ - │ │ │ │ - var geometry = feature.geometry; │ │ │ │ - var type = geometry.CLASS_NAME.split('.')[2].toLowerCase(); │ │ │ │ - │ │ │ │ - var pointGeometries; │ │ │ │ - if (type == "point") │ │ │ │ - pointGeometries = new Array(geometry); │ │ │ │ - else if (type == "linestring" || │ │ │ │ - type == "linearring" || │ │ │ │ - type == "multipoint") │ │ │ │ - pointGeometries = geometry.components; │ │ │ │ - else if (type == "polygon") │ │ │ │ - pointGeometries = geometry.components[0].components; │ │ │ │ - else │ │ │ │ - return null; │ │ │ │ - │ │ │ │ - var flatPoints = []; │ │ │ │ + handleEvent: function(evt) { │ │ │ │ + if (evt == null) { │ │ │ │ + this.reset(); │ │ │ │ + return; │ │ │ │ + } │ │ │ │ │ │ │ │ - var pointGeometriesLength = pointGeometries.length; │ │ │ │ - for (var i = 0; i < pointGeometriesLength; ++i) { │ │ │ │ - var pointGeometry = pointGeometries[i]; │ │ │ │ - flatPoints.push(pointGeometry.y); │ │ │ │ - flatPoints.push(pointGeometry.x); │ │ │ │ + var lonLat = this.map.getLonLatFromPixel(evt.xy); │ │ │ │ + if (!lonLat) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ │ │ │ │ - return this.encodeDeltas(flatPoints, 2); │ │ │ │ + var layers = this.findLayers(); │ │ │ │ + if (layers.length > 0) { │ │ │ │ + var infoLookup = {}; │ │ │ │ + var layer, idx; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + layer = layers[i]; │ │ │ │ + idx = OpenLayers.Util.indexOf(this.map.layers, layer); │ │ │ │ + infoLookup[idx] = layer.getFeatureInfo(lonLat); │ │ │ │ + } │ │ │ │ + this.callback(infoLookup, lonLat, evt.xy); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: encode │ │ │ │ - * Serialize an array of n-dimensional points and return an encoded string │ │ │ │ + * APIMethod: callback │ │ │ │ + * Function to be called when a mouse event corresponds with a location that │ │ │ │ + * includes data in one of the configured UTFGrid layers. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * points - {Array(Array(int))} An array containing n-dimensional │ │ │ │ - * arrays of coordinates │ │ │ │ - * dims - {int} The dimension of the points that should be read │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} An encoded string │ │ │ │ + * infoLookup - {Object} Keys of this object are layer indexes and can be │ │ │ │ + * used to resolve a layer in the map.layers array. The structure of │ │ │ │ + * the property values depend on the data included in the underlying │ │ │ │ + * UTFGrid and may be any valid JSON type. │ │ │ │ */ │ │ │ │ - encode: function(points, dims, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var flatPoints = []; │ │ │ │ - │ │ │ │ - var pointsLength = points.length; │ │ │ │ - for (var i = 0; i < pointsLength; ++i) { │ │ │ │ - var point = points[i]; │ │ │ │ - │ │ │ │ - for (var dim = 0; dim < dims; ++dim) { │ │ │ │ - flatPoints.push(point[dim]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + callback: function(infoLookup) { │ │ │ │ + // to be provided in the constructor │ │ │ │ + }, │ │ │ │ │ │ │ │ - return this.encodeDeltas(flatPoints, dims, factor); │ │ │ │ + /** │ │ │ │ + * Method: reset │ │ │ │ + * Calls the callback with null. │ │ │ │ + */ │ │ │ │ + reset: function(evt) { │ │ │ │ + this.callback(null); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: encodeDeltas │ │ │ │ - * Encode a list of n-dimensional points and return an encoded string │ │ │ │ + * Method: findLayers │ │ │ │ + * Internal method to get the layers, independent of whether we are │ │ │ │ + * inspecting the map or using a client-provided array │ │ │ │ * │ │ │ │ - * Attention: This function will modify the passed array! │ │ │ │ + * The default value of this.layers is null; this causes the │ │ │ │ + * findLayers method to return ALL UTFGrid layers encountered. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * numbers - {Array.<number>} A list of n-dimensional points. │ │ │ │ - * dimension - {number} The dimension of the points in the list. │ │ │ │ - * opt_factor - {number=} The factor by which the numbers will be │ │ │ │ - * multiplied. The remaining decimal places will get rounded away. │ │ │ │ + * None │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * {Array} Layers to handle on each event │ │ │ │ */ │ │ │ │ - encodeDeltas: function(numbers, dimension, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var d; │ │ │ │ - │ │ │ │ - var lastNumbers = new Array(dimension); │ │ │ │ - for (d = 0; d < dimension; ++d) { │ │ │ │ - lastNumbers[d] = 0; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength;) { │ │ │ │ - for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ - var num = numbers[i]; │ │ │ │ - var delta = num - lastNumbers[d]; │ │ │ │ - lastNumbers[d] = num; │ │ │ │ - │ │ │ │ - numbers[i] = delta; │ │ │ │ + findLayers: function() { │ │ │ │ + var candidates = this.layers || this.map.layers; │ │ │ │ + var layers = []; │ │ │ │ + var layer; │ │ │ │ + for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ + layer = candidates[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.UTFGrid) { │ │ │ │ + layers.push(layer); │ │ │ │ } │ │ │ │ } │ │ │ │ - │ │ │ │ - return this.encodeFloats(numbers, factor); │ │ │ │ + return layers; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.UTFGrid" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/DragFeature.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: decodeDeltas │ │ │ │ - * Decode a list of n-dimensional points from an encoded string │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ - * dimension - {number} The dimension of the points in the encoded string. │ │ │ │ - * opt_factor - {number=} The factor by which the resulting numbers will │ │ │ │ - * be divided. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array.<number>} A list of n-dimensional points. │ │ │ │ - */ │ │ │ │ - decodeDeltas: function(encoded, dimension, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var d; │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - var lastNumbers = new Array(dimension); │ │ │ │ - for (d = 0; d < dimension; ++d) { │ │ │ │ - lastNumbers[d] = 0; │ │ │ │ - } │ │ │ │ │ │ │ │ - var numbers = this.decodeFloats(encoded, factor); │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ + * @requires OpenLayers/Handler/Feature.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength;) { │ │ │ │ - for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ - lastNumbers[d] += numbers[i]; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.DragFeature │ │ │ │ + * The DragFeature control moves a feature with a drag of the mouse. Create a │ │ │ │ + * new control with the <OpenLayers.Control.DragFeature> constructor. │ │ │ │ + * │ │ │ │ + * Inherits From: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.DragFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - numbers[i] = lastNumbers[d]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: geometryTypes │ │ │ │ + * {Array(String)} To restrict dragging to a limited set of geometry types, │ │ │ │ + * send a list of strings corresponding to the geometry class names. │ │ │ │ + */ │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ - return numbers; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: onStart │ │ │ │ + * {Function} Define this function if you want to know when a drag starts. │ │ │ │ + * The function should expect to receive two arguments: the feature │ │ │ │ + * that is about to be dragged and the pixel location of the mouse. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature that is about to be │ │ │ │ + * dragged. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The pixel location of the mouse. │ │ │ │ + */ │ │ │ │ + onStart: function(feature, pixel) {}, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * APIProperty: onDrag │ │ │ │ + * {Function} Define this function if you want to know about each move of a │ │ │ │ + * feature. The function should expect to receive two arguments: the │ │ │ │ + * feature that is being dragged and the pixel location of the mouse. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature that was dragged. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The pixel location of the mouse. │ │ │ │ + */ │ │ │ │ + onDrag: function(feature, pixel) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: encodeFloats │ │ │ │ - * Encode a list of floating point numbers and return an encoded string │ │ │ │ + * APIProperty: onComplete │ │ │ │ + * {Function} Define this function if you want to know when a feature is │ │ │ │ + * done dragging. The function should expect to receive two arguments: │ │ │ │ + * the feature that is being dragged and the pixel location of the │ │ │ │ + * mouse. │ │ │ │ * │ │ │ │ - * Attention: This function will modify the passed array! │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature that was dragged. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The pixel location of the mouse. │ │ │ │ + */ │ │ │ │ + onComplete: function(feature, pixel) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: onEnter │ │ │ │ + * {Function} Define this function if you want to know when the mouse │ │ │ │ + * goes over a feature and thereby makes this feature a candidate │ │ │ │ + * for dragging. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * numbers - {Array.<number>} A list of floating point numbers. │ │ │ │ - * opt_factor - {number=} The factor by which the numbers will be │ │ │ │ - * multiplied. The remaining decimal places will get rounded away. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature that is ready │ │ │ │ + * to be dragged. │ │ │ │ + */ │ │ │ │ + onEnter: function(feature) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: onLeave │ │ │ │ + * {Function} Define this function if you want to know when the mouse │ │ │ │ + * goes out of the feature that was dragged. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature that was dragged. │ │ │ │ */ │ │ │ │ - encodeFloats: function(numbers, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ + onLeave: function(feature) {}, │ │ │ │ │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - numbers[i] = Math.round(numbers[i] * factor); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} If set to true, mouse dragging will continue even if the │ │ │ │ + * mouse cursor leaves the map viewport. Default is false. │ │ │ │ + */ │ │ │ │ + documentDrag: false, │ │ │ │ │ │ │ │ - return this.encodeSignedIntegers(numbers); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Property: feature │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + feature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: decodeFloats │ │ │ │ - * Decode a list of floating point numbers from an encoded string │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ - * opt_factor - {number=} The factor by which the result will be divided. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array.<number>} A list of floating point numbers. │ │ │ │ + * Property: dragCallbacks │ │ │ │ + * {Object} The functions that are sent to the drag handler for callback. │ │ │ │ */ │ │ │ │ - decodeFloats: function(encoded, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ + dragCallbacks: {}, │ │ │ │ │ │ │ │ - var numbers = this.decodeSignedIntegers(encoded); │ │ │ │ + /** │ │ │ │ + * Property: featureCallbacks │ │ │ │ + * {Object} The functions that are sent to the feature handler for callback. │ │ │ │ + */ │ │ │ │ + featureCallbacks: {}, │ │ │ │ │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - numbers[i] /= factor; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: lastPixel │ │ │ │ + * {<OpenLayers.Pixel>} │ │ │ │ + */ │ │ │ │ + lastPixel: null, │ │ │ │ │ │ │ │ - return numbers; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.DragFeature │ │ │ │ + * Create a new control to drag features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} The layer containing features to be │ │ │ │ + * dragged. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * control. │ │ │ │ + */ │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.layer = layer; │ │ │ │ + this.handlers = { │ │ │ │ + drag: new OpenLayers.Handler.Drag( │ │ │ │ + this, OpenLayers.Util.extend({ │ │ │ │ + down: this.downFeature, │ │ │ │ + move: this.moveFeature, │ │ │ │ + up: this.upFeature, │ │ │ │ + out: this.cancel, │ │ │ │ + done: this.doneDragging │ │ │ │ + }, this.dragCallbacks), { │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + } │ │ │ │ + ), │ │ │ │ + feature: new OpenLayers.Handler.Feature( │ │ │ │ + this, this.layer, OpenLayers.Util.extend({ │ │ │ │ + // 'click' and 'clickout' callback are for the mobile │ │ │ │ + // support: no 'over' or 'out' in touch based browsers. │ │ │ │ + click: this.clickFeature, │ │ │ │ + clickout: this.clickoutFeature, │ │ │ │ + over: this.overFeature, │ │ │ │ + out: this.outFeature │ │ │ │ + }, this.featureCallbacks), { │ │ │ │ + geometryTypes: this.geometryTypes │ │ │ │ + } │ │ │ │ + ) │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: encodeSignedIntegers │ │ │ │ - * Encode a list of signed integers and return an encoded string │ │ │ │ - * │ │ │ │ - * Attention: This function will modify the passed array! │ │ │ │ + * Method: clickFeature │ │ │ │ + * Called when the feature handler detects a click-in on a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * numbers - {Array.<number>} A list of signed integers. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - encodeSignedIntegers: function(numbers) { │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - var num = numbers[i]; │ │ │ │ - │ │ │ │ - var signedNum = num << 1; │ │ │ │ - if (num < 0) { │ │ │ │ - signedNum = ~(signedNum); │ │ │ │ - } │ │ │ │ - │ │ │ │ - numbers[i] = signedNum; │ │ │ │ + clickFeature: function(feature) { │ │ │ │ + if (this.handlers.feature.touch && !this.over && this.overFeature(feature)) { │ │ │ │ + this.handlers.drag.dragstart(this.handlers.feature.evt); │ │ │ │ + // to let the events propagate to the feature handler (click callback) │ │ │ │ + this.handlers.drag.stopDown = false; │ │ │ │ } │ │ │ │ - │ │ │ │ - return this.encodeUnsignedIntegers(numbers); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: decodeSignedIntegers │ │ │ │ - * Decode a list of signed integers from an encoded string │ │ │ │ + * Method: clickoutFeature │ │ │ │ + * Called when the feature handler detects a click-out on a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array.<number>} A list of signed integers. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - decodeSignedIntegers: function(encoded) { │ │ │ │ - var numbers = this.decodeUnsignedIntegers(encoded); │ │ │ │ - │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - var num = numbers[i]; │ │ │ │ - numbers[i] = (num & 1) ? ~(num >> 1) : (num >> 1); │ │ │ │ + clickoutFeature: function(feature) { │ │ │ │ + if (this.handlers.feature.touch && this.over) { │ │ │ │ + this.outFeature(feature); │ │ │ │ + this.handlers.drag.stopDown = true; │ │ │ │ } │ │ │ │ - │ │ │ │ - return numbers; │ │ │ │ }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Take care of things that are not handled in superclass │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.layer = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, []); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: encodeUnsignedIntegers │ │ │ │ - * Encode a list of unsigned integers and return an encoded string │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * numbers - {Array.<number>} A list of unsigned integers. │ │ │ │ - * │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the control and the feature handler. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * {Boolean} Successfully activated the control and feature handler. │ │ │ │ */ │ │ │ │ - encodeUnsignedIntegers: function(numbers) { │ │ │ │ - var encoded = ''; │ │ │ │ - │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - encoded += this.encodeUnsignedInteger(numbers[i]); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return encoded; │ │ │ │ + activate: function() { │ │ │ │ + return (this.handlers.feature.activate() && │ │ │ │ + OpenLayers.Control.prototype.activate.apply(this, arguments)); │ │ │ │ }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the control and all handlers. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Successfully deactivated the control. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + // the return from the handlers is unimportant in this case │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + this.handlers.feature.deactivate(); │ │ │ │ + this.feature = null; │ │ │ │ + this.dragging = false; │ │ │ │ + this.lastPixel = null; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, this.displayClass + "Over" │ │ │ │ + ); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: decodeUnsignedIntegers │ │ │ │ - * Decode a list of unsigned integers from an encoded string │ │ │ │ + * Method: overFeature │ │ │ │ + * Called when the feature handler detects a mouse-over on a feature. │ │ │ │ + * This activates the drag handler. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The selected feature. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array.<number>} A list of unsigned integers. │ │ │ │ + * {Boolean} Successfully activated the drag handler. │ │ │ │ */ │ │ │ │ - decodeUnsignedIntegers: function(encoded) { │ │ │ │ - var numbers = []; │ │ │ │ - │ │ │ │ - var current = 0; │ │ │ │ - var shift = 0; │ │ │ │ - │ │ │ │ - var encodedLength = encoded.length; │ │ │ │ - for (var i = 0; i < encodedLength; ++i) { │ │ │ │ - var b = encoded.charCodeAt(i) - 63; │ │ │ │ - │ │ │ │ - current |= (b & 0x1f) << shift; │ │ │ │ - │ │ │ │ - if (b < 0x20) { │ │ │ │ - numbers.push(current); │ │ │ │ - current = 0; │ │ │ │ - shift = 0; │ │ │ │ + overFeature: function(feature) { │ │ │ │ + var activated = false; │ │ │ │ + if (!this.handlers.drag.dragging) { │ │ │ │ + this.feature = feature; │ │ │ │ + this.handlers.drag.activate(); │ │ │ │ + activated = true; │ │ │ │ + this.over = true; │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ + this.onEnter(feature); │ │ │ │ + } else { │ │ │ │ + if (this.feature.id == feature.id) { │ │ │ │ + this.over = true; │ │ │ │ } else { │ │ │ │ - shift += 5; │ │ │ │ + this.over = false; │ │ │ │ } │ │ │ │ } │ │ │ │ - │ │ │ │ - return numbers; │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: encodeFloat │ │ │ │ - * Encode one single floating point number and return an encoded string │ │ │ │ + * Method: downFeature │ │ │ │ + * Called when the drag handler detects a mouse-down. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * num - {number} Floating point number that should be encoded. │ │ │ │ - * opt_factor - {number=} The factor by which num will be multiplied. │ │ │ │ - * The remaining decimal places will get rounded away. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} Location of the mouse event. │ │ │ │ */ │ │ │ │ - encodeFloat: function(num, opt_factor) { │ │ │ │ - num = Math.round(num * (opt_factor || 1e5)); │ │ │ │ - return this.encodeSignedInteger(num); │ │ │ │ + downFeature: function(pixel) { │ │ │ │ + this.lastPixel = pixel; │ │ │ │ + this.onStart(this.feature, pixel); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: decodeFloat │ │ │ │ - * Decode one single floating point number from an encoded string │ │ │ │ - * │ │ │ │ + * Method: moveFeature │ │ │ │ + * Called when the drag handler detects a mouse-move. Also calls the │ │ │ │ + * optional onDrag method. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ - * opt_factor - {number=} The factor by which the result will be divided. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {number} The decoded floating point number. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} Location of the mouse event. │ │ │ │ */ │ │ │ │ - decodeFloat: function(encoded, opt_factor) { │ │ │ │ - var result = this.decodeSignedInteger(encoded); │ │ │ │ - return result / (opt_factor || 1e5); │ │ │ │ + moveFeature: function(pixel) { │ │ │ │ + var res = this.map.getResolution(); │ │ │ │ + this.feature.geometry.move(res * (pixel.x - this.lastPixel.x), │ │ │ │ + res * (this.lastPixel.y - pixel.y)); │ │ │ │ + this.layer.drawFeature(this.feature); │ │ │ │ + this.lastPixel = pixel; │ │ │ │ + this.onDrag(this.feature, pixel); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: encodeSignedInteger │ │ │ │ - * Encode one single signed integer and return an encoded string │ │ │ │ - * │ │ │ │ + * Method: upFeature │ │ │ │ + * Called when the drag handler detects a mouse-up. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * num - {number} Signed integer that should be encoded. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} Location of the mouse event. │ │ │ │ */ │ │ │ │ - encodeSignedInteger: function(num) { │ │ │ │ - var signedNum = num << 1; │ │ │ │ - if (num < 0) { │ │ │ │ - signedNum = ~(signedNum); │ │ │ │ + upFeature: function(pixel) { │ │ │ │ + if (!this.over) { │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ } │ │ │ │ - │ │ │ │ - return this.encodeUnsignedInteger(signedNum); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: decodeSignedInteger │ │ │ │ - * Decode one single signed integer from an encoded string │ │ │ │ + * Method: doneDragging │ │ │ │ + * Called when the drag handler is done dragging. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {number} The decoded signed integer. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} The last event pixel location. If this event │ │ │ │ + * came from a mouseout, this may not be in the map viewport. │ │ │ │ */ │ │ │ │ - decodeSignedInteger: function(encoded) { │ │ │ │ - var result = this.decodeUnsignedInteger(encoded); │ │ │ │ - return ((result & 1) ? ~(result >> 1) : (result >> 1)); │ │ │ │ + doneDragging: function(pixel) { │ │ │ │ + this.onComplete(this.feature, pixel); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: encodeUnsignedInteger │ │ │ │ - * Encode one single unsigned integer and return an encoded string │ │ │ │ + * Method: outFeature │ │ │ │ + * Called when the feature handler detects a mouse-out on a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * num - {number} Unsigned integer that should be encoded. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {string} The encoded string. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature that the mouse left. │ │ │ │ */ │ │ │ │ - encodeUnsignedInteger: function(num) { │ │ │ │ - var value, encoded = ''; │ │ │ │ - while (num >= 0x20) { │ │ │ │ - value = (0x20 | (num & 0x1f)) + 63; │ │ │ │ - encoded += (String.fromCharCode(value)); │ │ │ │ - num >>= 5; │ │ │ │ + outFeature: function(feature) { │ │ │ │ + if (!this.handlers.drag.dragging) { │ │ │ │ + this.over = false; │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, this.displayClass + "Over" │ │ │ │ + ); │ │ │ │ + this.onLeave(feature); │ │ │ │ + this.feature = null; │ │ │ │ + } else { │ │ │ │ + if (this.feature.id == feature.id) { │ │ │ │ + this.over = false; │ │ │ │ + } │ │ │ │ } │ │ │ │ - value = num + 63; │ │ │ │ - encoded += (String.fromCharCode(value)); │ │ │ │ - return encoded; │ │ │ │ }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Method: cancel │ │ │ │ + * Called when the drag handler detects a mouse-out (from the map viewport). │ │ │ │ + */ │ │ │ │ + cancel: function() { │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + this.over = false; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: decodeUnsignedInteger │ │ │ │ - * Decode one single unsigned integer from an encoded string │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * encoded - {string} An encoded string. │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control and all handlers. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {number} The decoded unsigned integer. │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} The control's map. │ │ │ │ */ │ │ │ │ - decodeUnsignedInteger: function(encoded) { │ │ │ │ - var result = 0; │ │ │ │ - var shift = 0; │ │ │ │ - │ │ │ │ - var encodedLength = encoded.length; │ │ │ │ - for (var i = 0; i < encodedLength; ++i) { │ │ │ │ - var b = encoded.charCodeAt(i) - 63; │ │ │ │ - │ │ │ │ - result |= (b & 0x1f) << shift; │ │ │ │ - │ │ │ │ - if (b < 0x20) │ │ │ │ - break; │ │ │ │ - │ │ │ │ - shift += 5; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return result; │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.drag.setMap(map); │ │ │ │ + this.handlers.feature.setMap(map); │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.EncodedPolyline" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DragFeature" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/Atom.js │ │ │ │ + OpenLayers/Control/PanZoom.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/GML/v3.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.Atom │ │ │ │ - * Read/write Atom feeds. Create a new instance with the │ │ │ │ - * <OpenLayers.Format.AtomFeed> constructor. │ │ │ │ + * Class: OpenLayers.Control.PanZoom │ │ │ │ + * The PanZoom is a visible control, composed of a │ │ │ │ + * <OpenLayers.Control.PanPanel> and a <OpenLayers.Control.ZoomPanel>. By │ │ │ │ + * default it is drawn in the upper left corner of the map. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.Atom = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. Properties │ │ │ │ - * of this object should not be set individually. Read-only. All │ │ │ │ - * XML subclasses should have their own namespaces object. Use │ │ │ │ - * <setNamespace> to add or set a namespace alias after construction. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - atom: "http://www.w3.org/2005/Atom", │ │ │ │ - georss: "http://www.georss.org/georss" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: feedTitle │ │ │ │ - * {String} Atom feed elements require a title. Default is "untitled". │ │ │ │ - */ │ │ │ │ - feedTitle: "untitled", │ │ │ │ +OpenLayers.Control.PanZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultEntryTitle │ │ │ │ - * {String} Atom entry elements require a title. In cases where one is │ │ │ │ - * not provided in the feature attributes, this will be used. Default │ │ │ │ - * is "untitled". │ │ │ │ + /** │ │ │ │ + * APIProperty: slideFactor │ │ │ │ + * {Integer} Number of pixels by which we'll pan the map in any direction │ │ │ │ + * on clicking the arrow buttons. If you want to pan by some ratio │ │ │ │ + * of the map dimensions, use <slideRatio> instead. │ │ │ │ */ │ │ │ │ - defaultEntryTitle: "untitled", │ │ │ │ + slideFactor: 50, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: gmlParse │ │ │ │ - * {Object} GML Format object for parsing features │ │ │ │ - * Non-API and only created if necessary │ │ │ │ + /** │ │ │ │ + * APIProperty: slideRatio │ │ │ │ + * {Number} The fraction of map width/height by which we'll pan the map │ │ │ │ + * on clicking the arrow buttons. Default is null. If set, will │ │ │ │ + * override <slideFactor>. E.g. if slideRatio is .5, then the Pan Up │ │ │ │ + * button will pan up half the map height. │ │ │ │ */ │ │ │ │ - gmlParser: null, │ │ │ │ + slideRatio: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: xy │ │ │ │ - * {Boolean} Order of the GML coordinate: true:(x,y) or false:(y,x) │ │ │ │ - * For GeoRSS the default is (y,x), therefore: false │ │ │ │ + /** │ │ │ │ + * Property: buttons │ │ │ │ + * {Array(DOMElement)} Array of Button Divs │ │ │ │ */ │ │ │ │ - xy: false, │ │ │ │ + buttons: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.AtomEntry │ │ │ │ - * Create a new parser for Atom. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + /** │ │ │ │ + * Property: position │ │ │ │ + * {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ + position: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Return a list of features from an Atom feed or entry document. │ │ │ │ - │ │ │ │ + * Constructor: OpenLayers.Control.PanZoom │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * doc - {Element} or {String} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ - } │ │ │ │ - return this.parseFeatures(doc); │ │ │ │ + initialize: function(options) { │ │ │ │ + this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X, │ │ │ │ + OpenLayers.Control.PanZoom.Y); │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Serialize or more feature nodes to Atom documents. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {<OpenLayers.Feature.Vector>} or Array({<OpenLayers.Feature.Vector>}) │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} an Atom entry document if passed one feature node, or a feed │ │ │ │ - * document if passed an array of feature nodes. │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - write: function(features) { │ │ │ │ - var doc; │ │ │ │ - if (OpenLayers.Util.isArray(features)) { │ │ │ │ - doc = this.createElementNSPlus("atom:feed"); │ │ │ │ - doc.appendChild( │ │ │ │ - this.createElementNSPlus("atom:title", { │ │ │ │ - value: this.feedTitle │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - for (var i = 0, ii = features.length; i < ii; i++) { │ │ │ │ - doc.appendChild(this.buildEntryNode(features[i])); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - doc = this.buildEntryNode(features); │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [doc]); │ │ │ │ + this.removeButtons(); │ │ │ │ + this.buttons = null; │ │ │ │ + this.position = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: buildContentNode │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * content - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} an Atom content node. │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ * │ │ │ │ - * TODO: types other than text. │ │ │ │ + * Properties: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - buildContentNode: function(content) { │ │ │ │ - var node = this.createElementNSPlus("atom:content", { │ │ │ │ - attributes: { │ │ │ │ - type: content.type || null │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (content.src) { │ │ │ │ - node.setAttribute("src", content.src); │ │ │ │ - } else { │ │ │ │ - if (content.type == "text" || content.type == null) { │ │ │ │ - node.appendChild( │ │ │ │ - this.createTextNode(content.value) │ │ │ │ - ); │ │ │ │ - } else if (content.type == "html") { │ │ │ │ - if (typeof content.value != "string") { │ │ │ │ - throw "HTML content must be in form of an escaped string"; │ │ │ │ - } │ │ │ │ - node.appendChild( │ │ │ │ - this.createTextNode(content.value) │ │ │ │ - ); │ │ │ │ - } else if (content.type == "xhtml") { │ │ │ │ - node.appendChild(content.value); │ │ │ │ - } else if (content.type == "xhtml" || │ │ │ │ - content.type.match(/(\+|\/)xml$/)) { │ │ │ │ - node.appendChild(content.value); │ │ │ │ - } else { // MUST be a valid Base64 encoding │ │ │ │ - node.appendChild( │ │ │ │ - this.createTextNode(content.value) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildEntryNode │ │ │ │ - * Build an Atom entry node from a feature object. │ │ │ │ + * Method: draw │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} an Atom entry node. │ │ │ │ - * │ │ │ │ - * These entries are geared for publication using AtomPub. │ │ │ │ - * │ │ │ │ - * TODO: support extension elements │ │ │ │ + * {DOMElement} A reference to the container div for the PanZoom control. │ │ │ │ */ │ │ │ │ - buildEntryNode: function(feature) { │ │ │ │ - var attrib = feature.attributes; │ │ │ │ - var atomAttrib = attrib.atom || {}; │ │ │ │ - var entryNode = this.createElementNSPlus("atom:entry"); │ │ │ │ - │ │ │ │ - // atom:author │ │ │ │ - if (atomAttrib.authors) { │ │ │ │ - var authors = OpenLayers.Util.isArray(atomAttrib.authors) ? │ │ │ │ - atomAttrib.authors : [atomAttrib.authors]; │ │ │ │ - for (var i = 0, ii = authors.length; i < ii; i++) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.buildPersonConstructNode( │ │ │ │ - "author", authors[i] │ │ │ │ - ) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:category │ │ │ │ - if (atomAttrib.categories) { │ │ │ │ - var categories = OpenLayers.Util.isArray(atomAttrib.categories) ? │ │ │ │ - atomAttrib.categories : [atomAttrib.categories]; │ │ │ │ - var category; │ │ │ │ - for (var i = 0, ii = categories.length; i < ii; i++) { │ │ │ │ - category = categories[i]; │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:category", { │ │ │ │ - attributes: { │ │ │ │ - term: category.term, │ │ │ │ - scheme: category.scheme || null, │ │ │ │ - label: category.label || null │ │ │ │ - } │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:content │ │ │ │ - if (atomAttrib.content) { │ │ │ │ - entryNode.appendChild(this.buildContentNode(atomAttrib.content)); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:contributor │ │ │ │ - if (atomAttrib.contributors) { │ │ │ │ - var contributors = OpenLayers.Util.isArray(atomAttrib.contributors) ? │ │ │ │ - atomAttrib.contributors : [atomAttrib.contributors]; │ │ │ │ - for (var i = 0, ii = contributors.length; i < ii; i++) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.buildPersonConstructNode( │ │ │ │ - "contributor", │ │ │ │ - contributors[i] │ │ │ │ - ) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:id │ │ │ │ - if (feature.fid) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:id", { │ │ │ │ - value: feature.fid │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:link │ │ │ │ - if (atomAttrib.links) { │ │ │ │ - var links = OpenLayers.Util.isArray(atomAttrib.links) ? │ │ │ │ - atomAttrib.links : [atomAttrib.links]; │ │ │ │ - var link; │ │ │ │ - for (var i = 0, ii = links.length; i < ii; i++) { │ │ │ │ - link = links[i]; │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:link", { │ │ │ │ - attributes: { │ │ │ │ - href: link.href, │ │ │ │ - rel: link.rel || null, │ │ │ │ - type: link.type || null, │ │ │ │ - hreflang: link.hreflang || null, │ │ │ │ - title: link.title || null, │ │ │ │ - length: link.length || null │ │ │ │ - } │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:published │ │ │ │ - if (atomAttrib.published) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:published", { │ │ │ │ - value: atomAttrib.published │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:rights │ │ │ │ - if (atomAttrib.rights) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:rights", { │ │ │ │ - value: atomAttrib.rights │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:source not implemented │ │ │ │ - │ │ │ │ - // atom:summary │ │ │ │ - if (atomAttrib.summary || attrib.description) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:summary", { │ │ │ │ - value: atomAttrib.summary || attrib.description │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atom:title │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:title", { │ │ │ │ - value: atomAttrib.title || attrib.title || this.defaultEntryTitle │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // atom:updated │ │ │ │ - if (atomAttrib.updated) { │ │ │ │ - entryNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:updated", { │ │ │ │ - value: atomAttrib.updated │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // georss:where │ │ │ │ - if (feature.geometry) { │ │ │ │ - var whereNode = this.createElementNSPlus("georss:where"); │ │ │ │ - whereNode.appendChild( │ │ │ │ - this.buildGeometryNode(feature.geometry) │ │ │ │ - ); │ │ │ │ - entryNode.appendChild(whereNode); │ │ │ │ - } │ │ │ │ + draw: function(px) { │ │ │ │ + // initialize our internal div │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + px = this.position; │ │ │ │ │ │ │ │ - return entryNode; │ │ │ │ - }, │ │ │ │ + // place the controls │ │ │ │ + this.buttons = []; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: initGmlParser │ │ │ │ - * Creates a GML parser. │ │ │ │ - */ │ │ │ │ - initGmlParser: function() { │ │ │ │ - this.gmlParser = new OpenLayers.Format.GML.v3({ │ │ │ │ - xy: this.xy, │ │ │ │ - featureNS: "http://example.com#feature", │ │ │ │ - internalProjection: this.internalProjection, │ │ │ │ - externalProjection: this.externalProjection │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + var sz = { │ │ │ │ + w: 18, │ │ │ │ + h: 18 │ │ │ │ + }; │ │ │ │ + var centered = new OpenLayers.Pixel(px.x + sz.w / 2, px.y); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: buildGeometryNode │ │ │ │ - * builds a GeoRSS node with a given geometry │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A gml node. │ │ │ │ - */ │ │ │ │ - buildGeometryNode: function(geometry) { │ │ │ │ - if (!this.gmlParser) { │ │ │ │ - this.initGmlParser(); │ │ │ │ - } │ │ │ │ - var node = this.gmlParser.writeNode("feature:_geometry", geometry); │ │ │ │ - return node.firstChild; │ │ │ │ + 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: buildPersonConstructNode │ │ │ │ - * │ │ │ │ + * Method: _addButton │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} │ │ │ │ - * value - {Object} │ │ │ │ - * │ │ │ │ + * id - {String} │ │ │ │ + * img - {String} │ │ │ │ + * xy - {<OpenLayers.Pixel>} │ │ │ │ + * sz - {<OpenLayers.Size>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} an Atom person construct node. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * >>> buildPersonConstructNode("author", {name: "John Smith"}) │ │ │ │ - * {<author><name>John Smith</name></author>} │ │ │ │ - * │ │ │ │ - * TODO: how to specify extension elements? Add to the oNames array? │ │ │ │ + * {DOMElement} A Div (an alphaImageDiv, to be precise) that contains the │ │ │ │ + * image of the button, and has all the proper event handlers set. │ │ │ │ */ │ │ │ │ - buildPersonConstructNode: function(name, value) { │ │ │ │ - var oNames = ["uri", "email"]; │ │ │ │ - var personNode = this.createElementNSPlus("atom:" + name); │ │ │ │ - personNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:name", { │ │ │ │ - value: value.name │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - for (var i = 0, ii = oNames.length; i < ii; i++) { │ │ │ │ - if (value[oNames[i]]) { │ │ │ │ - personNode.appendChild( │ │ │ │ - this.createElementNSPlus("atom:" + oNames[i], { │ │ │ │ - value: value[oNames[i]] │ │ │ │ - }) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return personNode; │ │ │ │ - }, │ │ │ │ + _addButton: function(id, img, xy, sz) { │ │ │ │ + var imgLocation = OpenLayers.Util.getImageLocation(img); │ │ │ │ + var btn = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + this.id + "_" + id, │ │ │ │ + xy, sz, imgLocation, "absolute"); │ │ │ │ + btn.style.cursor = "pointer"; │ │ │ │ + //we want to add the outer div │ │ │ │ + this.div.appendChild(btn); │ │ │ │ + btn.action = id; │ │ │ │ + btn.className = "olButton"; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getFirstChildValue │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * nsuri - {String} Child node namespace uri ("*" for any). │ │ │ │ - * name - {String} Child node name. │ │ │ │ - * def - {String} Optional string default to return if no child found. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The value of the first child with the given tag name. Returns │ │ │ │ - * default value or empty string if none found. │ │ │ │ - */ │ │ │ │ - getFirstChildValue: function(node, nsuri, name, def) { │ │ │ │ - var value; │ │ │ │ - var nodes = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ - if (nodes && nodes.length > 0) { │ │ │ │ - value = this.getChildValue(nodes[0], def); │ │ │ │ - } else { │ │ │ │ - value = def; │ │ │ │ - } │ │ │ │ - return value; │ │ │ │ + //we want to remember/reference the outer div │ │ │ │ + this.buttons.push(btn); │ │ │ │ + return btn; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeature │ │ │ │ - * Parse feature from an Atom entry node.. │ │ │ │ - * │ │ │ │ + * Method: _removeButton │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} An Atom entry or feed node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ + * btn - {Object} │ │ │ │ */ │ │ │ │ - parseFeature: function(node) { │ │ │ │ - var atomAttrib = {}; │ │ │ │ - var value = null; │ │ │ │ - var nodes = null; │ │ │ │ - var attval = null; │ │ │ │ - var atomns = this.namespaces.atom; │ │ │ │ - │ │ │ │ - // atomAuthor* │ │ │ │ - this.parsePersonConstructs(node, "author", atomAttrib); │ │ │ │ - │ │ │ │ - // atomCategory* │ │ │ │ - nodes = this.getElementsByTagNameNS(node, atomns, "category"); │ │ │ │ - if (nodes.length > 0) { │ │ │ │ - atomAttrib.categories = []; │ │ │ │ - } │ │ │ │ - for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ - value = {}; │ │ │ │ - value.term = nodes[i].getAttribute("term"); │ │ │ │ - attval = nodes[i].getAttribute("scheme"); │ │ │ │ - if (attval) { │ │ │ │ - value.scheme = attval; │ │ │ │ - } │ │ │ │ - attval = nodes[i].getAttribute("label"); │ │ │ │ - if (attval) { │ │ │ │ - value.label = attval; │ │ │ │ - } │ │ │ │ - atomAttrib.categories.push(value); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atomContent? │ │ │ │ - nodes = this.getElementsByTagNameNS(node, atomns, "content"); │ │ │ │ - if (nodes.length > 0) { │ │ │ │ - value = {}; │ │ │ │ - attval = nodes[0].getAttribute("type"); │ │ │ │ - if (attval) { │ │ │ │ - value.type = attval; │ │ │ │ - } │ │ │ │ - attval = nodes[0].getAttribute("src"); │ │ │ │ - if (attval) { │ │ │ │ - value.src = attval; │ │ │ │ - } else { │ │ │ │ - if (value.type == "text" || │ │ │ │ - value.type == "html" || │ │ │ │ - value.type == null) { │ │ │ │ - value.value = this.getFirstChildValue( │ │ │ │ - node, │ │ │ │ - atomns, │ │ │ │ - "content", │ │ │ │ - null │ │ │ │ - ); │ │ │ │ - } else if (value.type == "xhtml" || │ │ │ │ - value.type.match(/(\+|\/)xml$/)) { │ │ │ │ - value.value = this.getChildEl(nodes[0]); │ │ │ │ - } else { // MUST be base64 encoded │ │ │ │ - value.value = this.getFirstChildValue( │ │ │ │ - node, │ │ │ │ - atomns, │ │ │ │ - "content", │ │ │ │ - null │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - atomAttrib.content = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atomContributor* │ │ │ │ - this.parsePersonConstructs(node, "contributor", atomAttrib); │ │ │ │ - │ │ │ │ - // atomId │ │ │ │ - atomAttrib.id = this.getFirstChildValue(node, atomns, "id", null); │ │ │ │ - │ │ │ │ - // atomLink* │ │ │ │ - nodes = this.getElementsByTagNameNS(node, atomns, "link"); │ │ │ │ - if (nodes.length > 0) { │ │ │ │ - atomAttrib.links = new Array(nodes.length); │ │ │ │ - } │ │ │ │ - var oAtts = ["rel", "type", "hreflang", "title", "length"]; │ │ │ │ - for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ - value = {}; │ │ │ │ - value.href = nodes[i].getAttribute("href"); │ │ │ │ - for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ - attval = nodes[i].getAttribute(oAtts[j]); │ │ │ │ - if (attval) { │ │ │ │ - value[oAtts[j]] = attval; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - atomAttrib.links[i] = value; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atomPublished? │ │ │ │ - value = this.getFirstChildValue(node, atomns, "published", null); │ │ │ │ - if (value) { │ │ │ │ - atomAttrib.published = value; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atomRights? │ │ │ │ - value = this.getFirstChildValue(node, atomns, "rights", null); │ │ │ │ - if (value) { │ │ │ │ - atomAttrib.rights = value; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atomSource? -- not implemented │ │ │ │ - │ │ │ │ - // atomSummary? │ │ │ │ - value = this.getFirstChildValue(node, atomns, "summary", null); │ │ │ │ - if (value) { │ │ │ │ - atomAttrib.summary = value; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // atomTitle │ │ │ │ - atomAttrib.title = this.getFirstChildValue( │ │ │ │ - node, atomns, "title", null │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // atomUpdated │ │ │ │ - atomAttrib.updated = this.getFirstChildValue( │ │ │ │ - node, atomns, "updated", null │ │ │ │ - ); │ │ │ │ - │ │ │ │ - var featureAttrib = { │ │ │ │ - title: atomAttrib.title, │ │ │ │ - description: atomAttrib.summary, │ │ │ │ - atom: atomAttrib │ │ │ │ - }; │ │ │ │ - var geometry = this.parseLocations(node)[0]; │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, featureAttrib); │ │ │ │ - feature.fid = atomAttrib.id; │ │ │ │ - return feature; │ │ │ │ + _removeButton: function(btn) { │ │ │ │ + this.div.removeChild(btn); │ │ │ │ + OpenLayers.Util.removeItem(this.buttons, btn); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeatures │ │ │ │ - * Return features from an Atom entry or feed. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} An Atom entry or feed node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + * Method: removeButtons │ │ │ │ */ │ │ │ │ - parseFeatures: function(node) { │ │ │ │ - var features = []; │ │ │ │ - var entries = this.getElementsByTagNameNS( │ │ │ │ - node, this.namespaces.atom, "entry" │ │ │ │ - ); │ │ │ │ - if (entries.length == 0) { │ │ │ │ - entries = [node]; │ │ │ │ - } │ │ │ │ - for (var i = 0, ii = entries.length; i < ii; i++) { │ │ │ │ - features.push(this.parseFeature(entries[i])); │ │ │ │ + removeButtons: function() { │ │ │ │ + for (var i = this.buttons.length - 1; i >= 0; --i) { │ │ │ │ + this._removeButton(this.buttons[i]); │ │ │ │ } │ │ │ │ - return features; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseLocations │ │ │ │ - * Parse the locations from an Atom entry or feed. │ │ │ │ + * Method: onButtonClick │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} An Atom entry or feed node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * Array({<OpenLayers.Geometry>}) │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - parseLocations: function(node) { │ │ │ │ - var georssns = this.namespaces.georss; │ │ │ │ - │ │ │ │ - var locations = { │ │ │ │ - components: [] │ │ │ │ - }; │ │ │ │ - var where = this.getElementsByTagNameNS(node, georssns, "where"); │ │ │ │ - if (where && where.length > 0) { │ │ │ │ - if (!this.gmlParser) { │ │ │ │ - this.initGmlParser(); │ │ │ │ - } │ │ │ │ - for (var i = 0, ii = where.length; i < ii; i++) { │ │ │ │ - this.gmlParser.readChildNodes(where[i], locations); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - var components = locations.components; │ │ │ │ - var point = this.getElementsByTagNameNS(node, georssns, "point"); │ │ │ │ - if (point && point.length > 0) { │ │ │ │ - for (var i = 0, ii = point.length; i < ii; i++) { │ │ │ │ - var xy = OpenLayers.String.trim( │ │ │ │ - point[i].firstChild.nodeValue │ │ │ │ - ).split(/\s+/); │ │ │ │ - if (xy.length != 2) { │ │ │ │ - xy = OpenLayers.String.trim( │ │ │ │ - point[i].firstChild.nodeValue │ │ │ │ - ).split(/\s*,\s*/); │ │ │ │ - } │ │ │ │ - components.push(new OpenLayers.Geometry.Point(xy[1], xy[0])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - var line = this.getElementsByTagNameNS(node, georssns, "line"); │ │ │ │ - if (line && line.length > 0) { │ │ │ │ - var coords; │ │ │ │ - var p; │ │ │ │ - var points; │ │ │ │ - for (var i = 0, ii = line.length; i < ii; i++) { │ │ │ │ - coords = OpenLayers.String.trim( │ │ │ │ - line[i].firstChild.nodeValue │ │ │ │ - ).split(/\s+/); │ │ │ │ - points = []; │ │ │ │ - for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ - p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ - points.push(p); │ │ │ │ - } │ │ │ │ - components.push( │ │ │ │ - new OpenLayers.Geometry.LineString(points) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - var polygon = this.getElementsByTagNameNS(node, georssns, "polygon"); │ │ │ │ - if (polygon && polygon.length > 0) { │ │ │ │ - var coords; │ │ │ │ - var p; │ │ │ │ - var points; │ │ │ │ - for (var i = 0, ii = polygon.length; i < ii; i++) { │ │ │ │ - coords = OpenLayers.String.trim( │ │ │ │ - polygon[i].firstChild.nodeValue │ │ │ │ - ).split(/\s+/); │ │ │ │ - points = []; │ │ │ │ - for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ - p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ - points.push(p); │ │ │ │ - } │ │ │ │ - components.push( │ │ │ │ - new OpenLayers.Geometry.Polygon( │ │ │ │ - [new OpenLayers.Geometry.LinearRing(points)] │ │ │ │ - ) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - for (var i = 0, ii = components.length; i < ii; i++) { │ │ │ │ - if (components[i]) { │ │ │ │ - components[i].transform( │ │ │ │ - this.externalProjection, │ │ │ │ - this.internalProjection │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var btn = evt.buttonElement; │ │ │ │ + switch (btn.action) { │ │ │ │ + case "panup": │ │ │ │ + this.map.pan(0, -this.getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case "pandown": │ │ │ │ + this.map.pan(0, this.getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case "panleft": │ │ │ │ + this.map.pan(-this.getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + case "panright": │ │ │ │ + this.map.pan(this.getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + case "zoomin": │ │ │ │ + this.map.zoomIn(); │ │ │ │ + break; │ │ │ │ + case "zoomout": │ │ │ │ + this.map.zoomOut(); │ │ │ │ + break; │ │ │ │ + case "zoomworld": │ │ │ │ + this.map.zoomToMaxExtent(); │ │ │ │ + break; │ │ │ │ } │ │ │ │ - │ │ │ │ - return components; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parsePersonConstruct │ │ │ │ - * Parse Atom person constructs from an Atom entry node. │ │ │ │ + * Method: getSlideFactor │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} An Atom entry or feed node. │ │ │ │ - * name - {String} Construcy name ("author" or "contributor") │ │ │ │ - * data = {Object} Object in which to put parsed persons. │ │ │ │ + * dim - {String} "w" or "h" (for width or height). │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * An {Object}. │ │ │ │ + * {Number} The slide factor for panning in the requested direction. │ │ │ │ */ │ │ │ │ - parsePersonConstructs: function(node, name, data) { │ │ │ │ - var persons = []; │ │ │ │ - var atomns = this.namespaces.atom; │ │ │ │ - var nodes = this.getElementsByTagNameNS(node, atomns, name); │ │ │ │ - var oAtts = ["uri", "email"]; │ │ │ │ - for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ - var value = {}; │ │ │ │ - value.name = this.getFirstChildValue( │ │ │ │ - nodes[i], │ │ │ │ - atomns, │ │ │ │ - "name", │ │ │ │ - null │ │ │ │ - ); │ │ │ │ - for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ - var attval = this.getFirstChildValue( │ │ │ │ - nodes[i], │ │ │ │ - atomns, │ │ │ │ - oAtts[j], │ │ │ │ - null); │ │ │ │ - if (attval) { │ │ │ │ - value[oAtts[j]] = attval; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - persons.push(value); │ │ │ │ - } │ │ │ │ - if (persons.length > 0) { │ │ │ │ - data[name + "s"] = persons; │ │ │ │ - } │ │ │ │ + getSlideFactor: function(dim) { │ │ │ │ + return this.slideRatio ? │ │ │ │ + this.map.getSize()[dim] * this.slideRatio : │ │ │ │ + this.slideFactor; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Atom" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.PanZoom" │ │ │ │ }); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: X │ │ │ │ + * {Integer} │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.PanZoom.X = 4; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: Y │ │ │ │ + * {Integer} │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.PanZoom.Y = 4; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/GeoRSS.js │ │ │ │ + OpenLayers/Control/PanZoomBar.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + * @requires OpenLayers/Control/PanZoom.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.GeoRSS │ │ │ │ - * Read/write GeoRSS parser. Create a new instance with the │ │ │ │ - * <OpenLayers.Format.GeoRSS> constructor. │ │ │ │ + * Class: OpenLayers.Control.PanZoomBar │ │ │ │ + * The PanZoomBar is a visible control composed of a │ │ │ │ + * <OpenLayers.Control.PanPanel> and a <OpenLayers.Control.ZoomBar>. │ │ │ │ + * By default it is displayed in the upper left corner of the map as 4 │ │ │ │ + * directional arrows above a vertical slider. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control.PanZoom> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.GeoRSS = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ +OpenLayers.Control.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoom, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: rssns │ │ │ │ - * {String} RSS namespace to use. Defaults to │ │ │ │ - * "http://backend.userland.com/rss2" │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomStopWidth │ │ │ │ */ │ │ │ │ - rssns: "http://backend.userland.com/rss2", │ │ │ │ + zoomStopWidth: 18, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: featurens │ │ │ │ - * {String} Feature Attributes namespace. Defaults to │ │ │ │ - * "http://mapserver.gis.umn.edu/mapserver" │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomStopHeight │ │ │ │ */ │ │ │ │ - featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ + zoomStopHeight: 11, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: georssns │ │ │ │ - * {String} GeoRSS namespace to use. Defaults to │ │ │ │ - * "http://www.georss.org/georss" │ │ │ │ + /** │ │ │ │ + * Property: slider │ │ │ │ */ │ │ │ │ - georssns: "http://www.georss.org/georss", │ │ │ │ + slider: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: sliderEvents │ │ │ │ + * {<OpenLayers.Events>} │ │ │ │ + */ │ │ │ │ + sliderEvents: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: zoombarDiv │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + zoombarDiv: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomWorldIcon │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + zoomWorldIcon: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: geons │ │ │ │ - * {String} W3C Geo namespace to use. Defaults to │ │ │ │ - * "http://www.w3.org/2003/01/geo/wgs84_pos#" │ │ │ │ + * APIProperty: panIcons │ │ │ │ + * {Boolean} Set this property to false not to display the pan icons. If │ │ │ │ + * false the zoom world icon is placed under the zoom bar. Defaults to │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - geons: "http://www.w3.org/2003/01/geo/wgs84_pos#", │ │ │ │ + panIcons: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: featureTitle │ │ │ │ - * {String} Default title for features. Defaults to "Untitled" │ │ │ │ + * APIProperty: forceFixedZoomLevel │ │ │ │ + * {Boolean} Force a fixed zoom level even though the map has │ │ │ │ + * fractionalZoom │ │ │ │ */ │ │ │ │ - featureTitle: "Untitled", │ │ │ │ + forceFixedZoomLevel: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: featureDescription │ │ │ │ - * {String} Default description for features. Defaults to "No Description" │ │ │ │ + * Property: mouseDragStart │ │ │ │ + * {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - featureDescription: "No Description", │ │ │ │ + mouseDragStart: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: gmlParse │ │ │ │ - * {Object} GML Format object for parsing features │ │ │ │ - * Non-API and only created if necessary │ │ │ │ + * Property: deltaY │ │ │ │ + * {Number} The cumulative vertical pixel offset during a zoom bar drag. │ │ │ │ */ │ │ │ │ - gmlParser: null, │ │ │ │ + deltaY: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: xy │ │ │ │ - * {Boolean} Order of the GML coordinate: true:(x,y) or false:(y,x) │ │ │ │ - * For GeoRSS the default is (y,x), therefore: false │ │ │ │ + * Property: zoomStart │ │ │ │ + * {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - xy: false, │ │ │ │ + zoomStart: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.GeoRSS │ │ │ │ - * Create a new parser for GeoRSS. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * Constructor: OpenLayers.Control.PanZoomBar │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createGeometryFromItem │ │ │ │ - * Return a geometry from a GeoRSS Item. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * item - {DOMElement} A GeoRSS item node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry representing the node. │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - createGeometryFromItem: function(item) { │ │ │ │ - var point = this.getElementsByTagNameNS(item, this.georssns, "point"); │ │ │ │ - var lat = this.getElementsByTagNameNS(item, this.geons, 'lat'); │ │ │ │ - var lon = this.getElementsByTagNameNS(item, this.geons, 'long'); │ │ │ │ + destroy: function() { │ │ │ │ │ │ │ │ - var line = this.getElementsByTagNameNS(item, │ │ │ │ - this.georssns, │ │ │ │ - "line"); │ │ │ │ - var polygon = this.getElementsByTagNameNS(item, │ │ │ │ - this.georssns, │ │ │ │ - "polygon"); │ │ │ │ - var where = this.getElementsByTagNameNS(item, │ │ │ │ - this.georssns, │ │ │ │ - "where"); │ │ │ │ - var box = this.getElementsByTagNameNS(item, │ │ │ │ - this.georssns, │ │ │ │ - "box"); │ │ │ │ + this._removeZoomBar(); │ │ │ │ │ │ │ │ - if (point.length > 0 || (lat.length > 0 && lon.length > 0)) { │ │ │ │ - var location; │ │ │ │ - if (point.length > 0) { │ │ │ │ - location = OpenLayers.String.trim( │ │ │ │ - point[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ - if (location.length != 2) { │ │ │ │ - location = OpenLayers.String.trim( │ │ │ │ - point[0].firstChild.nodeValue).split(/\s*,\s*/); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - location = [parseFloat(lat[0].firstChild.nodeValue), │ │ │ │ - parseFloat(lon[0].firstChild.nodeValue) │ │ │ │ - ]; │ │ │ │ - } │ │ │ │ + this.map.events.un({ │ │ │ │ + "changebaselayer": this.redraw, │ │ │ │ + "updatesize": this.redraw, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(location[1], location[0]); │ │ │ │ + OpenLayers.Control.PanZoom.prototype.destroy.apply(this, arguments); │ │ │ │ │ │ │ │ - } else if (line.length > 0) { │ │ │ │ - var coords = OpenLayers.String.trim(this.getChildValue(line[0])).split(/\s+/); │ │ │ │ - var components = []; │ │ │ │ - var point; │ │ │ │ - for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ - components.push(point); │ │ │ │ - } │ │ │ │ - geometry = new OpenLayers.Geometry.LineString(components); │ │ │ │ - } else if (polygon.length > 0) { │ │ │ │ - var coords = OpenLayers.String.trim(this.getChildValue(polygon[0])).split(/\s+/); │ │ │ │ - var components = []; │ │ │ │ - var point; │ │ │ │ - for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ - components.push(point); │ │ │ │ - } │ │ │ │ - geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]); │ │ │ │ - } else if (where.length > 0) { │ │ │ │ - if (!this.gmlParser) { │ │ │ │ - this.gmlParser = new OpenLayers.Format.GML({ │ │ │ │ - 'xy': this.xy │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - var feature = this.gmlParser.parseFeature(where[0]); │ │ │ │ - geometry = feature.geometry; │ │ │ │ - } else if (box.length > 0) { │ │ │ │ - var coords = OpenLayers.String.trim(box[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ - var components = []; │ │ │ │ - var point; │ │ │ │ - if (coords.length > 3) { │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[1], coords[2]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[3], coords[2]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[3], coords[0]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ - components.push(point); │ │ │ │ - } │ │ │ │ - geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]); │ │ │ │ - } │ │ │ │ + delete this.mouseDragStart; │ │ │ │ + delete this.zoomStart; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (geometry && this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.PanZoom.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.on({ │ │ │ │ + "changebaselayer": this.redraw, │ │ │ │ + "updatesize": this.redraw, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - return geometry; │ │ │ │ + /** │ │ │ │ + * Method: redraw │ │ │ │ + * clear the div and start over. │ │ │ │ + */ │ │ │ │ + redraw: function() { │ │ │ │ + if (this.div != null) { │ │ │ │ + this.removeButtons(); │ │ │ │ + this._removeZoomBar(); │ │ │ │ + } │ │ │ │ + this.draw(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFeatureFromItem │ │ │ │ - * Return a feature from a GeoRSS Item. │ │ │ │ + * Method: draw │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * item - {DOMElement} A GeoRSS item node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} A feature representing the item. │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - createFeatureFromItem: function(item) { │ │ │ │ - var geometry = this.createGeometryFromItem(item); │ │ │ │ + draw: function(px) { │ │ │ │ + // initialize our internal div │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + px = this.position.clone(); │ │ │ │ │ │ │ │ - /* Provide defaults for title and description */ │ │ │ │ - var title = this._getChildValue(item, "*", "title", this.featureTitle); │ │ │ │ + // place the controls │ │ │ │ + this.buttons = []; │ │ │ │ │ │ │ │ - /* First try RSS descriptions, then Atom summaries */ │ │ │ │ - var description = this._getChildValue( │ │ │ │ - item, "*", "description", │ │ │ │ - this._getChildValue(item, "*", "content", │ │ │ │ - this._getChildValue(item, "*", "summary", this.featureDescription))); │ │ │ │ + var sz = { │ │ │ │ + w: 18, │ │ │ │ + h: 18 │ │ │ │ + }; │ │ │ │ + if (this.panIcons) { │ │ │ │ + var centered = new OpenLayers.Pixel(px.x + sz.w / 2, px.y); │ │ │ │ + var wposition = sz.w; │ │ │ │ │ │ │ │ - /* If no link URL is found in the first child node, try the │ │ │ │ - href attribute */ │ │ │ │ - var link = this._getChildValue(item, "*", "link"); │ │ │ │ - if (!link) { │ │ │ │ - try { │ │ │ │ - link = this.getElementsByTagNameNS(item, "*", "link")[0].getAttribute("href"); │ │ │ │ - } catch (e) { │ │ │ │ - link = null; │ │ │ │ + if (this.zoomWorldIcon) { │ │ │ │ + centered = new OpenLayers.Pixel(px.x + sz.w, px.y); │ │ │ │ } │ │ │ │ - } │ │ │ │ │ │ │ │ - var id = this._getChildValue(item, "*", "id", null); │ │ │ │ + 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); │ │ │ │ │ │ │ │ - var data = { │ │ │ │ - "title": title, │ │ │ │ - "description": description, │ │ │ │ - "link": link │ │ │ │ - }; │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, data); │ │ │ │ - feature.fid = id; │ │ │ │ - return feature; │ │ │ │ + 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); │ │ │ │ + } else { │ │ │ │ + this._addButton("zoomin", "zoom-plus-mini.png", px, sz); │ │ │ │ + centered = this._addZoomBar(px.add(0, sz.h)); │ │ │ │ + this._addButton("zoomout", "zoom-minus-mini.png", centered, sz); │ │ │ │ + if (this.zoomWorldIcon) { │ │ │ │ + centered = centered.add(0, sz.h + 3); │ │ │ │ + this._addButton("zoomworld", "zoom-world-mini.png", centered, sz); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: _getChildValue │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: _addZoomBar │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * nsuri - {String} Child node namespace uri ("*" for any). │ │ │ │ - * name - {String} Child node name. │ │ │ │ - * def - {String} Optional string default to return if no child found. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The value of the first child with the given tag name. Returns │ │ │ │ - * default value or empty string if none found. │ │ │ │ + * centered - {<OpenLayers.Pixel>} where zoombar drawing is to start. │ │ │ │ */ │ │ │ │ - _getChildValue: function(node, nsuri, name, def) { │ │ │ │ - var value; │ │ │ │ - var eles = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ - if (eles && eles[0] && eles[0].firstChild && │ │ │ │ - eles[0].firstChild.nodeValue) { │ │ │ │ - value = this.getChildValue(eles[0]); │ │ │ │ + _addZoomBar: function(centered) { │ │ │ │ + var imgLocation = OpenLayers.Util.getImageLocation("slider.png"); │ │ │ │ + var id = this.id + "_" + this.map.id; │ │ │ │ + var minZoom = this.map.getMinZoom(); │ │ │ │ + var zoomsToEnd = this.map.getNumZoomLevels() - 1 - this.map.getZoom(); │ │ │ │ + var slider = OpenLayers.Util.createAlphaImageDiv(id, │ │ │ │ + centered.add(-1, zoomsToEnd * this.zoomStopHeight), { │ │ │ │ + w: 20, │ │ │ │ + h: 9 │ │ │ │ + }, │ │ │ │ + imgLocation, │ │ │ │ + "absolute"); │ │ │ │ + slider.style.cursor = "move"; │ │ │ │ + this.slider = slider; │ │ │ │ + │ │ │ │ + this.sliderEvents = new OpenLayers.Events(this, slider, null, true, { │ │ │ │ + includeXY: true │ │ │ │ + }); │ │ │ │ + this.sliderEvents.on({ │ │ │ │ + "touchstart": this.zoomBarDown, │ │ │ │ + "touchmove": this.zoomBarDrag, │ │ │ │ + "touchend": this.zoomBarUp, │ │ │ │ + "mousedown": this.zoomBarDown, │ │ │ │ + "mousemove": this.zoomBarDrag, │ │ │ │ + "mouseup": this.zoomBarUp │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var sz = { │ │ │ │ + w: this.zoomStopWidth, │ │ │ │ + h: this.zoomStopHeight * (this.map.getNumZoomLevels() - minZoom) │ │ │ │ + }; │ │ │ │ + var imgLocation = OpenLayers.Util.getImageLocation("zoombar.png"); │ │ │ │ + var div = null; │ │ │ │ + │ │ │ │ + if (OpenLayers.Util.alphaHack()) { │ │ │ │ + var id = this.id + "_" + this.map.id; │ │ │ │ + div = OpenLayers.Util.createAlphaImageDiv(id, centered, { │ │ │ │ + w: sz.w, │ │ │ │ + h: this.zoomStopHeight │ │ │ │ + }, │ │ │ │ + imgLocation, │ │ │ │ + "absolute", null, "crop"); │ │ │ │ + div.style.height = sz.h + "px"; │ │ │ │ } else { │ │ │ │ - value = (def == undefined) ? "" : def; │ │ │ │ + div = OpenLayers.Util.createDiv( │ │ │ │ + 'OpenLayers_Control_PanZoomBar_Zoombar' + this.map.id, │ │ │ │ + centered, │ │ │ │ + sz, │ │ │ │ + imgLocation); │ │ │ │ } │ │ │ │ - return value; │ │ │ │ + div.style.cursor = "pointer"; │ │ │ │ + div.className = "olButton"; │ │ │ │ + this.zoombarDiv = div; │ │ │ │ + │ │ │ │ + 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() - minZoom)); │ │ │ │ + return centered; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Return a list of features from a GeoRSS doc │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * doc - {Element} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ + * Method: _removeZoomBar │ │ │ │ */ │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ - } │ │ │ │ + _removeZoomBar: function() { │ │ │ │ + this.sliderEvents.un({ │ │ │ │ + "touchstart": this.zoomBarDown, │ │ │ │ + "touchmove": this.zoomBarDrag, │ │ │ │ + "touchend": this.zoomBarUp, │ │ │ │ + "mousedown": this.zoomBarDown, │ │ │ │ + "mousemove": this.zoomBarDrag, │ │ │ │ + "mouseup": this.zoomBarUp │ │ │ │ + }); │ │ │ │ + this.sliderEvents.destroy(); │ │ │ │ │ │ │ │ - /* Try RSS items first, then Atom entries */ │ │ │ │ - var itemlist = null; │ │ │ │ - itemlist = this.getElementsByTagNameNS(doc, '*', 'item'); │ │ │ │ - if (itemlist.length == 0) { │ │ │ │ - itemlist = this.getElementsByTagNameNS(doc, '*', 'entry'); │ │ │ │ - } │ │ │ │ + this.div.removeChild(this.zoombarDiv); │ │ │ │ + this.zoombarDiv = null; │ │ │ │ + this.div.removeChild(this.slider); │ │ │ │ + this.slider = null; │ │ │ │ │ │ │ │ - var numItems = itemlist.length; │ │ │ │ - var features = new Array(numItems); │ │ │ │ - for (var i = 0; i < numItems; i++) { │ │ │ │ - features[i] = this.createFeatureFromItem(itemlist[i]); │ │ │ │ - } │ │ │ │ - return features; │ │ │ │ + this.map.events.unregister("zoomend", this, this.moveZoomBar); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Accept Feature Collection, and return a string. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} List of features to serialize into a string. │ │ │ │ + * Method: onButtonClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - write: function(features) { │ │ │ │ - var georss; │ │ │ │ - if (OpenLayers.Util.isArray(features)) { │ │ │ │ - georss = this.createElementNS(this.rssns, "rss"); │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - georss.appendChild(this.createFeatureXML(features[i])); │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + OpenLayers.Control.PanZoom.prototype.onButtonClick.apply(this, arguments); │ │ │ │ + if (evt.buttonElement === this.zoombarDiv) { │ │ │ │ + var levels = evt.buttonXY.y / this.zoomStopHeight; │ │ │ │ + if (this.forceFixedZoomLevel || !this.map.fractionalZoom) { │ │ │ │ + levels = Math.floor(levels); │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - georss = this.createFeatureXML(features); │ │ │ │ + var zoom = (this.map.getNumZoomLevels() - 1) - levels; │ │ │ │ + zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1); │ │ │ │ + this.map.zoomTo(zoom); │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [georss]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFeatureXML │ │ │ │ - * Accept an <OpenLayers.Feature.Vector>, and build a geometry for it. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * 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. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - createFeatureXML: function(feature) { │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - var featureNode = this.createElementNS(this.rssns, "item"); │ │ │ │ - var titleNode = this.createElementNS(this.rssns, "title"); │ │ │ │ - titleNode.appendChild(this.createTextNode(feature.attributes.title ? feature.attributes.title : "")); │ │ │ │ - var descNode = this.createElementNS(this.rssns, "description"); │ │ │ │ - descNode.appendChild(this.createTextNode(feature.attributes.description ? feature.attributes.description : "")); │ │ │ │ - featureNode.appendChild(titleNode); │ │ │ │ - featureNode.appendChild(descNode); │ │ │ │ - if (feature.attributes.link) { │ │ │ │ - var linkNode = this.createElementNS(this.rssns, "link"); │ │ │ │ - linkNode.appendChild(this.createTextNode(feature.attributes.link)); │ │ │ │ - featureNode.appendChild(linkNode); │ │ │ │ - } │ │ │ │ - for (var attr in feature.attributes) { │ │ │ │ - if (attr == "link" || attr == "title" || attr == "description") { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ - var nodename = attr; │ │ │ │ - if (attr.search(":") != -1) { │ │ │ │ - nodename = attr.split(":")[1]; │ │ │ │ - } │ │ │ │ - var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ - attrContainer.appendChild(attrText); │ │ │ │ - featureNode.appendChild(attrContainer); │ │ │ │ - } │ │ │ │ - featureNode.appendChild(geometryNode); │ │ │ │ - return featureNode; │ │ │ │ + passEventToSlider: function(evt) { │ │ │ │ + this.sliderEvents.handleBrowserEvent(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: buildGeometryNode │ │ │ │ - * builds a GeoRSS node with a given geometry │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ + /* │ │ │ │ + * Method: zoomBarDown │ │ │ │ + * event listener for clicks on the slider │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A gml node. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - buildGeometryNode: function(geometry) { │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - geometry.transform(this.internalProjection, │ │ │ │ - this.externalProjection); │ │ │ │ - } │ │ │ │ - var node; │ │ │ │ - // match Polygon │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") { │ │ │ │ - node = this.createElementNS(this.georssns, 'georss:polygon'); │ │ │ │ - │ │ │ │ - node.appendChild(this.buildCoordinatesNode(geometry.components[0])); │ │ │ │ + zoomBarDown: function(evt) { │ │ │ │ + if (!OpenLayers.Event.isLeftClick(evt) && !OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ - // match LineString │ │ │ │ - else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") { │ │ │ │ - node = this.createElementNS(this.georssns, 'georss:line'); │ │ │ │ + this.map.events.on({ │ │ │ │ + "touchmove": this.passEventToSlider, │ │ │ │ + "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); │ │ │ │ + }, │ │ │ │ │ │ │ │ - node.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - } │ │ │ │ - // match Point │ │ │ │ - else if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - node = this.createElementNS(this.georssns, 'georss:point'); │ │ │ │ - node.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - } else { │ │ │ │ - throw "Couldn't parse " + geometry.CLASS_NAME; │ │ │ │ + /* │ │ │ │ + * 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 - {<OpenLayers.Event>} │ │ │ │ + */ │ │ │ │ + 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(); │ │ │ │ + } │ │ │ │ + // set cumulative displacement │ │ │ │ + this.deltaY = this.zoomStart.y - evt.xy.y; │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: buildCoordinatesNode │ │ │ │ - * │ │ │ │ + /* │ │ │ │ + * Method: zoomBarUp │ │ │ │ + * Perform cleanup when a mouseup event is received -- discover new zoom │ │ │ │ + * level and switch to it. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - buildCoordinatesNode: function(geometry) { │ │ │ │ - var points = null; │ │ │ │ - │ │ │ │ - if (geometry.components) { │ │ │ │ - points = geometry.components; │ │ │ │ + zoomBarUp: function(evt) { │ │ │ │ + if (!OpenLayers.Event.isLeftClick(evt) && evt.type !== "touchend") { │ │ │ │ + return; │ │ │ │ } │ │ │ │ - │ │ │ │ - var path; │ │ │ │ - if (points) { │ │ │ │ - var numPoints = points.length; │ │ │ │ - var parts = new Array(numPoints); │ │ │ │ - for (var i = 0; i < numPoints; i++) { │ │ │ │ - parts[i] = points[i].y + " " + points[i].x; │ │ │ │ + if (this.mouseDragStart) { │ │ │ │ + this.div.style.cursor = ""; │ │ │ │ + this.map.events.un({ │ │ │ │ + "touchmove": this.passEventToSlider, │ │ │ │ + "mouseup": this.passEventToSlider, │ │ │ │ + "mousemove": this.passEventToSlider, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + var zoomLevel = this.map.zoom; │ │ │ │ + if (!this.forceFixedZoomLevel && this.map.fractionalZoom) { │ │ │ │ + zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ + zoomLevel = Math.min(Math.max(zoomLevel, 0), │ │ │ │ + this.map.getNumZoomLevels() - 1); │ │ │ │ + } else { │ │ │ │ + zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ + zoomLevel = Math.max(Math.round(zoomLevel), 0); │ │ │ │ } │ │ │ │ - path = parts.join(" "); │ │ │ │ - } else { │ │ │ │ - path = geometry.y + " " + geometry.x; │ │ │ │ + this.map.zoomTo(zoomLevel); │ │ │ │ + this.mouseDragStart = null; │ │ │ │ + this.zoomStart = null; │ │ │ │ + this.deltaY = 0; │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ } │ │ │ │ - return this.createTextNode(path); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.GeoRSS" │ │ │ │ + /* │ │ │ │ + * 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/CSWGetDomain.js │ │ │ │ + OpenLayers/Control/ZoomIn.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format.js │ │ │ │ + * @requires OpenLayers/Control/Button.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.CSWGetDomain │ │ │ │ - * Default version is 2.0.2. │ │ │ │ + * Class: OpenLayers.Control.ZoomIn │ │ │ │ + * The ZoomIn control is a button to increase the zoom level of a map. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Format>} A CSWGetDomain format of the given version. │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.CSWGetDomain = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults( │ │ │ │ - options, OpenLayers.Format.CSWGetDomain.DEFAULTS │ │ │ │ - ); │ │ │ │ - var cls = OpenLayers.Format.CSWGetDomain["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported CSWGetDomain version: " + options.version; │ │ │ │ - } │ │ │ │ - return new cls(options); │ │ │ │ -}; │ │ │ │ +OpenLayers.Control.ZoomIn = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: DEFAULTS │ │ │ │ - * {Object} Default properties for the CSWGetDomain format. │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.CSWGetDomain.DEFAULTS = { │ │ │ │ - "version": "2.0.2" │ │ │ │ -}; │ │ │ │ + /** │ │ │ │ + * Method: trigger │ │ │ │ + */ │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.zoomIn(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomIn" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/OSM.js │ │ │ │ + OpenLayers/Control/ModifyFeature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ - * @requires OpenLayers/Projection.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ + * @requires OpenLayers/Handler/Keyboard.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.OSM │ │ │ │ - * OSM parser. Create a new instance with the │ │ │ │ - * <OpenLayers.Format.OSM> constructor. │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.ModifyFeature │ │ │ │ + * Control to modify features. When activated, a click renders the vertices │ │ │ │ + * of a feature - these vertices can then be dragged. By default, the │ │ │ │ + * delete key will delete the vertex under the mouse. New features are │ │ │ │ + * added by dragging "virtual vertices" between vertices. Create a new │ │ │ │ + * control with the <OpenLayers.Control.ModifyFeature> constructor. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * Inherits From: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.OSM = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ +OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: checkTags │ │ │ │ - * {Boolean} Should tags be checked to determine whether something │ │ │ │ - * should be treated as a seperate node. Will slow down parsing. │ │ │ │ - * Default is false. │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} If set to true, dragging vertices will continue even if the │ │ │ │ + * mouse cursor leaves the map viewport. Default is false. │ │ │ │ */ │ │ │ │ - checkTags: false, │ │ │ │ + documentDrag: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: interestingTagsExclude │ │ │ │ - * {Array} List of tags to exclude from 'interesting' checks on nodes. │ │ │ │ - * Must be set when creating the format. Will only be used if checkTags │ │ │ │ - * is set. │ │ │ │ + * APIProperty: geometryTypes │ │ │ │ + * {Array(String)} To restrict modification to a limited set of geometry │ │ │ │ + * types, send a list of strings corresponding to the geometry class │ │ │ │ + * names. │ │ │ │ */ │ │ │ │ - interestingTagsExclude: null, │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: areaTags │ │ │ │ - * {Array} List of tags indicating that something is an area. │ │ │ │ - * Must be set when creating the format. Will only be used if │ │ │ │ - * checkTags is true. │ │ │ │ + * APIProperty: clickout │ │ │ │ + * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ + * Default is true. │ │ │ │ */ │ │ │ │ - areaTags: null, │ │ │ │ + clickout: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.OSM │ │ │ │ - * Create a new parser for OSM. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIProperty: toggle │ │ │ │ + * {Boolean} Unselect a selected feature on click. │ │ │ │ + * Default is true. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - var layer_defaults = { │ │ │ │ - 'interestingTagsExclude': ['source', 'source_ref', │ │ │ │ - 'source:ref', 'history', 'attribution', 'created_by' │ │ │ │ - ], │ │ │ │ - 'areaTags': ['area', 'building', 'leisure', 'tourism', 'ruins', │ │ │ │ - 'historic', 'landuse', 'military', 'natural', 'sport' │ │ │ │ - ] │ │ │ │ - }; │ │ │ │ + toggle: true, │ │ │ │ │ │ │ │ - layer_defaults = OpenLayers.Util.extend(layer_defaults, options); │ │ │ │ + /** │ │ │ │ + * APIProperty: standalone │ │ │ │ + * {Boolean} Set to true to create a control without SelectFeature │ │ │ │ + * capabilities. Default is false. If standalone is true, to modify │ │ │ │ + * a feature, call the <selectFeature> method with the target feature. │ │ │ │ + * Note that you must call the <unselectFeature> method to finish │ │ │ │ + * feature modification in standalone mode (before starting to modify │ │ │ │ + * another feature). │ │ │ │ + */ │ │ │ │ + standalone: false, │ │ │ │ │ │ │ │ - var interesting = {}; │ │ │ │ - for (var i = 0; i < layer_defaults.interestingTagsExclude.length; i++) { │ │ │ │ - interesting[layer_defaults.interestingTagsExclude[i]] = true; │ │ │ │ - } │ │ │ │ - layer_defaults.interestingTagsExclude = interesting; │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - var area = {}; │ │ │ │ - for (var i = 0; i < layer_defaults.areaTags.length; i++) { │ │ │ │ - area[layer_defaults.areaTags[i]] = true; │ │ │ │ - } │ │ │ │ - layer_defaults.areaTags = area; │ │ │ │ + /** │ │ │ │ + * Property: feature │ │ │ │ + * {<OpenLayers.Feature.Vector>} Feature currently available for modification. │ │ │ │ + */ │ │ │ │ + feature: null, │ │ │ │ │ │ │ │ - // OSM coordinates are always in longlat WGS84 │ │ │ │ - this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + /** │ │ │ │ + * Property: vertex │ │ │ │ + * {<OpenLayers.Feature.Vector>} Vertex currently being modified. │ │ │ │ + */ │ │ │ │ + vertex: null, │ │ │ │ │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [layer_defaults]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: vertices │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} Verticies currently available │ │ │ │ + * for dragging. │ │ │ │ + */ │ │ │ │ + vertices: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Return a list of features from a OSM doc │ │ │ │ - │ │ │ │ - * Parameters: │ │ │ │ - * doc - {Element} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + * Property: virtualVertices │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} Virtual vertices in the middle │ │ │ │ + * of each edge. │ │ │ │ */ │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ - } │ │ │ │ + virtualVertices: null, │ │ │ │ │ │ │ │ - var nodes = this.getNodes(doc); │ │ │ │ - var ways = this.getWays(doc); │ │ │ │ + /** │ │ │ │ + * Property: handlers │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ + handlers: null, │ │ │ │ │ │ │ │ - // Geoms will contain at least ways.length entries. │ │ │ │ - var feat_list = new Array(ways.length); │ │ │ │ + /** │ │ │ │ + * APIProperty: deleteCodes │ │ │ │ + * {Array(Integer)} Keycodes for deleting verticies. Set to null to disable │ │ │ │ + * vertex deltion by keypress. If non-null, keypresses with codes │ │ │ │ + * in this array will delete vertices under the mouse. Default │ │ │ │ + * is 46 and 68, the 'delete' and lowercase 'd' keys. │ │ │ │ + */ │ │ │ │ + deleteCodes: null, │ │ │ │ │ │ │ │ - for (var i = 0; i < ways.length; i++) { │ │ │ │ - // We know the minimal of this one ahead of time. (Could be -1 │ │ │ │ - // due to areas/polygons) │ │ │ │ - var point_list = new Array(ways[i].nodes.length); │ │ │ │ + /** │ │ │ │ + * APIProperty: virtualStyle │ │ │ │ + * {Object} A symbolizer to be used for virtual vertices. │ │ │ │ + */ │ │ │ │ + virtualStyle: null, │ │ │ │ │ │ │ │ - var poly = this.isWayArea(ways[i]) ? 1 : 0; │ │ │ │ - for (var j = 0; j < ways[i].nodes.length; j++) { │ │ │ │ - var node = nodes[ways[i].nodes[j]]; │ │ │ │ + /** │ │ │ │ + * APIProperty: vertexRenderIntent │ │ │ │ + * {String} The renderIntent to use for vertices. If no <virtualStyle> is │ │ │ │ + * provided, this renderIntent will also be used for virtual vertices, with │ │ │ │ + * a fillOpacity and strokeOpacity of 0.3. Default is null, which means │ │ │ │ + * that the layer's default style will be used for vertices. │ │ │ │ + */ │ │ │ │ + vertexRenderIntent: null, │ │ │ │ │ │ │ │ - var point = new OpenLayers.Geometry.Point(node.lon, node.lat); │ │ │ │ + /** │ │ │ │ + * APIProperty: mode │ │ │ │ + * {Integer} Bitfields specifying the modification mode. Defaults to │ │ │ │ + * OpenLayers.Control.ModifyFeature.RESHAPE. To set the mode to a │ │ │ │ + * combination of options, use the | operator. For example, to allow │ │ │ │ + * the control to both resize and rotate features, use the following │ │ │ │ + * syntax │ │ │ │ + * (code) │ │ │ │ + * control.mode = OpenLayers.Control.ModifyFeature.RESIZE | │ │ │ │ + * OpenLayers.Control.ModifyFeature.ROTATE; │ │ │ │ + * (end) │ │ │ │ + */ │ │ │ │ + mode: null, │ │ │ │ │ │ │ │ - // Since OSM is topological, we stash the node ID internally. │ │ │ │ - point.osm_id = parseInt(ways[i].nodes[j]); │ │ │ │ - point_list[j] = point; │ │ │ │ + /** │ │ │ │ + * APIProperty: createVertices │ │ │ │ + * {Boolean} Create new vertices by dragging the virtual vertices │ │ │ │ + * in the middle of each edge. Default is true. │ │ │ │ + */ │ │ │ │ + createVertices: true, │ │ │ │ │ │ │ │ - // We don't display nodes if they're used inside other │ │ │ │ - // elements. │ │ │ │ - node.used = true; │ │ │ │ - } │ │ │ │ - var geometry = null; │ │ │ │ - if (poly) { │ │ │ │ - geometry = new OpenLayers.Geometry.Polygon( │ │ │ │ - new OpenLayers.Geometry.LinearRing(point_list)); │ │ │ │ - } else { │ │ │ │ - geometry = new OpenLayers.Geometry.LineString(point_list); │ │ │ │ - } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ - var feat = new OpenLayers.Feature.Vector(geometry, │ │ │ │ - ways[i].tags); │ │ │ │ - feat.osm_id = parseInt(ways[i].id); │ │ │ │ - feat.fid = "way." + feat.osm_id; │ │ │ │ - feat_list[i] = feat; │ │ │ │ - } │ │ │ │ - for (var node_id in nodes) { │ │ │ │ - var node = nodes[node_id]; │ │ │ │ - if (!node.used || this.checkTags) { │ │ │ │ - var tags = null; │ │ │ │ + /** │ │ │ │ + * Property: modified │ │ │ │ + * {Boolean} The currently selected feature has been modified. │ │ │ │ + */ │ │ │ │ + modified: false, │ │ │ │ │ │ │ │ - if (this.checkTags) { │ │ │ │ - var result = this.getTags(node.node, true); │ │ │ │ - if (node.used && !result[1]) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - tags = result[0]; │ │ │ │ - } else { │ │ │ │ - tags = this.getTags(node.node); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: radiusHandle │ │ │ │ + * {<OpenLayers.Feature.Vector>} A handle for rotating/resizing a feature. │ │ │ │ + */ │ │ │ │ + radiusHandle: null, │ │ │ │ │ │ │ │ - var feat = new OpenLayers.Feature.Vector( │ │ │ │ - new OpenLayers.Geometry.Point(node['lon'], node['lat']), │ │ │ │ - tags); │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - feat.geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ - feat.osm_id = parseInt(node_id); │ │ │ │ - feat.fid = "node." + feat.osm_id; │ │ │ │ - feat_list.push(feat); │ │ │ │ - } │ │ │ │ - // Memory cleanup │ │ │ │ - node.node = null; │ │ │ │ - } │ │ │ │ - return feat_list; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: dragHandle │ │ │ │ + * {<OpenLayers.Feature.Vector>} A handle for dragging a feature. │ │ │ │ + */ │ │ │ │ + dragHandle: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getNodes │ │ │ │ - * Return the node items from a doc. │ │ │ │ + * APIProperty: onModificationStart │ │ │ │ + * {Function} *Deprecated*. Register for "beforefeaturemodified" instead. │ │ │ │ + * The "beforefeaturemodified" event is triggered on the layer before │ │ │ │ + * any modification begins. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * doc - {DOMElement} node to parse tags from │ │ │ │ + * Optional function to be called when a feature is selected │ │ │ │ + * to be modified. The function should expect to be called with a │ │ │ │ + * feature. This could be used for example to allow to lock the │ │ │ │ + * feature on server-side. │ │ │ │ */ │ │ │ │ - getNodes: function(doc) { │ │ │ │ - var node_list = doc.getElementsByTagName("node"); │ │ │ │ - var nodes = {}; │ │ │ │ - for (var i = 0; i < node_list.length; i++) { │ │ │ │ - var node = node_list[i]; │ │ │ │ - var id = node.getAttribute("id"); │ │ │ │ - nodes[id] = { │ │ │ │ - 'lat': node.getAttribute("lat"), │ │ │ │ - 'lon': node.getAttribute("lon"), │ │ │ │ - 'node': node │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - return nodes; │ │ │ │ - }, │ │ │ │ + onModificationStart: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getWays │ │ │ │ - * Return the way items from a doc. │ │ │ │ + * APIProperty: onModification │ │ │ │ + * {Function} *Deprecated*. Register for "featuremodified" instead. │ │ │ │ + * The "featuremodified" event is triggered on the layer with each │ │ │ │ + * feature modification. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * doc - {DOMElement} node to parse tags from │ │ │ │ + * Optional function to be called when a feature has been │ │ │ │ + * modified. The function should expect to be called with a feature. │ │ │ │ */ │ │ │ │ - getWays: function(doc) { │ │ │ │ - var way_list = doc.getElementsByTagName("way"); │ │ │ │ - var return_ways = []; │ │ │ │ - for (var i = 0; i < way_list.length; i++) { │ │ │ │ - var way = way_list[i]; │ │ │ │ - var way_object = { │ │ │ │ - id: way.getAttribute("id") │ │ │ │ - }; │ │ │ │ - │ │ │ │ - way_object.tags = this.getTags(way); │ │ │ │ + onModification: function() {}, │ │ │ │ │ │ │ │ - var node_list = way.getElementsByTagName("nd"); │ │ │ │ + /** │ │ │ │ + * APIProperty: onModificationEnd │ │ │ │ + * {Function} *Deprecated*. Register for "afterfeaturemodified" instead. │ │ │ │ + * The "afterfeaturemodified" event is triggered on the layer after │ │ │ │ + * a feature has been modified. │ │ │ │ + * │ │ │ │ + * Optional function to be called when a feature is finished │ │ │ │ + * being modified. The function should expect to be called with a │ │ │ │ + * feature. │ │ │ │ + */ │ │ │ │ + onModificationEnd: function() {}, │ │ │ │ │ │ │ │ - way_object.nodes = new Array(node_list.length); │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.ModifyFeature │ │ │ │ + * Create a new modify feature control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} Layer that contains features that │ │ │ │ + * will be modified. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * control. │ │ │ │ + */ │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + options = options || {}; │ │ │ │ + this.layer = layer; │ │ │ │ + this.vertices = []; │ │ │ │ + this.virtualVertices = []; │ │ │ │ + this.virtualStyle = OpenLayers.Util.extend({}, │ │ │ │ + this.layer.style || │ │ │ │ + this.layer.styleMap.createSymbolizer(null, options.vertexRenderIntent) │ │ │ │ + ); │ │ │ │ + this.virtualStyle.fillOpacity = 0.3; │ │ │ │ + this.virtualStyle.strokeOpacity = 0.3; │ │ │ │ + this.deleteCodes = [46, 68]; │ │ │ │ + this.mode = OpenLayers.Control.ModifyFeature.RESHAPE; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!(OpenLayers.Util.isArray(this.deleteCodes))) { │ │ │ │ + this.deleteCodes = [this.deleteCodes]; │ │ │ │ + } │ │ │ │ │ │ │ │ - for (var j = 0; j < node_list.length; j++) { │ │ │ │ - way_object.nodes[j] = node_list[j].getAttribute("ref"); │ │ │ │ + // configure the drag handler │ │ │ │ + var dragCallbacks = { │ │ │ │ + down: function(pixel) { │ │ │ │ + this.vertex = null; │ │ │ │ + var feature = this.layer.getFeatureFromEvent( │ │ │ │ + this.handlers.drag.evt); │ │ │ │ + if (feature) { │ │ │ │ + this.dragStart(feature); │ │ │ │ + } else if (this.clickout) { │ │ │ │ + this._unselect = this.feature; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + move: function(pixel) { │ │ │ │ + delete this._unselect; │ │ │ │ + if (this.vertex) { │ │ │ │ + this.dragVertex(this.vertex, pixel); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + up: function() { │ │ │ │ + this.handlers.drag.stopDown = false; │ │ │ │ + if (this._unselect) { │ │ │ │ + this.unselectFeature(this._unselect); │ │ │ │ + delete this._unselect; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + done: function(pixel) { │ │ │ │ + if (this.vertex) { │ │ │ │ + this.dragComplete(this.vertex); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return_ways.push(way_object); │ │ │ │ - } │ │ │ │ - return return_ways; │ │ │ │ + }; │ │ │ │ + var dragOptions = { │ │ │ │ + documentDrag: this.documentDrag, │ │ │ │ + stopDown: false │ │ │ │ + }; │ │ │ │ │ │ │ │ + // configure the keyboard handler │ │ │ │ + var keyboardOptions = { │ │ │ │ + keydown: this.handleKeypress │ │ │ │ + }; │ │ │ │ + this.handlers = { │ │ │ │ + keyboard: new OpenLayers.Handler.Keyboard(this, keyboardOptions), │ │ │ │ + drag: new OpenLayers.Handler.Drag(this, dragCallbacks, dragOptions) │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getTags │ │ │ │ - * Return the tags list attached to a specific DOM element. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * dom_node - {DOMElement} node to parse tags from │ │ │ │ - * interesting_tags - {Boolean} whether the return from this function should │ │ │ │ - * return a boolean indicating that it has 'interesting tags' -- │ │ │ │ - * tags like attribution and source are ignored. (To change the list │ │ │ │ - * of tags, see interestingTagsExclude) │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Take care of things that are not handled in superclass. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.un({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.layer = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, []); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the control. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * tags - {Object} hash of tags │ │ │ │ - * interesting - {Boolean} if interesting_tags is passed, returns │ │ │ │ - * whether there are any interesting tags on this element. │ │ │ │ + * {Boolean} Successfully activated the control. │ │ │ │ */ │ │ │ │ - getTags: function(dom_node, interesting_tags) { │ │ │ │ - var tag_list = dom_node.getElementsByTagName("tag"); │ │ │ │ - var tags = {}; │ │ │ │ - var interesting = false; │ │ │ │ - for (var j = 0; j < tag_list.length; j++) { │ │ │ │ - var key = tag_list[j].getAttribute("k"); │ │ │ │ - tags[key] = tag_list[j].getAttribute("v"); │ │ │ │ - if (interesting_tags) { │ │ │ │ - if (!this.interestingTagsExclude[key]) { │ │ │ │ - interesting = true; │ │ │ │ - } │ │ │ │ + activate: function() { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + this.map.events.on({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + return (this.handlers.keyboard.activate() && │ │ │ │ + this.handlers.drag.activate() && │ │ │ │ + OpenLayers.Control.prototype.activate.apply(this, arguments)); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Successfully deactivated the control. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + // the return from the controls is unimportant in this case │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.moveLayerBack(); │ │ │ │ + this.map.events.un({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + this.handlers.keyboard.deactivate(); │ │ │ │ + var feature = this.feature; │ │ │ │ + if (feature && feature.geometry && feature.layer) { │ │ │ │ + this.unselectFeature(feature); │ │ │ │ } │ │ │ │ + deactivated = true; │ │ │ │ } │ │ │ │ - return interesting_tags ? [tags, interesting] : tags; │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: isWayArea │ │ │ │ - * Given a way object from getWays, check whether the tags and geometry │ │ │ │ - * indicate something is an area. │ │ │ │ + /** │ │ │ │ + * Method: beforeSelectFeature │ │ │ │ + * Called before a feature is selected. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The feature about to be selected. │ │ │ │ */ │ │ │ │ - isWayArea: function(way) { │ │ │ │ - var poly_shaped = false; │ │ │ │ - var poly_tags = false; │ │ │ │ + beforeSelectFeature: function(feature) { │ │ │ │ + return this.layer.events.triggerEvent( │ │ │ │ + "beforefeaturemodified", { │ │ │ │ + feature: feature │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (way.nodes[0] == way.nodes[way.nodes.length - 1]) { │ │ │ │ - poly_shaped = true; │ │ │ │ + /** │ │ │ │ + * APIMethod: selectFeature │ │ │ │ + * Select a feature for modification in standalone mode. In non-standalone │ │ │ │ + * mode, this method is called when a feature is selected by clicking. │ │ │ │ + * Register a listener to the beforefeaturemodified event and return false │ │ │ │ + * to prevent feature modification. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} the selected feature. │ │ │ │ + */ │ │ │ │ + selectFeature: function(feature) { │ │ │ │ + if (this.feature === feature || │ │ │ │ + (this.geometryTypes && OpenLayers.Util.indexOf(this.geometryTypes, │ │ │ │ + feature.geometry.CLASS_NAME) == -1)) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ - if (this.checkTags) { │ │ │ │ - for (var key in way.tags) { │ │ │ │ - if (this.areaTags[key]) { │ │ │ │ - poly_tags = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + if (this.beforeSelectFeature(feature) !== false) { │ │ │ │ + if (this.feature) { │ │ │ │ + this.unselectFeature(this.feature); │ │ │ │ } │ │ │ │ + this.feature = feature; │ │ │ │ + this.layer.selectedFeatures.push(feature); │ │ │ │ + this.layer.drawFeature(feature, 'select'); │ │ │ │ + this.modified = false; │ │ │ │ + this.resetVertices(); │ │ │ │ + this.onModificationStart(this.feature); │ │ │ │ + } │ │ │ │ + // keep track of geometry modifications │ │ │ │ + var modified = feature.modified; │ │ │ │ + if (feature.geometry && !(modified && modified.geometry)) { │ │ │ │ + this._originalGeometry = feature.geometry.clone(); │ │ │ │ } │ │ │ │ - return poly_shaped && (this.checkTags ? poly_tags : true); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Takes a list of features, returns a serialized OSM format file for use │ │ │ │ - * in tools like JOSM. │ │ │ │ + * APIMethod: unselectFeature │ │ │ │ + * Called when the select feature control unselects a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The unselected feature. │ │ │ │ */ │ │ │ │ - write: function(features) { │ │ │ │ - if (!(OpenLayers.Util.isArray(features))) { │ │ │ │ - features = [features]; │ │ │ │ + unselectFeature: function(feature) { │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.virtualVertices = []; │ │ │ │ + if (this.dragHandle) { │ │ │ │ + this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + delete this.dragHandle; │ │ │ │ + } │ │ │ │ + if (this.radiusHandle) { │ │ │ │ + this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + delete this.radiusHandle; │ │ │ │ } │ │ │ │ + this.layer.drawFeature(this.feature, 'default'); │ │ │ │ + this.feature = null; │ │ │ │ + OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); │ │ │ │ + this.onModificationEnd(feature); │ │ │ │ + this.layer.events.triggerEvent("afterfeaturemodified", { │ │ │ │ + feature: feature, │ │ │ │ + modified: this.modified │ │ │ │ + }); │ │ │ │ + this.modified = false; │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.osm_id = 1; │ │ │ │ - this.created_nodes = {}; │ │ │ │ - var root_node = this.createElementNS(null, "osm"); │ │ │ │ - root_node.setAttribute("version", "0.5"); │ │ │ │ - root_node.setAttribute("generator", "OpenLayers " + OpenLayers.VERSION_NUMBER); │ │ │ │ │ │ │ │ - // Loop backwards, because the deserializer puts nodes last, and │ │ │ │ - // we want them first if possible │ │ │ │ - for (var i = features.length - 1; i >= 0; i--) { │ │ │ │ - var nodes = this.createFeatureNodes(features[i]); │ │ │ │ - for (var j = 0; j < nodes.length; j++) { │ │ │ │ - root_node.appendChild(nodes[j]); │ │ │ │ + /** │ │ │ │ + * Method: dragStart │ │ │ │ + * Called by the drag handler before a feature is dragged. This method is │ │ │ │ + * used to differentiate between points and vertices │ │ │ │ + * of higher order geometries. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The point or vertex about to be │ │ │ │ + * dragged. │ │ │ │ + */ │ │ │ │ + dragStart: function(feature) { │ │ │ │ + var isPoint = feature.geometry.CLASS_NAME == │ │ │ │ + 'OpenLayers.Geometry.Point'; │ │ │ │ + if (!this.standalone && │ │ │ │ + ((!feature._sketch && isPoint) || !feature._sketch)) { │ │ │ │ + if (this.toggle && this.feature === feature) { │ │ │ │ + // mark feature for unselection │ │ │ │ + this._unselect = feature; │ │ │ │ } │ │ │ │ + this.selectFeature(feature); │ │ │ │ + } │ │ │ │ + if (feature._sketch || isPoint) { │ │ │ │ + // feature is a drag or virtual handle or point │ │ │ │ + this.vertex = feature; │ │ │ │ + this.handlers.drag.stopDown = true; │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [root_node]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFeatureNodes │ │ │ │ - * Takes a feature, returns a list of nodes from size 0->n. │ │ │ │ - * Will include all pieces of the serialization that are required which │ │ │ │ - * have not already been created. Calls out to createXML based on geometry │ │ │ │ - * type. │ │ │ │ + * Method: dragVertex │ │ │ │ + * Called by the drag handler with each drag move of a vertex. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged. │ │ │ │ + * pixel - {<OpenLayers.Pixel>} Pixel location of the mouse event. │ │ │ │ */ │ │ │ │ - createFeatureNodes: function(feature) { │ │ │ │ - var nodes = []; │ │ │ │ - var className = feature.geometry.CLASS_NAME; │ │ │ │ - var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ - type = type.toLowerCase(); │ │ │ │ - var builder = this.createXML[type]; │ │ │ │ - if (builder) { │ │ │ │ - nodes = builder.apply(this, [feature]); │ │ │ │ + dragVertex: function(vertex, pixel) { │ │ │ │ + var pos = this.map.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geom = vertex.geometry; │ │ │ │ + geom.move(pos.lon - geom.x, pos.lat - geom.y); │ │ │ │ + this.modified = true; │ │ │ │ + /** │ │ │ │ + * Five cases: │ │ │ │ + * 1) dragging a simple point │ │ │ │ + * 2) dragging a virtual vertex │ │ │ │ + * 3) dragging a drag handle │ │ │ │ + * 4) dragging a real vertex │ │ │ │ + * 5) dragging a radius handle │ │ │ │ + */ │ │ │ │ + if (this.feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + // dragging a simple point │ │ │ │ + this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ + vertex: vertex.geometry, │ │ │ │ + feature: this.feature, │ │ │ │ + pixel: pixel │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + if (vertex._index) { │ │ │ │ + // dragging a virtual vertex │ │ │ │ + vertex.geometry.parent.addComponent(vertex.geometry, │ │ │ │ + vertex._index); │ │ │ │ + // move from virtual to real vertex │ │ │ │ + delete vertex._index; │ │ │ │ + OpenLayers.Util.removeItem(this.virtualVertices, vertex); │ │ │ │ + this.vertices.push(vertex); │ │ │ │ + } else if (vertex == this.dragHandle) { │ │ │ │ + // dragging a drag handle │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + if (this.radiusHandle) { │ │ │ │ + this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.radiusHandle = null; │ │ │ │ + } │ │ │ │ + } else if (vertex !== this.radiusHandle) { │ │ │ │ + // dragging a real vertex │ │ │ │ + this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ + vertex: vertex.geometry, │ │ │ │ + feature: this.feature, │ │ │ │ + pixel: pixel │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + // dragging a radius handle - no special treatment │ │ │ │ + if (this.virtualVertices.length > 0) { │ │ │ │ + this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.virtualVertices = []; │ │ │ │ + } │ │ │ │ + this.layer.drawFeature(this.feature, this.standalone ? undefined : │ │ │ │ + 'select'); │ │ │ │ } │ │ │ │ - return nodes; │ │ │ │ + // keep the vertex on top so it gets the mouseout after dragging │ │ │ │ + // this should be removed in favor of an option to draw under or │ │ │ │ + // maintain node z-index │ │ │ │ + this.layer.drawFeature(vertex); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createXML │ │ │ │ - * Takes a feature, returns a list of nodes from size 0->n. │ │ │ │ - * Will include all pieces of the serialization that are required which │ │ │ │ - * have not already been created. │ │ │ │ + * Method: dragComplete │ │ │ │ + * Called by the drag handler when the feature dragging is complete. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged. │ │ │ │ */ │ │ │ │ - createXML: { │ │ │ │ - 'point': function(point) { │ │ │ │ - var id = null; │ │ │ │ - var geometry = point.geometry ? point.geometry : point; │ │ │ │ + dragComplete: function(vertex) { │ │ │ │ + this.resetVertices(); │ │ │ │ + this.setFeatureState(); │ │ │ │ + this.onModification(this.feature); │ │ │ │ + this.layer.events.triggerEvent("featuremodified", { │ │ │ │ + feature: this.feature │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - geometry.transform(this.internalProjection, │ │ │ │ - this.externalProjection); │ │ │ │ + /** │ │ │ │ + * Method: setFeatureState │ │ │ │ + * Called when the feature is modified. If the current state is not │ │ │ │ + * INSERT or DELETE, the state is set to UPDATE. │ │ │ │ + */ │ │ │ │ + setFeatureState: function() { │ │ │ │ + if (this.feature.state != OpenLayers.State.INSERT && │ │ │ │ + this.feature.state != OpenLayers.State.DELETE) { │ │ │ │ + this.feature.state = OpenLayers.State.UPDATE; │ │ │ │ + if (this.modified && this._originalGeometry) { │ │ │ │ + var feature = this.feature; │ │ │ │ + feature.modified = OpenLayers.Util.extend(feature.modified, { │ │ │ │ + geometry: this._originalGeometry │ │ │ │ + }); │ │ │ │ + delete this._originalGeometry; │ │ │ │ } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - var already_exists = false; // We don't return anything if the node │ │ │ │ - // has already been created │ │ │ │ - if (point.osm_id) { │ │ │ │ - id = point.osm_id; │ │ │ │ - if (this.created_nodes[id]) { │ │ │ │ - already_exists = true; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - id = -this.osm_id; │ │ │ │ - this.osm_id++; │ │ │ │ + /** │ │ │ │ + * Method: resetVertices │ │ │ │ + */ │ │ │ │ + resetVertices: function() { │ │ │ │ + if (this.vertices.length > 0) { │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + } │ │ │ │ + if (this.virtualVertices.length > 0) { │ │ │ │ + this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.virtualVertices = []; │ │ │ │ + } │ │ │ │ + if (this.dragHandle) { │ │ │ │ + this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.dragHandle = null; │ │ │ │ + } │ │ │ │ + if (this.radiusHandle) { │ │ │ │ + this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.radiusHandle = null; │ │ │ │ + } │ │ │ │ + if (this.feature && │ │ │ │ + this.feature.geometry.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ + if ((this.mode & OpenLayers.Control.ModifyFeature.DRAG)) { │ │ │ │ + this.collectDragHandle(); │ │ │ │ } │ │ │ │ - if (already_exists) { │ │ │ │ - node = this.created_nodes[id]; │ │ │ │ - } else { │ │ │ │ - var node = this.createElementNS(null, "node"); │ │ │ │ + if ((this.mode & (OpenLayers.Control.ModifyFeature.ROTATE | │ │ │ │ + OpenLayers.Control.ModifyFeature.RESIZE))) { │ │ │ │ + this.collectRadiusHandle(); │ │ │ │ } │ │ │ │ - this.created_nodes[id] = node; │ │ │ │ - node.setAttribute("id", id); │ │ │ │ - node.setAttribute("lon", geometry.x); │ │ │ │ - node.setAttribute("lat", geometry.y); │ │ │ │ - if (point.attributes) { │ │ │ │ - this.serializeTags(point, node); │ │ │ │ + if (this.mode & OpenLayers.Control.ModifyFeature.RESHAPE) { │ │ │ │ + // Don't collect vertices when we're resizing │ │ │ │ + if (!(this.mode & OpenLayers.Control.ModifyFeature.RESIZE)) { │ │ │ │ + this.collectVertices(); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.setState(point, node); │ │ │ │ - return already_exists ? [] : [node]; │ │ │ │ - }, │ │ │ │ - linestring: function(feature) { │ │ │ │ - var id; │ │ │ │ - var nodes = []; │ │ │ │ - var geometry = feature.geometry; │ │ │ │ - if (feature.osm_id) { │ │ │ │ - id = feature.osm_id; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: handleKeypress │ │ │ │ + * Called by the feature handler on keypress. This is used to delete │ │ │ │ + * vertices. If the <deleteCode> property is set, vertices will │ │ │ │ + * be deleted when a feature is selected for modification and │ │ │ │ + * the mouse is over a vertex. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} Keypress event. │ │ │ │ + */ │ │ │ │ + handleKeypress: function(evt) { │ │ │ │ + var code = evt.keyCode; │ │ │ │ + │ │ │ │ + // check for delete key │ │ │ │ + if (this.feature && │ │ │ │ + OpenLayers.Util.indexOf(this.deleteCodes, code) != -1) { │ │ │ │ + var vertex = this.layer.getFeatureFromEvent(this.handlers.drag.evt); │ │ │ │ + if (vertex && │ │ │ │ + OpenLayers.Util.indexOf(this.vertices, vertex) != -1 && │ │ │ │ + !this.handlers.drag.dragging && vertex.geometry.parent) { │ │ │ │ + // remove the vertex │ │ │ │ + vertex.geometry.parent.removeComponent(vertex.geometry); │ │ │ │ + this.layer.events.triggerEvent("vertexremoved", { │ │ │ │ + vertex: vertex.geometry, │ │ │ │ + feature: this.feature, │ │ │ │ + pixel: evt.xy │ │ │ │ + }); │ │ │ │ + this.layer.drawFeature(this.feature, this.standalone ? │ │ │ │ + undefined : 'select'); │ │ │ │ + this.modified = true; │ │ │ │ + this.resetVertices(); │ │ │ │ + this.setFeatureState(); │ │ │ │ + this.onModification(this.feature); │ │ │ │ + this.layer.events.triggerEvent("featuremodified", { │ │ │ │ + feature: this.feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: collectVertices │ │ │ │ + * Collect the vertices from the modifiable feature's geometry and push │ │ │ │ + * them on to the control's vertices array. │ │ │ │ + */ │ │ │ │ + collectVertices: function() { │ │ │ │ + this.vertices = []; │ │ │ │ + this.virtualVertices = []; │ │ │ │ + var control = this; │ │ │ │ + │ │ │ │ + function collectComponentVertices(geometry) { │ │ │ │ + var i, vertex, component, len; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + vertex = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + vertex._sketch = true; │ │ │ │ + vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ + control.vertices.push(vertex); │ │ │ │ } else { │ │ │ │ - id = -this.osm_id; │ │ │ │ - this.osm_id++; │ │ │ │ + var numVert = geometry.components.length; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ + numVert -= 1; │ │ │ │ + } │ │ │ │ + for (i = 0; i < numVert; ++i) { │ │ │ │ + component = geometry.components[i]; │ │ │ │ + if (component.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + vertex = new OpenLayers.Feature.Vector(component); │ │ │ │ + vertex._sketch = true; │ │ │ │ + vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ + control.vertices.push(vertex); │ │ │ │ + } else { │ │ │ │ + collectComponentVertices(component); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // add virtual vertices in the middle of each edge │ │ │ │ + if (control.createVertices && geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") { │ │ │ │ + for (i = 0, len = geometry.components.length; i < len - 1; ++i) { │ │ │ │ + var prevVertex = geometry.components[i]; │ │ │ │ + var nextVertex = geometry.components[i + 1]; │ │ │ │ + if (prevVertex.CLASS_NAME == "OpenLayers.Geometry.Point" && │ │ │ │ + nextVertex.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + var x = (prevVertex.x + nextVertex.x) / 2; │ │ │ │ + var y = (prevVertex.y + nextVertex.y) / 2; │ │ │ │ + var point = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.Point(x, y), │ │ │ │ + null, control.virtualStyle │ │ │ │ + ); │ │ │ │ + // set the virtual parent and intended index │ │ │ │ + point.geometry.parent = geometry; │ │ │ │ + point._index = i + 1; │ │ │ │ + point._sketch = true; │ │ │ │ + control.virtualVertices.push(point); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - var way = this.createElementNS(null, "way"); │ │ │ │ - way.setAttribute("id", id); │ │ │ │ - for (var i = 0; i < geometry.components.length; i++) { │ │ │ │ - var node = this.createXML['point'].apply(this, [geometry.components[i]]); │ │ │ │ - if (node.length) { │ │ │ │ - node = node[0]; │ │ │ │ - var node_ref = node.getAttribute("id"); │ │ │ │ - nodes.push(node); │ │ │ │ + } │ │ │ │ + collectComponentVertices.call(this, this.feature.geometry); │ │ │ │ + this.layer.addFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.layer.addFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: collectDragHandle │ │ │ │ + * Collect the drag handle for the selected geometry. │ │ │ │ + */ │ │ │ │ + collectDragHandle: function() { │ │ │ │ + var geometry = this.feature.geometry; │ │ │ │ + var center = geometry.getBounds().getCenterLonLat(); │ │ │ │ + var originGeometry = new OpenLayers.Geometry.Point( │ │ │ │ + center.lon, center.lat │ │ │ │ + ); │ │ │ │ + var origin = new OpenLayers.Feature.Vector(originGeometry); │ │ │ │ + originGeometry.move = function(x, y) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + geometry.move(x, y); │ │ │ │ + }; │ │ │ │ + origin._sketch = true; │ │ │ │ + this.dragHandle = origin; │ │ │ │ + this.dragHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ + this.layer.addFeatures([this.dragHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: collectRadiusHandle │ │ │ │ + * Collect the radius handle for the selected geometry. │ │ │ │ + */ │ │ │ │ + collectRadiusHandle: function() { │ │ │ │ + var geometry = this.feature.geometry; │ │ │ │ + var bounds = geometry.getBounds(); │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var originGeometry = new OpenLayers.Geometry.Point( │ │ │ │ + center.lon, center.lat │ │ │ │ + ); │ │ │ │ + var radiusGeometry = new OpenLayers.Geometry.Point( │ │ │ │ + bounds.right, bounds.bottom │ │ │ │ + ); │ │ │ │ + var radius = new OpenLayers.Feature.Vector(radiusGeometry); │ │ │ │ + var resize = (this.mode & OpenLayers.Control.ModifyFeature.RESIZE); │ │ │ │ + var reshape = (this.mode & OpenLayers.Control.ModifyFeature.RESHAPE); │ │ │ │ + var rotate = (this.mode & OpenLayers.Control.ModifyFeature.ROTATE); │ │ │ │ + │ │ │ │ + radiusGeometry.move = function(x, y) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + var dx1 = this.x - originGeometry.x; │ │ │ │ + var dy1 = this.y - originGeometry.y; │ │ │ │ + var dx0 = dx1 - x; │ │ │ │ + var dy0 = dy1 - y; │ │ │ │ + if (rotate) { │ │ │ │ + var a0 = Math.atan2(dy0, dx0); │ │ │ │ + var a1 = Math.atan2(dy1, dx1); │ │ │ │ + var angle = a1 - a0; │ │ │ │ + angle *= 180 / Math.PI; │ │ │ │ + geometry.rotate(angle, originGeometry); │ │ │ │ + } │ │ │ │ + if (resize) { │ │ │ │ + var scale, ratio; │ │ │ │ + // 'resize' together with 'reshape' implies that the aspect │ │ │ │ + // ratio of the geometry will not be preserved whilst resizing │ │ │ │ + if (reshape) { │ │ │ │ + scale = dy1 / dy0; │ │ │ │ + ratio = (dx1 / dx0) / scale; │ │ │ │ } else { │ │ │ │ - node_ref = geometry.components[i].osm_id; │ │ │ │ - node = this.created_nodes[node_ref]; │ │ │ │ + var l0 = Math.sqrt((dx0 * dx0) + (dy0 * dy0)); │ │ │ │ + var l1 = Math.sqrt((dx1 * dx1) + (dy1 * dy1)); │ │ │ │ + scale = l1 / l0; │ │ │ │ } │ │ │ │ - this.setState(feature, node); │ │ │ │ - var nd_dom = this.createElementNS(null, "nd"); │ │ │ │ - nd_dom.setAttribute("ref", node_ref); │ │ │ │ - way.appendChild(nd_dom); │ │ │ │ + geometry.resize(scale, originGeometry, ratio); │ │ │ │ } │ │ │ │ - this.serializeTags(feature, way); │ │ │ │ - nodes.push(way); │ │ │ │ - │ │ │ │ - return nodes; │ │ │ │ - }, │ │ │ │ - polygon: function(feature) { │ │ │ │ - var attrs = OpenLayers.Util.extend({ │ │ │ │ - 'area': 'yes' │ │ │ │ - }, feature.attributes); │ │ │ │ - var feat = new OpenLayers.Feature.Vector(feature.geometry.components[0], attrs); │ │ │ │ - feat.osm_id = feature.osm_id; │ │ │ │ - return this.createXML['linestring'].apply(this, [feat]); │ │ │ │ - } │ │ │ │ + }; │ │ │ │ + radius._sketch = true; │ │ │ │ + this.radiusHandle = radius; │ │ │ │ + this.radiusHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ + this.layer.addFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: serializeTags │ │ │ │ - * Given a feature, serialize the attributes onto the given node. │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control and all handlers. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * node - {DOMNode} │ │ │ │ + * map - {<OpenLayers.Map>} The control's map. │ │ │ │ */ │ │ │ │ - serializeTags: function(feature, node) { │ │ │ │ - for (var key in feature.attributes) { │ │ │ │ - var tag = this.createElementNS(null, "tag"); │ │ │ │ - tag.setAttribute("k", key); │ │ │ │ - tag.setAttribute("v", feature.attributes[key]); │ │ │ │ - node.appendChild(tag); │ │ │ │ - } │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.drag.setMap(map); │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setState │ │ │ │ - * OpenStreetMap has a convention that 'state' is stored for modification or deletion. │ │ │ │ - * This allows the file to be uploaded via JOSM or the bulk uploader tool. │ │ │ │ - * │ │ │ │ + * Method: handleMapEvents │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * node - {DOMNode} │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - setState: function(feature, node) { │ │ │ │ - if (feature.state) { │ │ │ │ - var state = null; │ │ │ │ - switch (feature.state) { │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - state = "modify"; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - state = "delete"; │ │ │ │ - } │ │ │ │ - if (state) { │ │ │ │ - node.setAttribute("action", state); │ │ │ │ - } │ │ │ │ + handleMapEvents: function(evt) { │ │ │ │ + if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.OSM" │ │ │ │ + /** │ │ │ │ + * Method: moveLayerToTop │ │ │ │ + * Moves the layer for this handler to the top, so mouse events can reach │ │ │ │ + * it. │ │ │ │ + */ │ │ │ │ + moveLayerToTop: function() { │ │ │ │ + var index = Math.max(this.map.Z_INDEX_BASE['Feature'] - 1, │ │ │ │ + this.layer.getZIndex()) + 1; │ │ │ │ + this.layer.setZIndex(index); │ │ │ │ + │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: moveLayerBack │ │ │ │ + * Moves the layer back to the position determined by the map's layers │ │ │ │ + * array. │ │ │ │ + */ │ │ │ │ + moveLayerBack: function() { │ │ │ │ + var index = this.layer.getZIndex() - 1; │ │ │ │ + if (index >= this.map.Z_INDEX_BASE['Feature']) { │ │ │ │ + this.layer.setZIndex(index); │ │ │ │ + } else { │ │ │ │ + this.map.setLayerZIndex(this.layer, │ │ │ │ + this.map.getLayerIndex(this.layer)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ModifyFeature" │ │ │ │ }); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: RESHAPE │ │ │ │ + * {Integer} Constant used to make the control work in reshape mode │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ModifyFeature.RESHAPE = 1; │ │ │ │ +/** │ │ │ │ + * Constant: RESIZE │ │ │ │ + * {Integer} Constant used to make the control work in resize mode │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ModifyFeature.RESIZE = 2; │ │ │ │ +/** │ │ │ │ + * Constant: ROTATE │ │ │ │ + * {Integer} Constant used to make the control work in rotate mode │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ModifyFeature.ROTATE = 4; │ │ │ │ +/** │ │ │ │ + * Constant: DRAG │ │ │ │ + * {Integer} Constant used to make the control work in drag mode │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ModifyFeature.DRAG = 8; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/GPX.js │ │ │ │ + OpenLayers/Control/NavigationHistory.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - * @requires OpenLayers/Projection.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Control/Button.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.GPX │ │ │ │ - * Read/write GPX parser. Create a new instance with the │ │ │ │ - * <OpenLayers.Format.GPX> constructor. │ │ │ │ + * Class: OpenLayers.Control.NavigationHistory │ │ │ │ + * A navigation history control. This is a meta-control, that creates two │ │ │ │ + * dependent controls: <previous> and <next>. Call the trigger method │ │ │ │ + * on the <previous> and <next> 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.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ +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: defaultDesc │ │ │ │ - * {String} Default description for the waypoints/tracks in the case │ │ │ │ - * where the feature has no "description" attribute. │ │ │ │ - * Default is "No description available". │ │ │ │ + /** │ │ │ │ + * APIProperty: previous │ │ │ │ + * {<OpenLayers.Control>} A button type control whose trigger method restores │ │ │ │ + * the previous state managed by this control. │ │ │ │ */ │ │ │ │ - defaultDesc: "No description available", │ │ │ │ + previous: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractWaypoints │ │ │ │ - * {Boolean} Extract waypoints from GPX. (default: true) │ │ │ │ + * APIProperty: previousOptions │ │ │ │ + * {Object} Set this property on the options argument of the constructor │ │ │ │ + * to set optional properties on the <previous> control. │ │ │ │ */ │ │ │ │ - extractWaypoints: true, │ │ │ │ + previousOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractTracks │ │ │ │ - * {Boolean} Extract tracks from GPX. (default: true) │ │ │ │ + * APIProperty: next │ │ │ │ + * {<OpenLayers.Control>} A button type control whose trigger method restores │ │ │ │ + * the next state managed by this control. │ │ │ │ */ │ │ │ │ - extractTracks: true, │ │ │ │ + next: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractRoutes │ │ │ │ - * {Boolean} Extract routes from GPX. (default: true) │ │ │ │ + * APIProperty: nextOptions │ │ │ │ + * {Object} Set this property on the options argument of the constructor │ │ │ │ + * to set optional properties on the <next> control. │ │ │ │ */ │ │ │ │ - extractRoutes: true, │ │ │ │ + nextOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractAttributes │ │ │ │ - * {Boolean} Extract feature attributes from GPX. (default: true) │ │ │ │ - * NOTE: Attributes as part of extensions to the GPX standard may not │ │ │ │ - * be extracted. │ │ │ │ + * APIProperty: limit │ │ │ │ + * {Integer} Optional limit on the number of history items to retain. If │ │ │ │ + * null, there is no limit. Default is 50. │ │ │ │ */ │ │ │ │ - extractAttributes: true, │ │ │ │ + limit: 50, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - gpx: "http://www.topografix.com/GPX/1/1", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location. Defaults to │ │ │ │ - * "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd" │ │ │ │ + * Property: clearOnDeactivate │ │ │ │ + * {Boolean} Clear the history when the control is deactivated. Default │ │ │ │ + * is false. │ │ │ │ */ │ │ │ │ - schemaLocation: "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd", │ │ │ │ + clearOnDeactivate: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: creator │ │ │ │ - * {String} The creator attribute to be added to the written GPX files. │ │ │ │ - * Defaults to "OpenLayers" │ │ │ │ + * Property: registry │ │ │ │ + * {Object} An object with keys corresponding to event types. Values │ │ │ │ + * are functions that return an object representing the current state. │ │ │ │ */ │ │ │ │ - creator: "OpenLayers", │ │ │ │ + registry: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.GPX │ │ │ │ - * Create a new parser for GPX. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * Property: nextStack │ │ │ │ + * {Array} Array of items in the history. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - // GPX coordinates are always in longlat WGS84 │ │ │ │ - this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + nextStack: null, │ │ │ │ │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: previousStack │ │ │ │ + * {Array} List of items in the history. First item represents the current │ │ │ │ + * state. │ │ │ │ + */ │ │ │ │ + previousStack: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Return a list of features from a GPX doc │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * doc - {Element} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * Array({<OpenLayers.Feature.Vector>}) │ │ │ │ + * Property: listeners │ │ │ │ + * {Object} An object containing properties corresponding to event types. │ │ │ │ + * This object is used to configure the control and is modified on │ │ │ │ + * construction. │ │ │ │ */ │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]); │ │ │ │ - } │ │ │ │ - var features = []; │ │ │ │ + listeners: null, │ │ │ │ │ │ │ │ - if (this.extractTracks) { │ │ │ │ - var tracks = doc.getElementsByTagName("trk"); │ │ │ │ - for (var i = 0, len = tracks.length; i < len; i++) { │ │ │ │ - // Attributes are only in trk nodes, not trkseg nodes │ │ │ │ - var attrs = {}; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attrs = this.parseAttributes(tracks[i]); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * 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, │ │ │ │ │ │ │ │ - var segs = this.getElementsByTagNameNS(tracks[i], tracks[i].namespaceURI, "trkseg"); │ │ │ │ - for (var j = 0, seglen = segs.length; j < seglen; j++) { │ │ │ │ - // We don't yet support extraction of trkpt attributes │ │ │ │ - // All trksegs of a trk get that trk's attributes │ │ │ │ - var track = this.extractSegment(segs[j], "trkpt"); │ │ │ │ - features.push(new OpenLayers.Feature.Vector(track, attrs)); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * 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]); │ │ │ │ │ │ │ │ - if (this.extractRoutes) { │ │ │ │ - var routes = doc.getElementsByTagName("rte"); │ │ │ │ - for (var k = 0, klen = routes.length; k < klen; k++) { │ │ │ │ - var attrs = {}; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attrs = this.parseAttributes(routes[k]); │ │ │ │ - } │ │ │ │ - var route = this.extractSegment(routes[k], "rtept"); │ │ │ │ - features.push(new OpenLayers.Feature.Vector(route, attrs)); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.registry = OpenLayers.Util.extend({ │ │ │ │ + "moveend": this.getState │ │ │ │ + }, this.registry); │ │ │ │ │ │ │ │ - if (this.extractWaypoints) { │ │ │ │ - var waypoints = doc.getElementsByTagName("wpt"); │ │ │ │ - for (var l = 0, len = waypoints.length; l < len; l++) { │ │ │ │ - var attrs = {}; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attrs = this.parseAttributes(waypoints[l]); │ │ │ │ - } │ │ │ │ - var wpt = new OpenLayers.Geometry.Point(waypoints[l].getAttribute("lon"), waypoints[l].getAttribute("lat")); │ │ │ │ - features.push(new OpenLayers.Feature.Vector(wpt, attrs)); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var previousOptions = { │ │ │ │ + trigger: OpenLayers.Function.bind(this.previousTrigger, this), │ │ │ │ + displayClass: this.displayClass + " " + this.displayClass + "Previous" │ │ │ │ + }; │ │ │ │ + OpenLayers.Util.extend(previousOptions, this.previousOptions); │ │ │ │ + this.previous = new OpenLayers.Control.Button(previousOptions); │ │ │ │ │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - for (var g = 0, featLength = features.length; g < featLength; g++) { │ │ │ │ - features[g].geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var nextOptions = { │ │ │ │ + trigger: OpenLayers.Function.bind(this.nextTrigger, this), │ │ │ │ + displayClass: this.displayClass + " " + this.displayClass + "Next" │ │ │ │ + }; │ │ │ │ + OpenLayers.Util.extend(nextOptions, this.nextOptions); │ │ │ │ + this.next = new OpenLayers.Control.Button(nextOptions); │ │ │ │ │ │ │ │ - return features; │ │ │ │ + this.clear(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: extractSegment │ │ │ │ + * Method: onPreviousChange │ │ │ │ + * Called when the previous history stack changes. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * segment - {DOMElement} a trkseg or rte node to parse │ │ │ │ - * segmentType - {String} nodeName of waypoints that form the line │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.LineString>} A linestring geometry │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - extractSegment: function(segment, segmentType) { │ │ │ │ - var points = this.getElementsByTagNameNS(segment, segment.namespaceURI, segmentType); │ │ │ │ - var point_features = []; │ │ │ │ - for (var i = 0, len = points.length; i < len; i++) { │ │ │ │ - point_features.push(new OpenLayers.Geometry.Point(points[i].getAttribute("lon"), points[i].getAttribute("lat"))); │ │ │ │ + onPreviousChange: function(state, length) { │ │ │ │ + if (state && !this.previous.active) { │ │ │ │ + this.previous.activate(); │ │ │ │ + } else if (!state && this.previous.active) { │ │ │ │ + this.previous.deactivate(); │ │ │ │ } │ │ │ │ - return new OpenLayers.Geometry.LineString(point_features); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseAttributes │ │ │ │ + * Method: onNextChange │ │ │ │ + * Called when the next history stack changes. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {<DOMElement>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An attributes object. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - parseAttributes: function(node) { │ │ │ │ - // node is either a wpt, trk or rte │ │ │ │ - // attributes are children of the form <attr>value</attr> │ │ │ │ - var attributes = {}; │ │ │ │ - var attrNode = node.firstChild, │ │ │ │ - value, name; │ │ │ │ - while (attrNode) { │ │ │ │ - if (attrNode.nodeType == 1 && attrNode.firstChild) { │ │ │ │ - value = attrNode.firstChild; │ │ │ │ - if (value.nodeType == 3 || value.nodeType == 4) { │ │ │ │ - name = (attrNode.prefix) ? │ │ │ │ - attrNode.nodeName.split(":")[1] : │ │ │ │ - attrNode.nodeName; │ │ │ │ - if (name != "trkseg" && name != "rtept") { │ │ │ │ - attributes[name] = value.nodeValue; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - attrNode = attrNode.nextSibling; │ │ │ │ + onNextChange: function(state, length) { │ │ │ │ + if (state && !this.next.active) { │ │ │ │ + this.next.activate(); │ │ │ │ + } else if (!state && this.next.active) { │ │ │ │ + this.next.deactivate(); │ │ │ │ } │ │ │ │ - return attributes; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Accepts Feature Collection, and returns a string. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} List of features to serialize into a string. │ │ │ │ - * metadata - {Object} A key/value pairs object to build a metadata node to │ │ │ │ - * add to the gpx. Supported keys are 'name', 'desc', 'author'. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Destroy the control. │ │ │ │ */ │ │ │ │ - write: function(features, metadata) { │ │ │ │ - features = OpenLayers.Util.isArray(features) ? │ │ │ │ - features : [features]; │ │ │ │ - var gpx = this.createElementNS(this.namespaces.gpx, "gpx"); │ │ │ │ - gpx.setAttribute("version", "1.1"); │ │ │ │ - gpx.setAttribute("creator", this.creator); │ │ │ │ - this.setAttributes(gpx, { │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ - }); │ │ │ │ - │ │ │ │ - if (metadata && typeof metadata == 'object') { │ │ │ │ - gpx.appendChild(this.buildMetadataNode(metadata)); │ │ │ │ - } │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - gpx.appendChild(this.buildFeatureNode(features[i])); │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ + this.previous.destroy(); │ │ │ │ + this.next.destroy(); │ │ │ │ + this.deactivate(); │ │ │ │ + for (var prop in this) { │ │ │ │ + this[prop] = null; │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [gpx]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control and <previous> and <next> child │ │ │ │ + * controls. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + this.next.setMap(map); │ │ │ │ + this.previous.setMap(map); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildMetadataNode │ │ │ │ - * Creates a "metadata" node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: draw │ │ │ │ + * Called when the control is added to the map. │ │ │ │ */ │ │ │ │ - buildMetadataNode: function(metadata) { │ │ │ │ - var types = ['name', 'desc', 'author'], │ │ │ │ - node = this.createElementNS(this.namespaces.gpx, 'metadata'); │ │ │ │ - for (var i = 0; i < types.length; i++) { │ │ │ │ - var type = types[i]; │ │ │ │ - if (metadata[type]) { │ │ │ │ - var n = this.createElementNS(this.namespaces.gpx, type); │ │ │ │ - n.appendChild(this.createTextNode(metadata[type])); │ │ │ │ - node.appendChild(n); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + this.next.draw(); │ │ │ │ + this.previous.draw(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildFeatureNode │ │ │ │ - * Accepts an <OpenLayers.Feature.Vector>, and builds a node for it. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Method: previousTrigger │ │ │ │ + * Restore the previous state. If no items are in the previous history │ │ │ │ + * stack, this has no effect. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} - The created node, either a 'wpt' or a 'trk'. │ │ │ │ + * {Object} Item representing state that was restored. Undefined if no │ │ │ │ + * items are in the previous history stack. │ │ │ │ */ │ │ │ │ - buildFeatureNode: function(feature) { │ │ │ │ - var geometry = feature.geometry; │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.internalProjection, │ │ │ │ - this.externalProjection); │ │ │ │ - } │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - var wpt = this.buildWptNode(geometry); │ │ │ │ - this.appendAttributesNode(wpt, feature); │ │ │ │ - return wpt; │ │ │ │ + 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 { │ │ │ │ - var trkNode = this.createElementNS(this.namespaces.gpx, "trk"); │ │ │ │ - this.appendAttributesNode(trkNode, feature); │ │ │ │ - var trkSegNodes = this.buildTrkSegNode(geometry); │ │ │ │ - trkSegNodes = OpenLayers.Util.isArray(trkSegNodes) ? │ │ │ │ - trkSegNodes : [trkSegNodes]; │ │ │ │ - for (var i = 0, len = trkSegNodes.length; i < len; i++) { │ │ │ │ - trkNode.appendChild(trkSegNodes[i]); │ │ │ │ - } │ │ │ │ - return trkNode; │ │ │ │ + this.previousStack.unshift(current); │ │ │ │ } │ │ │ │ + return state; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildTrkSegNode │ │ │ │ - * Builds trkseg node(s) given a geometry │ │ │ │ + * 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. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * trknode │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * Returns: │ │ │ │ + * {Object} Item representing state that was restored. Undefined if no │ │ │ │ + * items are in the next history stack. │ │ │ │ */ │ │ │ │ - buildTrkSegNode: function(geometry) { │ │ │ │ - var node, │ │ │ │ - i, │ │ │ │ - len, │ │ │ │ - point, │ │ │ │ - nodes; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" || │ │ │ │ - geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ - node = this.createElementNS(this.namespaces.gpx, "trkseg"); │ │ │ │ - for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ - point = geometry.components[i]; │ │ │ │ - node.appendChild(this.buildTrkPtNode(point)); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - } else { │ │ │ │ - nodes = []; │ │ │ │ - for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ - nodes.push(this.buildTrkSegNode(geometry.components[i])); │ │ │ │ - } │ │ │ │ - return nodes; │ │ │ │ + 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; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildTrkPtNode │ │ │ │ - * Builds a trkpt node given a point │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A trkpt node │ │ │ │ + * APIMethod: clear │ │ │ │ + * Clear history. │ │ │ │ */ │ │ │ │ - buildTrkPtNode: function(point) { │ │ │ │ - var node = this.createElementNS(this.namespaces.gpx, "trkpt"); │ │ │ │ - node.setAttribute("lon", point.x); │ │ │ │ - node.setAttribute("lat", point.y); │ │ │ │ - return node; │ │ │ │ + clear: function() { │ │ │ │ + this.previousStack = []; │ │ │ │ + this.previous.deactivate(); │ │ │ │ + this.nextStack = []; │ │ │ │ + this.next.deactivate(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildWptNode │ │ │ │ - * Builds a wpt node given a point │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Point>} │ │ │ │ + * Method: getState │ │ │ │ + * Get the current state and return it. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A wpt node │ │ │ │ + * {Object} An object representing the current state. │ │ │ │ */ │ │ │ │ - buildWptNode: function(geometry) { │ │ │ │ - var node = this.createElementNS(this.namespaces.gpx, "wpt"); │ │ │ │ - node.setAttribute("lon", geometry.x); │ │ │ │ - node.setAttribute("lat", geometry.y); │ │ │ │ - return node; │ │ │ │ + getState: function() { │ │ │ │ + return { │ │ │ │ + center: this.map.getCenter(), │ │ │ │ + resolution: this.map.getResolution(), │ │ │ │ + projection: this.map.getProjectionObject(), │ │ │ │ + units: this.map.getProjectionObject().getUnits() || │ │ │ │ + this.map.units || this.map.baseLayer.units │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: appendAttributesNode │ │ │ │ - * Adds some attributes node. │ │ │ │ + * Method: restore │ │ │ │ + * Update the state with the given object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} the node to append the attribute nodes to. │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * state - {Object} An object representing the state to restore. │ │ │ │ */ │ │ │ │ - appendAttributesNode: function(node, feature) { │ │ │ │ - var name = this.createElementNS(this.namespaces.gpx, 'name'); │ │ │ │ - name.appendChild(this.createTextNode( │ │ │ │ - feature.attributes.name || feature.id)); │ │ │ │ - node.appendChild(name); │ │ │ │ - var desc = this.createElementNS(this.namespaces.gpx, 'desc'); │ │ │ │ - desc.appendChild(this.createTextNode( │ │ │ │ - feature.attributes.description || this.defaultDesc)); │ │ │ │ - node.appendChild(desc); │ │ │ │ - // TBD - deal with remaining (non name/description) attributes. │ │ │ │ + restore: function(state) { │ │ │ │ + var center, zoom; │ │ │ │ + if (this.map.getProjectionObject() == state.projection) { │ │ │ │ + zoom = this.map.getZoomForResolution(state.resolution); │ │ │ │ + center = state.center; │ │ │ │ + } else { │ │ │ │ + center = state.center.clone(); │ │ │ │ + center.transform(state.projection, this.map.getProjectionObject()); │ │ │ │ + var sourceUnits = state.units; │ │ │ │ + var targetUnits = this.map.getProjectionObject().getUnits() || │ │ │ │ + this.map.units || this.map.baseLayer.units; │ │ │ │ + var resolutionFactor = sourceUnits && targetUnits ? │ │ │ │ + OpenLayers.INCHES_PER_UNIT[sourceUnits] / OpenLayers.INCHES_PER_UNIT[targetUnits] : 1; │ │ │ │ + zoom = this.map.getZoomForResolution(resolutionFactor * state.resolution); │ │ │ │ + } │ │ │ │ + this.map.setCenter(center, zoom); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.GPX" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WCSCapabilities.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WCSCapabilities │ │ │ │ - * Read WCS Capabilities. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WCSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ + * Method: setListeners │ │ │ │ + * Sets functions to be registered in the listeners object. │ │ │ │ */ │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ + 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); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WCSCapabilities │ │ │ │ - * Create a new parser for WCS capabilities. │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the control. This registers any listeners. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * 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: read │ │ │ │ - * Read capabilities data from a string, and return a list of coverages. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the control. This unregisters any listeners. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array} List of named coverages. │ │ │ │ + * {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.Format.WCSCapabilities" │ │ │ │ - │ │ │ │ + CLASS_NAME: "OpenLayers.Control.NavigationHistory" │ │ │ │ }); │ │ │ │ + │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/OWSContext.js │ │ │ │ + OpenLayers/Control/ArgParser.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/Context.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.OWSContext │ │ │ │ - * Read and write OWS Context documents. OWS Context documents are a │ │ │ │ - * preliminary OGC (Open Geospatial Consortium) standard for storing the │ │ │ │ - * state of a web mapping application. In a way it is the successor to │ │ │ │ - * Web Map Context (WMC), since it is more generic and more types of layers │ │ │ │ - * can be stored. Also, nesting of layers is supported since version 0.3.1. │ │ │ │ - * For more information see: http://www.ogcnetwork.net/context │ │ │ │ + * Class: OpenLayers.Control.ArgParser │ │ │ │ + * The ArgParser control adds location bar query string parsing functionality │ │ │ │ + * to an OpenLayers Map. │ │ │ │ + * When added to a Map control, on a page load/refresh, the Map will │ │ │ │ + * automatically take the href string and parse it for lon, lat, zoom, and │ │ │ │ + * layers information. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.Context> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.OWSContext = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ +OpenLayers.Control.ArgParser = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "0.3.1". │ │ │ │ + * Property: center │ │ │ │ + * {<OpenLayers.LonLat>} │ │ │ │ */ │ │ │ │ - defaultVersion: "0.3.1", │ │ │ │ + center: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.OWSContext │ │ │ │ - * Create a new parser for OWS Context documents. │ │ │ │ + * Property: zoom │ │ │ │ + * {int} │ │ │ │ + */ │ │ │ │ + zoom: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: layers │ │ │ │ + * {String} Each character represents the state of the corresponding layer │ │ │ │ + * on the map. │ │ │ │ + */ │ │ │ │ + layers: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: displayProjection │ │ │ │ + * {<OpenLayers.Projection>} 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. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * 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, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getVersion │ │ │ │ - * Returns the version to use. Subclasses can override this function │ │ │ │ - * if a different version detection is needed. │ │ │ │ + * Constructor: OpenLayers.Control.ArgParser │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * root - {DOMElement} │ │ │ │ - * options - {Object} Optional configuration object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The version to use. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - getVersion: function(root, options) { │ │ │ │ - var version = OpenLayers.Format.XML.VersionedOGC.prototype.getVersion.apply( │ │ │ │ - this, arguments); │ │ │ │ - // 0.3.1 is backwards compatible with 0.3.0 │ │ │ │ - if (version === "0.3.0") { │ │ │ │ - version = this.defaultVersion; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getParameters │ │ │ │ + */ │ │ │ │ + getParameters: function(url) { │ │ │ │ + url = url || window.location.href; │ │ │ │ + var parameters = OpenLayers.Util.getParameters(url); │ │ │ │ + │ │ │ │ + // If we have an anchor in the url use it to split the url │ │ │ │ + var index = url.indexOf('#'); │ │ │ │ + if (index > 0) { │ │ │ │ + // create an url to parse on the getParameters │ │ │ │ + url = '?' + url.substring(index + 1, url.length); │ │ │ │ + │ │ │ │ + OpenLayers.Util.extend(parameters, │ │ │ │ + OpenLayers.Util.getParameters(url)); │ │ │ │ } │ │ │ │ - return version; │ │ │ │ + return parameters; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: toContext │ │ │ │ - * Create a context object free from layer given a map or a │ │ │ │ - * context object. │ │ │ │ - * │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * obj - {<OpenLayers.Map> | Object} The map or context. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} A context object. │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - toContext: function(obj) { │ │ │ │ - var context = {}; │ │ │ │ - if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ - context.bounds = obj.getExtent(); │ │ │ │ - context.maxExtent = obj.maxExtent; │ │ │ │ - context.projection = obj.projection; │ │ │ │ - context.size = obj.getSize(); │ │ │ │ - context.layers = obj.layers; │ │ │ │ - } │ │ │ │ - return context; │ │ │ │ - }, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.OWSContext" │ │ │ │ + //make sure we dont already have an arg parser attached │ │ │ │ + for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ + var control = this.map.controls[i]; │ │ │ │ + if ((control != this) && │ │ │ │ + (control.CLASS_NAME == "OpenLayers.Control.ArgParser")) { │ │ │ │ │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WFSCapabilities.js │ │ │ │ - ====================================================================== */ │ │ │ │ + // 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; │ │ │ │ + } │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (i == this.map.controls.length) { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ - */ │ │ │ │ + var args = this.getParameters(); │ │ │ │ + // Be careful to set layer first, to not trigger unnecessary layer loads │ │ │ │ + if (args.layers) { │ │ │ │ + this.layers = args.layers; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WFSCapabilities │ │ │ │ - * Read WFS Capabilities. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WFSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + // 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 = parseFloat(args.zoom); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ - */ │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ + // when we add a new baselayer to see when we can set the center │ │ │ │ + this.map.events.register('changebaselayer', this, │ │ │ │ + this.setCenter); │ │ │ │ + this.setCenter(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WFSCapabilities │ │ │ │ - * Create a new parser for WFS capabilities. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + /** │ │ │ │ + * Method: setCenter │ │ │ │ + * As soon as a baseLayer has been loaded, we center and zoom │ │ │ │ + * ...and remove the handler. │ │ │ │ */ │ │ │ │ + setCenter: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return a list of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} List of named layers. │ │ │ │ + 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() { │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities" │ │ │ │ + if (this.layers.length == this.map.layers.length) { │ │ │ │ + this.map.events.unregister('addlayer', this, this.configureLayers); │ │ │ │ + │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; 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/Format/KML.js │ │ │ │ + OpenLayers/Control/OverviewMap.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Date.js │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ - * @requires OpenLayers/Geometry/Collection.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ - * @requires OpenLayers/Projection.js │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/BaseTypes.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + * @requires OpenLayers/Map.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.KML │ │ │ │ - * Read/Write KML. Create a new instance with the <OpenLayers.Format.KML> │ │ │ │ - * constructor. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.OverviewMap │ │ │ │ + * The OverMap control creates a small overview map, useful to display the │ │ │ │ + * extent of a zoomed map and your main map and provide additional │ │ │ │ + * navigation options to the User. By default the overview map is drawn in │ │ │ │ + * the lower right corner of the main map. Create a new overview map with the │ │ │ │ + * <OpenLayers.Control.OverviewMap> constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.KML = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ +OpenLayers.Control.OverviewMap = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * Property: element │ │ │ │ + * {DOMElement} The DOM element that contains the overview map │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - kml: "http://www.opengis.net/kml/2.2", │ │ │ │ - gx: "http://www.google.com/kml/ext/2.2" │ │ │ │ - }, │ │ │ │ + element: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: kmlns │ │ │ │ - * {String} KML Namespace to use. Defaults to 2.0 namespace. │ │ │ │ - */ │ │ │ │ - kmlns: "http://earth.google.com/kml/2.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: placemarksDesc │ │ │ │ - * {String} Name of the placemarks. Default is "No description available". │ │ │ │ + * APIProperty: ovmap │ │ │ │ + * {<OpenLayers.Map>} A reference to the overview map itself. │ │ │ │ */ │ │ │ │ - placemarksDesc: "No description available", │ │ │ │ + ovmap: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: foldersName │ │ │ │ - * {String} Name of the folders. Default is "OpenLayers export". │ │ │ │ - * If set to null, no name element will be created. │ │ │ │ + /** │ │ │ │ + * APIProperty: size │ │ │ │ + * {<OpenLayers.Size>} The overvew map size in pixels. Note that this is │ │ │ │ + * the size of the map itself - the element that contains the map (default │ │ │ │ + * class name olControlOverviewMapElement) may have padding or other style │ │ │ │ + * attributes added via CSS. │ │ │ │ */ │ │ │ │ - foldersName: "OpenLayers export", │ │ │ │ + size: { │ │ │ │ + w: 180, │ │ │ │ + h: 90 │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: foldersDesc │ │ │ │ - * {String} Description of the folders. Default is "Exported on [date]." │ │ │ │ - * If set to null, no description element will be created. │ │ │ │ + /** │ │ │ │ + * APIProperty: layers │ │ │ │ + * {Array(<OpenLayers.Layer>)} Ordered list of layers in the overview map. │ │ │ │ + * If none are sent at construction, the base layer for the main map is used. │ │ │ │ */ │ │ │ │ - foldersDesc: "Exported on " + new Date(), │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractAttributes │ │ │ │ - * {Boolean} Extract attributes from KML. Default is true. │ │ │ │ - * Extracting styleUrls requires this to be set to true │ │ │ │ - * Note that currently only Data and SimpleData │ │ │ │ - * elements are handled. │ │ │ │ + * APIProperty: minRectSize │ │ │ │ + * {Integer} The minimum width or height (in pixels) of the extent │ │ │ │ + * rectangle on the overview map. When the extent rectangle reaches │ │ │ │ + * this size, it will be replaced depending on the value of the │ │ │ │ + * <minRectDisplayClass> property. Default is 15 pixels. │ │ │ │ */ │ │ │ │ - extractAttributes: true, │ │ │ │ + minRectSize: 15, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: kvpAttributes │ │ │ │ - * {Boolean} Only used if extractAttributes is true. │ │ │ │ - * If set to true, attributes will be simple │ │ │ │ - * key-value pairs, compatible with other formats, │ │ │ │ - * Any displayName elements will be ignored. │ │ │ │ - * If set to false, attributes will be objects, │ │ │ │ - * retaining any displayName elements, but not │ │ │ │ - * compatible with other formats. Any CDATA in │ │ │ │ - * displayName will be read in as a string value. │ │ │ │ - * Default is false. │ │ │ │ + * APIProperty: minRectDisplayClass │ │ │ │ + * {String} Replacement style class name for the extent rectangle when │ │ │ │ + * <minRectSize> is reached. This string will be suffixed on to the │ │ │ │ + * displayClass. Default is "RectReplacement". │ │ │ │ + * │ │ │ │ + * Example CSS declaration: │ │ │ │ + * (code) │ │ │ │ + * .olControlOverviewMapRectReplacement { │ │ │ │ + * overflow: hidden; │ │ │ │ + * cursor: move; │ │ │ │ + * background-image: url("img/overview_replacement.gif"); │ │ │ │ + * background-repeat: no-repeat; │ │ │ │ + * background-position: center; │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - kvpAttributes: false, │ │ │ │ + minRectDisplayClass: "RectReplacement", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: extractStyles │ │ │ │ - * {Boolean} Extract styles from KML. Default is false. │ │ │ │ - * Extracting styleUrls also requires extractAttributes to be │ │ │ │ - * set to true │ │ │ │ + * APIProperty: minRatio │ │ │ │ + * {Float} The ratio of the overview map resolution to the main map │ │ │ │ + * resolution at which to zoom farther out on the overview map. │ │ │ │ */ │ │ │ │ - extractStyles: false, │ │ │ │ + minRatio: 8, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractTracks │ │ │ │ - * {Boolean} Extract gx:Track elements from Placemark elements. Default │ │ │ │ - * is false. If true, features will be generated for all points in │ │ │ │ - * all gx:Track elements. Features will have a when (Date) attribute │ │ │ │ - * based on when elements in the track. If tracks include angle │ │ │ │ - * elements, features will have heading, tilt, and roll attributes. │ │ │ │ - * If track point coordinates have three values, features will have │ │ │ │ - * an altitude attribute with the third coordinate value. │ │ │ │ + * APIProperty: maxRatio │ │ │ │ + * {Float} The ratio of the overview map resolution to the main map │ │ │ │ + * resolution at which to zoom farther in on the overview map. │ │ │ │ */ │ │ │ │ - extractTracks: false, │ │ │ │ + maxRatio: 32, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: trackAttributes │ │ │ │ - * {Array} If <extractTracks> is true, points within gx:Track elements will │ │ │ │ - * be parsed as features with when, heading, tilt, and roll attributes. │ │ │ │ - * Any additional attribute names can be provided in <trackAttributes>. │ │ │ │ + * APIProperty: mapOptions │ │ │ │ + * {Object} An object containing any non-default properties to be sent to │ │ │ │ + * the overview map's map constructor. These should include any │ │ │ │ + * non-default options that the main map was constructed with. │ │ │ │ */ │ │ │ │ - trackAttributes: null, │ │ │ │ + mapOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: internalns │ │ │ │ - * {String} KML Namespace to use -- defaults to the namespace of the │ │ │ │ - * Placemark node being parsed, but falls back to kmlns. │ │ │ │ + * APIProperty: autoPan │ │ │ │ + * {Boolean} Always pan the overview map, so the extent marker remains in │ │ │ │ + * the center. Default is false. If true, when you drag the extent │ │ │ │ + * marker, the overview map will update itself so the marker returns │ │ │ │ + * to the center. │ │ │ │ */ │ │ │ │ - internalns: null, │ │ │ │ + autoPan: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: features │ │ │ │ - * {Array} Array of features │ │ │ │ - * │ │ │ │ + * Property: handlers │ │ │ │ + * {Object} │ │ │ │ */ │ │ │ │ - features: null, │ │ │ │ + handlers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: styles │ │ │ │ - * {Object} Storage of style objects │ │ │ │ - * │ │ │ │ + * Property: resolutionFactor │ │ │ │ + * {Object} │ │ │ │ */ │ │ │ │ - styles: null, │ │ │ │ + resolutionFactor: 1, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: styleBaseUrl │ │ │ │ - * {String} │ │ │ │ + * APIProperty: maximized │ │ │ │ + * {Boolean} Start as maximized (visible). Defaults to false. │ │ │ │ */ │ │ │ │ - styleBaseUrl: "", │ │ │ │ + maximized: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: fetched │ │ │ │ - * {Object} Storage of KML URLs that have been fetched before │ │ │ │ - * in order to prevent reloading them. │ │ │ │ + * APIProperty: maximizeTitle │ │ │ │ + * {String} This property is used for showing a tooltip over the │ │ │ │ + * maximize div. Defaults to "" (no title). │ │ │ │ */ │ │ │ │ - fetched: null, │ │ │ │ + maximizeTitle: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxDepth │ │ │ │ - * {Integer} Maximum depth for recursive loading external KML URLs │ │ │ │ - * Defaults to 0: do no external fetching │ │ │ │ + * APIProperty: minimizeTitle │ │ │ │ + * {String} This property is used for showing a tooltip over the │ │ │ │ + * minimize div. Defaults to "" (no title). │ │ │ │ */ │ │ │ │ - maxDepth: 0, │ │ │ │ + minimizeTitle: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.KML │ │ │ │ - * Create a new parser for KML. │ │ │ │ + * Constructor: OpenLayers.Control.OverviewMap │ │ │ │ + * Create a new overview map │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * options - {Object} Properties of this object will be set on the overview │ │ │ │ + * map object. Note, to set options on the map object contained in this │ │ │ │ + * control, set <mapOptions> as one of the options properties. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ - // compile regular expressions once instead of every time they are used │ │ │ │ - this.regExes = { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g), │ │ │ │ - kmlColor: (/(\w{2})(\w{2})(\w{2})(\w{2})/), │ │ │ │ - kmlIconPalette: (/root:\/\/icons\/palette-(\d+)(\.\w+)/), │ │ │ │ - straightBracket: (/\$\[(.*?)\]/g) │ │ │ │ - }; │ │ │ │ - // KML coordinates are always in longlat WGS84 │ │ │ │ - this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read data from a string, and return a list of features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} List of features. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - this.features = []; │ │ │ │ - this.styles = {}; │ │ │ │ - this.fetched = {}; │ │ │ │ - │ │ │ │ - // Set default options │ │ │ │ - var options = { │ │ │ │ - depth: 0, │ │ │ │ - styleBaseUrl: this.styleBaseUrl │ │ │ │ - }; │ │ │ │ - │ │ │ │ - return this.parseData(data, options); │ │ │ │ + this.layers = []; │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseData │ │ │ │ - * Read data from a string, and return a list of features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * options - {Object} Hash of options │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} List of features. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Deconstruct the control │ │ │ │ */ │ │ │ │ - parseData: function(data, options) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + destroy: function() { │ │ │ │ + if (!this.mapDiv) { // we've already been destroyed │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + if (this.handlers.click) { │ │ │ │ + this.handlers.click.destroy(); │ │ │ │ + } │ │ │ │ + if (this.handlers.drag) { │ │ │ │ + this.handlers.drag.destroy(); │ │ │ │ } │ │ │ │ │ │ │ │ - // Loop throught the following node types in this order and │ │ │ │ - // process the nodes found │ │ │ │ - var types = ["Link", "NetworkLink", "Style", "StyleMap", "Placemark"]; │ │ │ │ - for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ - var type = types[i]; │ │ │ │ - │ │ │ │ - var nodes = this.getElementsByTagNameNS(data, "*", type); │ │ │ │ - │ │ │ │ - // skip to next type if no nodes are found │ │ │ │ - if (nodes.length == 0) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - │ │ │ │ - switch (type.toLowerCase()) { │ │ │ │ - │ │ │ │ - // Fetch external links │ │ │ │ - case "link": │ │ │ │ - case "networklink": │ │ │ │ - this.parseLinks(nodes, options); │ │ │ │ - break; │ │ │ │ + this.ovmap && this.ovmap.viewPortDiv.removeChild(this.extentRectangle); │ │ │ │ + this.extentRectangle = null; │ │ │ │ │ │ │ │ - // parse style information │ │ │ │ - case "style": │ │ │ │ - if (this.extractStyles) { │ │ │ │ - this.parseStyles(nodes, options); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "stylemap": │ │ │ │ - if (this.extractStyles) { │ │ │ │ - this.parseStyleMaps(nodes, options); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ + if (this.rectEvents) { │ │ │ │ + this.rectEvents.destroy(); │ │ │ │ + this.rectEvents = null; │ │ │ │ + } │ │ │ │ │ │ │ │ - // parse features │ │ │ │ - case "placemark": │ │ │ │ - this.parseFeatures(nodes, options); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + if (this.ovmap) { │ │ │ │ + this.ovmap.destroy(); │ │ │ │ + this.ovmap = null; │ │ │ │ } │ │ │ │ │ │ │ │ - return this.features; │ │ │ │ - }, │ │ │ │ + this.element.removeChild(this.mapDiv); │ │ │ │ + this.mapDiv = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: parseLinks │ │ │ │ - * Finds URLs of linked KML documents and fetches them │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ - * options - {Object} Hash of options │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - parseLinks: function(nodes, options) { │ │ │ │ + this.div.removeChild(this.element); │ │ │ │ + this.element = null; │ │ │ │ │ │ │ │ - // Fetch external links <NetworkLink> and <Link> │ │ │ │ - // Don't do anything if we have reached our maximum depth for recursion │ │ │ │ - if (options.depth >= this.maxDepth) { │ │ │ │ - return false; │ │ │ │ + if (this.maximizeDiv) { │ │ │ │ + this.div.removeChild(this.maximizeDiv); │ │ │ │ + this.maximizeDiv = null; │ │ │ │ } │ │ │ │ │ │ │ │ - // increase depth │ │ │ │ - var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ - newOptions.depth++; │ │ │ │ - │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var href = this.parseProperty(nodes[i], "*", "href"); │ │ │ │ - if (href && !this.fetched[href]) { │ │ │ │ - this.fetched[href] = true; // prevent reloading the same urls │ │ │ │ - var data = this.fetchLink(href); │ │ │ │ - if (data) { │ │ │ │ - this.parseData(data, newOptions); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (this.minimizeDiv) { │ │ │ │ + this.div.removeChild(this.minimizeDiv); │ │ │ │ + this.minimizeDiv = null; │ │ │ │ } │ │ │ │ │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: fetchLink │ │ │ │ - * Fetches a URL and returns the result │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * href - {String} url to be fetched │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - fetchLink: function(href) { │ │ │ │ - var request = OpenLayers.Request.GET({ │ │ │ │ - url: href, │ │ │ │ - async: false │ │ │ │ + this.map.events.un({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + moveend: this.update, │ │ │ │ + changebaselayer: this.baseLayerDraw, │ │ │ │ + scope: this │ │ │ │ }); │ │ │ │ - if (request) { │ │ │ │ - return request.responseText; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseStyles │ │ │ │ - * Parses <Style> nodes │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ - * options - {Object} Hash of options │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - parseStyles: function(nodes, options) { │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var style = this.parseStyle(nodes[i]); │ │ │ │ - if (style) { │ │ │ │ - var styleName = (options.styleBaseUrl || "") + "#" + style.id; │ │ │ │ │ │ │ │ - this.styles[styleName] = style; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseKmlColor │ │ │ │ - * Parses a kml color (in 'aabbggrr' format) and returns the corresponding │ │ │ │ - * color and opacity or null if the color is invalid. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * kmlColor - {String} a kml formated color │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} │ │ │ │ + * Method: draw │ │ │ │ + * Render the control in the browser. │ │ │ │ */ │ │ │ │ - parseKmlColor: function(kmlColor) { │ │ │ │ - var color = null; │ │ │ │ - if (kmlColor) { │ │ │ │ - var matches = kmlColor.match(this.regExes.kmlColor); │ │ │ │ - if (matches) { │ │ │ │ - color = { │ │ │ │ - color: '#' + matches[4] + matches[3] + matches[2], │ │ │ │ - opacity: parseInt(matches[1], 16) / 255 │ │ │ │ - }; │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.layers.length === 0) { │ │ │ │ + if (this.map.baseLayer) { │ │ │ │ + var layer = this.map.baseLayer.clone(); │ │ │ │ + this.layers = [layer]; │ │ │ │ + } else { │ │ │ │ + this.map.events.register("changebaselayer", this, this.baseLayerDraw); │ │ │ │ + return this.div; │ │ │ │ } │ │ │ │ } │ │ │ │ - return color; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseStyle │ │ │ │ - * Parses the children of a <Style> node and builds the style hash │ │ │ │ - * accordingly │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} <Style> node │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - parseStyle: function(node) { │ │ │ │ - var style = {}; │ │ │ │ - │ │ │ │ - var types = ["LineStyle", "PolyStyle", "IconStyle", "BalloonStyle", │ │ │ │ - "LabelStyle" │ │ │ │ - ]; │ │ │ │ - var type, styleTypeNode, nodeList, geometry, parser; │ │ │ │ - for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ - type = types[i]; │ │ │ │ - styleTypeNode = this.getElementsByTagNameNS(node, "*", type)[0]; │ │ │ │ - if (!styleTypeNode) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // only deal with first geometry of this type │ │ │ │ - switch (type.toLowerCase()) { │ │ │ │ - case "linestyle": │ │ │ │ - var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ - var color = this.parseKmlColor(kmlColor); │ │ │ │ - if (color) { │ │ │ │ - style["strokeColor"] = color.color; │ │ │ │ - style["strokeOpacity"] = color.opacity; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var width = this.parseProperty(styleTypeNode, "*", "width"); │ │ │ │ - if (width) { │ │ │ │ - style["strokeWidth"] = width; │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - │ │ │ │ - case "polystyle": │ │ │ │ - var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ - var color = this.parseKmlColor(kmlColor); │ │ │ │ - if (color) { │ │ │ │ - style["fillOpacity"] = color.opacity; │ │ │ │ - style["fillColor"] = color.color; │ │ │ │ - } │ │ │ │ - // Check if fill is disabled │ │ │ │ - var fill = this.parseProperty(styleTypeNode, "*", "fill"); │ │ │ │ - if (fill == "0") { │ │ │ │ - style["fillColor"] = "none"; │ │ │ │ - } │ │ │ │ - // Check if outline is disabled │ │ │ │ - var outline = this.parseProperty(styleTypeNode, "*", "outline"); │ │ │ │ - if (outline == "0") { │ │ │ │ - style["strokeWidth"] = "0"; │ │ │ │ - } │ │ │ │ - │ │ │ │ - break; │ │ │ │ - │ │ │ │ - case "iconstyle": │ │ │ │ - // set scale │ │ │ │ - var scale = parseFloat(this.parseProperty(styleTypeNode, │ │ │ │ - "*", "scale") || 1); │ │ │ │ - │ │ │ │ - // set default width and height of icon │ │ │ │ - var width = 32 * scale; │ │ │ │ - var height = 32 * scale; │ │ │ │ - │ │ │ │ - var iconNode = this.getElementsByTagNameNS(styleTypeNode, │ │ │ │ - "*", │ │ │ │ - "Icon")[0]; │ │ │ │ - if (iconNode) { │ │ │ │ - var href = this.parseProperty(iconNode, "*", "href"); │ │ │ │ - if (href) { │ │ │ │ - │ │ │ │ - var w = this.parseProperty(iconNode, "*", "w"); │ │ │ │ - var h = this.parseProperty(iconNode, "*", "h"); │ │ │ │ - │ │ │ │ - // Settings for Google specific icons that are 64x64 │ │ │ │ - // We set the width and height to 64 and halve the │ │ │ │ - // scale to prevent icons from being too big │ │ │ │ - var google = "http://maps.google.com/mapfiles/kml"; │ │ │ │ - if (OpenLayers.String.startsWith( │ │ │ │ - href, google) && !w && !h) { │ │ │ │ - w = 64; │ │ │ │ - h = 64; │ │ │ │ - scale = scale / 2; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // if only dimension is defined, make sure the │ │ │ │ - // other one has the same value │ │ │ │ - w = w || h; │ │ │ │ - h = h || w; │ │ │ │ - │ │ │ │ - if (w) { │ │ │ │ - width = parseInt(w) * scale; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (h) { │ │ │ │ - height = parseInt(h) * scale; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // support for internal icons │ │ │ │ - // (/root://icons/palette-x.png) │ │ │ │ - // x and y tell the position on the palette: │ │ │ │ - // - in pixels │ │ │ │ - // - starting from the left bottom │ │ │ │ - // We translate that to a position in the list │ │ │ │ - // and request the appropriate icon from the │ │ │ │ - // google maps website │ │ │ │ - var matches = href.match(this.regExes.kmlIconPalette); │ │ │ │ - if (matches) { │ │ │ │ - var palette = matches[1]; │ │ │ │ - var file_extension = matches[2]; │ │ │ │ - │ │ │ │ - var x = this.parseProperty(iconNode, "*", "x"); │ │ │ │ - var y = this.parseProperty(iconNode, "*", "y"); │ │ │ │ - │ │ │ │ - var posX = x ? x / 32 : 0; │ │ │ │ - var posY = y ? (7 - y / 32) : 7; │ │ │ │ - │ │ │ │ - var pos = posY * 8 + posX; │ │ │ │ - href = "http://maps.google.com/mapfiles/kml/pal" + │ │ │ │ - palette + "/icon" + pos + file_extension; │ │ │ │ - } │ │ │ │ - │ │ │ │ - style["graphicOpacity"] = 1; // fully opaque │ │ │ │ - style["externalGraphic"] = href; │ │ │ │ - } │ │ │ │ - │ │ │ │ - } │ │ │ │ │ │ │ │ + // create overview map DOM elements │ │ │ │ + this.element = document.createElement('div'); │ │ │ │ + this.element.className = this.displayClass + 'Element'; │ │ │ │ + this.element.style.display = 'none'; │ │ │ │ │ │ │ │ - // hotSpots define the offset for an Icon │ │ │ │ - var hotSpotNode = this.getElementsByTagNameNS(styleTypeNode, │ │ │ │ - "*", │ │ │ │ - "hotSpot")[0]; │ │ │ │ - if (hotSpotNode) { │ │ │ │ - var x = parseFloat(hotSpotNode.getAttribute("x")); │ │ │ │ - var y = parseFloat(hotSpotNode.getAttribute("y")); │ │ │ │ + this.mapDiv = document.createElement('div'); │ │ │ │ + this.mapDiv.style.width = this.size.w + 'px'; │ │ │ │ + this.mapDiv.style.height = this.size.h + 'px'; │ │ │ │ + this.mapDiv.style.position = 'relative'; │ │ │ │ + this.mapDiv.style.overflow = 'hidden'; │ │ │ │ + this.mapDiv.id = OpenLayers.Util.createUniqueID('overviewMap'); │ │ │ │ │ │ │ │ - var xUnits = hotSpotNode.getAttribute("xunits"); │ │ │ │ - if (xUnits == "pixels") { │ │ │ │ - style["graphicXOffset"] = -x * scale; │ │ │ │ - } else if (xUnits == "insetPixels") { │ │ │ │ - style["graphicXOffset"] = -width + (x * scale); │ │ │ │ - } else if (xUnits == "fraction") { │ │ │ │ - style["graphicXOffset"] = -width * x; │ │ │ │ - } │ │ │ │ + this.extentRectangle = document.createElement('div'); │ │ │ │ + this.extentRectangle.style.position = 'absolute'; │ │ │ │ + this.extentRectangle.style.zIndex = 1000; //HACK │ │ │ │ + this.extentRectangle.className = this.displayClass + 'ExtentRectangle'; │ │ │ │ │ │ │ │ - var yUnits = hotSpotNode.getAttribute("yunits"); │ │ │ │ - if (yUnits == "pixels") { │ │ │ │ - style["graphicYOffset"] = -height + (y * scale) + 1; │ │ │ │ - } else if (yUnits == "insetPixels") { │ │ │ │ - style["graphicYOffset"] = -(y * scale) + 1; │ │ │ │ - } else if (yUnits == "fraction") { │ │ │ │ - style["graphicYOffset"] = -height * (1 - y) + 1; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.element.appendChild(this.mapDiv); │ │ │ │ │ │ │ │ - style["graphicWidth"] = width; │ │ │ │ - style["graphicHeight"] = height; │ │ │ │ - break; │ │ │ │ + this.div.appendChild(this.element); │ │ │ │ │ │ │ │ - case "balloonstyle": │ │ │ │ - var balloonStyle = OpenLayers.Util.getXmlNodeValue( │ │ │ │ - styleTypeNode); │ │ │ │ - if (balloonStyle) { │ │ │ │ - style["balloonStyle"] = balloonStyle.replace( │ │ │ │ - this.regExes.straightBracket, "${$1}"); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "labelstyle": │ │ │ │ - var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ - var color = this.parseKmlColor(kmlColor); │ │ │ │ - if (color) { │ │ │ │ - style["fontColor"] = color.color; │ │ │ │ - style["fontOpacity"] = color.opacity; │ │ │ │ - } │ │ │ │ - break; │ │ │ │ + // Optionally add min/max buttons if the control will go in the │ │ │ │ + // map viewport. │ │ │ │ + if (!this.outsideViewport) { │ │ │ │ + this.div.className += " " + this.displayClass + 'Container'; │ │ │ │ + // maximize button div │ │ │ │ + var img = OpenLayers.Util.getImageLocation('layer-switcher-maximize.png'); │ │ │ │ + this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + this.displayClass + 'MaximizeButton', │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + img, │ │ │ │ + 'absolute'); │ │ │ │ + this.maximizeDiv.style.display = 'none'; │ │ │ │ + this.maximizeDiv.className = this.displayClass + 'MaximizeButton olButton'; │ │ │ │ + if (this.maximizeTitle) { │ │ │ │ + this.maximizeDiv.title = this.maximizeTitle; │ │ │ │ + } │ │ │ │ + this.div.appendChild(this.maximizeDiv); │ │ │ │ │ │ │ │ - default: │ │ │ │ + // minimize button div │ │ │ │ + var img = OpenLayers.Util.getImageLocation('layer-switcher-minimize.png'); │ │ │ │ + this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + 'OpenLayers_Control_minimizeDiv', │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + img, │ │ │ │ + 'absolute'); │ │ │ │ + this.minimizeDiv.style.display = 'none'; │ │ │ │ + this.minimizeDiv.className = this.displayClass + 'MinimizeButton olButton'; │ │ │ │ + if (this.minimizeTitle) { │ │ │ │ + this.minimizeDiv.title = this.minimizeTitle; │ │ │ │ } │ │ │ │ + this.div.appendChild(this.minimizeDiv); │ │ │ │ + this.minimizeControl(); │ │ │ │ + } else { │ │ │ │ + // show the overview map │ │ │ │ + this.element.style.display = ''; │ │ │ │ } │ │ │ │ - │ │ │ │ - // Some polygons have no line color, so we use the fillColor for that │ │ │ │ - if (!style["strokeColor"] && style["fillColor"]) { │ │ │ │ - style["strokeColor"] = style["fillColor"]; │ │ │ │ + if (this.map.getExtent()) { │ │ │ │ + this.update(); │ │ │ │ } │ │ │ │ │ │ │ │ - var id = node.getAttribute("id"); │ │ │ │ - if (id && style) { │ │ │ │ - style.id = id; │ │ │ │ - } │ │ │ │ + this.map.events.on({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + moveend: this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ │ │ │ │ - return style; │ │ │ │ + if (this.maximized) { │ │ │ │ + this.maximizeControl(); │ │ │ │ + } │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseStyleMaps │ │ │ │ - * Parses <StyleMap> nodes, but only uses the 'normal' key │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ - * options - {Object} Hash of options │ │ │ │ - * │ │ │ │ + * Method: baseLayerDraw │ │ │ │ + * Draw the base layer - called if unable to complete in the initial draw │ │ │ │ */ │ │ │ │ - parseStyleMaps: function(nodes, options) { │ │ │ │ - // Only the default or "normal" part of the StyleMap is processed now │ │ │ │ - // To do the select or "highlight" bit, we'd need to change lots more │ │ │ │ - │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var node = nodes[i]; │ │ │ │ - var pairs = this.getElementsByTagNameNS(node, "*", │ │ │ │ - "Pair"); │ │ │ │ - │ │ │ │ - var id = node.getAttribute("id"); │ │ │ │ - for (var j = 0, jlen = pairs.length; j < jlen; j++) { │ │ │ │ - var pair = pairs[j]; │ │ │ │ - // Use the shortcut in the SLD format to quickly retrieve the │ │ │ │ - // value of a node. Maybe it's good to have a method in │ │ │ │ - // Format.XML to do this │ │ │ │ - var key = this.parseProperty(pair, "*", "key"); │ │ │ │ - var styleUrl = this.parseProperty(pair, "*", "styleUrl"); │ │ │ │ - │ │ │ │ - if (styleUrl && key == "normal") { │ │ │ │ - this.styles[(options.styleBaseUrl || "") + "#" + id] = │ │ │ │ - this.styles[(options.styleBaseUrl || "") + styleUrl]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // TODO: implement the "select" part │ │ │ │ - //if (styleUrl && key == "highlight") { │ │ │ │ - //} │ │ │ │ - │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ + baseLayerDraw: function() { │ │ │ │ + this.draw(); │ │ │ │ + this.map.events.unregister("changebaselayer", this, this.baseLayerDraw); │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: parseFeatures │ │ │ │ - * Loop through all Placemark nodes and parse them. │ │ │ │ - * Will create a list of features │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nodes - {Array} of {DOMElement} data to read/parse. │ │ │ │ - * options - {Object} Hash of options │ │ │ │ - * │ │ │ │ + * Method: rectDrag │ │ │ │ + * Handle extent rectangle drag │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} The pixel location of the drag. │ │ │ │ */ │ │ │ │ - parseFeatures: function(nodes, options) { │ │ │ │ - var features = []; │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var featureNode = nodes[i]; │ │ │ │ - var feature = this.parseFeature.apply(this, [featureNode]); │ │ │ │ - if (feature) { │ │ │ │ - │ │ │ │ - // Create reference to styleUrl │ │ │ │ - if (this.extractStyles && feature.attributes && │ │ │ │ - feature.attributes.styleUrl) { │ │ │ │ - feature.style = this.getStyle(feature.attributes.styleUrl, options); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.extractStyles) { │ │ │ │ - // Make sure that <Style> nodes within a placemark are │ │ │ │ - // processed as well │ │ │ │ - var inlineStyleNode = this.getElementsByTagNameNS(featureNode, │ │ │ │ - "*", │ │ │ │ - "Style")[0]; │ │ │ │ - if (inlineStyleNode) { │ │ │ │ - var inlineStyle = this.parseStyle(inlineStyleNode); │ │ │ │ - if (inlineStyle) { │ │ │ │ - feature.style = OpenLayers.Util.extend( │ │ │ │ - feature.style, inlineStyle │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // check if gx:Track elements should be parsed │ │ │ │ - if (this.extractTracks) { │ │ │ │ - var tracks = this.getElementsByTagNameNS( │ │ │ │ - featureNode, this.namespaces.gx, "Track" │ │ │ │ - ); │ │ │ │ - if (tracks && tracks.length > 0) { │ │ │ │ - var track = tracks[0]; │ │ │ │ - var container = { │ │ │ │ - features: [], │ │ │ │ - feature: feature │ │ │ │ - }; │ │ │ │ - this.readNode(track, container); │ │ │ │ - if (container.features.length > 0) { │ │ │ │ - features.push.apply(features, container.features); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // add feature to list of features │ │ │ │ - features.push(feature); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - throw "Bad Placemark: " + i; │ │ │ │ - } │ │ │ │ + rectDrag: function(px) { │ │ │ │ + var deltaX = this.handlers.drag.last.x - px.x; │ │ │ │ + var deltaY = this.handlers.drag.last.y - px.y; │ │ │ │ + if (deltaX != 0 || deltaY != 0) { │ │ │ │ + var rectTop = this.rectPxBounds.top; │ │ │ │ + var rectLeft = this.rectPxBounds.left; │ │ │ │ + var rectHeight = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ + var rectWidth = this.rectPxBounds.getWidth(); │ │ │ │ + // don't allow dragging off of parent element │ │ │ │ + var newTop = Math.max(0, (rectTop - deltaY)); │ │ │ │ + newTop = Math.min(newTop, │ │ │ │ + this.ovmap.size.h - this.hComp - rectHeight); │ │ │ │ + var newLeft = Math.max(0, (rectLeft - deltaX)); │ │ │ │ + newLeft = Math.min(newLeft, │ │ │ │ + this.ovmap.size.w - this.wComp - rectWidth); │ │ │ │ + this.setRectPxBounds(new OpenLayers.Bounds(newLeft, │ │ │ │ + newTop + rectHeight, │ │ │ │ + newLeft + rectWidth, │ │ │ │ + newTop)); │ │ │ │ } │ │ │ │ - │ │ │ │ - // add new features to existing feature list │ │ │ │ - this.features = this.features.concat(features); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ + * Method: mapDivClick │ │ │ │ + * Handle browser events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} evt │ │ │ │ */ │ │ │ │ - readers: { │ │ │ │ - "kml": { │ │ │ │ - "when": function(node, container) { │ │ │ │ - container.whens.push(OpenLayers.Date.parse( │ │ │ │ - this.getChildValue(node) │ │ │ │ - )); │ │ │ │ - }, │ │ │ │ - "_trackPointAttribute": function(node, container) { │ │ │ │ - var name = node.nodeName.split(":").pop(); │ │ │ │ - container.attributes[name].push(this.getChildValue(node)); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "gx": { │ │ │ │ - "Track": function(node, container) { │ │ │ │ - var obj = { │ │ │ │ - whens: [], │ │ │ │ - points: [], │ │ │ │ - angles: [] │ │ │ │ - }; │ │ │ │ - if (this.trackAttributes) { │ │ │ │ - var name; │ │ │ │ - obj.attributes = {}; │ │ │ │ - for (var i = 0, ii = this.trackAttributes.length; i < ii; ++i) { │ │ │ │ - name = this.trackAttributes[i]; │ │ │ │ - obj.attributes[name] = []; │ │ │ │ - if (!(name in this.readers.kml)) { │ │ │ │ - this.readers.kml[name] = this.readers.kml._trackPointAttribute; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - if (obj.whens.length !== obj.points.length) { │ │ │ │ - throw new Error("gx:Track with unequal number of when (" + │ │ │ │ - obj.whens.length + ") and gx:coord (" + │ │ │ │ - obj.points.length + ") elements."); │ │ │ │ - } │ │ │ │ - var hasAngles = obj.angles.length > 0; │ │ │ │ - if (hasAngles && obj.whens.length !== obj.angles.length) { │ │ │ │ - throw new Error("gx:Track with unequal number of when (" + │ │ │ │ - obj.whens.length + ") and gx:angles (" + │ │ │ │ - obj.angles.length + ") elements."); │ │ │ │ - } │ │ │ │ - var feature, point, angles; │ │ │ │ - for (var i = 0, ii = obj.whens.length; i < ii; ++i) { │ │ │ │ - feature = container.feature.clone(); │ │ │ │ - feature.fid = container.feature.fid || container.feature.id; │ │ │ │ - point = obj.points[i]; │ │ │ │ - feature.geometry = point; │ │ │ │ - if ("z" in point) { │ │ │ │ - feature.attributes.altitude = point.z; │ │ │ │ - } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - feature.geometry.transform( │ │ │ │ - this.externalProjection, this.internalProjection │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (this.trackAttributes) { │ │ │ │ - for (var j = 0, jj = this.trackAttributes.length; j < jj; ++j) { │ │ │ │ - var name = this.trackAttributes[j]; │ │ │ │ - feature.attributes[name] = obj.attributes[name][i]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - feature.attributes.when = obj.whens[i]; │ │ │ │ - feature.attributes.trackId = container.feature.id; │ │ │ │ - if (hasAngles) { │ │ │ │ - angles = obj.angles[i]; │ │ │ │ - feature.attributes.heading = parseFloat(angles[0]); │ │ │ │ - feature.attributes.tilt = parseFloat(angles[1]); │ │ │ │ - feature.attributes.roll = parseFloat(angles[2]); │ │ │ │ - } │ │ │ │ - container.features.push(feature); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "coord": function(node, container) { │ │ │ │ - var str = this.getChildValue(node); │ │ │ │ - var coords = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ - var point = new OpenLayers.Geometry.Point(coords[0], coords[1]); │ │ │ │ - if (coords.length > 2) { │ │ │ │ - point.z = parseFloat(coords[2]); │ │ │ │ - } │ │ │ │ - container.points.push(point); │ │ │ │ - }, │ │ │ │ - "angles": function(node, container) { │ │ │ │ - var str = this.getChildValue(node); │ │ │ │ - var parts = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ - container.angles.push(parts); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + mapDivClick: function(evt) { │ │ │ │ + var pxCenter = this.rectPxBounds.getCenterPixel(); │ │ │ │ + var deltaX = evt.xy.x - pxCenter.x; │ │ │ │ + var deltaY = evt.xy.y - pxCenter.y; │ │ │ │ + var top = this.rectPxBounds.top; │ │ │ │ + var left = this.rectPxBounds.left; │ │ │ │ + var height = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ + var width = this.rectPxBounds.getWidth(); │ │ │ │ + var newTop = Math.max(0, (top + deltaY)); │ │ │ │ + newTop = Math.min(newTop, this.ovmap.size.h - height); │ │ │ │ + var newLeft = Math.max(0, (left + deltaX)); │ │ │ │ + newLeft = Math.min(newLeft, this.ovmap.size.w - width); │ │ │ │ + this.setRectPxBounds(new OpenLayers.Bounds(newLeft, │ │ │ │ + newTop + height, │ │ │ │ + newLeft + width, │ │ │ │ + newTop)); │ │ │ │ + this.updateMapToRect(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeature │ │ │ │ - * This function is the core of the KML parsing code in OpenLayers. │ │ │ │ - * It creates the geometries that are then attached to the returned │ │ │ │ - * feature, and calls parseAttributes() to get attribute data out. │ │ │ │ + * Method: onButtonClick │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} A vector feature. │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - parseFeature: function(node) { │ │ │ │ - // only accept one geometry per feature - look for highest "order" │ │ │ │ - var order = ["MultiGeometry", "Polygon", "LineString", "Point"]; │ │ │ │ - var type, nodeList, geometry, parser; │ │ │ │ - for (var i = 0, len = order.length; i < len; ++i) { │ │ │ │ - type = order[i]; │ │ │ │ - this.internalns = node.namespaceURI ? │ │ │ │ - node.namespaceURI : this.kmlns; │ │ │ │ - nodeList = this.getElementsByTagNameNS(node, │ │ │ │ - this.internalns, type); │ │ │ │ - if (nodeList.length > 0) { │ │ │ │ - // only deal with first geometry of this type │ │ │ │ - var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ - if (parser) { │ │ │ │ - geometry = parser.apply(this, [nodeList[0]]); │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - throw new TypeError("Unsupported geometry type: " + type); │ │ │ │ - } │ │ │ │ - // stop looking for different geometry types │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // construct feature (optionally with attributes) │ │ │ │ - var attributes; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attributes = this.parseAttributes(node); │ │ │ │ - } │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, attributes); │ │ │ │ - │ │ │ │ - var fid = node.getAttribute("id") || node.getAttribute("name"); │ │ │ │ - if (fid != null) { │ │ │ │ - feature.fid = fid; │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + if (evt.buttonElement === this.minimizeDiv) { │ │ │ │ + this.minimizeControl(); │ │ │ │ + } else if (evt.buttonElement === this.maximizeDiv) { │ │ │ │ + this.maximizeControl(); │ │ │ │ } │ │ │ │ - │ │ │ │ - return feature; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getStyle │ │ │ │ - * Retrieves a style from a style hash using styleUrl as the key │ │ │ │ - * If the styleUrl doesn't exist yet, we try to fetch it │ │ │ │ - * Internet │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * styleUrl - {String} URL of style │ │ │ │ - * options - {Object} Hash of options │ │ │ │ + * Method: maximizeControl │ │ │ │ + * Unhide the control. Called when the control is in the map viewport. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Object} - (reference to) Style hash │ │ │ │ + * Parameters: │ │ │ │ + * e - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - getStyle: function(styleUrl, options) { │ │ │ │ - │ │ │ │ - var styleBaseUrl = OpenLayers.Util.removeTail(styleUrl); │ │ │ │ - │ │ │ │ - var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ - newOptions.depth++; │ │ │ │ - newOptions.styleBaseUrl = styleBaseUrl; │ │ │ │ - │ │ │ │ - // Fetch remote Style URLs (if not fetched before) │ │ │ │ - if (!this.styles[styleUrl] && │ │ │ │ - !OpenLayers.String.startsWith(styleUrl, "#") && │ │ │ │ - newOptions.depth <= this.maxDepth && │ │ │ │ - !this.fetched[styleBaseUrl]) { │ │ │ │ - │ │ │ │ - var data = this.fetchLink(styleBaseUrl); │ │ │ │ - if (data) { │ │ │ │ - this.parseData(data, newOptions); │ │ │ │ - } │ │ │ │ - │ │ │ │ + maximizeControl: function(e) { │ │ │ │ + this.element.style.display = ''; │ │ │ │ + this.showToggle(false); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ } │ │ │ │ - │ │ │ │ - // return requested style │ │ │ │ - var style = OpenLayers.Util.extend({}, this.styles[styleUrl]); │ │ │ │ - return style; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: parseGeometry │ │ │ │ - * Properties of this object are the functions that parse geometries based │ │ │ │ - * on their type. │ │ │ │ + * Method: minimizeControl │ │ │ │ + * Hide all the contents of the control, shrink the size, │ │ │ │ + * add the maximize icon │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * e - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - parseGeometry: { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseGeometry.point │ │ │ │ - * Given a KML node representing a point geometry, create an OpenLayers │ │ │ │ - * point geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} A KML Point node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} A point geometry. │ │ │ │ - */ │ │ │ │ - point: function(node) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, this.internalns, │ │ │ │ - "coordinates"); │ │ │ │ - var coords = []; │ │ │ │ - if (nodeList.length > 0) { │ │ │ │ - var coordString = nodeList[0].firstChild.nodeValue; │ │ │ │ - coordString = coordString.replace(this.regExes.removeSpace, ""); │ │ │ │ - coords = coordString.split(","); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var point = null; │ │ │ │ - if (coords.length > 1) { │ │ │ │ - // preserve third dimension │ │ │ │ - if (coords.length == 2) { │ │ │ │ - coords[2] = null; │ │ │ │ - } │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[0], coords[1], │ │ │ │ - coords[2]); │ │ │ │ - } else { │ │ │ │ - throw "Bad coordinate string: " + coordString; │ │ │ │ - } │ │ │ │ - return point; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseGeometry.linestring │ │ │ │ - * Given a KML node representing a linestring geometry, create an │ │ │ │ - * OpenLayers linestring geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} A KML LineString node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.LineString>} A linestring geometry. │ │ │ │ - */ │ │ │ │ - linestring: function(node, ring) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, this.internalns, │ │ │ │ - "coordinates"); │ │ │ │ - var line = null; │ │ │ │ - if (nodeList.length > 0) { │ │ │ │ - var coordString = this.getChildValue(nodeList[0]); │ │ │ │ - │ │ │ │ - coordString = coordString.replace(this.regExes.trimSpace, │ │ │ │ - ""); │ │ │ │ - coordString = coordString.replace(this.regExes.trimComma, │ │ │ │ - ","); │ │ │ │ - var pointList = coordString.split(this.regExes.splitSpace); │ │ │ │ - var numPoints = pointList.length; │ │ │ │ - var points = new Array(numPoints); │ │ │ │ - var coords, numCoords; │ │ │ │ - for (var i = 0; i < numPoints; ++i) { │ │ │ │ - coords = pointList[i].split(","); │ │ │ │ - numCoords = coords.length; │ │ │ │ - if (numCoords > 1) { │ │ │ │ - if (coords.length == 2) { │ │ │ │ - coords[2] = null; │ │ │ │ - } │ │ │ │ - points[i] = new OpenLayers.Geometry.Point(coords[0], │ │ │ │ - coords[1], │ │ │ │ - coords[2]); │ │ │ │ - } else { │ │ │ │ - throw "Bad LineString point coordinates: " + │ │ │ │ - pointList[i]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (numPoints) { │ │ │ │ - if (ring) { │ │ │ │ - line = new OpenLayers.Geometry.LinearRing(points); │ │ │ │ - } else { │ │ │ │ - line = new OpenLayers.Geometry.LineString(points); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - throw "Bad LineString coordinates: " + coordString; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - return line; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseGeometry.polygon │ │ │ │ - * Given a KML node representing a polygon geometry, create an │ │ │ │ - * OpenLayers polygon geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} A KML Polygon node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Polygon>} A polygon geometry. │ │ │ │ - */ │ │ │ │ - polygon: function(node) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, this.internalns, │ │ │ │ - "LinearRing"); │ │ │ │ - var numRings = nodeList.length; │ │ │ │ - var components = new Array(numRings); │ │ │ │ - if (numRings > 0) { │ │ │ │ - // this assumes exterior ring first, inner rings after │ │ │ │ - var ring; │ │ │ │ - for (var i = 0, len = nodeList.length; i < len; ++i) { │ │ │ │ - ring = this.parseGeometry.linestring.apply(this, │ │ │ │ - [nodeList[i], true]); │ │ │ │ - if (ring) { │ │ │ │ - components[i] = ring; │ │ │ │ - } else { │ │ │ │ - throw "Bad LinearRing geometry: " + i; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.Polygon(components); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseGeometry.multigeometry │ │ │ │ - * Given a KML node representing a multigeometry, create an │ │ │ │ - * OpenLayers geometry collection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} A KML MultiGeometry node. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Collection>} A geometry collection. │ │ │ │ - */ │ │ │ │ - multigeometry: function(node) { │ │ │ │ - var child, parser; │ │ │ │ - var parts = []; │ │ │ │ - var children = node.childNodes; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - var type = (child.prefix) ? │ │ │ │ - child.nodeName.split(":")[1] : │ │ │ │ - child.nodeName; │ │ │ │ - var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ - if (parser) { │ │ │ │ - parts.push(parser.apply(this, [child])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.Collection(parts); │ │ │ │ + minimizeControl: function(e) { │ │ │ │ + this.element.style.display = 'none'; │ │ │ │ + this.showToggle(true); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ } │ │ │ │ - │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseAttributes │ │ │ │ + * Method: showToggle │ │ │ │ + * Hide/Show the toggle depending on whether the control is minimized │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An attributes object. │ │ │ │ + * minimize - {Boolean} │ │ │ │ */ │ │ │ │ - parseAttributes: function(node) { │ │ │ │ - var attributes = {}; │ │ │ │ - │ │ │ │ - // Extended Data is parsed first. │ │ │ │ - var edNodes = node.getElementsByTagName("ExtendedData"); │ │ │ │ - if (edNodes.length) { │ │ │ │ - attributes = this.parseExtendedData(edNodes[0]); │ │ │ │ + showToggle: function(minimize) { │ │ │ │ + if (this.maximizeDiv) { │ │ │ │ + this.maximizeDiv.style.display = minimize ? '' : 'none'; │ │ │ │ } │ │ │ │ - │ │ │ │ - // assume attribute nodes are type 1 children with a type 3 or 4 child │ │ │ │ - var child, grandchildren, grandchild; │ │ │ │ - var children = node.childNodes; │ │ │ │ - │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - grandchildren = child.childNodes; │ │ │ │ - if (grandchildren.length >= 1 && grandchildren.length <= 3) { │ │ │ │ - var grandchild; │ │ │ │ - switch (grandchildren.length) { │ │ │ │ - case 1: │ │ │ │ - grandchild = grandchildren[0]; │ │ │ │ - break; │ │ │ │ - case 2: │ │ │ │ - var c1 = grandchildren[0]; │ │ │ │ - var c2 = grandchildren[1]; │ │ │ │ - grandchild = (c1.nodeType == 3 || c1.nodeType == 4) ? │ │ │ │ - c1 : c2; │ │ │ │ - break; │ │ │ │ - case 3: │ │ │ │ - default: │ │ │ │ - grandchild = grandchildren[1]; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - if (grandchild.nodeType == 3 || grandchild.nodeType == 4) { │ │ │ │ - var name = (child.prefix) ? │ │ │ │ - child.nodeName.split(":")[1] : │ │ │ │ - child.nodeName; │ │ │ │ - var value = OpenLayers.Util.getXmlNodeValue(grandchild); │ │ │ │ - if (value) { │ │ │ │ - value = value.replace(this.regExes.trimSpace, ""); │ │ │ │ - attributes[name] = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (this.minimizeDiv) { │ │ │ │ + this.minimizeDiv.style.display = minimize ? 'none' : ''; │ │ │ │ } │ │ │ │ - return attributes; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseExtendedData │ │ │ │ - * Parse ExtendedData from KML. Limited support for schemas/datatypes. │ │ │ │ - * See http://code.google.com/apis/kml/documentation/kmlreference.html#extendeddata │ │ │ │ - * for more information on extendeddata. │ │ │ │ + * Method: update │ │ │ │ + * Update the overview map after layers move. │ │ │ │ */ │ │ │ │ - parseExtendedData: function(node) { │ │ │ │ - var attributes = {}; │ │ │ │ - var i, len, data, key; │ │ │ │ - var dataNodes = node.getElementsByTagName("Data"); │ │ │ │ - for (i = 0, len = dataNodes.length; i < len; i++) { │ │ │ │ - data = dataNodes[i]; │ │ │ │ - key = data.getAttribute("name"); │ │ │ │ - var ed = {}; │ │ │ │ - var valueNode = data.getElementsByTagName("value"); │ │ │ │ - if (valueNode.length) { │ │ │ │ - ed['value'] = this.getChildValue(valueNode[0]); │ │ │ │ - } │ │ │ │ - if (this.kvpAttributes) { │ │ │ │ - attributes[key] = ed['value']; │ │ │ │ - } else { │ │ │ │ - var nameNode = data.getElementsByTagName("displayName"); │ │ │ │ - if (nameNode.length) { │ │ │ │ - ed['displayName'] = this.getChildValue(nameNode[0]); │ │ │ │ - } │ │ │ │ - attributes[key] = ed; │ │ │ │ - } │ │ │ │ + update: function() { │ │ │ │ + if (this.ovmap == null) { │ │ │ │ + this.createMap(); │ │ │ │ } │ │ │ │ - var simpleDataNodes = node.getElementsByTagName("SimpleData"); │ │ │ │ - for (i = 0, len = simpleDataNodes.length; i < len; i++) { │ │ │ │ - var ed = {}; │ │ │ │ - data = simpleDataNodes[i]; │ │ │ │ - key = data.getAttribute("name"); │ │ │ │ - ed['value'] = this.getChildValue(data); │ │ │ │ - if (this.kvpAttributes) { │ │ │ │ - attributes[key] = ed['value']; │ │ │ │ - } else { │ │ │ │ - ed['displayName'] = key; │ │ │ │ - attributes[key] = ed; │ │ │ │ - } │ │ │ │ + │ │ │ │ + if (this.autoPan || !this.isSuitableOverview()) { │ │ │ │ + this.updateOverview(); │ │ │ │ } │ │ │ │ │ │ │ │ - return attributes; │ │ │ │ + // update extent rectangle │ │ │ │ + this.updateRectToMap(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseProperty │ │ │ │ - * Convenience method to find a node and return its value │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * xmlNode - {<DOMElement>} │ │ │ │ - * namespace - {String} namespace of the node to find │ │ │ │ - * tagName - {String} name of the property to parse │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The value for the requested property (defaults to null) │ │ │ │ + * Method: isSuitableOverview │ │ │ │ + * Determines if the overview map is suitable given the extent and │ │ │ │ + * resolution of the main map. │ │ │ │ */ │ │ │ │ - parseProperty: function(xmlNode, namespace, tagName) { │ │ │ │ - var value; │ │ │ │ - var nodeList = this.getElementsByTagNameNS(xmlNode, namespace, tagName); │ │ │ │ - try { │ │ │ │ - value = OpenLayers.Util.getXmlNodeValue(nodeList[0]); │ │ │ │ - } catch (e) { │ │ │ │ - value = null; │ │ │ │ + isSuitableOverview: function() { │ │ │ │ + var mapExtent = this.map.getExtent(); │ │ │ │ + var maxExtent = this.map.getMaxExtent(); │ │ │ │ + var testExtent = new OpenLayers.Bounds( │ │ │ │ + Math.max(mapExtent.left, maxExtent.left), │ │ │ │ + Math.max(mapExtent.bottom, maxExtent.bottom), │ │ │ │ + Math.min(mapExtent.right, maxExtent.right), │ │ │ │ + Math.min(mapExtent.top, maxExtent.top)); │ │ │ │ + │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + testExtent = testExtent.transform( │ │ │ │ + this.map.getProjectionObject(), │ │ │ │ + this.ovmap.getProjectionObject()); │ │ │ │ } │ │ │ │ │ │ │ │ - return value; │ │ │ │ + var resRatio = this.ovmap.getResolution() / this.map.getResolution(); │ │ │ │ + return ((resRatio > this.minRatio) && │ │ │ │ + (resRatio <= this.maxRatio) && │ │ │ │ + (this.ovmap.getExtent().containsBounds(testExtent))); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Accept Feature Collection, and return a string. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} An array of features. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A KML string. │ │ │ │ + * Method updateOverview │ │ │ │ + * Called by <update> if <isSuitableOverview> returns true │ │ │ │ */ │ │ │ │ - write: function(features) { │ │ │ │ - if (!(OpenLayers.Util.isArray(features))) { │ │ │ │ - features = [features]; │ │ │ │ + updateOverview: function() { │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + var targetRes = this.ovmap.getResolution(); │ │ │ │ + var resRatio = targetRes / mapRes; │ │ │ │ + if (resRatio > this.maxRatio) { │ │ │ │ + // zoom in overview map │ │ │ │ + targetRes = this.minRatio * mapRes; │ │ │ │ + } else if (resRatio <= this.minRatio) { │ │ │ │ + // zoom out overview map │ │ │ │ + targetRes = this.maxRatio * mapRes; │ │ │ │ } │ │ │ │ - var kml = this.createElementNS(this.kmlns, "kml"); │ │ │ │ - var folder = this.createFolderXML(); │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - folder.appendChild(this.createPlacemarkXML(features[i])); │ │ │ │ + var center; │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + center = this.map.center.clone(); │ │ │ │ + center.transform(this.map.getProjectionObject(), │ │ │ │ + this.ovmap.getProjectionObject()); │ │ │ │ + } else { │ │ │ │ + center = this.map.center; │ │ │ │ } │ │ │ │ - kml.appendChild(folder); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [kml]); │ │ │ │ + this.ovmap.setCenter(center, this.ovmap.getZoomForResolution( │ │ │ │ + targetRes * this.resolutionFactor)); │ │ │ │ + this.updateRectToMap(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFolderXML │ │ │ │ - * Creates and returns a KML folder node │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: createMap │ │ │ │ + * Construct the map that this control contains │ │ │ │ */ │ │ │ │ - createFolderXML: function() { │ │ │ │ - // Folder │ │ │ │ - var folder = this.createElementNS(this.kmlns, "Folder"); │ │ │ │ + createMap: function() { │ │ │ │ + // create the overview map │ │ │ │ + var options = OpenLayers.Util.extend({ │ │ │ │ + controls: [], │ │ │ │ + maxResolution: 'auto', │ │ │ │ + fallThrough: false │ │ │ │ + }, this.mapOptions); │ │ │ │ + this.ovmap = new OpenLayers.Map(this.mapDiv, options); │ │ │ │ + this.ovmap.viewPortDiv.appendChild(this.extentRectangle); │ │ │ │ │ │ │ │ - // Folder name │ │ │ │ - if (this.foldersName) { │ │ │ │ - var folderName = this.createElementNS(this.kmlns, "name"); │ │ │ │ - var folderNameText = this.createTextNode(this.foldersName); │ │ │ │ - folderName.appendChild(folderNameText); │ │ │ │ - folder.appendChild(folderName); │ │ │ │ - } │ │ │ │ + // prevent ovmap from being destroyed when the page unloads, because │ │ │ │ + // the OverviewMap control has to do this (and does it). │ │ │ │ + OpenLayers.Event.stopObserving(window, 'unload', this.ovmap.unloadDestroy); │ │ │ │ │ │ │ │ - // Folder description │ │ │ │ - if (this.foldersDesc) { │ │ │ │ - var folderDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ - var folderDescText = this.createTextNode(this.foldersDesc); │ │ │ │ - folderDesc.appendChild(folderDescText); │ │ │ │ - folder.appendChild(folderDesc); │ │ │ │ - } │ │ │ │ + this.ovmap.addLayers(this.layers); │ │ │ │ + this.ovmap.zoomToMaxExtent(); │ │ │ │ + // check extent rectangle border width │ │ │ │ + this.wComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ + 'border-left-width')) + │ │ │ │ + parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ + 'border-right-width')); │ │ │ │ + this.wComp = (this.wComp) ? this.wComp : 2; │ │ │ │ + this.hComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ + 'border-top-width')) + │ │ │ │ + parseInt(OpenLayers.Element.getStyle(this.extentRectangle, │ │ │ │ + 'border-bottom-width')); │ │ │ │ + this.hComp = (this.hComp) ? this.hComp : 2; │ │ │ │ │ │ │ │ - return folder; │ │ │ │ + this.handlers.drag = new OpenLayers.Handler.Drag( │ │ │ │ + this, { │ │ │ │ + move: this.rectDrag, │ │ │ │ + done: this.updateMapToRect │ │ │ │ + }, { │ │ │ │ + map: this.ovmap │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ + this, { │ │ │ │ + "click": this.mapDivClick │ │ │ │ + }, { │ │ │ │ + "single": true, │ │ │ │ + "double": false, │ │ │ │ + "stopSingle": true, │ │ │ │ + "stopDouble": true, │ │ │ │ + "pixelTolerance": 1, │ │ │ │ + map: this.ovmap │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + │ │ │ │ + this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, │ │ │ │ + null, true); │ │ │ │ + this.rectEvents.register("mouseover", this, function(e) { │ │ │ │ + if (!this.handlers.drag.active && !this.map.dragging) { │ │ │ │ + this.handlers.drag.activate(); │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.rectEvents.register("mouseout", this, function(e) { │ │ │ │ + if (!this.handlers.drag.dragging) { │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + var sourceUnits = this.map.getProjectionObject().getUnits() || │ │ │ │ + this.map.units || this.map.baseLayer.units; │ │ │ │ + var targetUnits = this.ovmap.getProjectionObject().getUnits() || │ │ │ │ + this.ovmap.units || this.ovmap.baseLayer.units; │ │ │ │ + this.resolutionFactor = sourceUnits && targetUnits ? │ │ │ │ + OpenLayers.INCHES_PER_UNIT[sourceUnits] / │ │ │ │ + OpenLayers.INCHES_PER_UNIT[targetUnits] : 1; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createPlacemarkXML │ │ │ │ - * Creates and returns a KML placemark node representing the given feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: updateRectToMap │ │ │ │ + * Updates the extent rectangle position and size to match the map extent │ │ │ │ */ │ │ │ │ - createPlacemarkXML: function(feature) { │ │ │ │ - // Placemark name │ │ │ │ - var placemarkName = this.createElementNS(this.kmlns, "name"); │ │ │ │ - var label = (feature.style && feature.style.label) ? feature.style.label : feature.id; │ │ │ │ - var name = feature.attributes.name || label; │ │ │ │ - placemarkName.appendChild(this.createTextNode(name)); │ │ │ │ - │ │ │ │ - // Placemark description │ │ │ │ - var placemarkDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ - var desc = feature.attributes.description || this.placemarksDesc; │ │ │ │ - placemarkDesc.appendChild(this.createTextNode(desc)); │ │ │ │ - │ │ │ │ - // Placemark │ │ │ │ - var placemarkNode = this.createElementNS(this.kmlns, "Placemark"); │ │ │ │ - if (feature.fid != null) { │ │ │ │ - placemarkNode.setAttribute("id", feature.fid); │ │ │ │ + updateRectToMap: function() { │ │ │ │ + // If the projections differ we need to reproject │ │ │ │ + var bounds; │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + bounds = this.map.getExtent().transform( │ │ │ │ + this.map.getProjectionObject(), │ │ │ │ + this.ovmap.getProjectionObject()); │ │ │ │ + } else { │ │ │ │ + bounds = this.map.getExtent(); │ │ │ │ } │ │ │ │ - placemarkNode.appendChild(placemarkName); │ │ │ │ - placemarkNode.appendChild(placemarkDesc); │ │ │ │ - │ │ │ │ - // Geometry node (Point, LineString, etc. nodes) │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - placemarkNode.appendChild(geometryNode); │ │ │ │ - │ │ │ │ - // output attributes as extendedData │ │ │ │ - if (feature.attributes) { │ │ │ │ - var edNode = this.buildExtendedData(feature.attributes); │ │ │ │ - if (edNode) { │ │ │ │ - placemarkNode.appendChild(edNode); │ │ │ │ - } │ │ │ │ + var pxBounds = this.getRectBoundsFromMapBounds(bounds); │ │ │ │ + if (pxBounds) { │ │ │ │ + this.setRectPxBounds(pxBounds); │ │ │ │ } │ │ │ │ - │ │ │ │ - return placemarkNode; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildGeometryNode │ │ │ │ - * Builds and returns a KML geometry node with the given geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: updateMapToRect │ │ │ │ + * Updates the map extent to match the extent rectangle position and size │ │ │ │ */ │ │ │ │ - buildGeometryNode: function(geometry) { │ │ │ │ - var className = geometry.CLASS_NAME; │ │ │ │ - var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ - var builder = this.buildGeometry[type.toLowerCase()]; │ │ │ │ - var node = null; │ │ │ │ - if (builder) { │ │ │ │ - node = builder.apply(this, [geometry]); │ │ │ │ + updateMapToRect: function() { │ │ │ │ + var lonLatBounds = this.getMapBoundsFromRectBounds(this.rectPxBounds); │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + lonLatBounds = lonLatBounds.transform( │ │ │ │ + this.ovmap.getProjectionObject(), │ │ │ │ + this.map.getProjectionObject()); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ + this.map.panTo(lonLatBounds.getCenterLonLat()); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: buildGeometry │ │ │ │ - * Object containing methods to do the actual geometry node building │ │ │ │ - * based on geometry type. │ │ │ │ + * Method: setRectPxBounds │ │ │ │ + * Set extent rectangle pixel bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * pxBounds - {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - buildGeometry: { │ │ │ │ - // TBD: Anybody care about namespace aliases here (these nodes have │ │ │ │ - // no prefixes)? │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.point │ │ │ │ - * Given an OpenLayers point geometry, create a KML point. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Point>} A point geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML point node. │ │ │ │ - */ │ │ │ │ - point: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "Point"); │ │ │ │ - kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - return kml; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.multipoint │ │ │ │ - * Given an OpenLayers multipoint geometry, create a KML │ │ │ │ - * GeometryCollection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Point>} A multipoint geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML GeometryCollection node. │ │ │ │ - */ │ │ │ │ - multipoint: function(geometry) { │ │ │ │ - return this.buildGeometry.collection.apply(this, [geometry]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.linestring │ │ │ │ - * Given an OpenLayers linestring geometry, create a KML linestring. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.LineString>} A linestring geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML linestring node. │ │ │ │ - */ │ │ │ │ - linestring: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "LineString"); │ │ │ │ - kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - return kml; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.multilinestring │ │ │ │ - * Given an OpenLayers multilinestring geometry, create a KML │ │ │ │ - * GeometryCollection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Point>} A multilinestring geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML GeometryCollection node. │ │ │ │ - */ │ │ │ │ - multilinestring: function(geometry) { │ │ │ │ - return this.buildGeometry.collection.apply(this, [geometry]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.linearring │ │ │ │ - * Given an OpenLayers linearring geometry, create a KML linearring. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.LinearRing>} A linearring geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML linearring node. │ │ │ │ - */ │ │ │ │ - linearring: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "LinearRing"); │ │ │ │ - kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - return kml; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.polygon │ │ │ │ - * Given an OpenLayers polygon geometry, create a KML polygon. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Polygon>} A polygon geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML polygon node. │ │ │ │ - */ │ │ │ │ - polygon: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "Polygon"); │ │ │ │ - var rings = geometry.components; │ │ │ │ - var ringMember, ringGeom, type; │ │ │ │ - for (var i = 0, len = rings.length; i < len; ++i) { │ │ │ │ - type = (i == 0) ? "outerBoundaryIs" : "innerBoundaryIs"; │ │ │ │ - ringMember = this.createElementNS(this.kmlns, type); │ │ │ │ - ringGeom = this.buildGeometry.linearring.apply(this, │ │ │ │ - [rings[i]]); │ │ │ │ - ringMember.appendChild(ringGeom); │ │ │ │ - kml.appendChild(ringMember); │ │ │ │ - } │ │ │ │ - return kml; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.multipolygon │ │ │ │ - * Given an OpenLayers multipolygon geometry, create a KML │ │ │ │ - * GeometryCollection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Point>} A multipolygon geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML GeometryCollection node. │ │ │ │ - */ │ │ │ │ - multipolygon: function(geometry) { │ │ │ │ - return this.buildGeometry.collection.apply(this, [geometry]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: buildGeometry.collection │ │ │ │ - * Given an OpenLayers geometry collection, create a KML MultiGeometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry.Collection>} A geometry collection. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A KML MultiGeometry node. │ │ │ │ - */ │ │ │ │ - collection: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "MultiGeometry"); │ │ │ │ - var child; │ │ │ │ - for (var i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ - child = this.buildGeometryNode.apply(this, │ │ │ │ - [geometry.components[i]]); │ │ │ │ - if (child) { │ │ │ │ - kml.appendChild(child); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return kml; │ │ │ │ + setRectPxBounds: function(pxBounds) { │ │ │ │ + var top = Math.max(pxBounds.top, 0); │ │ │ │ + var left = Math.max(pxBounds.left, 0); │ │ │ │ + var bottom = Math.min(pxBounds.top + Math.abs(pxBounds.getHeight()), │ │ │ │ + this.ovmap.size.h - this.hComp); │ │ │ │ + var right = Math.min(pxBounds.left + pxBounds.getWidth(), │ │ │ │ + this.ovmap.size.w - this.wComp); │ │ │ │ + var width = Math.max(right - left, 0); │ │ │ │ + var height = Math.max(bottom - top, 0); │ │ │ │ + if (width < this.minRectSize || height < this.minRectSize) { │ │ │ │ + this.extentRectangle.className = this.displayClass + │ │ │ │ + this.minRectDisplayClass; │ │ │ │ + var rLeft = left + (width / 2) - (this.minRectSize / 2); │ │ │ │ + var rTop = top + (height / 2) - (this.minRectSize / 2); │ │ │ │ + this.extentRectangle.style.top = Math.round(rTop) + 'px'; │ │ │ │ + this.extentRectangle.style.left = Math.round(rLeft) + 'px'; │ │ │ │ + this.extentRectangle.style.height = this.minRectSize + 'px'; │ │ │ │ + this.extentRectangle.style.width = this.minRectSize + 'px'; │ │ │ │ + } else { │ │ │ │ + this.extentRectangle.className = this.displayClass + │ │ │ │ + 'ExtentRectangle'; │ │ │ │ + this.extentRectangle.style.top = Math.round(top) + 'px'; │ │ │ │ + this.extentRectangle.style.left = Math.round(left) + 'px'; │ │ │ │ + this.extentRectangle.style.height = Math.round(height) + 'px'; │ │ │ │ + this.extentRectangle.style.width = Math.round(width) + 'px'; │ │ │ │ } │ │ │ │ + this.rectPxBounds = new OpenLayers.Bounds( │ │ │ │ + Math.round(left), Math.round(bottom), │ │ │ │ + Math.round(right), Math.round(top) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildCoordinatesNode │ │ │ │ - * Builds and returns the KML coordinates node with the given geometry │ │ │ │ - * <coordinates>...</coordinates> │ │ │ │ - * │ │ │ │ + * Method: getRectBoundsFromMapBounds │ │ │ │ + * Get the rect bounds from the map bounds. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ + * lonLatBounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * {<OpenLayers.Bounds>}A bounds which is the passed-in map lon/lat extent │ │ │ │ + * translated into pixel bounds for the overview map │ │ │ │ */ │ │ │ │ - buildCoordinatesNode: function(geometry) { │ │ │ │ - var coordinatesNode = this.createElementNS(this.kmlns, "coordinates"); │ │ │ │ - │ │ │ │ - var path; │ │ │ │ - var points = geometry.components; │ │ │ │ - if (points) { │ │ │ │ - // LineString or LinearRing │ │ │ │ - var point; │ │ │ │ - var numPoints = points.length; │ │ │ │ - var parts = new Array(numPoints); │ │ │ │ - for (var i = 0; i < numPoints; ++i) { │ │ │ │ - point = points[i]; │ │ │ │ - parts[i] = this.buildCoordinates(point); │ │ │ │ - } │ │ │ │ - path = parts.join(" "); │ │ │ │ - } else { │ │ │ │ - // Point │ │ │ │ - path = this.buildCoordinates(geometry); │ │ │ │ + getRectBoundsFromMapBounds: function(lonLatBounds) { │ │ │ │ + var leftBottomPx = this.getOverviewPxFromLonLat({ │ │ │ │ + lon: lonLatBounds.left, │ │ │ │ + lat: lonLatBounds.bottom │ │ │ │ + }); │ │ │ │ + var rightTopPx = this.getOverviewPxFromLonLat({ │ │ │ │ + lon: lonLatBounds.right, │ │ │ │ + lat: lonLatBounds.top │ │ │ │ + }); │ │ │ │ + var bounds = null; │ │ │ │ + if (leftBottomPx && rightTopPx) { │ │ │ │ + bounds = new OpenLayers.Bounds(leftBottomPx.x, leftBottomPx.y, │ │ │ │ + rightTopPx.x, rightTopPx.y); │ │ │ │ } │ │ │ │ + return bounds; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var txtNode = this.createTextNode(path); │ │ │ │ - coordinatesNode.appendChild(txtNode); │ │ │ │ - │ │ │ │ - return coordinatesNode; │ │ │ │ + /** │ │ │ │ + * Method: getMapBoundsFromRectBounds │ │ │ │ + * Get the map bounds from the rect bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * pxBounds - {<OpenLayers.Bounds>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} Bounds which is the passed-in overview rect bounds │ │ │ │ + * translated into lon/lat bounds for the overview map │ │ │ │ + */ │ │ │ │ + getMapBoundsFromRectBounds: function(pxBounds) { │ │ │ │ + var leftBottomLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ + x: pxBounds.left, │ │ │ │ + y: pxBounds.bottom │ │ │ │ + }); │ │ │ │ + var rightTopLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ + x: pxBounds.right, │ │ │ │ + y: pxBounds.top │ │ │ │ + }); │ │ │ │ + return new OpenLayers.Bounds(leftBottomLonLat.lon, leftBottomLonLat.lat, │ │ │ │ + rightTopLonLat.lon, rightTopLonLat.lat); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildCoordinates │ │ │ │ + * Method: getLonLatFromOverviewPx │ │ │ │ + * Get a map location from a pixel location │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * overviewMapPx - {<OpenLayers.Pixel>|Object} OpenLayers.Pixel or │ │ │ │ + * an object with a │ │ │ │ + * 'x' and 'y' properties. │ │ │ │ * │ │ │ │ - * Returns │ │ │ │ - * {String} a coordinate pair │ │ │ │ + * Returns: │ │ │ │ + * {Object} Location which is the passed-in overview map │ │ │ │ + * OpenLayers.Pixel, translated into lon/lat by the overview │ │ │ │ + * map. An object with a 'lon' and 'lat' properties. │ │ │ │ */ │ │ │ │ - buildCoordinates: function(point) { │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - point = point.clone(); │ │ │ │ - point.transform(this.internalProjection, │ │ │ │ - this.externalProjection); │ │ │ │ - } │ │ │ │ - return point.x + "," + point.y; │ │ │ │ + getLonLatFromOverviewPx: function(overviewMapPx) { │ │ │ │ + var size = this.ovmap.size; │ │ │ │ + var res = this.ovmap.getResolution(); │ │ │ │ + var center = this.ovmap.getExtent().getCenterLonLat(); │ │ │ │ + │ │ │ │ + var deltaX = overviewMapPx.x - (size.w / 2); │ │ │ │ + var deltaY = overviewMapPx.y - (size.h / 2); │ │ │ │ + │ │ │ │ + return { │ │ │ │ + lon: center.lon + deltaX * res, │ │ │ │ + lat: center.lat - deltaY * res │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buildExtendedData │ │ │ │ + * Method: getOverviewPxFromLonLat │ │ │ │ + * Get a pixel location from a map location │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * attributes - {Object} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an │ │ │ │ + * object with a 'lon' and 'lat' properties. │ │ │ │ * │ │ │ │ - * Returns │ │ │ │ - * {DOMElement} A KML ExtendedData node or {null} if no attributes. │ │ │ │ + * Returns: │ │ │ │ + * {Object} Location which is the passed-in OpenLayers.LonLat, │ │ │ │ + * translated into overview map pixels │ │ │ │ */ │ │ │ │ - buildExtendedData: function(attributes) { │ │ │ │ - var extendedData = this.createElementNS(this.kmlns, "ExtendedData"); │ │ │ │ - for (var attributeName in attributes) { │ │ │ │ - // empty, name, description, styleUrl attributes ignored │ │ │ │ - if (attributes[attributeName] && attributeName != "name" && attributeName != "description" && attributeName != "styleUrl") { │ │ │ │ - var data = this.createElementNS(this.kmlns, "Data"); │ │ │ │ - data.setAttribute("name", attributeName); │ │ │ │ - var value = this.createElementNS(this.kmlns, "value"); │ │ │ │ - if (typeof attributes[attributeName] == "object") { │ │ │ │ - // cater for object attributes with 'value' properties │ │ │ │ - // other object properties will output an empty node │ │ │ │ - if (attributes[attributeName].value) { │ │ │ │ - value.appendChild(this.createTextNode(attributes[attributeName].value)); │ │ │ │ - } │ │ │ │ - if (attributes[attributeName].displayName) { │ │ │ │ - var displayName = this.createElementNS(this.kmlns, "displayName"); │ │ │ │ - // displayName always written as CDATA │ │ │ │ - displayName.appendChild(this.getXMLDoc().createCDATASection(attributes[attributeName].displayName)); │ │ │ │ - data.appendChild(displayName); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - value.appendChild(this.createTextNode(attributes[attributeName])); │ │ │ │ - } │ │ │ │ - data.appendChild(value); │ │ │ │ - extendedData.appendChild(data); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.isSimpleContent(extendedData)) { │ │ │ │ - return null; │ │ │ │ - } else { │ │ │ │ - return extendedData; │ │ │ │ + getOverviewPxFromLonLat: function(lonlat) { │ │ │ │ + var res = this.ovmap.getResolution(); │ │ │ │ + var extent = this.ovmap.getExtent(); │ │ │ │ + if (extent) { │ │ │ │ + return { │ │ │ │ + x: Math.round(1 / res * (lonlat.lon - extent.left)), │ │ │ │ + y: Math.round(1 / res * (extent.top - lonlat.lat)) │ │ │ │ + }; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.KML" │ │ │ │ + CLASS_NAME: 'OpenLayers.Control.OverviewMap' │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSDescribeLayer.js │ │ │ │ + OpenLayers/Control/Graticule.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Lang.js │ │ │ │ + * @requires OpenLayers/Rule.js │ │ │ │ + * @requires OpenLayers/StyleMap.js │ │ │ │ + * @requires OpenLayers/Layer/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WMSDescribeLayer │ │ │ │ - * Read SLD WMS DescribeLayer response │ │ │ │ - * DescribeLayer is meant to couple WMS to WFS and WCS │ │ │ │ + * Class: OpenLayers.Control.Graticule │ │ │ │ + * The Graticule displays a grid of latitude/longitude lines reprojected on │ │ │ │ + * the map. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + * │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WMSDescribeLayer = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ +OpenLayers.Control.Graticule = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.1.1". │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - defaultVersion: "1.1.1", │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSDescribeLayer │ │ │ │ - * Create a new parser for WMS DescribeLayer responses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIProperty: intervals │ │ │ │ + * {Array(Float)} A list of possible graticule widths in degrees. │ │ │ │ */ │ │ │ │ + intervals: [45, 30, 20, 10, 5, 2, 1, │ │ │ │ + 0.5, 0.2, 0.1, 0.05, 0.01, │ │ │ │ + 0.005, 0.002, 0.001 │ │ │ │ + ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read DescribeLayer data from a string, and return the response. │ │ │ │ - * The OGC currently defines 2 formats which are allowed for output, │ │ │ │ - * so we need to parse these 2 types │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} Array of {<LayerDescription>} objects which have: │ │ │ │ - * - {String} owsType: WFS/WCS │ │ │ │ - * - {String} owsURL: the online resource │ │ │ │ - * - {String} typeName: the name of the typename on the service │ │ │ │ + * APIProperty: displayInLayerSwitcher │ │ │ │ + * {Boolean} Allows the Graticule control to be switched on and off by │ │ │ │ + * LayerSwitcher control. Defaults is true. │ │ │ │ */ │ │ │ │ + displayInLayerSwitcher: true, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer" │ │ │ │ + /** │ │ │ │ + * APIProperty: visible │ │ │ │ + * {Boolean} should the graticule be initially visible (default=true) │ │ │ │ + */ │ │ │ │ + visible: true, │ │ │ │ │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/XLS.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * APIProperty: numPoints │ │ │ │ + * {Integer} The number of points to use in each graticule line. Higher │ │ │ │ + * numbers result in a smoother curve for projected maps │ │ │ │ + */ │ │ │ │ + numPoints: 50, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: targetSize │ │ │ │ + * {Integer} The maximum size of the grid in pixels on the map │ │ │ │ + */ │ │ │ │ + targetSize: 200, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: layerName │ │ │ │ + * {String} The name to be displayed in the layer switcher, default is set │ │ │ │ + * by {<OpenLayers.Lang>}. │ │ │ │ + */ │ │ │ │ + layerName: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.XLS │ │ │ │ - * Read/Write XLS (OpenLS). Create a new instance with the <OpenLayers.Format.XLS> │ │ │ │ - * constructor. Currently only implemented for Location Utility Services, more │ │ │ │ - * specifically only for Geocoding. No support for Reverse Geocoding as yet. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.XLS = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + /** │ │ │ │ + * APIProperty: labelled │ │ │ │ + * {Boolean} Should the graticule lines be labelled?. default=true │ │ │ │ + */ │ │ │ │ + labelled: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.1.0". │ │ │ │ + * APIProperty: labelFormat │ │ │ │ + * {String} the format of the labels, default = 'dm'. See │ │ │ │ + * <OpenLayers.Util.getFormattedLonLat> for other options. │ │ │ │ */ │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ + labelFormat: 'dm', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: stringifyOutput │ │ │ │ - * {Boolean} If true, write will return a string otherwise a DOMElement. │ │ │ │ - * Default is true. │ │ │ │ + * APIProperty: lineSymbolizer │ │ │ │ + * {symbolizer} the symbolizer used to render lines │ │ │ │ */ │ │ │ │ - stringifyOutput: true, │ │ │ │ + lineSymbolizer: { │ │ │ │ + strokeColor: "#333", │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeOpacity: 0.5 │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.XLS │ │ │ │ - * Create a new parser for XLS. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIProperty: labelSymbolizer │ │ │ │ + * {symbolizer} the symbolizer used to render labels │ │ │ │ */ │ │ │ │ + labelSymbolizer: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Write out an XLS request. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * request - {Object} An object representing the LUS request. │ │ │ │ - * options - {Object} Optional configuration object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} An XLS document string. │ │ │ │ + * Property: gratLayer │ │ │ │ + * {<OpenLayers.Layer.Vector>} vector layer used to draw the graticule on │ │ │ │ */ │ │ │ │ + gratLayer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read an XLS doc and return an object representing the result. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Control.Graticule │ │ │ │ + * Create a new graticule control to display a grid of latitude longitude │ │ │ │ + * lines. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * data - {String | DOMElement} Data to read. │ │ │ │ - * options - {Object} Options for the reader. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object representing the GeocodeResponse. │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ */ │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.layerName = options.layerName || OpenLayers.i18n("Graticule"); │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.XLS" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/SOSCapabilities.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML/VersionedOGC.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.SOSCapabilities │ │ │ │ - * Read SOS Capabilities. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML.VersionedOGC> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.SOSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + this.labelSymbolizer.stroke = false; │ │ │ │ + this.labelSymbolizer.fill = false; │ │ │ │ + this.labelSymbolizer.label = "${label}"; │ │ │ │ + this.labelSymbolizer.labelAlign = "${labelAlign}"; │ │ │ │ + this.labelSymbolizer.labelXOffset = "${xOffset}"; │ │ │ │ + this.labelSymbolizer.labelYOffset = "${yOffset}"; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultVersion │ │ │ │ - * {String} Version number to assume if none found. Default is "1.0.0". │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - defaultVersion: "1.0.0", │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.gratLayer) { │ │ │ │ + this.gratLayer.destroy(); │ │ │ │ + this.gratLayer = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.SOSCapabilities │ │ │ │ - * Create a new parser for SOS Capabilities. │ │ │ │ + * Method: draw │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return information about │ │ │ │ - * the service (offering and observedProperty mostly). │ │ │ │ + * initializes the graticule layer and does the initial update │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ * Returns: │ │ │ │ - * {Object} Info about the SOS │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSCapabilities" │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WFST/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WFST/v1.js │ │ │ │ - * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WFST.v1_0_0 │ │ │ │ - * A format for creating WFS v1.0.0 transactions. Create a new instance with the │ │ │ │ - * <OpenLayers.Format.WFST.v1_0_0> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.Filter.v1_0_0> │ │ │ │ - * - <OpenLayers.Format.WFST.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WFST.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.Filter.v1_0_0, OpenLayers.Format.WFST.v1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} WFS version number. │ │ │ │ - */ │ │ │ │ - version: "1.0.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: srsNameInQuery │ │ │ │ - * {Boolean} If true the reference system is passed in Query requests │ │ │ │ - * via the "srsName" attribute to the "wfs:Query" element, this │ │ │ │ - * property defaults to false as it isn't WFS 1.0.0 compliant. │ │ │ │ - */ │ │ │ │ - srsNameInQuery: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: schemaLocations │ │ │ │ - * {Object} Properties are namespace aliases, values are schema locations. │ │ │ │ - */ │ │ │ │ - schemaLocations: { │ │ │ │ - "wfs": "http://schemas.opengis.net/wfs/1.0.0/WFS-transaction.xsd" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WFST.v1_0_0 │ │ │ │ - * A class for parsing and generating WFS v1.0.0 transactions. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ - * Valid options properties: │ │ │ │ - * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ - * featureNS - {String} Feature namespace (optional). │ │ │ │ - * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ - * if featureNS is provided). Default is 'feature'. │ │ │ │ - * geometryName - {String} Name of geometry attribute. Default is 'the_geom'. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.Filter.v1_0_0.prototype.initialize.apply(this, [options]); │ │ │ │ - OpenLayers.Format.WFST.v1.prototype.initialize.apply(this, [options]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: readNode │ │ │ │ - * Shorthand for applying one of the named readers given the node │ │ │ │ - * namespace and local name. Readers take two args (node, obj) and │ │ │ │ - * generally extend or modify the second. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} The node to be read (required). │ │ │ │ - * obj - {Object} The object to be modified (optional). │ │ │ │ - * first - {Boolean} Should be set to true for the first node read. This │ │ │ │ - * is usually the readNode call in the read method. Without this being │ │ │ │ - * set, auto-configured properties will stick on subsequent reads. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The input object, modified (or a new one if none was provided). │ │ │ │ - */ │ │ │ │ - readNode: function(node, obj, first) { │ │ │ │ - // Not the superclass, only the mixin classes inherit from │ │ │ │ - // Format.GML.v2. We need this because we don't want to get readNode │ │ │ │ - // from the superclass's superclass, which is OpenLayers.Format.XML. │ │ │ │ - return OpenLayers.Format.GML.v2.prototype.readNode.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ - "WFS_TransactionResponse": function(node, obj) { │ │ │ │ - obj.insertIds = []; │ │ │ │ - obj.success = false; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "InsertResult": function(node, container) { │ │ │ │ - var obj = { │ │ │ │ - fids: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - container.insertIds = container.insertIds.concat(obj.fids); │ │ │ │ - }, │ │ │ │ - "TransactionResult": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Status": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "SUCCESS": function(node, obj) { │ │ │ │ - obj.success = true; │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WFST.v1.prototype.readers["wfs"]), │ │ │ │ - "gml": OpenLayers.Format.GML.v2.prototype.readers["gml"], │ │ │ │ - "feature": OpenLayers.Format.GML.v2.prototype.readers["feature"], │ │ │ │ - "ogc": OpenLayers.Format.Filter.v1_0_0.prototype.readers["ogc"] │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ - */ │ │ │ │ - writers: { │ │ │ │ - "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ - "Query": function(options) { │ │ │ │ - options = OpenLayers.Util.extend({ │ │ │ │ - featureNS: this.featureNS, │ │ │ │ - featurePrefix: this.featurePrefix, │ │ │ │ - featureType: this.featureType, │ │ │ │ - srsName: this.srsName, │ │ │ │ - srsNameInQuery: this.srsNameInQuery │ │ │ │ - }, options); │ │ │ │ - var prefix = options.featurePrefix; │ │ │ │ - var node = this.createElementNSPlus("wfs:Query", { │ │ │ │ - attributes: { │ │ │ │ - typeName: (prefix ? prefix + ":" : "") + │ │ │ │ - options.featureType │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.srsNameInQuery && options.srsName) { │ │ │ │ - node.setAttribute("srsName", options.srsName); │ │ │ │ - } │ │ │ │ - if (options.featureNS) { │ │ │ │ - node.setAttribute("xmlns:" + prefix, options.featureNS); │ │ │ │ - } │ │ │ │ - if (options.propertyNames) { │ │ │ │ - for (var i = 0, len = options.propertyNames.length; i < len; i++) { │ │ │ │ - this.writeNode( │ │ │ │ - "ogc:PropertyName", { │ │ │ │ - property: options.propertyNames[i] │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (options.filter) { │ │ │ │ - this.setFilterProperty(options.filter); │ │ │ │ - this.writeNode("ogc:Filter", options.filter, node); │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.gratLayer) { │ │ │ │ + var gratStyle = new OpenLayers.Style({}, { │ │ │ │ + rules: [new OpenLayers.Rule({ │ │ │ │ + 'symbolizer': { │ │ │ │ + "Point": this.labelSymbolizer, │ │ │ │ + "Line": this.lineSymbolizer │ │ │ │ } │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WFST.v1.prototype.writers["wfs"]), │ │ │ │ - "gml": OpenLayers.Format.GML.v2.prototype.writers["gml"], │ │ │ │ - "feature": OpenLayers.Format.GML.v2.prototype.writers["feature"], │ │ │ │ - "ogc": OpenLayers.Format.Filter.v1_0_0.prototype.writers["ogc"] │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFST.v1_0_0" │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/ArcXML/Features.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/ArcXML.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.ArcXML.Features │ │ │ │ - * Read/Write ArcXML features. Create a new instance with the │ │ │ │ - * <OpenLayers.Format.ArcXML.Features> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.ArcXML.Features = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + })] │ │ │ │ + }); │ │ │ │ + this.gratLayer = new OpenLayers.Layer.Vector(this.layerName, { │ │ │ │ + styleMap: new OpenLayers.StyleMap({ │ │ │ │ + 'default': gratStyle │ │ │ │ + }), │ │ │ │ + visibility: this.visible, │ │ │ │ + displayInLayerSwitcher: this.displayInLayerSwitcher │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return this.div; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.ArcXML.Features │ │ │ │ - * Create a new parser/writer for ArcXML Features. Create an instance of this class │ │ │ │ - * to get a set of features from an ArcXML response. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIMethod: activate │ │ │ │ */ │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.map.addLayer(this.gratLayer); │ │ │ │ + this.map.events.register('moveend', this, this.update); │ │ │ │ + this.update(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read data from a string of ArcXML, and return a set of OpenLayers features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * APIMethod: deactivate │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.map.events.unregister('moveend', this, this.update); │ │ │ │ + this.map.removeLayer(this.gratLayer); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ * │ │ │ │ + * calculates the grid to be displayed and actually draws it │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} A collection of features. │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - var axl = new OpenLayers.Format.ArcXML(); │ │ │ │ - var parsed = axl.read(data); │ │ │ │ - │ │ │ │ - return parsed.features.feature; │ │ │ │ - } │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSDescribeLayer/v1_1.js │ │ │ │ - ====================================================================== */ │ │ │ │ + update: function() { │ │ │ │ + //wait for the map to be initialized before proceeding │ │ │ │ + var mapBounds = this.map.getExtent(); │ │ │ │ + if (!mapBounds) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + //clear out the old grid │ │ │ │ + this.gratLayer.destroyFeatures(); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSDescribeLayer.js │ │ │ │ - * @requires OpenLayers/Format/OGCExceptionReport.js │ │ │ │ - */ │ │ │ │ + //get the projection objects required │ │ │ │ + var llProj = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + var mapProj = this.map.getProjectionObject(); │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSDescribeLayer.v1_1_1 │ │ │ │ - * Read SLD WMS DescribeLayer response for WMS 1.1.X │ │ │ │ - * WMS 1.1.X is tightly coupled to SLD 1.0.0 │ │ │ │ - * │ │ │ │ - * Example DescribeLayer request: │ │ │ │ - * http://demo.opengeo.org/geoserver/wms?request=DescribeLayer&version=1.1.1&layers=topp:states │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSDescribeLayer> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSDescribeLayer.v1_1_1 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSDescribeLayer, { │ │ │ │ + //if the map is in lon/lat, then the lines are straight and only one │ │ │ │ + //point is required │ │ │ │ + if (mapProj.proj && mapProj.proj.projName == "longlat") { │ │ │ │ + this.numPoints = 1; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSDescribeLayer │ │ │ │ - * Create a new parser for WMS DescribeLayer responses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.WMSDescribeLayer.prototype.initialize.apply(this, │ │ │ │ - [options]); │ │ │ │ - }, │ │ │ │ + //get the map center in EPSG:4326 │ │ │ │ + var mapCenter = this.map.getCenter(); //lon and lat here are really map x and y │ │ │ │ + var mapCenterLL = new OpenLayers.Pixel(mapCenter.lon, mapCenter.lat); │ │ │ │ + OpenLayers.Projection.transform(mapCenterLL, mapProj, llProj); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read DescribeLayer data from a string, and return the response. │ │ │ │ - * The OGC defines 2 formats which are allowed for output, │ │ │ │ - * so we need to parse these 2 types for version 1.1.X │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Object with a layerDescriptions property, which holds an Array │ │ │ │ - * of {<LayerDescription>} objects which have: │ │ │ │ - * - {String} owsType: WFS/WCS │ │ │ │ - * - {String} owsURL: the online resource │ │ │ │ - * - {String} typeName: the name of the typename on the owsType service │ │ │ │ - * - {String} layerName: the name of the WMS layer we did a lookup for │ │ │ │ + /* This block of code determines the lon/lat interval to use for the │ │ │ │ + * grid by calculating the diagonal size of one grid cell at the map │ │ │ │ + * center. Iterates through the intervals array until the diagonal │ │ │ │ + * length is less than the targetSize option. │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - var root = data.documentElement; │ │ │ │ - var children = root.childNodes; │ │ │ │ - var describelayer = { │ │ │ │ - layerDescriptions: [] │ │ │ │ - }; │ │ │ │ - var childNode, nodeName; │ │ │ │ - for (var i = 0; i < children.length; ++i) { │ │ │ │ - childNode = children[i]; │ │ │ │ - nodeName = childNode.nodeName; │ │ │ │ - if (nodeName == 'LayerDescription') { │ │ │ │ - var layerName = childNode.getAttribute('name'); │ │ │ │ - var owsType = ''; │ │ │ │ - var owsURL = ''; │ │ │ │ - var typeName = ''; │ │ │ │ - // check for owsType and owsURL attributes │ │ │ │ - if (childNode.getAttribute('owsType')) { │ │ │ │ - owsType = childNode.getAttribute('owsType'); │ │ │ │ - owsURL = childNode.getAttribute('owsURL'); │ │ │ │ - } else { │ │ │ │ - // look for wfs or wcs attribute │ │ │ │ - if (childNode.getAttribute('wfs') != '') { │ │ │ │ - owsType = 'WFS'; │ │ │ │ - owsURL = childNode.getAttribute('wfs'); │ │ │ │ - } else if (childNode.getAttribute('wcs') != '') { │ │ │ │ - owsType = 'WCS'; │ │ │ │ - owsURL = childNode.getAttribute('wcs'); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // look for Query child │ │ │ │ - var query = childNode.getElementsByTagName('Query'); │ │ │ │ - if (query.length > 0) { │ │ │ │ - typeName = query[0].getAttribute('typeName'); │ │ │ │ - if (!typeName) { │ │ │ │ - // because of Ionic bug │ │ │ │ - typeName = query[0].getAttribute('typename'); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var layerDescription = { │ │ │ │ - layerName: layerName, │ │ │ │ - owsType: owsType, │ │ │ │ - owsURL: owsURL, │ │ │ │ - typeName: typeName │ │ │ │ - }; │ │ │ │ - describelayer.layerDescriptions.push(layerDescription); │ │ │ │ - │ │ │ │ - //TODO do this in deprecated.js instead: │ │ │ │ - // array style index for backwards compatibility │ │ │ │ - describelayer.length = describelayer.layerDescriptions.length; │ │ │ │ - describelayer[describelayer.length - 1] = layerDescription; │ │ │ │ - │ │ │ │ - } else if (nodeName == 'ServiceException') { │ │ │ │ - // an exception must have occurred, so parse it │ │ │ │ - var parser = new OpenLayers.Format.OGCExceptionReport(); │ │ │ │ - return { │ │ │ │ - error: parser.read(data) │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + //find lat/lon interval that results in a grid of less than the target size │ │ │ │ + var testSq = this.targetSize * mapRes; │ │ │ │ + testSq *= testSq; //compare squares rather than doing a square root to save time │ │ │ │ + var llInterval; │ │ │ │ + for (var i = 0; i < this.intervals.length; ++i) { │ │ │ │ + llInterval = this.intervals[i]; //could do this for both x and y?? │ │ │ │ + var delta = llInterval / 2; │ │ │ │ + var p1 = mapCenterLL.offset({ │ │ │ │ + x: -delta, │ │ │ │ + y: -delta │ │ │ │ + }); //test coords in EPSG:4326 space │ │ │ │ + var p2 = mapCenterLL.offset({ │ │ │ │ + x: delta, │ │ │ │ + y: delta │ │ │ │ + }); │ │ │ │ + OpenLayers.Projection.transform(p1, llProj, mapProj); // convert them back to map projection │ │ │ │ + OpenLayers.Projection.transform(p2, llProj, mapProj); │ │ │ │ + var distSq = (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y); │ │ │ │ + if (distSq <= testSq) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ - return describelayer; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer.v1_1_1" │ │ │ │ - │ │ │ │ - }); │ │ │ │ - │ │ │ │ -// Version alias - workaround for http://trac.osgeo.org/mapserver/ticket/2257 │ │ │ │ -OpenLayers.Format.WMSDescribeLayer.v1_1_0 = │ │ │ │ - OpenLayers.Format.WMSDescribeLayer.v1_1_1; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities.js │ │ │ │ - * @requires OpenLayers/Format/OGCExceptionReport.js │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities.v1 │ │ │ │ - * Abstract class not to be instantiated directly. Creates │ │ │ │ - * the common parts for both WMS 1.1.X and WMS 1.3.X. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ + } │ │ │ │ + //alert(llInterval); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - wms: "http://www.opengis.net/wms", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ + //round the LL center to an even number based on the interval │ │ │ │ + mapCenterLL.x = Math.floor(mapCenterLL.x / llInterval) * llInterval; │ │ │ │ + mapCenterLL.y = Math.floor(mapCenterLL.y / llInterval) * llInterval; │ │ │ │ + //TODO adjust for minutses/seconds? │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ + /* The following 2 blocks calculate the nodes of the grid along a │ │ │ │ + * line of constant longitude (then latitiude) running through the │ │ │ │ + * center of the map until it reaches the map edge. The calculation │ │ │ │ + * goes from the center in both directions to the edge. │ │ │ │ */ │ │ │ │ - defaultPrefix: "wms", │ │ │ │ + //get the central longitude line, increment the latitude │ │ │ │ + var iter = 0; │ │ │ │ + var centerLonPoints = [mapCenterLL.clone()]; │ │ │ │ + var newPoint = mapCenterLL.clone(); │ │ │ │ + var mapXY; │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: 0, │ │ │ │ + y: llInterval │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLonPoints.unshift(newPoint); │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ + newPoint = mapCenterLL.clone(); │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: 0, │ │ │ │ + y: -llInterval │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLonPoints.push(newPoint); │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSCapabilities.v1 │ │ │ │ - * Create an instance of one of the subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + //get the central latitude line, increment the longitude │ │ │ │ + iter = 0; │ │ │ │ + var centerLatPoints = [mapCenterLL.clone()]; │ │ │ │ + newPoint = mapCenterLL.clone(); │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: -llInterval, │ │ │ │ + y: 0 │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLatPoints.unshift(newPoint); │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ + newPoint = mapCenterLL.clone(); │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: llInterval, │ │ │ │ + y: 0 │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLatPoints.push(newPoint); │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1000); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return a list of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} List of named layers. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - var raw = data; │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ + //now generate a line for each node in the central lat and lon lines │ │ │ │ + //first loop over constant longitude │ │ │ │ + var lines = []; │ │ │ │ + for (var i = 0; i < centerLatPoints.length; ++i) { │ │ │ │ + var lon = centerLatPoints[i].x; │ │ │ │ + var pointList = []; │ │ │ │ + var labelPoint = null; │ │ │ │ + var latEnd = Math.min(centerLonPoints[0].y, 90); │ │ │ │ + var latStart = Math.max(centerLonPoints[centerLonPoints.length - 1].y, -90); │ │ │ │ + var latDelta = (latEnd - latStart) / this.numPoints; │ │ │ │ + var lat = latStart; │ │ │ │ + for (var j = 0; j <= this.numPoints; ++j) { │ │ │ │ + var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ + gridPoint.transform(llProj, mapProj); │ │ │ │ + pointList.push(gridPoint); │ │ │ │ + lat += latDelta; │ │ │ │ + if (gridPoint.y >= mapBounds.bottom && !labelPoint) { │ │ │ │ + labelPoint = gridPoint; │ │ │ │ + } │ │ │ │ } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - if (capabilities.service === undefined) { │ │ │ │ - // an exception must have occurred, so parse it │ │ │ │ - var parser = new OpenLayers.Format.OGCExceptionReport(); │ │ │ │ - capabilities.error = parser.read(raw); │ │ │ │ + if (this.labelled) { │ │ │ │ + //keep track of when this grid line crosses the map bounds to set │ │ │ │ + //the label position │ │ │ │ + //labels along the bottom, add 10 pixel offset up into the map │ │ │ │ + //TODO add option for labels on top │ │ │ │ + var labelPos = new OpenLayers.Geometry.Point(labelPoint.x, mapBounds.bottom); │ │ │ │ + var labelAttrs = { │ │ │ │ + value: lon, │ │ │ │ + label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lon, "lon", this.labelFormat) : "", │ │ │ │ + labelAlign: "cb", │ │ │ │ + xOffset: 0, │ │ │ │ + yOffset: 2 │ │ │ │ + }; │ │ │ │ + this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)); │ │ │ │ } │ │ │ │ - return capabilities; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wms": { │ │ │ │ - "Service": function(node, obj) { │ │ │ │ - obj.service = {}; │ │ │ │ - this.readChildNodes(node, obj.service); │ │ │ │ - }, │ │ │ │ - "Name": function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Title": function(node, obj) { │ │ │ │ - obj.title = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Abstract": function(node, obj) { │ │ │ │ - obj["abstract"] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "BoundingBox": function(node, obj) { │ │ │ │ - var bbox = {}; │ │ │ │ - bbox.bbox = [ │ │ │ │ - parseFloat(node.getAttribute("minx")), │ │ │ │ - parseFloat(node.getAttribute("miny")), │ │ │ │ - parseFloat(node.getAttribute("maxx")), │ │ │ │ - parseFloat(node.getAttribute("maxy")) │ │ │ │ - ]; │ │ │ │ - var res = { │ │ │ │ - x: parseFloat(node.getAttribute("resx")), │ │ │ │ - y: parseFloat(node.getAttribute("resy")) │ │ │ │ - }; │ │ │ │ + var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ + lines.push(new OpenLayers.Feature.Vector(geom)); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (!(isNaN(res.x) && isNaN(res.y))) { │ │ │ │ - bbox.res = res; │ │ │ │ - } │ │ │ │ - // return the bbox so that descendant classes can set the │ │ │ │ - // CRS and SRS and add it to the obj │ │ │ │ - return bbox; │ │ │ │ - }, │ │ │ │ - "OnlineResource": function(node, obj) { │ │ │ │ - obj.href = this.getAttributeNS(node, this.namespaces.xlink, │ │ │ │ - "href"); │ │ │ │ - }, │ │ │ │ - "ContactInformation": function(node, obj) { │ │ │ │ - obj.contactInformation = {}; │ │ │ │ - this.readChildNodes(node, obj.contactInformation); │ │ │ │ - }, │ │ │ │ - "ContactPersonPrimary": function(node, obj) { │ │ │ │ - obj.personPrimary = {}; │ │ │ │ - this.readChildNodes(node, obj.personPrimary); │ │ │ │ - }, │ │ │ │ - "ContactPerson": function(node, obj) { │ │ │ │ - obj.person = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContactOrganization": function(node, obj) { │ │ │ │ - obj.organization = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContactPosition": function(node, obj) { │ │ │ │ - obj.position = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContactAddress": function(node, obj) { │ │ │ │ - obj.contactAddress = {}; │ │ │ │ - this.readChildNodes(node, obj.contactAddress); │ │ │ │ - }, │ │ │ │ - "AddressType": function(node, obj) { │ │ │ │ - obj.type = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Address": function(node, obj) { │ │ │ │ - obj.address = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "City": function(node, obj) { │ │ │ │ - obj.city = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "StateOrProvince": function(node, obj) { │ │ │ │ - obj.stateOrProvince = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "PostCode": function(node, obj) { │ │ │ │ - obj.postcode = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Country": function(node, obj) { │ │ │ │ - obj.country = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContactVoiceTelephone": function(node, obj) { │ │ │ │ - obj.phone = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContactFacsimileTelephone": function(node, obj) { │ │ │ │ - obj.fax = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContactElectronicMailAddress": function(node, obj) { │ │ │ │ - obj.email = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Fees": function(node, obj) { │ │ │ │ - var fees = this.getChildValue(node); │ │ │ │ - if (fees && fees.toLowerCase() != "none") { │ │ │ │ - obj.fees = fees; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "AccessConstraints": function(node, obj) { │ │ │ │ - var constraints = this.getChildValue(node); │ │ │ │ - if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ - obj.accessConstraints = constraints; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Capability": function(node, obj) { │ │ │ │ - obj.capability = { │ │ │ │ - nestedLayers: [], │ │ │ │ - layers: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.capability); │ │ │ │ - }, │ │ │ │ - "Request": function(node, obj) { │ │ │ │ - obj.request = {}; │ │ │ │ - this.readChildNodes(node, obj.request); │ │ │ │ - }, │ │ │ │ - "GetCapabilities": function(node, obj) { │ │ │ │ - obj.getcapabilities = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getcapabilities); │ │ │ │ - }, │ │ │ │ - "Format": function(node, obj) { │ │ │ │ - if (OpenLayers.Util.isArray(obj.formats)) { │ │ │ │ - obj.formats.push(this.getChildValue(node)); │ │ │ │ - } else { │ │ │ │ - obj.format = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "DCPType": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "HTTP": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Get": function(node, obj) { │ │ │ │ - obj.get = {}; │ │ │ │ - this.readChildNodes(node, obj.get); │ │ │ │ - // backwards compatibility │ │ │ │ - if (!obj.href) { │ │ │ │ - obj.href = obj.get.href; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Post": function(node, obj) { │ │ │ │ - obj.post = {}; │ │ │ │ - this.readChildNodes(node, obj.post); │ │ │ │ - // backwards compatibility │ │ │ │ - if (!obj.href) { │ │ │ │ - obj.href = obj.get.href; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "GetMap": function(node, obj) { │ │ │ │ - obj.getmap = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getmap); │ │ │ │ - }, │ │ │ │ - "GetFeatureInfo": function(node, obj) { │ │ │ │ - obj.getfeatureinfo = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getfeatureinfo); │ │ │ │ - }, │ │ │ │ - "Exception": function(node, obj) { │ │ │ │ - obj.exception = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.exception); │ │ │ │ - }, │ │ │ │ - "Layer": function(node, obj) { │ │ │ │ - var parentLayer, capability; │ │ │ │ - if (obj.capability) { │ │ │ │ - capability = obj.capability; │ │ │ │ - parentLayer = obj; │ │ │ │ - } else { │ │ │ │ - capability = obj; │ │ │ │ - } │ │ │ │ - var attrNode = node.getAttributeNode("queryable"); │ │ │ │ - var queryable = (attrNode && attrNode.specified) ? │ │ │ │ - node.getAttribute("queryable") : null; │ │ │ │ - attrNode = node.getAttributeNode("cascaded"); │ │ │ │ - var cascaded = (attrNode && attrNode.specified) ? │ │ │ │ - node.getAttribute("cascaded") : null; │ │ │ │ - attrNode = node.getAttributeNode("opaque"); │ │ │ │ - var opaque = (attrNode && attrNode.specified) ? │ │ │ │ - node.getAttribute('opaque') : null; │ │ │ │ - var noSubsets = node.getAttribute('noSubsets'); │ │ │ │ - var fixedWidth = node.getAttribute('fixedWidth'); │ │ │ │ - var fixedHeight = node.getAttribute('fixedHeight'); │ │ │ │ - var parent = parentLayer || {}, │ │ │ │ - extend = OpenLayers.Util.extend; │ │ │ │ - var layer = { │ │ │ │ - nestedLayers: [], │ │ │ │ - styles: parentLayer ? [].concat(parentLayer.styles) : [], │ │ │ │ - srs: parentLayer ? extend({}, parent.srs) : {}, │ │ │ │ - metadataURLs: [], │ │ │ │ - bbox: parentLayer ? extend({}, parent.bbox) : {}, │ │ │ │ - llbbox: parent.llbbox, │ │ │ │ - dimensions: parentLayer ? extend({}, parent.dimensions) : {}, │ │ │ │ - authorityURLs: parentLayer ? extend({}, parent.authorityURLs) : {}, │ │ │ │ - identifiers: {}, │ │ │ │ - keywords: [], │ │ │ │ - queryable: (queryable && queryable !== "") ? │ │ │ │ - (queryable === "1" || queryable === "true") : (parent.queryable || false), │ │ │ │ - cascaded: (cascaded !== null) ? parseInt(cascaded) : (parent.cascaded || 0), │ │ │ │ - opaque: opaque ? │ │ │ │ - (opaque === "1" || opaque === "true") : (parent.opaque || false), │ │ │ │ - noSubsets: (noSubsets !== null) ? │ │ │ │ - (noSubsets === "1" || noSubsets === "true") : (parent.noSubsets || false), │ │ │ │ - fixedWidth: (fixedWidth != null) ? │ │ │ │ - parseInt(fixedWidth) : (parent.fixedWidth || 0), │ │ │ │ - fixedHeight: (fixedHeight != null) ? │ │ │ │ - parseInt(fixedHeight) : (parent.fixedHeight || 0), │ │ │ │ - minScale: parent.minScale, │ │ │ │ - maxScale: parent.maxScale, │ │ │ │ - attribution: parent.attribution │ │ │ │ - }; │ │ │ │ - obj.nestedLayers.push(layer); │ │ │ │ - layer.capability = capability; │ │ │ │ - this.readChildNodes(node, layer); │ │ │ │ - delete layer.capability; │ │ │ │ - if (layer.name) { │ │ │ │ - var parts = layer.name.split(":"), │ │ │ │ - request = capability.request, │ │ │ │ - gfi = request.getfeatureinfo; │ │ │ │ - if (parts.length > 0) { │ │ │ │ - layer.prefix = parts[0]; │ │ │ │ - } │ │ │ │ - capability.layers.push(layer); │ │ │ │ - if (layer.formats === undefined) { │ │ │ │ - layer.formats = request.getmap.formats; │ │ │ │ - } │ │ │ │ - if (layer.infoFormats === undefined && gfi) { │ │ │ │ - layer.infoFormats = gfi.formats; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Attribution": function(node, obj) { │ │ │ │ - obj.attribution = {}; │ │ │ │ - this.readChildNodes(node, obj.attribution); │ │ │ │ - }, │ │ │ │ - "LogoURL": function(node, obj) { │ │ │ │ - obj.logo = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height") │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.logo); │ │ │ │ - }, │ │ │ │ - "Style": function(node, obj) { │ │ │ │ - var style = {}; │ │ │ │ - obj.styles.push(style); │ │ │ │ - this.readChildNodes(node, style); │ │ │ │ - }, │ │ │ │ - "LegendURL": function(node, obj) { │ │ │ │ - var legend = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height") │ │ │ │ - }; │ │ │ │ - obj.legend = legend; │ │ │ │ - this.readChildNodes(node, legend); │ │ │ │ - }, │ │ │ │ - "MetadataURL": function(node, obj) { │ │ │ │ - var metadataURL = { │ │ │ │ - type: node.getAttribute("type") │ │ │ │ - }; │ │ │ │ - obj.metadataURLs.push(metadataURL); │ │ │ │ - this.readChildNodes(node, metadataURL); │ │ │ │ - }, │ │ │ │ - "DataURL": function(node, obj) { │ │ │ │ - obj.dataURL = {}; │ │ │ │ - this.readChildNodes(node, obj.dataURL); │ │ │ │ - }, │ │ │ │ - "FeatureListURL": function(node, obj) { │ │ │ │ - obj.featureListURL = {}; │ │ │ │ - this.readChildNodes(node, obj.featureListURL); │ │ │ │ - }, │ │ │ │ - "AuthorityURL": function(node, obj) { │ │ │ │ - var name = node.getAttribute("name"); │ │ │ │ - var authority = {}; │ │ │ │ - this.readChildNodes(node, authority); │ │ │ │ - obj.authorityURLs[name] = authority.href; │ │ │ │ - }, │ │ │ │ - "Identifier": function(node, obj) { │ │ │ │ - var authority = node.getAttribute("authority"); │ │ │ │ - obj.identifiers[authority] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "KeywordList": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "SRS": function(node, obj) { │ │ │ │ - obj.srs[this.getChildValue(node)] = true; │ │ │ │ - } │ │ │ │ + //now draw the lines of constant latitude │ │ │ │ + for (var j = 0; j < centerLonPoints.length; ++j) { │ │ │ │ + lat = centerLonPoints[j].y; │ │ │ │ + if (lat < -90 || lat > 90) { //latitudes only valid between -90 and 90 │ │ │ │ + continue; │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1_1.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities/v1.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities.v1_1 │ │ │ │ - * Abstract class not to be instantiated directly. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSCapabilities.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ - "WMT_MS_Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Keyword": function(node, obj) { │ │ │ │ - if (obj.keywords) { │ │ │ │ - obj.keywords.push(this.getChildValue(node)); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "DescribeLayer": function(node, obj) { │ │ │ │ - obj.describelayer = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.describelayer); │ │ │ │ - }, │ │ │ │ - "GetLegendGraphic": function(node, obj) { │ │ │ │ - obj.getlegendgraphic = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getlegendgraphic); │ │ │ │ - }, │ │ │ │ - "GetStyles": function(node, obj) { │ │ │ │ - obj.getstyles = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getstyles); │ │ │ │ - }, │ │ │ │ - "PutStyles": function(node, obj) { │ │ │ │ - obj.putstyles = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.putstyles); │ │ │ │ - }, │ │ │ │ - "UserDefinedSymbolization": function(node, obj) { │ │ │ │ - var userSymbols = { │ │ │ │ - supportSLD: parseInt(node.getAttribute("SupportSLD")) == 1, │ │ │ │ - userLayer: parseInt(node.getAttribute("UserLayer")) == 1, │ │ │ │ - userStyle: parseInt(node.getAttribute("UserStyle")) == 1, │ │ │ │ - remoteWFS: parseInt(node.getAttribute("RemoteWFS")) == 1 │ │ │ │ - }; │ │ │ │ - obj.userSymbols = userSymbols; │ │ │ │ - }, │ │ │ │ - "LatLonBoundingBox": function(node, obj) { │ │ │ │ - obj.llbbox = [ │ │ │ │ - parseFloat(node.getAttribute("minx")), │ │ │ │ - parseFloat(node.getAttribute("miny")), │ │ │ │ - parseFloat(node.getAttribute("maxx")), │ │ │ │ - parseFloat(node.getAttribute("maxy")) │ │ │ │ - ]; │ │ │ │ - }, │ │ │ │ - "BoundingBox": function(node, obj) { │ │ │ │ - var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ - bbox.srs = node.getAttribute("SRS"); │ │ │ │ - obj.bbox[bbox.srs] = bbox; │ │ │ │ - }, │ │ │ │ - "ScaleHint": function(node, obj) { │ │ │ │ - var min = node.getAttribute("min"); │ │ │ │ - var max = node.getAttribute("max"); │ │ │ │ - var rad2 = Math.pow(2, 0.5); │ │ │ │ - var ipm = OpenLayers.INCHES_PER_UNIT["m"]; │ │ │ │ - if (min != 0) { │ │ │ │ - obj.maxScale = parseFloat( │ │ │ │ - ((min / rad2) * ipm * │ │ │ │ - OpenLayers.DOTS_PER_INCH).toPrecision(13) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (max != Number.POSITIVE_INFINITY) { │ │ │ │ - obj.minScale = parseFloat( │ │ │ │ - ((max / rad2) * ipm * │ │ │ │ - OpenLayers.DOTS_PER_INCH).toPrecision(13) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Dimension": function(node, obj) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - var dim = { │ │ │ │ - name: name, │ │ │ │ - units: node.getAttribute("units"), │ │ │ │ - unitsymbol: node.getAttribute("unitSymbol") │ │ │ │ - }; │ │ │ │ - obj.dimensions[dim.name] = dim; │ │ │ │ - }, │ │ │ │ - "Extent": function(node, obj) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - if (name in obj["dimensions"]) { │ │ │ │ - var extent = obj.dimensions[name]; │ │ │ │ - extent.nearestVal = │ │ │ │ - node.getAttribute("nearestValue") === "1"; │ │ │ │ - extent.multipleVal = │ │ │ │ - node.getAttribute("multipleValues") === "1"; │ │ │ │ - extent.current = node.getAttribute("current") === "1"; │ │ │ │ - extent["default"] = node.getAttribute("default") || ""; │ │ │ │ - var values = this.getChildValue(node); │ │ │ │ - extent.values = values.split(","); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1_3.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities/v1.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities/v1_3 │ │ │ │ - * Abstract base class for WMS Capabilities version 1.3.X. │ │ │ │ - * SLD 1.1.0 adds in the extra operations DescribeLayer and GetLegendGraphic, │ │ │ │ - * see: http://schemas.opengis.net/sld/1.1.0/sld_capabilities.xsd │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSCapabilities.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_3 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ - "WMS_Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "LayerLimit": function(node, obj) { │ │ │ │ - obj.layerLimit = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "MaxWidth": function(node, obj) { │ │ │ │ - obj.maxWidth = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "MaxHeight": function(node, obj) { │ │ │ │ - obj.maxHeight = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "BoundingBox": function(node, obj) { │ │ │ │ - var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ - bbox.srs = node.getAttribute("CRS"); │ │ │ │ - obj.bbox[bbox.srs] = bbox; │ │ │ │ - }, │ │ │ │ - "CRS": function(node, obj) { │ │ │ │ - // CRS is the synonym of SRS │ │ │ │ - this.readers.wms.SRS.apply(this, [node, obj]); │ │ │ │ - }, │ │ │ │ - "EX_GeographicBoundingBox": function(node, obj) { │ │ │ │ - // replacement of LatLonBoundingBox │ │ │ │ - obj.llbbox = []; │ │ │ │ - this.readChildNodes(node, obj.llbbox); │ │ │ │ - │ │ │ │ - }, │ │ │ │ - "westBoundLongitude": function(node, obj) { │ │ │ │ - obj[0] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "eastBoundLongitude": function(node, obj) { │ │ │ │ - obj[2] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "southBoundLatitude": function(node, obj) { │ │ │ │ - obj[1] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "northBoundLatitude": function(node, obj) { │ │ │ │ - obj[3] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "MinScaleDenominator": function(node, obj) { │ │ │ │ - obj.maxScale = parseFloat(this.getChildValue(node)).toPrecision(16); │ │ │ │ - }, │ │ │ │ - "MaxScaleDenominator": function(node, obj) { │ │ │ │ - obj.minScale = parseFloat(this.getChildValue(node)).toPrecision(16); │ │ │ │ - }, │ │ │ │ - "Dimension": function(node, obj) { │ │ │ │ - // dimension has extra attributes: default, multipleValues, │ │ │ │ - // nearestValue, current which used to be part of Extent. It now │ │ │ │ - // also contains the values. │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - var dim = { │ │ │ │ - name: name, │ │ │ │ - units: node.getAttribute("units"), │ │ │ │ - unitsymbol: node.getAttribute("unitSymbol"), │ │ │ │ - nearestVal: node.getAttribute("nearestValue") === "1", │ │ │ │ - multipleVal: node.getAttribute("multipleValues") === "1", │ │ │ │ - "default": node.getAttribute("default") || "", │ │ │ │ - current: node.getAttribute("current") === "1", │ │ │ │ - values: this.getChildValue(node).split(",") │ │ │ │ - │ │ │ │ - }; │ │ │ │ - // Theoretically there can be more dimensions with the same │ │ │ │ - // name, but with a different unit. Until we meet such a case, │ │ │ │ - // let's just keep the same structure as the WMS 1.1 │ │ │ │ - // GetCapabilities parser uses. We will store the last │ │ │ │ - // one encountered. │ │ │ │ - obj.dimensions[dim.name] = dim; │ │ │ │ - }, │ │ │ │ - "Keyword": function(node, obj) { │ │ │ │ - // TODO: should we change the structure of keyword in v1.js? │ │ │ │ - // Make it an object with a value instead of a string? │ │ │ │ - var keyword = { │ │ │ │ - value: this.getChildValue(node), │ │ │ │ - vocabulary: node.getAttribute("vocabulary") │ │ │ │ - }; │ │ │ │ - if (obj.keywords) { │ │ │ │ - obj.keywords.push(keyword); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]), │ │ │ │ - "sld": { │ │ │ │ - "UserDefinedSymbolization": function(node, obj) { │ │ │ │ - this.readers.wms.UserDefinedSymbolization.apply(this, [node, obj]); │ │ │ │ - // add the two extra attributes │ │ │ │ - obj.userSymbols.inlineFeature = parseInt(node.getAttribute("InlineFeature")) == 1; │ │ │ │ - obj.userSymbols.remoteWCS = parseInt(node.getAttribute("RemoteWCS")) == 1; │ │ │ │ - }, │ │ │ │ - "DescribeLayer": function(node, obj) { │ │ │ │ - this.readers.wms.DescribeLayer.apply(this, [node, obj]); │ │ │ │ - }, │ │ │ │ - "GetLegendGraphic": function(node, obj) { │ │ │ │ - this.readers.wms.GetLegendGraphic.apply(this, [node, obj]); │ │ │ │ + var pointList = []; │ │ │ │ + var lonStart = centerLatPoints[0].x; │ │ │ │ + var lonEnd = centerLatPoints[centerLatPoints.length - 1].x; │ │ │ │ + var lonDelta = (lonEnd - lonStart) / this.numPoints; │ │ │ │ + var lon = lonStart; │ │ │ │ + var labelPoint = null; │ │ │ │ + for (var i = 0; i <= this.numPoints; ++i) { │ │ │ │ + var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ + gridPoint.transform(llProj, mapProj); │ │ │ │ + pointList.push(gridPoint); │ │ │ │ + lon += lonDelta; │ │ │ │ + if (gridPoint.x < mapBounds.right) { │ │ │ │ + labelPoint = gridPoint; │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1_3_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities/v1_3.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities/v1_3_0 │ │ │ │ - * Read WMS Capabilities version 1.3.0. │ │ │ │ - * SLD 1.1.0 adds in the extra operations DescribeLayer and GetLegendGraphic, │ │ │ │ - * see: http://schemas.opengis.net/sld/1.1.0/sld_capabilities.xsd │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSCapabilities.v1_3> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_3_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSCapabilities.v1_3, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The specific parser version. │ │ │ │ - */ │ │ │ │ - version: "1.3.0", │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3_0" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1_1_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities/v1_1.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities/v1_1_0 │ │ │ │ - * Read WMS Capabilities version 1.1.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSCapabilities.v1_1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The specific parser version. │ │ │ │ - */ │ │ │ │ - version: "1.1.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSCapabilities.v1_1_0 │ │ │ │ - * Create a new parser for WMS capabilities version 1.1.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ - "SRS": function(node, obj) { │ │ │ │ - var srs = this.getChildValue(node); │ │ │ │ - var values = srs.split(/ +/); │ │ │ │ - for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ - obj.srs[values[i]] = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_0" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1_1_1.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities/v1_1.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities/v1_1_1 │ │ │ │ - * Read WMS Capabilities version 1.1.1. │ │ │ │ - * │ │ │ │ - * Note on <ScaleHint> parsing: If the 'min' attribute is set to "0", no │ │ │ │ - * maxScale will be set on the layer object. If the 'max' attribute is set to │ │ │ │ - * "Infinity", no minScale will be set. This makes it easy to create proper │ │ │ │ - * {<OpenLayers.Layer.WMS>} configurations directly from the layer object │ │ │ │ - * literals returned by this format, because no minScale/maxScale modifications │ │ │ │ - * need to be made. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSCapabilities.v1_1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1_1 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The specific parser version. │ │ │ │ - */ │ │ │ │ - version: "1.1.1", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSCapabilities.v1_1_1 │ │ │ │ - * Create a new parser for WMS capabilities version 1.1.1. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ - "SRS": function(node, obj) { │ │ │ │ - obj.srs[this.getChildValue(node)] = true; │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1" │ │ │ │ - │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMSCapabilities/v1_1_1_WMSC.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMSCapabilities/v1_1_1.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMSCapabilities/v1_1_1_WMSC │ │ │ │ - * Read WMS-C Capabilities version 1.1.1. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMSCapabilities.v1_1_1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMSCapabilities.v1_1_1, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The specific parser version. │ │ │ │ - */ │ │ │ │ - version: "1.1.1", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: profile │ │ │ │ - * {String} The specific profile │ │ │ │ - */ │ │ │ │ - profile: "WMSC", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMSCapabilities.v1_1_1 │ │ │ │ - * Create a new parser for WMS-C capabilities version 1.1.1. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wms": OpenLayers.Util.applyDefaults({ │ │ │ │ - "VendorSpecificCapabilities": function(node, obj) { │ │ │ │ - obj.vendorSpecific = { │ │ │ │ - tileSets: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.vendorSpecific); │ │ │ │ - }, │ │ │ │ - "TileSet": function(node, vendorSpecific) { │ │ │ │ - var tileset = { │ │ │ │ - srs: {}, │ │ │ │ - bbox: {}, │ │ │ │ - resolutions: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, tileset); │ │ │ │ - vendorSpecific.tileSets.push(tileset); │ │ │ │ - }, │ │ │ │ - "Resolutions": function(node, tileset) { │ │ │ │ - var res = this.getChildValue(node).split(" "); │ │ │ │ - for (var i = 0, len = res.length; i < len; i++) { │ │ │ │ - if (res[i] != "") { │ │ │ │ - tileset.resolutions.push(parseFloat(res[i])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Width": function(node, tileset) { │ │ │ │ - tileset.width = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "Height": function(node, tileset) { │ │ │ │ - tileset.height = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "Layers": function(node, tileset) { │ │ │ │ - tileset.layers = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Styles": function(node, tileset) { │ │ │ │ - tileset.styles = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1_1_1.prototype.readers["wms"]) │ │ │ │ - }, │ │ │ │ + if (this.labelled) { │ │ │ │ + //keep track of when this grid line crosses the map bounds to set │ │ │ │ + //the label position │ │ │ │ + //labels along the right, 30 pixel offset left into the map │ │ │ │ + //TODO add option for labels on left │ │ │ │ + var labelPos = new OpenLayers.Geometry.Point(mapBounds.right, labelPoint.y); │ │ │ │ + var labelAttrs = { │ │ │ │ + value: lat, │ │ │ │ + label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lat, "lat", this.labelFormat) : "", │ │ │ │ + labelAlign: "rb", │ │ │ │ + xOffset: -2, │ │ │ │ + yOffset: 2 │ │ │ │ + }; │ │ │ │ + this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)); │ │ │ │ + } │ │ │ │ + var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ + lines.push(new OpenLayers.Feature.Vector(geom)); │ │ │ │ + } │ │ │ │ + this.gratLayer.addFeatures(lines); │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Graticule" │ │ │ │ +}); │ │ │ │ │ │ │ │ - }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WPSCapabilities/v1_0_0.js │ │ │ │ + OpenLayers/Control/GetFeature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/WPSCapabilities.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Handler/Box.js │ │ │ │ + * @requires OpenLayers/Handler/Hover.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WPSCapabilities.v1_0_0 │ │ │ │ - * Read WPS Capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.GetFeature │ │ │ │ + * Gets vector features for locations underneath the mouse cursor. Can be │ │ │ │ + * configured to act on click, hover or dragged boxes. Uses an │ │ │ │ + * <OpenLayers.Protocol> that supports spatial filters to retrieve │ │ │ │ + * features from a server and fires events that notify applications of the │ │ │ │ + * selected features. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WPSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink" │ │ │ │ - }, │ │ │ │ +OpenLayers.Control.GetFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: protocol │ │ │ │ + * {<OpenLayers.Protocol>} Required. The protocol used for fetching │ │ │ │ + * features. │ │ │ │ + */ │ │ │ │ + protocol: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WPSCapabilities.v1_0_0 │ │ │ │ - * Create a new parser for WPS capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: multipleKey │ │ │ │ + * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ + * the <multiple> property to true. Default is null. │ │ │ │ + */ │ │ │ │ + multipleKey: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return info about the WPS. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Information about the WPS service. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: toggleKey │ │ │ │ + * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ + * the <toggle> property to true. Default is null. │ │ │ │ + */ │ │ │ │ + toggleKey: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wps": { │ │ │ │ - "Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "ProcessOfferings": function(node, obj) { │ │ │ │ - obj.processOfferings = {}; │ │ │ │ - this.readChildNodes(node, obj.processOfferings); │ │ │ │ - }, │ │ │ │ - "Process": function(node, processOfferings) { │ │ │ │ - var processVersion = this.getAttributeNS(node, this.namespaces.wps, "processVersion"); │ │ │ │ - var process = { │ │ │ │ - processVersion: processVersion │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, process); │ │ │ │ - processOfferings[process.identifier] = process; │ │ │ │ - }, │ │ │ │ - "Languages": function(node, obj) { │ │ │ │ - obj.languages = []; │ │ │ │ - this.readChildNodes(node, obj.languages); │ │ │ │ - }, │ │ │ │ - "Default": function(node, languages) { │ │ │ │ - var language = { │ │ │ │ - isDefault: true │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, language); │ │ │ │ - languages.push(language); │ │ │ │ - }, │ │ │ │ - "Supported": function(node, languages) { │ │ │ │ - var language = {}; │ │ │ │ - this.readChildNodes(node, language); │ │ │ │ - languages.push(language); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: modifiers │ │ │ │ + * {Object} The event modifiers to use, according to the current event │ │ │ │ + * being handled by this control's handlers │ │ │ │ + */ │ │ │ │ + modifiers: null, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WPSCapabilities.v1_0_0" │ │ │ │ + /** │ │ │ │ + * APIProperty: multiple │ │ │ │ + * {Boolean} Allow selection of multiple geometries. Default is false. │ │ │ │ + */ │ │ │ │ + multiple: false, │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/CSWGetRecords/v2_0_2.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * APIProperty: click │ │ │ │ + * {Boolean} Use a click handler for selecting/unselecting features. If │ │ │ │ + * both <click> and <box> are set to true, the click handler takes │ │ │ │ + * precedence over the box handler if a box with zero extent was │ │ │ │ + * selected. Default is true. │ │ │ │ + */ │ │ │ │ + click: true, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: single │ │ │ │ + * {Boolean} Tells whether select by click should select a single │ │ │ │ + * feature. If set to false, all matching features are selected. │ │ │ │ + * If set to true, only the best matching feature is selected. │ │ │ │ + * This option has an effect only of the <click> option is set │ │ │ │ + * to true. Default is true. │ │ │ │ + */ │ │ │ │ + single: true, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/CSWGetRecords.js │ │ │ │ - * @requires OpenLayers/Format/Filter/v1_0_0.js │ │ │ │ - * @requires OpenLayers/Format/Filter/v1_1_0.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_0_0.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: clickout │ │ │ │ + * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ + * Applies only if <click> is true. Default is true. │ │ │ │ + */ │ │ │ │ + clickout: true, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.CSWGetRecords.v2_0_2 │ │ │ │ - * A format for creating CSWGetRecords v2.0.2 transactions. │ │ │ │ - * Create a new instance with the │ │ │ │ - * <OpenLayers.Format.CSWGetRecords.v2_0_2> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.CSWGetRecords.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + /** │ │ │ │ + * APIProperty: toggle │ │ │ │ + * {Boolean} Unselect a selected feature on click. Applies only if │ │ │ │ + * <click> is true. Default is false. │ │ │ │ + */ │ │ │ │ + toggle: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * APIProperty: clickTolerance │ │ │ │ + * {Integer} Tolerance for the filter query in pixels. This has the │ │ │ │ + * same effect as the tolerance parameter on WMS GetFeatureInfo │ │ │ │ + * requests. Will be ignored for box selections. Applies only if │ │ │ │ + * <click> or <hover> is true. Default is 5. Note that this not │ │ │ │ + * only affects requests on click, but also on hover. │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - csw: "http://www.opengis.net/cat/csw/2.0.2", │ │ │ │ - dc: "http://purl.org/dc/elements/1.1/", │ │ │ │ - dct: "http://purl.org/dc/terms/", │ │ │ │ - gmd: "http://www.isotc211.org/2005/gmd", │ │ │ │ - geonet: "http://www.fao.org/geonetwork", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - ows: "http://www.opengis.net/ows", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ + clickTolerance: 5, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - * {String} The default prefix (used by Format.XML). │ │ │ │ + * APIProperty: hover │ │ │ │ + * {Boolean} Send feature requests on mouse moves. Default is false. │ │ │ │ */ │ │ │ │ - defaultPrefix: "csw", │ │ │ │ + hover: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: version │ │ │ │ - * {String} CSW version number. │ │ │ │ + * APIProperty: box │ │ │ │ + * {Boolean} Allow feature selection by drawing a box. If set to │ │ │ │ + * true set <click> to false to disable the click handler and │ │ │ │ + * rely on the box handler only, even for "zero extent" boxes. │ │ │ │ + * See the description of the <click> option for additional │ │ │ │ + * information. Default is false. │ │ │ │ */ │ │ │ │ - version: "2.0.2", │ │ │ │ + box: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/cat/csw/2.0.2 │ │ │ │ - * http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd │ │ │ │ + * APIProperty: maxFeatures │ │ │ │ + * {Integer} Maximum number of features to return from a query in single mode │ │ │ │ + * if supported by the <protocol>. This set of features is then used to │ │ │ │ + * determine the best match client-side. Default is 10. │ │ │ │ */ │ │ │ │ - schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ + maxFeatures: 10, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: requestId │ │ │ │ - * {String} Value of the requestId attribute of the GetRecords element. │ │ │ │ + * Property: features │ │ │ │ + * {Object} Hash of {<OpenLayers.Feature.Vector>}, keyed by fid, holding │ │ │ │ + * the currently selected features │ │ │ │ */ │ │ │ │ - requestId: null, │ │ │ │ + features: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: resultType │ │ │ │ - * {String} Value of the resultType attribute of the GetRecords element, │ │ │ │ - * specifies the result type in the GetRecords response, "hits" is │ │ │ │ - * the default. │ │ │ │ + * Proeprty: hoverFeature │ │ │ │ + * {<OpenLayers.Feature.Vector>} The feature currently selected by the │ │ │ │ + * hover handler │ │ │ │ */ │ │ │ │ - resultType: null, │ │ │ │ + hoverFeature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: outputFormat │ │ │ │ - * {String} Value of the outputFormat attribute of the GetRecords element, │ │ │ │ - * specifies the format of the GetRecords response, │ │ │ │ - * "application/xml" is the default. │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Additional options for the handlers used by this control. This │ │ │ │ + * is a hash with the keys "click", "box" and "hover". │ │ │ │ */ │ │ │ │ - outputFormat: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: outputSchema │ │ │ │ - * {String} Value of the outputSchema attribute of the GetRecords element, │ │ │ │ - * specifies the schema of the GetRecords response. │ │ │ │ + * Property: handlers │ │ │ │ + * {Object} Object with references to multiple <OpenLayers.Handler> │ │ │ │ + * instances. │ │ │ │ */ │ │ │ │ - outputSchema: null, │ │ │ │ + handlers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: startPosition │ │ │ │ - * {String} Value of the startPosition attribute of the GetRecords element, │ │ │ │ - * specifies the start position (offset+1) for the GetRecords response, │ │ │ │ - * 1 is the default. │ │ │ │ + * Property: hoverResponse │ │ │ │ + * {<OpenLayers.Protocol.Response>} The response object associated with │ │ │ │ + * the currently running hover request (if any). │ │ │ │ */ │ │ │ │ - startPosition: null, │ │ │ │ + hoverResponse: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxRecords │ │ │ │ - * {String} Value of the maxRecords attribute of the GetRecords element, │ │ │ │ - * specifies the maximum number of records in the GetRecords response, │ │ │ │ - * 10 is the default. │ │ │ │ + * Property: filterType │ │ │ │ + * {<String>} The type of filter to use when sending off a request. │ │ │ │ + * Possible values: │ │ │ │ + * OpenLayers.Filter.Spatial.<BBOX|INTERSECTS|WITHIN|CONTAINS> │ │ │ │ + * Defaults to: OpenLayers.Filter.Spatial.BBOX │ │ │ │ + */ │ │ │ │ + filterType: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforefeatureselected - Triggered when <click> is true before a │ │ │ │ + * feature is selected. The event object has a feature property with │ │ │ │ + * the feature about to select │ │ │ │ + * featureselected - Triggered when <click> is true and a feature is │ │ │ │ + * selected. The event object has a feature property with the │ │ │ │ + * selected feature │ │ │ │ + * beforefeaturesselected - Triggered when <click> is true before a │ │ │ │ + * set of features is selected. The event object is an array of │ │ │ │ + * feature properties with the features about to be selected. │ │ │ │ + * Return false after receiving this event to discontinue processing │ │ │ │ + * of all featureselected events and the featuresselected event. │ │ │ │ + * featuresselected - Triggered when <click> is true and a set of │ │ │ │ + * features is selected. The event object is an array of feature │ │ │ │ + * properties of the selected features │ │ │ │ + * featureunselected - Triggered when <click> is true and a feature is │ │ │ │ + * unselected. The event object has a feature property with the │ │ │ │ + * unselected feature │ │ │ │ + * clickout - Triggered when when <click> is true and no feature was │ │ │ │ + * selected. │ │ │ │ + * hoverfeature - Triggered when <hover> is true and the mouse has │ │ │ │ + * stopped over a feature │ │ │ │ + * outfeature - Triggered when <hover> is true and the mouse moves │ │ │ │ + * moved away from a hover-selected feature │ │ │ │ */ │ │ │ │ - maxRecords: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: DistributedSearch │ │ │ │ - * {String} Value of the csw:DistributedSearch element, used when writing │ │ │ │ - * a csw:GetRecords document. │ │ │ │ + * Constructor: OpenLayers.Control.GetFeature │ │ │ │ + * Create a new control for fetching remote features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} A configuration object which at least has to contain │ │ │ │ + * a <protocol> property (if not, it has to be set before a request is │ │ │ │ + * made) │ │ │ │ */ │ │ │ │ - DistributedSearch: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + options.handlerOptions = options.handlerOptions || {}; │ │ │ │ + │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + │ │ │ │ + this.features = {}; │ │ │ │ + │ │ │ │ + this.handlers = {}; │ │ │ │ + │ │ │ │ + if (this.click) { │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click(this, { │ │ │ │ + click: this.selectClick │ │ │ │ + }, this.handlerOptions.click || {}); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box = new OpenLayers.Handler.Box( │ │ │ │ + this, { │ │ │ │ + done: this.selectBox │ │ │ │ + }, │ │ │ │ + OpenLayers.Util.extend(this.handlerOptions.box, { │ │ │ │ + boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.hover) { │ │ │ │ + this.handlers.hover = new OpenLayers.Handler.Hover( │ │ │ │ + this, { │ │ │ │ + 'move': this.cancelHover, │ │ │ │ + 'pause': this.selectHover │ │ │ │ + }, │ │ │ │ + OpenLayers.Util.extend(this.handlerOptions.hover, { │ │ │ │ + 'delay': 250, │ │ │ │ + 'pixelTolerance': 2 │ │ │ │ + }) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ResponseHandler │ │ │ │ - * {Array({String})} Values of the csw:ResponseHandler elements, used when │ │ │ │ - * writting a csw:GetRecords document. │ │ │ │ + * Method: activate │ │ │ │ + * Activates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively activated. │ │ │ │ */ │ │ │ │ - ResponseHandler: null, │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + for (var i in this.handlers) { │ │ │ │ + this.handlers[i].activate(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: Query │ │ │ │ - * {String} Value of the csw:Query element, used when writing a csw:GetRecords │ │ │ │ - * document. │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively deactivated. │ │ │ │ */ │ │ │ │ - Query: null, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + for (var i in this.handlers) { │ │ │ │ + this.handlers[i].deactivate(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ + * Method: selectClick │ │ │ │ + * Called on click │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ + selectClick: function(evt) { │ │ │ │ + var bounds = this.pixelToBounds(evt.xy); │ │ │ │ + │ │ │ │ + this.setModifiers(evt); │ │ │ │ + this.request(bounds, { │ │ │ │ + single: this.single │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.CSWGetRecords.v2_0_2 │ │ │ │ - * A class for parsing and generating CSWGetRecords v2.0.2 transactions. │ │ │ │ + * Method: selectBox │ │ │ │ + * Callback from the handlers.box set up when <box> selection is on │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * position - {<OpenLayers.Bounds>|Object} An OpenLayers.Bounds or │ │ │ │ + * an object with a 'left', 'bottom', 'right' and 'top' properties. │ │ │ │ + */ │ │ │ │ + selectBox: function(position) { │ │ │ │ + var bounds; │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + bounds = new OpenLayers.Bounds( │ │ │ │ + minXY.lon, minXY.lat, maxXY.lon, maxXY.lat │ │ │ │ + ); │ │ │ │ + │ │ │ │ + } else { │ │ │ │ + if (this.click) { │ │ │ │ + // box without extent - let the click handler take care of it │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + bounds = this.pixelToBounds(position); │ │ │ │ + } │ │ │ │ + this.setModifiers(this.handlers.box.dragHandler.evt); │ │ │ │ + this.request(bounds); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: selectHover │ │ │ │ + * Callback from the handlers.hover set up when <hover> selection is on │ │ │ │ * │ │ │ │ - * Valid options properties (documented as class properties): │ │ │ │ - * - requestId │ │ │ │ - * - resultType │ │ │ │ - * - outputFormat │ │ │ │ - * - outputSchema │ │ │ │ - * - startPosition │ │ │ │ - * - maxRecords │ │ │ │ - * - DistributedSearch │ │ │ │ - * - ResponseHandler │ │ │ │ - * - Query │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} event object with an xy property │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + selectHover: function(evt) { │ │ │ │ + var bounds = this.pixelToBounds(evt.xy); │ │ │ │ + this.request(bounds, { │ │ │ │ + single: true, │ │ │ │ + hover: true │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Parse the response from a GetRecords request. │ │ │ │ + * Method: cancelHover │ │ │ │ + * Callback from the handlers.hover set up when <hover> selection is on │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ + cancelHover: function() { │ │ │ │ + if (this.hoverResponse) { │ │ │ │ + this.protocol.abort(this.hoverResponse); │ │ │ │ + this.hoverResponse = null; │ │ │ │ + │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ } │ │ │ │ - var obj = {}; │ │ │ │ - this.readNode(data, obj); │ │ │ │ - return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ + * Method: request │ │ │ │ + * Sends a GetFeature request to the WFS │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} bounds for the request's BBOX filter │ │ │ │ + * options - {Object} additional options for this method. │ │ │ │ + * │ │ │ │ + * Supported options include: │ │ │ │ + * single - {Boolean} A single feature should be returned. │ │ │ │ + * Note that this will be ignored if the protocol does not │ │ │ │ + * return the geometries of the features. │ │ │ │ + * hover - {Boolean} Do the request for the hover handler. │ │ │ │ */ │ │ │ │ - readers: { │ │ │ │ - "csw": { │ │ │ │ - "GetRecordsResponse": function(node, obj) { │ │ │ │ - obj.records = []; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - var version = this.getAttributeNS(node, "", 'version'); │ │ │ │ - if (version != "") { │ │ │ │ - obj.version = version; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "RequestId": function(node, obj) { │ │ │ │ - obj.RequestId = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "SearchStatus": function(node, obj) { │ │ │ │ - obj.SearchStatus = {}; │ │ │ │ - var timestamp = this.getAttributeNS(node, "", 'timestamp'); │ │ │ │ - if (timestamp != "") { │ │ │ │ - obj.SearchStatus.timestamp = timestamp; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "SearchResults": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var SearchResults = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - if ((attrs[i].name == "numberOfRecordsMatched") || │ │ │ │ - (attrs[i].name == "numberOfRecordsReturned") || │ │ │ │ - (attrs[i].name == "nextRecord")) { │ │ │ │ - SearchResults[attrs[i].name] = parseInt(attrs[i].nodeValue); │ │ │ │ + request: function(bounds, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: this.filterType, │ │ │ │ + value: bounds │ │ │ │ + }); │ │ │ │ + │ │ │ │ + // Set the cursor to "wait" to tell the user we're working. │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + │ │ │ │ + var response = this.protocol.read({ │ │ │ │ + maxFeatures: options.single == true ? this.maxFeatures : undefined, │ │ │ │ + filter: filter, │ │ │ │ + callback: function(result) { │ │ │ │ + if (result.success()) { │ │ │ │ + if (result.features.length) { │ │ │ │ + if (options.single == true) { │ │ │ │ + this.selectBestFeature(result.features, │ │ │ │ + bounds.getCenterLonLat(), options); │ │ │ │ + } else { │ │ │ │ + this.select(result.features); │ │ │ │ + } │ │ │ │ + } else if (options.hover) { │ │ │ │ + this.hoverSelect(); │ │ │ │ } else { │ │ │ │ - SearchResults[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ + this.events.triggerEvent("clickout"); │ │ │ │ + if (this.clickout) { │ │ │ │ + this.unselectAll(); │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - obj.SearchResults = SearchResults; │ │ │ │ - }, │ │ │ │ - "SummaryRecord": function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "SummaryRecord" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record); │ │ │ │ - }, │ │ │ │ - "BriefRecord": function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "BriefRecord" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record); │ │ │ │ - }, │ │ │ │ - "DCMIRecord": function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "DCMIRecord" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record); │ │ │ │ - }, │ │ │ │ - "Record": function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "Record" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record); │ │ │ │ + // Reset the cursor. │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ }, │ │ │ │ - "*": function(node, obj) { │ │ │ │ - var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ - obj[name] = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "geonet": { │ │ │ │ - "info": function(node, obj) { │ │ │ │ - var gninfo = {}; │ │ │ │ - this.readChildNodes(node, gninfo); │ │ │ │ - obj.gninfo = gninfo; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "dc": { │ │ │ │ - // audience, contributor, coverage, creator, date, description, format, │ │ │ │ - // identifier, language, provenance, publisher, relation, rights, │ │ │ │ - // rightsHolder, source, subject, title, type, URI │ │ │ │ - "*": function(node, obj) { │ │ │ │ - var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ - if (!(OpenLayers.Util.isArray(obj[name]))) { │ │ │ │ - obj[name] = []; │ │ │ │ - } │ │ │ │ - var dc_element = {}; │ │ │ │ - var attrs = node.attributes; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - dc_element[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ - } │ │ │ │ - dc_element.value = this.getChildValue(node); │ │ │ │ - if (dc_element.value != "") { │ │ │ │ - obj[name].push(dc_element); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "dct": { │ │ │ │ - // abstract, modified, spatial │ │ │ │ - "*": function(node, obj) { │ │ │ │ - var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ - if (!(OpenLayers.Util.isArray(obj[name]))) { │ │ │ │ - obj[name] = []; │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (options.hover == true) { │ │ │ │ + this.hoverResponse = response; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: selectBestFeature │ │ │ │ + * Selects the feature from an array of features that is the best match │ │ │ │ + * for the click position. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ + * clickPosition - {<OpenLayers.LonLat>} │ │ │ │ + * options - {Object} additional options for this method │ │ │ │ + * │ │ │ │ + * Supported options include: │ │ │ │ + * hover - {Boolean} Do the selection for the hover handler. │ │ │ │ + */ │ │ │ │ + selectBestFeature: function(features, clickPosition, options) { │ │ │ │ + options = options || {}; │ │ │ │ + if (features.length) { │ │ │ │ + var point = new OpenLayers.Geometry.Point(clickPosition.lon, │ │ │ │ + clickPosition.lat); │ │ │ │ + var feature, resultFeature, dist; │ │ │ │ + var minDist = Number.MAX_VALUE; │ │ │ │ + for (var i = 0; i < features.length; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (feature.geometry) { │ │ │ │ + dist = point.distanceTo(feature.geometry, { │ │ │ │ + edge: false │ │ │ │ + }); │ │ │ │ + if (dist < minDist) { │ │ │ │ + minDist = dist; │ │ │ │ + resultFeature = feature; │ │ │ │ + if (minDist == 0) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - obj[name].push(this.getChildValue(node)); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - "ows": OpenLayers.Util.applyDefaults({ │ │ │ │ - "BoundingBox": function(node, obj) { │ │ │ │ - if (obj.bounds) { │ │ │ │ - obj.BoundingBox = [{ │ │ │ │ - crs: obj.projection, │ │ │ │ - value: [ │ │ │ │ - obj.bounds.left, │ │ │ │ - obj.bounds.bottom, │ │ │ │ - obj.bounds.right, │ │ │ │ - obj.bounds.top │ │ │ │ - ] │ │ │ │ - }]; │ │ │ │ - delete obj.projection; │ │ │ │ - delete obj.bounds; │ │ │ │ - } │ │ │ │ - OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]["BoundingBox"].apply( │ │ │ │ - this, arguments); │ │ │ │ + │ │ │ │ + if (options.hover == true) { │ │ │ │ + this.hoverSelect(resultFeature); │ │ │ │ + } else { │ │ │ │ + this.select(resultFeature || features); │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]) │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ - * Given an configuration js object, write a CSWGetRecords request. │ │ │ │ - * │ │ │ │ + * Method: setModifiers │ │ │ │ + * Sets the multiple and toggle modifiers according to the current event │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} A object mapping the request. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A serialized CSWGetRecords request. │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - write: function(options) { │ │ │ │ - var node = this.writeNode("csw:GetRecords", options); │ │ │ │ - node.setAttribute("xmlns:gmd", this.namespaces.gmd); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + setModifiers: function(evt) { │ │ │ │ + this.modifiers = { │ │ │ │ + multiple: this.multiple || (this.multipleKey && evt[this.multipleKey]), │ │ │ │ + toggle: this.toggle || (this.toggleKey && evt[this.toggleKey]) │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * Method: select │ │ │ │ + * Add feature to the hash of selected features and trigger the │ │ │ │ + * featureselected and featuresselected events. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {<OpenLayers.Feature.Vector>} or an array of features │ │ │ │ */ │ │ │ │ - writers: { │ │ │ │ - "csw": { │ │ │ │ - "GetRecords": function(options) { │ │ │ │ - if (!options) { │ │ │ │ - options = {}; │ │ │ │ - } │ │ │ │ - var node = this.createElementNSPlus("csw:GetRecords", { │ │ │ │ - attributes: { │ │ │ │ - service: "CSW", │ │ │ │ - version: this.version, │ │ │ │ - requestId: options.requestId || this.requestId, │ │ │ │ - resultType: options.resultType || this.resultType, │ │ │ │ - outputFormat: options.outputFormat || this.outputFormat, │ │ │ │ - outputSchema: options.outputSchema || this.outputSchema, │ │ │ │ - startPosition: options.startPosition || this.startPosition, │ │ │ │ - maxRecords: options.maxRecords || this.maxRecords │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.DistributedSearch || this.DistributedSearch) { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:DistributedSearch", │ │ │ │ - options.DistributedSearch || this.DistributedSearch, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - var ResponseHandler = options.ResponseHandler || this.ResponseHandler; │ │ │ │ - if (OpenLayers.Util.isArray(ResponseHandler) && ResponseHandler.length > 0) { │ │ │ │ - // ResponseHandler must be a non-empty array │ │ │ │ - for (var i = 0, len = ResponseHandler.length; i < len; i++) { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:ResponseHandler", │ │ │ │ - ResponseHandler[i], │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.writeNode("Query", options.Query || this.Query, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "DistributedSearch": function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:DistributedSearch", { │ │ │ │ - attributes: { │ │ │ │ - hopCount: options.hopCount │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ResponseHandler": function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:ResponseHandler", { │ │ │ │ - value: options.value │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Query": function(options) { │ │ │ │ - if (!options) { │ │ │ │ - options = {}; │ │ │ │ - } │ │ │ │ - var node = this.createElementNSPlus("csw:Query", { │ │ │ │ - attributes: { │ │ │ │ - typeNames: options.typeNames || "csw:Record" │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - var ElementName = options.ElementName; │ │ │ │ - if (OpenLayers.Util.isArray(ElementName) && ElementName.length > 0) { │ │ │ │ - // ElementName must be a non-empty array │ │ │ │ - for (var i = 0, len = ElementName.length; i < len; i++) { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:ElementName", │ │ │ │ - ElementName[i], │ │ │ │ - node │ │ │ │ - ); │ │ │ │ + select: function(features) { │ │ │ │ + if (!this.modifiers.multiple && !this.modifiers.toggle) { │ │ │ │ + this.unselectAll(); │ │ │ │ + } │ │ │ │ + if (!(OpenLayers.Util.isArray(features))) { │ │ │ │ + features = [features]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var cont = this.events.triggerEvent("beforefeaturesselected", { │ │ │ │ + features: features │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + var selectedFeatures = []; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (this.features[feature.fid || feature.id]) { │ │ │ │ + if (this.modifiers.toggle) { │ │ │ │ + this.unselect(this.features[feature.fid || feature.id]); │ │ │ │ } │ │ │ │ } else { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:ElementSetName", │ │ │ │ - options.ElementSetName || { │ │ │ │ - value: 'summary' │ │ │ │ - }, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (options.Constraint) { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:Constraint", │ │ │ │ - options.Constraint, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - if (options.SortBy) { │ │ │ │ - this.writeNode( │ │ │ │ - "ogc:SortBy", │ │ │ │ - options.SortBy, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ElementName": function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:ElementName", { │ │ │ │ - value: options.value │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ElementSetName": function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:ElementSetName", { │ │ │ │ - attributes: { │ │ │ │ - typeNames: options.typeNames │ │ │ │ - }, │ │ │ │ - value: options.value │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Constraint": function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:Constraint", { │ │ │ │ - attributes: { │ │ │ │ - version: options.version │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.Filter) { │ │ │ │ - var format = new OpenLayers.Format.Filter({ │ │ │ │ - version: options.version │ │ │ │ - }); │ │ │ │ - node.appendChild(format.write(options.Filter)); │ │ │ │ - } else if (options.CqlText) { │ │ │ │ - var child = this.createElementNSPlus("CqlText", { │ │ │ │ - value: options.CqlText.value │ │ │ │ + cont = this.events.triggerEvent("beforefeatureselected", { │ │ │ │ + feature: feature │ │ │ │ }); │ │ │ │ - node.appendChild(child); │ │ │ │ + if (cont !== false) { │ │ │ │ + this.features[feature.fid || feature.id] = feature; │ │ │ │ + selectedFeatures.push(feature); │ │ │ │ + │ │ │ │ + this.events.triggerEvent("featureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return node; │ │ │ │ } │ │ │ │ - }, │ │ │ │ - "ogc": OpenLayers.Format.Filter.v1_1_0.prototype.writers["ogc"] │ │ │ │ + this.events.triggerEvent("featuresselected", { │ │ │ │ + features: selectedFeatures │ │ │ │ + }); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.CSWGetRecords.v2_0_2" │ │ │ │ + /** │ │ │ │ + * Method: hoverSelect │ │ │ │ + * Sets/unsets the <hoverFeature> │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} the feature to hover-select. │ │ │ │ + * If none is provided, the current <hoverFeature> will be nulled and │ │ │ │ + * the outfeature event will be triggered. │ │ │ │ + */ │ │ │ │ + hoverSelect: function(feature) { │ │ │ │ + var fid = feature ? feature.fid || feature.id : null; │ │ │ │ + var hfid = this.hoverFeature ? │ │ │ │ + this.hoverFeature.fid || this.hoverFeature.id : null; │ │ │ │ + │ │ │ │ + if (hfid && hfid != fid) { │ │ │ │ + this.events.triggerEvent("outfeature", { │ │ │ │ + feature: this.hoverFeature │ │ │ │ + }); │ │ │ │ + this.hoverFeature = null; │ │ │ │ + } │ │ │ │ + if (fid && fid != hfid) { │ │ │ │ + this.events.triggerEvent("hoverfeature", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.hoverFeature = feature; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: unselect │ │ │ │ + * Remove feature from the hash of selected features and trigger the │ │ │ │ + * featureunselected event. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + unselect: function(feature) { │ │ │ │ + delete this.features[feature.fid || feature.id]; │ │ │ │ + this.events.triggerEvent("featureunselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: unselectAll │ │ │ │ + * Unselect all selected features. │ │ │ │ + */ │ │ │ │ + unselectAll: function() { │ │ │ │ + // we'll want an option to supress notification here │ │ │ │ + for (var fid in this.features) { │ │ │ │ + this.unselect(this.features[fid]); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + for (var i in this.handlers) { │ │ │ │ + this.handlers[i].setMap(map); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: pixelToBounds │ │ │ │ + * Takes a pixel as argument and creates bounds after adding the │ │ │ │ + * <clickTolerance>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * pixel - {<OpenLayers.Pixel>} │ │ │ │ + */ │ │ │ │ + pixelToBounds: function(pixel) { │ │ │ │ + var llPx = pixel.add(-this.clickTolerance / 2, this.clickTolerance / 2); │ │ │ │ + var urPx = pixel.add(this.clickTolerance / 2, -this.clickTolerance / 2); │ │ │ │ + var ll = this.map.getLonLatFromPixel(llPx); │ │ │ │ + var ur = this.map.getLonLatFromPixel(urPx); │ │ │ │ + return new OpenLayers.Bounds(ll.lon, ll.lat, ur.lon, ur.lat); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.GetFeature" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/SLD/v1_0_0_GeoServer.js │ │ │ │ + OpenLayers/Control/Measure.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.SLD/v1_0_0_GeoServer │ │ │ │ - * Read and write SLD version 1.0.0 with GeoServer-specific enhanced options. │ │ │ │ - * See http://svn.osgeo.org/geotools/trunk/modules/extension/xsd/xsd-sld/src/main/resources/org/geotools/sld/bindings/StyledLayerDescriptor.xsd │ │ │ │ - * for more information. │ │ │ │ + * Class: OpenLayers.Control.Measure │ │ │ │ + * Allows for drawing of features for measurements. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.SLD.v1_0_0> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.SLD.v1_0_0_GeoServer = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.SLD.v1_0_0, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The specific parser version. │ │ │ │ - */ │ │ │ │ - version: "1.0.0", │ │ │ │ +OpenLayers.Control.Measure = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: profile │ │ │ │ - * {String} The specific profile │ │ │ │ - */ │ │ │ │ - profile: "GeoServer", │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * measure - Triggered when a measurement sketch is complete. Listeners │ │ │ │ + * will receive an event with measure, units, order, and geometry │ │ │ │ + * properties. │ │ │ │ + * measurepartial - Triggered when a new point is added to the │ │ │ │ + * measurement sketch or if the <immediate> property is true and the │ │ │ │ + * measurement sketch is modified. Listeners receive an event with measure, │ │ │ │ + * units, order, and geometry. │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.SLD.v1_0_0_GeoServer │ │ │ │ - * Create a new parser for GeoServer-enhanced SLD version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Used to set non-default properties on the control's handler │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: OpenLayers.Util.applyDefaults({ │ │ │ │ - "sld": OpenLayers.Util.applyDefaults({ │ │ │ │ - "Priority": function(node, obj) { │ │ │ │ - var value = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (value) { │ │ │ │ - obj.priority = value; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "VendorOption": function(node, obj) { │ │ │ │ - if (!obj.vendorOptions) { │ │ │ │ - obj.vendorOptions = {}; │ │ │ │ - } │ │ │ │ - obj.vendorOptions[node.getAttribute("name")] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "TextSymbolizer": function(node, rule) { │ │ │ │ - OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld.TextSymbolizer.apply(this, arguments); │ │ │ │ - var symbolizer = this.multipleSymbolizers ? rule.symbolizers[rule.symbolizers.length - 1] : rule.symbolizer["Text"]; │ │ │ │ - if (symbolizer.graphic === undefined) { │ │ │ │ - symbolizer.graphic = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.readers["sld"]) │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.readers), │ │ │ │ + /** │ │ │ │ + * Property: callbacks │ │ │ │ + * {Object} The functions that are sent to the handler for callback │ │ │ │ + */ │ │ │ │ + callbacks: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ - */ │ │ │ │ - writers: OpenLayers.Util.applyDefaults({ │ │ │ │ - "sld": OpenLayers.Util.applyDefaults({ │ │ │ │ - "Priority": function(priority) { │ │ │ │ - return this.writers.sld._OGCExpression.call( │ │ │ │ - this, "sld:Priority", priority │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - "VendorOption": function(option) { │ │ │ │ - return this.createElementNSPlus("sld:VendorOption", { │ │ │ │ - attributes: { │ │ │ │ - name: option.name │ │ │ │ - }, │ │ │ │ - value: option.value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "TextSymbolizer": function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["TextSymbolizer"].apply(this, arguments); │ │ │ │ - if (symbolizer.graphic !== false && (symbolizer.externalGraphic || symbolizer.graphicName)) { │ │ │ │ - this.writeNode("Graphic", symbolizer, node); │ │ │ │ - } │ │ │ │ - if ("priority" in symbolizer) { │ │ │ │ - this.writeNode("Priority", symbolizer.priority, node); │ │ │ │ - } │ │ │ │ - return this.addVendorOptions(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "PointSymbolizer": function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["PointSymbolizer"].apply(this, arguments); │ │ │ │ - return this.addVendorOptions(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "LineSymbolizer": function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["LineSymbolizer"].apply(this, arguments); │ │ │ │ - return this.addVendorOptions(node, symbolizer); │ │ │ │ - }, │ │ │ │ - "PolygonSymbolizer": function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["PolygonSymbolizer"].apply(this, arguments); │ │ │ │ - return this.addVendorOptions(node, symbolizer); │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.writers["sld"]) │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.writers), │ │ │ │ + /** │ │ │ │ + * APIProperty: displaySystem │ │ │ │ + * {String} Display system for output measurements. Supported values │ │ │ │ + * are 'english', 'metric', and 'geographic'. Default is 'metric'. │ │ │ │ + */ │ │ │ │ + displaySystem: 'metric', │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: addVendorOptions │ │ │ │ - * Add in the VendorOption tags and return the node again. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} A DOM node. │ │ │ │ - * symbolizer - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A DOM node. │ │ │ │ - */ │ │ │ │ - addVendorOptions: function(node, symbolizer) { │ │ │ │ - var options = symbolizer.vendorOptions; │ │ │ │ - if (options) { │ │ │ │ - for (var key in symbolizer.vendorOptions) { │ │ │ │ - this.writeNode("VendorOption", { │ │ │ │ - name: key, │ │ │ │ - value: symbolizer.vendorOptions[key] │ │ │ │ - }, node); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: geodesic │ │ │ │ + * {Boolean} Calculate geodesic metrics instead of planar metrics. This │ │ │ │ + * requires that geometries can be transformed into Geographic/WGS84 │ │ │ │ + * (if that is not already the map projection). Default is false. │ │ │ │ + */ │ │ │ │ + geodesic: false, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0_GeoServer" │ │ │ │ + /** │ │ │ │ + * Property: displaySystemUnits │ │ │ │ + * {Object} Units for various measurement systems. Values are arrays │ │ │ │ + * of unit abbreviations (from OpenLayers.INCHES_PER_UNIT) in decreasing │ │ │ │ + * order of length. │ │ │ │ + */ │ │ │ │ + displaySystemUnits: { │ │ │ │ + geographic: ['dd'], │ │ │ │ + english: ['mi', 'ft', 'in'], │ │ │ │ + metric: ['km', 'm'] │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/CSWGetDomain/v2_0_2.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Property: delay │ │ │ │ + * {Number} Number of milliseconds between clicks before the event is │ │ │ │ + * considered a double-click. The "measurepartial" event will not │ │ │ │ + * be triggered if the sketch is completed within this time. This │ │ │ │ + * is required for IE where creating a browser reflow (if a listener │ │ │ │ + * is modifying the DOM by displaying the measurement values) messes │ │ │ │ + * with the dblclick listener in the sketch handler. │ │ │ │ + */ │ │ │ │ + partialDelay: 300, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * Property: delayedTrigger │ │ │ │ + * {Number} Timeout id of trigger for measurepartial. │ │ │ │ + */ │ │ │ │ + delayedTrigger: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/CSWGetDomain.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: persist │ │ │ │ + * {Boolean} Keep the temporary measurement sketch drawn after the │ │ │ │ + * measurement is complete. The geometry will persist until a new │ │ │ │ + * measurement is started, the control is deactivated, or <cancel> is │ │ │ │ + * called. │ │ │ │ + */ │ │ │ │ + persist: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.CSWGetDomain.v2_0_2 │ │ │ │ - * A format for creating CSWGetDomain v2.0.2 transactions. │ │ │ │ - * Create a new instance with the │ │ │ │ - * <OpenLayers.Format.CSWGetDomain.v2_0_2> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.CSWGetDomain.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + /** │ │ │ │ + * APIProperty: immediate │ │ │ │ + * {Boolean} Activates the immediate measurement so that the "measurepartial" │ │ │ │ + * event is also fired once the measurement sketch is modified. │ │ │ │ + * Default is false. │ │ │ │ + */ │ │ │ │ + immediate: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * Constructor: OpenLayers.Control.Measure │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * handler - {<OpenLayers.Handler>} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - csw: "http://www.opengis.net/cat/csw/2.0.2" │ │ │ │ + initialize: function(handler, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + var callbacks = { │ │ │ │ + done: this.measureComplete, │ │ │ │ + point: this.measurePartial │ │ │ │ + }; │ │ │ │ + if (this.immediate) { │ │ │ │ + callbacks.modify = this.measureImmediate; │ │ │ │ + } │ │ │ │ + this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ + │ │ │ │ + // let the handler options override, so old code that passes 'persist' │ │ │ │ + // directly to the handler does not need an update │ │ │ │ + this.handlerOptions = OpenLayers.Util.extend({ │ │ │ │ + persist: this.persist │ │ │ │ + }, this.handlerOptions); │ │ │ │ + this.handler = new handler(this, this.callbacks, this.handlerOptions); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - * {String} The default prefix (used by Format.XML). │ │ │ │ + * APIMethod: deactivate │ │ │ │ */ │ │ │ │ - defaultPrefix: "csw", │ │ │ │ + deactivate: function() { │ │ │ │ + this.cancelDelay(); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: version │ │ │ │ - * {String} CSW version number. │ │ │ │ + * APIMethod: cancel │ │ │ │ + * Stop the control from measuring. If <persist> is true, the temporary │ │ │ │ + * sketch will be erased. │ │ │ │ */ │ │ │ │ - version: "2.0.2", │ │ │ │ + cancel: function() { │ │ │ │ + this.cancelDelay(); │ │ │ │ + this.handler.cancel(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/cat/csw/2.0.2 │ │ │ │ - * http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd │ │ │ │ + * APIMethod: setImmediate │ │ │ │ + * Sets the <immediate> property. Changes the activity of immediate │ │ │ │ + * measurement. │ │ │ │ */ │ │ │ │ - schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ + setImmediate: function(immediate) { │ │ │ │ + this.immediate = immediate; │ │ │ │ + if (this.immediate) { │ │ │ │ + this.callbacks.modify = this.measureImmediate; │ │ │ │ + } else { │ │ │ │ + delete this.callbacks.modify; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: PropertyName │ │ │ │ - * {String} Value of the csw:PropertyName element, used when │ │ │ │ - * writing a GetDomain document. │ │ │ │ + * Method: updateHandler │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * handler - {Function} One of the sketch handler constructors. │ │ │ │ + * options - {Object} Options for the handler. │ │ │ │ */ │ │ │ │ - PropertyName: null, │ │ │ │ + updateHandler: function(handler, options) { │ │ │ │ + var active = this.active; │ │ │ │ + if (active) { │ │ │ │ + this.deactivate(); │ │ │ │ + } │ │ │ │ + this.handler = new handler(this, this.callbacks, options); │ │ │ │ + if (active) { │ │ │ │ + this.activate(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ParameterName │ │ │ │ - * {String} Value of the csw:ParameterName element, used when │ │ │ │ - * writing a GetDomain document. │ │ │ │ + * Method: measureComplete │ │ │ │ + * Called when the measurement sketch is done. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - ParameterName: null, │ │ │ │ + measureComplete: function(geometry) { │ │ │ │ + this.cancelDelay(); │ │ │ │ + this.measure(geometry, "measure"); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.CSWGetDomain.v2_0_2 │ │ │ │ - * A class for parsing and generating CSWGetDomain v2.0.2 transactions. │ │ │ │ + * Method: measurePartial │ │ │ │ + * Called each time a new point is added to the measurement sketch. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} The last point added. │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The sketch geometry. │ │ │ │ + */ │ │ │ │ + measurePartial: function(point, geometry) { │ │ │ │ + this.cancelDelay(); │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + // when we're wating for a dblclick, we have to trigger measurepartial │ │ │ │ + // after some delay to deal with reflow issues in IE │ │ │ │ + if (this.handler.freehandMode(this.handler.evt)) { │ │ │ │ + // no dblclick in freehand mode │ │ │ │ + this.measure(geometry, "measurepartial"); │ │ │ │ + } else { │ │ │ │ + this.delayedTrigger = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(function() { │ │ │ │ + this.delayedTrigger = null; │ │ │ │ + this.measure(geometry, "measurepartial"); │ │ │ │ + }, this), │ │ │ │ + this.partialDelay │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: measureImmediate │ │ │ │ + * Called each time the measurement sketch is modified. │ │ │ │ * │ │ │ │ - * Valid options properties: │ │ │ │ - * - PropertyName │ │ │ │ - * - ParameterName │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} The point at the mouse position. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} The sketch feature. │ │ │ │ + * drawing - {Boolean} Indicates whether we're currently drawing. │ │ │ │ */ │ │ │ │ + measureImmediate: function(point, feature, drawing) { │ │ │ │ + if (drawing && !this.handler.freehandMode(this.handler.evt)) { │ │ │ │ + this.cancelDelay(); │ │ │ │ + this.measure(feature.geometry, "measurepartial"); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Parse the response from a GetDomain request. │ │ │ │ + * Method: cancelDelay │ │ │ │ + * Cancels the delay measurement that measurePartial began. │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + cancelDelay: function() { │ │ │ │ + if (this.delayedTrigger !== null) { │ │ │ │ + window.clearTimeout(this.delayedTrigger); │ │ │ │ + this.delayedTrigger = null; │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: measure │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * eventType - {String} │ │ │ │ + */ │ │ │ │ + measure: function(geometry, eventType) { │ │ │ │ + var stat, order; │ │ │ │ + if (geometry.CLASS_NAME.indexOf('LineString') > -1) { │ │ │ │ + stat = this.getBestLength(geometry); │ │ │ │ + order = 1; │ │ │ │ + } else { │ │ │ │ + stat = this.getBestArea(geometry); │ │ │ │ + order = 2; │ │ │ │ } │ │ │ │ - var obj = {}; │ │ │ │ - this.readNode(data, obj); │ │ │ │ - return obj; │ │ │ │ + this.events.triggerEvent(eventType, { │ │ │ │ + measure: stat[0], │ │ │ │ + units: stat[1], │ │ │ │ + order: order, │ │ │ │ + geometry: geometry │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ + * Method: getBestArea │ │ │ │ + * Based on the <displaySystem> returns the area of a geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array([Float, String])} Returns a two item array containing the │ │ │ │ + * area and the units abbreviation. │ │ │ │ */ │ │ │ │ - readers: { │ │ │ │ - "csw": { │ │ │ │ - "GetDomainResponse": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "DomainValues": function(node, obj) { │ │ │ │ - if (!(OpenLayers.Util.isArray(obj.DomainValues))) { │ │ │ │ - obj.DomainValues = []; │ │ │ │ - } │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var domainValue = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - domainValue[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, domainValue); │ │ │ │ - obj.DomainValues.push(domainValue); │ │ │ │ - }, │ │ │ │ - "PropertyName": function(node, obj) { │ │ │ │ - obj.PropertyName = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ParameterName": function(node, obj) { │ │ │ │ - obj.ParameterName = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ListOfValues": function(node, obj) { │ │ │ │ - if (!(OpenLayers.Util.isArray(obj.ListOfValues))) { │ │ │ │ - obj.ListOfValues = []; │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, obj.ListOfValues); │ │ │ │ - }, │ │ │ │ - "Value": function(node, obj) { │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var value = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - value[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ - } │ │ │ │ - value.value = this.getChildValue(node); │ │ │ │ - obj.push({ │ │ │ │ - Value: value │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "ConceptualScheme": function(node, obj) { │ │ │ │ - obj.ConceptualScheme = {}; │ │ │ │ - this.readChildNodes(node, obj.ConceptualScheme); │ │ │ │ - }, │ │ │ │ - "Name": function(node, obj) { │ │ │ │ - obj.Name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Document": function(node, obj) { │ │ │ │ - obj.Document = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Authority": function(node, obj) { │ │ │ │ - obj.Authority = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "RangeOfValues": function(node, obj) { │ │ │ │ - obj.RangeOfValues = {}; │ │ │ │ - this.readChildNodes(node, obj.RangeOfValues); │ │ │ │ - }, │ │ │ │ - "MinValue": function(node, obj) { │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var value = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - value[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ - } │ │ │ │ - value.value = this.getChildValue(node); │ │ │ │ - obj.MinValue = value; │ │ │ │ - }, │ │ │ │ - "MaxValue": function(node, obj) { │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var value = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - value[attrs[i].name] = attrs[i].nodeValue; │ │ │ │ - } │ │ │ │ - value.value = this.getChildValue(node); │ │ │ │ - obj.MaxValue = value; │ │ │ │ + getBestArea: function(geometry) { │ │ │ │ + var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ + var unit, area; │ │ │ │ + for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ + unit = units[i]; │ │ │ │ + area = this.getArea(geometry, unit); │ │ │ │ + if (area > 1) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ + return [area, unit]; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Given an configuration js object, write a CSWGetDomain request. │ │ │ │ + * Method: getArea │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} A object mapping the request. │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * units - {String} Unit abbreviation │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A serialized CSWGetDomain request. │ │ │ │ + * {Float} The geometry area in the given units. │ │ │ │ */ │ │ │ │ - write: function(options) { │ │ │ │ - var node = this.writeNode("csw:GetDomain", options); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + getArea: function(geometry, units) { │ │ │ │ + var area, geomUnits; │ │ │ │ + if (this.geodesic) { │ │ │ │ + area = geometry.getGeodesicArea(this.map.getProjectionObject()); │ │ │ │ + geomUnits = "m"; │ │ │ │ + } else { │ │ │ │ + area = geometry.getArea(); │ │ │ │ + geomUnits = this.map.getUnits(); │ │ │ │ + } │ │ │ │ + var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ + if (inPerDisplayUnit) { │ │ │ │ + var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ + area *= Math.pow((inPerMapUnit / inPerDisplayUnit), 2); │ │ │ │ + } │ │ │ │ + return area; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * Method: getBestLength │ │ │ │ + * Based on the <displaySystem> returns the length of a geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array([Float, String])} Returns a two item array containing the │ │ │ │ + * length and the units abbreviation. │ │ │ │ */ │ │ │ │ - writers: { │ │ │ │ - "csw": { │ │ │ │ - "GetDomain": function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:GetDomain", { │ │ │ │ - attributes: { │ │ │ │ - service: "CSW", │ │ │ │ - version: this.version │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.PropertyName || this.PropertyName) { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:PropertyName", │ │ │ │ - options.PropertyName || this.PropertyName, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } else if (options.ParameterName || this.ParameterName) { │ │ │ │ - this.writeNode( │ │ │ │ - "csw:ParameterName", │ │ │ │ - options.ParameterName || this.ParameterName, │ │ │ │ - node │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, options); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "PropertyName": function(value) { │ │ │ │ - var node = this.createElementNSPlus("csw:PropertyName", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ParameterName": function(value) { │ │ │ │ - var node = this.createElementNSPlus("csw:ParameterName", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ + getBestLength: function(geometry) { │ │ │ │ + var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ + var unit, length; │ │ │ │ + for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ + unit = units[i]; │ │ │ │ + length = this.getLength(geometry, unit); │ │ │ │ + if (length > 1) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ + return [length, unit]; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.CSWGetDomain.v2_0_2" │ │ │ │ + /** │ │ │ │ + * Method: getLength │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * units - {String} Unit abbreviation │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The geometry length in the given units. │ │ │ │ + */ │ │ │ │ + getLength: function(geometry, units) { │ │ │ │ + var length, geomUnits; │ │ │ │ + if (this.geodesic) { │ │ │ │ + length = geometry.getGeodesicLength(this.map.getProjectionObject()); │ │ │ │ + geomUnits = "m"; │ │ │ │ + } else { │ │ │ │ + length = geometry.getLength(); │ │ │ │ + geomUnits = this.map.getUnits(); │ │ │ │ + } │ │ │ │ + var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ + if (inPerDisplayUnit) { │ │ │ │ + var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ + length *= (inPerMapUnit / inPerDisplayUnit); │ │ │ │ + } │ │ │ │ + return length; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Measure" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WMTSCapabilities/v1_0_0.js │ │ │ │ + OpenLayers/Control/ZoomOut.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/WMTSCapabilities.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + * @requires OpenLayers/Control/Button.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WMTSCapabilities.v1_0_0 │ │ │ │ - * Read WMTS Capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.ZoomOut │ │ │ │ + * The ZoomOut control is a button to decrease the zoom level of a map. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMTSCapabilities> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WMTSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.OWSCommon.v1_1_0, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} The parser version ("1.0.0"). │ │ │ │ - */ │ │ │ │ - version: "1.0.0", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - wmts: "http://www.opengis.net/wmts/1.0", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: yx │ │ │ │ - * {Object} Members in the yx object are used to determine if a CRS URN │ │ │ │ - * corresponds to a CRS with y,x axis order. Member names are CRS URNs │ │ │ │ - * and values are boolean. Defaults come from the │ │ │ │ - * <OpenLayers.Format.WMTSCapabilities> prototype. │ │ │ │ - */ │ │ │ │ - yx: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - * {String} The default namespace alias for creating element nodes. │ │ │ │ - */ │ │ │ │ - defaultPrefix: "wmts", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMTSCapabilities.v1_0_0 │ │ │ │ - * Create a new parser for WMTS capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options; │ │ │ │ - var yx = OpenLayers.Util.extend({}, OpenLayers.Format.WMTSCapabilities.prototype.yx); │ │ │ │ - this.yx = OpenLayers.Util.extend(yx, this.yx); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return info about the WMTS. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Information about the SOS service. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - capabilities.version = this.version; │ │ │ │ - return capabilities; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wmts": { │ │ │ │ - "Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Contents": function(node, obj) { │ │ │ │ - obj.contents = {}; │ │ │ │ - obj.contents.layers = []; │ │ │ │ - obj.contents.tileMatrixSets = {}; │ │ │ │ - this.readChildNodes(node, obj.contents); │ │ │ │ - }, │ │ │ │ - "Layer": function(node, obj) { │ │ │ │ - var layer = { │ │ │ │ - styles: [], │ │ │ │ - formats: [], │ │ │ │ - dimensions: [], │ │ │ │ - tileMatrixSetLinks: [] │ │ │ │ - }; │ │ │ │ - layer.layers = []; │ │ │ │ - this.readChildNodes(node, layer); │ │ │ │ - obj.layers.push(layer); │ │ │ │ - }, │ │ │ │ - "Style": function(node, obj) { │ │ │ │ - var style = {}; │ │ │ │ - style.isDefault = (node.getAttribute("isDefault") === "true"); │ │ │ │ - this.readChildNodes(node, style); │ │ │ │ - obj.styles.push(style); │ │ │ │ - }, │ │ │ │ - "Format": function(node, obj) { │ │ │ │ - obj.formats.push(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "TileMatrixSetLink": function(node, obj) { │ │ │ │ - var tileMatrixSetLink = {}; │ │ │ │ - this.readChildNodes(node, tileMatrixSetLink); │ │ │ │ - obj.tileMatrixSetLinks.push(tileMatrixSetLink); │ │ │ │ - }, │ │ │ │ - "TileMatrixSet": function(node, obj) { │ │ │ │ - // node could be child of wmts:Contents or wmts:TileMatrixSetLink │ │ │ │ - // duck type wmts:Contents by looking for layers │ │ │ │ - if (obj.layers) { │ │ │ │ - // TileMatrixSet as object type in schema │ │ │ │ - var tileMatrixSet = { │ │ │ │ - matrixIds: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, tileMatrixSet); │ │ │ │ - obj.tileMatrixSets[tileMatrixSet.identifier] = tileMatrixSet; │ │ │ │ - } else { │ │ │ │ - // TileMatrixSet as string type in schema │ │ │ │ - obj.tileMatrixSet = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "TileMatrix": function(node, obj) { │ │ │ │ - var tileMatrix = { │ │ │ │ - supportedCRS: obj.supportedCRS │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, tileMatrix); │ │ │ │ - obj.matrixIds.push(tileMatrix); │ │ │ │ - }, │ │ │ │ - "ScaleDenominator": function(node, obj) { │ │ │ │ - obj.scaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "TopLeftCorner": function(node, obj) { │ │ │ │ - var topLeftCorner = this.getChildValue(node); │ │ │ │ - var coords = topLeftCorner.split(" "); │ │ │ │ - // decide on axis order for the given CRS │ │ │ │ - var yx; │ │ │ │ - if (obj.supportedCRS) { │ │ │ │ - // extract out version from URN │ │ │ │ - var crs = obj.supportedCRS.replace( │ │ │ │ - /urn:ogc:def:crs:(\w+):.+:(\w+)$/, │ │ │ │ - "urn:ogc:def:crs:$1::$2" │ │ │ │ - ); │ │ │ │ - yx = !!this.yx[crs]; │ │ │ │ - } │ │ │ │ - if (yx) { │ │ │ │ - obj.topLeftCorner = new OpenLayers.LonLat( │ │ │ │ - coords[1], coords[0] │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - obj.topLeftCorner = new OpenLayers.LonLat( │ │ │ │ - coords[0], coords[1] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "TileWidth": function(node, obj) { │ │ │ │ - obj.tileWidth = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "TileHeight": function(node, obj) { │ │ │ │ - obj.tileHeight = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "MatrixWidth": function(node, obj) { │ │ │ │ - obj.matrixWidth = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "MatrixHeight": function(node, obj) { │ │ │ │ - obj.matrixHeight = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "ResourceURL": function(node, obj) { │ │ │ │ - obj.resourceUrl = obj.resourceUrl || {}; │ │ │ │ - var resourceType = node.getAttribute("resourceType"); │ │ │ │ - if (!obj.resourceUrls) { │ │ │ │ - obj.resourceUrls = []; │ │ │ │ - } │ │ │ │ - var resourceUrl = obj.resourceUrl[resourceType] = { │ │ │ │ - format: node.getAttribute("format"), │ │ │ │ - template: node.getAttribute("template"), │ │ │ │ - resourceType: resourceType │ │ │ │ - }; │ │ │ │ - obj.resourceUrls.push(resourceUrl); │ │ │ │ - }, │ │ │ │ - // not used for now, can be added in the future though │ │ │ │ - /*"Themes": function(node, obj) { │ │ │ │ - obj.themes = []; │ │ │ │ - this.readChildNodes(node, obj.themes); │ │ │ │ - }, │ │ │ │ - "Theme": function(node, obj) { │ │ │ │ - var theme = {}; │ │ │ │ - this.readChildNodes(node, theme); │ │ │ │ - obj.push(theme); │ │ │ │ - },*/ │ │ │ │ - "WSDL": function(node, obj) { │ │ │ │ - obj.wsdl = {}; │ │ │ │ - obj.wsdl.href = node.getAttribute("xlink:href"); │ │ │ │ - // TODO: other attributes of <WSDL> element │ │ │ │ - }, │ │ │ │ - "ServiceMetadataURL": function(node, obj) { │ │ │ │ - obj.serviceMetadataUrl = {}; │ │ │ │ - obj.serviceMetadataUrl.href = node.getAttribute("xlink:href"); │ │ │ │ - // TODO: other attributes of <ServiceMetadataURL> element │ │ │ │ - }, │ │ │ │ - "LegendURL": function(node, obj) { │ │ │ │ - obj.legend = {}; │ │ │ │ - obj.legend.href = node.getAttribute("xlink:href"); │ │ │ │ - obj.legend.format = node.getAttribute("format"); │ │ │ │ - }, │ │ │ │ - "Dimension": function(node, obj) { │ │ │ │ - var dimension = { │ │ │ │ - values: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, dimension); │ │ │ │ - obj.dimensions.push(dimension); │ │ │ │ - }, │ │ │ │ - "Default": function(node, obj) { │ │ │ │ - obj["default"] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Value": function(node, obj) { │ │ │ │ - obj.values.push(this.getChildValue(node)); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ +OpenLayers.Control.ZoomOut = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMTSCapabilities.v1_0_0" │ │ │ │ + /** │ │ │ │ + * Method: trigger │ │ │ │ + */ │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.zoomOut(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomOut" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WMC/v1.js │ │ │ │ + OpenLayers/Control/DrawFeature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/WMC.js │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WMC.v1 │ │ │ │ - * Superclass for WMC version 1 parsers. │ │ │ │ + * Class: OpenLayers.Control.DrawFeature │ │ │ │ + * The DrawFeature control draws point, line or polygon features on a vector │ │ │ │ + * layer when active. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ +OpenLayers.Control.DrawFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - ol: "http://openlayers.org/context", │ │ │ │ - wmc: "http://www.opengis.net/context", │ │ │ │ - sld: "http://www.opengis.net/sld", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location for a particular minor version. │ │ │ │ + * Property: callbacks │ │ │ │ + * {Object} The functions that are sent to the handler for callback │ │ │ │ */ │ │ │ │ - schemaLocation: "", │ │ │ │ + callbacks: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getNamespacePrefix │ │ │ │ - * Get the namespace prefix for a given uri from the <namespaces> object. │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {String} A namespace prefix or null if none found. │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * featureadded - Triggered when a feature is added │ │ │ │ */ │ │ │ │ - getNamespacePrefix: function(uri) { │ │ │ │ - var prefix = null; │ │ │ │ - if (uri == null) { │ │ │ │ - prefix = this.namespaces[this.defaultPrefix]; │ │ │ │ - } else { │ │ │ │ - for (prefix in this.namespaces) { │ │ │ │ - if (this.namespaces[prefix] == uri) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return prefix; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ + * APIProperty: multi │ │ │ │ + * {Boolean} Cast features to multi-part geometries before passing to the │ │ │ │ + * layer. Default is false. │ │ │ │ */ │ │ │ │ - defaultPrefix: "wmc", │ │ │ │ + multi: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: rootPrefix │ │ │ │ - * {String} Prefix on the root node that maps to the context namespace URI. │ │ │ │ + * APIProperty: featureAdded │ │ │ │ + * {Function} Called after each feature is added │ │ │ │ */ │ │ │ │ - rootPrefix: null, │ │ │ │ + featureAdded: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultStyleName │ │ │ │ - * {String} Style name used if layer has no style param. Default is "". │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Used to set non-default properties on the control's handler │ │ │ │ */ │ │ │ │ - defaultStyleName: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultStyleTitle │ │ │ │ - * {String} Default style title. Default is "Default". │ │ │ │ + * Constructor: OpenLayers.Control.DrawFeature │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ + * handler - {<OpenLayers.Handler>} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - defaultStyleTitle: "Default", │ │ │ │ + initialize: function(layer, handler, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.callbacks = OpenLayers.Util.extend({ │ │ │ │ + done: this.drawFeature, │ │ │ │ + modify: function(vertex, feature) { │ │ │ │ + this.layer.events.triggerEvent( │ │ │ │ + "sketchmodified", { │ │ │ │ + vertex: vertex, │ │ │ │ + feature: feature │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + create: function(vertex, feature) { │ │ │ │ + this.layer.events.triggerEvent( │ │ │ │ + "sketchstarted", { │ │ │ │ + vertex: vertex, │ │ │ │ + feature: feature │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + this.callbacks │ │ │ │ + ); │ │ │ │ + this.layer = layer; │ │ │ │ + this.handlerOptions = this.handlerOptions || {}; │ │ │ │ + this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults( │ │ │ │ + this.handlerOptions.layerOptions, { │ │ │ │ + renderers: layer.renderers, │ │ │ │ + rendererOptions: layer.rendererOptions │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + if (!("multi" in this.handlerOptions)) { │ │ │ │ + this.handlerOptions.multi = this.multi; │ │ │ │ + } │ │ │ │ + var sketchStyle = this.layer.styleMap && this.layer.styleMap.styles.temporary; │ │ │ │ + if (sketchStyle) { │ │ │ │ + this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults( │ │ │ │ + this.handlerOptions.layerOptions, { │ │ │ │ + styleMap: new OpenLayers.StyleMap({ │ │ │ │ + "default": sketchStyle │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + this.handler = new handler(this, this.callbacks, this.handlerOptions); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.WMC.v1 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.WMC> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * Method: drawFeature │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + drawFeature: function(geometry) { │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + var proceed = this.layer.events.triggerEvent( │ │ │ │ + "sketchcomplete", { │ │ │ │ + feature: feature │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + if (proceed !== false) { │ │ │ │ + feature.state = OpenLayers.State.INSERT; │ │ │ │ + this.layer.addFeatures([feature]); │ │ │ │ + this.featureAdded(feature); │ │ │ │ + this.events.triggerEvent("featureadded", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read │ │ │ │ - * Read capabilities data from a string, and return a list of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ + * APIMethod: insertXY │ │ │ │ + * Insert a point in the current sketch given x & y coordinates. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Array} List of named layers. │ │ │ │ + * Parameters: │ │ │ │ + * x - {Number} The x-coordinate of the point. │ │ │ │ + * y - {Number} The y-coordinate of the point. │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ + insertXY: function(x, y) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertXY(x, y); │ │ │ │ } │ │ │ │ - var root = data.documentElement; │ │ │ │ - this.rootPrefix = root.prefix; │ │ │ │ - var context = { │ │ │ │ - version: root.getAttribute("version") │ │ │ │ - }; │ │ │ │ - this.runChildNodes(context, root); │ │ │ │ - return context; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: runChildNodes │ │ │ │ + * APIMethod: insertDeltaXY │ │ │ │ + * Insert a point given offsets from the previously inserted point. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * dx - {Number} The x-coordinate offset of the point. │ │ │ │ + * dy - {Number} The y-coordinate offset of the point. │ │ │ │ */ │ │ │ │ - runChildNodes: function(obj, node) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var childNode, processor, prefix, local; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - childNode = children[i]; │ │ │ │ - if (childNode.nodeType == 1) { │ │ │ │ - prefix = this.getNamespacePrefix(childNode.namespaceURI); │ │ │ │ - local = childNode.nodeName.split(":").pop(); │ │ │ │ - processor = this["read_" + prefix + "_" + local]; │ │ │ │ - if (processor) { │ │ │ │ - processor.apply(this, [obj, childNode]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + insertDeltaXY: function(dx, dy) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertDeltaXY(dx, dy); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_General │ │ │ │ + * APIMethod: insertDirectionLength │ │ │ │ + * Insert a point in the current sketch given a direction and a length. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * direction - {Number} Degrees clockwise from the positive x-axis. │ │ │ │ + * length - {Number} Distance from the previously drawn point. │ │ │ │ */ │ │ │ │ - read_wmc_General: function(context, node) { │ │ │ │ - this.runChildNodes(context, node); │ │ │ │ + insertDirectionLength: function(direction, length) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertDirectionLength(direction, length); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_BoundingBox │ │ │ │ + * APIMethod: insertDeflectionLength │ │ │ │ + * Insert a point in the current sketch given a deflection and a length. │ │ │ │ + * The deflection should be degrees clockwise from the previously │ │ │ │ + * digitized segment. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * deflection - {Number} Degrees clockwise from the previous segment. │ │ │ │ + * length - {Number} Distance from the previously drawn point. │ │ │ │ */ │ │ │ │ - read_wmc_BoundingBox: function(context, node) { │ │ │ │ - context.projection = node.getAttribute("SRS"); │ │ │ │ - context.bounds = new OpenLayers.Bounds( │ │ │ │ - node.getAttribute("minx"), node.getAttribute("miny"), │ │ │ │ - node.getAttribute("maxx"), node.getAttribute("maxy") │ │ │ │ - ); │ │ │ │ + insertDeflectionLength: function(deflection, length) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertDeflectionLength(deflection, length); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_LayerList │ │ │ │ + * APIMethod: undo │ │ │ │ + * Remove the most recently added point in the current sketch geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} An edit was undone. │ │ │ │ */ │ │ │ │ - read_wmc_LayerList: function(context, node) { │ │ │ │ - // layersContext is an array containing info for each layer │ │ │ │ - context.layersContext = []; │ │ │ │ - this.runChildNodes(context, node); │ │ │ │ + undo: function() { │ │ │ │ + return this.handler.undo && this.handler.undo(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Layer │ │ │ │ + * APIMethod: redo │ │ │ │ + * Reinsert the most recently removed point resulting from an <undo> call. │ │ │ │ + * The undo stack is deleted whenever a point is added by other means. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} An edit was redone. │ │ │ │ */ │ │ │ │ - read_wmc_Layer: function(context, node) { │ │ │ │ - var layerContext = { │ │ │ │ - visibility: (node.getAttribute("hidden") != "1"), │ │ │ │ - queryable: (node.getAttribute("queryable") == "1"), │ │ │ │ - formats: [], │ │ │ │ - styles: [], │ │ │ │ - metadata: {} │ │ │ │ - }; │ │ │ │ - │ │ │ │ - this.runChildNodes(layerContext, node); │ │ │ │ - // set properties common to multiple objects on layer options/params │ │ │ │ - context.layersContext.push(layerContext); │ │ │ │ + redo: function() { │ │ │ │ + return this.handler.redo && this.handler.redo(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Extension │ │ │ │ + * APIMethod: finishSketch │ │ │ │ + * Finishes the sketch without including the currently drawn point. │ │ │ │ + * This method can be called to terminate drawing programmatically │ │ │ │ + * instead of waiting for the user to end the sketch. │ │ │ │ */ │ │ │ │ - read_wmc_Extension: function(obj, node) { │ │ │ │ - this.runChildNodes(obj, node); │ │ │ │ + finishSketch: function() { │ │ │ │ + this.handler.finishGeometry(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_units │ │ │ │ + * APIMethod: cancel │ │ │ │ + * Cancel the current sketch. This removes the current sketch and keeps │ │ │ │ + * the drawing control active. │ │ │ │ */ │ │ │ │ - read_ol_units: function(layerContext, node) { │ │ │ │ - layerContext.units = this.getChildValue(node); │ │ │ │ + cancel: function() { │ │ │ │ + this.handler.cancel(); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_ol_maxExtent │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DrawFeature" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/SLDSelect.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Layer/WMS.js │ │ │ │ + * @requires OpenLayers/Handler/RegularPolygon.js │ │ │ │ + * @requires OpenLayers/Handler/Polygon.js │ │ │ │ + * @requires OpenLayers/Handler/Path.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + * @requires OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.SLDSelect │ │ │ │ + * Perform selections on WMS layers using Styled Layer Descriptor (SLD) │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.SLDSelect = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * selected - Triggered when a selection occurs. Listeners receive an │ │ │ │ + * event with *filters* and *layer* properties. Filters will be an │ │ │ │ + * array of OpenLayers.Filter objects created in order to perform │ │ │ │ + * the particular selection. │ │ │ │ */ │ │ │ │ - read_ol_maxExtent: function(obj, node) { │ │ │ │ - var bounds = new OpenLayers.Bounds( │ │ │ │ - node.getAttribute("minx"), node.getAttribute("miny"), │ │ │ │ - node.getAttribute("maxx"), node.getAttribute("maxy") │ │ │ │ - ); │ │ │ │ - obj.maxExtent = bounds; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_transparent │ │ │ │ + * APIProperty: clearOnDeactivate │ │ │ │ + * {Boolean} Should the selection be cleared when the control is │ │ │ │ + * deactivated. Default value is false. │ │ │ │ */ │ │ │ │ - read_ol_transparent: function(layerContext, node) { │ │ │ │ - layerContext.transparent = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ + clearOnDeactivate: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_numZoomLevels │ │ │ │ + * APIProperty: layers │ │ │ │ + * {Array(<OpenLayers.Layer.WMS>)} The WMS layers this control will work │ │ │ │ + * on. │ │ │ │ */ │ │ │ │ - read_ol_numZoomLevels: function(layerContext, node) { │ │ │ │ - layerContext.numZoomLevels = parseInt(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_opacity │ │ │ │ + * Property: callbacks │ │ │ │ + * {Object} The functions that are sent to the handler for callback │ │ │ │ */ │ │ │ │ - read_ol_opacity: function(layerContext, node) { │ │ │ │ - layerContext.opacity = parseFloat(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ + callbacks: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_singleTile │ │ │ │ + * APIProperty: selectionSymbolizer │ │ │ │ + * {Object} Determines the styling of the selected objects. Default is │ │ │ │ + * a selection in red. │ │ │ │ */ │ │ │ │ - read_ol_singleTile: function(layerContext, node) { │ │ │ │ - layerContext.singleTile = (this.getChildValue(node) == "true"); │ │ │ │ + selectionSymbolizer: { │ │ │ │ + 'Polygon': { │ │ │ │ + fillColor: '#FF0000', │ │ │ │ + stroke: false │ │ │ │ + }, │ │ │ │ + 'Line': { │ │ │ │ + strokeColor: '#FF0000', │ │ │ │ + strokeWidth: 2 │ │ │ │ + }, │ │ │ │ + 'Point': { │ │ │ │ + graphicName: 'square', │ │ │ │ + fillColor: '#FF0000', │ │ │ │ + pointRadius: 5 │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_tileSize │ │ │ │ + * APIProperty: layerOptions │ │ │ │ + * {Object} The options to apply to the selection layer, by default the │ │ │ │ + * selection layer will be kept out of the layer switcher. │ │ │ │ */ │ │ │ │ - read_ol_tileSize: function(layerContext, node) { │ │ │ │ - var obj = { │ │ │ │ - "width": node.getAttribute("width"), │ │ │ │ - "height": node.getAttribute("height") │ │ │ │ - }; │ │ │ │ - layerContext.tileSize = obj; │ │ │ │ - }, │ │ │ │ + layerOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_isBaseLayer │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Used to set non-default properties on the control's handler │ │ │ │ */ │ │ │ │ - read_ol_isBaseLayer: function(layerContext, node) { │ │ │ │ - layerContext.isBaseLayer = (this.getChildValue(node) == "true"); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_ol_displayInLayerSwitcher │ │ │ │ + * APIProperty: sketchStyle │ │ │ │ + * {<OpenLayers.Style>|Object} Style or symbolizer to use for the sketch │ │ │ │ + * handler. The recommended way of styling the sketch layer, however, is │ │ │ │ + * to configure an <OpenLayers.StyleMap> in the layerOptions of the │ │ │ │ + * <handlerOptions>: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Control.SLDSelect(OpenLayers.Handler.Path, { │ │ │ │ + * handlerOptions: { │ │ │ │ + * layerOptions: { │ │ │ │ + * styleMap: new OpenLayers.StyleMap({ │ │ │ │ + * "default": {strokeColor: "yellow"} │ │ │ │ + * }) │ │ │ │ + * } │ │ │ │ + * } │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - read_ol_displayInLayerSwitcher: function(layerContext, node) { │ │ │ │ - layerContext.displayInLayerSwitcher = (this.getChildValue(node) == "true"); │ │ │ │ - }, │ │ │ │ + sketchStyle: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Server │ │ │ │ + * APIProperty: wfsCache │ │ │ │ + * {Object} Cache to use for storing parsed results from │ │ │ │ + * <OpenLayers.Format.WFSDescribeFeatureType.read>. If not provided, │ │ │ │ + * these will be cached on the prototype. │ │ │ │ */ │ │ │ │ - read_wmc_Server: function(layerContext, node) { │ │ │ │ - layerContext.version = node.getAttribute("version"); │ │ │ │ - layerContext.url = this.getOnlineResource_href(node); │ │ │ │ - layerContext.metadata.servertitle = node.getAttribute("title"); │ │ │ │ - }, │ │ │ │ + wfsCache: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_FormatList │ │ │ │ + * APIProperty: layerCache │ │ │ │ + * {Object} Cache to use for storing references to the selection layers. │ │ │ │ + * Normally each source layer will have exactly 1 selection layer of │ │ │ │ + * type OpenLayers.Layer.WMS. If not provided, layers will │ │ │ │ + * be cached on the prototype. Note that if <clearOnDeactivate> is │ │ │ │ + * true, the layer will no longer be cached after deactivating the │ │ │ │ + * control. │ │ │ │ */ │ │ │ │ - read_wmc_FormatList: function(layerContext, node) { │ │ │ │ - this.runChildNodes(layerContext, node); │ │ │ │ - }, │ │ │ │ + layerCache: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Format │ │ │ │ + * Constructor: OpenLayers.Control.SLDSelect │ │ │ │ + * Create a new control for selecting features in WMS layers using │ │ │ │ + * Styled Layer Descriptor (SLD). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * handler - {<OpenLayers.Class>} A sketch handler class. This determines │ │ │ │ + * the type of selection, e.g. box (<OpenLayers.Handler.Box>), point │ │ │ │ + * (<OpenLayers.Handler.Point>), path (<OpenLayers.Handler.Path>) or │ │ │ │ + * polygon (<OpenLayers.Handler.Polygon>) selection. To use circle │ │ │ │ + * type selection, use <OpenLayers.Handler.RegularPolygon> and pass │ │ │ │ + * the number of desired sides (e.g. 40) as "sides" property to the │ │ │ │ + * <handlerOptions>. │ │ │ │ + * options - {Object} An object containing all configuration properties for │ │ │ │ + * the control. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * layers - Array({<OpenLayers.Layer.WMS>}) The layers to perform the │ │ │ │ + * selection on. │ │ │ │ */ │ │ │ │ - read_wmc_Format: function(layerContext, node) { │ │ │ │ - var format = { │ │ │ │ - value: this.getChildValue(node) │ │ │ │ - }; │ │ │ │ - if (node.getAttribute("current") == "1") { │ │ │ │ - format.current = true; │ │ │ │ + initialize: function(handler, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + │ │ │ │ + this.callbacks = OpenLayers.Util.extend({ │ │ │ │ + done: this.select, │ │ │ │ + click: this.select │ │ │ │ + }, this.callbacks); │ │ │ │ + this.handlerOptions = this.handlerOptions || {}; │ │ │ │ + this.layerOptions = OpenLayers.Util.applyDefaults(this.layerOptions, { │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + tileOptions: { │ │ │ │ + maxGetUrlLength: 2048 │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (this.sketchStyle) { │ │ │ │ + this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults( │ │ │ │ + this.handlerOptions.layerOptions, { │ │ │ │ + styleMap: new OpenLayers.StyleMap({ │ │ │ │ + "default": this.sketchStyle │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + ); │ │ │ │ } │ │ │ │ - layerContext.formats.push(format); │ │ │ │ + this.handler = new handler(this, this.callbacks, this.handlerOptions); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_StyleList │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Take care of things that are not handled in superclass. │ │ │ │ */ │ │ │ │ - read_wmc_StyleList: function(layerContext, node) { │ │ │ │ - this.runChildNodes(layerContext, node); │ │ │ │ + destroy: function() { │ │ │ │ + for (var key in this.layerCache) { │ │ │ │ + delete this.layerCache[key]; │ │ │ │ + } │ │ │ │ + for (var key in this.wfsCache) { │ │ │ │ + delete this.wfsCache[key]; │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Style │ │ │ │ + * Method: coupleLayerVisiblity │ │ │ │ + * Couple the selection layer and the source layer with respect to │ │ │ │ + * layer visibility. So if the source layer is turned off, the │ │ │ │ + * selection layer is also turned off. │ │ │ │ + * │ │ │ │ + * Context: │ │ │ │ + * - {<OpenLayers.Layer>} │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - read_wmc_Style: function(layerContext, node) { │ │ │ │ - var style = {}; │ │ │ │ - this.runChildNodes(style, node); │ │ │ │ - if (node.getAttribute("current") == "1") { │ │ │ │ - style.current = true; │ │ │ │ - } │ │ │ │ - layerContext.styles.push(style); │ │ │ │ + coupleLayerVisiblity: function(evt) { │ │ │ │ + this.setVisibility(evt.object.getVisibility()); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_SLD │ │ │ │ + * Method: createSelectionLayer │ │ │ │ + * Creates a "clone" from the source layer in which the selection can │ │ │ │ + * be drawn. This ensures both the source layer and the selection are │ │ │ │ + * visible and not only the selection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * source - {<OpenLayers.Layer.WMS>} The source layer on which the selection │ │ │ │ + * is performed. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.WMS>} A WMS layer with maxGetUrlLength configured to 2048 │ │ │ │ + * since SLD selections can easily get quite long. │ │ │ │ */ │ │ │ │ - read_wmc_SLD: function(style, node) { │ │ │ │ - this.runChildNodes(style, node); │ │ │ │ - // style either comes back with an href or a body property │ │ │ │ + createSelectionLayer: function(source) { │ │ │ │ + // check if we already have a selection layer for the source layer │ │ │ │ + var selectionLayer; │ │ │ │ + if (!this.layerCache[source.id]) { │ │ │ │ + selectionLayer = new OpenLayers.Layer.WMS(source.name, │ │ │ │ + source.url, source.params, │ │ │ │ + OpenLayers.Util.applyDefaults( │ │ │ │ + this.layerOptions, │ │ │ │ + source.getOptions()) │ │ │ │ + ); │ │ │ │ + this.layerCache[source.id] = selectionLayer; │ │ │ │ + // make sure the layers are coupled wrt visibility, but only │ │ │ │ + // if they are not displayed in the layer switcher, because in │ │ │ │ + // that case the user cannot control visibility. │ │ │ │ + if (this.layerOptions.displayInLayerSwitcher === false) { │ │ │ │ + source.events.on({ │ │ │ │ + "visibilitychanged": this.coupleLayerVisiblity, │ │ │ │ + scope: selectionLayer │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.map.addLayer(selectionLayer); │ │ │ │ + } else { │ │ │ │ + selectionLayer = this.layerCache[source.id]; │ │ │ │ + } │ │ │ │ + return selectionLayer; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_sld_StyledLayerDescriptor │ │ │ │ + * Method: createSLD │ │ │ │ + * Create the SLD document for the layer using the supplied filters. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.WMS>} │ │ │ │ + * filters - Array({<OpenLayers.Filter>}) The filters to be applied. │ │ │ │ + * geometryAttributes - Array({Object}) The geometry attributes of the │ │ │ │ + * layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The SLD document generated as a string. │ │ │ │ */ │ │ │ │ - read_sld_StyledLayerDescriptor: function(sld, node) { │ │ │ │ - var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ - sld.body = xml; │ │ │ │ + createSLD: function(layer, filters, geometryAttributes) { │ │ │ │ + var sld = { │ │ │ │ + version: "1.0.0", │ │ │ │ + namedLayers: {} │ │ │ │ + }; │ │ │ │ + var layerNames = [layer.params.LAYERS].join(",").split(","); │ │ │ │ + for (var i = 0, len = layerNames.length; i < len; i++) { │ │ │ │ + var name = layerNames[i]; │ │ │ │ + sld.namedLayers[name] = { │ │ │ │ + name: name, │ │ │ │ + userStyles: [] │ │ │ │ + }; │ │ │ │ + var symbolizer = this.selectionSymbolizer; │ │ │ │ + var geometryAttribute = geometryAttributes[i]; │ │ │ │ + if (geometryAttribute.type.indexOf('Polygon') >= 0) { │ │ │ │ + symbolizer = { │ │ │ │ + Polygon: this.selectionSymbolizer['Polygon'] │ │ │ │ + }; │ │ │ │ + } else if (geometryAttribute.type.indexOf('LineString') >= 0) { │ │ │ │ + symbolizer = { │ │ │ │ + Line: this.selectionSymbolizer['Line'] │ │ │ │ + }; │ │ │ │ + } else if (geometryAttribute.type.indexOf('Point') >= 0) { │ │ │ │ + symbolizer = { │ │ │ │ + Point: this.selectionSymbolizer['Point'] │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + var filter = filters[i]; │ │ │ │ + sld.namedLayers[name].userStyles.push({ │ │ │ │ + name: 'default', │ │ │ │ + rules: [ │ │ │ │ + new OpenLayers.Rule({ │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + filter: filter, │ │ │ │ + maxScaleDenominator: layer.options.minScale │ │ │ │ + }) │ │ │ │ + ] │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return new OpenLayers.Format.SLD({ │ │ │ │ + srsName: this.map.getProjection() │ │ │ │ + }).write(sld); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_sld_FeatureTypeStyle │ │ │ │ + * Method: parseDescribeLayer │ │ │ │ + * Parse the SLD WMS DescribeLayer response and issue the corresponding │ │ │ │ + * WFS DescribeFeatureType request │ │ │ │ + * │ │ │ │ + * request - {XMLHttpRequest} The request object. │ │ │ │ */ │ │ │ │ - read_sld_FeatureTypeStyle: function(sld, node) { │ │ │ │ - var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ - sld.body = xml; │ │ │ │ + parseDescribeLayer: function(request) { │ │ │ │ + var format = new OpenLayers.Format.WMSDescribeLayer(); │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ + } │ │ │ │ + var describeLayer = format.read(doc); │ │ │ │ + var typeNames = []; │ │ │ │ + var url = null; │ │ │ │ + for (var i = 0, len = describeLayer.length; i < len; i++) { │ │ │ │ + // perform a WFS DescribeFeatureType request │ │ │ │ + if (describeLayer[i].owsType == "WFS") { │ │ │ │ + typeNames.push(describeLayer[i].typeName); │ │ │ │ + url = describeLayer[i].owsURL; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var options = { │ │ │ │ + url: url, │ │ │ │ + params: { │ │ │ │ + SERVICE: "WFS", │ │ │ │ + TYPENAME: typeNames.toString(), │ │ │ │ + REQUEST: "DescribeFeatureType", │ │ │ │ + VERSION: "1.0.0" │ │ │ │ + }, │ │ │ │ + callback: function(request) { │ │ │ │ + var format = new OpenLayers.Format.WFSDescribeFeatureType(); │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ + } │ │ │ │ + var describeFeatureType = format.read(doc); │ │ │ │ + this.control.wfsCache[this.layer.id] = describeFeatureType; │ │ │ │ + this.control._queue && this.control.applySelection(); │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }; │ │ │ │ + OpenLayers.Request.GET(options); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_OnlineResource │ │ │ │ + * Method: getGeometryAttributes │ │ │ │ + * Look up the geometry attributes from the WFS DescribeFeatureType response │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.WMS>} The layer for which to look up the │ │ │ │ + * geometry attributes. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * Array({Object}) Array of geometry attributes │ │ │ │ */ │ │ │ │ - read_wmc_OnlineResource: function(obj, node) { │ │ │ │ - obj.href = this.getAttributeNS( │ │ │ │ - node, this.namespaces.xlink, "href" │ │ │ │ - ); │ │ │ │ + getGeometryAttributes: function(layer) { │ │ │ │ + var result = []; │ │ │ │ + var cache = this.wfsCache[layer.id]; │ │ │ │ + for (var i = 0, len = cache.featureTypes.length; i < len; i++) { │ │ │ │ + var typeName = cache.featureTypes[i]; │ │ │ │ + var properties = typeName.properties; │ │ │ │ + for (var j = 0, lenj = properties.length; j < lenj; j++) { │ │ │ │ + var property = properties[j]; │ │ │ │ + var type = property.type; │ │ │ │ + if ((type.indexOf('LineString') >= 0) || │ │ │ │ + (type.indexOf('GeometryAssociationType') >= 0) || │ │ │ │ + (type.indexOf('GeometryPropertyType') >= 0) || │ │ │ │ + (type.indexOf('Point') >= 0) || │ │ │ │ + (type.indexOf('Polygon') >= 0)) { │ │ │ │ + result.push(property); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Name │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the control. Activating the control will perform a SLD WMS │ │ │ │ + * DescribeLayer request followed by a WFS DescribeFeatureType request │ │ │ │ + * so that the proper symbolizers can be chosen based on the geometry │ │ │ │ + * type. │ │ │ │ */ │ │ │ │ - read_wmc_Name: function(obj, node) { │ │ │ │ - var name = this.getChildValue(node); │ │ │ │ - if (name) { │ │ │ │ - obj.name = name; │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + var layer = this.layers[i]; │ │ │ │ + if (layer && !this.wfsCache[layer.id]) { │ │ │ │ + var options = { │ │ │ │ + url: layer.url, │ │ │ │ + params: { │ │ │ │ + SERVICE: "WMS", │ │ │ │ + VERSION: layer.params.VERSION, │ │ │ │ + LAYERS: layer.params.LAYERS, │ │ │ │ + REQUEST: "DescribeLayer" │ │ │ │ + }, │ │ │ │ + callback: this.parseDescribeLayer, │ │ │ │ + scope: { │ │ │ │ + layer: layer, │ │ │ │ + control: this │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + OpenLayers.Request.GET(options); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return activated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Title │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the control. If clearOnDeactivate is true, remove the │ │ │ │ + * selection layer(s). │ │ │ │ */ │ │ │ │ - read_wmc_Title: function(obj, node) { │ │ │ │ - var title = this.getChildValue(node); │ │ │ │ - if (title) { │ │ │ │ - obj.title = title; │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + var layer = this.layers[i]; │ │ │ │ + if (layer && this.clearOnDeactivate === true) { │ │ │ │ + var layerCache = this.layerCache; │ │ │ │ + var selectionLayer = layerCache[layer.id]; │ │ │ │ + if (selectionLayer) { │ │ │ │ + layer.events.un({ │ │ │ │ + "visibilitychanged": this.coupleLayerVisiblity, │ │ │ │ + scope: selectionLayer │ │ │ │ + }); │ │ │ │ + selectionLayer.destroy(); │ │ │ │ + delete layerCache[layer.id]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_MetadataURL │ │ │ │ + * APIMethod: setLayers │ │ │ │ + * Set the layers on which the selection should be performed. Call the │ │ │ │ + * setLayers method if the layer(s) to be used change and the same │ │ │ │ + * control should be used on a new set of layers. │ │ │ │ + * If the control is already active, it will be active after the new │ │ │ │ + * set of layers is set. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layers - {Array(<OpenLayers.Layer.WMS>)} The new set of layers on which │ │ │ │ + * the selection should be performed. │ │ │ │ */ │ │ │ │ - read_wmc_MetadataURL: function(layerContext, node) { │ │ │ │ - layerContext.metadataURL = this.getOnlineResource_href(node); │ │ │ │ + setLayers: function(layers) { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layers = layers; │ │ │ │ + this.activate(); │ │ │ │ + } else { │ │ │ │ + this.layers = layers; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_KeywordList │ │ │ │ + * Function: createFilter │ │ │ │ + * Create the filter to be used in the SLD. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometryAttribute - {Object} Used to get the name of the geometry │ │ │ │ + * attribute which is needed for constructing the spatial filter. │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The geometry to use. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter.Spatial>} The spatial filter created. │ │ │ │ */ │ │ │ │ - read_wmc_KeywordList: function(context, node) { │ │ │ │ - context.keywords = []; │ │ │ │ - this.runChildNodes(context.keywords, node); │ │ │ │ + createFilter: function(geometryAttribute, geometry) { │ │ │ │ + var filter = null; │ │ │ │ + if (this.handler instanceof OpenLayers.Handler.RegularPolygon) { │ │ │ │ + // box │ │ │ │ + if (this.handler.irregular === true) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry.getBounds() │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else if (this.handler instanceof OpenLayers.Handler.Polygon) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }); │ │ │ │ + } else if (this.handler instanceof OpenLayers.Handler.Path) { │ │ │ │ + // if source layer is point based, use DWITHIN instead │ │ │ │ + if (geometryAttribute.type.indexOf('Point') >= 0) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + distance: this.map.getExtent().getWidth() * 0.01, │ │ │ │ + distanceUnits: this.map.getUnits(), │ │ │ │ + value: geometry │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else if (this.handler instanceof OpenLayers.Handler.Click) { │ │ │ │ + if (geometryAttribute.type.indexOf('Polygon') >= 0) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + distance: this.map.getExtent().getWidth() * 0.01, │ │ │ │ + distanceUnits: this.map.getUnits(), │ │ │ │ + value: geometry │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return filter; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Keyword │ │ │ │ + * Method: select │ │ │ │ + * When the handler is done, use SLD_BODY on the selection layer to │ │ │ │ + * display the selection in the map. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {Object} or {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - read_wmc_Keyword: function(keywords, node) { │ │ │ │ - keywords.push(this.getChildValue(node)); │ │ │ │ + select: function(geometry) { │ │ │ │ + this._queue = function() { │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + var layer = this.layers[i]; │ │ │ │ + var geometryAttributes = this.getGeometryAttributes(layer); │ │ │ │ + var filters = []; │ │ │ │ + for (var j = 0, lenj = geometryAttributes.length; j < lenj; j++) { │ │ │ │ + var geometryAttribute = geometryAttributes[j]; │ │ │ │ + if (geometryAttribute !== null) { │ │ │ │ + // from the click handler we will not get an actual │ │ │ │ + // geometry so transform │ │ │ │ + if (!(geometry instanceof OpenLayers.Geometry)) { │ │ │ │ + var point = this.map.getLonLatFromPixel( │ │ │ │ + geometry.xy); │ │ │ │ + geometry = new OpenLayers.Geometry.Point( │ │ │ │ + point.lon, point.lat); │ │ │ │ + } │ │ │ │ + var filter = this.createFilter(geometryAttribute, │ │ │ │ + geometry); │ │ │ │ + if (filter !== null) { │ │ │ │ + filters.push(filter); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + var selectionLayer = this.createSelectionLayer(layer); │ │ │ │ + │ │ │ │ + this.events.triggerEvent("selected", { │ │ │ │ + layer: layer, │ │ │ │ + filters: filters │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var sld = this.createSLD(layer, filters, geometryAttributes); │ │ │ │ + │ │ │ │ + selectionLayer.mergeNewParams({ │ │ │ │ + SLD_BODY: sld │ │ │ │ + }); │ │ │ │ + delete this._queue; │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + this.applySelection(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Abstract │ │ │ │ + * Method: applySelection │ │ │ │ + * Checks if all required wfs data is cached, and applies the selection │ │ │ │ */ │ │ │ │ - read_wmc_Abstract: function(obj, node) { │ │ │ │ - var abst = this.getChildValue(node); │ │ │ │ - if (abst) { │ │ │ │ - obj["abstract"] = abst; │ │ │ │ + applySelection: function() { │ │ │ │ + var canApply = true; │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + if (!this.wfsCache[this.layers[i].id]) { │ │ │ │ + canApply = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ } │ │ │ │ + canApply && this._queue.call(this); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.SLDSelect" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/Permalink.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Control/ArgParser.js │ │ │ │ + * @requires OpenLayers/Lang.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.Permalink │ │ │ │ + * The Permalink control is hyperlink that will return the user to the │ │ │ │ + * current map view. By default it is drawn in the lower right corner of the │ │ │ │ + * map. The href is updated as the map is zoomed, panned and whilst layers │ │ │ │ + * are switched. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: read_wmc_LogoURL │ │ │ │ + * APIProperty: argParserClass │ │ │ │ + * {Class} The ArgParser control class (not instance) to use with this │ │ │ │ + * control. │ │ │ │ */ │ │ │ │ - read_wmc_LogoURL: function(context, node) { │ │ │ │ - context.logo = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height"), │ │ │ │ - format: node.getAttribute("format"), │ │ │ │ - href: this.getOnlineResource_href(node) │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ + argParserClass: OpenLayers.Control.ArgParser, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_wmc_DescriptionURL │ │ │ │ + /** │ │ │ │ + * Property: element │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - read_wmc_DescriptionURL: function(context, node) { │ │ │ │ - context.descriptionURL = this.getOnlineResource_href(node); │ │ │ │ - }, │ │ │ │ + element: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_wmc_ContactInformation │ │ │ │ + /** │ │ │ │ + * APIProperty: anchor │ │ │ │ + * {Boolean} This option changes 3 things: │ │ │ │ + * the character '#' is used in place of the character '?', │ │ │ │ + * the window.href is updated if no element is provided. │ │ │ │ + * When this option is set to true it's not recommend to provide │ │ │ │ + * a base without provide an element. │ │ │ │ */ │ │ │ │ - read_wmc_ContactInformation: function(obj, node) { │ │ │ │ - var contact = {}; │ │ │ │ - this.runChildNodes(contact, node); │ │ │ │ - obj.contactInformation = contact; │ │ │ │ - }, │ │ │ │ + anchor: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_wmc_ContactPersonPrimary │ │ │ │ + /** │ │ │ │ + * APIProperty: base │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - read_wmc_ContactPersonPrimary: function(contact, node) { │ │ │ │ - var personPrimary = {}; │ │ │ │ - this.runChildNodes(personPrimary, node); │ │ │ │ - contact.personPrimary = personPrimary; │ │ │ │ - }, │ │ │ │ + base: '', │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_wmc_ContactPerson │ │ │ │ + /** │ │ │ │ + * APIProperty: displayProjection │ │ │ │ + * {<OpenLayers.Projection>} 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. │ │ │ │ */ │ │ │ │ - read_wmc_ContactPerson: function(primaryPerson, node) { │ │ │ │ - var person = this.getChildValue(node); │ │ │ │ - if (person) { │ │ │ │ - primaryPerson.person = person; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + displayProjection: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_ContactOrganization │ │ │ │ + * Constructor: OpenLayers.Control.Permalink │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * element - {DOMElement} │ │ │ │ + * base - {String} │ │ │ │ + * options - {Object} options to the control. │ │ │ │ + * │ │ │ │ + * Or for anchor: │ │ │ │ + * options - {Object} options to the control. │ │ │ │ */ │ │ │ │ - read_wmc_ContactOrganization: function(primaryPerson, node) { │ │ │ │ - var organization = this.getChildValue(node); │ │ │ │ - if (organization) { │ │ │ │ - primaryPerson.organization = organization; │ │ │ │ + initialize: function(element, base, options) { │ │ │ │ + if (element !== null && typeof element == 'object' && !OpenLayers.Util.isElement(element)) { │ │ │ │ + options = element; │ │ │ │ + this.base = document.location.href; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (this.element != null) { │ │ │ │ + this.element = OpenLayers.Util.getElement(this.element); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.element = OpenLayers.Util.getElement(element); │ │ │ │ + this.base = base || document.location.href; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_ContactPosition │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - read_wmc_ContactPosition: function(contact, node) { │ │ │ │ - var position = this.getChildValue(node); │ │ │ │ - if (position) { │ │ │ │ - contact.position = position; │ │ │ │ + destroy: function() { │ │ │ │ + if (this.element && this.element.parentNode == this.div) { │ │ │ │ + this.div.removeChild(this.element); │ │ │ │ + this.element = null; │ │ │ │ + } │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister('moveend', this, this.updateLink); │ │ │ │ } │ │ │ │ + │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_ContactAddress │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - read_wmc_ContactAddress: function(contact, node) { │ │ │ │ - var contactAddress = {}; │ │ │ │ - this.runChildNodes(contactAddress, node); │ │ │ │ - contact.contactAddress = contactAddress; │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + │ │ │ │ + //make sure we have an arg parser attached │ │ │ │ + for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ + var control = this.map.controls[i]; │ │ │ │ + if (control.CLASS_NAME == this.argParserClass.CLASS_NAME) { │ │ │ │ + │ │ │ │ + // 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 this.argParserClass({ │ │ │ │ + 'displayProjection': this.displayProjection │ │ │ │ + })); │ │ │ │ + } │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_AddressType │ │ │ │ + * Method: draw │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - read_wmc_AddressType: function(contactAddress, node) { │ │ │ │ - var type = this.getChildValue(node); │ │ │ │ - if (type) { │ │ │ │ - contactAddress.type = type; │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (!this.element && !this.anchor) { │ │ │ │ + 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 │ │ │ │ + }); │ │ │ │ + │ │ │ │ + // Make it so there is at least a link even though the map may not have │ │ │ │ + // moved yet. │ │ │ │ + this.updateLink(); │ │ │ │ + │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Address │ │ │ │ + * Method: updateLink │ │ │ │ */ │ │ │ │ - read_wmc_Address: function(contactAddress, node) { │ │ │ │ - var address = this.getChildValue(node); │ │ │ │ - if (address) { │ │ │ │ - contactAddress.address = address; │ │ │ │ + updateLink: function() { │ │ │ │ + var separator = this.anchor ? '#' : '?'; │ │ │ │ + var href = this.base; │ │ │ │ + var anchor = null; │ │ │ │ + if (href.indexOf("#") != -1 && this.anchor == false) { │ │ │ │ + anchor = href.substring(href.indexOf("#"), href.length); │ │ │ │ + } │ │ │ │ + if (href.indexOf(separator) != -1) { │ │ │ │ + href = href.substring(0, href.indexOf(separator)); │ │ │ │ + } │ │ │ │ + var splits = href.split("#"); │ │ │ │ + href = splits[0] + separator + OpenLayers.Util.getParameterString(this.createParams()); │ │ │ │ + if (anchor) { │ │ │ │ + href += anchor; │ │ │ │ + } │ │ │ │ + if (this.anchor && !this.element) { │ │ │ │ + window.location.href = href; │ │ │ │ + } else { │ │ │ │ + this.element.href = href; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_City │ │ │ │ + * APIMethod: createParams │ │ │ │ + * Creates the parameters that need to be encoded into the permalink url. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * center - {<OpenLayers.LonLat>} center to encode in the permalink. │ │ │ │ + * Defaults to the current map center. │ │ │ │ + * zoom - {Integer} zoom level to encode in the permalink. Defaults to the │ │ │ │ + * current map zoom level. │ │ │ │ + * layers - {Array(<OpenLayers.Layer>)} layers to encode in the permalink. │ │ │ │ + * Defaults to the current map layers. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} Hash of parameters that will be url-encoded into the │ │ │ │ + * permalink. │ │ │ │ */ │ │ │ │ - read_wmc_City: function(contactAddress, node) { │ │ │ │ - var city = this.getChildValue(node); │ │ │ │ - if (city) { │ │ │ │ - contactAddress.city = city; │ │ │ │ + createParams: function(center, zoom, layers) { │ │ │ │ + center = center || this.map.getCenter(); │ │ │ │ + │ │ │ │ + var params = OpenLayers.Util.getParameters(this.base); │ │ │ │ + │ │ │ │ + // If there's still no center, map is not initialized yet. │ │ │ │ + // Break out of this function, and simply return the params from the │ │ │ │ + // base link. │ │ │ │ + if (center) { │ │ │ │ + │ │ │ │ + //zoom │ │ │ │ + params.zoom = zoom || this.map.getZoom(); │ │ │ │ + │ │ │ │ + //lon,lat │ │ │ │ + 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; │ │ │ │ + │ │ │ │ + //layers │ │ │ │ + layers = layers || this.map.layers; │ │ │ │ + params.layers = ''; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + │ │ │ │ + if (layer.isBaseLayer) { │ │ │ │ + params.layers += (layer == this.map.baseLayer) ? "B" : "0"; │ │ │ │ + } else { │ │ │ │ + params.layers += (layer.getVisibility()) ? "T" : "F"; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + │ │ │ │ + return params; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Permalink" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/EditingToolbar.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control/Panel.js │ │ │ │ + * @requires OpenLayers/Control/Navigation.js │ │ │ │ + * @requires OpenLayers/Control/DrawFeature.js │ │ │ │ + * @requires OpenLayers/Handler/Point.js │ │ │ │ + * @requires OpenLayers/Handler/Path.js │ │ │ │ + * @requires OpenLayers/Handler/Polygon.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.EditingToolbar │ │ │ │ + * The EditingToolbar is a panel of 4 controls to draw polygons, lines, │ │ │ │ + * points, or to navigate the map by panning. By default it appears in the │ │ │ │ + * upper right corner of the map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control.Panel> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.EditingToolbar = OpenLayers.Class( │ │ │ │ + OpenLayers.Control.Panel, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: citeCompliant │ │ │ │ + * {Boolean} If set to true, coordinates of features drawn in a map extent │ │ │ │ + * crossing the date line won't exceed the world bounds. Default is false. │ │ │ │ + */ │ │ │ │ + citeCompliant: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.EditingToolbar │ │ │ │ + * Create an editing toolbar for a given layer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ + * options - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + │ │ │ │ + this.addControls( │ │ │ │ + [new OpenLayers.Control.Navigation()] │ │ │ │ + ); │ │ │ │ + var controls = [ │ │ │ │ + new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Point, { │ │ │ │ + displayClass: 'olControlDrawFeaturePoint', │ │ │ │ + handlerOptions: { │ │ │ │ + citeCompliant: this.citeCompliant │ │ │ │ + } │ │ │ │ + }), │ │ │ │ + new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Path, { │ │ │ │ + displayClass: 'olControlDrawFeaturePath', │ │ │ │ + handlerOptions: { │ │ │ │ + citeCompliant: this.citeCompliant │ │ │ │ + } │ │ │ │ + }), │ │ │ │ + new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Polygon, { │ │ │ │ + displayClass: 'olControlDrawFeaturePolygon', │ │ │ │ + handlerOptions: { │ │ │ │ + citeCompliant: this.citeCompliant │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + ]; │ │ │ │ + this.addControls(controls); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * calls the default draw, and then activates mouse defaults. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.defaultControl === null) { │ │ │ │ + this.defaultControl = this.controls[0]; │ │ │ │ + } │ │ │ │ + return div; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.EditingToolbar" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/Scale.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Lang.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.Scale │ │ │ │ + * The Scale control displays the current map scale as a ratio (e.g. Scale = │ │ │ │ + * 1:1M). By default it is displayed in the lower right corner of the map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.Scale = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: read_wmc_StateOrProvince │ │ │ │ + * Property: element │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - read_wmc_StateOrProvince: function(contactAddress, node) { │ │ │ │ - var stateOrProvince = this.getChildValue(node); │ │ │ │ - if (stateOrProvince) { │ │ │ │ - contactAddress.stateOrProvince = stateOrProvince; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + element: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_PostCode │ │ │ │ + * APIProperty: geodesic │ │ │ │ + * {Boolean} Use geodesic measurement. Default is false. The recommended │ │ │ │ + * setting for maps in EPSG:4326 is false, and true EPSG:900913. If set to │ │ │ │ + * true, the scale will be calculated based on the horizontal size of the │ │ │ │ + * pixel in the center of the map viewport. │ │ │ │ */ │ │ │ │ - read_wmc_PostCode: function(contactAddress, node) { │ │ │ │ - var postcode = this.getChildValue(node); │ │ │ │ - if (postcode) { │ │ │ │ - contactAddress.postcode = postcode; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + geodesic: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Country │ │ │ │ + * Constructor: OpenLayers.Control.Scale │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * element - {DOMElement} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - read_wmc_Country: function(contactAddress, node) { │ │ │ │ - var country = this.getChildValue(node); │ │ │ │ - if (country) { │ │ │ │ - contactAddress.country = country; │ │ │ │ - } │ │ │ │ + initialize: function(element, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.element = OpenLayers.Util.getElement(element); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_ContactVoiceTelephone │ │ │ │ + * Method: draw │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - read_wmc_ContactVoiceTelephone: function(contact, node) { │ │ │ │ - var phone = this.getChildValue(node); │ │ │ │ - if (phone) { │ │ │ │ - contact.phone = phone; │ │ │ │ + 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: read_wmc_ContactFacsimileTelephone │ │ │ │ + * Method: updateScale │ │ │ │ */ │ │ │ │ - read_wmc_ContactFacsimileTelephone: function(contact, node) { │ │ │ │ - var fax = this.getChildValue(node); │ │ │ │ - if (fax) { │ │ │ │ - contact.fax = fax; │ │ │ │ + updateScale: function() { │ │ │ │ + var scale; │ │ │ │ + if (this.geodesic === true) { │ │ │ │ + var units = this.map.getUnits(); │ │ │ │ + if (!units) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ + scale = (this.map.getGeodesicPixelSize().w || 0.000001) * │ │ │ │ + inches["km"] * OpenLayers.DOTS_PER_INCH; │ │ │ │ + } else { │ │ │ │ + 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 = 1 : ${scaleDenom}", { │ │ │ │ + 'scaleDenom': scale │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Scale" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/ZoomToMaxExtent.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control/Button.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.ZoomToMaxExtent │ │ │ │ + * The ZoomToMaxExtent control is a button that zooms out to the maximum │ │ │ │ + * extent of the map. It is designed to be used with a │ │ │ │ + * <OpenLayers.Control.Panel>. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ZoomToMaxExtent = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: read_wmc_ContactElectronicMailAddress │ │ │ │ + * Method: trigger │ │ │ │ + * │ │ │ │ + * Called whenever this control is being rendered inside of a panel and a │ │ │ │ + * click occurs on this controls element. Actually zooms to the maximum │ │ │ │ + * extent of this controls map. │ │ │ │ */ │ │ │ │ - read_wmc_ContactElectronicMailAddress: function(contact, node) { │ │ │ │ - var email = this.getChildValue(node); │ │ │ │ - if (email) { │ │ │ │ - contact.email = email; │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.zoomToMaxExtent(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomToMaxExtent" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/ZoomPanel.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control/Panel.js │ │ │ │ + * @requires OpenLayers/Control/ZoomIn.js │ │ │ │ + * @requires OpenLayers/Control/ZoomOut.js │ │ │ │ + * @requires OpenLayers/Control/ZoomToMaxExtent.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.ZoomPanel │ │ │ │ + * The ZoomPanel control is a compact collecton of 3 zoom controls: a │ │ │ │ + * <OpenLayers.Control.ZoomIn>, a <OpenLayers.Control.ZoomToMaxExtent>, and a │ │ │ │ + * <OpenLayers.Control.ZoomOut>. By default it is drawn in the upper left │ │ │ │ + * corner of the map. │ │ │ │ + * │ │ │ │ + * Note: │ │ │ │ + * If you wish to use this class with the default images and you want │ │ │ │ + * it to look nice in ie6, you should add the following, conditionally │ │ │ │ + * added css stylesheet to your HTML file: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * <!--[if lte IE 6]> │ │ │ │ + * <link rel="stylesheet" href="../theme/default/ie6-style.css" type="text/css" /> │ │ │ │ + * <![endif]--> │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control.Panel> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ZoomPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: read_wmc_DataURL │ │ │ │ + * Constructor: OpenLayers.Control.ZoomPanel │ │ │ │ + * Add the three zooming controls. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ */ │ │ │ │ - read_wmc_DataURL: function(layerContext, node) { │ │ │ │ - layerContext.dataURL = this.getOnlineResource_href(node); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + this.addControls([ │ │ │ │ + new OpenLayers.Control.ZoomIn(), │ │ │ │ + new OpenLayers.Control.ZoomToMaxExtent(), │ │ │ │ + new OpenLayers.Control.ZoomOut() │ │ │ │ + ]); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomPanel" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/ScaleLine.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.ScaleLine │ │ │ │ + * The ScaleLine displays a small line indicator representing the current │ │ │ │ + * map scale on the map. By default it is drawn in the lower left corner of │ │ │ │ + * the map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + * │ │ │ │ + * Is a very close copy of: │ │ │ │ + * - <OpenLayers.Control.Scale> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ScaleLine = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: read_wmc_LegendURL │ │ │ │ + * Property: maxWidth │ │ │ │ + * {Integer} Maximum width of the scale line in pixels. Default is 100. │ │ │ │ */ │ │ │ │ - read_wmc_LegendURL: function(style, node) { │ │ │ │ - var legend = { │ │ │ │ - width: node.getAttribute('width'), │ │ │ │ - height: node.getAttribute('height'), │ │ │ │ - format: node.getAttribute('format'), │ │ │ │ - href: this.getOnlineResource_href(node) │ │ │ │ - }; │ │ │ │ - style.legend = legend; │ │ │ │ - }, │ │ │ │ + maxWidth: 100, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read_wmc_DimensionList │ │ │ │ + * Property: topOutUnits │ │ │ │ + * {String} Units for zoomed out on top bar. Default is km. │ │ │ │ */ │ │ │ │ - read_wmc_DimensionList: function(layerContext, node) { │ │ │ │ - layerContext.dimensions = {}; │ │ │ │ - this.runChildNodes(layerContext.dimensions, node); │ │ │ │ - }, │ │ │ │ + topOutUnits: "km", │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: read_wmc_Dimension │ │ │ │ + * Property: topInUnits │ │ │ │ + * {String} Units for zoomed in on top bar. Default is m. │ │ │ │ */ │ │ │ │ - read_wmc_Dimension: function(dimensions, node) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - │ │ │ │ - var dim = { │ │ │ │ - name: name, │ │ │ │ - units: node.getAttribute("units") || "", │ │ │ │ - unitSymbol: node.getAttribute("unitSymbol") || "", │ │ │ │ - userValue: node.getAttribute("userValue") || "", │ │ │ │ - nearestValue: node.getAttribute("nearestValue") === "1", │ │ │ │ - multipleValues: node.getAttribute("multipleValues") === "1", │ │ │ │ - current: node.getAttribute("current") === "1", │ │ │ │ - "default": node.getAttribute("default") || "" │ │ │ │ - }; │ │ │ │ - var values = this.getChildValue(node); │ │ │ │ - dim.values = values.split(","); │ │ │ │ - │ │ │ │ - dimensions[dim.name] = dim; │ │ │ │ - }, │ │ │ │ + topInUnits: "m", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} An object representing the map context. │ │ │ │ - * options - {Object} Optional object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A WMC document string. │ │ │ │ + * Property: bottomOutUnits │ │ │ │ + * {String} Units for zoomed out on bottom bar. Default is mi. │ │ │ │ */ │ │ │ │ - write: function(context, options) { │ │ │ │ - var root = this.createElementDefaultNS("ViewContext"); │ │ │ │ - this.setAttributes(root, { │ │ │ │ - version: this.VERSION, │ │ │ │ - id: (options && typeof options.id == "string") ? │ │ │ │ - options.id : OpenLayers.Util.createUniqueID("OpenLayers_Context_") │ │ │ │ - }); │ │ │ │ + bottomOutUnits: "mi", │ │ │ │ │ │ │ │ - // add schemaLocation attribute │ │ │ │ - this.setAttributeNS( │ │ │ │ - root, this.namespaces.xsi, │ │ │ │ - "xsi:schemaLocation", this.schemaLocation │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * Property: bottomInUnits │ │ │ │ + * {String} Units for zoomed in on bottom bar. Default is ft. │ │ │ │ + */ │ │ │ │ + bottomInUnits: "ft", │ │ │ │ │ │ │ │ - // required General element │ │ │ │ - root.appendChild(this.write_wmc_General(context)); │ │ │ │ + /** │ │ │ │ + * Property: eTop │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + eTop: null, │ │ │ │ │ │ │ │ - // required LayerList element │ │ │ │ - root.appendChild(this.write_wmc_LayerList(context)); │ │ │ │ + /** │ │ │ │ + * Property: eBottom │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + eBottom: null, │ │ │ │ │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [root]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: geodesic │ │ │ │ + * {Boolean} Use geodesic measurement. Default is false. The recommended │ │ │ │ + * setting for maps in EPSG:4326 is false, and true EPSG:900913. If set to │ │ │ │ + * true, the scale will be calculated based on the horizontal size of the │ │ │ │ + * pixel in the center of the map viewport. │ │ │ │ + */ │ │ │ │ + geodesic: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createElementDefaultNS │ │ │ │ - * Shorthand for createElementNS with namespace from <defaultPrefix>. │ │ │ │ - * Can optionally be used to set attributes and a text child value. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Control.ScaleLine │ │ │ │ + * Create a new scale line control. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} The qualified node name. │ │ │ │ - * childValue - {String} Optional value for text child node. │ │ │ │ - * attributes - {Object} Optional object representing attributes. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} An element node. │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ */ │ │ │ │ - createElementDefaultNS: function(name, childValue, attributes) { │ │ │ │ - var node = this.createElementNS( │ │ │ │ - this.namespaces[this.defaultPrefix], │ │ │ │ - name │ │ │ │ - ); │ │ │ │ - if (childValue) { │ │ │ │ - node.appendChild(this.createTextNode(childValue)); │ │ │ │ - } │ │ │ │ - if (attributes) { │ │ │ │ - this.setAttributes(node, attributes); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setAttributes │ │ │ │ - * Set multiple attributes given key value pairs from an object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {Element} An element node. │ │ │ │ - * obj - {Object} An object whose properties represent attribute names and │ │ │ │ - * values represent attribute values. │ │ │ │ + * Method: draw │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - setAttributes: function(node, obj) { │ │ │ │ - var value; │ │ │ │ - for (var name in obj) { │ │ │ │ - value = obj[name].toString(); │ │ │ │ - if (value.match(/[A-Z]/)) { │ │ │ │ - // safari lowercases attributes with setAttribute │ │ │ │ - this.setAttributeNS(node, null, name, value); │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.eTop) { │ │ │ │ + // 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 { │ │ │ │ - node.setAttribute(name, value); │ │ │ │ + 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: write_wmc_General │ │ │ │ - * Create a General node given an context object. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * 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: │ │ │ │ - * context - {Object} Context object. │ │ │ │ - * │ │ │ │ + * maxLen - {float} the number we're rounding down from │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Element} A WMC General element node. │ │ │ │ + * {Float} the rounded number (less than or equal to maxLen) │ │ │ │ */ │ │ │ │ - write_wmc_General: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("General"); │ │ │ │ + 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); │ │ │ │ │ │ │ │ - // optional Window element │ │ │ │ - if (context.size) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Window", null, { │ │ │ │ - width: context.size.w, │ │ │ │ - height: context.size.h │ │ │ │ - } │ │ │ │ - )); │ │ │ │ - } │ │ │ │ + // ok, find first character │ │ │ │ + var firstChar = parseInt(maxLen / pow10); │ │ │ │ │ │ │ │ - // required BoundingBox element │ │ │ │ - var bounds = context.bounds; │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "BoundingBox", null, { │ │ │ │ - minx: bounds.left.toPrecision(18), │ │ │ │ - miny: bounds.bottom.toPrecision(18), │ │ │ │ - maxx: bounds.right.toPrecision(18), │ │ │ │ - maxy: bounds.top.toPrecision(18), │ │ │ │ - SRS: context.projection │ │ │ │ - } │ │ │ │ - )); │ │ │ │ + // right, put it into the correct bracket │ │ │ │ + var barLen; │ │ │ │ + if (firstChar > 5) { │ │ │ │ + barLen = 5; │ │ │ │ + } else if (firstChar > 2) { │ │ │ │ + barLen = 2; │ │ │ │ + } else { │ │ │ │ + barLen = 1; │ │ │ │ + } │ │ │ │ │ │ │ │ - // required Title element │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Title", context.title │ │ │ │ - )); │ │ │ │ + // scale it up the correct power of 10 │ │ │ │ + return barLen * pow10; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // optional KeywordList element │ │ │ │ - if (context.keywords) { │ │ │ │ - node.appendChild(this.write_wmc_KeywordList(context.keywords)); │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ + * Update the size of the bars, and the labels they contain. │ │ │ │ + */ │ │ │ │ + update: function() { │ │ │ │ + var res = this.map.getResolution(); │ │ │ │ + if (!res) { │ │ │ │ + return; │ │ │ │ } │ │ │ │ │ │ │ │ - // optional Abstract element │ │ │ │ - if (context["abstract"]) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Abstract", context["abstract"] │ │ │ │ - )); │ │ │ │ - } │ │ │ │ + var curMapUnits = this.map.getUnits(); │ │ │ │ + var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ │ │ │ │ - // Optional LogoURL element │ │ │ │ - if (context.logo) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("LogoURL", context.logo.href, context.logo)); │ │ │ │ + // convert maxWidth to map units │ │ │ │ + var maxSizeData = this.maxWidth * res * inches[curMapUnits]; │ │ │ │ + var geodesicRatio = 1; │ │ │ │ + if (this.geodesic === true) { │ │ │ │ + var maxSizeGeodesic = (this.map.getGeodesicPixelSize().w || │ │ │ │ + 0.000001) * this.maxWidth; │ │ │ │ + var maxSizeKilometers = maxSizeData / inches["km"]; │ │ │ │ + geodesicRatio = maxSizeGeodesic / maxSizeKilometers; │ │ │ │ + maxSizeData *= geodesicRatio; │ │ │ │ } │ │ │ │ │ │ │ │ - // Optional DescriptionURL element │ │ │ │ - if (context.descriptionURL) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("DescriptionURL", context.descriptionURL)); │ │ │ │ + // 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; │ │ │ │ } │ │ │ │ │ │ │ │ - // Optional ContactInformation element │ │ │ │ - if (context.contactInformation) { │ │ │ │ - node.appendChild(this.write_wmc_ContactInformation(context.contactInformation)); │ │ │ │ + // 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 / geodesicRatio; │ │ │ │ + var bottomPx = bottomMax / res / geodesicRatio; │ │ │ │ + │ │ │ │ + // now set the pixel widths │ │ │ │ + // and the values inside them │ │ │ │ + │ │ │ │ + if (this.eBottom.style.visibility == "visible") { │ │ │ │ + this.eBottom.style.width = Math.round(bottomPx) + "px"; │ │ │ │ + this.eBottom.innerHTML = bottomRounded + " " + bottomUnits; │ │ │ │ } │ │ │ │ │ │ │ │ - // OpenLayers specific map properties │ │ │ │ - node.appendChild(this.write_ol_MapExtension(context)); │ │ │ │ + if (this.eTop.style.visibility == "visible") { │ │ │ │ + this.eTop.style.width = Math.round(topPx) + "px"; │ │ │ │ + this.eTop.innerHTML = topRounded + " " + topUnits; │ │ │ │ + } │ │ │ │ │ │ │ │ - return node; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ScaleLine" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/CacheWrite.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ + * @requires OpenLayers/Console.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.CacheWrite │ │ │ │ + * A control for caching image tiles in the browser's local storage. The │ │ │ │ + * <OpenLayers.Control.CacheRead> control is used to fetch and use the cached │ │ │ │ + * tile images. │ │ │ │ + * │ │ │ │ + * Note: Before using this control on any layer that is not your own, make sure │ │ │ │ + * that the terms of service of the tile provider allow local storage of tiles. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.CacheWrite = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * To register events in the constructor, configure <eventListeners>. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * cachefull - Triggered when the cache is full. Listeners receive an │ │ │ │ + * object with a tile property as first argument. The tile references │ │ │ │ + * the tile that couldn't be cached. │ │ │ │ + */ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: write_wmc_KeywordList │ │ │ │ + * APIProperty: eventListeners │ │ │ │ + * {Object} Object with event listeners, keyed by event name. An optional │ │ │ │ + * scope property defines the scope that listeners will be executed in. │ │ │ │ */ │ │ │ │ - write_wmc_KeywordList: function(keywords) { │ │ │ │ - var node = this.createElementDefaultNS("KeywordList"); │ │ │ │ │ │ │ │ - for (var i = 0, len = keywords.length; i < len; i++) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Keyword", keywords[i] │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ /** │ │ │ │ - * Method: write_wmc_ContactInformation │ │ │ │ + * APIProperty: layers │ │ │ │ + * {Array(<OpenLayers.Layer.Grid>)}. Optional. If provided, caching │ │ │ │ + * will be enabled for these layers only, otherwise for all cacheable │ │ │ │ + * layers. │ │ │ │ */ │ │ │ │ - write_wmc_ContactInformation: function(contact) { │ │ │ │ - var node = this.createElementDefaultNS("ContactInformation"); │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ - if (contact.personPrimary) { │ │ │ │ - node.appendChild(this.write_wmc_ContactPersonPrimary(contact.personPrimary)); │ │ │ │ - } │ │ │ │ - if (contact.position) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "ContactPosition", contact.position │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - if (contact.contactAddress) { │ │ │ │ - node.appendChild(this.write_wmc_ContactAddress(contact.contactAddress)); │ │ │ │ - } │ │ │ │ - if (contact.phone) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "ContactVoiceTelephone", contact.phone │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - if (contact.fax) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "ContactFacsimileTelephone", contact.fax │ │ │ │ - )); │ │ │ │ + /** │ │ │ │ + * APIProperty: imageFormat │ │ │ │ + * {String} The image format used for caching. The default is "image/png". │ │ │ │ + * Supported formats depend on the user agent. If an unsupported │ │ │ │ + * <imageFormat> is provided, "image/png" will be used. For aerial │ │ │ │ + * imagery, "image/jpeg" is recommended. │ │ │ │ + */ │ │ │ │ + imageFormat: "image/png", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: quotaRegEx │ │ │ │ + * {RegExp} │ │ │ │ + */ │ │ │ │ + quotaRegEx: (/quota/i), │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.CacheWrite │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Object with API properties for this control. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + var i, layers = this.layers || map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.addLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }); │ │ │ │ } │ │ │ │ - if (contact.email) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "ContactElectronicMailAddress", contact.email │ │ │ │ - )); │ │ │ │ + if (!this.layers) { │ │ │ │ + map.events.on({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_ContactPersonPrimary │ │ │ │ + * Method: addLayer │ │ │ │ + * Adds a layer to the control. Once added, tiles requested for this layer │ │ │ │ + * will be cached. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} Object with a layer property referencing an │ │ │ │ + * <OpenLayers.Layer> instance │ │ │ │ */ │ │ │ │ - write_wmc_ContactPersonPrimary: function(personPrimary) { │ │ │ │ - var node = this.createElementDefaultNS("ContactPersonPrimary"); │ │ │ │ - if (personPrimary.person) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "ContactPerson", personPrimary.person │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - if (personPrimary.organization) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "ContactOrganization", personPrimary.organization │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ + addLayer: function(evt) { │ │ │ │ + evt.layer.events.on({ │ │ │ │ + tileloadstart: this.makeSameOrigin, │ │ │ │ + tileloaded: this.onTileLoaded, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_ContactAddress │ │ │ │ + * Method: removeLayer │ │ │ │ + * Removes a layer from the control. Once removed, tiles requested for this │ │ │ │ + * layer will no longer be cached. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} Object with a layer property referencing an │ │ │ │ + * <OpenLayers.Layer> instance │ │ │ │ */ │ │ │ │ - write_wmc_ContactAddress: function(contactAddress) { │ │ │ │ - var node = this.createElementDefaultNS("ContactAddress"); │ │ │ │ - if (contactAddress.type) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "AddressType", contactAddress.type │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - if (contactAddress.address) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Address", contactAddress.address │ │ │ │ - )); │ │ │ │ + removeLayer: function(evt) { │ │ │ │ + evt.layer.events.un({ │ │ │ │ + tileloadstart: this.makeSameOrigin, │ │ │ │ + tileloaded: this.onTileLoaded, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: makeSameOrigin │ │ │ │ + * If the tile does not have CORS image loading enabled and is from a │ │ │ │ + * different origin, use OpenLayers.ProxyHost to make it a same origin url. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ + */ │ │ │ │ + makeSameOrigin: function(evt) { │ │ │ │ + if (this.active) { │ │ │ │ + var tile = evt.tile; │ │ │ │ + if (tile instanceof OpenLayers.Tile.Image && │ │ │ │ + !tile.crossOriginKeyword && │ │ │ │ + tile.url.substr(0, 5) !== "data:") { │ │ │ │ + var sameOriginUrl = OpenLayers.Request.makeSameOrigin( │ │ │ │ + tile.url, OpenLayers.ProxyHost │ │ │ │ + ); │ │ │ │ + OpenLayers.Control.CacheWrite.urlMap[sameOriginUrl] = tile.url; │ │ │ │ + tile.url = sameOriginUrl; │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (contactAddress.city) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "City", contactAddress.city │ │ │ │ - )); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: onTileLoaded │ │ │ │ + * Decides whether a tile can be cached and calls the cache method. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + onTileLoaded: function(evt) { │ │ │ │ + if (this.active && !evt.aborted && │ │ │ │ + evt.tile instanceof OpenLayers.Tile.Image && │ │ │ │ + evt.tile.url.substr(0, 5) !== 'data:') { │ │ │ │ + this.cache({ │ │ │ │ + tile: evt.tile │ │ │ │ + }); │ │ │ │ + delete OpenLayers.Control.CacheWrite.urlMap[evt.tile.url]; │ │ │ │ } │ │ │ │ - if (contactAddress.stateOrProvince) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "StateOrProvince", contactAddress.stateOrProvince │ │ │ │ - )); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: cache │ │ │ │ + * Adds a tile to the cache. When the cache is full, the "cachefull" event │ │ │ │ + * is triggered. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} Object with a tile property, tile being the │ │ │ │ + * <OpenLayers.Tile.Image> with the data to add to the cache │ │ │ │ + */ │ │ │ │ + cache: function(obj) { │ │ │ │ + if (window.localStorage) { │ │ │ │ + var tile = obj.tile; │ │ │ │ + try { │ │ │ │ + var canvasContext = tile.getCanvasContext(); │ │ │ │ + if (canvasContext) { │ │ │ │ + var urlMap = OpenLayers.Control.CacheWrite.urlMap; │ │ │ │ + var url = urlMap[tile.url] || tile.url; │ │ │ │ + window.localStorage.setItem( │ │ │ │ + "olCache_" + url, │ │ │ │ + canvasContext.canvas.toDataURL(this.imageFormat) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } catch (e) { │ │ │ │ + // local storage full or CORS violation │ │ │ │ + var reason = e.name || e.message; │ │ │ │ + if (reason && this.quotaRegEx.test(reason)) { │ │ │ │ + this.events.triggerEvent("cachefull", { │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.error(e.toString()); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (contactAddress.postcode) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "PostCode", contactAddress.postcode │ │ │ │ - )); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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.layers || this.map) { │ │ │ │ + var i, layers = this.layers || this.map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (contactAddress.country) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Country", contactAddress.country │ │ │ │ - )); │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.un({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: write_ol_MapExtension │ │ │ │ + CLASS_NAME: "OpenLayers.Control.CacheWrite" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * APIFunction: OpenLayers.Control.CacheWrite.clearCache │ │ │ │ + * Clears all tiles cached with <OpenLayers.Control.CacheWrite> from the cache. │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.CacheWrite.clearCache = function() { │ │ │ │ + if (!window.localStorage) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var i, key; │ │ │ │ + for (i = window.localStorage.length - 1; i >= 0; --i) { │ │ │ │ + key = window.localStorage.key(i); │ │ │ │ + if (key.substr(0, 8) === "olCache_") { │ │ │ │ + window.localStorage.removeItem(key); │ │ │ │ + } │ │ │ │ + } │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Property: OpenLayers.Control.CacheWrite.urlMap │ │ │ │ + * {Object} Mapping of same origin urls to cache url keys. Entries will be │ │ │ │ + * deleted as soon as a tile was cached. │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.CacheWrite.urlMap = {}; │ │ │ │ + │ │ │ │ + │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/LayerSwitcher.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Lang.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.LayerSwitcher │ │ │ │ + * The LayerSwitcher control displays a table of contents for the map. This │ │ │ │ + * allows the user interface to switch between BaseLasyers and to show or hide │ │ │ │ + * Overlays. By default the switcher is shown minimized on the right edge of │ │ │ │ + * the map, the user may expand it by clicking on the handle. │ │ │ │ + * │ │ │ │ + * To create the LayerSwitcher outside of the map, pass the Id of a html div │ │ │ │ + * as the first argument to the constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - write_ol_MapExtension: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("Extension"); │ │ │ │ + layerStates: null, │ │ │ │ │ │ │ │ - var bounds = context.maxExtent; │ │ │ │ - if (bounds) { │ │ │ │ - var maxExtent = this.createElementNS( │ │ │ │ - this.namespaces.ol, "ol:maxExtent" │ │ │ │ - ); │ │ │ │ - this.setAttributes(maxExtent, { │ │ │ │ - minx: bounds.left.toPrecision(18), │ │ │ │ - miny: bounds.bottom.toPrecision(18), │ │ │ │ - maxx: bounds.right.toPrecision(18), │ │ │ │ - maxy: bounds.top.toPrecision(18) │ │ │ │ - }); │ │ │ │ - node.appendChild(maxExtent); │ │ │ │ - } │ │ │ │ + // DOM Elements │ │ │ │ │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: layersDiv │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + layersDiv: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_LayerList │ │ │ │ - * Create a LayerList node given an context object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} Context object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC LayerList element node. │ │ │ │ + * Property: baseLayersDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - write_wmc_LayerList: function(context) { │ │ │ │ - var list = this.createElementDefaultNS("LayerList"); │ │ │ │ + baseLayersDiv: null, │ │ │ │ │ │ │ │ - for (var i = 0, len = context.layersContext.length; i < len; ++i) { │ │ │ │ - list.appendChild(this.write_wmc_Layer(context.layersContext[i])); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: baseLayers │ │ │ │ + * {Array(Object)} │ │ │ │ + */ │ │ │ │ + baseLayers: null, │ │ │ │ │ │ │ │ - return list; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_Layer │ │ │ │ - * Create a Layer node given a layer context object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} A layer context object.} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC Layer element node. │ │ │ │ + * Property: dataLbl │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - write_wmc_Layer: function(context) { │ │ │ │ - var node = this.createElementDefaultNS( │ │ │ │ - "Layer", null, { │ │ │ │ - queryable: context.queryable ? "1" : "0", │ │ │ │ - hidden: context.visibility ? "0" : "1" │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - │ │ │ │ - // required Server element │ │ │ │ - node.appendChild(this.write_wmc_Server(context)); │ │ │ │ + dataLbl: null, │ │ │ │ │ │ │ │ - // required Name element │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Name", context.name │ │ │ │ - )); │ │ │ │ + /** │ │ │ │ + * Property: dataLayersDiv │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + dataLayersDiv: null, │ │ │ │ │ │ │ │ - // required Title element │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Title", context.title │ │ │ │ - )); │ │ │ │ + /** │ │ │ │ + * Property: dataLayers │ │ │ │ + * {Array(Object)} │ │ │ │ + */ │ │ │ │ + dataLayers: null, │ │ │ │ │ │ │ │ - // optional Abstract element │ │ │ │ - if (context["abstract"]) { │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Abstract", context["abstract"] │ │ │ │ - )); │ │ │ │ - } │ │ │ │ │ │ │ │ - // optional DataURL element │ │ │ │ - if (context.dataURL) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("DataURL", context.dataURL)); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: minimizeDiv │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + minimizeDiv: null, │ │ │ │ │ │ │ │ - // optional MetadataURL element │ │ │ │ - if (context.metadataURL) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("MetadataURL", context.metadataURL)); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: maximizeDiv │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + maximizeDiv: null, │ │ │ │ │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: ascending │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + ascending: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_LayerExtension │ │ │ │ - * Add OpenLayers specific layer parameters to an Extension element. │ │ │ │ + * Constructor: OpenLayers.Control.LayerSwitcher │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * context - {Object} A layer context object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC Extension element (for a layer). │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - write_wmc_LayerExtension: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("Extension"); │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + this.layerStates = []; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var bounds = context.maxExtent; │ │ │ │ - var maxExtent = this.createElementNS( │ │ │ │ - this.namespaces.ol, "ol:maxExtent" │ │ │ │ - ); │ │ │ │ - this.setAttributes(maxExtent, { │ │ │ │ - minx: bounds.left.toPrecision(18), │ │ │ │ - miny: bounds.bottom.toPrecision(18), │ │ │ │ - maxx: bounds.right.toPrecision(18), │ │ │ │ - maxy: bounds.top.toPrecision(18) │ │ │ │ - }); │ │ │ │ - node.appendChild(maxExtent); │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ │ │ │ │ - if (context.tileSize && !context.singleTile) { │ │ │ │ - var size = this.createElementNS( │ │ │ │ - this.namespaces.ol, "ol:tileSize" │ │ │ │ - ); │ │ │ │ - this.setAttributes(size, context.tileSize); │ │ │ │ - node.appendChild(size); │ │ │ │ - } │ │ │ │ + //clear out layers info and unregister their events │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ │ │ │ │ - var properties = [ │ │ │ │ - "transparent", "numZoomLevels", "units", "isBaseLayer", │ │ │ │ - "opacity", "displayInLayerSwitcher", "singleTile" │ │ │ │ - ]; │ │ │ │ - var child; │ │ │ │ - for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ - child = this.createOLPropertyNode(context, properties[i]); │ │ │ │ - if (child) { │ │ │ │ - node.appendChild(child); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.map.events.un({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + addlayer: this.redraw, │ │ │ │ + changelayer: this.redraw, │ │ │ │ + removelayer: this.redraw, │ │ │ │ + changebaselayer: this.redraw, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ │ │ │ │ - return node; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createOLPropertyNode │ │ │ │ - * Create a node representing an OpenLayers property. If the property is │ │ │ │ - * null or undefined, null will be returned. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} An object. │ │ │ │ - * prop - {String} A property. │ │ │ │ + * Method: setMap │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A property node. │ │ │ │ + * Properties: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - createOLPropertyNode: function(obj, prop) { │ │ │ │ - var node = null; │ │ │ │ - if (obj[prop] != null) { │ │ │ │ - node = this.createElementNS(this.namespaces.ol, "ol:" + prop); │ │ │ │ - node.appendChild(this.createTextNode(obj[prop].toString())); │ │ │ │ + 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 │ │ │ │ + }); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_Server │ │ │ │ - * Create a Server node given a layer context object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} Layer context object. │ │ │ │ + * Method: draw │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Element} A WMC Server element node. │ │ │ │ + * {DOMElement} A reference to the DIV DOMElement containing the │ │ │ │ + * switcher tabs. │ │ │ │ */ │ │ │ │ - write_wmc_Server: function(context) { │ │ │ │ - var server = context.server; │ │ │ │ - var node = this.createElementDefaultNS("Server"); │ │ │ │ - var attributes = { │ │ │ │ - service: "OGC:WMS", │ │ │ │ - version: server.version │ │ │ │ - }; │ │ │ │ - if (server.title) { │ │ │ │ - attributes.title = server.title; │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ + │ │ │ │ + // create layout divs │ │ │ │ + this.loadContents(); │ │ │ │ + │ │ │ │ + // set mode to minimize │ │ │ │ + if (!this.outsideViewport) { │ │ │ │ + this.minimizeControl(); │ │ │ │ } │ │ │ │ - this.setAttributes(node, attributes); │ │ │ │ │ │ │ │ - // required OnlineResource element │ │ │ │ - node.appendChild(this.write_wmc_OnlineResource(server.url)); │ │ │ │ + // populate div with current info │ │ │ │ + this.redraw(); │ │ │ │ │ │ │ │ - return node; │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_URLType │ │ │ │ - * Create a LogoURL/DescriptionURL/MetadataURL/DataURL/LegendURL node given a object and elementName. │ │ │ │ + * Method: onButtonClick │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * elName - {String} Name of element (LogoURL/DescriptionURL/MetadataURL/LegendURL) │ │ │ │ - * url - {String} URL string value │ │ │ │ - * attr - {Object} Optional attributes (width, height, format) │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC element node. │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - write_wmc_URLType: function(elName, url, attr) { │ │ │ │ - var node = this.createElementDefaultNS(elName); │ │ │ │ - node.appendChild(this.write_wmc_OnlineResource(url)); │ │ │ │ - if (attr) { │ │ │ │ - var optionalAttributes = ["width", "height", "format"]; │ │ │ │ - for (var i = 0; i < optionalAttributes.length; i++) { │ │ │ │ - if (optionalAttributes[i] in attr) { │ │ │ │ - node.setAttribute(optionalAttributes[i], attr[optionalAttributes[i]]); │ │ │ │ - } │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.minimizeDiv) { │ │ │ │ + this.minimizeControl(); │ │ │ │ + } else if (button === this.maximizeDiv) { │ │ │ │ + this.maximizeControl(); │ │ │ │ + } else if (button._layerSwitcher === this.id) { │ │ │ │ + if (button["for"]) { │ │ │ │ + button = document.getElementById(button["for"]); │ │ │ │ } │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: write_wmc_DimensionList │ │ │ │ - */ │ │ │ │ - write_wmc_DimensionList: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("DimensionList"); │ │ │ │ - var required_attributes = { │ │ │ │ - name: true, │ │ │ │ - units: true, │ │ │ │ - unitSymbol: true, │ │ │ │ - userValue: true │ │ │ │ - }; │ │ │ │ - for (var dim in context.dimensions) { │ │ │ │ - var attributes = {}; │ │ │ │ - var dimension = context.dimensions[dim]; │ │ │ │ - for (var name in dimension) { │ │ │ │ - if (typeof dimension[name] == "boolean") { │ │ │ │ - attributes[name] = Number(dimension[name]); │ │ │ │ + if (!button.disabled) { │ │ │ │ + if (button.type == "radio") { │ │ │ │ + button.checked = true; │ │ │ │ + this.map.setBaseLayer(this.map.getLayer(button._layer)); │ │ │ │ } else { │ │ │ │ - attributes[name] = dimension[name]; │ │ │ │ + button.checked = !button.checked; │ │ │ │ + this.updateMap(); │ │ │ │ } │ │ │ │ } │ │ │ │ - var values = ""; │ │ │ │ - if (attributes.values) { │ │ │ │ - values = attributes.values.join(","); │ │ │ │ - delete attributes.values; │ │ │ │ - } │ │ │ │ - │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Dimension", values, attributes │ │ │ │ - )); │ │ │ │ } │ │ │ │ - return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_FormatList │ │ │ │ - * Create a FormatList node given a layer context. │ │ │ │ + * Method: clearLayersArray │ │ │ │ + * User specifies either "base" or "data". we then clear all the │ │ │ │ + * corresponding listeners, the div, and reinitialize a new array. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * context - {Object} Layer context object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC FormatList element node. │ │ │ │ + * layersType - {String} │ │ │ │ */ │ │ │ │ - write_wmc_FormatList: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("FormatList"); │ │ │ │ - for (var i = 0, len = context.formats.length; i < len; i++) { │ │ │ │ - var format = context.formats[i]; │ │ │ │ - node.appendChild(this.createElementDefaultNS( │ │ │ │ - "Format", │ │ │ │ - format.value, │ │ │ │ - (format.current && format.current == true) ? { │ │ │ │ - current: "1" │ │ │ │ - } : null │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return node; │ │ │ │ + clearLayersArray: function(layersType) { │ │ │ │ + this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ + this[layersType + "Layers"] = []; │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: write_wmc_StyleList │ │ │ │ - * Create a StyleList node given a layer context. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {Object} Layer context object. │ │ │ │ + * Method: checkRedraw │ │ │ │ + * Checks if the layer state has changed since the last redraw() call. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Element} A WMC StyleList element node. │ │ │ │ + * {Boolean} The layer state changed since the last redraw() call. │ │ │ │ */ │ │ │ │ - write_wmc_StyleList: function(layer) { │ │ │ │ - var node = this.createElementDefaultNS("StyleList"); │ │ │ │ - │ │ │ │ - var styles = layer.styles; │ │ │ │ - if (styles && OpenLayers.Util.isArray(styles)) { │ │ │ │ - var sld; │ │ │ │ - for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ - var s = styles[i]; │ │ │ │ - // three style types to consider │ │ │ │ - // [1] linked SLD │ │ │ │ - // [2] inline SLD │ │ │ │ - // [3] named style │ │ │ │ - // running child nodes always gets name, optionally gets href or body │ │ │ │ - var style = this.createElementDefaultNS( │ │ │ │ - "Style", │ │ │ │ - null, │ │ │ │ - (s.current && s.current == true) ? { │ │ │ │ - current: "1" │ │ │ │ - } : null │ │ │ │ - ); │ │ │ │ - if (s.href) { // [1] │ │ │ │ - sld = this.createElementDefaultNS("SLD"); │ │ │ │ - // Name is optional. │ │ │ │ - if (s.name) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ - } │ │ │ │ - // Title is optional. │ │ │ │ - if (s.title) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ - } │ │ │ │ - // LegendURL is optional │ │ │ │ - if (s.legend) { │ │ │ │ - sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var link = this.write_wmc_OnlineResource(s.href); │ │ │ │ - sld.appendChild(link); │ │ │ │ - style.appendChild(sld); │ │ │ │ - } else if (s.body) { // [2] │ │ │ │ - sld = this.createElementDefaultNS("SLD"); │ │ │ │ - // Name is optional. │ │ │ │ - if (s.name) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ - } │ │ │ │ - // Title is optional. │ │ │ │ - if (s.title) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ - } │ │ │ │ - // LegendURL is optional │ │ │ │ - if (s.legend) { │ │ │ │ - sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)); │ │ │ │ - } │ │ │ │ + checkRedraw: function() { │ │ │ │ + if (!this.layerStates.length || │ │ │ │ + (this.map.layers.length != this.layerStates.length)) { │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ │ │ │ │ - // read in body as xml doc - assume proper namespace declarations │ │ │ │ - var doc = OpenLayers.Format.XML.prototype.read.apply(this, [s.body]); │ │ │ │ - // append to StyledLayerDescriptor node │ │ │ │ - var imported = doc.documentElement; │ │ │ │ - if (sld.ownerDocument && sld.ownerDocument.importNode) { │ │ │ │ - imported = sld.ownerDocument.importNode(imported, true); │ │ │ │ - } │ │ │ │ - sld.appendChild(imported); │ │ │ │ - style.appendChild(sld); │ │ │ │ - } else { // [3] │ │ │ │ - // both Name and Title are required. │ │ │ │ - style.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ - style.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ - // Abstract is optional │ │ │ │ - if (s['abstract']) { // abstract is a js keyword │ │ │ │ - style.appendChild(this.createElementDefaultNS( │ │ │ │ - "Abstract", s['abstract'] │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - // LegendURL is optional │ │ │ │ - if (s.legend) { │ │ │ │ - style.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - node.appendChild(style); │ │ │ │ + for (var i = 0, len = this.layerStates.length; i < len; 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)) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ } │ │ │ │ │ │ │ │ - return node; │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write_wmc_OnlineResource │ │ │ │ - * Create an OnlineResource node given a URL. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * href - {String} URL for the resource. │ │ │ │ + * 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: │ │ │ │ - * {Element} A WMC OnlineResource element node. │ │ │ │ - */ │ │ │ │ - write_wmc_OnlineResource: function(href) { │ │ │ │ - var node = this.createElementDefaultNS("OnlineResource"); │ │ │ │ - this.setAttributeNS(node, this.namespaces.xlink, "xlink:type", "simple"); │ │ │ │ - this.setAttributeNS(node, this.namespaces.xlink, "xlink:href", href); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getOnlineResource_href │ │ │ │ + * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ */ │ │ │ │ - getOnlineResource_href: function(node) { │ │ │ │ - var object = {}; │ │ │ │ - var links = node.getElementsByTagName("OnlineResource"); │ │ │ │ - if (links.length > 0) { │ │ │ │ - this.read_wmc_OnlineResource(object, links[0]); │ │ │ │ + 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; │ │ │ │ } │ │ │ │ - return object.href; │ │ │ │ - }, │ │ │ │ - │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC.v1" │ │ │ │ + //clear out previous layers │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMC/v1_1_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + var containsOverlays = false; │ │ │ │ + var containsBaseLayers = false; │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + // 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. │ │ │ │ + var len = this.map.layers.length; │ │ │ │ + this.layerStates = new Array(len); │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + this.layerStates[i] = { │ │ │ │ + 'name': layer.name, │ │ │ │ + 'visibility': layer.visibility, │ │ │ │ + 'inRange': layer.inRange, │ │ │ │ + 'id': layer.id │ │ │ │ + }; │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMC/v1.js │ │ │ │ - */ │ │ │ │ + var layers = this.map.layers.slice(); │ │ │ │ + if (!this.ascending) { │ │ │ │ + layers.reverse(); │ │ │ │ + } │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + var baseLayer = layer.isBaseLayer; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMC.v1_1_0 │ │ │ │ - * Read and write WMC version 1.1.0. │ │ │ │ - * │ │ │ │ - * Differences between 1.1.0 and 1.0.0: │ │ │ │ - * - 1.1.0 Layers have optional sld:MinScaleDenominator and │ │ │ │ - * sld:MaxScaleDenominator │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMC.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMC.v1_1_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMC.v1, { │ │ │ │ + if (layer.displayInLayerSwitcher) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.1.0 │ │ │ │ - */ │ │ │ │ - VERSION: "1.1.0", │ │ │ │ + if (baseLayer) { │ │ │ │ + containsBaseLayers = true; │ │ │ │ + } else { │ │ │ │ + containsOverlays = true; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/context │ │ │ │ - * http://schemas.opengis.net/context/1.1.0/context.xsd │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.1.0/context.xsd", │ │ │ │ + // 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(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMC.v1_1_0 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.WMC> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.WMC.v1.prototype.initialize.apply( │ │ │ │ - this, [options] │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ + // create input element │ │ │ │ + var inputElem = document.createElement("input"), │ │ │ │ + // The input shall have an id attribute so we can use │ │ │ │ + // labels to interact with them. │ │ │ │ + inputId = OpenLayers.Util.createUniqueID( │ │ │ │ + this.id + "_input_" │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_sld_MinScaleDenominator │ │ │ │ - * Read a sld:MinScaleDenominator node. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layerContext - {Object} An object representing a layer. │ │ │ │ - * node - {Element} An element node. │ │ │ │ - */ │ │ │ │ - read_sld_MinScaleDenominator: function(layerContext, node) { │ │ │ │ - var minScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ - if (minScaleDenominator > 0) { │ │ │ │ - layerContext.maxScale = minScaleDenominator; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + inputElem.id = inputId; │ │ │ │ + inputElem.name = (baseLayer) ? this.id + "_baseLayers" : layer.name; │ │ │ │ + inputElem.type = (baseLayer) ? "radio" : "checkbox"; │ │ │ │ + inputElem.value = layer.name; │ │ │ │ + inputElem.checked = checked; │ │ │ │ + inputElem.defaultChecked = checked; │ │ │ │ + inputElem.className = "olButton"; │ │ │ │ + inputElem._layer = layer.id; │ │ │ │ + inputElem._layerSwitcher = this.id; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_sld_MaxScaleDenominator │ │ │ │ - * Read a sld:MaxScaleDenominator node. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layerContext - {Object} An object representing a layer. │ │ │ │ - * node - {Element} An element node. │ │ │ │ - */ │ │ │ │ - read_sld_MaxScaleDenominator: function(layerContext, node) { │ │ │ │ - layerContext.minScale = parseFloat(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + inputElem.disabled = true; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_wmc_SRS │ │ │ │ - */ │ │ │ │ - read_wmc_SRS: function(layerContext, node) { │ │ │ │ - if (!("srs" in layerContext)) { │ │ │ │ - layerContext.srs = {}; │ │ │ │ - } │ │ │ │ - layerContext.srs[this.getChildValue(node)] = true; │ │ │ │ - }, │ │ │ │ + // create span │ │ │ │ + var labelSpan = document.createElement("label"); │ │ │ │ + // this isn't the DOM attribute 'for', but an arbitrary name we │ │ │ │ + // use to find the appropriate input element in <onButtonClick> │ │ │ │ + labelSpan["for"] = inputElem.id; │ │ │ │ + OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ + labelSpan._layer = layer.id; │ │ │ │ + labelSpan._layerSwitcher = this.id; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + labelSpan.style.color = "gray"; │ │ │ │ + } │ │ │ │ + labelSpan.innerHTML = layer.name; │ │ │ │ + labelSpan.style.verticalAlign = (baseLayer) ? "bottom" : │ │ │ │ + "baseline"; │ │ │ │ + // create line break │ │ │ │ + var br = document.createElement("br"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: write_wmc_Layer │ │ │ │ - * Create a Layer node given a layer context object. This method adds │ │ │ │ - * elements specific to version 1.1.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} A layer context object.} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC Layer element node. │ │ │ │ - */ │ │ │ │ - write_wmc_Layer: function(context) { │ │ │ │ - var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply( │ │ │ │ - this, [context] │ │ │ │ - ); │ │ │ │ │ │ │ │ - // min/max scale denominator elements go before the 4th element in v1 │ │ │ │ - if (context.maxScale) { │ │ │ │ - var minSD = this.createElementNS( │ │ │ │ - this.namespaces.sld, "sld:MinScaleDenominator" │ │ │ │ - ); │ │ │ │ - minSD.appendChild(this.createTextNode(context.maxScale.toPrecision(16))); │ │ │ │ - node.appendChild(minSD); │ │ │ │ - } │ │ │ │ + var groupArray = (baseLayer) ? this.baseLayers : │ │ │ │ + this.dataLayers; │ │ │ │ + groupArray.push({ │ │ │ │ + 'layer': layer, │ │ │ │ + 'inputElem': inputElem, │ │ │ │ + 'labelSpan': labelSpan │ │ │ │ + }); │ │ │ │ │ │ │ │ - if (context.minScale) { │ │ │ │ - var maxSD = this.createElementNS( │ │ │ │ - this.namespaces.sld, "sld:MaxScaleDenominator" │ │ │ │ - ); │ │ │ │ - maxSD.appendChild(this.createTextNode(context.minScale.toPrecision(16))); │ │ │ │ - node.appendChild(maxSD); │ │ │ │ - } │ │ │ │ │ │ │ │ - // optional SRS element(s) │ │ │ │ - if (context.srs) { │ │ │ │ - for (var name in context.srs) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("SRS", name)); │ │ │ │ - } │ │ │ │ + var groupDiv = (baseLayer) ? this.baseLayersDiv : │ │ │ │ + this.dataLayersDiv; │ │ │ │ + groupDiv.appendChild(inputElem); │ │ │ │ + groupDiv.appendChild(labelSpan); │ │ │ │ + groupDiv.appendChild(br); │ │ │ │ } │ │ │ │ + } │ │ │ │ │ │ │ │ - // optional FormatList element │ │ │ │ - node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ + // if no overlays, dont display the overlay label │ │ │ │ + this.dataLbl.style.display = (containsOverlays) ? "" : "none"; │ │ │ │ │ │ │ │ - // optional StyleList element │ │ │ │ - node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ + // if no baselayers, dont display the baselayer label │ │ │ │ + this.baseLbl.style.display = (containsBaseLayers) ? "" : "none"; │ │ │ │ │ │ │ │ - // optional DimensionList element │ │ │ │ - if (context.dimensions) { │ │ │ │ - node.appendChild(this.write_wmc_DimensionList(context)); │ │ │ │ - } │ │ │ │ + return this.div; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // OpenLayers specific properties go in an Extension element │ │ │ │ - node.appendChild(this.write_wmc_LayerExtension(context)); │ │ │ │ + /** │ │ │ │ + * 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() { │ │ │ │ │ │ │ │ - return node; │ │ │ │ + // set the newly selected base layer │ │ │ │ + for (var i = 0, len = this.baseLayers.length; i < len; 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, len = this.dataLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.dataLayers[i]; │ │ │ │ + layerEntry.layer.setVisibility(layerEntry.inputElem.checked); │ │ │ │ + } │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC.v1_1_0" │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WMC/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Method: maximizeControl │ │ │ │ + * Set up the labels and divs for the control │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * e - {Event} │ │ │ │ + */ │ │ │ │ + maximizeControl: function(e) { │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + // set the div's width and height to empty values, so │ │ │ │ + // the div dimensions can be controlled by CSS │ │ │ │ + this.div.style.width = ""; │ │ │ │ + this.div.style.height = ""; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WMC/v1.js │ │ │ │ - */ │ │ │ │ + this.showControls(false); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WMC.v1_0_0 │ │ │ │ - * Read and write WMC version 1.0.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WMC.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WMC.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WMC.v1, { │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.0.0 │ │ │ │ - */ │ │ │ │ - VERSION: "1.0.0", │ │ │ │ + /** │ │ │ │ + * Method: minimizeControl │ │ │ │ + * Hide all the contents of the control, shrink the size, │ │ │ │ + * add the maximize icon │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * e - {Event} │ │ │ │ + */ │ │ │ │ + minimizeControl: function(e) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/context │ │ │ │ - * http://schemas.opengis.net/context/1.0.0/context.xsd │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.0.0/context.xsd", │ │ │ │ + // to minimize the control we set its div's width │ │ │ │ + // and height to 0px, we cannot just set "display" │ │ │ │ + // to "none" because it would hide the maximize │ │ │ │ + // div │ │ │ │ + this.div.style.width = "0px"; │ │ │ │ + this.div.style.height = "0px"; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WMC.v1_0_0 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.WMC> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.WMC.v1.prototype.initialize.apply( │ │ │ │ - this, [options] │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ + this.showControls(true); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: read_wmc_SRS │ │ │ │ - */ │ │ │ │ - read_wmc_SRS: function(layerContext, node) { │ │ │ │ - var srs = this.getChildValue(node); │ │ │ │ - if (typeof layerContext.projections != "object") { │ │ │ │ - layerContext.projections = {}; │ │ │ │ - } │ │ │ │ - var values = srs.split(/ +/); │ │ │ │ - for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ - layerContext.projections[values[i]] = true; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: write_wmc_Layer │ │ │ │ - * Create a Layer node given a layer context object. This method adds │ │ │ │ - * elements specific to version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} A layer context object.} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Element} A WMC Layer element node. │ │ │ │ - */ │ │ │ │ - write_wmc_Layer: function(context) { │ │ │ │ - var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply( │ │ │ │ - this, [context] │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * Method: showControls │ │ │ │ + * Hide/Show all LayerSwitcher controls depending on whether we are │ │ │ │ + * minimized or not │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * minimize - {Boolean} │ │ │ │ + */ │ │ │ │ + showControls: function(minimize) { │ │ │ │ │ │ │ │ - // optional SRS element(s) │ │ │ │ - if (context.srs) { │ │ │ │ - var projections = []; │ │ │ │ - for (var name in context.srs) { │ │ │ │ - projections.push(name); │ │ │ │ - } │ │ │ │ - node.appendChild(this.createElementDefaultNS("SRS", projections.join(" "))); │ │ │ │ - } │ │ │ │ + this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ + this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ │ │ │ │ - // optional FormatList element │ │ │ │ - node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ + this.layersDiv.style.display = minimize ? "none" : ""; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // optional StyleList element │ │ │ │ - node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ + /** │ │ │ │ + * Method: loadContents │ │ │ │ + * Set up the labels and divs for the control │ │ │ │ + */ │ │ │ │ + loadContents: function() { │ │ │ │ │ │ │ │ - // optional DimensionList element │ │ │ │ - if (context.dimensions) { │ │ │ │ - node.appendChild(this.write_wmc_DimensionList(context)); │ │ │ │ - } │ │ │ │ + // layers list div │ │ │ │ + this.layersDiv = document.createElement("div"); │ │ │ │ + this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ + OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ │ │ │ │ - // OpenLayers specific properties go in an Extension element │ │ │ │ - node.appendChild(this.write_wmc_LayerExtension(context)); │ │ │ │ - }, │ │ │ │ + this.baseLbl = document.createElement("div"); │ │ │ │ + this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC.v1_0_0" │ │ │ │ + this.baseLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WCSCapabilities/v1.js │ │ │ │ - ====================================================================== */ │ │ │ │ + this.dataLbl = document.createElement("div"); │ │ │ │ + this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + this.dataLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WCSCapabilities.js │ │ │ │ - */ │ │ │ │ + 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); │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WCSCapabilities.v1 │ │ │ │ - * Abstract class not to be instantiated directly. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WCSCapabilities.v1 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ + this.div.appendChild(this.layersDiv); │ │ │ │ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - splitSpace: (/\s+/) │ │ │ │ - }, │ │ │ │ + // maximize button div │ │ │ │ + var img = OpenLayers.Util.getImageLocation('layer-switcher-maximize.png'); │ │ │ │ + this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + "OpenLayers_Control_MaximizeDiv", │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + img, │ │ │ │ + "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ + this.maximizeDiv.style.display = "none"; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - */ │ │ │ │ - defaultPrefix: "wcs", │ │ │ │ + this.div.appendChild(this.maximizeDiv); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return a list of coverages. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} List of named coverages. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - var raw = data; │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities; │ │ │ │ - }, │ │ │ │ + // minimize button div │ │ │ │ + var img = OpenLayers.Util.getImageLocation('layer-switcher-minimize.png'); │ │ │ │ + this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + "OpenLayers_Control_MinimizeDiv", │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + img, │ │ │ │ + "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ + this.minimizeDiv.style.display = "none"; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1" │ │ │ │ + this.div.appendChild(this.minimizeDiv); │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/WCSCapabilities/v1_1_0.js │ │ │ │ + OpenLayers/Control/TransformFeature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/WCSCapabilities/v1.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Control/DragFeature.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.WCSCapabilities/v1_1_0 │ │ │ │ - * Read WCS Capabilities version 1.1.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WCSCapabilities.v1> │ │ │ │ + * Class: OpenLayers.Control.TransformFeature │ │ │ │ + * Control to transform features with a standard transformation box. │ │ │ │ + * │ │ │ │ + * Inherits From: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.WCSCapabilities.v1_1_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ +OpenLayers.Control.TransformFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - wcs: "http://www.opengis.net/wcs/1.1", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - ows: "http://www.opengis.net/ows/1.1" │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforesetfeature - Triggered before a feature is set for │ │ │ │ + * tranformation. The feature will not be set if a listener returns │ │ │ │ + * false. Listeners receive a *feature* property, with the feature │ │ │ │ + * that will be set for transformation. Listeners are allowed to │ │ │ │ + * set the control's *scale*, *ratio* and *rotation* properties, │ │ │ │ + * which will set the initial scale, ratio and rotation of the │ │ │ │ + * feature, like the <setFeature> method's initialParams argument. │ │ │ │ + * setfeature - Triggered when a feature is set for tranformation. │ │ │ │ + * Listeners receive a *feature* property, with the feature that │ │ │ │ + * is now set for transformation. │ │ │ │ + * beforetransform - Triggered while dragging, before a feature is │ │ │ │ + * transformed. The feature will not be transformed if a listener │ │ │ │ + * returns false (but the box still will). Listeners receive one or │ │ │ │ + * more of *center*, *scale*, *ratio* and *rotation*. The *center* │ │ │ │ + * property is an <OpenLayers.Geometry.Point> object with the new │ │ │ │ + * center of the transformed feature, the others are Floats with the │ │ │ │ + * scale, ratio or rotation change since the last transformation. │ │ │ │ + * transform - Triggered while dragging, when a feature is transformed. │ │ │ │ + * Listeners receive an event object with one or more of *center*, │ │ │ │ + * scale*, *ratio* and *rotation*. The *center* property is an │ │ │ │ + * <OpenLayers.Geometry.Point> object with the new center of the │ │ │ │ + * transformed feature, the others are Floats with the scale, ratio │ │ │ │ + * or rotation change of the feature since the last transformation. │ │ │ │ + * transformcomplete - Triggered after dragging. Listeners receive │ │ │ │ + * an event object with the transformed *feature*. │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: errorProperty │ │ │ │ - * {String} Which property of the returned object to check for in order to │ │ │ │ - * determine whether or not parsing has failed. In the case that the │ │ │ │ - * errorProperty is undefined on the returned object, the document will be │ │ │ │ - * run through an OGCExceptionReport parser. │ │ │ │ - */ │ │ │ │ - errorProperty: "operationsMetadata", │ │ │ │ + /** │ │ │ │ + * APIProperty: geometryTypes │ │ │ │ + * {Array(String)} To restrict transformation to a limited set of geometry │ │ │ │ + * types, send a list of strings corresponding to the geometry class │ │ │ │ + * names. │ │ │ │ + */ │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WCSCapabilities.v1_1_0 │ │ │ │ - * Create a new parser for WCS capabilities version 1.1.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wcs": OpenLayers.Util.applyDefaults({ │ │ │ │ - // In 1.0.0, this was WCS_Capabilties, in 1.1.0, it's Capabilities │ │ │ │ - "Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Contents": function(node, request) { │ │ │ │ - request.contentMetadata = []; │ │ │ │ - this.readChildNodes(node, request.contentMetadata); │ │ │ │ - }, │ │ │ │ - "CoverageSummary": function(node, contentMetadata) { │ │ │ │ - var coverageSummary = {}; │ │ │ │ - // Read the summary: │ │ │ │ - this.readChildNodes(node, coverageSummary); │ │ │ │ + /** │ │ │ │ + * APIProperty: preserveAspectRatio │ │ │ │ + * {Boolean} set to true to not change the feature's aspect ratio. │ │ │ │ + */ │ │ │ │ + preserveAspectRatio: false, │ │ │ │ │ │ │ │ - // Add it to the contentMetadata array: │ │ │ │ - contentMetadata.push(coverageSummary); │ │ │ │ - }, │ │ │ │ - "Identifier": function(node, coverageSummary) { │ │ │ │ - coverageSummary.identifier = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Title": function(node, coverageSummary) { │ │ │ │ - coverageSummary.title = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "Abstract": function(node, coverageSummary) { │ │ │ │ - coverageSummary["abstract"] = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "SupportedCRS": function(node, coverageSummary) { │ │ │ │ - var crs = this.getChildValue(node); │ │ │ │ - if (crs) { │ │ │ │ - if (!coverageSummary.supportedCRS) { │ │ │ │ - coverageSummary.supportedCRS = []; │ │ │ │ - } │ │ │ │ - coverageSummary.supportedCRS.push(crs); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "SupportedFormat": function(node, coverageSummary) { │ │ │ │ - var format = this.getChildValue(node); │ │ │ │ - if (format) { │ │ │ │ - if (!coverageSummary.supportedFormat) { │ │ │ │ - coverageSummary.supportedFormat = []; │ │ │ │ - } │ │ │ │ - coverageSummary.supportedFormat.push(format); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WCSCapabilities.v1.prototype.readers["wcs"]), │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: rotate │ │ │ │ + * {Boolean} set to false if rotation should be disabled. Default is true. │ │ │ │ + * To be passed with the constructor or set when the control is not │ │ │ │ + * active. │ │ │ │ + */ │ │ │ │ + rotate: true, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_1_0" │ │ │ │ + /** │ │ │ │ + * APIProperty: feature │ │ │ │ + * {<OpenLayers.Feature.Vector>} Feature currently available for │ │ │ │ + * transformation. Read-only, use <setFeature> to set it manually. │ │ │ │ + */ │ │ │ │ + feature: null, │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WCSCapabilities/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * APIProperty: renderIntent │ │ │ │ + * {String|Object} Render intent for the transformation box and │ │ │ │ + * handles. A symbolizer object can also be provided here. │ │ │ │ + */ │ │ │ │ + renderIntent: "temporary", │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: rotationHandleSymbolizer │ │ │ │ + * {Object|String} Optional. A custom symbolizer for the rotation handles. │ │ │ │ + * A render intent can also be provided here. Defaults to │ │ │ │ + * (code) │ │ │ │ + * { │ │ │ │ + * stroke: false, │ │ │ │ + * pointRadius: 10, │ │ │ │ + * fillOpacity: 0, │ │ │ │ + * cursor: "pointer" │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + */ │ │ │ │ + rotationHandleSymbolizer: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WCSCapabilities/v1.js │ │ │ │ - * @requires OpenLayers/Format/GML/v3.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: box │ │ │ │ + * {<OpenLayers.Feature.Vector>} The transformation box rectangle. │ │ │ │ + * Read-only. │ │ │ │ + */ │ │ │ │ + box: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WCSCapabilities/v1_0_0 │ │ │ │ - * Read WCS Capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WCSCapabilities.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WCSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ + /** │ │ │ │ + * APIProperty: center │ │ │ │ + * {<OpenLayers.Geometry.Point>} The center of the feature bounds. │ │ │ │ + * Read-only. │ │ │ │ + */ │ │ │ │ + center: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WCSCapabilities.v1_0_0 │ │ │ │ - * Create a new parser for WCS capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: scale │ │ │ │ + * {Float} The scale of the feature, relative to the scale the time the │ │ │ │ + * feature was set. Read-only, except for *beforesetfeature* │ │ │ │ + * listeners. │ │ │ │ + */ │ │ │ │ + scale: 1, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - wcs: "http://www.opengis.net/wcs", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - ows: "http://www.opengis.net/ows" │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: ratio │ │ │ │ + * {Float} The ratio of the feature relative to the ratio the time the │ │ │ │ + * feature was set. Read-only, except for *beforesetfeature* │ │ │ │ + * listeners. │ │ │ │ + */ │ │ │ │ + ratio: 1, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: errorProperty │ │ │ │ - * {String} Which property of the returned object to check for in order to │ │ │ │ - * determine whether or not parsing has failed. In the case that the │ │ │ │ - * errorProperty is undefined on the returned object, the document will be │ │ │ │ - * run through an OGCExceptionReport parser. │ │ │ │ - */ │ │ │ │ - errorProperty: "service", │ │ │ │ + /** │ │ │ │ + * Property: rotation │ │ │ │ + * {Integer} the current rotation angle of the box. Read-only, except for │ │ │ │ + * *beforesetfeature* listeners. │ │ │ │ + */ │ │ │ │ + rotation: 0, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wcs": { │ │ │ │ - "WCS_Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Service": function(node, obj) { │ │ │ │ - obj.service = {}; │ │ │ │ - this.readChildNodes(node, obj.service); │ │ │ │ - }, │ │ │ │ - "name": function(node, service) { │ │ │ │ - service.name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "label": function(node, service) { │ │ │ │ - service.label = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "keywords": function(node, service) { │ │ │ │ - service.keywords = []; │ │ │ │ - this.readChildNodes(node, service.keywords); │ │ │ │ - }, │ │ │ │ - "keyword": function(node, keywords) { │ │ │ │ - // Append the keyword to the keywords list │ │ │ │ - keywords.push(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "responsibleParty": function(node, service) { │ │ │ │ - service.responsibleParty = {}; │ │ │ │ - this.readChildNodes(node, service.responsibleParty); │ │ │ │ - }, │ │ │ │ - "individualName": function(node, responsibleParty) { │ │ │ │ - responsibleParty.individualName = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "organisationName": function(node, responsibleParty) { │ │ │ │ - responsibleParty.organisationName = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "positionName": function(node, responsibleParty) { │ │ │ │ - responsibleParty.positionName = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "contactInfo": function(node, responsibleParty) { │ │ │ │ - responsibleParty.contactInfo = {}; │ │ │ │ - this.readChildNodes(node, responsibleParty.contactInfo); │ │ │ │ - }, │ │ │ │ - "phone": function(node, contactInfo) { │ │ │ │ - contactInfo.phone = {}; │ │ │ │ - this.readChildNodes(node, contactInfo.phone); │ │ │ │ - }, │ │ │ │ - "voice": function(node, phone) { │ │ │ │ - phone.voice = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "facsimile": function(node, phone) { │ │ │ │ - phone.facsimile = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "address": function(node, contactInfo) { │ │ │ │ - contactInfo.address = {}; │ │ │ │ - this.readChildNodes(node, contactInfo.address); │ │ │ │ - }, │ │ │ │ - "deliveryPoint": function(node, address) { │ │ │ │ - address.deliveryPoint = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "city": function(node, address) { │ │ │ │ - address.city = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "postalCode": function(node, address) { │ │ │ │ - address.postalCode = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "country": function(node, address) { │ │ │ │ - address.country = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "electronicMailAddress": function(node, address) { │ │ │ │ - address.electronicMailAddress = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "fees": function(node, service) { │ │ │ │ - service.fees = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "accessConstraints": function(node, service) { │ │ │ │ - service.accessConstraints = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "ContentMetadata": function(node, obj) { │ │ │ │ - obj.contentMetadata = []; │ │ │ │ - this.readChildNodes(node, obj.contentMetadata); │ │ │ │ - }, │ │ │ │ - "CoverageOfferingBrief": function(node, contentMetadata) { │ │ │ │ - var coverageOfferingBrief = {}; │ │ │ │ - this.readChildNodes(node, coverageOfferingBrief); │ │ │ │ - contentMetadata.push(coverageOfferingBrief); │ │ │ │ - }, │ │ │ │ - "name": function(node, coverageOfferingBrief) { │ │ │ │ - coverageOfferingBrief.name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "label": function(node, coverageOfferingBrief) { │ │ │ │ - coverageOfferingBrief.label = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "lonLatEnvelope": function(node, coverageOfferingBrief) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, "http://www.opengis.net/gml", "pos"); │ │ │ │ + /** │ │ │ │ + * APIProperty: handles │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} The 8 handles currently available │ │ │ │ + * for scaling/resizing. Numbered counterclockwise, starting from the │ │ │ │ + * southwest corner. Read-only. │ │ │ │ + */ │ │ │ │ + handles: null, │ │ │ │ │ │ │ │ - // We expect two nodes here, to create the corners of a bounding box │ │ │ │ - if (nodeList.length == 2) { │ │ │ │ - var min = {}; │ │ │ │ - var max = {}; │ │ │ │ + /** │ │ │ │ + * APIProperty: rotationHandles │ │ │ │ + * {Array(<OpenLayers.Feature.Vector>)} The 4 rotation handles currently │ │ │ │ + * available for rotating. Numbered counterclockwise, starting from │ │ │ │ + * the southwest corner. Read-only. │ │ │ │ + */ │ │ │ │ + rotationHandles: null, │ │ │ │ │ │ │ │ - OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[0], min]); │ │ │ │ - OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[1], max]); │ │ │ │ + /** │ │ │ │ + * Property: dragControl │ │ │ │ + * {<OpenLayers.Control.DragFeature>} │ │ │ │ + */ │ │ │ │ + dragControl: null, │ │ │ │ │ │ │ │ - coverageOfferingBrief.lonLatEnvelope = {}; │ │ │ │ - coverageOfferingBrief.lonLatEnvelope.srsName = node.getAttribute("srsName"); │ │ │ │ - coverageOfferingBrief.lonLatEnvelope.min = min.points[0]; │ │ │ │ - coverageOfferingBrief.lonLatEnvelope.max = max.points[0]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: irregular │ │ │ │ + * {Boolean} Make scaling/resizing work irregularly. If true then │ │ │ │ + * dragging a handle causes the feature to resize in the direction │ │ │ │ + * of movement. If false then the feature resizes symetrically │ │ │ │ + * about it's center. │ │ │ │ + */ │ │ │ │ + irregular: false, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_0_0" │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.TransformFeature │ │ │ │ + * Create a new transform feature control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} Layer that contains features that │ │ │ │ + * will be transformed. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * control. │ │ │ │ + */ │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WFSCapabilities/v1.js │ │ │ │ - ====================================================================== */ │ │ │ │ + this.layer = layer; │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + if (!this.rotationHandleSymbolizer) { │ │ │ │ + this.rotationHandleSymbolizer = { │ │ │ │ + stroke: false, │ │ │ │ + pointRadius: 10, │ │ │ │ + fillOpacity: 0, │ │ │ │ + cursor: "pointer" │ │ │ │ + }; │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WFSCapabilities.js │ │ │ │ - */ │ │ │ │ + this.createBox(); │ │ │ │ + this.createControl(); │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WFSCapabilities.v1 │ │ │ │ - * Abstract class not to be instantiated directly. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WFSCapabilities.v1 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XML, { │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activates the control. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragControl.activate(); │ │ │ │ + this.layer.addFeatures([this.box]); │ │ │ │ + this.rotate && this.layer.addFeatures(this.rotationHandles); │ │ │ │ + this.layer.addFeatures(this.handles); │ │ │ │ + activated = true; │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - wfs: "http://www.opengis.net/wfs", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - ows: "http://www.opengis.net/ows" │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivates the control. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.layer.removeFeatures(this.handles); │ │ │ │ + this.rotate && this.layer.removeFeatures(this.rotationHandles); │ │ │ │ + this.layer.removeFeatures([this.box]); │ │ │ │ + this.dragControl.deactivate(); │ │ │ │ + deactivated = true; │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + this.dragControl.setMap(map); │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: errorProperty │ │ │ │ - * {String} Which property of the returned object to check for in order to │ │ │ │ - * determine whether or not parsing has failed. In the case that the │ │ │ │ - * errorProperty is undefined on the returned object, the document will be │ │ │ │ - * run through an OGCExceptionReport parser. │ │ │ │ - */ │ │ │ │ - errorProperty: "featureTypeList", │ │ │ │ + /** │ │ │ │ + * APIMethod: setFeature │ │ │ │ + * Place the transformation box on a feature and start transforming it. │ │ │ │ + * If the control is not active, it will be activated. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * initialParams - {Object} Initial values for rotation, scale or ratio. │ │ │ │ + * Setting a rotation value here will cause the transformation box to │ │ │ │ + * start rotated. Setting a scale or ratio will not affect the │ │ │ │ + * transormation box, but applications may use this to keep track of │ │ │ │ + * scale and ratio of a feature across multiple transforms. │ │ │ │ + */ │ │ │ │ + setFeature: function(feature, initialParams) { │ │ │ │ + initialParams = OpenLayers.Util.applyDefaults(initialParams, { │ │ │ │ + rotation: 0, │ │ │ │ + scale: 1, │ │ │ │ + ratio: 1 │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - */ │ │ │ │ - defaultPrefix: "wfs", │ │ │ │ + var oldRotation = this.rotation; │ │ │ │ + var oldCenter = this.center; │ │ │ │ + OpenLayers.Util.extend(this, initialParams); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WFSCapabilities.v1_1 │ │ │ │ - * Create an instance of one of the subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + var cont = this.events.triggerEvent("beforesetfeature", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont === false) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return a list of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} List of named layers. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - var raw = data; │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities; │ │ │ │ - }, │ │ │ │ + this.feature = feature; │ │ │ │ + this.activate(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wfs": { │ │ │ │ - "WFS_Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "FeatureTypeList": function(node, request) { │ │ │ │ - request.featureTypeList = { │ │ │ │ - featureTypes: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, request.featureTypeList); │ │ │ │ - }, │ │ │ │ - "FeatureType": function(node, featureTypeList) { │ │ │ │ - var featureType = {}; │ │ │ │ - this.readChildNodes(node, featureType); │ │ │ │ - featureTypeList.featureTypes.push(featureType); │ │ │ │ - }, │ │ │ │ - "Name": function(node, obj) { │ │ │ │ - var name = this.getChildValue(node); │ │ │ │ - if (name) { │ │ │ │ - var parts = name.split(":"); │ │ │ │ - obj.name = parts.pop(); │ │ │ │ - if (parts.length > 0) { │ │ │ │ - obj.featureNS = this.lookupNamespaceURI(node, parts[0]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Title": function(node, obj) { │ │ │ │ - var title = this.getChildValue(node); │ │ │ │ - if (title) { │ │ │ │ - obj.title = title; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Abstract": function(node, obj) { │ │ │ │ - var abst = this.getChildValue(node); │ │ │ │ - if (abst) { │ │ │ │ - obj["abstract"] = abst; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + this._setfeature = true; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1" │ │ │ │ + var featureBounds = this.feature.geometry.getBounds(); │ │ │ │ + this.box.move(featureBounds.getCenterLonLat()); │ │ │ │ + this.box.geometry.rotate(-oldRotation, oldCenter); │ │ │ │ + this._angle = 0; │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WFSCapabilities/v1_1_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + var ll; │ │ │ │ + if (this.rotation) { │ │ │ │ + var geom = feature.geometry.clone(); │ │ │ │ + geom.rotate(-this.rotation, this.center); │ │ │ │ + var box = new OpenLayers.Feature.Vector( │ │ │ │ + geom.getBounds().toGeometry()); │ │ │ │ + box.geometry.rotate(this.rotation, this.center); │ │ │ │ + this.box.geometry.rotate(this.rotation, this.center); │ │ │ │ + this.box.move(box.geometry.getBounds().getCenterLonLat()); │ │ │ │ + var llGeom = box.geometry.components[0].components[0]; │ │ │ │ + ll = llGeom.getBounds().getCenterLonLat(); │ │ │ │ + } else { │ │ │ │ + ll = new OpenLayers.LonLat(featureBounds.left, featureBounds.bottom); │ │ │ │ + } │ │ │ │ + this.handles[0].move(ll); │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + delete this._setfeature; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WFSCapabilities/v1.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1.js │ │ │ │ - */ │ │ │ │ + this.events.triggerEvent("setfeature", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WFSCapabilities/v1_1_0 │ │ │ │ - * Read WFS Capabilities version 1.1.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WFSCapabilities> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WFSCapabilities.v1_1_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ + /** │ │ │ │ + * APIMethod: unsetFeature │ │ │ │ + * Remove the transformation box off any feature. │ │ │ │ + * If the control is active, it will be deactivated first. │ │ │ │ + */ │ │ │ │ + unsetFeature: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + } else { │ │ │ │ + this.feature = null; │ │ │ │ + this.rotation = 0; │ │ │ │ + this.scale = 1; │ │ │ │ + this.ratio = 1; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: createBox │ │ │ │ + * Creates the box with all handles and transformation handles. │ │ │ │ + */ │ │ │ │ + createBox: function() { │ │ │ │ + var control = this; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WFSCapabilities.v1_1_0 │ │ │ │ - * Create a new parser for WFS capabilities version 1.1.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + this.center = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ + this.box = new OpenLayers.Feature.Vector( │ │ │ │ + new OpenLayers.Geometry.LineString([ │ │ │ │ + new OpenLayers.Geometry.Point(-1, -1), │ │ │ │ + new OpenLayers.Geometry.Point(0, -1), │ │ │ │ + new OpenLayers.Geometry.Point(1, -1), │ │ │ │ + new OpenLayers.Geometry.Point(1, 0), │ │ │ │ + new OpenLayers.Geometry.Point(1, 1), │ │ │ │ + new OpenLayers.Geometry.Point(0, 1), │ │ │ │ + new OpenLayers.Geometry.Point(-1, 1), │ │ │ │ + new OpenLayers.Geometry.Point(-1, 0), │ │ │ │ + new OpenLayers.Geometry.Point(-1, -1) │ │ │ │ + ]), null, │ │ │ │ + typeof this.renderIntent == "string" ? null : this.renderIntent │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ - "DefaultSRS": function(node, obj) { │ │ │ │ - var defaultSRS = this.getChildValue(node); │ │ │ │ - if (defaultSRS) { │ │ │ │ - obj.srs = defaultSRS; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]), │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1.prototype.readers.ows │ │ │ │ - }, │ │ │ │ + // Override for box move - make sure that the center gets updated │ │ │ │ + this.box.geometry.move = function(x, y) { │ │ │ │ + control._moving = true; │ │ │ │ + OpenLayers.Geometry.LineString.prototype.move.apply(this, arguments); │ │ │ │ + control.center.move(x, y); │ │ │ │ + delete control._moving; │ │ │ │ + }; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_1_0" │ │ │ │ + // Overrides for vertex move, resize and rotate - make sure that │ │ │ │ + // handle and rotationHandle geometries are also moved, resized and │ │ │ │ + // rotated. │ │ │ │ + var vertexMoveFn = function(x, y) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.apply(this, arguments); │ │ │ │ + this._rotationHandle && this._rotationHandle.geometry.move(x, y); │ │ │ │ + this._handle.geometry.move(x, y); │ │ │ │ + }; │ │ │ │ + var vertexResizeFn = function(scale, center, ratio) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.resize.apply(this, arguments); │ │ │ │ + this._rotationHandle && this._rotationHandle.geometry.resize( │ │ │ │ + scale, center, ratio); │ │ │ │ + this._handle.geometry.resize(scale, center, ratio); │ │ │ │ + }; │ │ │ │ + var vertexRotateFn = function(angle, center) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.rotate.apply(this, arguments); │ │ │ │ + this._rotationHandle && this._rotationHandle.geometry.rotate( │ │ │ │ + angle, center); │ │ │ │ + this._handle.geometry.rotate(angle, center); │ │ │ │ + }; │ │ │ │ │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/WFSCapabilities/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + // Override for handle move - make sure that the box and other handles │ │ │ │ + // are updated, and finally transform the feature. │ │ │ │ + var handleMoveFn = function(x, y) { │ │ │ │ + var oldX = this.x, │ │ │ │ + oldY = this.y; │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + if (control._moving) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var evt = control.dragControl.handlers.drag.evt; │ │ │ │ + var preserveAspectRatio = !control._setfeature && │ │ │ │ + control.preserveAspectRatio; │ │ │ │ + var reshape = !preserveAspectRatio && !(evt && evt.shiftKey); │ │ │ │ + var oldGeom = new OpenLayers.Geometry.Point(oldX, oldY); │ │ │ │ + var centerGeometry = control.center; │ │ │ │ + this.rotate(-control.rotation, centerGeometry); │ │ │ │ + oldGeom.rotate(-control.rotation, centerGeometry); │ │ │ │ + var dx1 = this.x - centerGeometry.x; │ │ │ │ + var dy1 = this.y - centerGeometry.y; │ │ │ │ + var dx0 = dx1 - (this.x - oldGeom.x); │ │ │ │ + var dy0 = dy1 - (this.y - oldGeom.y); │ │ │ │ + if (control.irregular && !control._setfeature) { │ │ │ │ + dx1 -= (this.x - oldGeom.x) / 2; │ │ │ │ + dy1 -= (this.y - oldGeom.y) / 2; │ │ │ │ + } │ │ │ │ + this.x = oldX; │ │ │ │ + this.y = oldY; │ │ │ │ + var scale, ratio = 1; │ │ │ │ + if (reshape) { │ │ │ │ + scale = Math.abs(dy0) < 0.00001 ? 1 : dy1 / dy0; │ │ │ │ + ratio = (Math.abs(dx0) < 0.00001 ? 1 : (dx1 / dx0)) / scale; │ │ │ │ + } else { │ │ │ │ + var l0 = Math.sqrt((dx0 * dx0) + (dy0 * dy0)); │ │ │ │ + var l1 = Math.sqrt((dx1 * dx1) + (dy1 * dy1)); │ │ │ │ + scale = l1 / l0; │ │ │ │ + } │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + // rotate the box to 0 before resizing - saves us some │ │ │ │ + // calculations and is inexpensive because we don't drawFeature. │ │ │ │ + control._moving = true; │ │ │ │ + control.box.geometry.rotate(-control.rotation, centerGeometry); │ │ │ │ + delete control._moving; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Format/WFSCapabilities/v1.js │ │ │ │ - */ │ │ │ │ + control.box.geometry.resize(scale, centerGeometry, ratio); │ │ │ │ + control.box.geometry.rotate(control.rotation, centerGeometry); │ │ │ │ + control.transformFeature({ │ │ │ │ + scale: scale, │ │ │ │ + ratio: ratio │ │ │ │ + }); │ │ │ │ + if (control.irregular && !control._setfeature) { │ │ │ │ + var newCenter = centerGeometry.clone(); │ │ │ │ + newCenter.x += Math.abs(oldX - centerGeometry.x) < 0.00001 ? 0 : (this.x - oldX); │ │ │ │ + newCenter.y += Math.abs(oldY - centerGeometry.y) < 0.00001 ? 0 : (this.y - oldY); │ │ │ │ + control.box.geometry.move(this.x - oldX, this.y - oldY); │ │ │ │ + control.transformFeature({ │ │ │ │ + center: newCenter │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Format.WFSCapabilities/v1_0_0 │ │ │ │ - * Read WFS Capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.WFSCapabilities.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Format.WFSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ + // Override for rotation handle move - make sure that the box and │ │ │ │ + // other handles are updated, and finally transform the feature. │ │ │ │ + var rotationHandleMoveFn = function(x, y) { │ │ │ │ + var oldX = this.x, │ │ │ │ + oldY = this.y; │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + if (control._moving) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var evt = control.dragControl.handlers.drag.evt; │ │ │ │ + var constrain = (evt && evt.shiftKey) ? 45 : 1; │ │ │ │ + var centerGeometry = control.center; │ │ │ │ + var dx1 = this.x - centerGeometry.x; │ │ │ │ + var dy1 = this.y - centerGeometry.y; │ │ │ │ + var dx0 = dx1 - x; │ │ │ │ + var dy0 = dy1 - y; │ │ │ │ + this.x = oldX; │ │ │ │ + this.y = oldY; │ │ │ │ + var a0 = Math.atan2(dy0, dx0); │ │ │ │ + var a1 = Math.atan2(dy1, dx1); │ │ │ │ + var angle = a1 - a0; │ │ │ │ + angle *= 180 / Math.PI; │ │ │ │ + control._angle = (control._angle + angle) % 360; │ │ │ │ + var diff = control.rotation % constrain; │ │ │ │ + if (Math.abs(control._angle) >= constrain || diff !== 0) { │ │ │ │ + angle = Math.round(control._angle / constrain) * constrain - │ │ │ │ + diff; │ │ │ │ + control._angle = 0; │ │ │ │ + control.box.geometry.rotate(angle, centerGeometry); │ │ │ │ + control.transformFeature({ │ │ │ │ + rotation: angle │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.WFSCapabilities.v1_0_0 │ │ │ │ - * Create a new parser for WFS capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + var handles = new Array(8); │ │ │ │ + var rotationHandles = new Array(4); │ │ │ │ + var geom, handle, rotationHandle; │ │ │ │ + var positions = ["sw", "s", "se", "e", "ne", "n", "nw", "w"]; │ │ │ │ + for (var i = 0; i < 8; ++i) { │ │ │ │ + geom = this.box.geometry.components[i]; │ │ │ │ + handle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ + role: positions[i] + "-resize" │ │ │ │ + }, typeof this.renderIntent == "string" ? null : │ │ │ │ + this.renderIntent); │ │ │ │ + if (i % 2 == 0) { │ │ │ │ + rotationHandle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ + role: positions[i] + "-rotate" │ │ │ │ + }, typeof this.rotationHandleSymbolizer == "string" ? │ │ │ │ + null : this.rotationHandleSymbolizer); │ │ │ │ + rotationHandle.geometry.move = rotationHandleMoveFn; │ │ │ │ + geom._rotationHandle = rotationHandle; │ │ │ │ + rotationHandles[i / 2] = rotationHandle; │ │ │ │ + } │ │ │ │ + geom.move = vertexMoveFn; │ │ │ │ + geom.resize = vertexResizeFn; │ │ │ │ + geom.rotate = vertexRotateFn; │ │ │ │ + handle.geometry.move = handleMoveFn; │ │ │ │ + geom._handle = handle; │ │ │ │ + handles[i] = handle; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "wfs": OpenLayers.Util.applyDefaults({ │ │ │ │ - "Service": function(node, capabilities) { │ │ │ │ - capabilities.service = {}; │ │ │ │ - this.readChildNodes(node, capabilities.service); │ │ │ │ - }, │ │ │ │ - "Fees": function(node, service) { │ │ │ │ - var fees = this.getChildValue(node); │ │ │ │ - if (fees && fees.toLowerCase() != "none") { │ │ │ │ - service.fees = fees; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "AccessConstraints": function(node, service) { │ │ │ │ - var constraints = this.getChildValue(node); │ │ │ │ - if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ - service.accessConstraints = constraints; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "OnlineResource": function(node, service) { │ │ │ │ - var onlineResource = this.getChildValue(node); │ │ │ │ - if (onlineResource && onlineResource.toLowerCase() != "none") { │ │ │ │ - service.onlineResource = onlineResource; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Keywords": function(node, service) { │ │ │ │ - var keywords = this.getChildValue(node); │ │ │ │ - if (keywords && keywords.toLowerCase() != "none") { │ │ │ │ - service.keywords = keywords.split(', '); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Capability": function(node, capabilities) { │ │ │ │ - capabilities.capability = {}; │ │ │ │ - this.readChildNodes(node, capabilities.capability); │ │ │ │ - }, │ │ │ │ - "Request": function(node, obj) { │ │ │ │ - obj.request = {}; │ │ │ │ - this.readChildNodes(node, obj.request); │ │ │ │ - }, │ │ │ │ - "GetFeature": function(node, request) { │ │ │ │ - request.getfeature = { │ │ │ │ - href: {}, // DCPType │ │ │ │ - formats: [] // ResultFormat │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, request.getfeature); │ │ │ │ - }, │ │ │ │ - "ResultFormat": function(node, obj) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var childNode; │ │ │ │ - for (var i = 0; i < children.length; i++) { │ │ │ │ - childNode = children[i]; │ │ │ │ - if (childNode.nodeType == 1) { │ │ │ │ - obj.formats.push(childNode.nodeName); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "DCPType": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "HTTP": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj.href); │ │ │ │ - }, │ │ │ │ - "Get": function(node, obj) { │ │ │ │ - obj.get = node.getAttribute("onlineResource"); │ │ │ │ - }, │ │ │ │ - "Post": function(node, obj) { │ │ │ │ - obj.post = node.getAttribute("onlineResource"); │ │ │ │ - }, │ │ │ │ - "SRS": function(node, obj) { │ │ │ │ - var srs = this.getChildValue(node); │ │ │ │ - if (srs) { │ │ │ │ - obj.srs = srs; │ │ │ │ - } │ │ │ │ + this.rotationHandles = rotationHandles; │ │ │ │ + this.handles = handles; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createControl │ │ │ │ + * Creates a DragFeature control for this control. │ │ │ │ + */ │ │ │ │ + createControl: function() { │ │ │ │ + var control = this; │ │ │ │ + this.dragControl = new OpenLayers.Control.DragFeature(this.layer, { │ │ │ │ + documentDrag: true, │ │ │ │ + // avoid moving the feature itself - move the box instead │ │ │ │ + moveFeature: function(pixel) { │ │ │ │ + if (this.feature === control.feature) { │ │ │ │ + this.feature = control.box; │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]) │ │ │ │ - }, │ │ │ │ + OpenLayers.Control.DragFeature.prototype.moveFeature.apply(this, │ │ │ │ + arguments); │ │ │ │ + }, │ │ │ │ + // transform while dragging │ │ │ │ + onDrag: function(feature, pixel) { │ │ │ │ + if (feature === control.box) { │ │ │ │ + control.transformFeature({ │ │ │ │ + center: control.center │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + // set a new feature │ │ │ │ + onStart: function(feature, pixel) { │ │ │ │ + var eligible = !control.geometryTypes || │ │ │ │ + OpenLayers.Util.indexOf(control.geometryTypes, │ │ │ │ + feature.geometry.CLASS_NAME) !== -1; │ │ │ │ + var i = OpenLayers.Util.indexOf(control.handles, feature); │ │ │ │ + i += OpenLayers.Util.indexOf(control.rotationHandles, │ │ │ │ + feature); │ │ │ │ + if (feature !== control.feature && feature !== control.box && │ │ │ │ + i == -2 && eligible) { │ │ │ │ + control.setFeature(feature); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + onComplete: function(feature, pixel) { │ │ │ │ + control.events.triggerEvent("transformcomplete", { │ │ │ │ + feature: control.feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_0_0" │ │ │ │ + /** │ │ │ │ + * Method: drawHandles │ │ │ │ + * Draws the handles to match the box. │ │ │ │ + */ │ │ │ │ + drawHandles: function() { │ │ │ │ + var layer = this.layer; │ │ │ │ + for (var i = 0; i < 8; ++i) { │ │ │ │ + if (this.rotate && i % 2 === 0) { │ │ │ │ + layer.drawFeature(this.rotationHandles[i / 2], │ │ │ │ + this.rotationHandleSymbolizer); │ │ │ │ + } │ │ │ │ + layer.drawFeature(this.handles[i], this.renderIntent); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: transformFeature │ │ │ │ + * Transforms the feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * mods - {Object} An object with optional scale, ratio, rotation and │ │ │ │ + * center properties. │ │ │ │ + */ │ │ │ │ + transformFeature: function(mods) { │ │ │ │ + if (!this._setfeature) { │ │ │ │ + this.scale *= (mods.scale || 1); │ │ │ │ + this.ratio *= (mods.ratio || 1); │ │ │ │ + var oldRotation = this.rotation; │ │ │ │ + this.rotation = (this.rotation + (mods.rotation || 0)) % 360; │ │ │ │ + │ │ │ │ + if (this.events.triggerEvent("beforetransform", mods) !== false) { │ │ │ │ + var feature = this.feature; │ │ │ │ + var geom = feature.geometry; │ │ │ │ + var center = this.center; │ │ │ │ + geom.rotate(-oldRotation, center); │ │ │ │ + if (mods.scale || mods.ratio) { │ │ │ │ + geom.resize(mods.scale, center, mods.ratio); │ │ │ │ + } else if (mods.center) { │ │ │ │ + feature.move(mods.center.getBounds().getCenterLonLat()); │ │ │ │ + } │ │ │ │ + geom.rotate(this.rotation, center); │ │ │ │ + this.layer.drawFeature(feature); │ │ │ │ + feature.toState(OpenLayers.State.UPDATE); │ │ │ │ + this.events.triggerEvent("transform", mods); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.drawFeature(this.box, this.renderIntent); │ │ │ │ + this.drawHandles(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Take care of things that are not handled in superclass. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0; i < 8; ++i) { │ │ │ │ + geom = this.box.geometry.components[i]; │ │ │ │ + geom._handle.destroy(); │ │ │ │ + geom._handle = null; │ │ │ │ + geom._rotationHandle && geom._rotationHandle.destroy(); │ │ │ │ + geom._rotationHandle = null; │ │ │ │ + } │ │ │ │ + this.center = null; │ │ │ │ + this.feature = null; │ │ │ │ + this.handles = null; │ │ │ │ + this.rotationHandleSymbolizer = null; │ │ │ │ + this.rotationHandles = null; │ │ │ │ + this.box.destroy(); │ │ │ │ + this.box = null; │ │ │ │ + this.layer = null; │ │ │ │ + this.dragControl.destroy(); │ │ │ │ + this.dragControl = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.TransformFeature" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/SOSCapabilities/v1_0_0.js │ │ │ │ + OpenLayers/Control/PanPanel.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/SOSCapabilities.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_1_0.js │ │ │ │ - * @requires OpenLayers/Format/GML/v3.js │ │ │ │ + * @requires OpenLayers/Control/Panel.js │ │ │ │ + * @requires OpenLayers/Control/Pan.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.SOSCapabilities.v1_0_0 │ │ │ │ - * Read SOS Capabilities version 1.0.0. │ │ │ │ + * Class: OpenLayers.Control.PanPanel │ │ │ │ + * The PanPanel is visible control for panning the map North, South, East or │ │ │ │ + * West in small steps. By default it is drawn in the top left corner of the │ │ │ │ + * map. │ │ │ │ + * │ │ │ │ + * Note: │ │ │ │ + * If you wish to use this class with the default images and you want │ │ │ │ + * it to look nice in ie6, you should add the following, conditionally │ │ │ │ + * added css stylesheet to your HTML file: │ │ │ │ * │ │ │ │ + * (code) │ │ │ │ + * <!--[if lte IE 6]> │ │ │ │ + * <link rel="stylesheet" href="../theme/default/ie6-style.css" type="text/css" /> │ │ │ │ + * <![endif]--> │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.SOSCapabilities> │ │ │ │ + * - <OpenLayers.Control.Panel> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.SOSCapabilities.v1_0_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.SOSCapabilities, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - sos: "http://www.opengis.net/sos/1.0", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.SOSCapabilities.v1_0_0 │ │ │ │ - * Create a new parser for SOS capabilities version 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options; │ │ │ │ - }, │ │ │ │ +OpenLayers.Control.PanPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read capabilities data from a string, and return info about the SOS. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} Information about the SOS service. │ │ │ │ - */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ - } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: slideFactor │ │ │ │ + * {Integer} Number of pixels by which we'll pan the map in any direction │ │ │ │ + * on clicking the arrow buttons, defaults to 50. If you want to pan │ │ │ │ + * by some ratio of the map dimensions, use <slideRatio> instead. │ │ │ │ + */ │ │ │ │ + slideFactor: 50, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ - "name": function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "TimePeriod": function(node, obj) { │ │ │ │ - obj.timePeriod = {}; │ │ │ │ - this.readChildNodes(node, obj.timePeriod); │ │ │ │ - }, │ │ │ │ - "beginPosition": function(node, timePeriod) { │ │ │ │ - timePeriod.beginPosition = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "endPosition": function(node, timePeriod) { │ │ │ │ - timePeriod.endPosition = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.v3.prototype.readers["gml"]), │ │ │ │ - "sos": { │ │ │ │ - "Capabilities": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Contents": function(node, obj) { │ │ │ │ - obj.contents = {}; │ │ │ │ - this.readChildNodes(node, obj.contents); │ │ │ │ - }, │ │ │ │ - "ObservationOfferingList": function(node, contents) { │ │ │ │ - contents.offeringList = {}; │ │ │ │ - this.readChildNodes(node, contents.offeringList); │ │ │ │ - }, │ │ │ │ - "ObservationOffering": function(node, offeringList) { │ │ │ │ - var id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ - offeringList[id] = { │ │ │ │ - procedures: [], │ │ │ │ - observedProperties: [], │ │ │ │ - featureOfInterestIds: [], │ │ │ │ - responseFormats: [], │ │ │ │ - resultModels: [], │ │ │ │ - responseModes: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, offeringList[id]); │ │ │ │ - }, │ │ │ │ - "time": function(node, offering) { │ │ │ │ - offering.time = {}; │ │ │ │ - this.readChildNodes(node, offering.time); │ │ │ │ - }, │ │ │ │ - "procedure": function(node, offering) { │ │ │ │ - offering.procedures.push(this.getAttributeNS(node, │ │ │ │ - this.namespaces.xlink, "href")); │ │ │ │ - }, │ │ │ │ - "observedProperty": function(node, offering) { │ │ │ │ - offering.observedProperties.push(this.getAttributeNS(node, │ │ │ │ - this.namespaces.xlink, "href")); │ │ │ │ - }, │ │ │ │ - "featureOfInterest": function(node, offering) { │ │ │ │ - offering.featureOfInterestIds.push(this.getAttributeNS(node, │ │ │ │ - this.namespaces.xlink, "href")); │ │ │ │ - }, │ │ │ │ - "responseFormat": function(node, offering) { │ │ │ │ - offering.responseFormats.push(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "resultModel": function(node, offering) { │ │ │ │ - offering.resultModels.push(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "responseMode": function(node, offering) { │ │ │ │ - offering.responseModes.push(this.getChildValue(node)); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: slideRatio │ │ │ │ + * {Number} The fraction of map width/height by which we'll pan the map │ │ │ │ + * on clicking the arrow buttons. Default is null. If set, will │ │ │ │ + * override <slideFactor>. E.g. if slideRatio is .5, then Pan Up will │ │ │ │ + * pan up half the map height. │ │ │ │ + */ │ │ │ │ + slideRatio: null, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSCapabilities.v1_0_0" │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.PanPanel │ │ │ │ + * Add the four directional pan buttons. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + var options = { │ │ │ │ + slideFactor: this.slideFactor, │ │ │ │ + slideRatio: this.slideRatio │ │ │ │ + }; │ │ │ │ + this.addControls([ │ │ │ │ + new OpenLayers.Control.Pan(OpenLayers.Control.Pan.NORTH, options), │ │ │ │ + new OpenLayers.Control.Pan(OpenLayers.Control.Pan.SOUTH, options), │ │ │ │ + new OpenLayers.Control.Pan(OpenLayers.Control.Pan.EAST, options), │ │ │ │ + new OpenLayers.Control.Pan(OpenLayers.Control.Pan.WEST, options) │ │ │ │ + ]); │ │ │ │ + }, │ │ │ │ │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.PanPanel" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/OWSContext/v0_3_1.js │ │ │ │ + OpenLayers/Control/MousePosition.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XML.js │ │ │ │ - * @requires OpenLayers/Format/KML.js │ │ │ │ - * @requires OpenLayers/Format/GML.js │ │ │ │ - * @requires OpenLayers/Format/GML/v2.js │ │ │ │ - * @requires OpenLayers/Format/SLD/v1_0_0.js │ │ │ │ - * @requires OpenLayers/Format/OWSContext.js │ │ │ │ - * @requires OpenLayers/Format/OWSCommon/v1_0_0.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.OWSContext.v0_3_1 │ │ │ │ - * Read and write OWSContext version 0.3.1. │ │ │ │ + * Class: OpenLayers.Control.MousePosition │ │ │ │ + * The MousePosition control displays geographic coordinates of the mouse │ │ │ │ + * pointer, as it is moved about the map. │ │ │ │ + * │ │ │ │ + * You can use the <prefix>- or <suffix>-properties to provide more information │ │ │ │ + * about the displayed coordinates to the user: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * var mousePositionCtrl = new OpenLayers.Control.MousePosition({ │ │ │ │ + * prefix: '<a target="_blank" ' + │ │ │ │ + * 'href="http://spatialreference.org/ref/epsg/4326/">' + │ │ │ │ + * 'EPSG:4326</a> coordinates: ' │ │ │ │ + * } │ │ │ │ + * ); │ │ │ │ + * (end code) │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.OWSContext.v0_3_1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ +OpenLayers.Control.MousePosition = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - namespaces: { │ │ │ │ - owc: "http://www.opengis.net/ows-context", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - kml: "http://www.opengis.net/kml/2.2", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - ows: "http://www.opengis.net/ows", │ │ │ │ - sld: "http://www.opengis.net/sld", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 0.3.1 │ │ │ │ + * Property: element │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - VERSION: "0.3.1", │ │ │ │ + element: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location │ │ │ │ + * APIProperty: prefix │ │ │ │ + * {String} A string to be prepended to the current pointers coordinates │ │ │ │ + * when it is rendered. Defaults to the empty string ''. │ │ │ │ */ │ │ │ │ - schemaLocation: "http://www.opengis.net/ows-context http://www.ogcnetwork.net/schemas/owc/0.3.1/owsContext.xsd", │ │ │ │ + prefix: '', │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ - * {String} Default namespace prefix to use. │ │ │ │ + * APIProperty: separator │ │ │ │ + * {String} A string to be used to seperate the two coordinates from each │ │ │ │ + * other. Defaults to the string ', ', which will result in a │ │ │ │ + * rendered coordinate of e.g. '42.12, 21.22'. │ │ │ │ */ │ │ │ │ - defaultPrefix: "owc", │ │ │ │ + separator: ', ', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: extractAttributes │ │ │ │ - * {Boolean} Extract attributes from GML. Default is true. │ │ │ │ + * APIProperty: suffix │ │ │ │ + * {String} A string to be appended to the current pointers coordinates │ │ │ │ + * when it is rendered. Defaults to the empty string ''. │ │ │ │ */ │ │ │ │ - extractAttributes: true, │ │ │ │ + suffix: '', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: xy │ │ │ │ - * {Boolean} Order of the GML coordinate true:(x,y) or false:(y,x) │ │ │ │ - * Changing is not recommended, a new Format should be instantiated. │ │ │ │ + * APIProperty: numDigits │ │ │ │ + * {Integer} The number of digits each coordinate shall have when being │ │ │ │ + * rendered, Defaults to 5. │ │ │ │ */ │ │ │ │ - xy: true, │ │ │ │ + numDigits: 5, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ + * APIProperty: granularity │ │ │ │ + * {Integer} │ │ │ │ */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ + granularity: 10, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: featureNS │ │ │ │ - * {String} The namespace uri to use for writing InlineGeometry │ │ │ │ + * APIProperty: emptyString │ │ │ │ + * {String} Set this to some value to set when the mouse is outside the │ │ │ │ + * map. │ │ │ │ */ │ │ │ │ - featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ + emptyString: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: featureType │ │ │ │ - * {String} The name to use as the feature type when writing out │ │ │ │ - * InlineGeometry │ │ │ │ + * Property: lastXy │ │ │ │ + * {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - featureType: 'vector', │ │ │ │ + lastXy: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: geometryName │ │ │ │ - * {String} The name to use for the geometry attribute when writing out │ │ │ │ - * InlineGeometry │ │ │ │ + * APIProperty: displayProjection │ │ │ │ + * {<OpenLayers.Projection>} The projection in which the mouse position is │ │ │ │ + * displayed. │ │ │ │ */ │ │ │ │ - geometryName: 'geometry', │ │ │ │ + displayProjection: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: nestingLayerLookup │ │ │ │ - * {Object} Hashtable lookup for nesting layer nodes. Used while writing │ │ │ │ - * the OWS context document. It is necessary to keep track of the │ │ │ │ - * nestingPaths for which nesting layer nodes have already been │ │ │ │ - * created, so (nesting) layer nodes are added to those nodes. │ │ │ │ - * │ │ │ │ - * For example: │ │ │ │ - * │ │ │ │ - * If there are three layers with nestingPaths: │ │ │ │ - * layer1.metadata.nestingPath = "a/b/" │ │ │ │ - * layer2.metadata.nestingPath = "a/b/" │ │ │ │ - * layer2.metadata.nestingPath = "a/c" │ │ │ │ + * Constructor: OpenLayers.Control.MousePosition │ │ │ │ * │ │ │ │ - * then a nesting layer node "a" should be created once and added │ │ │ │ - * to the resource list, a nesting layer node "b" should be created │ │ │ │ - * once and added under "a", and a nesting layer node "c" should be │ │ │ │ - * created and added under "a". The lookup paths for these nodes │ │ │ │ - * will be "a", "a/b", and "a/c" respectively. │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Options for control. │ │ │ │ */ │ │ │ │ - nestingLayerLookup: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.OWSContext.v0_3_1 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.OWSContext> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - OpenLayers.Format.GML.v2.prototype.setGeometryTypes.call(this); │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setNestingPath │ │ │ │ - * Set the nestingPath property of the layer depending on the position │ │ │ │ - * of the layer in hierarchy of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * l - {Object} An object that may have a layersContext array property. │ │ │ │ - * │ │ │ │ + * APIMethod: activate │ │ │ │ */ │ │ │ │ - setNestingPath: function(l) { │ │ │ │ - if (l.layersContext) { │ │ │ │ - for (var i = 0, len = l.layersContext.length; i < len; i++) { │ │ │ │ - var layerContext = l.layersContext[i]; │ │ │ │ - var nPath = []; │ │ │ │ - var nTitle = l.title || ""; │ │ │ │ - if (l.metadata && l.metadata.nestingPath) { │ │ │ │ - nPath = l.metadata.nestingPath.slice(); │ │ │ │ - } │ │ │ │ - if (nTitle != "") { │ │ │ │ - nPath.push(nTitle); │ │ │ │ - } │ │ │ │ - layerContext.metadata.nestingPath = nPath; │ │ │ │ - if (layerContext.layersContext) { │ │ │ │ - this.setNestingPath(layerContext); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.map.events.register('mousemove', this, this.redraw); │ │ │ │ + this.map.events.register('mouseout', this, this.reset); │ │ │ │ + this.redraw(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Function: decomposeNestingPath │ │ │ │ - * Takes a nestingPath like "a/b/c" and decomposes it into subpaths: │ │ │ │ - * "a", "a/b", "a/b/c" │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nPath - {Array} the nesting path │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * Array({String}) Array with subpaths, or empty array if there is nothing │ │ │ │ - * to decompose │ │ │ │ + * APIMethod: deactivate │ │ │ │ */ │ │ │ │ - decomposeNestingPath: function(nPath) { │ │ │ │ - var a = []; │ │ │ │ - if (OpenLayers.Util.isArray(nPath)) { │ │ │ │ - var path = nPath.slice(); │ │ │ │ - while (path.length > 0) { │ │ │ │ - a.push(path.slice()); │ │ │ │ - path.pop(); │ │ │ │ - } │ │ │ │ - a.reverse(); │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.map.events.unregister('mousemove', this, this.redraw); │ │ │ │ + this.map.events.unregister('mouseout', this, this.reset); │ │ │ │ + this.element.innerHTML = ""; │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - return a; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Read OWS context data from a string or DOMElement, and return a list │ │ │ │ - * of layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {String} or {DOMElement} data to read/parse. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The context object with a flat layer list as a property named │ │ │ │ - * layersContext. │ │ │ │ + * Method: draw │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement; │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (!this.element) { │ │ │ │ + this.div.left = ""; │ │ │ │ + this.div.top = ""; │ │ │ │ + this.element = this.div; │ │ │ │ } │ │ │ │ - var context = {}; │ │ │ │ - this.readNode(data, context); │ │ │ │ - // since an OWSContext can be nested we need to go through this │ │ │ │ - // structure recursively │ │ │ │ - this.setNestingPath({ │ │ │ │ - layersContext: context.layersContext │ │ │ │ - }); │ │ │ │ - // after nesting path has been set, create a flat list of layers │ │ │ │ - var layers = []; │ │ │ │ - this.processLayer(layers, context); │ │ │ │ - delete context.layersContext; │ │ │ │ - context.layersContext = layers; │ │ │ │ - return context; │ │ │ │ + │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: processLayer │ │ │ │ - * Recursive function to get back a flat list of layers from the hierarchic │ │ │ │ - * layer structure. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layerArray - {Array({Object})} Array of layerContext objects │ │ │ │ - * layer - {Object} layerContext object │ │ │ │ + * Method: redraw │ │ │ │ */ │ │ │ │ - processLayer: function(layerArray, layer) { │ │ │ │ - if (layer.layersContext) { │ │ │ │ - for (var i = 0, len = layer.layersContext.length; i < len; i++) { │ │ │ │ - var l = layer.layersContext[i]; │ │ │ │ - layerArray.push(l); │ │ │ │ - if (l.layersContext) { │ │ │ │ - this.processLayer(layerArray, l); │ │ │ │ - } │ │ │ │ + redraw: function(evt) { │ │ │ │ + │ │ │ │ + var lonLat; │ │ │ │ + │ │ │ │ + if (evt == null) { │ │ │ │ + this.reset(); │ │ │ │ + return; │ │ │ │ + } 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; │ │ │ │ + │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: write │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} An object representing the map context. │ │ │ │ - * options - {Object} Optional object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} An OWS Context document string. │ │ │ │ - */ │ │ │ │ - write: function(context, options) { │ │ │ │ - var name = "OWSContext"; │ │ │ │ - this.nestingLayerLookup = {}; //start with empty lookup │ │ │ │ - options = options || {}; │ │ │ │ - OpenLayers.Util.applyDefaults(options, context); │ │ │ │ - var root = this.writeNode(name, options); │ │ │ │ - this.nestingLayerLookup = null; //clear lookup │ │ │ │ - this.setAttributeNS( │ │ │ │ - root, this.namespaces["xsi"], │ │ │ │ - "xsi:schemaLocation", this.schemaLocation │ │ │ │ - ); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [root]); │ │ │ │ + var newHtml = this.formatOutput(lonLat); │ │ │ │ + │ │ │ │ + if (newHtml != this.element.innerHTML) { │ │ │ │ + this.element.innerHTML = newHtml; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ + * Method: reset │ │ │ │ */ │ │ │ │ - readers: { │ │ │ │ - "kml": { │ │ │ │ - "Document": function(node, obj) { │ │ │ │ - obj.features = new OpenLayers.Format.KML({ │ │ │ │ - kmlns: this.namespaces.kml, │ │ │ │ - extractStyles: true │ │ │ │ - }).read(node); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "owc": { │ │ │ │ - "OWSContext": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "General": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "ResourceList": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Layer": function(node, obj) { │ │ │ │ - var layerContext = { │ │ │ │ - metadata: {}, │ │ │ │ - visibility: (node.getAttribute("hidden") != "1"), │ │ │ │ - queryable: (node.getAttribute("queryable") == "1"), │ │ │ │ - opacity: ((node.getAttribute("opacity") != null) ? │ │ │ │ - parseFloat(node.getAttribute("opacity")) : null), │ │ │ │ - name: node.getAttribute("name"), │ │ │ │ - /* A category layer is a dummy layer meant for creating │ │ │ │ - hierarchies. It is not a physical layer in the │ │ │ │ - OpenLayers sense. The assumption we make here is that │ │ │ │ - category layers do not have a name attribute */ │ │ │ │ - categoryLayer: (node.getAttribute("name") == null), │ │ │ │ - formats: [], │ │ │ │ - styles: [] │ │ │ │ - }; │ │ │ │ - if (!obj.layersContext) { │ │ │ │ - obj.layersContext = []; │ │ │ │ - } │ │ │ │ - obj.layersContext.push(layerContext); │ │ │ │ - this.readChildNodes(node, layerContext); │ │ │ │ - }, │ │ │ │ - "InlineGeometry": function(node, obj) { │ │ │ │ - obj.features = []; │ │ │ │ - var elements = this.getElementsByTagNameNS(node, │ │ │ │ - this.namespaces.gml, "featureMember"); │ │ │ │ - var el; │ │ │ │ - if (elements.length >= 1) { │ │ │ │ - el = elements[0]; │ │ │ │ - } │ │ │ │ - if (el && el.firstChild) { │ │ │ │ - var featurenode = (el.firstChild.nextSibling) ? │ │ │ │ - el.firstChild.nextSibling : el.firstChild; │ │ │ │ - this.setNamespace("feature", featurenode.namespaceURI); │ │ │ │ - this.featureType = featurenode.localName || │ │ │ │ - featurenode.nodeName.split(":").pop(); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Server": function(node, obj) { │ │ │ │ - // when having multiple Server types, we prefer WMS │ │ │ │ - if ((!obj.service && !obj.version) || │ │ │ │ - (obj.service != │ │ │ │ - OpenLayers.Format.Context.serviceTypes.WMS)) { │ │ │ │ - obj.service = node.getAttribute("service"); │ │ │ │ - obj.version = node.getAttribute("version"); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "Name": function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "Title": function(node, obj) { │ │ │ │ - obj.title = this.getChildValue(node); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - }, │ │ │ │ - "StyleList": function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj.styles); │ │ │ │ - }, │ │ │ │ - "Style": function(node, obj) { │ │ │ │ - var style = {}; │ │ │ │ - obj.push(style); │ │ │ │ - this.readChildNodes(node, style); │ │ │ │ - }, │ │ │ │ - "LegendURL": function(node, obj) { │ │ │ │ - var legend = {}; │ │ │ │ - obj.legend = legend; │ │ │ │ - this.readChildNodes(node, legend); │ │ │ │ - }, │ │ │ │ - "OnlineResource": function(node, obj) { │ │ │ │ - obj.url = this.getAttributeNS(node, this.namespaces.xlink, │ │ │ │ - "href"); │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers.ows, │ │ │ │ - "gml": OpenLayers.Format.GML.v2.prototype.readers.gml, │ │ │ │ - "sld": OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld, │ │ │ │ - "feature": OpenLayers.Format.GML.v2.prototype.readers.feature │ │ │ │ + reset: function(evt) { │ │ │ │ + if (this.emptyString != null) { │ │ │ │ + this.element.innerHTML = this.emptyString; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * Method: formatOutput │ │ │ │ + * Override to provide custom display output │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lonLat - {<OpenLayers.LonLat>} Location to display │ │ │ │ */ │ │ │ │ - writers: { │ │ │ │ - "owc": { │ │ │ │ - "OWSContext": function(options) { │ │ │ │ - var node = this.createElementNSPlus("OWSContext", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - id: options.id || OpenLayers.Util.createUniqueID("OpenLayers_OWSContext_") │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("General", options, node); │ │ │ │ - this.writeNode("ResourceList", options, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "General": function(options) { │ │ │ │ - var node = this.createElementNSPlus("General"); │ │ │ │ - this.writeNode("ows:BoundingBox", options, node); │ │ │ │ - this.writeNode("ows:Title", options.title || 'OpenLayers OWSContext', node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "ResourceList": function(options) { │ │ │ │ - var node = this.createElementNSPlus("ResourceList"); │ │ │ │ - for (var i = 0, len = options.layers.length; i < len; i++) { │ │ │ │ - var layer = options.layers[i]; │ │ │ │ - var decomposedPath = this.decomposeNestingPath(layer.metadata.nestingPath); │ │ │ │ - this.writeNode("_Layer", { │ │ │ │ - layer: layer, │ │ │ │ - subPaths: decomposedPath │ │ │ │ - }, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Server": function(options) { │ │ │ │ - var node = this.createElementNSPlus("Server", { │ │ │ │ - attributes: { │ │ │ │ - version: options.version, │ │ │ │ - service: options.service │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("OnlineResource", options, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "OnlineResource": function(options) { │ │ │ │ - var node = this.createElementNSPlus("OnlineResource", { │ │ │ │ - attributes: { │ │ │ │ - "xlink:href": options.url │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "InlineGeometry": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("InlineGeometry"), │ │ │ │ - dataExtent = layer.getDataExtent(); │ │ │ │ - if (dataExtent !== null) { │ │ │ │ - this.writeNode("gml:boundedBy", dataExtent, node); │ │ │ │ - } │ │ │ │ - for (var i = 0, len = layer.features.length; i < len; i++) { │ │ │ │ - this.writeNode("gml:featureMember", layer.features[i], node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "StyleList": function(styles) { │ │ │ │ - var node = this.createElementNSPlus("StyleList"); │ │ │ │ - for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ - this.writeNode("Style", styles[i], node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Style": function(style) { │ │ │ │ - var node = this.createElementNSPlus("Style"); │ │ │ │ - this.writeNode("Name", style, node); │ │ │ │ - this.writeNode("Title", style, node); │ │ │ │ - if (style.legend) { │ │ │ │ - this.writeNode("LegendURL", style, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Name": function(obj) { │ │ │ │ - var node = this.createElementNSPlus("Name", { │ │ │ │ - value: obj.name │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Title": function(obj) { │ │ │ │ - var node = this.createElementNSPlus("Title", { │ │ │ │ - value: obj.title │ │ │ │ - }); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "LegendURL": function(style) { │ │ │ │ - var node = this.createElementNSPlus("LegendURL"); │ │ │ │ - this.writeNode("OnlineResource", style.legend, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "_WMS": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer", { │ │ │ │ - attributes: { │ │ │ │ - name: layer.params.LAYERS, │ │ │ │ - queryable: layer.queryable ? "1" : "0", │ │ │ │ - hidden: layer.visibility ? "0" : "1", │ │ │ │ - opacity: layer.hasOwnProperty("opacity") ? layer.opacity : null │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("ows:OutputFormat", layer.params.FORMAT, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.WMS, │ │ │ │ - version: layer.params.VERSION, │ │ │ │ - url: layer.url │ │ │ │ - }, node); │ │ │ │ - if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ - this.writeNode("StyleList", layer.metadata.styles, node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "_Layer": function(options) { │ │ │ │ - var layer, subPaths, node, title; │ │ │ │ - layer = options.layer; │ │ │ │ - subPaths = options.subPaths; │ │ │ │ - node = null; │ │ │ │ - title = null; │ │ │ │ - // subPaths is an array of an array │ │ │ │ - // recursively calling _Layer writer eats up subPaths, until a │ │ │ │ - // real writer is called and nodes are returned. │ │ │ │ - if (subPaths.length > 0) { │ │ │ │ - var path = subPaths[0].join("/"); │ │ │ │ - var index = path.lastIndexOf("/"); │ │ │ │ - node = this.nestingLayerLookup[path]; │ │ │ │ - title = (index > 0) ? path.substring(index + 1, path.length) : path; │ │ │ │ - if (!node) { │ │ │ │ - // category layer │ │ │ │ - node = this.createElementNSPlus("Layer"); │ │ │ │ - this.writeNode("ows:Title", title, node); │ │ │ │ - this.nestingLayerLookup[path] = node; │ │ │ │ - } │ │ │ │ - options.subPaths.shift(); //remove a path after each call │ │ │ │ - this.writeNode("_Layer", options, node); │ │ │ │ - return node; │ │ │ │ - } else { │ │ │ │ - // write out the actual layer │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ - node = this.writeNode("_WMS", layer); │ │ │ │ - } else if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ - if (layer.protocol instanceof OpenLayers.Protocol.WFS.v1) { │ │ │ │ - node = this.writeNode("_WFS", layer); │ │ │ │ - } else if (layer.protocol instanceof OpenLayers.Protocol.HTTP) { │ │ │ │ - if (layer.protocol.format instanceof OpenLayers.Format.GML) { │ │ │ │ - layer.protocol.format.version = "2.1.2"; │ │ │ │ - node = this.writeNode("_GML", layer); │ │ │ │ - } else if (layer.protocol.format instanceof OpenLayers.Format.KML) { │ │ │ │ - layer.protocol.format.version = "2.2"; │ │ │ │ - node = this.writeNode("_KML", layer); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // write out as inline GML since we have no idea │ │ │ │ - // about the original Format │ │ │ │ - this.setNamespace("feature", this.featureNS); │ │ │ │ - node = this.writeNode("_InlineGeometry", layer); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (layer.options.maxScale) { │ │ │ │ - this.writeNode("sld:MinScaleDenominator", │ │ │ │ - layer.options.maxScale, node); │ │ │ │ - } │ │ │ │ - if (layer.options.minScale) { │ │ │ │ - this.writeNode("sld:MaxScaleDenominator", │ │ │ │ - layer.options.minScale, node); │ │ │ │ - } │ │ │ │ - this.nestingLayerLookup[layer.name] = node; │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "_WFS": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer", { │ │ │ │ - attributes: { │ │ │ │ - name: layer.protocol.featurePrefix + ":" + layer.protocol.featureType, │ │ │ │ - hidden: layer.visibility ? "0" : "1" │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.WFS, │ │ │ │ - version: layer.protocol.version, │ │ │ │ - url: layer.protocol.url │ │ │ │ - }, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "_InlineGeometry": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer", { │ │ │ │ - attributes: { │ │ │ │ - name: this.featureType, │ │ │ │ - hidden: layer.visibility ? "0" : "1" │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("InlineGeometry", layer, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "_GML": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer"); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.GML, │ │ │ │ - url: layer.protocol.url, │ │ │ │ - version: layer.protocol.format.version │ │ │ │ - }, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "_KML": function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer"); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.KML, │ │ │ │ - version: layer.protocol.format.version, │ │ │ │ - url: layer.protocol.url │ │ │ │ - }, node); │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "gml": OpenLayers.Util.applyDefaults({ │ │ │ │ - "boundedBy": function(bounds) { │ │ │ │ - var node = this.createElementNSPlus("gml:boundedBy"); │ │ │ │ - this.writeNode("gml:Box", bounds, node); │ │ │ │ - return node; │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.v2.prototype.writers.gml), │ │ │ │ - "ows": OpenLayers.Format.OWSCommon.v1_0_0.prototype.writers.ows, │ │ │ │ - "sld": OpenLayers.Format.SLD.v1_0_0.prototype.writers.sld, │ │ │ │ - "feature": OpenLayers.Format.GML.v2.prototype.writers.feature │ │ │ │ + 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; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.OWSContext.v0_3_1" │ │ │ │ - │ │ │ │ + CLASS_NAME: "OpenLayers.Control.MousePosition" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/XLS/v1.js │ │ │ │ + OpenLayers/Control/Zoom.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XLS.js │ │ │ │ - * @requires OpenLayers/Format/GML/v3.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.XLS.v1 │ │ │ │ - * Superclass for XLS version 1 parsers. Only supports GeocodeRequest for now. │ │ │ │ + * Class: OpenLayers.Control.Zoom │ │ │ │ + * The Zoom control is a pair of +/- links for zooming in and out. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XML> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.XLS.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: namespaces │ │ │ │ - * {Object} Mapping of namespace aliases to namespace URIs. │ │ │ │ - */ │ │ │ │ - namespaces: { │ │ │ │ - xls: "http://www.opengis.net/xls", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: regExes │ │ │ │ - * Compiled regular expressions for manipulating strings. │ │ │ │ - */ │ │ │ │ - regExes: { │ │ │ │ - trimSpace: (/^\s*|\s*$/g), │ │ │ │ - removeSpace: (/\s*/g), │ │ │ │ - splitSpace: (/\s+/), │ │ │ │ - trimComma: (/\s*,\s*/g) │ │ │ │ - }, │ │ │ │ +OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: xy │ │ │ │ - * {Boolean} Order of the GML coordinate true:(x,y) or false:(y,x) │ │ │ │ - * Changing is not recommended, a new Format should be instantiated. │ │ │ │ + * APIProperty: zoomInText │ │ │ │ + * {String} │ │ │ │ + * Text for zoom-in link. Default is "+". │ │ │ │ */ │ │ │ │ - xy: true, │ │ │ │ + zoomInText: "+", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultPrefix │ │ │ │ + * APIProperty: zoomInId │ │ │ │ + * {String} │ │ │ │ + * Instead of having the control create a zoom in link, you can provide │ │ │ │ + * the identifier for an anchor element already added to the document. │ │ │ │ + * By default, an element with id "olZoomInLink" will be searched for │ │ │ │ + * and used if it exists. │ │ │ │ */ │ │ │ │ - defaultPrefix: "xls", │ │ │ │ + zoomInId: "olZoomInLink", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} Schema location for a particular minor version. │ │ │ │ + * APIProperty: zoomOutText │ │ │ │ + * {String} │ │ │ │ + * Text for zoom-out link. Default is "\u2212". │ │ │ │ */ │ │ │ │ - schemaLocation: null, │ │ │ │ + zoomOutText: "\u2212", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.XLS.v1 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.XLS> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * APIProperty: zoomOutId │ │ │ │ + * {String} │ │ │ │ + * Instead of having the control create a zoom out link, you can provide │ │ │ │ + * the identifier for an anchor element already added to the document. │ │ │ │ + * By default, an element with id "olZoomOutLink" will be searched for │ │ │ │ + * and used if it exists. │ │ │ │ */ │ │ │ │ + zoomOutId: "olZoomOutLink", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * data - {DOMElement} An XLS document element. │ │ │ │ - * options - {Object} Options for the reader. │ │ │ │ + * Method: draw │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object representing the XLSResponse. │ │ │ │ + * {DOMElement} A reference to the DOMElement containing the zoom links. │ │ │ │ */ │ │ │ │ - read: function(data, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var xls = {}; │ │ │ │ - this.readChildNodes(data, xls); │ │ │ │ - return xls; │ │ │ │ - }, │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ + links = this.getOrCreateLinks(div), │ │ │ │ + zoomIn = links.zoomIn, │ │ │ │ + zoomOut = links.zoomOut, │ │ │ │ + eventsInstance = this.map.events; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: readers │ │ │ │ - * Contains public functions, grouped by namespace prefix, that will │ │ │ │ - * be applied when a namespaced node is found matching the function │ │ │ │ - * name. The function will be applied in the scope of this parser │ │ │ │ - * with two arguments: the node being read and a context object passed │ │ │ │ - * from the parent. │ │ │ │ - */ │ │ │ │ - readers: { │ │ │ │ - "xls": { │ │ │ │ - "XLS": function(node, xls) { │ │ │ │ - xls.version = node.getAttribute("version"); │ │ │ │ - this.readChildNodes(node, xls); │ │ │ │ - }, │ │ │ │ - "Response": function(node, xls) { │ │ │ │ - this.readChildNodes(node, xls); │ │ │ │ - }, │ │ │ │ - "GeocodeResponse": function(node, xls) { │ │ │ │ - xls.responseLists = []; │ │ │ │ - this.readChildNodes(node, xls); │ │ │ │ - }, │ │ │ │ - "GeocodeResponseList": function(node, xls) { │ │ │ │ - var responseList = { │ │ │ │ - features: [], │ │ │ │ - numberOfGeocodedAddresses: parseInt(node.getAttribute("numberOfGeocodedAddresses")) │ │ │ │ - }; │ │ │ │ - xls.responseLists.push(responseList); │ │ │ │ - this.readChildNodes(node, responseList); │ │ │ │ - }, │ │ │ │ - "GeocodedAddress": function(node, responseList) { │ │ │ │ - var feature = new OpenLayers.Feature.Vector(); │ │ │ │ - responseList.features.push(feature); │ │ │ │ - this.readChildNodes(node, feature); │ │ │ │ - // post-process geometry │ │ │ │ - feature.geometry = feature.components[0]; │ │ │ │ - }, │ │ │ │ - "GeocodeMatchCode": function(node, feature) { │ │ │ │ - feature.attributes.matchCode = { │ │ │ │ - accuracy: parseFloat(node.getAttribute("accuracy")), │ │ │ │ - matchType: node.getAttribute("matchType") │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ - "Address": function(node, feature) { │ │ │ │ - var address = { │ │ │ │ - countryCode: node.getAttribute("countryCode"), │ │ │ │ - addressee: node.getAttribute("addressee"), │ │ │ │ - street: [], │ │ │ │ - place: [] │ │ │ │ - }; │ │ │ │ - feature.attributes.address = address; │ │ │ │ - this.readChildNodes(node, address); │ │ │ │ - }, │ │ │ │ - "freeFormAddress": function(node, address) { │ │ │ │ - address.freeFormAddress = this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "StreetAddress": function(node, address) { │ │ │ │ - this.readChildNodes(node, address); │ │ │ │ - }, │ │ │ │ - "Building": function(node, address) { │ │ │ │ - address.building = { │ │ │ │ - 'number': node.getAttribute("number"), │ │ │ │ - subdivision: node.getAttribute("subdivision"), │ │ │ │ - buildingName: node.getAttribute("buildingName") │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ - "Street": function(node, address) { │ │ │ │ - // only support the built-in primitive type for now │ │ │ │ - address.street.push(this.getChildValue(node)); │ │ │ │ - }, │ │ │ │ - "Place": function(node, address) { │ │ │ │ - // type is one of CountrySubdivision, │ │ │ │ - // CountrySecondarySubdivision, Municipality or │ │ │ │ - // MunicipalitySubdivision │ │ │ │ - address.place[node.getAttribute("type")] = │ │ │ │ - this.getChildValue(node); │ │ │ │ - }, │ │ │ │ - "PostalCode": function(node, address) { │ │ │ │ - address.postalCode = this.getChildValue(node); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - "gml": OpenLayers.Format.GML.v3.prototype.readers.gml │ │ │ │ + if (zoomOut.parentNode !== div) { │ │ │ │ + eventsInstance = this.events; │ │ │ │ + eventsInstance.attachToElement(zoomOut.parentNode); │ │ │ │ + } │ │ │ │ + eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ + │ │ │ │ + this.zoomInLink = zoomIn; │ │ │ │ + this.zoomOutLink = zoomOut; │ │ │ │ + return div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ - * │ │ │ │ + * Method: getOrCreateLinks │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * request - {Object} An object representing the geocode request. │ │ │ │ + * el - {DOMElement} │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The root of an XLS document. │ │ │ │ + * Return: │ │ │ │ + * {Object} Object with zoomIn and zoomOut properties referencing links. │ │ │ │ */ │ │ │ │ - write: function(request) { │ │ │ │ - return this.writers.xls.XLS.apply(this, [request]); │ │ │ │ + getOrCreateLinks: function(el) { │ │ │ │ + var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ + zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ + if (!zoomIn) { │ │ │ │ + zoomIn = document.createElement("a"); │ │ │ │ + zoomIn.href = "#zoomIn"; │ │ │ │ + zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ + zoomIn.className = "olControlZoomIn"; │ │ │ │ + el.appendChild(zoomIn); │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ + if (!zoomOut) { │ │ │ │ + zoomOut = document.createElement("a"); │ │ │ │ + zoomOut.href = "#zoomOut"; │ │ │ │ + zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ + zoomOut.className = "olControlZoomOut"; │ │ │ │ + el.appendChild(zoomOut); │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ + return { │ │ │ │ + zoomIn: zoomIn, │ │ │ │ + zoomOut: zoomOut │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: writers │ │ │ │ - * As a compliment to the readers property, this structure contains public │ │ │ │ - * writing functions grouped by namespace alias and named like the │ │ │ │ - * node names they produce. │ │ │ │ + * Method: onZoomClick │ │ │ │ + * Called when zoomin/out link is clicked. │ │ │ │ */ │ │ │ │ - writers: { │ │ │ │ - "xls": { │ │ │ │ - "XLS": function(request) { │ │ │ │ - var root = this.createElementNSPlus( │ │ │ │ - "xls:XLS", { │ │ │ │ - attributes: { │ │ │ │ - "version": this.VERSION, │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ - } │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - this.writeNode("RequestHeader", request.header, root); │ │ │ │ - this.writeNode("Request", request, root); │ │ │ │ - return root; │ │ │ │ - }, │ │ │ │ - "RequestHeader": function(header) { │ │ │ │ - return this.createElementNSPlus("xls:RequestHeader"); │ │ │ │ - }, │ │ │ │ - "Request": function(request) { │ │ │ │ - var node = this.createElementNSPlus("xls:Request", { │ │ │ │ - attributes: { │ │ │ │ - methodName: "GeocodeRequest", │ │ │ │ - requestID: request.requestID || "", │ │ │ │ - version: this.VERSION │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("GeocodeRequest", request.addresses, node); │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "GeocodeRequest": function(addresses) { │ │ │ │ - var node = this.createElementNSPlus("xls:GeocodeRequest"); │ │ │ │ - for (var i = 0, len = addresses.length; i < len; i++) { │ │ │ │ - this.writeNode("Address", addresses[i], node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Address": function(address) { │ │ │ │ - var node = this.createElementNSPlus("xls:Address", { │ │ │ │ - attributes: { │ │ │ │ - countryCode: address.countryCode │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (address.freeFormAddress) { │ │ │ │ - this.writeNode("freeFormAddress", address.freeFormAddress, node); │ │ │ │ - } else { │ │ │ │ - if (address.street) { │ │ │ │ - this.writeNode("StreetAddress", address, node); │ │ │ │ - } │ │ │ │ - if (address.municipality) { │ │ │ │ - this.writeNode("Municipality", address.municipality, node); │ │ │ │ - } │ │ │ │ - if (address.countrySubdivision) { │ │ │ │ - this.writeNode("CountrySubdivision", address.countrySubdivision, node); │ │ │ │ - } │ │ │ │ - if (address.postalCode) { │ │ │ │ - this.writeNode("PostalCode", address.postalCode, node); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "freeFormAddress": function(freeFormAddress) { │ │ │ │ - return this.createElementNSPlus("freeFormAddress", { │ │ │ │ - value: freeFormAddress │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "StreetAddress": function(address) { │ │ │ │ - var node = this.createElementNSPlus("xls:StreetAddress"); │ │ │ │ - if (address.building) { │ │ │ │ - this.writeNode(node, "Building", address.building); │ │ │ │ - } │ │ │ │ - var street = address.street; │ │ │ │ - if (!(OpenLayers.Util.isArray(street))) { │ │ │ │ - street = [street]; │ │ │ │ - } │ │ │ │ - for (var i = 0, len = street.length; i < len; i++) { │ │ │ │ - this.writeNode("Street", street[i], node); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - "Building": function(building) { │ │ │ │ - return this.createElementNSPlus("xls:Building", { │ │ │ │ - attributes: { │ │ │ │ - "number": building["number"], │ │ │ │ - "subdivision": building.subdivision, │ │ │ │ - "buildingName": building.buildingName │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Street": function(street) { │ │ │ │ - return this.createElementNSPlus("xls:Street", { │ │ │ │ - value: street │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "Municipality": function(municipality) { │ │ │ │ - return this.createElementNSPlus("xls:Place", { │ │ │ │ - attributes: { │ │ │ │ - type: "Municipality" │ │ │ │ - }, │ │ │ │ - value: municipality │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "CountrySubdivision": function(countrySubdivision) { │ │ │ │ - return this.createElementNSPlus("xls:Place", { │ │ │ │ - attributes: { │ │ │ │ - type: "CountrySubdivision" │ │ │ │ - }, │ │ │ │ - value: countrySubdivision │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - "PostalCode": function(postalCode) { │ │ │ │ - return this.createElementNSPlus("xls:PostalCode", { │ │ │ │ - value: postalCode │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + onZoomClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.zoomInLink) { │ │ │ │ + this.map.zoomIn(); │ │ │ │ + } else if (button === this.zoomOutLink) { │ │ │ │ + this.map.zoomOut(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.XLS.v1" │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Clean up. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onZoomClick); │ │ │ │ + } │ │ │ │ + delete this.zoomInLink; │ │ │ │ + delete this.zoomOutLink; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/XLS/v1_1_0.js │ │ │ │ + OpenLayers/Control/PinchZoom.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/XLS/v1.js │ │ │ │ + * @requires OpenLayers/Handler/Pinch.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.XLS.v1_1_0 │ │ │ │ - * Read / write XLS version 1.1.0. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.XLS.v1> │ │ │ │ + * Class: OpenLayers.Control.PinchZoom │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Format.XLS.v1_1_0 = OpenLayers.Class( │ │ │ │ - OpenLayers.Format.XLS.v1, { │ │ │ │ +OpenLayers.Control.PinchZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constant: VERSION │ │ │ │ - * {String} 1.1 │ │ │ │ - */ │ │ │ │ - VERSION: "1.1", │ │ │ │ + /** │ │ │ │ + * Property: type │ │ │ │ + * {OpenLayers.Control.TYPES} │ │ │ │ + */ │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: schemaLocation │ │ │ │ - * {String} http://www.opengis.net/xls │ │ │ │ - * http://schemas.opengis.net/ols/1.1.0/LocationUtilityService.xsd │ │ │ │ - */ │ │ │ │ - schemaLocation: "http://www.opengis.net/xls http://schemas.opengis.net/ols/1.1.0/LocationUtilityService.xsd", │ │ │ │ + /** │ │ │ │ + * Property: pinchOrigin │ │ │ │ + * {Object} Cached object representing the pinch start (in pixels). │ │ │ │ + */ │ │ │ │ + pinchOrigin: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.XLS.v1_1_0 │ │ │ │ - * Instances of this class are not created directly. Use the │ │ │ │ - * <OpenLayers.Format.XLS> constructor instead. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Property: currentCenter │ │ │ │ + * {Object} Cached object representing the latest pinch center (in pixels). │ │ │ │ + */ │ │ │ │ + currentCenter: null, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.XLS.v1_1_0" │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * APIProperty: preserveCenter │ │ │ │ + * {Boolean} Set this to true if you don't want the map center to change │ │ │ │ + * while pinching. For example you may want to set preserveCenter to │ │ │ │ + * true when the user location is being watched and you want to preserve │ │ │ │ + * the user location at the center of the map even if he zooms in or │ │ │ │ + * out using pinch. This property's value can be changed any time on an │ │ │ │ + * existing instance. Default is false. │ │ │ │ + */ │ │ │ │ + preserveCenter: false, │ │ │ │ │ │ │ │ -// Support non standard implementation │ │ │ │ -OpenLayers.Format.XLS.v1_1 = OpenLayers.Format.XLS.v1_1_0; │ │ │ │ + /** │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Used to set non-default properties on the pinch handler │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.PinchZoom │ │ │ │ + * Create a control for zooming with pinch gestures. This works on devices │ │ │ │ + * with multi-touch support. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * the control │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + this.handler = new OpenLayers.Handler.Pinch(this, { │ │ │ │ + start: this.pinchStart, │ │ │ │ + move: this.pinchMove, │ │ │ │ + done: this.pinchDone │ │ │ │ + }, this.handlerOptions); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: pinchStart │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * pinchData - {Object} pinch data object related to the current touchmove │ │ │ │ + * of the pinch gesture. This give us the current scale of the pinch. │ │ │ │ + */ │ │ │ │ + pinchStart: function(evt, pinchData) { │ │ │ │ + var xy = (this.preserveCenter) ? │ │ │ │ + this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ + this.pinchOrigin = xy; │ │ │ │ + this.currentCenter = xy; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: pinchMove │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * pinchData - {Object} pinch data object related to the current touchmove │ │ │ │ + * of the pinch gesture. This give us the current scale of the pinch. │ │ │ │ + */ │ │ │ │ + pinchMove: function(evt, pinchData) { │ │ │ │ + var scale = pinchData.scale; │ │ │ │ + var containerOrigin = this.map.layerContainerOriginPx; │ │ │ │ + var pinchOrigin = this.pinchOrigin; │ │ │ │ + var current = (this.preserveCenter) ? │ │ │ │ + this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ + │ │ │ │ + var dx = Math.round((containerOrigin.x + current.x - pinchOrigin.x) + (scale - 1) * (containerOrigin.x - pinchOrigin.x)); │ │ │ │ + var dy = Math.round((containerOrigin.y + current.y - pinchOrigin.y) + (scale - 1) * (containerOrigin.y - pinchOrigin.y)); │ │ │ │ + │ │ │ │ + this.map.applyTransform(dx, dy, scale); │ │ │ │ + this.currentCenter = current; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: pinchDone │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * start - {Object} pinch data object related to the touchstart event that │ │ │ │ + * started the pinch gesture. │ │ │ │ + * last - {Object} pinch data object related to the last touchmove event │ │ │ │ + * of the pinch gesture. This give us the final scale of the pinch. │ │ │ │ + */ │ │ │ │ + pinchDone: function(evt, start, last) { │ │ │ │ + this.map.applyTransform(); │ │ │ │ + var zoom = this.map.getZoomForResolution(this.map.getResolution() / last.scale, true); │ │ │ │ + if (zoom !== this.map.getZoom() || !this.currentCenter.equals(this.pinchOrigin)) { │ │ │ │ + var resolution = this.map.getResolutionForZoom(zoom); │ │ │ │ + │ │ │ │ + var location = this.map.getLonLatFromPixel(this.pinchOrigin); │ │ │ │ + var zoomPixel = this.currentCenter; │ │ │ │ + var size = this.map.getSize(); │ │ │ │ + │ │ │ │ + location.lon += resolution * ((size.w / 2) - zoomPixel.x); │ │ │ │ + location.lat -= resolution * ((size.h / 2) - zoomPixel.y); │ │ │ │ + │ │ │ │ + // Force a reflow before calling setCenter. This is to work │ │ │ │ + // around an issue occuring in iOS. │ │ │ │ + // │ │ │ │ + // See https://github.com/openlayers/openlayers/pull/351. │ │ │ │ + // │ │ │ │ + // Without a reflow setting the layer container div's top left │ │ │ │ + // style properties to "0px" - as done in Map.moveTo when zoom │ │ │ │ + // is changed - won't actually correctly reposition the layer │ │ │ │ + // container div. │ │ │ │ + // │ │ │ │ + // Also, we need to use a statement that the Google Closure │ │ │ │ + // compiler won't optimize away. │ │ │ │ + this.map.div.clientWidth = this.map.div.clientWidth; │ │ │ │ + │ │ │ │ + this.map.setCenter(location, zoom); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.PinchZoom" │ │ │ │ + │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Tile/Image/IFrame.js │ │ │ │ + OpenLayers/Control/TouchNavigation.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Tile/Image.js │ │ │ │ + * @requires OpenLayers/Control/DragPan.js │ │ │ │ + * @requires OpenLayers/Control/PinchZoom.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: OpenLayers.Tile.Image.IFrame │ │ │ │ - * Mixin for tiles that use form-encoded POST requests to get images from │ │ │ │ - * remote services. Images will be loaded using HTTP-POST into an IFrame. │ │ │ │ + * Class: OpenLayers.Control.TouchNavigation │ │ │ │ + * The navigation control handles map browsing with touch events (dragging, │ │ │ │ + * double-tapping, tap with two fingers, and pinch zoom). Create a new │ │ │ │ + * control with the <OpenLayers.Control.TouchNavigation> constructor. │ │ │ │ * │ │ │ │ - * This mixin will be applied to <OpenLayers.Tile.Image> instances │ │ │ │ - * configured with <OpenLayers.Tile.Image.maxGetUrlLength> set. │ │ │ │ + * If you’re only targeting touch enabled devices with your mapping application, │ │ │ │ + * you can create a map with only a TouchNavigation control. The │ │ │ │ + * <OpenLayers.Control.Navigation> control is mobile ready by default, but │ │ │ │ + * you can generate a smaller build of the library by only including this │ │ │ │ + * touch navigation control if you aren't concerned about mouse interaction. │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Tile.Image.IFrame = { │ │ │ │ +OpenLayers.Control.TouchNavigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: useIFrame │ │ │ │ - * {Boolean} true if we are currently using an IFrame to render POST │ │ │ │ - * responses, false if we are using an img element to render GET responses. │ │ │ │ + * Property: dragPan │ │ │ │ + * {<OpenLayers.Control.DragPan>} │ │ │ │ */ │ │ │ │ - useIFrame: null, │ │ │ │ + dragPan: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: blankImageUrl │ │ │ │ - * {String} Using a data scheme url is not supported by all browsers, but │ │ │ │ - * we don't care because we either set it as css backgroundImage, or the │ │ │ │ - * image's display style is set to "none" when we use it. │ │ │ │ + * APIProperty: dragPanOptions │ │ │ │ + * {Object} Options passed to the DragPan control. │ │ │ │ */ │ │ │ │ - blankImageUrl: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAQAIBRAA7", │ │ │ │ + dragPanOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * Set useIFrame in the instance, and operate the image/iframe switch. │ │ │ │ - * Then call Tile.Image.draw. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * Property: pinchZoom │ │ │ │ + * {<OpenLayers.Control.PinchZoom>} │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - var draw = OpenLayers.Tile.Image.prototype.shouldDraw.call(this); │ │ │ │ - if (draw) { │ │ │ │ - │ │ │ │ - // this.url isn't set to the currect value yet, so we call getURL │ │ │ │ - // on the layer and store the result in a local variable │ │ │ │ - var url = this.layer.getURL(this.bounds); │ │ │ │ - │ │ │ │ - var usedIFrame = this.useIFrame; │ │ │ │ - this.useIFrame = this.maxGetUrlLength !== null && │ │ │ │ - !this.layer.async && │ │ │ │ - url.length > this.maxGetUrlLength; │ │ │ │ - │ │ │ │ - var fromIFrame = usedIFrame && !this.useIFrame; │ │ │ │ - var toIFrame = !usedIFrame && this.useIFrame; │ │ │ │ + pinchZoom: null, │ │ │ │ │ │ │ │ - if (fromIFrame || toIFrame) { │ │ │ │ + /** │ │ │ │ + * APIProperty: pinchZoomOptions │ │ │ │ + * {Object} Options passed to the PinchZoom control. │ │ │ │ + */ │ │ │ │ + pinchZoomOptions: null, │ │ │ │ │ │ │ │ - // Switching between GET (image) and POST (iframe). │ │ │ │ + /** │ │ │ │ + * APIProperty: clickHandlerOptions │ │ │ │ + * {Object} Options passed to the Click handler. │ │ │ │ + */ │ │ │ │ + clickHandlerOptions: null, │ │ │ │ │ │ │ │ - // We remove the imgDiv (really either an image or an iframe) │ │ │ │ - // from the frame and set it to null to make sure initImage │ │ │ │ - // will call getImage. │ │ │ │ + /** │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} Allow panning of the map by dragging outside map viewport. │ │ │ │ + * Default is false. │ │ │ │ + */ │ │ │ │ + documentDrag: false, │ │ │ │ │ │ │ │ - if (this.imgDiv && this.imgDiv.parentNode === this.frame) { │ │ │ │ - this.frame.removeChild(this.imgDiv); │ │ │ │ - } │ │ │ │ - this.imgDiv = null; │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ - // And if we had an iframe we also remove the event pane. │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.TouchNavigation │ │ │ │ + * Create a new navigation control │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * the control │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (fromIFrame) { │ │ │ │ - this.frame.removeChild(this.frame.firstChild); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * 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() { │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.dragPan) { │ │ │ │ + this.dragPan.destroy(); │ │ │ │ } │ │ │ │ - return OpenLayers.Tile.Image.prototype.draw.apply(this, arguments); │ │ │ │ + this.dragPan = null; │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.destroy(); │ │ │ │ + delete this.pinchZoom; │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getImage │ │ │ │ - * Creates the content for the frame on the tile. │ │ │ │ + * Method: activate │ │ │ │ */ │ │ │ │ - getImage: function() { │ │ │ │ - if (this.useIFrame === true) { │ │ │ │ - if (!this.frame.childNodes.length) { │ │ │ │ - var eventPane = document.createElement("div"), │ │ │ │ - style = eventPane.style; │ │ │ │ - style.position = "absolute"; │ │ │ │ - style.width = "100%"; │ │ │ │ - style.height = "100%"; │ │ │ │ - style.zIndex = 1; │ │ │ │ - style.backgroundImage = "url(" + this.blankImageUrl + ")"; │ │ │ │ - this.frame.appendChild(eventPane); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var id = this.id + '_iFrame', │ │ │ │ - iframe; │ │ │ │ - if (parseFloat(navigator.appVersion.split("MSIE")[1]) < 9) { │ │ │ │ - // Older IE versions do not set the name attribute of an iFrame │ │ │ │ - // properly via DOM manipulation, so we need to do it on our own with │ │ │ │ - // this hack. │ │ │ │ - iframe = document.createElement('<iframe name="' + id + '">'); │ │ │ │ - │ │ │ │ - // IFrames in older IE versions are not transparent, if you set │ │ │ │ - // the backgroundColor transparent. This is a workaround to get │ │ │ │ - // transparent iframes. │ │ │ │ - iframe.style.backgroundColor = '#FFFFFF'; │ │ │ │ - iframe.style.filter = 'chroma(color=#FFFFFF)'; │ │ │ │ - } else { │ │ │ │ - iframe = document.createElement('iframe'); │ │ │ │ - iframe.style.backgroundColor = 'transparent'; │ │ │ │ - │ │ │ │ - // iframe.name needs to be an unique id, otherwise it │ │ │ │ - // could happen that other iframes are overwritten. │ │ │ │ - iframe.name = id; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // some special properties to avoid scaling the images and scrollbars │ │ │ │ - // in the iframe │ │ │ │ - iframe.scrolling = 'no'; │ │ │ │ - iframe.marginWidth = '0px'; │ │ │ │ - iframe.marginHeight = '0px'; │ │ │ │ - iframe.frameBorder = '0'; │ │ │ │ - │ │ │ │ - iframe.style.position = "absolute"; │ │ │ │ - iframe.style.width = "100%"; │ │ │ │ - iframe.style.height = "100%"; │ │ │ │ - │ │ │ │ - if (this.layer.opacity < 1) { │ │ │ │ - OpenLayers.Util.modifyDOMElement(iframe, null, null, null, │ │ │ │ - null, null, null, this.layer.opacity); │ │ │ │ - } │ │ │ │ - this.frame.appendChild(iframe); │ │ │ │ - this.imgDiv = iframe; │ │ │ │ - return iframe; │ │ │ │ - } else { │ │ │ │ - return OpenLayers.Tile.Image.prototype.getImage.apply(this, arguments); │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragPan.activate(); │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + this.pinchZoom.activate(); │ │ │ │ + return true; │ │ │ │ } │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createRequestForm │ │ │ │ - * Create the html <form> element with width, height, bbox and all │ │ │ │ - * parameters specified in the layer params. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The form element which sends the HTTP-POST request to the │ │ │ │ - * WMS. │ │ │ │ + * Method: deactivate │ │ │ │ */ │ │ │ │ - createRequestForm: function() { │ │ │ │ - // creation of the form element │ │ │ │ - var form = document.createElement('form'); │ │ │ │ - form.method = 'POST'; │ │ │ │ - var cacheId = this.layer.params["_OLSALT"]; │ │ │ │ - cacheId = (cacheId ? cacheId + "_" : "") + this.bounds.toBBOX(); │ │ │ │ - form.action = OpenLayers.Util.urlAppend(this.layer.url, cacheId); │ │ │ │ - form.target = this.id + '_iFrame'; │ │ │ │ - │ │ │ │ - // adding all parameters in layer params as hidden fields to the html │ │ │ │ - // form element │ │ │ │ - var imageSize = this.layer.getImageSize(), │ │ │ │ - params = OpenLayers.Util.getParameters(this.url), │ │ │ │ - field; │ │ │ │ - │ │ │ │ - for (var par in params) { │ │ │ │ - field = document.createElement('input'); │ │ │ │ - field.type = 'hidden'; │ │ │ │ - field.name = par; │ │ │ │ - field.value = params[par]; │ │ │ │ - form.appendChild(field); │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.dragPan.deactivate(); │ │ │ │ + this.handlers.click.deactivate(); │ │ │ │ + this.pinchZoom.deactivate(); │ │ │ │ + return true; │ │ │ │ } │ │ │ │ - │ │ │ │ - return form; │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setImgSrc │ │ │ │ - * Sets the source for the tile image │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * url - {String} │ │ │ │ + * Method: draw │ │ │ │ */ │ │ │ │ - setImgSrc: function(url) { │ │ │ │ - if (this.useIFrame === true) { │ │ │ │ - if (url) { │ │ │ │ - var form = this.createRequestForm(); │ │ │ │ - this.frame.appendChild(form); │ │ │ │ - form.submit(); │ │ │ │ - this.frame.removeChild(form); │ │ │ │ - } else if (this.imgDiv.parentNode === this.frame) { │ │ │ │ - // we don't reuse iframes to avoid caching issues │ │ │ │ - this.frame.removeChild(this.imgDiv); │ │ │ │ - this.imgDiv = null; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Tile.Image.prototype.setImgSrc.apply(this, arguments); │ │ │ │ - } │ │ │ │ + draw: function() { │ │ │ │ + var clickCallbacks = { │ │ │ │ + click: this.defaultClick, │ │ │ │ + dblclick: this.defaultDblClick │ │ │ │ + }; │ │ │ │ + var clickOptions = OpenLayers.Util.extend({ │ │ │ │ + "double": true, │ │ │ │ + stopDouble: true, │ │ │ │ + pixelTolerance: 2 │ │ │ │ + }, this.clickHandlerOptions); │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ + this, clickCallbacks, clickOptions │ │ │ │ + ); │ │ │ │ + this.dragPan = new OpenLayers.Control.DragPan( │ │ │ │ + OpenLayers.Util.extend({ │ │ │ │ + map: this.map, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }, this.dragPanOptions) │ │ │ │ + ); │ │ │ │ + this.dragPan.draw(); │ │ │ │ + this.pinchZoom = new OpenLayers.Control.PinchZoom( │ │ │ │ + OpenLayers.Util.extend({ │ │ │ │ + map: this.map │ │ │ │ + }, this.pinchZoomOptions) │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onImageLoad │ │ │ │ - * Handler for the image onload event │ │ │ │ + * Method: defaultClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - onImageLoad: function() { │ │ │ │ - //TODO de-uglify opacity handling │ │ │ │ - OpenLayers.Tile.Image.prototype.onImageLoad.apply(this, arguments); │ │ │ │ - if (this.useIFrame === true) { │ │ │ │ - this.imgDiv.style.opacity = 1; │ │ │ │ - this.frame.style.opacity = this.layer.opacity; │ │ │ │ + defaultClick: function(evt) { │ │ │ │ + if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ + this.map.zoomOut(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createBackBuffer │ │ │ │ - * Override createBackBuffer to do nothing when we use an iframe. Moving an │ │ │ │ - * iframe from one element to another makes it necessary to reload the iframe │ │ │ │ - * because its content is lost. So we just give up. │ │ │ │ + * Method: defaultDblClick │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - createBackBuffer: function() { │ │ │ │ - var backBuffer; │ │ │ │ - if (this.useIFrame === false) { │ │ │ │ - backBuffer = OpenLayers.Tile.Image.prototype.createBackBuffer.call(this); │ │ │ │ - } │ │ │ │ - return backBuffer; │ │ │ │ - } │ │ │ │ -}; │ │ │ │ + defaultDblClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom + 1, evt.xy); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.TouchNavigation" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol/WFS.js │ │ │ │ + OpenLayers/Control/WMTSGetFeatureInfo.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Protocol.js │ │ │ │ - */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol.WFS │ │ │ │ - * Used to create a versioned WFS protocol. Default version is 1.0.0. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol>} A WFS protocol of the given version. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var protocol = new OpenLayers.Protocol.WFS({ │ │ │ │ - * version: "1.1.0", │ │ │ │ - * url: "http://demo.opengeo.org/geoserver/wfs", │ │ │ │ - * featureType: "tasmania_roads", │ │ │ │ - * featureNS: "http://www.openplans.org/topp", │ │ │ │ - * geometryName: "the_geom" │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * See the protocols for specific WFS versions for more detail. │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Handler/Hover.js │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ + * @requires OpenLayers/Format/WMSGetFeatureInfo.js │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.WFS = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults( │ │ │ │ - options, OpenLayers.Protocol.WFS.DEFAULTS │ │ │ │ - ); │ │ │ │ - var cls = OpenLayers.Protocol.WFS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported WFS version: " + options.version; │ │ │ │ - } │ │ │ │ - return new cls(options); │ │ │ │ -}; │ │ │ │ │ │ │ │ /** │ │ │ │ - * Function: fromWMSLayer │ │ │ │ - * Convenience function to create a WFS protocol from a WMS layer. This makes │ │ │ │ - * the assumption that a WFS requests can be issued at the same URL as │ │ │ │ - * WMS requests and that a WFS featureType exists with the same name as the │ │ │ │ - * WMS layer. │ │ │ │ - * │ │ │ │ - * This function is designed to auto-configure <url>, <featureType>, │ │ │ │ - * <featurePrefix> and <srsName> for WFS <version> 1.1.0. Note that │ │ │ │ - * srsName matching with the WMS layer will not work with WFS 1.0.0. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.WMS>} WMS layer that has a matching WFS │ │ │ │ - * FeatureType at the same server url with the same typename. │ │ │ │ - * options - {Object} Default properties to be set on the protocol. │ │ │ │ + * Class: OpenLayers.Control.WMTSGetFeatureInfo │ │ │ │ + * The WMTSGetFeatureInfo control uses a WMTS query to get information about a │ │ │ │ + * point on the map. The information may be in a display-friendly format │ │ │ │ + * such as HTML, or a machine-friendly format such as GML, depending on the │ │ │ │ + * server's capabilities and the client's configuration. This control │ │ │ │ + * handles click or hover events, attempts to parse the results using an │ │ │ │ + * OpenLayers.Format, and fires a 'getfeatureinfo' event for each layer │ │ │ │ + * queried. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.WFS>} │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.WFS.fromWMSLayer = function(layer, options) { │ │ │ │ - var typeName, featurePrefix; │ │ │ │ - var param = layer.params["LAYERS"]; │ │ │ │ - var parts = (OpenLayers.Util.isArray(param) ? param[0] : param).split(":"); │ │ │ │ - if (parts.length > 1) { │ │ │ │ - featurePrefix = parts[0]; │ │ │ │ - } │ │ │ │ - typeName = parts.pop(); │ │ │ │ - var protocolOptions = { │ │ │ │ - url: layer.url, │ │ │ │ - featureType: typeName, │ │ │ │ - featurePrefix: featurePrefix, │ │ │ │ - srsName: layer.projection && layer.projection.getCode() || │ │ │ │ - layer.map && layer.map.getProjectionObject().getCode(), │ │ │ │ - version: "1.1.0" │ │ │ │ - }; │ │ │ │ - return new OpenLayers.Protocol.WFS(OpenLayers.Util.applyDefaults( │ │ │ │ - options, protocolOptions │ │ │ │ - )); │ │ │ │ -}; │ │ │ │ +OpenLayers.Control.WMTSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Protocol.WFS.DEFAULTS │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.WFS.DEFAULTS = { │ │ │ │ - "version": "1.0.0" │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Protocol/Script.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * APIProperty: hover │ │ │ │ + * {Boolean} Send GetFeatureInfo requests when mouse stops moving. │ │ │ │ + * Default is false. │ │ │ │ + */ │ │ │ │ + hover: false, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * Property: requestEncoding │ │ │ │ + * {String} One of "KVP" or "REST". Only KVP encoding is supported at this │ │ │ │ + * time. │ │ │ │ + */ │ │ │ │ + requestEncoding: "KVP", │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Protocol.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Format/GeoJSON.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: drillDown │ │ │ │ + * {Boolean} Drill down over all WMTS layers in the map. When │ │ │ │ + * using drillDown mode, hover is not possible. A getfeatureinfo event │ │ │ │ + * will be fired for each layer queried. │ │ │ │ + */ │ │ │ │ + drillDown: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * if application uses the query string, for example, for BBOX parameters, │ │ │ │ - * OpenLayers/Format/QueryStringFilter.js should be included in the build config file │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: maxFeatures │ │ │ │ + * {Integer} Maximum number of features to return from a WMTS query. This │ │ │ │ + * sets the feature_count parameter on WMTS GetFeatureInfo │ │ │ │ + * requests. │ │ │ │ + */ │ │ │ │ + maxFeatures: 10, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Protocol.Script │ │ │ │ - * A basic Script protocol for vector layers. Create a new instance with the │ │ │ │ - * <OpenLayers.Protocol.Script> constructor. A script protocol is used to │ │ │ │ - * get around the same origin policy. It works with services that return │ │ │ │ - * JSONP - that is, JSON wrapped in a client-specified callback. The │ │ │ │ - * protocol handles fetching and parsing of feature data and sends parsed │ │ │ │ - * features to the <callback> configured with the protocol. The protocol │ │ │ │ - * expects features serialized as GeoJSON by default, but can be configured │ │ │ │ - * to work with other formats by setting the <format> property. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol> │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + /** APIProperty: clickCallback │ │ │ │ + * {String} The click callback to register in the │ │ │ │ + * {<OpenLayers.Handler.Click>} object created when the hover │ │ │ │ + * option is set to false. Default is "click". │ │ │ │ + */ │ │ │ │ + clickCallback: "click", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} Service URL. The service is expected to return serialized │ │ │ │ - * features wrapped in a named callback (where the callback name is │ │ │ │ - * generated by this protocol). │ │ │ │ - * Read-only, set through the options passed to the constructor. │ │ │ │ + * Property: layers │ │ │ │ + * {Array(<OpenLayers.Layer.WMTS>)} The layers to query for feature info. │ │ │ │ + * If omitted, all map WMTS layers will be considered. │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: params │ │ │ │ - * {Object} Query string parameters to be appended to the URL. │ │ │ │ - * Read-only, set through the options passed to the constructor. │ │ │ │ - * Example: {maxFeatures: 50} │ │ │ │ + * APIProperty: queryVisible │ │ │ │ + * {Boolean} Filter out hidden layers when searching the map for layers to │ │ │ │ + * query. Default is true. │ │ │ │ */ │ │ │ │ - params: null, │ │ │ │ + queryVisible: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: callback │ │ │ │ - * {Object} Function to be called when the <read> operation completes. │ │ │ │ + * Property: infoFormat │ │ │ │ + * {String} The mimetype to request from the server │ │ │ │ */ │ │ │ │ - callback: null, │ │ │ │ + infoFormat: 'text/html', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: callbackTemplate │ │ │ │ - * {String} Template for creating a unique callback function name │ │ │ │ - * for the registry. Should include ${id}. The ${id} variable will be │ │ │ │ - * replaced with a string identifier prefixed with a "c" (e.g. c1, c2). │ │ │ │ - * Default is "OpenLayers.Protocol.Script.registry.${id}". │ │ │ │ + * Property: vendorParams │ │ │ │ + * {Object} Additional parameters that will be added to the request, for │ │ │ │ + * WMTS implementations that support them. This could e.g. look like │ │ │ │ + * (start code) │ │ │ │ + * { │ │ │ │ + * radius: 5 │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - callbackTemplate: "OpenLayers.Protocol.Script.registry.${id}", │ │ │ │ + vendorParams: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: callbackKey │ │ │ │ - * {String} The name of the query string parameter that the service │ │ │ │ - * recognizes as the callback identifier. Default is "callback". │ │ │ │ - * This key is used to generate the URL for the script. For example │ │ │ │ - * setting <callbackKey> to "myCallback" would result in a URL like │ │ │ │ - * http://example.com/?myCallback=... │ │ │ │ + * Property: format │ │ │ │ + * {<OpenLayers.Format>} A format for parsing GetFeatureInfo responses. │ │ │ │ + * Default is <OpenLayers.Format.WMSGetFeatureInfo>. │ │ │ │ */ │ │ │ │ - callbackKey: "callback", │ │ │ │ + format: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: callbackPrefix │ │ │ │ - * {String} Where a service requires that the callback query string │ │ │ │ - * parameter value is prefixed by some string, this value may be set. │ │ │ │ - * For example, setting <callbackPrefix> to "foo:" would result in a │ │ │ │ - * URL like http://example.com/?callback=foo:... Default is "". │ │ │ │ + * Property: formatOptions │ │ │ │ + * {Object} Optional properties to set on the format (if one is not provided │ │ │ │ + * in the <format> property. │ │ │ │ */ │ │ │ │ - callbackPrefix: "", │ │ │ │ + formatOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: scope │ │ │ │ - * {Object} Optional ``this`` object for the callback. Read-only, set │ │ │ │ - * through the options passed to the constructor. │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Additional options for the handlers used by this control, e.g. │ │ │ │ + * (start code) │ │ │ │ + * { │ │ │ │ + * "click": {delay: 100}, │ │ │ │ + * "hover": {delay: 300} │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - scope: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: format │ │ │ │ - * {<OpenLayers.Format>} Format for parsing features. Default is an │ │ │ │ - * <OpenLayers.Format.GeoJSON> format. If an alternative is provided, │ │ │ │ - * the format's read method must take an object and return an array │ │ │ │ - * of features. │ │ │ │ + * Property: handler │ │ │ │ + * {Object} Reference to the <OpenLayers.Handler> for this control │ │ │ │ */ │ │ │ │ - format: null, │ │ │ │ + handler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: pendingRequests │ │ │ │ - * {Object} References all pending requests. Property names are script │ │ │ │ - * identifiers and property values are script elements. │ │ │ │ + * Property: hoverRequest │ │ │ │ + * {<OpenLayers.Request>} contains the currently running hover request │ │ │ │ + * (if any). │ │ │ │ */ │ │ │ │ - pendingRequests: null, │ │ │ │ + hoverRequest: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: srsInBBOX │ │ │ │ - * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ - * Setting this property has no effect if a custom filterToParams method │ │ │ │ - * is provided. Default is false. If true and the layer has a │ │ │ │ - * projection object set, any BBOX filter will be serialized with a │ │ │ │ - * fifth item identifying the projection. │ │ │ │ - * E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforegetfeatureinfo - Triggered before each request is sent. │ │ │ │ + * The event object has an *xy* property with the position of the │ │ │ │ + * mouse click or hover event that triggers the request and a *layer* │ │ │ │ + * property referencing the layer about to be queried. If a listener │ │ │ │ + * returns false, the request will not be issued. │ │ │ │ + * getfeatureinfo - Triggered when a GetFeatureInfo response is received. │ │ │ │ + * The event object has a *text* property with the body of the │ │ │ │ + * response (String), a *features* property with an array of the │ │ │ │ + * parsed features, an *xy* property with the position of the mouse │ │ │ │ + * click or hover event that triggered the request, a *layer* property │ │ │ │ + * referencing the layer queried and a *request* property with the │ │ │ │ + * request itself. If drillDown is set to true, one event will be fired │ │ │ │ + * for each layer queried. │ │ │ │ + * exception - Triggered when a GetFeatureInfo request fails (with a │ │ │ │ + * status other than 200) or whenparsing fails. Listeners will receive │ │ │ │ + * an event with *request*, *xy*, and *layer* properties. In the case │ │ │ │ + * of a parsing error, the event will also contain an *error* property. │ │ │ │ */ │ │ │ │ - srsInBBOX: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: pending │ │ │ │ + * {Number} The number of pending requests. │ │ │ │ + */ │ │ │ │ + pending: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.Script │ │ │ │ - * A class for giving layers generic Script protocol. │ │ │ │ + * Constructor: <OpenLayers.Control.WMTSGetFeatureInfo> │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ - * Valid options include: │ │ │ │ - * url - {String} │ │ │ │ - * params - {Object} │ │ │ │ - * callback - {Function} │ │ │ │ - * scope - {Object} │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ options = options || {}; │ │ │ │ - this.params = {}; │ │ │ │ - this.pendingRequests = {}; │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + options.handlerOptions = options.handlerOptions || {}; │ │ │ │ + │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + │ │ │ │ if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.GeoJSON(); │ │ │ │ + this.format = new OpenLayers.Format.WMSGetFeatureInfo( │ │ │ │ + options.formatOptions │ │ │ │ + ); │ │ │ │ } │ │ │ │ │ │ │ │ - if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ - var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ - srsInBBOX: this.srsInBBOX │ │ │ │ - }); │ │ │ │ - this.filterToParams = function(filter, params) { │ │ │ │ - return format.write(filter, params); │ │ │ │ - }; │ │ │ │ + if (this.drillDown === true) { │ │ │ │ + this.hover = false; │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * url - {String} Url for the request. │ │ │ │ - * params - {Object} Parameters to get serialized as a query string. │ │ │ │ - * filter - {<OpenLayers.Filter>} Filter to get serialized as a │ │ │ │ - * query string. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property │ │ │ │ - * references the injected script. This object is also passed to the │ │ │ │ - * callback function when the request completes, its "features" property │ │ │ │ - * is then populated with the features received from the server. │ │ │ │ - */ │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - options.params = OpenLayers.Util.applyDefaults( │ │ │ │ - options.params, this.options.params │ │ │ │ - ); │ │ │ │ - if (options.filter && this.filterToParams) { │ │ │ │ - options.params = this.filterToParams( │ │ │ │ - options.filter, options.params │ │ │ │ + if (this.hover) { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover( │ │ │ │ + this, { │ │ │ │ + move: this.cancelHover, │ │ │ │ + pause: this.getInfoForHover │ │ │ │ + }, │ │ │ │ + OpenLayers.Util.extend( │ │ │ │ + this.handlerOptions.hover || {}, { │ │ │ │ + delay: 250 │ │ │ │ + } │ │ │ │ + ) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + var callbacks = {}; │ │ │ │ + callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ + this.handler = new OpenLayers.Handler.Click( │ │ │ │ + this, callbacks, this.handlerOptions.click || {} │ │ │ │ ); │ │ │ │ } │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - var request = this.createRequest( │ │ │ │ - options.url, │ │ │ │ - options.params, │ │ │ │ - OpenLayers.Function.bind(function(data) { │ │ │ │ - response.data = data; │ │ │ │ - this.handleRead(response, options); │ │ │ │ - }, this) │ │ │ │ - ); │ │ │ │ - response.priv = request; │ │ │ │ - return response; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: filterToParams │ │ │ │ - * Optional method to translate an <OpenLayers.Filter> object into an object │ │ │ │ - * that can be serialized as request query string provided. If a custom │ │ │ │ - * method is not provided, any filter will not be serialized. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ - * params - {Object} The parameters object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The resulting parameters object. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createRequest │ │ │ │ - * Issues a request for features by creating injecting a script in the │ │ │ │ - * document head. │ │ │ │ + /** │ │ │ │ + * Method: getInfoForClick │ │ │ │ + * Called on click │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * url - {String} Service URL. │ │ │ │ - * params - {Object} Query string parameters. │ │ │ │ - * callback - {Function} Callback to be called with resulting data. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {HTMLScriptElement} The script pending execution. │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - createRequest: function(url, params, callback) { │ │ │ │ - var id = OpenLayers.Protocol.Script.register(callback); │ │ │ │ - var name = OpenLayers.String.format(this.callbackTemplate, { │ │ │ │ - id: id │ │ │ │ - }); │ │ │ │ - params = OpenLayers.Util.extend({}, params); │ │ │ │ - params[this.callbackKey] = this.callbackPrefix + name; │ │ │ │ - url = OpenLayers.Util.urlAppend( │ │ │ │ - url, OpenLayers.Util.getParameterString(params) │ │ │ │ - ); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = "OpenLayers_Protocol_Script_" + id; │ │ │ │ - this.pendingRequests[script.id] = script; │ │ │ │ - var head = document.getElementsByTagName("head")[0]; │ │ │ │ - head.appendChild(script); │ │ │ │ - return script; │ │ │ │ + getInfoForClick: function(evt) { │ │ │ │ + this.request(evt.xy, {}); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroyRequest │ │ │ │ - * Remove a script node associated with a response from the document. Also │ │ │ │ - * unregisters the callback and removes the script from the │ │ │ │ - * <pendingRequests> object. │ │ │ │ + /** │ │ │ │ + * Method: getInfoForHover │ │ │ │ + * Pause callback for the hover handler │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * script - {HTMLScriptElement} │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - destroyRequest: function(script) { │ │ │ │ - OpenLayers.Protocol.Script.unregister(script.id.split("_").pop()); │ │ │ │ - delete this.pendingRequests[script.id]; │ │ │ │ - if (script.parentNode) { │ │ │ │ - script.parentNode.removeChild(script); │ │ │ │ - } │ │ │ │ + getInfoForHover: function(evt) { │ │ │ │ + this.request(evt.xy, { │ │ │ │ + hover: true │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRead │ │ │ │ - * Individual callbacks are created for read, create and update, should │ │ │ │ - * a subclass need to override each one separately. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * the user callback. │ │ │ │ - * options - {Object} The user options passed to the read call. │ │ │ │ + * Method: cancelHover │ │ │ │ + * Cancel callback for the hover handler │ │ │ │ */ │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - this.handleResponse(response, options); │ │ │ │ + cancelHover: function() { │ │ │ │ + if (this.hoverRequest) { │ │ │ │ + --this.pending; │ │ │ │ + if (this.pending <= 0) { │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + this.pending = 0; │ │ │ │ + } │ │ │ │ + this.hoverRequest.abort(); │ │ │ │ + this.hoverRequest = null; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleResponse │ │ │ │ - * Called by CRUD specific handlers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the create, read, update, │ │ │ │ - * or delete call. │ │ │ │ + * Method: findLayers │ │ │ │ + * Internal method to get the layers, independent of whether we are │ │ │ │ + * inspecting the map or using a client-provided array │ │ │ │ */ │ │ │ │ - handleResponse: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - if (response.data) { │ │ │ │ - response.features = this.parseFeatures(response.data); │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ - } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + findLayers: function() { │ │ │ │ + var candidates = this.layers || this.map.layers; │ │ │ │ + var layers = []; │ │ │ │ + var layer; │ │ │ │ + for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ + layer = candidates[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMTS && │ │ │ │ + layer.requestEncoding === this.requestEncoding && │ │ │ │ + (!this.queryVisible || layer.getVisibility())) { │ │ │ │ + layers.push(layer); │ │ │ │ + if (!this.drillDown || this.hover) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.destroyRequest(response.priv); │ │ │ │ - options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ + return layers; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeatures │ │ │ │ - * Read Script response body and return features. │ │ │ │ + * Method: buildRequestOptions │ │ │ │ + * Build an object with the relevant options for the GetFeatureInfo request. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * data - {Object} The data sent to the callback function by the server. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} Array of features or a single feature. │ │ │ │ + * layer - {<OpenLayers.Layer.WMTS>} A WMTS layer. │ │ │ │ + * xy - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ + * mouse event occurred. │ │ │ │ */ │ │ │ │ - parseFeatures: function(data) { │ │ │ │ - return this.format.read(data); │ │ │ │ + buildRequestOptions: function(layer, xy) { │ │ │ │ + var loc = this.map.getLonLatFromPixel(xy); │ │ │ │ + var getTileUrl = layer.getURL( │ │ │ │ + new OpenLayers.Bounds(loc.lon, loc.lat, loc.lon, loc.lat) │ │ │ │ + ); │ │ │ │ + var params = OpenLayers.Util.getParameters(getTileUrl); │ │ │ │ + var tileInfo = layer.getTileInfo(loc); │ │ │ │ + OpenLayers.Util.extend(params, { │ │ │ │ + service: "WMTS", │ │ │ │ + version: layer.version, │ │ │ │ + request: "GetFeatureInfo", │ │ │ │ + infoFormat: this.infoFormat, │ │ │ │ + i: tileInfo.i, │ │ │ │ + j: tileInfo.j │ │ │ │ + }); │ │ │ │ + OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ + return { │ │ │ │ + url: OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url, │ │ │ │ + params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ + callback: function(request) { │ │ │ │ + this.handleResponse(xy, request, layer); │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: abort │ │ │ │ - * Abort an ongoing request. If no response is provided, all pending │ │ │ │ - * requests will be aborted. │ │ │ │ - * │ │ │ │ + * Method: request │ │ │ │ + * Sends a GetFeatureInfo request to the WMTS │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object returned │ │ │ │ - * from a <read> request. │ │ │ │ + * xy - {<OpenLayers.Pixel>} The position on the map where the mouse event │ │ │ │ + * occurred. │ │ │ │ + * options - {Object} additional options for this method. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * - *hover* {Boolean} true if we do the request for the hover handler │ │ │ │ */ │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - this.destroyRequest(response.priv); │ │ │ │ - } else { │ │ │ │ - for (var key in this.pendingRequests) { │ │ │ │ - this.destroyRequest(this.pendingRequests[key]); │ │ │ │ + request: function(xy, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var layers = this.findLayers(); │ │ │ │ + if (layers.length > 0) { │ │ │ │ + var issue, layer; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + layer = layers[i]; │ │ │ │ + issue = this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ + xy: xy, │ │ │ │ + layer: layer │ │ │ │ + }); │ │ │ │ + if (issue !== false) { │ │ │ │ + ++this.pending; │ │ │ │ + var requestOptions = this.buildRequestOptions(layer, xy); │ │ │ │ + var request = OpenLayers.Request.GET(requestOptions); │ │ │ │ + if (options.hover === true) { │ │ │ │ + this.hoverRequest = request; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.pending > 0) { │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * Method: handleResponse │ │ │ │ + * Handler for the GetFeatureInfo response. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} The position on the map where the mouse event │ │ │ │ + * occurred. │ │ │ │ + * request - {XMLHttpRequest} The request object. │ │ │ │ + * layer - {<OpenLayers.Layer.WMTS>} The queried layer. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.abort(); │ │ │ │ - delete this.params; │ │ │ │ - delete this.format; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ + handleResponse: function(xy, request, layer) { │ │ │ │ + --this.pending; │ │ │ │ + if (this.pending <= 0) { │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + this.pending = 0; │ │ │ │ + } │ │ │ │ + if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ + this.events.triggerEvent("exception", { │ │ │ │ + xy: xy, │ │ │ │ + request: request, │ │ │ │ + layer: layer │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ + } │ │ │ │ + var features, except; │ │ │ │ + try { │ │ │ │ + features = this.format.read(doc); │ │ │ │ + } catch (error) { │ │ │ │ + except = true; │ │ │ │ + this.events.triggerEvent("exception", { │ │ │ │ + xy: xy, │ │ │ │ + request: request, │ │ │ │ + error: error, │ │ │ │ + layer: layer │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (!except) { │ │ │ │ + this.events.triggerEvent("getfeatureinfo", { │ │ │ │ + text: request.responseText, │ │ │ │ + features: features, │ │ │ │ + request: request, │ │ │ │ + xy: xy, │ │ │ │ + layer: layer │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.Script" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.WMTSGetFeatureInfo" │ │ │ │ }); │ │ │ │ - │ │ │ │ -(function() { │ │ │ │ - var o = OpenLayers.Protocol.Script; │ │ │ │ - var counter = 0; │ │ │ │ - o.registry = {}; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: OpenLayers.Protocol.Script.register │ │ │ │ - * Register a callback for a newly created script. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The callback to be executed when the newly added │ │ │ │ - * script loads. This callback will be called with a single argument │ │ │ │ - * that is the JSON returned by the service. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} An identifier for retrieving the registered callback. │ │ │ │ - */ │ │ │ │ - o.register = function(callback) { │ │ │ │ - var id = "c" + (++counter); │ │ │ │ - o.registry[id] = function() { │ │ │ │ - callback.apply(this, arguments); │ │ │ │ - }; │ │ │ │ - return id; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: OpenLayers.Protocol.Script.unregister │ │ │ │ - * Unregister a callback previously registered with the register function. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {Number} The identifer returned by the register function. │ │ │ │ - */ │ │ │ │ - o.unregister = function(id) { │ │ │ │ - delete o.registry[id]; │ │ │ │ - }; │ │ │ │ -})(); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol/CSW.js │ │ │ │ + OpenLayers/Control/WMSGetFeatureInfo.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Protocol.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Protocol.CSW │ │ │ │ - * Used to create a versioned CSW protocol. Default version is 2.0.2. │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.CSW = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults( │ │ │ │ - options, OpenLayers.Protocol.CSW.DEFAULTS │ │ │ │ - ); │ │ │ │ - var cls = OpenLayers.Protocol.CSW["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported CSW version: " + options.version; │ │ │ │ - } │ │ │ │ - return new cls(options); │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Protocol.CSW.DEFAULTS │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.CSW.DEFAULTS = { │ │ │ │ - "version": "2.0.2" │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Protocol/SOS.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Protocol.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Handler/Hover.js │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ + * @requires OpenLayers/Format/WMSGetFeatureInfo.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Function: OpenLayers.Protocol.SOS │ │ │ │ - * Used to create a versioned SOS protocol. Default version is 1.0.0. │ │ │ │ + * Class: OpenLayers.Control.WMSGetFeatureInfo │ │ │ │ + * The WMSGetFeatureInfo control uses a WMS query to get information about a point on the map. The │ │ │ │ + * information may be in a display-friendly format such as HTML, or a machine-friendly format such │ │ │ │ + * as GML, depending on the server's capabilities and the client's configuration. This control │ │ │ │ + * handles click or hover events, attempts to parse the results using an OpenLayers.Format, and │ │ │ │ + * fires a 'getfeatureinfo' event with the click position, the raw body of the response, and an │ │ │ │ + * array of features if it successfully read the response. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol>} An SOS protocol for the given version. │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.SOS = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults( │ │ │ │ - options, OpenLayers.Protocol.SOS.DEFAULTS │ │ │ │ - ); │ │ │ │ - var cls = OpenLayers.Protocol.SOS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported SOS version: " + options.version; │ │ │ │ - } │ │ │ │ - return new cls(options); │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Protocol.SOS.DEFAULTS │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.SOS.DEFAULTS = { │ │ │ │ - "version": "1.0.0" │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Protocol/HTTP.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ +OpenLayers.Control.WMSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Protocol.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: hover │ │ │ │ + * {Boolean} Send GetFeatureInfo requests when mouse stops moving. │ │ │ │ + * Default is false. │ │ │ │ + */ │ │ │ │ + hover: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * if application uses the query string, for example, for BBOX parameters, │ │ │ │ - * OpenLayers/Format/QueryStringFilter.js should be included in the build config file │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: drillDown │ │ │ │ + * {Boolean} Drill down over all WMS layers in the map. When │ │ │ │ + * using drillDown mode, hover is not possible, and an infoFormat that │ │ │ │ + * returns parseable features is required. Default is false. │ │ │ │ + */ │ │ │ │ + drillDown: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Protocol.HTTP │ │ │ │ - * A basic HTTP protocol for vector layers. Create a new instance with the │ │ │ │ - * <OpenLayers.Protocol.HTTP> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol> │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + /** │ │ │ │ + * APIProperty: maxFeatures │ │ │ │ + * {Integer} Maximum number of features to return from a WMS query. This │ │ │ │ + * sets the feature_count parameter on WMS GetFeatureInfo │ │ │ │ + * requests. │ │ │ │ + */ │ │ │ │ + maxFeatures: 10, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: url │ │ │ │ - * {String} Service URL, read-only, set through the options │ │ │ │ - * passed to constructor. │ │ │ │ + * APIProperty: clickCallback │ │ │ │ + * {String} The click callback to register in the │ │ │ │ + * {<OpenLayers.Handler.Click>} object created when the hover │ │ │ │ + * option is set to false. Default is "click". │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + clickCallback: "click", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: headers │ │ │ │ - * {Object} HTTP request headers, read-only, set through the options │ │ │ │ - * passed to the constructor, │ │ │ │ - * Example: {'Content-Type': 'plain/text'} │ │ │ │ + * APIProperty: output │ │ │ │ + * {String} Either "features" or "object". When triggering a getfeatureinfo │ │ │ │ + * request should we pass on an array of features or an object with with │ │ │ │ + * a "features" property and other properties (such as the url of the │ │ │ │ + * WMS). Default is "features". │ │ │ │ */ │ │ │ │ - headers: null, │ │ │ │ + output: "features", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: params │ │ │ │ - * {Object} Parameters of GET requests, read-only, set through the options │ │ │ │ - * passed to the constructor, │ │ │ │ - * Example: {'bbox': '5,5,5,5'} │ │ │ │ + * APIProperty: layers │ │ │ │ + * {Array(<OpenLayers.Layer.WMS>)} The layers to query for feature info. │ │ │ │ + * If omitted, all map WMS layers with a url that matches this <url> or │ │ │ │ + * <layerUrls> will be considered. │ │ │ │ */ │ │ │ │ - params: null, │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: callback │ │ │ │ - * {Object} Function to be called when the <read>, <create>, │ │ │ │ - * <update>, <delete> or <commit> operation completes, read-only, │ │ │ │ - * set through the options passed to the constructor. │ │ │ │ + * APIProperty: queryVisible │ │ │ │ + * {Boolean} If true, filter out hidden layers when searching the map for │ │ │ │ + * layers to query. Default is false. │ │ │ │ */ │ │ │ │ - callback: null, │ │ │ │ + queryVisible: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: scope │ │ │ │ - * {Object} Callback execution scope, read-only, set through the │ │ │ │ - * options passed to the constructor. │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} The URL of the WMS service to use. If not provided, the url │ │ │ │ + * of the first eligible layer will be used. │ │ │ │ */ │ │ │ │ - scope: null, │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: readWithPOST │ │ │ │ - * {Boolean} true if read operations are done with POST requests │ │ │ │ - * instead of GET, defaults to false. │ │ │ │ + * APIProperty: layerUrls │ │ │ │ + * {Array(String)} Optional list of urls for layers that should be queried. │ │ │ │ + * This can be used when the layer url differs from the url used for │ │ │ │ + * making GetFeatureInfo requests (in the case of a layer using cached │ │ │ │ + * tiles). │ │ │ │ */ │ │ │ │ - readWithPOST: false, │ │ │ │ + layerUrls: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: updateWithPOST │ │ │ │ - * {Boolean} true if update operations are done with POST requests │ │ │ │ - * defaults to false. │ │ │ │ + * APIProperty: infoFormat │ │ │ │ + * {String} The mimetype to request from the server. If you are using │ │ │ │ + * drillDown mode and have multiple servers that do not share a common │ │ │ │ + * infoFormat, you can override the control's infoFormat by providing an │ │ │ │ + * INFO_FORMAT parameter in your <OpenLayers.Layer.WMS> instance(s). │ │ │ │ */ │ │ │ │ - updateWithPOST: false, │ │ │ │ + infoFormat: 'text/html', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: deleteWithPOST │ │ │ │ - * {Boolean} true if delete operations are done with POST requests │ │ │ │ - * defaults to false. │ │ │ │ - * if true, POST data is set to output of format.write(). │ │ │ │ + * APIProperty: vendorParams │ │ │ │ + * {Object} Additional parameters that will be added to the request, for │ │ │ │ + * WMS implementations that support them. This could e.g. look like │ │ │ │ + * (start code) │ │ │ │ + * { │ │ │ │ + * radius: 5 │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - deleteWithPOST: false, │ │ │ │ + vendorParams: {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: wildcarded. │ │ │ │ - * {Boolean} If true percent signs are added around values │ │ │ │ - * read from LIKE filters, for example if the protocol │ │ │ │ - * read method is passed a LIKE filter whose property │ │ │ │ - * is "foo" and whose value is "bar" the string │ │ │ │ - * "foo__ilike=%bar%" will be sent in the query string; │ │ │ │ - * defaults to false. │ │ │ │ + * APIProperty: format │ │ │ │ + * {<OpenLayers.Format>} A format for parsing GetFeatureInfo responses. │ │ │ │ + * Default is <OpenLayers.Format.WMSGetFeatureInfo>. │ │ │ │ */ │ │ │ │ - wildcarded: false, │ │ │ │ + format: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: srsInBBOX │ │ │ │ - * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ - * Default is false. If true and the layer has a projection object set, │ │ │ │ - * any BBOX filter will be serialized with a fifth item identifying the │ │ │ │ - * projection. E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ + * APIProperty: formatOptions │ │ │ │ + * {Object} Optional properties to set on the format (if one is not provided │ │ │ │ + * in the <format> property. │ │ │ │ */ │ │ │ │ - srsInBBOX: false, │ │ │ │ + formatOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.HTTP │ │ │ │ - * A class for giving layers generic HTTP protocol. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ - * Valid options include: │ │ │ │ - * url - {String} │ │ │ │ - * headers - {Object} │ │ │ │ - * params - {Object} URL parameters for GET requests │ │ │ │ - * format - {<OpenLayers.Format>} │ │ │ │ - * callback - {Function} │ │ │ │ - * scope - {Object} │ │ │ │ + * APIProperty: handlerOptions │ │ │ │ + * {Object} Additional options for the handlers used by this control, e.g. │ │ │ │ + * (start code) │ │ │ │ + * { │ │ │ │ + * "click": {delay: 100}, │ │ │ │ + * "hover": {delay: 300} │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - this.params = {}; │ │ │ │ - this.headers = {}; │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ - var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ - wildcarded: this.wildcarded, │ │ │ │ - srsInBBOX: this.srsInBBOX │ │ │ │ - }); │ │ │ │ - this.filterToParams = function(filter, params) { │ │ │ │ - return format.write(filter, params); │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: handler │ │ │ │ + * {Object} Reference to the <OpenLayers.Handler> for this control │ │ │ │ + */ │ │ │ │ + handler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * Property: hoverRequest │ │ │ │ + * {<OpenLayers.Request>} contains the currently running hover request │ │ │ │ + * (if any). │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.params = null; │ │ │ │ - this.headers = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ - }, │ │ │ │ + hoverRequest: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: filterToParams │ │ │ │ - * Optional method to translate an <OpenLayers.Filter> object into an object │ │ │ │ - * that can be serialized as request query string provided. If a custom │ │ │ │ - * method is not provided, the filter will be serialized using the │ │ │ │ - * <OpenLayers.Format.QueryStringFilter> class. │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ - * params - {Object} The parameters object. │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The resulting parameters object. │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforegetfeatureinfo - Triggered before the request is sent. │ │ │ │ + * The event object has an *xy* property with the position of the │ │ │ │ + * mouse click or hover event that triggers the request. │ │ │ │ + * nogetfeatureinfo - no queryable layers were found. │ │ │ │ + * getfeatureinfo - Triggered when a GetFeatureInfo response is received. │ │ │ │ + * The event object has a *text* property with the body of the │ │ │ │ + * response (String), a *features* property with an array of the │ │ │ │ + * parsed features, an *xy* property with the position of the mouse │ │ │ │ + * click or hover event that triggered the request, and a *request* │ │ │ │ + * property with the request itself. If drillDown is set to true and │ │ │ │ + * multiple requests were issued to collect feature info from all │ │ │ │ + * layers, *text* and *request* will only contain the response body │ │ │ │ + * and request object of the last request. │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new features. │ │ │ │ + * Constructor: <OpenLayers.Control.WMSGetFeatureInfo> │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * url - {String} Url for the request. │ │ │ │ - * params - {Object} Parameters to get serialized as a query string. │ │ │ │ - * headers - {Object} Headers to be set on the request. │ │ │ │ - * filter - {<OpenLayers.Filter>} Filter to get serialized as a │ │ │ │ - * query string. │ │ │ │ - * readWithPOST - {Boolean} If the request should be done with POST. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property │ │ │ │ - * references the HTTP request, this object is also passed to the │ │ │ │ - * callback function when the request completes, its "features" property │ │ │ │ - * is then populated with the features received from the server. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + initialize: function(options) { │ │ │ │ options = options || {}; │ │ │ │ - options.params = OpenLayers.Util.applyDefaults( │ │ │ │ - options.params, this.options.params); │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - if (options.filter && this.filterToParams) { │ │ │ │ - options.params = this.filterToParams( │ │ │ │ - options.filter, options.params │ │ │ │ + options.handlerOptions = options.handlerOptions || {}; │ │ │ │ + │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + │ │ │ │ + if (!this.format) { │ │ │ │ + this.format = new OpenLayers.Format.WMSGetFeatureInfo( │ │ │ │ + options.formatOptions │ │ │ │ ); │ │ │ │ } │ │ │ │ - var readWithPOST = (options.readWithPOST !== undefined) ? │ │ │ │ - options.readWithPOST : this.readWithPOST; │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - if (readWithPOST) { │ │ │ │ - var headers = options.headers || {}; │ │ │ │ - headers["Content-Type"] = "application/x-www-form-urlencoded"; │ │ │ │ - resp.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ - data: OpenLayers.Util.getParameterString(options.params), │ │ │ │ - headers: headers │ │ │ │ - }); │ │ │ │ + │ │ │ │ + if (this.drillDown === true) { │ │ │ │ + this.hover = false; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.hover) { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover( │ │ │ │ + this, { │ │ │ │ + 'move': this.cancelHover, │ │ │ │ + 'pause': this.getInfoForHover │ │ │ │ + }, │ │ │ │ + OpenLayers.Util.extend(this.handlerOptions.hover || {}, { │ │ │ │ + 'delay': 250 │ │ │ │ + })); │ │ │ │ } else { │ │ │ │ - resp.priv = OpenLayers.Request.GET({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers │ │ │ │ - }); │ │ │ │ + var callbacks = {}; │ │ │ │ + callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ + this.handler = new OpenLayers.Handler.Click( │ │ │ │ + this, callbacks, this.handlerOptions.click || {}); │ │ │ │ } │ │ │ │ - return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRead │ │ │ │ - * Individual callbacks are created for read, create and update, should │ │ │ │ - * a subclass need to override each one separately. │ │ │ │ + * Method: getInfoForClick │ │ │ │ + * Called on click │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * the user callback. │ │ │ │ - * options - {Object} The user options passed to the read call. │ │ │ │ + * evt - {<OpenLayers.Event>} │ │ │ │ */ │ │ │ │ - handleRead: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + getInfoForClick: function(evt) { │ │ │ │ + this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ + xy: evt.xy │ │ │ │ + }); │ │ │ │ + // Set the cursor to "wait" to tell the user we're working on their │ │ │ │ + // click. │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + this.request(evt.xy, {}); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: create │ │ │ │ - * Construct a request for writing newly created features. │ │ │ │ + * Method: getInfoForHover │ │ │ │ + * Pause callback for the hover handler │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, whose "priv" property references the HTTP request, this │ │ │ │ - * object is also passed to the callback function when the request │ │ │ │ - * completes, its "features" property is then populated with the │ │ │ │ - * the features received from the server. │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - create: function(features, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: features, │ │ │ │ - requestType: "create" │ │ │ │ + getInfoForHover: function(evt) { │ │ │ │ + this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ + xy: evt.xy │ │ │ │ }); │ │ │ │ - │ │ │ │ - resp.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleCreate, resp, options), │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(features) │ │ │ │ + this.request(evt.xy, { │ │ │ │ + hover: true │ │ │ │ }); │ │ │ │ - │ │ │ │ - return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleCreate │ │ │ │ - * Called the the request issued by <create> is complete. May be overridden │ │ │ │ - * by subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the create call. │ │ │ │ + * Method: cancelHover │ │ │ │ + * Cancel callback for the hover handler │ │ │ │ */ │ │ │ │ - handleCreate: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + cancelHover: function() { │ │ │ │ + if (this.hoverRequest) { │ │ │ │ + this.hoverRequest.abort(); │ │ │ │ + this.hoverRequest = null; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: update │ │ │ │ - * Construct a request updating modified feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, whose "priv" property references the HTTP request, this │ │ │ │ - * object is also passed to the callback function when the request │ │ │ │ - * completes, its "features" property is then populated with the │ │ │ │ - * the feature received from the server. │ │ │ │ + * Method: findLayers │ │ │ │ + * Internal method to get the layers, independent of whether we are │ │ │ │ + * inspecting the map or using a client-provided array │ │ │ │ */ │ │ │ │ - update: function(feature, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var url = options.url || │ │ │ │ - feature.url || │ │ │ │ - this.options.url + "/" + feature.fid; │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: feature, │ │ │ │ - requestType: "update" │ │ │ │ - }); │ │ │ │ - │ │ │ │ - var method = this.updateWithPOST ? "POST" : "PUT"; │ │ │ │ - resp.priv = OpenLayers.Request[method]({ │ │ │ │ - url: url, │ │ │ │ - callback: this.createCallback(this.handleUpdate, resp, options), │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(feature) │ │ │ │ - }); │ │ │ │ - │ │ │ │ - return resp; │ │ │ │ - }, │ │ │ │ + findLayers: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleUpdate │ │ │ │ - * Called the the request issued by <update> is complete. May be overridden │ │ │ │ - * by subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the update call. │ │ │ │ - */ │ │ │ │ - handleUpdate: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + var candidates = this.layers || this.map.layers; │ │ │ │ + var layers = []; │ │ │ │ + var layer, url; │ │ │ │ + for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ + layer = candidates[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMS && │ │ │ │ + (!this.queryVisible || layer.getVisibility())) { │ │ │ │ + url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ + // if the control was not configured with a url, set it │ │ │ │ + // to the first layer url │ │ │ │ + if (this.drillDown === false && !this.url) { │ │ │ │ + this.url = url; │ │ │ │ + } │ │ │ │ + if (this.drillDown === true || this.urlMatches(url)) { │ │ │ │ + layers.push(layer); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return layers; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: delete │ │ │ │ - * Construct a request deleting a removed feature. │ │ │ │ + * Method: urlMatches │ │ │ │ + * Test to see if the provided url matches either the control <url> or one │ │ │ │ + * of the <layerUrls>. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ + * url - {String} The url to test. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, whose "priv" property references the HTTP request, this │ │ │ │ - * object is also passed to the callback function when the request │ │ │ │ - * completes. │ │ │ │ + * {Boolean} The provided url matches the control <url> or one of the │ │ │ │ + * <layerUrls>. │ │ │ │ */ │ │ │ │ - "delete": function(feature, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var url = options.url || │ │ │ │ - feature.url || │ │ │ │ - this.options.url + "/" + feature.fid; │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: feature, │ │ │ │ - requestType: "delete" │ │ │ │ - }); │ │ │ │ - │ │ │ │ - var method = this.deleteWithPOST ? "POST" : "DELETE"; │ │ │ │ - var requestOptions = { │ │ │ │ - url: url, │ │ │ │ - callback: this.createCallback(this.handleDelete, resp, options), │ │ │ │ - headers: options.headers │ │ │ │ - }; │ │ │ │ - if (this.deleteWithPOST) { │ │ │ │ - requestOptions.data = this.format.write(feature); │ │ │ │ + urlMatches: function(url) { │ │ │ │ + var matches = OpenLayers.Util.isEquivalentUrl(this.url, url); │ │ │ │ + if (!matches && this.layerUrls) { │ │ │ │ + for (var i = 0, len = this.layerUrls.length; i < len; ++i) { │ │ │ │ + if (OpenLayers.Util.isEquivalentUrl(this.layerUrls[i], url)) { │ │ │ │ + matches = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - resp.priv = OpenLayers.Request[method](requestOptions); │ │ │ │ - │ │ │ │ - return resp; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: handleDelete │ │ │ │ - * Called the the request issued by <delete> is complete. May be overridden │ │ │ │ - * by subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the delete call. │ │ │ │ - */ │ │ │ │ - handleDelete: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + return matches; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleResponse │ │ │ │ - * Called by CRUD specific handlers. │ │ │ │ + * Method: buildWMSOptions │ │ │ │ + * Build an object with the relevant WMS options for the GetFeatureInfo request │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the create, read, update, │ │ │ │ - * or delete call. │ │ │ │ + * url - {String} The url to be used for sending the request │ │ │ │ + * layers - {Array(<OpenLayers.Layer.WMS)} An array of layers │ │ │ │ + * clickPosition - {<OpenLayers.Pixel>} The position on the map where the mouse │ │ │ │ + * event occurred. │ │ │ │ + * format - {String} The format from the corresponding GetMap request │ │ │ │ */ │ │ │ │ - handleResponse: function(resp, options) { │ │ │ │ - var request = resp.priv; │ │ │ │ - if (options.callback) { │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - // success │ │ │ │ - if (resp.requestType != "delete") { │ │ │ │ - resp.features = this.parseFeatures(request); │ │ │ │ - } │ │ │ │ - resp.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ - } else { │ │ │ │ - // failure │ │ │ │ - resp.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + buildWMSOptions: function(url, layers, clickPosition, format) { │ │ │ │ + var layerNames = [], │ │ │ │ + styleNames = []; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + if (layers[i].params.LAYERS != null) { │ │ │ │ + layerNames = layerNames.concat(layers[i].params.LAYERS); │ │ │ │ + styleNames = styleNames.concat(this.getStyleNames(layers[i])); │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, resp); │ │ │ │ } │ │ │ │ + var firstLayer = layers[0]; │ │ │ │ + // use the firstLayer's projection if it matches the map projection - │ │ │ │ + // this assumes that all layers will be available in this projection │ │ │ │ + var projection = this.map.getProjection(); │ │ │ │ + var layerProj = firstLayer.projection; │ │ │ │ + if (layerProj && layerProj.equals(this.map.getProjectionObject())) { │ │ │ │ + projection = layerProj.getCode(); │ │ │ │ + } │ │ │ │ + var params = OpenLayers.Util.extend({ │ │ │ │ + service: "WMS", │ │ │ │ + version: firstLayer.params.VERSION, │ │ │ │ + request: "GetFeatureInfo", │ │ │ │ + exceptions: firstLayer.params.EXCEPTIONS, │ │ │ │ + bbox: this.map.getExtent().toBBOX(null, │ │ │ │ + firstLayer.reverseAxisOrder()), │ │ │ │ + feature_count: this.maxFeatures, │ │ │ │ + height: this.map.getSize().h, │ │ │ │ + width: this.map.getSize().w, │ │ │ │ + format: format, │ │ │ │ + info_format: firstLayer.params.INFO_FORMAT || this.infoFormat │ │ │ │ + }, (parseFloat(firstLayer.params.VERSION) >= 1.3) ? { │ │ │ │ + crs: projection, │ │ │ │ + i: parseInt(clickPosition.x), │ │ │ │ + j: parseInt(clickPosition.y) │ │ │ │ + } : { │ │ │ │ + srs: projection, │ │ │ │ + x: parseInt(clickPosition.x), │ │ │ │ + y: parseInt(clickPosition.y) │ │ │ │ + }); │ │ │ │ + if (layerNames.length != 0) { │ │ │ │ + params = OpenLayers.Util.extend({ │ │ │ │ + layers: layerNames, │ │ │ │ + query_layers: layerNames, │ │ │ │ + styles: styleNames │ │ │ │ + }, params); │ │ │ │ + } │ │ │ │ + OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ + return { │ │ │ │ + url: url, │ │ │ │ + params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ + callback: function(request) { │ │ │ │ + this.handleResponse(clickPosition, request, url); │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeatures │ │ │ │ - * Read HTTP response body and return features. │ │ │ │ + * Method: getStyleNames │ │ │ │ + * Gets the STYLES parameter for the layer. Make sure the STYLES parameter │ │ │ │ + * matches the LAYERS parameter │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * request - {XMLHttpRequest} The request object │ │ │ │ + * layer - {<OpenLayers.Layer.WMS>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} Array of features or a single feature. │ │ │ │ + * {Array(String)} The STYLES parameter │ │ │ │ */ │ │ │ │ - parseFeatures: function(request) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null; │ │ │ │ + getStyleNames: function(layer) { │ │ │ │ + // in the event of a WMS layer bundling multiple layers but not │ │ │ │ + // specifying styles,we need the same number of commas to specify │ │ │ │ + // the default style for each of the layers. We can't just leave it │ │ │ │ + // blank as we may be including other layers that do specify styles. │ │ │ │ + var styleNames; │ │ │ │ + if (layer.params.STYLES) { │ │ │ │ + styleNames = layer.params.STYLES; │ │ │ │ + } else { │ │ │ │ + if (OpenLayers.Util.isArray(layer.params.LAYERS)) { │ │ │ │ + styleNames = new Array(layer.params.LAYERS.length); │ │ │ │ + } else { // Assume it's a String │ │ │ │ + styleNames = layer.params.LAYERS.replace(/[^,]/g, ""); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return this.format.read(doc); │ │ │ │ + return styleNames; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: commit │ │ │ │ - * Iterate over each feature and take action based on the feature state. │ │ │ │ - * Possible actions are create, update and delete. │ │ │ │ + * Method: request │ │ │ │ + * Sends a GetFeatureInfo request to the WMS │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} │ │ │ │ - * options - {Object} Optional object for setting up intermediate commit │ │ │ │ - * callbacks. │ │ │ │ + * clickPosition - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ + * mouse event occurred. │ │ │ │ + * options - {Object} additional options for this method. │ │ │ │ * │ │ │ │ * Valid options: │ │ │ │ - * create - {Object} Optional object to be passed to the <create> method. │ │ │ │ - * update - {Object} Optional object to be passed to the <update> method. │ │ │ │ - * delete - {Object} Optional object to be passed to the <delete> method. │ │ │ │ - * callback - {Function} Optional function to be called when the commit │ │ │ │ - * is complete. │ │ │ │ - * scope - {Object} Optional object to be set as the scope of the callback. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Protocol.Response>)} An array of response objects, │ │ │ │ - * one per request made to the server, each object's "priv" property │ │ │ │ - * references the corresponding HTTP request. │ │ │ │ + * - *hover* {Boolean} true if we do the request for the hover handler │ │ │ │ */ │ │ │ │ - commit: function(features, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var resp = [], │ │ │ │ - nResponses = 0; │ │ │ │ - │ │ │ │ - // Divide up features before issuing any requests. This properly │ │ │ │ - // counts requests in the event that any responses come in before │ │ │ │ - // all requests have been issued. │ │ │ │ - var types = {}; │ │ │ │ - types[OpenLayers.State.INSERT] = []; │ │ │ │ - types[OpenLayers.State.UPDATE] = []; │ │ │ │ - types[OpenLayers.State.DELETE] = []; │ │ │ │ - var feature, list, requestFeatures = []; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - list = types[feature.state]; │ │ │ │ - if (list) { │ │ │ │ - list.push(feature); │ │ │ │ - requestFeatures.push(feature); │ │ │ │ - } │ │ │ │ + request: function(clickPosition, options) { │ │ │ │ + var layers = this.findLayers(); │ │ │ │ + if (layers.length == 0) { │ │ │ │ + this.events.triggerEvent("nogetfeatureinfo"); │ │ │ │ + // Reset the cursor. │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + return; │ │ │ │ } │ │ │ │ - // tally up number of requests │ │ │ │ - var nRequests = (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) + │ │ │ │ - types[OpenLayers.State.UPDATE].length + │ │ │ │ - types[OpenLayers.State.DELETE].length; │ │ │ │ │ │ │ │ - // This response will be sent to the final callback after all the others │ │ │ │ - // have been fired. │ │ │ │ - var success = true; │ │ │ │ - var finalResponse = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: requestFeatures │ │ │ │ - }); │ │ │ │ + options = options || {}; │ │ │ │ + if (this.drillDown === false) { │ │ │ │ + var wmsOptions = this.buildWMSOptions(this.url, layers, │ │ │ │ + clickPosition, layers[0].params.FORMAT); │ │ │ │ + var request = OpenLayers.Request.GET(wmsOptions); │ │ │ │ │ │ │ │ - function insertCallback(response) { │ │ │ │ - var len = response.features ? response.features.length : 0; │ │ │ │ - var fids = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - fids[i] = response.features[i].fid; │ │ │ │ + if (options.hover === true) { │ │ │ │ + this.hoverRequest = request; │ │ │ │ } │ │ │ │ - finalResponse.insertIds = fids; │ │ │ │ - callback.apply(this, [response]); │ │ │ │ - } │ │ │ │ - │ │ │ │ - function callback(response) { │ │ │ │ - this.callUserCallback(response, options); │ │ │ │ - success = success && response.success(); │ │ │ │ - nResponses++; │ │ │ │ - if (nResponses >= nRequests) { │ │ │ │ - if (options.callback) { │ │ │ │ - finalResponse.code = success ? │ │ │ │ - OpenLayers.Protocol.Response.SUCCESS : │ │ │ │ - OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - options.callback.apply(options.scope, [finalResponse]); │ │ │ │ + } else { │ │ │ │ + this._requestCount = 0; │ │ │ │ + this._numRequests = 0; │ │ │ │ + this.features = []; │ │ │ │ + // group according to service url to combine requests │ │ │ │ + var services = {}, │ │ │ │ + url; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + var service, found = false; │ │ │ │ + url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ + if (url in services) { │ │ │ │ + services[url].push(layer); │ │ │ │ + } else { │ │ │ │ + this._numRequests++; │ │ │ │ + services[url] = [layer]; │ │ │ │ } │ │ │ │ } │ │ │ │ + var layers; │ │ │ │ + for (var url in services) { │ │ │ │ + layers = services[url]; │ │ │ │ + var wmsOptions = this.buildWMSOptions(url, layers, │ │ │ │ + clickPosition, layers[0].params.FORMAT); │ │ │ │ + OpenLayers.Request.GET(wmsOptions); │ │ │ │ + } │ │ │ │ } │ │ │ │ - │ │ │ │ - // start issuing requests │ │ │ │ - var queue = types[OpenLayers.State.INSERT]; │ │ │ │ - if (queue.length > 0) { │ │ │ │ - resp.push(this.create( │ │ │ │ - queue, OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: insertCallback, │ │ │ │ - scope: this │ │ │ │ - }, options.create) │ │ │ │ - )); │ │ │ │ - } │ │ │ │ - queue = types[OpenLayers.State.UPDATE]; │ │ │ │ - for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ - resp.push(this.update( │ │ │ │ - queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: callback, │ │ │ │ - scope: this │ │ │ │ - }, options.update))); │ │ │ │ - } │ │ │ │ - queue = types[OpenLayers.State.DELETE]; │ │ │ │ - for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ - resp.push(this["delete"]( │ │ │ │ - queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: callback, │ │ │ │ - scope: this │ │ │ │ - }, options["delete"]))); │ │ │ │ - } │ │ │ │ - return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: abort │ │ │ │ - * Abort an ongoing request, the response object passed to │ │ │ │ - * this method must come from this HTTP protocol (as a result │ │ │ │ - * of a create, read, update, delete or commit operation). │ │ │ │ + * Method: triggerGetFeatureInfo │ │ │ │ + * Trigger the getfeatureinfo event when all is done │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} │ │ │ │ + * request - {XMLHttpRequest} The request object │ │ │ │ + * xy - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ + * mouse event occurred. │ │ │ │ + * features - {Array(<OpenLayers.Feature.Vector>)} or │ │ │ │ + * {Array({Object}) when output is "object". The object has a url and a │ │ │ │ + * features property which contains an array of features. │ │ │ │ */ │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - response.priv.abort(); │ │ │ │ - } │ │ │ │ + triggerGetFeatureInfo: function(request, xy, features) { │ │ │ │ + this.events.triggerEvent("getfeatureinfo", { │ │ │ │ + text: request.responseText, │ │ │ │ + features: features, │ │ │ │ + request: request, │ │ │ │ + xy: xy │ │ │ │ + }); │ │ │ │ + │ │ │ │ + // Reset the cursor. │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: callUserCallback │ │ │ │ - * This method is used from within the commit method each time an │ │ │ │ - * an HTTP response is received from the server, it is responsible │ │ │ │ - * for calling the user-supplied callbacks. │ │ │ │ + * Method: handleResponse │ │ │ │ + * Handler for the GetFeatureInfo response. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} │ │ │ │ - * options - {Object} The map of options passed to the commit call. │ │ │ │ + * xy - {<OpenLayers.Pixel>} The position on the map where the │ │ │ │ + * mouse event occurred. │ │ │ │ + * request - {XMLHttpRequest} The request object. │ │ │ │ + * url - {String} The url which was used for this request. │ │ │ │ */ │ │ │ │ - callUserCallback: function(resp, options) { │ │ │ │ - var opt = options[resp.requestType]; │ │ │ │ - if (opt && opt.callback) { │ │ │ │ - opt.callback.call(opt.scope, resp); │ │ │ │ + handleResponse: function(xy, request, url) { │ │ │ │ + │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ + } │ │ │ │ + var features = this.format.read(doc); │ │ │ │ + if (this.drillDown === false) { │ │ │ │ + this.triggerGetFeatureInfo(request, xy, features); │ │ │ │ + } else { │ │ │ │ + this._requestCount++; │ │ │ │ + if (this.output === "object") { │ │ │ │ + this._features = (this._features || []).concat({ │ │ │ │ + url: url, │ │ │ │ + features: features │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + this._features = (this._features || []).concat(features); │ │ │ │ + } │ │ │ │ + if (this._requestCount === this._numRequests) { │ │ │ │ + this.triggerGetFeatureInfo(request, xy, this._features.concat()); │ │ │ │ + delete this._features; │ │ │ │ + delete this._requestCount; │ │ │ │ + delete this._numRequests; │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.WMSGetFeatureInfo" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol/CSW/v2_0_2.js │ │ │ │ + OpenLayers/Control/Geolocate.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Protocol/CSW.js │ │ │ │ - * @requires OpenLayers/Format/CSWGetRecords/v2_0_2.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Projection.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol.CSW.v2_0_2 │ │ │ │ - * CS-W (Catalogue services for the Web) version 2.0.2 protocol. │ │ │ │ + * Class: OpenLayers.Control.Geolocate │ │ │ │ + * The Geolocate control wraps w3c geolocation API into control that can be │ │ │ │ + * bound to a map, and generate events on location update │ │ │ │ + * │ │ │ │ + * To use this control requires to load the proj4js library if the projection │ │ │ │ + * of the map is not EPSG:4326 or EPSG:900913. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.CSW.v2_0_2 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ +OpenLayers.Control.Geolocate = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: formatOptions │ │ │ │ - * {Object} Optional options for the format. If a format is not provided, │ │ │ │ - * this property can be used to extend the default format options. │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * locationupdated - Triggered when browser return a new position. Listeners will │ │ │ │ + * receive an object with a 'position' property which is the browser.geolocation.position │ │ │ │ + * native object, as well as a 'point' property which is the location transformed in the │ │ │ │ + * current map projection. │ │ │ │ + * locationfailed - Triggered when geolocation has failed │ │ │ │ + * locationuncapable - Triggered when control is activated on a browser │ │ │ │ + * which doesn't support geolocation │ │ │ │ */ │ │ │ │ - formatOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.CSW.v2_0_2 │ │ │ │ - * A class for CSW version 2.0.2 protocol management. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * Property: geolocation │ │ │ │ + * {Object} The geolocation engine, as a property to be possibly mocked. │ │ │ │ + * This is set lazily to avoid a memory leak in IE9. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!options.format) { │ │ │ │ - this.format = new OpenLayers.Format.CSWGetRecords.v2_0_2(OpenLayers.Util.extend({}, this.formatOptions)); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + geolocation: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * Property: available │ │ │ │ + * {Boolean} The navigator.geolocation object is available. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.options && !this.options.format) { │ │ │ │ - this.format.destroy(); │ │ │ │ - } │ │ │ │ - this.format = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ - }, │ │ │ │ + available: ('geolocation' in navigator), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read │ │ │ │ - * Construct a request for reading new records from the Catalogue. │ │ │ │ + * APIProperty: bind │ │ │ │ + * {Boolean} If true, map center will be set on location update. │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - │ │ │ │ - var data = this.format.write(options.params || options); │ │ │ │ - │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, response, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers, │ │ │ │ - data: data │ │ │ │ - }); │ │ │ │ - │ │ │ │ - return response; │ │ │ │ - }, │ │ │ │ + bind: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRead │ │ │ │ - * Deal with response from the read request. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ - * to the user callback. │ │ │ │ - * This response is given a code property, and optionally a data property. │ │ │ │ - * The latter represents the CSW records as returned by the call to │ │ │ │ - * the CSW format read method. │ │ │ │ - * options - {Object} The user options passed to the read call. │ │ │ │ + * APIProperty: watch │ │ │ │ + * {Boolean} If true, position will be update regularly. │ │ │ │ */ │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - // success │ │ │ │ - response.data = this.parseData(request); │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ - } else { │ │ │ │ - // failure │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - } │ │ │ │ - options.callback.call(options.scope, response); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + watch: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseData │ │ │ │ - * Read HTTP response body and return records │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * request - {XMLHttpRequest} The request object │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The CSW records as returned by the call to the format read method. │ │ │ │ + * APIProperty: geolocationOptions │ │ │ │ + * {Object} Options to pass to the navigator's geolocation API. See │ │ │ │ + * <http://dev.w3.org/geo/api/spec-source.html>. No specific │ │ │ │ + * option is passed to the geolocation API by default. │ │ │ │ */ │ │ │ │ - parseData: function(request) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - return this.format.read(doc); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.CSW.v2_0_2" │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Protocol/SOS/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Protocol/SOS.js │ │ │ │ - * @requires OpenLayers/Format/SOSGetFeatureOfInterest.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Protocol.SOS.v1_0_0 │ │ │ │ - * An SOS v1.0.0 Protocol for vector layers. Create a new instance with the │ │ │ │ - * <OpenLayers.Protocol.SOS.v1_0_0> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol> │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.SOS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + geolocationOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: fois │ │ │ │ - * {Array(String)} Array of features of interest (foi) │ │ │ │ + * Constructor: OpenLayers.Control.Geolocate │ │ │ │ + * Create a new control to deal with browser geolocation API │ │ │ │ + * │ │ │ │ */ │ │ │ │ - fois: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: formatOptions │ │ │ │ - * {Object} Optional options for the format. If a format is not provided, │ │ │ │ - * this property can be used to extend the default format options. │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - formatOptions: null, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.SOS │ │ │ │ - * A class for giving layers an SOS protocol. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * Method: activate │ │ │ │ + * Activates the control. │ │ │ │ * │ │ │ │ - * Valid options properties: │ │ │ │ - * url - {String} URL to send requests to (required). │ │ │ │ - * fois - {Array} The features of interest (required). │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively activated. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!options.format) { │ │ │ │ - this.format = new OpenLayers.Format.SOSGetFeatureOfInterest( │ │ │ │ - this.formatOptions); │ │ │ │ + activate: function() { │ │ │ │ + if (this.available && !this.geolocation) { │ │ │ │ + // set lazily to avoid IE9 memory leak │ │ │ │ + this.geolocation = navigator.geolocation; │ │ │ │ + } │ │ │ │ + if (!this.geolocation) { │ │ │ │ + this.events.triggerEvent("locationuncapable"); │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + if (this.watch) { │ │ │ │ + this.watchId = this.geolocation.watchPosition( │ │ │ │ + OpenLayers.Function.bind(this.geolocate, this), │ │ │ │ + OpenLayers.Function.bind(this.failure, this), │ │ │ │ + this.geolocationOptions │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.getCurrentLocation(); │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ } │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively deactivated. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.options && !this.options.format) { │ │ │ │ - this.format.destroy(); │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active && this.watchId !== null) { │ │ │ │ + this.geolocation.clearWatch(this.watchId); │ │ │ │ } │ │ │ │ - this.format = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new sensor positions. This is done by │ │ │ │ - * issuing one GetFeatureOfInterest request. │ │ │ │ + * Method: geolocate │ │ │ │ + * Activates the control. │ │ │ │ + * │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - var format = this.format; │ │ │ │ - var data = OpenLayers.Format.XML.prototype.write.apply(format, │ │ │ │ - [format.writeNode("sos:GetFeatureOfInterest", { │ │ │ │ - fois: this.fois │ │ │ │ - })] │ │ │ │ + geolocate: function(position) { │ │ │ │ + var center = new OpenLayers.LonLat( │ │ │ │ + position.coords.longitude, │ │ │ │ + position.coords.latitude │ │ │ │ + ).transform( │ │ │ │ + new OpenLayers.Projection("EPSG:4326"), │ │ │ │ + this.map.getProjectionObject() │ │ │ │ ); │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, response, options), │ │ │ │ - data: data │ │ │ │ + if (this.bind) { │ │ │ │ + this.map.setCenter(center); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("locationupdated", { │ │ │ │ + position: position, │ │ │ │ + point: new OpenLayers.Geometry.Point( │ │ │ │ + center.lon, center.lat │ │ │ │ + ) │ │ │ │ }); │ │ │ │ - return response; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRead │ │ │ │ - * Deal with response from the read request. │ │ │ │ + * APIMethod: getCurrentLocation │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ - * to the user callback. │ │ │ │ - * options - {Object} The user options passed to the read call. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Returns true if a event will be fired (successfull │ │ │ │ + * registration) │ │ │ │ */ │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - // success │ │ │ │ - response.features = this.parseFeatures(request); │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ - } else { │ │ │ │ - // failure │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - } │ │ │ │ - options.callback.call(options.scope, response); │ │ │ │ + getCurrentLocation: function() { │ │ │ │ + if (!this.active || this.watch) { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ + this.geolocation.getCurrentPosition( │ │ │ │ + OpenLayers.Function.bind(this.geolocate, this), │ │ │ │ + OpenLayers.Function.bind(this.failure, this), │ │ │ │ + this.geolocationOptions │ │ │ │ + ); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeatures │ │ │ │ - * Read HTTP response body and return features │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * request - {XMLHttpRequest} The request object │ │ │ │ + * Method: failure │ │ │ │ + * method called on browser's geolocation failure │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Array({<OpenLayers.Feature.Vector>})} Array of features │ │ │ │ */ │ │ │ │ - parseFeatures: function(request) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - return this.format.read(doc); │ │ │ │ + failure: function(error) { │ │ │ │ + this.events.triggerEvent("locationfailed", { │ │ │ │ + error: error │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.SOS.v1_0_0" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Geolocate" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol/WFS/v1.js │ │ │ │ + OpenLayers/Control/Snapping.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Protocol/WFS.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Layer/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol.WFS.v1 │ │ │ │ - * Abstract class for for v1.0.0 and v1.1.0 protocol. │ │ │ │ + * Class: OpenLayers.Control.Snapping │ │ │ │ + * Acts as a snapping agent while editing vector features. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.WFS.v1 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: version │ │ │ │ - * {String} WFS version number. │ │ │ │ - */ │ │ │ │ - version: null, │ │ │ │ +OpenLayers.Control.Snapping = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: srsName │ │ │ │ - * {String} Name of spatial reference system. Default is "EPSG:4326". │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforesnap - Triggered before a snap occurs. Listeners receive an │ │ │ │ + * event object with *point*, *x*, *y*, *distance*, *layer*, and │ │ │ │ + * *snapType* properties. The point property will be original point │ │ │ │ + * geometry considered for snapping. The x and y properties represent │ │ │ │ + * coordinates the point will receive. The distance is the distance │ │ │ │ + * of the snap. The layer is the target layer. The snapType property │ │ │ │ + * will be one of "node", "vertex", or "edge". Return false to stop │ │ │ │ + * snapping from occurring. │ │ │ │ + * snap - Triggered when a snap occurs. Listeners receive an event with │ │ │ │ + * *point*, *snapType*, *layer*, and *distance* properties. The point │ │ │ │ + * will be the location snapped to. The snapType will be one of "node", │ │ │ │ + * "vertex", or "edge". The layer will be the target layer. The │ │ │ │ + * distance will be the distance of the snap in map units. │ │ │ │ + * unsnap - Triggered when a vertex is unsnapped. Listeners receive an │ │ │ │ + * event with a *point* property. │ │ │ │ */ │ │ │ │ - srsName: "EPSG:4326", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: featureType │ │ │ │ - * {String} Local feature typeName. │ │ │ │ + * CONSTANT: DEFAULTS │ │ │ │ + * Default target properties. │ │ │ │ */ │ │ │ │ - featureType: null, │ │ │ │ + DEFAULTS: { │ │ │ │ + tolerance: 10, │ │ │ │ + node: true, │ │ │ │ + edge: true, │ │ │ │ + vertex: true │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: featureNS │ │ │ │ - * {String} Feature namespace. │ │ │ │ + * Property: greedy │ │ │ │ + * {Boolean} Snap to closest feature in first layer with an eligible │ │ │ │ + * feature. Default is true. │ │ │ │ */ │ │ │ │ - featureNS: null, │ │ │ │ + greedy: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: geometryName │ │ │ │ - * {String} Name of the geometry attribute for features. Default is │ │ │ │ - * "the_geom" for WFS <version> 1.0, and null for higher versions. │ │ │ │ + * Property: precedence │ │ │ │ + * {Array} List representing precedence of different snapping types. │ │ │ │ + * Default is "node", "vertex", "edge". │ │ │ │ */ │ │ │ │ - geometryName: "the_geom", │ │ │ │ + precedence: ["node", "vertex", "edge"], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: maxFeatures │ │ │ │ - * {Integer} Optional maximum number of features to retrieve. │ │ │ │ + * Property: resolution │ │ │ │ + * {Float} The map resolution for the previously considered snap. │ │ │ │ */ │ │ │ │ + resolution: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: schema │ │ │ │ - * {String} Optional schema location that will be included in the │ │ │ │ - * schemaLocation attribute value. Note that the feature type schema │ │ │ │ - * is required for a strict XML validator (on transactions with an │ │ │ │ - * insert for example), but is *not* required by the WFS specification │ │ │ │ - * (since the server is supposed to know about feature type schemas). │ │ │ │ + * Property: geoToleranceCache │ │ │ │ + * {Object} A cache of geo-tolerances. Tolerance values (in map units) are │ │ │ │ + * calculated when the map resolution changes. │ │ │ │ */ │ │ │ │ - schema: null, │ │ │ │ + geoToleranceCache: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: featurePrefix │ │ │ │ - * {String} Namespace alias for feature type. Default is "feature". │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The current editable layer. Set at │ │ │ │ + * construction or after construction with <setLayer>. │ │ │ │ */ │ │ │ │ - featurePrefix: "feature", │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: formatOptions │ │ │ │ - * {Object} Optional options for the format. If a format is not provided, │ │ │ │ - * this property can be used to extend the default format options. │ │ │ │ - */ │ │ │ │ - formatOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: readFormat │ │ │ │ - * {<OpenLayers.Format>} For WFS requests it is possible to get a │ │ │ │ - * different output format than GML. In that case, we cannot parse │ │ │ │ - * the response with the default format (WFST) and we need a different │ │ │ │ - * format for reading. │ │ │ │ + * Property: feature │ │ │ │ + * {<OpenLayers.Feature.Vector>} The current editable feature. │ │ │ │ */ │ │ │ │ - readFormat: null, │ │ │ │ + feature: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: readOptions │ │ │ │ - * {Object} Optional object to pass to format's read. │ │ │ │ + * Property: point │ │ │ │ + * {<OpenLayers.Geometry.Point>} The currently snapped vertex. │ │ │ │ */ │ │ │ │ - readOptions: null, │ │ │ │ + point: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.WFS │ │ │ │ - * A class for giving layers WFS protocol. │ │ │ │ + * Constructor: OpenLayers.Control.Snapping │ │ │ │ + * Creates a new snapping control. A control is constructed with an editable │ │ │ │ + * layer and a set of configuration objects for target layers. While the │ │ │ │ + * control is active, dragging vertices while drawing new features or │ │ │ │ + * modifying existing features on the editable layer will engage │ │ │ │ + * snapping to features on the target layers. Whether a vertex snaps to │ │ │ │ + * a feature on a target layer depends on the target layer configuration. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * options - {Object} An object containing all configuration properties for │ │ │ │ + * the control. │ │ │ │ * │ │ │ │ - * Valid options properties: │ │ │ │ - * url - {String} URL to send requests to (required). │ │ │ │ - * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ - * featureNS - {String} Feature namespace (required, but can be autodetected │ │ │ │ - * during the first query if GML is used as readFormat and │ │ │ │ - * featurePrefix is provided and matches the prefix used by the server │ │ │ │ - * for this featureType). │ │ │ │ - * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ - * for writing if featureNS is provided). Default is 'feature'. │ │ │ │ - * geometryName - {String} Name of geometry attribute. The default is │ │ │ │ - * 'the_geom' for WFS <version> 1.0, and null for higher versions. If │ │ │ │ - * null, it will be set to the name of the first geometry found in the │ │ │ │ - * first read operation. │ │ │ │ - * multi - {Boolean} If set to true, geometries will be casted to Multi │ │ │ │ - * geometries before they are written in a transaction. No casting will │ │ │ │ - * be done when reading features. │ │ │ │ + * Valid options: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} The editable layer. Features from this │ │ │ │ + * layer that are digitized or modified may have vertices snapped to │ │ │ │ + * features from any of the target layers. │ │ │ │ + * targets - {Array(Object | OpenLayers.Layer.Vector)} A list of objects for │ │ │ │ + * configuring target layers. See valid properties of the target │ │ │ │ + * objects below. If the items in the targets list are vector layers │ │ │ │ + * (instead of configuration objects), the defaults from the <defaults> │ │ │ │ + * property will apply. The editable layer itself may be a target │ │ │ │ + * layer, allowing newly created or edited features to be snapped to │ │ │ │ + * existing features from the same layer. If no targets are provided │ │ │ │ + * the layer given in the constructor (as <layer>) will become the │ │ │ │ + * initial target. │ │ │ │ + * defaults - {Object} An object with default properties to be applied │ │ │ │ + * to all target objects. │ │ │ │ + * greedy - {Boolean} Snap to closest feature in first target layer that │ │ │ │ + * applies. Default is true. If false, all features in all target │ │ │ │ + * layers will be checked and the closest feature in all target layers │ │ │ │ + * will be chosen. The greedy property determines if the order of the │ │ │ │ + * target layers is significant. By default, the order of the target │ │ │ │ + * layers is significant where layers earlier in the target layer list │ │ │ │ + * have precedence over layers later in the list. Within a single │ │ │ │ + * layer, the closest feature is always chosen for snapping. This │ │ │ │ + * property only determines whether the search for a closer feature │ │ │ │ + * continues after an eligible feature is found in a target layer. │ │ │ │ + * │ │ │ │ + * Valid target properties: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} A target layer. Features from this │ │ │ │ + * layer will be eligible to act as snapping target for the editable │ │ │ │ + * layer. │ │ │ │ + * tolerance - {Float} The distance (in pixels) at which snapping may occur. │ │ │ │ + * Default is 10. │ │ │ │ + * node - {Boolean} Snap to nodes (first or last point in a geometry) in │ │ │ │ + * target layer. Default is true. │ │ │ │ + * nodeTolerance - {Float} Optional distance at which snapping may occur │ │ │ │ + * for nodes specifically. If none is provided, <tolerance> will be │ │ │ │ + * used. │ │ │ │ + * vertex - {Boolean} Snap to vertices in target layer. Default is true. │ │ │ │ + * vertexTolerance - {Float} Optional distance at which snapping may occur │ │ │ │ + * for vertices specifically. If none is provided, <tolerance> will be │ │ │ │ + * used. │ │ │ │ + * edge - {Boolean} Snap to edges in target layer. Default is true. │ │ │ │ + * edgeTolerance - {Float} Optional distance at which snapping may occur │ │ │ │ + * for edges specifically. If none is provided, <tolerance> will be │ │ │ │ + * used. │ │ │ │ + * filter - {<OpenLayers.Filter>} Optional filter to evaluate to determine if │ │ │ │ + * feature is eligible for snapping. If filter evaluates to true for a │ │ │ │ + * target feature a vertex may be snapped to the feature. │ │ │ │ + * minResolution - {Number} If a minResolution is provided, snapping to this │ │ │ │ + * target will only be considered if the map resolution is greater than │ │ │ │ + * or equal to this value (the minResolution is inclusive). Default is │ │ │ │ + * no minimum resolution limit. │ │ │ │ + * maxResolution - {Number} If a maxResolution is provided, snapping to this │ │ │ │ + * target will only be considered if the map resolution is strictly │ │ │ │ + * less than this value (the maxResolution is exclusive). Default is │ │ │ │ + * no maximum resolution limit. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!options.format) { │ │ │ │ - this.format = OpenLayers.Format.WFST(OpenLayers.Util.extend({ │ │ │ │ - version: this.version, │ │ │ │ - featureType: this.featureType, │ │ │ │ - featureNS: this.featureNS, │ │ │ │ - featurePrefix: this.featurePrefix, │ │ │ │ - geometryName: this.geometryName, │ │ │ │ - srsName: this.srsName, │ │ │ │ - schema: this.schema │ │ │ │ - }, this.formatOptions)); │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options || {}; // TODO: this could be done by the super │ │ │ │ + │ │ │ │ + // set the editable layer if provided │ │ │ │ + if (this.options.layer) { │ │ │ │ + this.setLayer(this.options.layer); │ │ │ │ } │ │ │ │ - if (!options.geometryName && parseFloat(this.format.version) > 1.0) { │ │ │ │ - this.setGeometryName(null); │ │ │ │ + // configure target layers │ │ │ │ + var defaults = OpenLayers.Util.extend({}, this.options.defaults); │ │ │ │ + this.defaults = OpenLayers.Util.applyDefaults(defaults, this.DEFAULTS); │ │ │ │ + this.setTargets(this.options.targets); │ │ │ │ + if (this.targets.length === 0 && this.layer) { │ │ │ │ + this.addTargetLayer(this.layer); │ │ │ │ } │ │ │ │ + │ │ │ │ + this.geoToleranceCache = {}; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * APIMethod: setLayer │ │ │ │ + * Set the editable layer. Call the setLayer method if the editable layer │ │ │ │ + * changes and the same control should be used on a new editable layer. │ │ │ │ + * If the control is already active, it will be active after the new │ │ │ │ + * layer is set. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} The new editable layer. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.options && !this.options.format) { │ │ │ │ - this.format.destroy(); │ │ │ │ + setLayer: function(layer) { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = layer; │ │ │ │ + this.activate(); │ │ │ │ + } else { │ │ │ │ + this.layer = layer; │ │ │ │ } │ │ │ │ - this.format = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new features. Since WFS splits the │ │ │ │ - * basic CRUD operations into GetFeature requests (for read) and │ │ │ │ - * Transactions (for all others), this method does not make use of the │ │ │ │ - * format's read method (that is only about reading transaction │ │ │ │ - * responses). │ │ │ │ + * Method: setTargets │ │ │ │ + * Set the targets for the snapping agent. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Options for the read operation, in addition to the │ │ │ │ - * options set on the instance (options set here will take precedence). │ │ │ │ - * │ │ │ │ - * To use a configured protocol to get e.g. a WFS hit count, applications │ │ │ │ - * could do the following: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * protocol.read({ │ │ │ │ - * readOptions: {output: "object"}, │ │ │ │ - * resultType: "hits", │ │ │ │ - * maxFeatures: null, │ │ │ │ - * callback: function(resp) { │ │ │ │ - * // process resp.numberOfFeatures here │ │ │ │ - * } │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * To use a configured protocol to use WFS paging (if supported by the │ │ │ │ - * server), applications could do the following: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * protocol.read({ │ │ │ │ - * startIndex: 0, │ │ │ │ - * count: 50 │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * To limit the attributes returned by the GetFeature request, applications │ │ │ │ - * can use the propertyNames option to specify the properties to include in │ │ │ │ - * the response: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * protocol.read({ │ │ │ │ - * propertyNames: ["DURATION", "INTENSITY"] │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ + * targets - {Array} An array of target configs or target layers. │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - │ │ │ │ - var data = OpenLayers.Format.XML.prototype.write.apply( │ │ │ │ - this.format, [this.format.writeNode("wfs:GetFeature", options)] │ │ │ │ - ); │ │ │ │ - │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, response, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers, │ │ │ │ - data: data │ │ │ │ - }); │ │ │ │ - │ │ │ │ - return response; │ │ │ │ + setTargets: function(targets) { │ │ │ │ + this.targets = []; │ │ │ │ + if (targets && targets.length) { │ │ │ │ + var target; │ │ │ │ + for (var i = 0, len = targets.length; i < len; ++i) { │ │ │ │ + target = targets[i]; │ │ │ │ + if (target instanceof OpenLayers.Layer.Vector) { │ │ │ │ + this.addTargetLayer(target); │ │ │ │ + } else { │ │ │ │ + this.addTarget(target); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setFeatureType │ │ │ │ - * Change the feature type on the fly. │ │ │ │ + * Method: addTargetLayer │ │ │ │ + * Add a target layer with the default target config. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * featureType - {String} Local (without prefix) feature typeName. │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} A target layer. │ │ │ │ */ │ │ │ │ - setFeatureType: function(featureType) { │ │ │ │ - this.featureType = featureType; │ │ │ │ - this.format.featureType = featureType; │ │ │ │ + addTargetLayer: function(layer) { │ │ │ │ + this.addTarget({ │ │ │ │ + layer: layer │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: setGeometryName │ │ │ │ - * Sets the geometryName option after instantiation. │ │ │ │ + * Method: addTarget │ │ │ │ + * Add a configured target layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometryName - {String} Name of geometry attribute. │ │ │ │ + * target - {Object} A target config. │ │ │ │ */ │ │ │ │ - setGeometryName: function(geometryName) { │ │ │ │ - this.geometryName = geometryName; │ │ │ │ - this.format.geometryName = geometryName; │ │ │ │ + addTarget: function(target) { │ │ │ │ + target = OpenLayers.Util.applyDefaults(target, this.defaults); │ │ │ │ + target.nodeTolerance = target.nodeTolerance || target.tolerance; │ │ │ │ + target.vertexTolerance = target.vertexTolerance || target.tolerance; │ │ │ │ + target.edgeTolerance = target.edgeTolerance || target.tolerance; │ │ │ │ + this.targets.push(target); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRead │ │ │ │ - * Deal with response from the read request. │ │ │ │ + * Method: removeTargetLayer │ │ │ │ + * Remove a target layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ - * to the user callback. │ │ │ │ - * options - {Object} The user options passed to the read call. │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} The target layer to remove. │ │ │ │ */ │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - // success │ │ │ │ - var result = this.parseResponse(request, options.readOptions); │ │ │ │ - if (result && result.success !== false) { │ │ │ │ - if (options.readOptions && options.readOptions.output == "object") { │ │ │ │ - OpenLayers.Util.extend(response, result); │ │ │ │ - } else { │ │ │ │ - response.features = result; │ │ │ │ - } │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ - } else { │ │ │ │ - // failure (service exception) │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - response.error = result; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // failure │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + removeTargetLayer: function(layer) { │ │ │ │ + var target; │ │ │ │ + for (var i = this.targets.length - 1; i >= 0; --i) { │ │ │ │ + target = this.targets[i]; │ │ │ │ + if (target.layer === layer) { │ │ │ │ + this.removeTarget(target); │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, response); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseResponse │ │ │ │ - * Read HTTP response body and return features │ │ │ │ + * Method: removeTarget │ │ │ │ + * Remove a target. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * request - {XMLHttpRequest} The request object │ │ │ │ - * options - {Object} Optional object to pass to format's read │ │ │ │ + * target - {Object} A target config. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} or {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - * An object with a features property, an array of features or a single │ │ │ │ - * feature. │ │ │ │ + * {Array} The targets array. │ │ │ │ */ │ │ │ │ - parseResponse: function(request, options) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null; │ │ │ │ + removeTarget: function(target) { │ │ │ │ + return OpenLayers.Util.removeItem(this.targets, target); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + * Activate the control. Activating the control registers listeners for │ │ │ │ + * editing related events so that during feature creation and │ │ │ │ + * modification, moving vertices will trigger snapping. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (this.layer && this.layer.events) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + sketchstarted: this.onSketchModified, │ │ │ │ + sketchmodified: this.onSketchModified, │ │ │ │ + vertexmodified: this.onVertexModified, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - var result = (this.readFormat !== null) ? this.readFormat.read(doc) : │ │ │ │ - this.format.read(doc, options); │ │ │ │ - if (!this.featureNS) { │ │ │ │ - var format = this.readFormat || this.format; │ │ │ │ - this.featureNS = format.featureNS; │ │ │ │ - // no need to auto-configure again on subsequent reads │ │ │ │ - format.autoConfig = false; │ │ │ │ - if (!this.geometryName) { │ │ │ │ - this.setGeometryName(format.geometryName); │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the control. Deactivating the control unregisters listeners │ │ │ │ + * so feature editing may proceed without engaging the snapping agent. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + if (this.layer && this.layer.events) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + sketchstarted: this.onSketchModified, │ │ │ │ + sketchmodified: this.onSketchModified, │ │ │ │ + vertexmodified: this.onVertexModified, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ } │ │ │ │ - return result; │ │ │ │ + this.feature = null; │ │ │ │ + this.point = null; │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: commit │ │ │ │ - * Given a list of feature, assemble a batch request for update, create, │ │ │ │ - * and delete transactions. A commit call on the prototype amounts │ │ │ │ - * to writing a WFS transaction - so the write method on the format │ │ │ │ - * is used. │ │ │ │ + * Method: onSketchModified │ │ │ │ + * Registered as a listener for the sketchmodified event on the editable │ │ │ │ + * layer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array(<OpenLayers.Feature.Vector>)} │ │ │ │ - * options - {Object} │ │ │ │ - * │ │ │ │ - * Valid options properties: │ │ │ │ - * nativeElements - {Array({Object})} Array of objects with information for writing │ │ │ │ - * out <Native> elements, these objects have vendorId, safeToIgnore and │ │ │ │ - * value properties. The <Native> element is intended to allow access to │ │ │ │ - * vendor specific capabilities of any particular web feature server or │ │ │ │ - * datastore. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} A response object with a features │ │ │ │ - * property containing any insertIds and a priv property referencing │ │ │ │ - * the XMLHttpRequest object. │ │ │ │ + * event - {Object} The sketch modified event. │ │ │ │ */ │ │ │ │ - commit: function(features, options) { │ │ │ │ - │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "commit", │ │ │ │ - reqFeatures: features │ │ │ │ - }); │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(features, options), │ │ │ │ - callback: this.createCallback(this.handleCommit, response, options) │ │ │ │ - }); │ │ │ │ - │ │ │ │ - return response; │ │ │ │ + onSketchModified: function(event) { │ │ │ │ + this.feature = event.feature; │ │ │ │ + this.considerSnapping(event.vertex, event.vertex); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleCommit │ │ │ │ - * Called when the commit request returns. │ │ │ │ - * │ │ │ │ + * Method: onVertexModified │ │ │ │ + * Registered as a listener for the vertexmodified event on the editable │ │ │ │ + * layer. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The response object to pass │ │ │ │ - * to the user callback. │ │ │ │ - * options - {Object} The user options passed to the commit call. │ │ │ │ + * event - {Object} The vertex modified event. │ │ │ │ */ │ │ │ │ - handleCommit: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ + onVertexModified: function(event) { │ │ │ │ + this.feature = event.feature; │ │ │ │ + var loc = this.layer.map.getLonLatFromViewPortPx(event.pixel); │ │ │ │ + this.considerSnapping( │ │ │ │ + event.vertex, new OpenLayers.Geometry.Point(loc.lon, loc.lat) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // ensure that we have an xml doc │ │ │ │ - var data = request.responseXML; │ │ │ │ - if (!data || !data.documentElement) { │ │ │ │ - data = request.responseText; │ │ │ │ + /** │ │ │ │ + * Method: considerSnapping │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} The vertex to be snapped (or │ │ │ │ + * unsnapped). │ │ │ │ + * loc - {<OpenLayers.Geometry.Point>} The location of the mouse in map │ │ │ │ + * coords. │ │ │ │ + */ │ │ │ │ + considerSnapping: function(point, loc) { │ │ │ │ + var best = { │ │ │ │ + rank: Number.POSITIVE_INFINITY, │ │ │ │ + dist: Number.POSITIVE_INFINITY, │ │ │ │ + x: null, │ │ │ │ + y: null │ │ │ │ + }; │ │ │ │ + var snapped = false; │ │ │ │ + var result, target; │ │ │ │ + for (var i = 0, len = this.targets.length; i < len; ++i) { │ │ │ │ + target = this.targets[i]; │ │ │ │ + result = this.testTarget(target, loc); │ │ │ │ + if (result) { │ │ │ │ + if (this.greedy) { │ │ │ │ + best = result; │ │ │ │ + best.target = target; │ │ │ │ + snapped = true; │ │ │ │ + break; │ │ │ │ + } else { │ │ │ │ + if ((result.rank < best.rank) || │ │ │ │ + (result.rank === best.rank && result.dist < best.dist)) { │ │ │ │ + best = result; │ │ │ │ + best.target = target; │ │ │ │ + snapped = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - │ │ │ │ - var obj = this.format.read(data) || {}; │ │ │ │ - │ │ │ │ - response.insertIds = obj.insertIds || []; │ │ │ │ - if (obj.success) { │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } │ │ │ │ + if (snapped) { │ │ │ │ + var proceed = this.events.triggerEvent("beforesnap", { │ │ │ │ + point: point, │ │ │ │ + x: best.x, │ │ │ │ + y: best.y, │ │ │ │ + distance: best.dist, │ │ │ │ + layer: best.target.layer, │ │ │ │ + snapType: this.precedence[best.rank] │ │ │ │ + }); │ │ │ │ + if (proceed !== false) { │ │ │ │ + point.x = best.x; │ │ │ │ + point.y = best.y; │ │ │ │ + this.point = point; │ │ │ │ + this.events.triggerEvent("snap", { │ │ │ │ + point: point, │ │ │ │ + snapType: this.precedence[best.rank], │ │ │ │ + layer: best.target.layer, │ │ │ │ + distance: best.dist │ │ │ │ + }); │ │ │ │ } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - response.error = obj; │ │ │ │ + snapped = false; │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, response); │ │ │ │ + } │ │ │ │ + if (this.point && !snapped) { │ │ │ │ + point.x = loc.x; │ │ │ │ + point.y = loc.y; │ │ │ │ + this.point = null; │ │ │ │ + this.events.triggerEvent("unsnap", { │ │ │ │ + point: point │ │ │ │ + }); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: filterDelete │ │ │ │ - * Send a request that deletes all features by their filter. │ │ │ │ - * │ │ │ │ + * Method: testTarget │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} filter │ │ │ │ + * target - {Object} Object with target layer configuration. │ │ │ │ + * loc - {<OpenLayers.Geometry.Point>} The location of the mouse in map │ │ │ │ + * coords. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} A result object with rank, dist, x, and y properties. │ │ │ │ + * Returns null if candidate is not eligible for snapping. │ │ │ │ */ │ │ │ │ - filterDelete: function(filter, options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "commit" │ │ │ │ - }); │ │ │ │ - │ │ │ │ - var root = this.format.createElementNSPlus("wfs:Transaction", { │ │ │ │ - attributes: { │ │ │ │ - service: "WFS", │ │ │ │ - version: this.version │ │ │ │ + testTarget: function(target, loc) { │ │ │ │ + var resolution = this.layer.map.getResolution(); │ │ │ │ + if ("minResolution" in target) { │ │ │ │ + if (resolution < target.minResolution) { │ │ │ │ + return null; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - │ │ │ │ - var deleteNode = this.format.createElementNSPlus("wfs:Delete", { │ │ │ │ - attributes: { │ │ │ │ - typeName: (options.featureNS ? this.featurePrefix + ":" : "") + │ │ │ │ - options.featureType │ │ │ │ + } │ │ │ │ + if ("maxResolution" in target) { │ │ │ │ + if (resolution >= target.maxResolution) { │ │ │ │ + return null; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - │ │ │ │ - if (options.featureNS) { │ │ │ │ - deleteNode.setAttribute("xmlns:" + this.featurePrefix, options.featureNS); │ │ │ │ } │ │ │ │ - var filterNode = this.format.writeNode("ogc:Filter", filter); │ │ │ │ - │ │ │ │ - deleteNode.appendChild(filterNode); │ │ │ │ - │ │ │ │ - root.appendChild(deleteNode); │ │ │ │ - │ │ │ │ - var data = OpenLayers.Format.XML.prototype.write.apply( │ │ │ │ - this.format, [root] │ │ │ │ + var tolerance = { │ │ │ │ + node: this.getGeoTolerance(target.nodeTolerance, resolution), │ │ │ │ + vertex: this.getGeoTolerance(target.vertexTolerance, resolution), │ │ │ │ + edge: this.getGeoTolerance(target.edgeTolerance, resolution) │ │ │ │ + }; │ │ │ │ + // this could be cached if we don't support setting tolerance values directly │ │ │ │ + var maxTolerance = Math.max( │ │ │ │ + tolerance.node, tolerance.vertex, tolerance.edge │ │ │ │ ); │ │ │ │ - │ │ │ │ - return OpenLayers.Request.POST({ │ │ │ │ - url: this.url, │ │ │ │ - callback: options.callback || function() {}, │ │ │ │ - data: data │ │ │ │ - }); │ │ │ │ - │ │ │ │ + var result = { │ │ │ │ + rank: Number.POSITIVE_INFINITY, │ │ │ │ + dist: Number.POSITIVE_INFINITY │ │ │ │ + }; │ │ │ │ + var eligible = false; │ │ │ │ + var features = target.layer.features; │ │ │ │ + var feature, type, vertices, vertex, closest, dist, found; │ │ │ │ + var numTypes = this.precedence.length; │ │ │ │ + var ll = new OpenLayers.LonLat(loc.x, loc.y); │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (feature !== this.feature && !feature._sketch && │ │ │ │ + feature.state !== OpenLayers.State.DELETE && │ │ │ │ + (!target.filter || target.filter.evaluate(feature))) { │ │ │ │ + if (feature.atPoint(ll, maxTolerance, maxTolerance)) { │ │ │ │ + for (var j = 0, stop = Math.min(result.rank + 1, numTypes); j < stop; ++j) { │ │ │ │ + type = this.precedence[j]; │ │ │ │ + if (target[type]) { │ │ │ │ + if (type === "edge") { │ │ │ │ + closest = feature.geometry.distanceTo(loc, { │ │ │ │ + details: true │ │ │ │ + }); │ │ │ │ + dist = closest.distance; │ │ │ │ + if (dist <= tolerance[type] && dist < result.dist) { │ │ │ │ + result = { │ │ │ │ + rank: j, │ │ │ │ + dist: dist, │ │ │ │ + x: closest.x0, │ │ │ │ + y: closest.y0 // closest coords on feature │ │ │ │ + }; │ │ │ │ + eligible = true; │ │ │ │ + // don't look for lower precedence types for this feature │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // look for nodes or vertices │ │ │ │ + vertices = feature.geometry.getVertices(type === "node"); │ │ │ │ + found = false; │ │ │ │ + for (var k = 0, klen = vertices.length; k < klen; ++k) { │ │ │ │ + vertex = vertices[k]; │ │ │ │ + dist = vertex.distanceTo(loc); │ │ │ │ + if (dist <= tolerance[type] && │ │ │ │ + (j < result.rank || (j === result.rank && dist < result.dist))) { │ │ │ │ + result = { │ │ │ │ + rank: j, │ │ │ │ + dist: dist, │ │ │ │ + x: vertex.x, │ │ │ │ + y: vertex.y │ │ │ │ + }; │ │ │ │ + eligible = true; │ │ │ │ + found = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (found) { │ │ │ │ + // don't look for lower precedence types for this feature │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return eligible ? result : null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: abort │ │ │ │ - * Abort an ongoing request, the response object passed to │ │ │ │ - * this method must come from this protocol (as a result │ │ │ │ - * of a read, or commit operation). │ │ │ │ - * │ │ │ │ + * Method: getGeoTolerance │ │ │ │ + * Calculate a tolerance in map units given a tolerance in pixels. This │ │ │ │ + * takes advantage of the <geoToleranceCache> when the map resolution │ │ │ │ + * has not changed. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} │ │ │ │ + * tolerance - {Number} A tolerance value in pixels. │ │ │ │ + * resolution - {Number} Map resolution. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} A tolerance value in map units. │ │ │ │ */ │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - response.priv.abort(); │ │ │ │ + getGeoTolerance: function(tolerance, resolution) { │ │ │ │ + if (resolution !== this.resolution) { │ │ │ │ + this.resolution = resolution; │ │ │ │ + this.geoToleranceCache = {}; │ │ │ │ + } │ │ │ │ + var geoTolerance = this.geoToleranceCache[tolerance]; │ │ │ │ + if (geoTolerance === undefined) { │ │ │ │ + geoTolerance = tolerance * resolution; │ │ │ │ + this.geoToleranceCache[tolerance] = geoTolerance; │ │ │ │ } │ │ │ │ + return geoTolerance; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.WFS.v1" │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Clean up the control. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); // TODO: this should be handled by the super │ │ │ │ + } │ │ │ │ + delete this.layer; │ │ │ │ + delete this.targets; │ │ │ │ + OpenLayers.Control.prototype.destroy.call(this); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Snapping" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol/WFS/v1_1_0.js │ │ │ │ + OpenLayers/Control/SelectFeature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Protocol/WFS/v1.js │ │ │ │ - * @requires OpenLayers/Format/WFST/v1_1_0.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Handler/Feature.js │ │ │ │ + * @requires OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol.WFS.v1_1_0 │ │ │ │ - * A WFS v1.1.0 protocol for vector layers. Create a new instance with the │ │ │ │ - * <OpenLayers.Protocol.WFS.v1_1_0> constructor. │ │ │ │ + * Class: OpenLayers.Control.SelectFeature │ │ │ │ + * The SelectFeature control selects vector features from a given layer on │ │ │ │ + * click or hover. │ │ │ │ * │ │ │ │ - * Differences from the v1.0.0 protocol: │ │ │ │ - * - uses Filter Encoding 1.1.0 instead of 1.0.0 │ │ │ │ - * - uses GML 3 instead of 2 if no format is provided │ │ │ │ - * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol.WFS.v1> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.WFS.v1_1_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ +OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforefeaturehighlighted - Triggered before a feature is highlighted │ │ │ │ + * featurehighlighted - Triggered when a feature is highlighted │ │ │ │ + * featureunhighlighted - Triggered when a feature is unhighlighted │ │ │ │ + * boxselectionstart - Triggered before box selection starts │ │ │ │ + * boxselectionend - Triggered after box selection ends │ │ │ │ + */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: version │ │ │ │ - * {String} WFS version number. │ │ │ │ + * Property: multipleKey │ │ │ │ + * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ + * the <multiple> property to true. Default is null. │ │ │ │ */ │ │ │ │ - version: "1.1.0", │ │ │ │ + multipleKey: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.WFS.v1_1_0 │ │ │ │ - * A class for giving layers WFS v1.1.0 protocol. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ - * Valid options properties: │ │ │ │ - * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ - * featureNS - {String} Feature namespace (optional). │ │ │ │ - * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ - * if featureNS is provided). Default is 'feature'. │ │ │ │ - * geometryName - {String} Name of geometry attribute. Default is 'the_geom'. │ │ │ │ - * outputFormat - {String} Optional output format to use for WFS GetFeature │ │ │ │ - * requests. This can be any format advertized by the WFS's │ │ │ │ - * GetCapabilities response. If set, an appropriate readFormat also │ │ │ │ - * has to be provided, unless outputFormat is GML3, GML2 or JSON. │ │ │ │ - * readFormat - {<OpenLayers.Format>} An appropriate format parser if │ │ │ │ - * outputFormat is none of GML3, GML2 or JSON. │ │ │ │ + * Property: toggleKey │ │ │ │ + * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ + * the <toggle> property to true. Default is null. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.WFS.v1.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.outputFormat && !this.readFormat) { │ │ │ │ - if (this.outputFormat.toLowerCase() == "gml2") { │ │ │ │ - this.readFormat = new OpenLayers.Format.GML.v2({ │ │ │ │ - featureType: this.featureType, │ │ │ │ - featureNS: this.featureNS, │ │ │ │ - geometryName: this.geometryName │ │ │ │ - }); │ │ │ │ - } else if (this.outputFormat.toLowerCase() == "json") { │ │ │ │ - this.readFormat = new OpenLayers.Format.GeoJSON(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + toggleKey: null, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.WFS.v1_1_0" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Protocol/WFS/v1_0_0.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * APIProperty: multiple │ │ │ │ + * {Boolean} Allow selection of multiple geometries. Default is false. │ │ │ │ + */ │ │ │ │ + multiple: false, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: clickout │ │ │ │ + * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ + * Default is true. │ │ │ │ + */ │ │ │ │ + clickout: true, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Protocol/WFS/v1.js │ │ │ │ - * @requires OpenLayers/Format/WFST/v1_0_0.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: toggle │ │ │ │ + * {Boolean} Unselect a selected feature on click. Default is false. Only │ │ │ │ + * has meaning if hover is false. │ │ │ │ + */ │ │ │ │ + toggle: false, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Protocol.WFS.v1_0_0 │ │ │ │ - * A WFS v1.0.0 protocol for vector layers. Create a new instance with the │ │ │ │ - * <OpenLayers.Protocol.WFS.v1_0_0> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol.WFS.v1> │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.WFS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ + /** │ │ │ │ + * APIProperty: hover │ │ │ │ + * {Boolean} Select on mouse over and deselect on mouse out. If true, this │ │ │ │ + * ignores clicks and only listens to mouse moves. │ │ │ │ + */ │ │ │ │ + hover: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: version │ │ │ │ - * {String} WFS version number. │ │ │ │ + * APIProperty: highlightOnly │ │ │ │ + * {Boolean} If true do not actually select features (that is place them in │ │ │ │ + * the layer's selected features array), just highlight them. This property │ │ │ │ + * has no effect if hover is false. Defaults to false. │ │ │ │ */ │ │ │ │ - version: "1.0.0", │ │ │ │ + highlightOnly: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.WFS.v1_0_0 │ │ │ │ - * A class for giving layers WFS v1.0.0 protocol. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ - * Valid options properties: │ │ │ │ - * featureType - {String} Local (without prefix) feature typeName (required). │ │ │ │ - * featureNS - {String} Feature namespace (optional). │ │ │ │ - * featurePrefix - {String} Feature namespace alias (optional - only used │ │ │ │ - * if featureNS is provided). Default is 'feature'. │ │ │ │ - * geometryName - {String} Name of geometry attribute. Default is 'the_geom'. │ │ │ │ + * APIProperty: box │ │ │ │ + * {Boolean} Allow feature selection by drawing a box. │ │ │ │ */ │ │ │ │ + box: false, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.WFS.v1_0_0" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Events/featureclick.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Property: onBeforeSelect │ │ │ │ + * {Function} Optional function to be called before a feature is selected. │ │ │ │ + * The function should expect to be called with a feature. │ │ │ │ + */ │ │ │ │ + onBeforeSelect: function() {}, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * APIProperty: onSelect │ │ │ │ + * {Function} Optional function to be called when a feature is selected. │ │ │ │ + * The function should expect to be called with a feature. │ │ │ │ + */ │ │ │ │ + onSelect: function() {}, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * APIProperty: onUnselect │ │ │ │ + * {Function} Optional function to be called when a feature is unselected. │ │ │ │ + * The function should expect to be called with a feature. │ │ │ │ + */ │ │ │ │ + onUnselect: function() {}, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Events.featureclick │ │ │ │ - * │ │ │ │ - * Extension event type for handling feature click events, including overlapping │ │ │ │ - * features. │ │ │ │ - * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - featureclick │ │ │ │ - */ │ │ │ │ -OpenLayers.Events.featureclick = OpenLayers.Class({ │ │ │ │ + /** │ │ │ │ + * Property: scope │ │ │ │ + * {Object} The scope to use with the onBeforeSelect, onSelect, onUnselect │ │ │ │ + * callbacks. If null the scope will be this control. │ │ │ │ + */ │ │ │ │ + scope: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: cache │ │ │ │ - * {Object} A cache of features under the mouse. │ │ │ │ + * APIProperty: geometryTypes │ │ │ │ + * {Array(String)} To restrict selecting to a limited set of geometry types, │ │ │ │ + * send a list of strings corresponding to the geometry class names. │ │ │ │ */ │ │ │ │ - cache: null, │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: map │ │ │ │ - * {<OpenLayers.Map>} The map to register browser events on. │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The vector layer with a common renderer │ │ │ │ + * root for all layers this control is configured with (if an array of │ │ │ │ + * layers was passed to the constructor), or the vector layer the control │ │ │ │ + * was configured with (if a single layer was passed to the constructor). │ │ │ │ */ │ │ │ │ - map: null, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: provides │ │ │ │ - * {Array(String)} The event types provided by this extension. │ │ │ │ + * Property: layers │ │ │ │ + * {Array(<OpenLayers.Layer.Vector>)} The layers this control will work on, │ │ │ │ + * or null if the control was configured with a single layer │ │ │ │ */ │ │ │ │ - provides: ["featureclick", "nofeatureclick", "featureover", "featureout"], │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Events.featureclick │ │ │ │ - * Create a new featureclick event type. │ │ │ │ + * APIProperty: callbacks │ │ │ │ + * {Object} The functions that are sent to the handlers.feature for callback │ │ │ │ + */ │ │ │ │ + callbacks: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: selectStyle │ │ │ │ + * {Object} Hash of styles │ │ │ │ + */ │ │ │ │ + selectStyle: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: renderIntent │ │ │ │ + * {String} key used to retrieve the select style from the layer's │ │ │ │ + * style map. │ │ │ │ + */ │ │ │ │ + renderIntent: "select", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: handlers │ │ │ │ + * {Object} Object with references to multiple <OpenLayers.Handler> │ │ │ │ + * instances. │ │ │ │ + */ │ │ │ │ + handlers: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.SelectFeature │ │ │ │ + * Create a new control for selecting features. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * target - {<OpenLayers.Events>} The events instance to create the events │ │ │ │ - * for. │ │ │ │ + * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. The │ │ │ │ + * layer(s) this control will select features from. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - if (target.object instanceof OpenLayers.Map) { │ │ │ │ - this.setMap(target.object); │ │ │ │ - } else if (target.object instanceof OpenLayers.Layer.Vector) { │ │ │ │ - if (target.object.map) { │ │ │ │ - this.setMap(target.object.map); │ │ │ │ - } else { │ │ │ │ - target.object.events.register("added", this, function(evt) { │ │ │ │ - this.setMap(target.object.map); │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - throw ("Listeners for '" + this.provides.join("', '") + │ │ │ │ - "' events can only be registered for OpenLayers.Layer.Vector " + │ │ │ │ - "or OpenLayers.Map instances"); │ │ │ │ + initialize: function(layers, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + │ │ │ │ + if (this.scope === null) { │ │ │ │ + this.scope = this; │ │ │ │ } │ │ │ │ - for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ - target.extensions[this.provides[i]] = true; │ │ │ │ + this.initLayer(layers); │ │ │ │ + var callbacks = { │ │ │ │ + click: this.clickFeature, │ │ │ │ + clickout: this.clickoutFeature │ │ │ │ + }; │ │ │ │ + if (this.hover) { │ │ │ │ + callbacks.over = this.overFeature; │ │ │ │ + callbacks.out = this.outFeature; │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ + this.handlers = { │ │ │ │ + feature: new OpenLayers.Handler.Feature( │ │ │ │ + this, this.layer, this.callbacks, { │ │ │ │ + geometryTypes: this.geometryTypes │ │ │ │ + } │ │ │ │ + ) │ │ │ │ + }; │ │ │ │ + │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box = new OpenLayers.Handler.Box( │ │ │ │ + this, { │ │ │ │ + done: this.selectBox │ │ │ │ + }, { │ │ │ │ + boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ + } │ │ │ │ + ); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * Method: initLayer │ │ │ │ + * Assign the layer property. If layers is an array, we need to use │ │ │ │ + * a RootContainer. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} The map to register browser events on. │ │ │ │ + * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - this.cache = {}; │ │ │ │ - map.events.register("mousedown", this, this.start, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("mouseup", this, this.onClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("touchstart", this, this.start, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("touchmove", this, this.cancel, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("touchend", this, this.onClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("mousemove", this, this.onMousemove, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ + initLayer: function(layers) { │ │ │ │ + if (OpenLayers.Util.isArray(layers)) { │ │ │ │ + this.layers = layers; │ │ │ │ + this.layer = new OpenLayers.Layer.Vector.RootContainer( │ │ │ │ + this.id + "_container", { │ │ │ │ + layers: layers │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.layer = layers; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: start │ │ │ │ - * Sets startEvt = evt. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - start: function(evt) { │ │ │ │ - this.startEvt = evt; │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active && this.layers) { │ │ │ │ + this.map.removeLayer(this.layer); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: cancel │ │ │ │ - * Deletes the start event. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * Method: activate │ │ │ │ + * Activates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively activated. │ │ │ │ */ │ │ │ │ - cancel: function(evt) { │ │ │ │ - delete this.startEvt; │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.addLayer(this.layer); │ │ │ │ + } │ │ │ │ + this.handlers.feature.activate(); │ │ │ │ + if (this.box && this.handlers.box) { │ │ │ │ + this.handlers.box.activate(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onClick │ │ │ │ - * Listener for the click event. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively deactivated. │ │ │ │ */ │ │ │ │ - onClick: function(evt) { │ │ │ │ - if (!this.startEvt || evt.type !== "touchend" && │ │ │ │ - !OpenLayers.Event.isLeftClick(evt)) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var features = this.getFeatures(this.startEvt); │ │ │ │ - delete this.startEvt; │ │ │ │ - // fire featureclick events │ │ │ │ - var feature, layer, more, clicked = {}; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - layer = feature.layer; │ │ │ │ - clicked[layer.id] = true; │ │ │ │ - more = this.triggerEvent("featureclick", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (more === false) { │ │ │ │ - break; │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.feature.deactivate(); │ │ │ │ + if (this.handlers.box) { │ │ │ │ + this.handlers.box.deactivate(); │ │ │ │ } │ │ │ │ - } │ │ │ │ - // fire nofeatureclick events on all vector layers with no targets │ │ │ │ - for (i = 0, len = this.map.layers.length; i < len; ++i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector && !clicked[layer.id]) { │ │ │ │ - this.triggerEvent("nofeatureclick", { │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.removeLayer(this.layer); │ │ │ │ } │ │ │ │ } │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onMousemove │ │ │ │ - * Listener for the mousemove event. │ │ │ │ + * Method: unselectAll │ │ │ │ + * Unselect all selected features. To unselect all except for a single │ │ │ │ + * feature, set the options.except property to the feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {<OpenLayers.Event>} │ │ │ │ + * options - {Object} Optional configuration object. │ │ │ │ */ │ │ │ │ - onMousemove: function(evt) { │ │ │ │ - delete this.startEvt; │ │ │ │ - var features = this.getFeatures(evt); │ │ │ │ - var over = {}, │ │ │ │ - newly = [], │ │ │ │ - feature; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - over[feature.id] = feature; │ │ │ │ - if (!this.cache[feature.id]) { │ │ │ │ - newly.push(feature); │ │ │ │ + unselectAll: function(options) { │ │ │ │ + // we'll want an option to supress notification here │ │ │ │ + var layers = this.layers || [this.layer], │ │ │ │ + layer, feature, l, numExcept; │ │ │ │ + for (l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + numExcept = 0; │ │ │ │ + //layer.selectedFeatures is null when layer is destroyed and │ │ │ │ + //one of it's preremovelayer listener calls setLayer │ │ │ │ + //with another layer on this control │ │ │ │ + if (layer.selectedFeatures != null) { │ │ │ │ + while (layer.selectedFeatures.length > numExcept) { │ │ │ │ + feature = layer.selectedFeatures[numExcept]; │ │ │ │ + if (!options || options.except != feature) { │ │ │ │ + this.unselect(feature); │ │ │ │ + } else { │ │ │ │ + ++numExcept; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - // check if already over features │ │ │ │ - var out = []; │ │ │ │ - for (var id in this.cache) { │ │ │ │ - feature = this.cache[id]; │ │ │ │ - if (feature.layer && feature.layer.map) { │ │ │ │ - if (!over[feature.id]) { │ │ │ │ - out.push(feature); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: clickFeature │ │ │ │ + * Called on click in a feature │ │ │ │ + * Only responds if this.hover is false. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + clickFeature: function(feature) { │ │ │ │ + if (!this.hover) { │ │ │ │ + var selected = (OpenLayers.Util.indexOf( │ │ │ │ + feature.layer.selectedFeatures, feature) > -1); │ │ │ │ + if (selected) { │ │ │ │ + if (this.toggleSelect()) { │ │ │ │ + this.unselect(feature); │ │ │ │ + } else if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }); │ │ │ │ } │ │ │ │ } else { │ │ │ │ - // removed │ │ │ │ - delete this.cache[id]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // fire featureover events │ │ │ │ - var more; │ │ │ │ - for (i = 0, len = newly.length; i < len; ++i) { │ │ │ │ - feature = newly[i]; │ │ │ │ - this.cache[feature.id] = feature; │ │ │ │ - more = this.triggerEvent("featureover", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (more === false) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // fire featureout events │ │ │ │ - for (i = 0, len = out.length; i < len; ++i) { │ │ │ │ - feature = out[i]; │ │ │ │ - delete this.cache[feature.id]; │ │ │ │ - more = this.triggerEvent("featureout", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (more === false) { │ │ │ │ - break; │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.select(feature); │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: triggerEvent │ │ │ │ - * Determines where to trigger the event and triggers it. │ │ │ │ + * Method: multipleSelect │ │ │ │ + * Allow for multiple selected features based on <multiple> property and │ │ │ │ + * <multipleKey> event modifier. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * type - {String} The event type to trigger │ │ │ │ - * evt - {Object} The listener argument │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow for multiple selected features. │ │ │ │ + */ │ │ │ │ + multipleSelect: function() { │ │ │ │ + return this.multiple || (this.handlers.feature.evt && │ │ │ │ + this.handlers.feature.evt[this.multipleKey]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: toggleSelect │ │ │ │ + * Event should toggle the selected state of a feature based on <toggle> │ │ │ │ + * property and <toggleKey> event modifier. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The last listener return. │ │ │ │ + * {Boolean} Toggle the selected state of a feature. │ │ │ │ */ │ │ │ │ - triggerEvent: function(type, evt) { │ │ │ │ - var layer = evt.feature ? evt.feature.layer : evt.layer, │ │ │ │ - object = this.target.object; │ │ │ │ - if (object instanceof OpenLayers.Map || object === layer) { │ │ │ │ - return this.target.triggerEvent(type, evt); │ │ │ │ + toggleSelect: function() { │ │ │ │ + return this.toggle || (this.handlers.feature.evt && │ │ │ │ + this.handlers.feature.evt[this.toggleKey]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: clickoutFeature │ │ │ │ + * Called on click outside a previously clicked (selected) feature. │ │ │ │ + * Only responds if this.hover is false. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ + */ │ │ │ │ + clickoutFeature: function(feature) { │ │ │ │ + if (!this.hover && this.clickout) { │ │ │ │ + this.unselectAll(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getFeatures │ │ │ │ - * Get all features at the given screen location. │ │ │ │ + * Method: overFeature │ │ │ │ + * Called on over a feature. │ │ │ │ + * Only responds if this.hover is true. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Object} Event object. │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + overFeature: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + this.highlight(feature); │ │ │ │ + } else if (OpenLayers.Util.indexOf( │ │ │ │ + layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: outFeature │ │ │ │ + * Called on out of a selected feature. │ │ │ │ + * Only responds if this.hover is true. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Feature.Vector>)} List of features at the given point. │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - getFeatures: function(evt) { │ │ │ │ - var x = evt.clientX, │ │ │ │ - y = evt.clientY, │ │ │ │ - features = [], │ │ │ │ - targets = [], │ │ │ │ - layers = [], │ │ │ │ - layer, target, feature, i, len; │ │ │ │ - // go through all layers looking for targets │ │ │ │ - for (i = this.map.layers.length - 1; i >= 0; --i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (layer.div.style.display !== "none") { │ │ │ │ - if (layer.renderer instanceof OpenLayers.Renderer.Elements) { │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ - target = document.elementFromPoint(x, y); │ │ │ │ - while (target && target._featureId) { │ │ │ │ - feature = layer.getFeatureById(target._featureId); │ │ │ │ - if (feature) { │ │ │ │ - features.push(feature); │ │ │ │ - target.style.display = "none"; │ │ │ │ - targets.push(target); │ │ │ │ - target = document.elementFromPoint(x, y); │ │ │ │ - } else { │ │ │ │ - // sketch, all bets off │ │ │ │ - target = false; │ │ │ │ - } │ │ │ │ + outFeature: function(feature) { │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + // we do nothing if we're not the last highlighter of the │ │ │ │ + // feature │ │ │ │ + if (feature._lastHighlighter == this.id) { │ │ │ │ + // if another select control had highlighted the feature before │ │ │ │ + // we did it ourself then we use that control to highlight the │ │ │ │ + // feature as it was before we highlighted it, else we just │ │ │ │ + // unhighlight it │ │ │ │ + if (feature._prevHighlighter && │ │ │ │ + feature._prevHighlighter != this.id) { │ │ │ │ + delete feature._lastHighlighter; │ │ │ │ + var control = this.map.getControl( │ │ │ │ + feature._prevHighlighter); │ │ │ │ + if (control) { │ │ │ │ + control.highlight(feature); │ │ │ │ } │ │ │ │ - } │ │ │ │ - layers.push(layer); │ │ │ │ - layer.div.style.display = "none"; │ │ │ │ - } else if (layer.renderer instanceof OpenLayers.Renderer.Canvas) { │ │ │ │ - feature = layer.renderer.getFeatureIdFromEvent(evt); │ │ │ │ - if (feature) { │ │ │ │ - features.push(feature); │ │ │ │ - layers.push(layer); │ │ │ │ + } else { │ │ │ │ + this.unhighlight(feature); │ │ │ │ } │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + this.unselect(feature); │ │ │ │ } │ │ │ │ } │ │ │ │ - // restore feature visibility │ │ │ │ - for (i = 0, len = targets.length; i < len; ++i) { │ │ │ │ - targets[i].style.display = ""; │ │ │ │ - } │ │ │ │ - // restore layer visibility │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - layers[i].div.style.display = "block"; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: highlight │ │ │ │ + * Redraw feature with the select style. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + highlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ + feature._lastHighlighter = this.id; │ │ │ │ + var style = this.selectStyle || this.renderIntent; │ │ │ │ + layer.drawFeature(feature, style); │ │ │ │ + this.events.triggerEvent("featurehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ } │ │ │ │ - return features; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up. │ │ │ │ + * Method: unhighlight │ │ │ │ + * Redraw feature with the "default" style │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ - delete this.target.extensions[this.provides[i]]; │ │ │ │ + unhighlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + // three cases: │ │ │ │ + // 1. there's no other highlighter, in that case _prev is undefined, │ │ │ │ + // and we just need to undef _last │ │ │ │ + // 2. another control highlighted the feature after we did it, in │ │ │ │ + // that case _last references this other control, and we just │ │ │ │ + // need to undef _prev │ │ │ │ + // 3. another control highlighted the feature before we did it, in │ │ │ │ + // that case _prev references this other control, and we need to │ │ │ │ + // set _last to _prev and undef _prev │ │ │ │ + if (feature._prevHighlighter == undefined) { │ │ │ │ + delete feature._lastHighlighter; │ │ │ │ + } else if (feature._prevHighlighter == this.id) { │ │ │ │ + delete feature._prevHighlighter; │ │ │ │ + } else { │ │ │ │ + feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ + delete feature._prevHighlighter; │ │ │ │ } │ │ │ │ - this.map.events.un({ │ │ │ │ - mousemove: this.onMousemove, │ │ │ │ - mousedown: this.start, │ │ │ │ - mouseup: this.onClick, │ │ │ │ - touchstart: this.start, │ │ │ │ - touchmove: this.cancel, │ │ │ │ - touchend: this.onClick, │ │ │ │ - scope: this │ │ │ │ + layer.drawFeature(feature, feature.style || feature.layer.style || │ │ │ │ + "default"); │ │ │ │ + this.events.triggerEvent("featureunhighlighted", { │ │ │ │ + feature: feature │ │ │ │ }); │ │ │ │ - delete this.cache; │ │ │ │ - delete this.map; │ │ │ │ - delete this.target; │ │ │ │ - } │ │ │ │ - │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Events.nofeatureclick │ │ │ │ - * │ │ │ │ - * Extension event type for handling click events that do not hit a feature. │ │ │ │ - * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - nofeatureclick │ │ │ │ - */ │ │ │ │ -OpenLayers.Events.nofeatureclick = OpenLayers.Events.featureclick; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Events.featureover │ │ │ │ - * │ │ │ │ - * Extension event type for handling hovering over a feature. │ │ │ │ - * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - featureover │ │ │ │ - */ │ │ │ │ -OpenLayers.Events.featureover = OpenLayers.Events.featureclick; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Events.featureout │ │ │ │ - * │ │ │ │ - * Extension event type for handling leaving a feature. │ │ │ │ - * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - featureout │ │ │ │ - */ │ │ │ │ -OpenLayers.Events.featureout = OpenLayers.Events.featureclick; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Popup/Anchored.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Popup.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Popup.Anchored │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Popup> │ │ │ │ - */ │ │ │ │ -OpenLayers.Popup.Anchored = │ │ │ │ - OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: relativePosition │ │ │ │ - * {String} Relative position of the popup ("br", "tr", "tl" or "bl"). │ │ │ │ - */ │ │ │ │ - relativePosition: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: keepInMap │ │ │ │ - * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ - * contrain the popup such that it always fits in the available map │ │ │ │ - * space. By default, this is set. If you are creating popups that are │ │ │ │ - * near map edges and not allowing pannning, and especially if you have │ │ │ │ - * a popup which has a fixedRelativePosition, setting this to false may │ │ │ │ - * be a smart thing to do. │ │ │ │ - * │ │ │ │ - * For anchored popups, default is true, since subclasses will │ │ │ │ - * usually want this functionality. │ │ │ │ - */ │ │ │ │ - keepInMap: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: anchor │ │ │ │ - * {Object} Object to which we'll anchor the popup. Must expose a │ │ │ │ - * 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>). │ │ │ │ - */ │ │ │ │ - anchor: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Popup.Anchored │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} │ │ │ │ - * lonlat - {<OpenLayers.LonLat>} │ │ │ │ - * contentSize - {<OpenLayers.Size>} │ │ │ │ - * contentHTML - {String} │ │ │ │ - * anchor - {Object} Object which must expose a 'size' <OpenLayers.Size> │ │ │ │ - * and 'offset' <OpenLayers.Pixel> (generally an <OpenLayers.Icon>). │ │ │ │ - * closeBox - {Boolean} │ │ │ │ - * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ - */ │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ - closeBoxCallback) { │ │ │ │ - var newArguments = [ │ │ │ │ - id, lonlat, contentSize, 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 - {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - var oldRelativePosition = this.relativePosition; │ │ │ │ - this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ - │ │ │ │ - OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ - │ │ │ │ - //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: │ │ │ │ - * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ - * contents div (in pixels). │ │ │ │ - */ │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - 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 - {<OpenLayers.Pixel>} │ │ │ │ - * │ │ │ │ - * 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 Framed, however, will want to do something │ │ │ │ - * special here. │ │ │ │ - */ │ │ │ │ - updateRelativePosition: function() { │ │ │ │ - //to be overridden by subclasses │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: calculateNewPx │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} 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); │ │ │ │ - │ │ │ │ - //use contentSize if size is not already set │ │ │ │ - var size = this.size || this.contentSize; │ │ │ │ - │ │ │ │ - var top = (this.relativePosition.charAt(0) == 't'); │ │ │ │ - newPx.y += (top) ? -size.h : this.anchor.size.h; │ │ │ │ - │ │ │ │ - var left = (this.relativePosition.charAt(1) == 'l'); │ │ │ │ - newPx.x += (left) ? -size.w : this.anchor.size.w; │ │ │ │ - │ │ │ │ - return newPx; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Popup/Framed.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Popup/Anchored.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Popup.Framed │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Popup.Anchored> │ │ │ │ - */ │ │ │ │ -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 │ │ │ │ - * {<OpenLayers.Size>} 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 - {<OpenLayers.LonLat>} │ │ │ │ - * contentSize - {<OpenLayers.Size>} │ │ │ │ - * contentHTML - {String} │ │ │ │ - * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ - * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ - * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ - * closeBox - {Boolean} │ │ │ │ - * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ - */ │ │ │ │ - initialize: function(id, lonlat, contentSize, 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 return the specified │ │ │ │ - // fixed 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: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.imageSrc = null; │ │ │ │ - this.imageSize = null; │ │ │ │ - this.isAlphaImage = null; │ │ │ │ - │ │ │ │ - this.fixedRelativePosition = false; │ │ │ │ - this.positionBlocks = null; │ │ │ │ - │ │ │ │ - //remove our blocks │ │ │ │ - for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - │ │ │ │ - if (block.image) { │ │ │ │ - block.div.removeChild(block.image); │ │ │ │ - } │ │ │ │ - block.image = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (block.div) { │ │ │ │ - this.groupDiv.removeChild(block.div); │ │ │ │ + /** │ │ │ │ + * Method: select │ │ │ │ + * Add feature to the layer's selectedFeature array, render the feature as │ │ │ │ + * selected, and call the onSelect function. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + select: function(feature) { │ │ │ │ + var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (cont !== false) { │ │ │ │ + cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + layer.selectedFeatures.push(feature); │ │ │ │ + this.highlight(feature); │ │ │ │ + // if the feature handler isn't involved in the feature │ │ │ │ + // selection (because the box handler is used or the │ │ │ │ + // feature is selected programatically) we fake the │ │ │ │ + // feature handler to allow unselecting on click │ │ │ │ + if (!this.handlers.feature.lastFeature) { │ │ │ │ + this.handlers.feature.lastFeature = layer.selectedFeatures[0]; │ │ │ │ } │ │ │ │ - block.div = null; │ │ │ │ - } │ │ │ │ - this.blocks = null; │ │ │ │ - │ │ │ │ - OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setBackgroundColor │ │ │ │ - */ │ │ │ │ - setBackgroundColor: function(color) { │ │ │ │ - //does nothing since the framed popup's entire scheme is based on a │ │ │ │ - // an image -- changing the background color makes no sense. │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setBorder │ │ │ │ - */ │ │ │ │ - setBorder: function() { │ │ │ │ - //does nothing since the framed popup's entire scheme is based on a │ │ │ │ - // an image -- changing the popup's border makes no sense. │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setOpacity │ │ │ │ - * Sets the opacity of the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ - */ │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - //does nothing since we suppose that we'll never apply an opacity │ │ │ │ - // to a framed popup │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setSize │ │ │ │ - * Overridden here, because we need to update the blocks whenever the size │ │ │ │ - * of the popup has changed. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ - * contents div (in pixels). │ │ │ │ - */ │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ - │ │ │ │ - this.updateBlocks(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: updateRelativePosition │ │ │ │ - * When the relative position changes, we need to set the new padding │ │ │ │ - * BBOX on the popup, reposition the close div, and update the blocks. │ │ │ │ - */ │ │ │ │ - updateRelativePosition: function() { │ │ │ │ - │ │ │ │ - //update the padding │ │ │ │ - this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ - │ │ │ │ - //update the position of our close box to new padding │ │ │ │ - if (this.closeDiv) { │ │ │ │ - // 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 + │ │ │ │ - this.padding.right + "px"; │ │ │ │ - this.closeDiv.style.top = contentDivPadding.top + │ │ │ │ - this.padding.top + "px"; │ │ │ │ + layer.events.triggerEvent("featureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onSelect.call(this.scope, feature); │ │ │ │ } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.updateBlocks(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: unselect │ │ │ │ + * Remove feature from the layer's selectedFeature array, render the feature as │ │ │ │ + * normal, and call the onUnselect function. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + unselect: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + // Store feature style for restoration later │ │ │ │ + this.unhighlight(feature); │ │ │ │ + OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ + layer.events.triggerEvent("featureunselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onUnselect.call(this.scope, feature); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: calculateNewPx │ │ │ │ - * Besides the standard offset as determined by the Anchored class, our │ │ │ │ - * Framed popups have a special 'offset' property for each of their │ │ │ │ - * positions, which is used to offset the popup relative to its anchor. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} The the new px position of the popup on the screen │ │ │ │ - * relative to the passed-in px. │ │ │ │ - */ │ │ │ │ - calculateNewPx: function(px) { │ │ │ │ - var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply( │ │ │ │ - this, arguments │ │ │ │ + /** │ │ │ │ + * Method: selectBox │ │ │ │ + * Callback from the handlers.box set up when <box> selection is true │ │ │ │ + * on. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * position - {<OpenLayers.Bounds> || <OpenLayers.Pixel> } │ │ │ │ + */ │ │ │ │ + selectBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + var bounds = new OpenLayers.Bounds( │ │ │ │ + minXY.lon, minXY.lat, maxXY.lon, maxXY.lat │ │ │ │ ); │ │ │ │ │ │ │ │ - newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ - │ │ │ │ - return newPx; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createBlocks │ │ │ │ - */ │ │ │ │ - createBlocks: function() { │ │ │ │ - this.blocks = []; │ │ │ │ - │ │ │ │ - //since all positions contain the same number of blocks, we can │ │ │ │ - // just pick the first position and use its blocks array to create │ │ │ │ - // our blocks array │ │ │ │ - var firstPosition = null; │ │ │ │ - for (var key in this.positionBlocks) { │ │ │ │ - firstPosition = key; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var position = this.positionBlocks[firstPosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - │ │ │ │ - var block = {}; │ │ │ │ - this.blocks.push(block); │ │ │ │ - │ │ │ │ - var divId = this.id + '_FrameDecorationDiv_' + i; │ │ │ │ - block.div = OpenLayers.Util.createDiv(divId, │ │ │ │ - null, null, null, "absolute", null, "hidden", null │ │ │ │ - ); │ │ │ │ - │ │ │ │ - var imgId = this.id + '_FrameDecorationImg_' + i; │ │ │ │ - var imageCreator = │ │ │ │ - (this.isAlphaImage) ? OpenLayers.Util.createAlphaImageDiv : │ │ │ │ - OpenLayers.Util.createImage; │ │ │ │ - │ │ │ │ - block.image = imageCreator(imgId, │ │ │ │ - null, this.imageSize, this.imageSrc, │ │ │ │ - "absolute", null, null, null │ │ │ │ - ); │ │ │ │ - │ │ │ │ - block.div.appendChild(block.image); │ │ │ │ - this.groupDiv.appendChild(block.div); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: updateBlocks │ │ │ │ - * Internal method, called on initialize and when the popup's relative │ │ │ │ - * position has changed. This function takes care of re-positioning │ │ │ │ - * the popup's blocks in their appropropriate places. │ │ │ │ - */ │ │ │ │ - updateBlocks: function() { │ │ │ │ - if (!this.blocks) { │ │ │ │ - this.createBlocks(); │ │ │ │ + // if multiple is false, first deselect currently selected features │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll(); │ │ │ │ } │ │ │ │ │ │ │ │ - if (this.size && this.relativePosition) { │ │ │ │ - var position = this.positionBlocks[this.relativePosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - │ │ │ │ - var positionBlock = position.blocks[i]; │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - │ │ │ │ - // adjust sizes │ │ │ │ - var l = positionBlock.anchor.left; │ │ │ │ - var b = positionBlock.anchor.bottom; │ │ │ │ - var r = positionBlock.anchor.right; │ │ │ │ - var t = positionBlock.anchor.top; │ │ │ │ - │ │ │ │ - //note that we use the isNaN() test here because if the │ │ │ │ - // size object is initialized with a "auto" parameter, the │ │ │ │ - // size constructor calls parseFloat() on the string, │ │ │ │ - // which will turn it into NaN │ │ │ │ - // │ │ │ │ - var w = (isNaN(positionBlock.size.w)) ? this.size.w - (r + l) : │ │ │ │ - positionBlock.size.w; │ │ │ │ - │ │ │ │ - var h = (isNaN(positionBlock.size.h)) ? this.size.h - (b + t) : │ │ │ │ - positionBlock.size.h; │ │ │ │ - │ │ │ │ - block.div.style.width = (w < 0 ? 0 : w) + 'px'; │ │ │ │ - block.div.style.height = (h < 0 ? 0 : h) + 'px'; │ │ │ │ - │ │ │ │ - block.div.style.left = (l != null) ? l + 'px' : ''; │ │ │ │ - block.div.style.bottom = (b != null) ? b + 'px' : ''; │ │ │ │ - block.div.style.right = (r != null) ? r + 'px' : ''; │ │ │ │ - block.div.style.top = (t != null) ? t + 'px' : ''; │ │ │ │ + // because we're using a box, we consider we want multiple selection │ │ │ │ + var prevMultiple = this.multiple; │ │ │ │ + this.multiple = true; │ │ │ │ + var layers = this.layers || [this.layer]; │ │ │ │ + this.events.triggerEvent("boxselectionstart", { │ │ │ │ + layers: layers │ │ │ │ + }); │ │ │ │ + var layer; │ │ │ │ + for (var l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ + var feature = layer.features[i]; │ │ │ │ + // check if the feature is displayed │ │ │ │ + if (!feature.getVisibility()) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ │ │ │ │ - block.image.style.left = positionBlock.position.x + 'px'; │ │ │ │ - block.image.style.top = positionBlock.position.y + 'px'; │ │ │ │ + if (this.geometryTypes == null || OpenLayers.Util.indexOf( │ │ │ │ + this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ + if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ + if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - │ │ │ │ - this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ - this.contentDiv.style.top = this.padding.top + "px"; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Popup/FramedCloud.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Popup/Framed.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Bounds.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Pixel.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Size.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Popup.FramedCloud │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Popup.Framed> │ │ │ │ - */ │ │ │ │ -OpenLayers.Popup.FramedCloud = │ │ │ │ - OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: contentDisplayClass │ │ │ │ - * {String} The CSS class of the popup content div. │ │ │ │ - */ │ │ │ │ - contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoSize │ │ │ │ - * {Boolean} Framed Cloud is autosizing by default. │ │ │ │ - */ │ │ │ │ - autoSize: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: panMapIfOutOfView │ │ │ │ - * {Boolean} Framed Cloud does pan into view by default. │ │ │ │ - */ │ │ │ │ - panMapIfOutOfView: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: imageSize │ │ │ │ - * {<OpenLayers.Size>} │ │ │ │ - */ │ │ │ │ - imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isAlphaImage │ │ │ │ - * {Boolean} The FramedCloud does not use an alpha image (in honor of the │ │ │ │ - * good ie6 folk out there) │ │ │ │ - */ │ │ │ │ - isAlphaImage: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: fixedRelativePosition │ │ │ │ - * {Boolean} The Framed Cloud popup works in just one fixed position. │ │ │ │ - */ │ │ │ │ - fixedRelativePosition: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: positionBlocks │ │ │ │ - * {Object} Hash of differen position blocks, keyed by relativePosition │ │ │ │ - * two-character code string (ie "tl", "tr", "bl", "br") │ │ │ │ - */ │ │ │ │ - positionBlocks: { │ │ │ │ - "tl": { │ │ │ │ - 'offset': new OpenLayers.Pixel(44, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 18), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -688) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - "tr": { │ │ │ │ - 'offset': new OpenLayers.Pixel(-45, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 19), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ - position: new OpenLayers.Pixel(-215, -687) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - "bl": { │ │ │ │ - 'offset': new OpenLayers.Pixel(45, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-101, -674) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - "br": { │ │ │ │ - 'offset': new OpenLayers.Pixel(-44, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ - position: new OpenLayers.Pixel(-311, -674) │ │ │ │ - }] │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: minSize │ │ │ │ - * {<OpenLayers.Size>} │ │ │ │ - */ │ │ │ │ - minSize: new OpenLayers.Size(105, 10), │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: maxSize │ │ │ │ - * {<OpenLayers.Size>} │ │ │ │ - */ │ │ │ │ - maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ + this.multiple = prevMultiple; │ │ │ │ + this.events.triggerEvent("boxselectionend", { │ │ │ │ + layers: layers │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Popup.FramedCloud │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} │ │ │ │ - * lonlat - {<OpenLayers.LonLat>} │ │ │ │ - * contentSize - {<OpenLayers.Size>} │ │ │ │ - * contentHTML - {String} │ │ │ │ - * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ - * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ - * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ - * closeBox - {Boolean} │ │ │ │ - * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ - */ │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ - closeBoxCallback) { │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.feature.setMap(map); │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box.setMap(map); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.imageSrc = OpenLayers.Util.getImageLocation('cloud-popup-relative.png'); │ │ │ │ - OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: setLayer │ │ │ │ + * Attach a new layer to the control, overriding any existing layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layers - Array of {<OpenLayers.Layer.Vector>} or a single │ │ │ │ + * {<OpenLayers.Layer.Vector>} │ │ │ │ + */ │ │ │ │ + setLayer: function(layers) { │ │ │ │ + var isActive = this.active; │ │ │ │ + this.unselectAll(); │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy(); │ │ │ │ + this.layers = null; │ │ │ │ + } │ │ │ │ + this.initLayer(layers); │ │ │ │ + this.handlers.feature.layer = this.layer; │ │ │ │ + if (isActive) { │ │ │ │ + this.activate(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ +}); │ │ ├── ./usr/share/javascript/openlayers/OpenLayers.light.js │ │ │ ├── js-beautify {} │ │ │ │ @@ -263,14 +263,449 @@ │ │ │ │ source.hasOwnProperty && source.hasOwnProperty("toString")) { │ │ │ │ destination.toString = source.toString; │ │ │ │ } │ │ │ │ } │ │ │ │ return destination; │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ + OpenLayers/Util/vendorPrefix.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Util.vendorPrefix │ │ │ │ + * A collection of utility functions to detect vendor prefixed features │ │ │ │ + */ │ │ │ │ +OpenLayers.Util.vendorPrefix = (function() { │ │ │ │ + "use strict"; │ │ │ │ + │ │ │ │ + var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ + divStyle = document.createElement("div").style, │ │ │ │ + cssCache = {}, │ │ │ │ + jsCache = {}; │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: domToCss │ │ │ │ + * Converts a upper camel case DOM style property name to a CSS property │ │ │ │ + * i.e. transformOrigin -> transform-origin │ │ │ │ + * or WebkitTransformOrigin -> -webkit-transform-origin │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * prefixedDom - {String} The property to convert │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The CSS property │ │ │ │ + */ │ │ │ │ + function domToCss(prefixedDom) { │ │ │ │ + if (!prefixedDom) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + return prefixedDom. │ │ │ │ + replace(/([A-Z])/g, function(c) { │ │ │ │ + return "-" + c.toLowerCase(); │ │ │ │ + }). │ │ │ │ + replace(/^ms-/, "-ms-"); │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: css │ │ │ │ + * Detect which property is used for a CSS property │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * property - {String} The standard (unprefixed) CSS property name │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The standard CSS property, prefixed property or null if not │ │ │ │ + * supported │ │ │ │ + */ │ │ │ │ + function css(property) { │ │ │ │ + if (cssCache[property] === undefined) { │ │ │ │ + var domProperty = property. │ │ │ │ + replace(/(-[\s\S])/g, function(c) { │ │ │ │ + return c.charAt(1).toUpperCase(); │ │ │ │ + }); │ │ │ │ + var prefixedDom = style(domProperty); │ │ │ │ + cssCache[property] = domToCss(prefixedDom); │ │ │ │ + } │ │ │ │ + return cssCache[property]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: js │ │ │ │ + * Detect which property is used for a JS property/method │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} The object to test on │ │ │ │ + * property - {String} The standard (unprefixed) JS property name │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The standard JS property, prefixed property or null if not │ │ │ │ + * supported │ │ │ │ + */ │ │ │ │ + function js(obj, property) { │ │ │ │ + if (jsCache[property] === undefined) { │ │ │ │ + var tmpProp, │ │ │ │ + i = 0, │ │ │ │ + l = VENDOR_PREFIXES.length, │ │ │ │ + prefix, │ │ │ │ + isStyleObj = (typeof obj.cssText !== "undefined"); │ │ │ │ + │ │ │ │ + jsCache[property] = null; │ │ │ │ + for (; i < l; i++) { │ │ │ │ + prefix = VENDOR_PREFIXES[i]; │ │ │ │ + if (prefix) { │ │ │ │ + if (!isStyleObj) { │ │ │ │ + // js prefix should be lower-case, while style │ │ │ │ + // properties have upper case on first character │ │ │ │ + prefix = prefix.toLowerCase(); │ │ │ │ + } │ │ │ │ + tmpProp = prefix + property.charAt(0).toUpperCase() + property.slice(1); │ │ │ │ + } else { │ │ │ │ + tmpProp = property; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (obj[tmpProp] !== undefined) { │ │ │ │ + jsCache[property] = tmpProp; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return jsCache[property]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: style │ │ │ │ + * Detect which property is used for a DOM style property │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * property - {String} The standard (unprefixed) style property name │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The standard style property, prefixed property or null if not │ │ │ │ + * supported │ │ │ │ + */ │ │ │ │ + function style(property) { │ │ │ │ + return js(divStyle, property); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return { │ │ │ │ + css: css, │ │ │ │ + js: js, │ │ │ │ + style: style, │ │ │ │ + │ │ │ │ + // used for testing │ │ │ │ + cssCache: cssCache, │ │ │ │ + jsCache: jsCache │ │ │ │ + }; │ │ │ │ +}()); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Animation.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + * @requires OpenLayers/Util/vendorPrefix.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Animation │ │ │ │ + * A collection of utility functions for executing methods that repaint a │ │ │ │ + * portion of the browser window. These methods take advantage of the │ │ │ │ + * browser's scheduled repaints where requestAnimationFrame is available. │ │ │ │ + */ │ │ │ │ +OpenLayers.Animation = (function(window) { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: isNative │ │ │ │ + * {Boolean} true if a native requestAnimationFrame function is available │ │ │ │ + */ │ │ │ │ + var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ + var isNative = !!(requestAnimationFrame); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: requestFrame │ │ │ │ + * Schedule a function to be called at the next available animation frame. │ │ │ │ + * Uses the native method where available. Where requestAnimationFrame is │ │ │ │ + * not available, setTimeout will be called with a 16ms delay. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The function to be called at the next animation frame. │ │ │ │ + * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ + */ │ │ │ │ + var requestFrame = (function() { │ │ │ │ + var request = window[requestAnimationFrame] || │ │ │ │ + function(callback, element) { │ │ │ │ + window.setTimeout(callback, 16); │ │ │ │ + }; │ │ │ │ + // bind to window to avoid illegal invocation of native function │ │ │ │ + return function(callback, element) { │ │ │ │ + request.apply(window, [callback, element]); │ │ │ │ + }; │ │ │ │ + })(); │ │ │ │ + │ │ │ │ + // private variables for animation loops │ │ │ │ + var counter = 0; │ │ │ │ + var loops = {}; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: start │ │ │ │ + * Executes a method with <requestFrame> in series for some │ │ │ │ + * duration. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The function to be called at the next animation frame. │ │ │ │ + * duration - {Number} Optional duration for the loop. If not provided, the │ │ │ │ + * animation loop will execute indefinitely. │ │ │ │ + * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} Identifier for the animation loop. Used to stop animations with │ │ │ │ + * <stop>. │ │ │ │ + */ │ │ │ │ + function start(callback, duration, element) { │ │ │ │ + duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ + var id = ++counter; │ │ │ │ + var start = +new Date; │ │ │ │ + loops[id] = function() { │ │ │ │ + if (loops[id] && +new Date - start <= duration) { │ │ │ │ + callback(); │ │ │ │ + if (loops[id]) { │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + delete loops[id]; │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + return id; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: stop │ │ │ │ + * Terminates an animation loop started with <start>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {Number} Identifier returned from <start>. │ │ │ │ + */ │ │ │ │ + function stop(id) { │ │ │ │ + delete loops[id]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return { │ │ │ │ + isNative: isNative, │ │ │ │ + requestFrame: requestFrame, │ │ │ │ + start: start, │ │ │ │ + stop: stop │ │ │ │ + }; │ │ │ │ + │ │ │ │ +})(window); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Kinetic.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Animation.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: threshold │ │ │ │ + * In most cases changing the threshold isn't needed. │ │ │ │ + * In px/ms, default to 0. │ │ │ │ + */ │ │ │ │ + threshold: 0, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: deceleration │ │ │ │ + * {Float} the deseleration in px/ms², default to 0.0035. │ │ │ │ + */ │ │ │ │ + deceleration: 0.0035, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: nbPoints │ │ │ │ + * {Integer} the number of points we use to calculate the kinetic │ │ │ │ + * initial values. │ │ │ │ + */ │ │ │ │ + nbPoints: 100, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: delay │ │ │ │ + * {Float} time to consider to calculate the kinetic initial values. │ │ │ │ + * In ms, default to 200. │ │ │ │ + */ │ │ │ │ + delay: 200, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: points │ │ │ │ + * List of points use to calculate the kinetic initial values. │ │ │ │ + */ │ │ │ │ + points: undefined, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: timerId │ │ │ │ + * ID of the timer. │ │ │ │ + */ │ │ │ │ + timerId: undefined, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Kinetic │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: begin │ │ │ │ + * Begins the dragging. │ │ │ │ + */ │ │ │ │ + begin: function() { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = undefined; │ │ │ │ + this.points = []; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ + * Updates during the dragging. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} The new position. │ │ │ │ + */ │ │ │ │ + update: function(xy) { │ │ │ │ + this.points.unshift({ │ │ │ │ + xy: xy, │ │ │ │ + tick: new Date().getTime() │ │ │ │ + }); │ │ │ │ + if (this.points.length > this.nbPoints) { │ │ │ │ + this.points.pop(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: end │ │ │ │ + * Ends the dragging, start the kinetic. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} The last position. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with two properties: "speed", and "theta". The │ │ │ │ + * "speed" and "theta" values are to be passed to the move │ │ │ │ + * function when starting the animation. │ │ │ │ + */ │ │ │ │ + end: function(xy) { │ │ │ │ + var last, now = new Date().getTime(); │ │ │ │ + for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ + point = this.points[i]; │ │ │ │ + if (now - point.tick > this.delay) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + last = point; │ │ │ │ + } │ │ │ │ + if (!last) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var time = new Date().getTime() - last.tick; │ │ │ │ + var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + │ │ │ │ + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ + var speed = dist / time; │ │ │ │ + if (speed == 0 || speed < this.threshold) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ + if (last.xy.x <= xy.x) { │ │ │ │ + theta = Math.PI - theta; │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + speed: speed, │ │ │ │ + theta: theta │ │ │ │ + }; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * Launch the kinetic move pan. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * info - {Object} An object with two properties, "speed", and "theta". │ │ │ │ + * These values are those returned from the "end" call. │ │ │ │ + * callback - {Function} Function called on every step of the animation, │ │ │ │ + * receives x, y (values to pan), end (is the last point). │ │ │ │ + */ │ │ │ │ + move: function(info, callback) { │ │ │ │ + var v0 = info.speed; │ │ │ │ + var fx = Math.cos(info.theta); │ │ │ │ + var fy = -Math.sin(info.theta); │ │ │ │ + │ │ │ │ + var initialTime = new Date().getTime(); │ │ │ │ + │ │ │ │ + var lastX = 0; │ │ │ │ + var lastY = 0; │ │ │ │ + │ │ │ │ + var timerCallback = function() { │ │ │ │ + if (this.timerId == null) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var t = new Date().getTime() - initialTime; │ │ │ │ + │ │ │ │ + var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t; │ │ │ │ + var x = p * fx; │ │ │ │ + var y = p * fy; │ │ │ │ + │ │ │ │ + var args = {}; │ │ │ │ + args.end = false; │ │ │ │ + var v = -this.deceleration * t + v0; │ │ │ │ + │ │ │ │ + if (v <= 0) { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + args.end = true; │ │ │ │ + } │ │ │ │ + │ │ │ │ + args.x = x - lastX; │ │ │ │ + args.y = y - lastY; │ │ │ │ + lastX = x; │ │ │ │ + lastY = y; │ │ │ │ + callback(args.x, args.y, args.end); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + this.timerId = OpenLayers.Animation.start( │ │ │ │ + OpenLayers.Function.bind(timerCallback, this) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ OpenLayers/BaseTypes.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -4426,1591 +4861,14 @@ │ │ │ │ } else { │ │ │ │ str += coordinate < 0 ? OpenLayers.i18n("S") : OpenLayers.i18n("N"); │ │ │ │ } │ │ │ │ return str; │ │ │ │ }; │ │ │ │ │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Feature.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Feature │ │ │ │ - * Features are combinations of geography and attributes. The OpenLayers.Feature │ │ │ │ - * class specifically combines a marker and a lonlat. │ │ │ │ - */ │ │ │ │ -OpenLayers.Feature = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer>} │ │ │ │ - */ │ │ │ │ - layer: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: lonlat │ │ │ │ - * {<OpenLayers.LonLat>} │ │ │ │ - */ │ │ │ │ - lonlat: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: data │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ - data: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: marker │ │ │ │ - * {<OpenLayers.Marker>} │ │ │ │ - */ │ │ │ │ - marker: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: popupClass │ │ │ │ - * {<OpenLayers.Class>} The class which will be used to instantiate │ │ │ │ - * a new Popup. Default is <OpenLayers.Popup.Anchored>. │ │ │ │ - */ │ │ │ │ - popupClass: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: popup │ │ │ │ - * {<OpenLayers.Popup>} │ │ │ │ - */ │ │ │ │ - popup: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Feature │ │ │ │ - * Constructor for features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer>} │ │ │ │ - * lonlat - {<OpenLayers.LonLat>} │ │ │ │ - * data - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature>} │ │ │ │ - */ │ │ │ │ - initialize: function(layer, lonlat, data) { │ │ │ │ - this.layer = layer; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - this.data = (data != null) ? data : {}; │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - │ │ │ │ - //remove the popup from the map │ │ │ │ - if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.layer.map.removePopup(this.popup); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // remove the marker from the layer │ │ │ │ - if (this.layer != null && this.marker != null) { │ │ │ │ - this.layer.removeMarker(this.marker); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.layer = null; │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.data = null; │ │ │ │ - if (this.marker != null) { │ │ │ │ - this.destroyMarker(this.marker); │ │ │ │ - this.marker = null; │ │ │ │ - } │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.destroyPopup(this.popup); │ │ │ │ - this.popup = null; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: onScreen │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the feature is currently visible on screen │ │ │ │ - * (based on its 'lonlat' property) │ │ │ │ - */ │ │ │ │ - onScreen: function() { │ │ │ │ - │ │ │ │ - var onScreen = false; │ │ │ │ - if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsLonLat(this.lonlat); │ │ │ │ - } │ │ │ │ - return onScreen; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createMarker │ │ │ │ - * Based on the data associated with the Feature, create and return a marker object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Marker>} A Marker Object created from the 'lonlat' and 'icon' properties │ │ │ │ - * set in this.data. If no 'lonlat' is set, returns null. If no │ │ │ │ - * 'icon' is set, OpenLayers.Marker() will load the default image. │ │ │ │ - * │ │ │ │ - * Note - this.marker is set to return value │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - createMarker: function() { │ │ │ │ - │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon); │ │ │ │ - } │ │ │ │ - return this.marker; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroyMarker │ │ │ │ - * Destroys marker. │ │ │ │ - * If user overrides the createMarker() function, s/he should be able │ │ │ │ - * to also specify an alternative function for destroying it │ │ │ │ - */ │ │ │ │ - destroyMarker: function() { │ │ │ │ - this.marker.destroy(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createPopup │ │ │ │ - * Creates a popup object created from the 'lonlat', 'popupSize', │ │ │ │ - * and 'popupContentHTML' properties set in this.data. It uses │ │ │ │ - * this.marker.icon as default anchor. │ │ │ │ - * │ │ │ │ - * If no 'lonlat' is set, returns null. │ │ │ │ - * If no this.marker has been created, no anchor is sent. │ │ │ │ - * │ │ │ │ - * Note - the returned popup object is 'owned' by the feature, so you │ │ │ │ - * cannot use the popup's destroy method to discard the popup. │ │ │ │ - * Instead, you must use the feature's destroyPopup │ │ │ │ - * │ │ │ │ - * Note - this.popup is set to return value │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * closeBox - {Boolean} create popup with closebox or not │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Popup>} Returns the created popup, which is also set │ │ │ │ - * as 'popup' property of this feature. Will be of whatever type │ │ │ │ - * specified by this feature's 'popupClass' property, but must be │ │ │ │ - * of type <OpenLayers.Popup>. │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - createPopup: function(closeBox) { │ │ │ │ - │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - if (!this.popup) { │ │ │ │ - var anchor = (this.marker) ? this.marker.icon : null; │ │ │ │ - var popupClass = this.popupClass ? │ │ │ │ - this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ - this.popup = new popupClass(this.id + "_popup", │ │ │ │ - this.lonlat, │ │ │ │ - this.data.popupSize, │ │ │ │ - this.data.popupContentHTML, │ │ │ │ - anchor, │ │ │ │ - closeBox); │ │ │ │ - } │ │ │ │ - if (this.data.overflow != null) { │ │ │ │ - this.popup.contentDiv.style.overflow = this.data.overflow; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.popup.feature = this; │ │ │ │ - } │ │ │ │ - return this.popup; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroyPopup │ │ │ │ - * Destroys the popup created via createPopup. │ │ │ │ - * │ │ │ │ - * As with the marker, if user overrides the createPopup() function, s/he │ │ │ │ - * should also be able to override the destruction │ │ │ │ - */ │ │ │ │ - destroyPopup: function() { │ │ │ │ - if (this.popup) { │ │ │ │ - this.popup.feature = null; │ │ │ │ - this.popup.destroy(); │ │ │ │ - this.popup = null; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Feature" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Feature/Vector.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -// TRASH THIS │ │ │ │ -OpenLayers.State = { │ │ │ │ - /** states */ │ │ │ │ - UNKNOWN: 'Unknown', │ │ │ │ - INSERT: 'Insert', │ │ │ │ - UPDATE: 'Update', │ │ │ │ - DELETE: 'Delete' │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Feature.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Feature.Vector │ │ │ │ - * Vector features use the OpenLayers.Geometry classes as geometry description. │ │ │ │ - * They have an 'attributes' property, which is the data object, and a 'style' │ │ │ │ - * property, the default values of which are defined in the │ │ │ │ - * <OpenLayers.Feature.Vector.style> objects. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Feature> │ │ │ │ - */ │ │ │ │ -OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: fid │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - fid: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: geometry │ │ │ │ - * {<OpenLayers.Geometry>} │ │ │ │ - */ │ │ │ │ - geometry: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: attributes │ │ │ │ - * {Object} This object holds arbitrary, serializable properties that │ │ │ │ - * describe the feature. │ │ │ │ - */ │ │ │ │ - attributes: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: bounds │ │ │ │ - * {<OpenLayers.Bounds>} The box bounding that feature's geometry, that │ │ │ │ - * property can be set by an <OpenLayers.Format> object when │ │ │ │ - * deserializing the feature, so in most cases it represents an │ │ │ │ - * information set by the server. │ │ │ │ - */ │ │ │ │ - bounds: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: state │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - state: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: style │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ - style: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} If this property is set it will be taken into account by │ │ │ │ - * {<OpenLayers.HTTP>} when upadting or deleting the feature. │ │ │ │ - */ │ │ │ │ - url: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: renderIntent │ │ │ │ - * {String} rendering intent currently being used │ │ │ │ - */ │ │ │ │ - renderIntent: "default", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: modified │ │ │ │ - * {Object} An object with the originals of the geometry and attributes of │ │ │ │ - * the feature, if they were changed. Currently this property is only read │ │ │ │ - * by <OpenLayers.Format.WFST.v1>, and written by │ │ │ │ - * <OpenLayers.Control.ModifyFeature>, which sets the geometry property. │ │ │ │ - * Applications can set the originals of modified attributes in the │ │ │ │ - * attributes property. Note that applications have to check if this │ │ │ │ - * object and the attributes property is already created before using it. │ │ │ │ - * After a change made with ModifyFeature, this object could look like │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * { │ │ │ │ - * geometry: >Object │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * When an application has made changes to feature attributes, it could │ │ │ │ - * have set the attributes to something like this: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * { │ │ │ │ - * attributes: { │ │ │ │ - * myAttribute: "original" │ │ │ │ - * } │ │ │ │ - * } │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Note that <OpenLayers.Format.WFST.v1> only checks for truthy values in │ │ │ │ - * *modified.geometry* and the attribute names in *modified.attributes*, │ │ │ │ - * but it is recommended to set the original values (and not just true) as │ │ │ │ - * attribute value, so applications could use this information to undo │ │ │ │ - * changes. │ │ │ │ - */ │ │ │ │ - modified: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Feature.Vector │ │ │ │ - * Create a vector feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The geometry that this feature │ │ │ │ - * represents. │ │ │ │ - * attributes - {Object} An optional object that will be mapped to the │ │ │ │ - * <attributes> property. │ │ │ │ - * style - {Object} An optional style object. │ │ │ │ - */ │ │ │ │ - initialize: function(geometry, attributes, style) { │ │ │ │ - OpenLayers.Feature.prototype.initialize.apply(this, │ │ │ │ - [null, null, attributes]); │ │ │ │ - this.lonlat = null; │ │ │ │ - this.geometry = geometry ? geometry : null; │ │ │ │ - this.state = null; │ │ │ │ - this.attributes = {}; │ │ │ │ - if (attributes) { │ │ │ │ - this.attributes = OpenLayers.Util.extend(this.attributes, │ │ │ │ - attributes); │ │ │ │ - } │ │ │ │ - this.style = style ? style : null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layer) { │ │ │ │ - this.layer.removeFeatures(this); │ │ │ │ - this.layer = null; │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.geometry = null; │ │ │ │ - this.modified = null; │ │ │ │ - OpenLayers.Feature.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - * Create a clone of this vector feature. Does not set any non-standard │ │ │ │ - * properties. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} An exact clone of this vector feature. │ │ │ │ - */ │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Feature.Vector( │ │ │ │ - this.geometry ? this.geometry.clone() : null, │ │ │ │ - this.attributes, │ │ │ │ - this.style); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: onScreen │ │ │ │ - * Determine whether the feature is within the map viewport. This method │ │ │ │ - * tests for an intersection between the geometry and the viewport │ │ │ │ - * bounds. If a more effecient but less precise geometry bounds │ │ │ │ - * intersection is desired, call the method with the boundsOnly │ │ │ │ - * parameter true. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * boundsOnly - {Boolean} Only test whether a feature's bounds intersects │ │ │ │ - * the viewport bounds. Default is false. If false, the feature's │ │ │ │ - * geometry must intersect the viewport for onScreen to return true. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The feature is currently visible on screen (optionally │ │ │ │ - * based on its bounds if boundsOnly is true). │ │ │ │ - */ │ │ │ │ - onScreen: function(boundsOnly) { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.layer && this.layer.map) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - if (boundsOnly) { │ │ │ │ - var featureBounds = this.geometry.getBounds(); │ │ │ │ - onScreen = screenBounds.intersectsBounds(featureBounds); │ │ │ │ - } else { │ │ │ │ - var screenPoly = screenBounds.toGeometry(); │ │ │ │ - onScreen = screenPoly.intersects(this.geometry); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return onScreen; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getVisibility │ │ │ │ - * Determine whether the feature is displayed or not. It may not displayed │ │ │ │ - * because: │ │ │ │ - * - its style display property is set to 'none', │ │ │ │ - * - it doesn't belong to any layer, │ │ │ │ - * - the styleMap creates a symbolizer with display property set to 'none' │ │ │ │ - * for it, │ │ │ │ - * - the layer which it belongs to is not visible. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The feature is currently displayed. │ │ │ │ - */ │ │ │ │ - getVisibility: function() { │ │ │ │ - return !(this.style && this.style.display == 'none' || │ │ │ │ - !this.layer || │ │ │ │ - this.layer && this.layer.styleMap && │ │ │ │ - this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == 'none' || │ │ │ │ - this.layer && !this.layer.getVisibility()); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createMarker │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * create markers │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Marker>} For now just returns null │ │ │ │ - */ │ │ │ │ - createMarker: function() { │ │ │ │ - return null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroyMarker │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * delete markers │ │ │ │ - * │ │ │ │ - * If user overrides the createMarker() function, s/he should be able │ │ │ │ - * to also specify an alternative function for destroying it │ │ │ │ - */ │ │ │ │ - destroyMarker: function() { │ │ │ │ - // pass │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createPopup │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * create popups │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Popup>} For now just returns null │ │ │ │ - */ │ │ │ │ - createPopup: function() { │ │ │ │ - return null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: atPoint │ │ │ │ - * Determins whether the feature intersects with the specified location. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * lonlat - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an │ │ │ │ - * object with a 'lon' and 'lat' properties. │ │ │ │ - * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ - * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the feature is at the specified location │ │ │ │ - */ │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - if (this.geometry) { │ │ │ │ - atPoint = this.geometry.atPoint(lonlat, toleranceLon, │ │ │ │ - toleranceLat); │ │ │ │ - } │ │ │ │ - return atPoint; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroyPopup │ │ │ │ - * HACK - we need to decide if all vector features should be able to │ │ │ │ - * delete popups │ │ │ │ - */ │ │ │ │ - destroyPopup: function() { │ │ │ │ - // pass │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: move │ │ │ │ - * Moves the feature and redraws it at its new location │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * location - {<OpenLayers.LonLat> or <OpenLayers.Pixel>} the │ │ │ │ - * location to which to move the feature. │ │ │ │ - */ │ │ │ │ - move: function(location) { │ │ │ │ - │ │ │ │ - if (!this.layer || !this.geometry.move) { │ │ │ │ - //do nothing if no layer or immoveable geometry │ │ │ │ - return undefined; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var pixel; │ │ │ │ - if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ - pixel = this.layer.getViewPortPxFromLonLat(location); │ │ │ │ - } else { │ │ │ │ - pixel = location; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ - var res = this.layer.map.getResolution(); │ │ │ │ - this.geometry.move(res * (pixel.x - lastPixel.x), │ │ │ │ - res * (lastPixel.y - pixel.y)); │ │ │ │ - this.layer.drawFeature(this); │ │ │ │ - return lastPixel; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: toState │ │ │ │ - * Sets the new state │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * state - {String} │ │ │ │ - */ │ │ │ │ - toState: function(state) { │ │ │ │ - if (state == OpenLayers.State.UPDATE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.INSERT) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.DELETE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - // the feature should be destroyed │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ - this.state = state; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ -}); │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Feature.Vector.style │ │ │ │ - * OpenLayers features can have a number of style attributes. The 'default' │ │ │ │ - * style will typically be used if no other style is specified. These │ │ │ │ - * styles correspond for the most part, to the styling properties defined │ │ │ │ - * by the SVG standard. │ │ │ │ - * Information on fill properties: http://www.w3.org/TR/SVG/painting.html#FillProperties │ │ │ │ - * Information on stroke properties: http://www.w3.org/TR/SVG/painting.html#StrokeProperties │ │ │ │ - * │ │ │ │ - * Symbolizer properties: │ │ │ │ - * fill - {Boolean} Set to false if no fill is desired. │ │ │ │ - * fillColor - {String} Hex fill color. Default is "#ee9900". │ │ │ │ - * fillOpacity - {Number} Fill opacity (0-1). Default is 0.4 │ │ │ │ - * stroke - {Boolean} Set to false if no stroke is desired. │ │ │ │ - * strokeColor - {String} Hex stroke color. Default is "#ee9900". │ │ │ │ - * strokeOpacity - {Number} Stroke opacity (0-1). Default is 1. │ │ │ │ - * strokeWidth - {Number} Pixel stroke width. Default is 1. │ │ │ │ - * strokeLinecap - {String} Stroke cap type. Default is "round". [butt | round | square] │ │ │ │ - * strokeDashstyle - {String} Stroke dash style. Default is "solid". [dot | dash | dashdot | longdash | longdashdot | solid] │ │ │ │ - * graphic - {Boolean} Set to false if no graphic is desired. │ │ │ │ - * pointRadius - {Number} Pixel point radius. Default is 6. │ │ │ │ - * pointerEvents - {String} Default is "visiblePainted". │ │ │ │ - * cursor - {String} Default is "". │ │ │ │ - * externalGraphic - {String} Url to an external graphic that will be used for rendering points. │ │ │ │ - * graphicWidth - {Number} Pixel width for sizing an external graphic. │ │ │ │ - * graphicHeight - {Number} Pixel height for sizing an external graphic. │ │ │ │ - * graphicOpacity - {Number} Opacity (0-1) for an external graphic. │ │ │ │ - * graphicXOffset - {Number} Pixel offset along the positive x axis for displacing an external graphic. │ │ │ │ - * graphicYOffset - {Number} Pixel offset along the positive y axis for displacing an external graphic. │ │ │ │ - * rotation - {Number} For point symbolizers, this is the rotation of a graphic in the clockwise direction about its center point (or any point off center as specified by graphicXOffset and graphicYOffset). │ │ │ │ - * graphicZIndex - {Number} The integer z-index value to use in rendering. │ │ │ │ - * graphicName - {String} Named graphic to use when rendering points. Supported values include "circle" (default), │ │ │ │ - * "square", "star", "x", "cross", "triangle". │ │ │ │ - * graphicTitle - {String} Tooltip when hovering over a feature. *deprecated*, use title instead │ │ │ │ - * title - {String} Tooltip when hovering over a feature. Not supported by the canvas renderer. │ │ │ │ - * backgroundGraphic - {String} Url to a graphic to be used as the background under an externalGraphic. │ │ │ │ - * backgroundGraphicZIndex - {Number} The integer z-index value to use in rendering the background graphic. │ │ │ │ - * backgroundXOffset - {Number} The x offset (in pixels) for the background graphic. │ │ │ │ - * backgroundYOffset - {Number} The y offset (in pixels) for the background graphic. │ │ │ │ - * backgroundHeight - {Number} The height of the background graphic. If not provided, the graphicHeight will be used. │ │ │ │ - * backgroundWidth - {Number} The width of the background width. If not provided, the graphicWidth will be used. │ │ │ │ - * label - {String} The text for an optional label. For browsers that use the canvas renderer, this requires either │ │ │ │ - * fillText or mozDrawText to be available. │ │ │ │ - * labelAlign - {String} Label alignment. This specifies the insertion point relative to the text. It is a string │ │ │ │ - * composed of two characters. The first character is for the horizontal alignment, the second for the vertical │ │ │ │ - * alignment. Valid values for horizontal alignment: "l"=left, "c"=center, "r"=right. Valid values for vertical │ │ │ │ - * alignment: "t"=top, "m"=middle, "b"=bottom. Example values: "lt", "cm", "rb". Default is "cm". │ │ │ │ - * labelXOffset - {Number} Pixel offset along the positive x axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ - * labelYOffset - {Number} Pixel offset along the positive y axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ - * labelSelect - {Boolean} If set to true, labels will be selectable using SelectFeature or similar controls. │ │ │ │ - * Default is false. │ │ │ │ - * labelOutlineColor - {String} The color of the label outline. Default is 'white'. Only supported by the canvas & SVG renderers. │ │ │ │ - * labelOutlineWidth - {Number} The width of the label outline. Default is 3, set to 0 or null to disable. Only supported by the SVG renderers. │ │ │ │ - * labelOutlineOpacity - {Number} The opacity (0-1) of the label outline. Default is fontOpacity. Only supported by the canvas & SVG renderers. │ │ │ │ - * fontColor - {String} The font color for the label, to be provided like CSS. │ │ │ │ - * fontOpacity - {Number} Opacity (0-1) for the label │ │ │ │ - * fontFamily - {String} The font family for the label, to be provided like in CSS. │ │ │ │ - * fontSize - {String} The font size for the label, to be provided like in CSS. │ │ │ │ - * fontStyle - {String} The font style for the label, to be provided like in CSS. │ │ │ │ - * fontWeight - {String} The font weight for the label, to be provided like in CSS. │ │ │ │ - * display - {String} Symbolizers will have no effect if display is set to "none". All other values have no effect. │ │ │ │ - */ │ │ │ │ -OpenLayers.Feature.Vector.style = { │ │ │ │ - 'default': { │ │ │ │ - fillColor: "#ee9900", │ │ │ │ - fillOpacity: 0.4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: 0.8, │ │ │ │ - strokeColor: "#ee9900", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: 0.2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - 'select': { │ │ │ │ - fillColor: "blue", │ │ │ │ - fillOpacity: 0.4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: 0.8, │ │ │ │ - strokeColor: "blue", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: 0.2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "pointer", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - │ │ │ │ - }, │ │ │ │ - 'temporary': { │ │ │ │ - fillColor: "#66cccc", │ │ │ │ - fillOpacity: 0.2, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: 0.8, │ │ │ │ - strokeColor: "#66cccc", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: 0.2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - │ │ │ │ - }, │ │ │ │ - 'delete': { │ │ │ │ - display: "none" │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Style.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Style │ │ │ │ - * This class represents a UserStyle obtained │ │ │ │ - * from a SLD, containing styling rules. │ │ │ │ - */ │ │ │ │ -OpenLayers.Style = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique id for this session. │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - name: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: title │ │ │ │ - * {String} Title of this style (set if included in SLD) │ │ │ │ - */ │ │ │ │ - title: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: description │ │ │ │ - * {String} Description of this style (set if abstract is included in SLD) │ │ │ │ - */ │ │ │ │ - description: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: layerName │ │ │ │ - * {<String>} name of the layer that this style belongs to, usually │ │ │ │ - * according to the NamedLayer attribute of an SLD document. │ │ │ │ - */ │ │ │ │ - layerName: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: isDefault │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - isDefault: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: rules │ │ │ │ - * {Array(<OpenLayers.Rule>)} │ │ │ │ - */ │ │ │ │ - rules: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: context │ │ │ │ - * {Object} An optional object with properties that symbolizers' property │ │ │ │ - * values should be evaluated against. If no context is specified, │ │ │ │ - * feature.attributes will be used │ │ │ │ - */ │ │ │ │ - context: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: defaultStyle │ │ │ │ - * {Object} hash of style properties to use as default for merging │ │ │ │ - * rule-based style symbolizers onto. If no rules are defined, │ │ │ │ - * createSymbolizer will return this style. If <defaultsPerSymbolizer> is set to │ │ │ │ - * true, the defaultStyle will only be taken into account if there are │ │ │ │ - * rules defined. │ │ │ │ - */ │ │ │ │ - defaultStyle: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: defaultsPerSymbolizer │ │ │ │ - * {Boolean} If set to true, the <defaultStyle> will extend the symbolizer │ │ │ │ - * of every rule. Properties of the <defaultStyle> will also be used to set │ │ │ │ - * missing symbolizer properties if the symbolizer has stroke, fill or │ │ │ │ - * graphic set to true. Default is false. │ │ │ │ - */ │ │ │ │ - defaultsPerSymbolizer: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: propertyStyles │ │ │ │ - * {Hash of Boolean} cache of style properties that need to be parsed for │ │ │ │ - * propertyNames. Property names are keys, values won't be used. │ │ │ │ - */ │ │ │ │ - propertyStyles: null, │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Style │ │ │ │ - * Creates a UserStyle. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * style - {Object} Optional hash of style properties that will be │ │ │ │ - * used as default style for this style object. This style │ │ │ │ - * applies if no rules are specified. Symbolizers defined in │ │ │ │ - * rules will extend this default style. │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * style. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * rules - {Array(<OpenLayers.Rule>)} List of rules to be added to the │ │ │ │ - * style. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Style>} │ │ │ │ - */ │ │ │ │ - initialize: function(style, options) { │ │ │ │ - │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.rules = []; │ │ │ │ - if (options && options.rules) { │ │ │ │ - this.addRules(options.rules); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // use the default style from OpenLayers.Feature.Vector if no style │ │ │ │ - // was given in the constructor │ │ │ │ - this.setDefaultStyle(style || │ │ │ │ - OpenLayers.Feature.Vector.style["default"]); │ │ │ │ - │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ - this.rules[i].destroy(); │ │ │ │ - this.rules[i] = null; │ │ │ │ - } │ │ │ │ - this.rules = null; │ │ │ │ - this.defaultStyle = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createSymbolizer │ │ │ │ - * creates a style by applying all feature-dependent rules to the base │ │ │ │ - * style. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature>} feature to evaluate rules for │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} symbolizer hash │ │ │ │ - */ │ │ │ │ - createSymbolizer: function(feature) { │ │ │ │ - var style = this.defaultsPerSymbolizer ? {} : this.createLiterals( │ │ │ │ - OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ - │ │ │ │ - var rules = this.rules; │ │ │ │ - │ │ │ │ - var rule, context; │ │ │ │ - var elseRules = []; │ │ │ │ - var appliedRules = false; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - rule = rules[i]; │ │ │ │ - // does the rule apply? │ │ │ │ - var applies = rule.evaluate(feature); │ │ │ │ - │ │ │ │ - if (applies) { │ │ │ │ - if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ - elseRules.push(rule); │ │ │ │ - } else { │ │ │ │ - appliedRules = true; │ │ │ │ - this.applySymbolizer(rule, style, feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // if no other rules apply, apply the rules with else filters │ │ │ │ - if (appliedRules == false && elseRules.length > 0) { │ │ │ │ - appliedRules = true; │ │ │ │ - for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ - this.applySymbolizer(elseRules[i], style, feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // don't display if there were rules but none applied │ │ │ │ - if (rules.length > 0 && appliedRules == false) { │ │ │ │ - style.display = "none"; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (style.label != null && typeof style.label !== "string") { │ │ │ │ - style.label = String(style.label); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return style; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: applySymbolizer │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * rule - {<OpenLayers.Rule>} │ │ │ │ - * style - {Object} │ │ │ │ - * feature - {<OpenLayer.Feature.Vector>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} A style with new symbolizer applied. │ │ │ │ - */ │ │ │ │ - applySymbolizer: function(rule, style, feature) { │ │ │ │ - var symbolizerPrefix = feature.geometry ? │ │ │ │ - this.getSymbolizerPrefix(feature.geometry) : │ │ │ │ - OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ - │ │ │ │ - var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ - │ │ │ │ - if (this.defaultsPerSymbolizer === true) { │ │ │ │ - var defaults = this.defaultStyle; │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: defaults.pointRadius │ │ │ │ - }); │ │ │ │ - if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - strokeWidth: defaults.strokeWidth, │ │ │ │ - strokeColor: defaults.strokeColor, │ │ │ │ - strokeOpacity: defaults.strokeOpacity, │ │ │ │ - strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ - strokeLinecap: defaults.strokeLinecap │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - fillColor: defaults.fillColor, │ │ │ │ - fillOpacity: defaults.fillOpacity │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: this.defaultStyle.pointRadius, │ │ │ │ - externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ - graphicName: this.defaultStyle.graphicName, │ │ │ │ - graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ - graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ - graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ - graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ - graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - // merge the style with the current style │ │ │ │ - return this.createLiterals( │ │ │ │ - OpenLayers.Util.extend(style, symbolizer), feature); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createLiterals │ │ │ │ - * creates literals for all style properties that have an entry in │ │ │ │ - * <this.propertyStyles>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * style - {Object} style to create literals for. Will be modified │ │ │ │ - * inline. │ │ │ │ - * feature - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} the modified style │ │ │ │ - */ │ │ │ │ - createLiterals: function(style, feature) { │ │ │ │ - var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ - OpenLayers.Util.extend(context, this.context); │ │ │ │ - │ │ │ │ - for (var i in this.propertyStyles) { │ │ │ │ - style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i); │ │ │ │ - } │ │ │ │ - return style; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: findPropertyStyles │ │ │ │ - * Looks into all rules for this style and the defaultStyle to collect │ │ │ │ - * all the style hash property names containing ${...} strings that have │ │ │ │ - * to be replaced using the createLiteral method before returning them. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} hash of property names that need createLiteral parsing. The │ │ │ │ - * name of the property is the key, and the value is true; │ │ │ │ - */ │ │ │ │ - findPropertyStyles: function() { │ │ │ │ - var propertyStyles = {}; │ │ │ │ - │ │ │ │ - // check the default style │ │ │ │ - var style = this.defaultStyle; │ │ │ │ - this.addPropertyStyles(propertyStyles, style); │ │ │ │ - │ │ │ │ - // walk through all rules to check for properties in their symbolizer │ │ │ │ - var rules = this.rules; │ │ │ │ - var symbolizer, value; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - symbolizer = rules[i].symbolizer; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - value = symbolizer[key]; │ │ │ │ - if (typeof value == "object") { │ │ │ │ - // symbolizer key is "Point", "Line" or "Polygon" │ │ │ │ - this.addPropertyStyles(propertyStyles, value); │ │ │ │ - } else { │ │ │ │ - // symbolizer is a hash of style properties │ │ │ │ - this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return propertyStyles; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: addPropertyStyles │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * propertyStyles - {Object} hash to add new property styles to. Will be │ │ │ │ - * modified inline │ │ │ │ - * symbolizer - {Object} search this symbolizer for property styles │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} propertyStyles hash │ │ │ │ - */ │ │ │ │ - addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ - var property; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - property = symbolizer[key]; │ │ │ │ - if (typeof property == "string" && │ │ │ │ - property.match(/\$\{\w+\}/)) { │ │ │ │ - propertyStyles[key] = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return propertyStyles; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: addRules │ │ │ │ - * Adds rules to this style. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * rules - {Array(<OpenLayers.Rule>)} │ │ │ │ - */ │ │ │ │ - addRules: function(rules) { │ │ │ │ - Array.prototype.push.apply(this.rules, rules); │ │ │ │ - this.propertyStyles = this.findPropertyStyles(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setDefaultStyle │ │ │ │ - * Sets the default style for this style object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * style - {Object} Hash of style properties │ │ │ │ - */ │ │ │ │ - setDefaultStyle: function(style) { │ │ │ │ - this.defaultStyle = style; │ │ │ │ - this.propertyStyles = this.findPropertyStyles(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getSymbolizerPrefix │ │ │ │ - * Returns the correct symbolizer prefix according to the │ │ │ │ - * geometry type of the passed geometry │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} key of the according symbolizer │ │ │ │ - */ │ │ │ │ - getSymbolizerPrefix: function(geometry) { │ │ │ │ - var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ - for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ - if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ - return prefixes[i]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this style. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Style>} Clone of this style. │ │ │ │ - */ │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - // clone rules │ │ │ │ - if (this.rules) { │ │ │ │ - options.rules = []; │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ - options.rules.push(this.rules[i].clone()); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // clone context │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - //clone default style │ │ │ │ - var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ - return new OpenLayers.Style(defaultStyle, options); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Style" │ │ │ │ -}); │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: createLiteral │ │ │ │ - * converts a style value holding a combination of PropertyName and Literal │ │ │ │ - * into a Literal, taking the property values from the passed features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * value - {String} value to parse. If this string contains a construct like │ │ │ │ - * "foo ${bar}", then "foo " will be taken as literal, and "${bar}" │ │ │ │ - * will be replaced by the value of the "bar" attribute of the passed │ │ │ │ - * feature. │ │ │ │ - * context - {Object} context to take attribute values from │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} optional feature to pass to │ │ │ │ - * <OpenLayers.String.format> for evaluating functions in the │ │ │ │ - * context. │ │ │ │ - * property - {String} optional, name of the property for which the literal is │ │ │ │ - * being created for evaluating functions in the context. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} the parsed value. In the example of the value parameter above, the │ │ │ │ - * result would be "foo valueOfBar", assuming that the passed feature has an │ │ │ │ - * attribute named "bar" with the value "valueOfBar". │ │ │ │ - */ │ │ │ │ -OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ - if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ - value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ - value = (isNaN(value) || !value) ? value : parseFloat(value); │ │ │ │ - } │ │ │ │ - return value; │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Style.SYMBOLIZER_PREFIXES │ │ │ │ - * {Array} prefixes of the sld symbolizers. These are the │ │ │ │ - * same as the main geometry types │ │ │ │ - */ │ │ │ │ -OpenLayers.Style.SYMBOLIZER_PREFIXES = ['Point', 'Line', 'Polygon', 'Text', │ │ │ │ - 'Raster' │ │ │ │ -]; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Rule.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Style.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Rule │ │ │ │ - * This class represents an SLD Rule, as being used for rule-based SLD styling. │ │ │ │ - */ │ │ │ │ -OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique id for this session. │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} name of this rule │ │ │ │ - */ │ │ │ │ - name: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: title │ │ │ │ - * {String} Title of this rule (set if included in SLD) │ │ │ │ - */ │ │ │ │ - title: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: description │ │ │ │ - * {String} Description of this rule (set if abstract is included in SLD) │ │ │ │ - */ │ │ │ │ - description: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: context │ │ │ │ - * {Object} An optional object with properties that the rule should be │ │ │ │ - * evaluated against. If no context is specified, feature.attributes will │ │ │ │ - * be used. │ │ │ │ - */ │ │ │ │ - context: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: filter │ │ │ │ - * {<OpenLayers.Filter>} Optional filter for the rule. │ │ │ │ - */ │ │ │ │ - filter: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: elseFilter │ │ │ │ - * {Boolean} Determines whether this rule is only to be applied only if │ │ │ │ - * no other rules match (ElseFilter according to the SLD specification). │ │ │ │ - * Default is false. For instances of OpenLayers.Rule, if elseFilter is │ │ │ │ - * false, the rule will always apply. For subclasses, the else property is │ │ │ │ - * ignored. │ │ │ │ - */ │ │ │ │ - elseFilter: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: symbolizer │ │ │ │ - * {Object} Symbolizer or hash of symbolizers for this rule. If hash of │ │ │ │ - * symbolizers, keys are one or more of ["Point", "Line", "Polygon"]. The │ │ │ │ - * latter if useful if it is required to style e.g. vertices of a line │ │ │ │ - * with a point symbolizer. Note, however, that this is not implemented │ │ │ │ - * yet in OpenLayers, but it is the way how symbolizers are defined in │ │ │ │ - * SLD. │ │ │ │ - */ │ │ │ │ - symbolizer: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: symbolizers │ │ │ │ - * {Array} Collection of symbolizers associated with this rule. If │ │ │ │ - * provided at construction, the symbolizers array has precedence │ │ │ │ - * over the deprecated symbolizer property. Note that multiple │ │ │ │ - * symbolizers are not currently supported by the vector renderers. │ │ │ │ - * Rules with multiple symbolizers are currently only useful for │ │ │ │ - * maintaining elements in an SLD document. │ │ │ │ - */ │ │ │ │ - symbolizers: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: minScaleDenominator │ │ │ │ - * {Number} or {String} minimum scale at which to draw the feature. │ │ │ │ - * In the case of a String, this can be a combination of text and │ │ │ │ - * propertyNames in the form "literal ${propertyName}" │ │ │ │ - */ │ │ │ │ - minScaleDenominator: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: maxScaleDenominator │ │ │ │ - * {Number} or {String} maximum scale at which to draw the feature. │ │ │ │ - * In the case of a String, this can be a combination of text and │ │ │ │ - * propertyNames in the form "literal ${propertyName}" │ │ │ │ - */ │ │ │ │ - maxScaleDenominator: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Rule │ │ │ │ - * Creates a Rule. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * rule │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Rule>} │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.symbolizer = {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - delete this.symbolizer; │ │ │ │ - } │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i in this.symbolizer) { │ │ │ │ - this.symbolizer[i] = null; │ │ │ │ - } │ │ │ │ - this.symbolizer = null; │ │ │ │ - delete this.symbolizers; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: evaluate │ │ │ │ - * evaluates this rule for a specific feature │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature>} feature to apply the rule to. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} true if the rule applies, false if it does not. │ │ │ │ - * This rule is the default rule and always returns true. │ │ │ │ - */ │ │ │ │ - evaluate: function(feature) { │ │ │ │ - var context = this.getContext(feature); │ │ │ │ - var applies = true; │ │ │ │ - │ │ │ │ - if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ - var scale = feature.layer.map.getScale(); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // check if within minScale/maxScale bounds │ │ │ │ - if (this.minScaleDenominator) { │ │ │ │ - applies = scale >= OpenLayers.Style.createLiteral( │ │ │ │ - this.minScaleDenominator, context); │ │ │ │ - } │ │ │ │ - if (applies && this.maxScaleDenominator) { │ │ │ │ - applies = scale < OpenLayers.Style.createLiteral( │ │ │ │ - this.maxScaleDenominator, context); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // check if optional filter applies │ │ │ │ - if (applies && this.filter) { │ │ │ │ - // feature id filters get the feature, others get the context │ │ │ │ - if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ - applies = this.filter.evaluate(feature); │ │ │ │ - } else { │ │ │ │ - applies = this.filter.evaluate(context); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - return applies; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getContext │ │ │ │ - * Gets the context for evaluating this rule │ │ │ │ - * │ │ │ │ - * Paramters: │ │ │ │ - * feature - {<OpenLayers.Feature>} feature to take the context from if │ │ │ │ - * none is specified. │ │ │ │ - */ │ │ │ │ - getContext: function(feature) { │ │ │ │ - var context = this.context; │ │ │ │ - if (!context) { │ │ │ │ - context = feature.attributes || feature.data; │ │ │ │ - } │ │ │ │ - if (typeof this.context == "function") { │ │ │ │ - context = this.context(feature); │ │ │ │ - } │ │ │ │ - return context; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this rule. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Rule>} Clone of this rule. │ │ │ │ - */ │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - // clone symbolizers │ │ │ │ - var len = this.symbolizers.length; │ │ │ │ - options.symbolizers = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - options.symbolizers[i] = this.symbolizers[i].clone(); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // clone symbolizer │ │ │ │ - options.symbolizer = {}; │ │ │ │ - var value, type; │ │ │ │ - for (var key in this.symbolizer) { │ │ │ │ - value = this.symbolizer[key]; │ │ │ │ - type = typeof value; │ │ │ │ - if (type === "object") { │ │ │ │ - options.symbolizer[key] = OpenLayers.Util.extend({}, value); │ │ │ │ - } else if (type === "string") { │ │ │ │ - options.symbolizer[key] = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // clone filter │ │ │ │ - options.filter = this.filter && this.filter.clone(); │ │ │ │ - // clone context │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - return new OpenLayers.Rule(options); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Rule" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Util/vendorPrefix.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Util.vendorPrefix │ │ │ │ - * A collection of utility functions to detect vendor prefixed features │ │ │ │ - */ │ │ │ │ -OpenLayers.Util.vendorPrefix = (function() { │ │ │ │ - "use strict"; │ │ │ │ - │ │ │ │ - var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ - divStyle = document.createElement("div").style, │ │ │ │ - cssCache = {}, │ │ │ │ - jsCache = {}; │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: domToCss │ │ │ │ - * Converts a upper camel case DOM style property name to a CSS property │ │ │ │ - * i.e. transformOrigin -> transform-origin │ │ │ │ - * or WebkitTransformOrigin -> -webkit-transform-origin │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * prefixedDom - {String} The property to convert │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The CSS property │ │ │ │ - */ │ │ │ │ - function domToCss(prefixedDom) { │ │ │ │ - if (!prefixedDom) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - return prefixedDom. │ │ │ │ - replace(/([A-Z])/g, function(c) { │ │ │ │ - return "-" + c.toLowerCase(); │ │ │ │ - }). │ │ │ │ - replace(/^ms-/, "-ms-"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: css │ │ │ │ - * Detect which property is used for a CSS property │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * property - {String} The standard (unprefixed) CSS property name │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The standard CSS property, prefixed property or null if not │ │ │ │ - * supported │ │ │ │ - */ │ │ │ │ - function css(property) { │ │ │ │ - if (cssCache[property] === undefined) { │ │ │ │ - var domProperty = property. │ │ │ │ - replace(/(-[\s\S])/g, function(c) { │ │ │ │ - return c.charAt(1).toUpperCase(); │ │ │ │ - }); │ │ │ │ - var prefixedDom = style(domProperty); │ │ │ │ - cssCache[property] = domToCss(prefixedDom); │ │ │ │ - } │ │ │ │ - return cssCache[property]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: js │ │ │ │ - * Detect which property is used for a JS property/method │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} The object to test on │ │ │ │ - * property - {String} The standard (unprefixed) JS property name │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The standard JS property, prefixed property or null if not │ │ │ │ - * supported │ │ │ │ - */ │ │ │ │ - function js(obj, property) { │ │ │ │ - if (jsCache[property] === undefined) { │ │ │ │ - var tmpProp, │ │ │ │ - i = 0, │ │ │ │ - l = VENDOR_PREFIXES.length, │ │ │ │ - prefix, │ │ │ │ - isStyleObj = (typeof obj.cssText !== "undefined"); │ │ │ │ - │ │ │ │ - jsCache[property] = null; │ │ │ │ - for (; i < l; i++) { │ │ │ │ - prefix = VENDOR_PREFIXES[i]; │ │ │ │ - if (prefix) { │ │ │ │ - if (!isStyleObj) { │ │ │ │ - // js prefix should be lower-case, while style │ │ │ │ - // properties have upper case on first character │ │ │ │ - prefix = prefix.toLowerCase(); │ │ │ │ - } │ │ │ │ - tmpProp = prefix + property.charAt(0).toUpperCase() + property.slice(1); │ │ │ │ - } else { │ │ │ │ - tmpProp = property; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (obj[tmpProp] !== undefined) { │ │ │ │ - jsCache[property] = tmpProp; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return jsCache[property]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: style │ │ │ │ - * Detect which property is used for a DOM style property │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * property - {String} The standard (unprefixed) style property name │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The standard style property, prefixed property or null if not │ │ │ │ - * supported │ │ │ │ - */ │ │ │ │ - function style(property) { │ │ │ │ - return js(divStyle, property); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - css: css, │ │ │ │ - js: js, │ │ │ │ - style: style, │ │ │ │ - │ │ │ │ - // used for testing │ │ │ │ - cssCache: cssCache, │ │ │ │ - jsCache: jsCache │ │ │ │ - }; │ │ │ │ -}()); │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Events.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -7179,120 +6037,14 @@ │ │ │ │ │ │ │ │ OpenLayers.Event.observe(element, 'MSPointerUp', cb); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Events" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Animation.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - * @requires OpenLayers/Util/vendorPrefix.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Animation │ │ │ │ - * A collection of utility functions for executing methods that repaint a │ │ │ │ - * portion of the browser window. These methods take advantage of the │ │ │ │ - * browser's scheduled repaints where requestAnimationFrame is available. │ │ │ │ - */ │ │ │ │ -OpenLayers.Animation = (function(window) { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: isNative │ │ │ │ - * {Boolean} true if a native requestAnimationFrame function is available │ │ │ │ - */ │ │ │ │ - var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ - var isNative = !!(requestAnimationFrame); │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: requestFrame │ │ │ │ - * Schedule a function to be called at the next available animation frame. │ │ │ │ - * Uses the native method where available. Where requestAnimationFrame is │ │ │ │ - * not available, setTimeout will be called with a 16ms delay. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The function to be called at the next animation frame. │ │ │ │ - * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ - */ │ │ │ │ - var requestFrame = (function() { │ │ │ │ - var request = window[requestAnimationFrame] || │ │ │ │ - function(callback, element) { │ │ │ │ - window.setTimeout(callback, 16); │ │ │ │ - }; │ │ │ │ - // bind to window to avoid illegal invocation of native function │ │ │ │ - return function(callback, element) { │ │ │ │ - request.apply(window, [callback, element]); │ │ │ │ - }; │ │ │ │ - })(); │ │ │ │ - │ │ │ │ - // private variables for animation loops │ │ │ │ - var counter = 0; │ │ │ │ - var loops = {}; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: start │ │ │ │ - * Executes a method with <requestFrame> in series for some │ │ │ │ - * duration. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The function to be called at the next animation frame. │ │ │ │ - * duration - {Number} Optional duration for the loop. If not provided, the │ │ │ │ - * animation loop will execute indefinitely. │ │ │ │ - * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} Identifier for the animation loop. Used to stop animations with │ │ │ │ - * <stop>. │ │ │ │ - */ │ │ │ │ - function start(callback, duration, element) { │ │ │ │ - duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ - var id = ++counter; │ │ │ │ - var start = +new Date; │ │ │ │ - loops[id] = function() { │ │ │ │ - if (loops[id] && +new Date - start <= duration) { │ │ │ │ - callback(); │ │ │ │ - if (loops[id]) { │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - delete loops[id]; │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - return id; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: stop │ │ │ │ - * Terminates an animation loop started with <start>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {Number} Identifier returned from <start>. │ │ │ │ - */ │ │ │ │ - function stop(id) { │ │ │ │ - delete loops[id]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - isNative: isNative, │ │ │ │ - requestFrame: requestFrame, │ │ │ │ - start: start, │ │ │ │ - stop: stop │ │ │ │ - }; │ │ │ │ - │ │ │ │ -})(window); │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Tween.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -10893,14 +9645,1210 @@ │ │ │ │ OpenLayers.Map.TILE_WIDTH = 256; │ │ │ │ /** │ │ │ │ * Constant: TILE_HEIGHT │ │ │ │ * {Integer} 256 Default tile height (unless otherwise specified) │ │ │ │ */ │ │ │ │ OpenLayers.Map.TILE_HEIGHT = 256; │ │ │ │ /* ====================================================================== │ │ │ │ + OpenLayers/Feature.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Feature │ │ │ │ + * Features are combinations of geography and attributes. The OpenLayers.Feature │ │ │ │ + * class specifically combines a marker and a lonlat. │ │ │ │ + */ │ │ │ │ +OpenLayers.Feature = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer>} │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + id: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: lonlat │ │ │ │ + * {<OpenLayers.LonLat>} │ │ │ │ + */ │ │ │ │ + lonlat: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: data │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ + data: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: marker │ │ │ │ + * {<OpenLayers.Marker>} │ │ │ │ + */ │ │ │ │ + marker: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: popupClass │ │ │ │ + * {<OpenLayers.Class>} The class which will be used to instantiate │ │ │ │ + * a new Popup. Default is <OpenLayers.Popup.Anchored>. │ │ │ │ + */ │ │ │ │ + popupClass: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: popup │ │ │ │ + * {<OpenLayers.Popup>} │ │ │ │ + */ │ │ │ │ + popup: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Feature │ │ │ │ + * Constructor for features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer>} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * data - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature>} │ │ │ │ + */ │ │ │ │ + initialize: function(layer, lonlat, data) { │ │ │ │ + this.layer = layer; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + this.data = (data != null) ? data : {}; │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + │ │ │ │ + //remove the popup from the map │ │ │ │ + if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.layer.map.removePopup(this.popup); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // remove the marker from the layer │ │ │ │ + if (this.layer != null && this.marker != null) { │ │ │ │ + this.layer.removeMarker(this.marker); │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.layer = null; │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.data = null; │ │ │ │ + if (this.marker != null) { │ │ │ │ + this.destroyMarker(this.marker); │ │ │ │ + this.marker = null; │ │ │ │ + } │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.destroyPopup(this.popup); │ │ │ │ + this.popup = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: onScreen │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the feature is currently visible on screen │ │ │ │ + * (based on its 'lonlat' property) │ │ │ │ + */ │ │ │ │ + onScreen: function() { │ │ │ │ + │ │ │ │ + var onScreen = false; │ │ │ │ + if ((this.layer != null) && (this.layer.map != null)) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsLonLat(this.lonlat); │ │ │ │ + } │ │ │ │ + return onScreen; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createMarker │ │ │ │ + * Based on the data associated with the Feature, create and return a marker object. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Marker>} A Marker Object created from the 'lonlat' and 'icon' properties │ │ │ │ + * set in this.data. If no 'lonlat' is set, returns null. If no │ │ │ │ + * 'icon' is set, OpenLayers.Marker() will load the default image. │ │ │ │ + * │ │ │ │ + * Note - this.marker is set to return value │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + createMarker: function() { │ │ │ │ + │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon); │ │ │ │ + } │ │ │ │ + return this.marker; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroyMarker │ │ │ │ + * Destroys marker. │ │ │ │ + * If user overrides the createMarker() function, s/he should be able │ │ │ │ + * to also specify an alternative function for destroying it │ │ │ │ + */ │ │ │ │ + destroyMarker: function() { │ │ │ │ + this.marker.destroy(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createPopup │ │ │ │ + * Creates a popup object created from the 'lonlat', 'popupSize', │ │ │ │ + * and 'popupContentHTML' properties set in this.data. It uses │ │ │ │ + * this.marker.icon as default anchor. │ │ │ │ + * │ │ │ │ + * If no 'lonlat' is set, returns null. │ │ │ │ + * If no this.marker has been created, no anchor is sent. │ │ │ │ + * │ │ │ │ + * Note - the returned popup object is 'owned' by the feature, so you │ │ │ │ + * cannot use the popup's destroy method to discard the popup. │ │ │ │ + * Instead, you must use the feature's destroyPopup │ │ │ │ + * │ │ │ │ + * Note - this.popup is set to return value │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * closeBox - {Boolean} create popup with closebox or not │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Popup>} Returns the created popup, which is also set │ │ │ │ + * as 'popup' property of this feature. Will be of whatever type │ │ │ │ + * specified by this feature's 'popupClass' property, but must be │ │ │ │ + * of type <OpenLayers.Popup>. │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + createPopup: function(closeBox) { │ │ │ │ + │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + if (!this.popup) { │ │ │ │ + var anchor = (this.marker) ? this.marker.icon : null; │ │ │ │ + var popupClass = this.popupClass ? │ │ │ │ + this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ + this.popup = new popupClass(this.id + "_popup", │ │ │ │ + this.lonlat, │ │ │ │ + this.data.popupSize, │ │ │ │ + this.data.popupContentHTML, │ │ │ │ + anchor, │ │ │ │ + closeBox); │ │ │ │ + } │ │ │ │ + if (this.data.overflow != null) { │ │ │ │ + this.popup.contentDiv.style.overflow = this.data.overflow; │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.popup.feature = this; │ │ │ │ + } │ │ │ │ + return this.popup; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroyPopup │ │ │ │ + * Destroys the popup created via createPopup. │ │ │ │ + * │ │ │ │ + * As with the marker, if user overrides the createPopup() function, s/he │ │ │ │ + * should also be able to override the destruction │ │ │ │ + */ │ │ │ │ + destroyPopup: function() { │ │ │ │ + if (this.popup) { │ │ │ │ + this.popup.feature = null; │ │ │ │ + this.popup.destroy(); │ │ │ │ + this.popup = null; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Feature" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Feature/Vector.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +// TRASH THIS │ │ │ │ +OpenLayers.State = { │ │ │ │ + /** states */ │ │ │ │ + UNKNOWN: 'Unknown', │ │ │ │ + INSERT: 'Insert', │ │ │ │ + UPDATE: 'Update', │ │ │ │ + DELETE: 'Delete' │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Feature.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Feature.Vector │ │ │ │ + * Vector features use the OpenLayers.Geometry classes as geometry description. │ │ │ │ + * They have an 'attributes' property, which is the data object, and a 'style' │ │ │ │ + * property, the default values of which are defined in the │ │ │ │ + * <OpenLayers.Feature.Vector.style> objects. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Feature> │ │ │ │ + */ │ │ │ │ +OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: fid │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + fid: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: geometry │ │ │ │ + * {<OpenLayers.Geometry>} │ │ │ │ + */ │ │ │ │ + geometry: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: attributes │ │ │ │ + * {Object} This object holds arbitrary, serializable properties that │ │ │ │ + * describe the feature. │ │ │ │ + */ │ │ │ │ + attributes: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: bounds │ │ │ │ + * {<OpenLayers.Bounds>} The box bounding that feature's geometry, that │ │ │ │ + * property can be set by an <OpenLayers.Format> object when │ │ │ │ + * deserializing the feature, so in most cases it represents an │ │ │ │ + * information set by the server. │ │ │ │ + */ │ │ │ │ + bounds: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: state │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + state: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: style │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ + style: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} If this property is set it will be taken into account by │ │ │ │ + * {<OpenLayers.HTTP>} when upadting or deleting the feature. │ │ │ │ + */ │ │ │ │ + url: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: renderIntent │ │ │ │ + * {String} rendering intent currently being used │ │ │ │ + */ │ │ │ │ + renderIntent: "default", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: modified │ │ │ │ + * {Object} An object with the originals of the geometry and attributes of │ │ │ │ + * the feature, if they were changed. Currently this property is only read │ │ │ │ + * by <OpenLayers.Format.WFST.v1>, and written by │ │ │ │ + * <OpenLayers.Control.ModifyFeature>, which sets the geometry property. │ │ │ │ + * Applications can set the originals of modified attributes in the │ │ │ │ + * attributes property. Note that applications have to check if this │ │ │ │ + * object and the attributes property is already created before using it. │ │ │ │ + * After a change made with ModifyFeature, this object could look like │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * { │ │ │ │ + * geometry: >Object │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * When an application has made changes to feature attributes, it could │ │ │ │ + * have set the attributes to something like this: │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * { │ │ │ │ + * attributes: { │ │ │ │ + * myAttribute: "original" │ │ │ │ + * } │ │ │ │ + * } │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Note that <OpenLayers.Format.WFST.v1> only checks for truthy values in │ │ │ │ + * *modified.geometry* and the attribute names in *modified.attributes*, │ │ │ │ + * but it is recommended to set the original values (and not just true) as │ │ │ │ + * attribute value, so applications could use this information to undo │ │ │ │ + * changes. │ │ │ │ + */ │ │ │ │ + modified: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Feature.Vector │ │ │ │ + * Create a vector feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The geometry that this feature │ │ │ │ + * represents. │ │ │ │ + * attributes - {Object} An optional object that will be mapped to the │ │ │ │ + * <attributes> property. │ │ │ │ + * style - {Object} An optional style object. │ │ │ │ + */ │ │ │ │ + initialize: function(geometry, attributes, style) { │ │ │ │ + OpenLayers.Feature.prototype.initialize.apply(this, │ │ │ │ + [null, null, attributes]); │ │ │ │ + this.lonlat = null; │ │ │ │ + this.geometry = geometry ? geometry : null; │ │ │ │ + this.state = null; │ │ │ │ + this.attributes = {}; │ │ │ │ + if (attributes) { │ │ │ │ + this.attributes = OpenLayers.Util.extend(this.attributes, │ │ │ │ + attributes); │ │ │ │ + } │ │ │ │ + this.style = style ? style : null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layer) { │ │ │ │ + this.layer.removeFeatures(this); │ │ │ │ + this.layer = null; │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.geometry = null; │ │ │ │ + this.modified = null; │ │ │ │ + OpenLayers.Feature.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: clone │ │ │ │ + * Create a clone of this vector feature. Does not set any non-standard │ │ │ │ + * properties. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} An exact clone of this vector feature. │ │ │ │ + */ │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Feature.Vector( │ │ │ │ + this.geometry ? this.geometry.clone() : null, │ │ │ │ + this.attributes, │ │ │ │ + this.style); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: onScreen │ │ │ │ + * Determine whether the feature is within the map viewport. This method │ │ │ │ + * tests for an intersection between the geometry and the viewport │ │ │ │ + * bounds. If a more effecient but less precise geometry bounds │ │ │ │ + * intersection is desired, call the method with the boundsOnly │ │ │ │ + * parameter true. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * boundsOnly - {Boolean} Only test whether a feature's bounds intersects │ │ │ │ + * the viewport bounds. Default is false. If false, the feature's │ │ │ │ + * geometry must intersect the viewport for onScreen to return true. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The feature is currently visible on screen (optionally │ │ │ │ + * based on its bounds if boundsOnly is true). │ │ │ │ + */ │ │ │ │ + onScreen: function(boundsOnly) { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.layer && this.layer.map) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + if (boundsOnly) { │ │ │ │ + var featureBounds = this.geometry.getBounds(); │ │ │ │ + onScreen = screenBounds.intersectsBounds(featureBounds); │ │ │ │ + } else { │ │ │ │ + var screenPoly = screenBounds.toGeometry(); │ │ │ │ + onScreen = screenPoly.intersects(this.geometry); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return onScreen; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getVisibility │ │ │ │ + * Determine whether the feature is displayed or not. It may not displayed │ │ │ │ + * because: │ │ │ │ + * - its style display property is set to 'none', │ │ │ │ + * - it doesn't belong to any layer, │ │ │ │ + * - the styleMap creates a symbolizer with display property set to 'none' │ │ │ │ + * for it, │ │ │ │ + * - the layer which it belongs to is not visible. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The feature is currently displayed. │ │ │ │ + */ │ │ │ │ + getVisibility: function() { │ │ │ │ + return !(this.style && this.style.display == 'none' || │ │ │ │ + !this.layer || │ │ │ │ + this.layer && this.layer.styleMap && │ │ │ │ + this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == 'none' || │ │ │ │ + this.layer && !this.layer.getVisibility()); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createMarker │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * create markers │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Marker>} For now just returns null │ │ │ │ + */ │ │ │ │ + createMarker: function() { │ │ │ │ + return null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroyMarker │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * delete markers │ │ │ │ + * │ │ │ │ + * If user overrides the createMarker() function, s/he should be able │ │ │ │ + * to also specify an alternative function for destroying it │ │ │ │ + */ │ │ │ │ + destroyMarker: function() { │ │ │ │ + // pass │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createPopup │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * create popups │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Popup>} For now just returns null │ │ │ │ + */ │ │ │ │ + createPopup: function() { │ │ │ │ + return null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: atPoint │ │ │ │ + * Determins whether the feature intersects with the specified location. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lonlat - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an │ │ │ │ + * object with a 'lon' and 'lat' properties. │ │ │ │ + * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ + * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the feature is at the specified location │ │ │ │ + */ │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + if (this.geometry) { │ │ │ │ + atPoint = this.geometry.atPoint(lonlat, toleranceLon, │ │ │ │ + toleranceLat); │ │ │ │ + } │ │ │ │ + return atPoint; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroyPopup │ │ │ │ + * HACK - we need to decide if all vector features should be able to │ │ │ │ + * delete popups │ │ │ │ + */ │ │ │ │ + destroyPopup: function() { │ │ │ │ + // pass │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * Moves the feature and redraws it at its new location │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * location - {<OpenLayers.LonLat> or <OpenLayers.Pixel>} the │ │ │ │ + * location to which to move the feature. │ │ │ │ + */ │ │ │ │ + move: function(location) { │ │ │ │ + │ │ │ │ + if (!this.layer || !this.geometry.move) { │ │ │ │ + //do nothing if no layer or immoveable geometry │ │ │ │ + return undefined; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var pixel; │ │ │ │ + if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ + pixel = this.layer.getViewPortPxFromLonLat(location); │ │ │ │ + } else { │ │ │ │ + pixel = location; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ + var res = this.layer.map.getResolution(); │ │ │ │ + this.geometry.move(res * (pixel.x - lastPixel.x), │ │ │ │ + res * (lastPixel.y - pixel.y)); │ │ │ │ + this.layer.drawFeature(this); │ │ │ │ + return lastPixel; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: toState │ │ │ │ + * Sets the new state │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * state - {String} │ │ │ │ + */ │ │ │ │ + toState: function(state) { │ │ │ │ + if (state == OpenLayers.State.UPDATE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.INSERT) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.DELETE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + // the feature should be destroyed │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ + this.state = state; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ +}); │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Feature.Vector.style │ │ │ │ + * OpenLayers features can have a number of style attributes. The 'default' │ │ │ │ + * style will typically be used if no other style is specified. These │ │ │ │ + * styles correspond for the most part, to the styling properties defined │ │ │ │ + * by the SVG standard. │ │ │ │ + * Information on fill properties: http://www.w3.org/TR/SVG/painting.html#FillProperties │ │ │ │ + * Information on stroke properties: http://www.w3.org/TR/SVG/painting.html#StrokeProperties │ │ │ │ + * │ │ │ │ + * Symbolizer properties: │ │ │ │ + * fill - {Boolean} Set to false if no fill is desired. │ │ │ │ + * fillColor - {String} Hex fill color. Default is "#ee9900". │ │ │ │ + * fillOpacity - {Number} Fill opacity (0-1). Default is 0.4 │ │ │ │ + * stroke - {Boolean} Set to false if no stroke is desired. │ │ │ │ + * strokeColor - {String} Hex stroke color. Default is "#ee9900". │ │ │ │ + * strokeOpacity - {Number} Stroke opacity (0-1). Default is 1. │ │ │ │ + * strokeWidth - {Number} Pixel stroke width. Default is 1. │ │ │ │ + * strokeLinecap - {String} Stroke cap type. Default is "round". [butt | round | square] │ │ │ │ + * strokeDashstyle - {String} Stroke dash style. Default is "solid". [dot | dash | dashdot | longdash | longdashdot | solid] │ │ │ │ + * graphic - {Boolean} Set to false if no graphic is desired. │ │ │ │ + * pointRadius - {Number} Pixel point radius. Default is 6. │ │ │ │ + * pointerEvents - {String} Default is "visiblePainted". │ │ │ │ + * cursor - {String} Default is "". │ │ │ │ + * externalGraphic - {String} Url to an external graphic that will be used for rendering points. │ │ │ │ + * graphicWidth - {Number} Pixel width for sizing an external graphic. │ │ │ │ + * graphicHeight - {Number} Pixel height for sizing an external graphic. │ │ │ │ + * graphicOpacity - {Number} Opacity (0-1) for an external graphic. │ │ │ │ + * graphicXOffset - {Number} Pixel offset along the positive x axis for displacing an external graphic. │ │ │ │ + * graphicYOffset - {Number} Pixel offset along the positive y axis for displacing an external graphic. │ │ │ │ + * rotation - {Number} For point symbolizers, this is the rotation of a graphic in the clockwise direction about its center point (or any point off center as specified by graphicXOffset and graphicYOffset). │ │ │ │ + * graphicZIndex - {Number} The integer z-index value to use in rendering. │ │ │ │ + * graphicName - {String} Named graphic to use when rendering points. Supported values include "circle" (default), │ │ │ │ + * "square", "star", "x", "cross", "triangle". │ │ │ │ + * graphicTitle - {String} Tooltip when hovering over a feature. *deprecated*, use title instead │ │ │ │ + * title - {String} Tooltip when hovering over a feature. Not supported by the canvas renderer. │ │ │ │ + * backgroundGraphic - {String} Url to a graphic to be used as the background under an externalGraphic. │ │ │ │ + * backgroundGraphicZIndex - {Number} The integer z-index value to use in rendering the background graphic. │ │ │ │ + * backgroundXOffset - {Number} The x offset (in pixels) for the background graphic. │ │ │ │ + * backgroundYOffset - {Number} The y offset (in pixels) for the background graphic. │ │ │ │ + * backgroundHeight - {Number} The height of the background graphic. If not provided, the graphicHeight will be used. │ │ │ │ + * backgroundWidth - {Number} The width of the background width. If not provided, the graphicWidth will be used. │ │ │ │ + * label - {String} The text for an optional label. For browsers that use the canvas renderer, this requires either │ │ │ │ + * fillText or mozDrawText to be available. │ │ │ │ + * labelAlign - {String} Label alignment. This specifies the insertion point relative to the text. It is a string │ │ │ │ + * composed of two characters. The first character is for the horizontal alignment, the second for the vertical │ │ │ │ + * alignment. Valid values for horizontal alignment: "l"=left, "c"=center, "r"=right. Valid values for vertical │ │ │ │ + * alignment: "t"=top, "m"=middle, "b"=bottom. Example values: "lt", "cm", "rb". Default is "cm". │ │ │ │ + * labelXOffset - {Number} Pixel offset along the positive x axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ + * labelYOffset - {Number} Pixel offset along the positive y axis for displacing the label. Not supported by the canvas renderer. │ │ │ │ + * labelSelect - {Boolean} If set to true, labels will be selectable using SelectFeature or similar controls. │ │ │ │ + * Default is false. │ │ │ │ + * labelOutlineColor - {String} The color of the label outline. Default is 'white'. Only supported by the canvas & SVG renderers. │ │ │ │ + * labelOutlineWidth - {Number} The width of the label outline. Default is 3, set to 0 or null to disable. Only supported by the SVG renderers. │ │ │ │ + * labelOutlineOpacity - {Number} The opacity (0-1) of the label outline. Default is fontOpacity. Only supported by the canvas & SVG renderers. │ │ │ │ + * fontColor - {String} The font color for the label, to be provided like CSS. │ │ │ │ + * fontOpacity - {Number} Opacity (0-1) for the label │ │ │ │ + * fontFamily - {String} The font family for the label, to be provided like in CSS. │ │ │ │ + * fontSize - {String} The font size for the label, to be provided like in CSS. │ │ │ │ + * fontStyle - {String} The font style for the label, to be provided like in CSS. │ │ │ │ + * fontWeight - {String} The font weight for the label, to be provided like in CSS. │ │ │ │ + * display - {String} Symbolizers will have no effect if display is set to "none". All other values have no effect. │ │ │ │ + */ │ │ │ │ +OpenLayers.Feature.Vector.style = { │ │ │ │ + 'default': { │ │ │ │ + fillColor: "#ee9900", │ │ │ │ + fillOpacity: 0.4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: 0.8, │ │ │ │ + strokeColor: "#ee9900", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: 0.2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + }, │ │ │ │ + 'select': { │ │ │ │ + fillColor: "blue", │ │ │ │ + fillOpacity: 0.4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: 0.8, │ │ │ │ + strokeColor: "blue", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: 0.2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "pointer", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + │ │ │ │ + }, │ │ │ │ + 'temporary': { │ │ │ │ + fillColor: "#66cccc", │ │ │ │ + fillOpacity: 0.2, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: 0.8, │ │ │ │ + strokeColor: "#66cccc", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: 0.2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + │ │ │ │ + }, │ │ │ │ + 'delete': { │ │ │ │ + display: "none" │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Style.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Style │ │ │ │ + * This class represents a UserStyle obtained │ │ │ │ + * from a SLD, containing styling rules. │ │ │ │ + */ │ │ │ │ +OpenLayers.Style = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique id for this session. │ │ │ │ + */ │ │ │ │ + id: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + name: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: title │ │ │ │ + * {String} Title of this style (set if included in SLD) │ │ │ │ + */ │ │ │ │ + title: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: description │ │ │ │ + * {String} Description of this style (set if abstract is included in SLD) │ │ │ │ + */ │ │ │ │ + description: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: layerName │ │ │ │ + * {<String>} name of the layer that this style belongs to, usually │ │ │ │ + * according to the NamedLayer attribute of an SLD document. │ │ │ │ + */ │ │ │ │ + layerName: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isDefault │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + isDefault: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: rules │ │ │ │ + * {Array(<OpenLayers.Rule>)} │ │ │ │ + */ │ │ │ │ + rules: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: context │ │ │ │ + * {Object} An optional object with properties that symbolizers' property │ │ │ │ + * values should be evaluated against. If no context is specified, │ │ │ │ + * feature.attributes will be used │ │ │ │ + */ │ │ │ │ + context: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultStyle │ │ │ │ + * {Object} hash of style properties to use as default for merging │ │ │ │ + * rule-based style symbolizers onto. If no rules are defined, │ │ │ │ + * createSymbolizer will return this style. If <defaultsPerSymbolizer> is set to │ │ │ │ + * true, the defaultStyle will only be taken into account if there are │ │ │ │ + * rules defined. │ │ │ │ + */ │ │ │ │ + defaultStyle: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: defaultsPerSymbolizer │ │ │ │ + * {Boolean} If set to true, the <defaultStyle> will extend the symbolizer │ │ │ │ + * of every rule. Properties of the <defaultStyle> will also be used to set │ │ │ │ + * missing symbolizer properties if the symbolizer has stroke, fill or │ │ │ │ + * graphic set to true. Default is false. │ │ │ │ + */ │ │ │ │ + defaultsPerSymbolizer: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: propertyStyles │ │ │ │ + * {Hash of Boolean} cache of style properties that need to be parsed for │ │ │ │ + * propertyNames. Property names are keys, values won't be used. │ │ │ │ + */ │ │ │ │ + propertyStyles: null, │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Style │ │ │ │ + * Creates a UserStyle. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * style - {Object} Optional hash of style properties that will be │ │ │ │ + * used as default style for this style object. This style │ │ │ │ + * applies if no rules are specified. Symbolizers defined in │ │ │ │ + * rules will extend this default style. │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * style. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * rules - {Array(<OpenLayers.Rule>)} List of rules to be added to the │ │ │ │ + * style. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Style>} │ │ │ │ + */ │ │ │ │ + initialize: function(style, options) { │ │ │ │ + │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.rules = []; │ │ │ │ + if (options && options.rules) { │ │ │ │ + this.addRules(options.rules); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // use the default style from OpenLayers.Feature.Vector if no style │ │ │ │ + // was given in the constructor │ │ │ │ + this.setDefaultStyle(style || │ │ │ │ + OpenLayers.Feature.Vector.style["default"]); │ │ │ │ + │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ + this.rules[i].destroy(); │ │ │ │ + this.rules[i] = null; │ │ │ │ + } │ │ │ │ + this.rules = null; │ │ │ │ + this.defaultStyle = null; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createSymbolizer │ │ │ │ + * creates a style by applying all feature-dependent rules to the base │ │ │ │ + * style. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature>} feature to evaluate rules for │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} symbolizer hash │ │ │ │ + */ │ │ │ │ + createSymbolizer: function(feature) { │ │ │ │ + var style = this.defaultsPerSymbolizer ? {} : this.createLiterals( │ │ │ │ + OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ + │ │ │ │ + var rules = this.rules; │ │ │ │ + │ │ │ │ + var rule, context; │ │ │ │ + var elseRules = []; │ │ │ │ + var appliedRules = false; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + rule = rules[i]; │ │ │ │ + // does the rule apply? │ │ │ │ + var applies = rule.evaluate(feature); │ │ │ │ + │ │ │ │ + if (applies) { │ │ │ │ + if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ + elseRules.push(rule); │ │ │ │ + } else { │ │ │ │ + appliedRules = true; │ │ │ │ + this.applySymbolizer(rule, style, feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // if no other rules apply, apply the rules with else filters │ │ │ │ + if (appliedRules == false && elseRules.length > 0) { │ │ │ │ + appliedRules = true; │ │ │ │ + for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ + this.applySymbolizer(elseRules[i], style, feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // don't display if there were rules but none applied │ │ │ │ + if (rules.length > 0 && appliedRules == false) { │ │ │ │ + style.display = "none"; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (style.label != null && typeof style.label !== "string") { │ │ │ │ + style.label = String(style.label); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return style; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: applySymbolizer │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * rule - {<OpenLayers.Rule>} │ │ │ │ + * style - {Object} │ │ │ │ + * feature - {<OpenLayer.Feature.Vector>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} A style with new symbolizer applied. │ │ │ │ + */ │ │ │ │ + applySymbolizer: function(rule, style, feature) { │ │ │ │ + var symbolizerPrefix = feature.geometry ? │ │ │ │ + this.getSymbolizerPrefix(feature.geometry) : │ │ │ │ + OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ + │ │ │ │ + var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ + │ │ │ │ + if (this.defaultsPerSymbolizer === true) { │ │ │ │ + var defaults = this.defaultStyle; │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: defaults.pointRadius │ │ │ │ + }); │ │ │ │ + if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + strokeWidth: defaults.strokeWidth, │ │ │ │ + strokeColor: defaults.strokeColor, │ │ │ │ + strokeOpacity: defaults.strokeOpacity, │ │ │ │ + strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ + strokeLinecap: defaults.strokeLinecap │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + fillColor: defaults.fillColor, │ │ │ │ + fillOpacity: defaults.fillOpacity │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: this.defaultStyle.pointRadius, │ │ │ │ + externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ + graphicName: this.defaultStyle.graphicName, │ │ │ │ + graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ + graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ + graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ + graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ + graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // merge the style with the current style │ │ │ │ + return this.createLiterals( │ │ │ │ + OpenLayers.Util.extend(style, symbolizer), feature); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createLiterals │ │ │ │ + * creates literals for all style properties that have an entry in │ │ │ │ + * <this.propertyStyles>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * style - {Object} style to create literals for. Will be modified │ │ │ │ + * inline. │ │ │ │ + * feature - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} the modified style │ │ │ │ + */ │ │ │ │ + createLiterals: function(style, feature) { │ │ │ │ + var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ + OpenLayers.Util.extend(context, this.context); │ │ │ │ + │ │ │ │ + for (var i in this.propertyStyles) { │ │ │ │ + style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i); │ │ │ │ + } │ │ │ │ + return style; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: findPropertyStyles │ │ │ │ + * Looks into all rules for this style and the defaultStyle to collect │ │ │ │ + * all the style hash property names containing ${...} strings that have │ │ │ │ + * to be replaced using the createLiteral method before returning them. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} hash of property names that need createLiteral parsing. The │ │ │ │ + * name of the property is the key, and the value is true; │ │ │ │ + */ │ │ │ │ + findPropertyStyles: function() { │ │ │ │ + var propertyStyles = {}; │ │ │ │ + │ │ │ │ + // check the default style │ │ │ │ + var style = this.defaultStyle; │ │ │ │ + this.addPropertyStyles(propertyStyles, style); │ │ │ │ + │ │ │ │ + // walk through all rules to check for properties in their symbolizer │ │ │ │ + var rules = this.rules; │ │ │ │ + var symbolizer, value; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + symbolizer = rules[i].symbolizer; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + value = symbolizer[key]; │ │ │ │ + if (typeof value == "object") { │ │ │ │ + // symbolizer key is "Point", "Line" or "Polygon" │ │ │ │ + this.addPropertyStyles(propertyStyles, value); │ │ │ │ + } else { │ │ │ │ + // symbolizer is a hash of style properties │ │ │ │ + this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return propertyStyles; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: addPropertyStyles │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * propertyStyles - {Object} hash to add new property styles to. Will be │ │ │ │ + * modified inline │ │ │ │ + * symbolizer - {Object} search this symbolizer for property styles │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} propertyStyles hash │ │ │ │ + */ │ │ │ │ + addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ + var property; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + property = symbolizer[key]; │ │ │ │ + if (typeof property == "string" && │ │ │ │ + property.match(/\$\{\w+\}/)) { │ │ │ │ + propertyStyles[key] = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return propertyStyles; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: addRules │ │ │ │ + * Adds rules to this style. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * rules - {Array(<OpenLayers.Rule>)} │ │ │ │ + */ │ │ │ │ + addRules: function(rules) { │ │ │ │ + Array.prototype.push.apply(this.rules, rules); │ │ │ │ + this.propertyStyles = this.findPropertyStyles(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setDefaultStyle │ │ │ │ + * Sets the default style for this style object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * style - {Object} Hash of style properties │ │ │ │ + */ │ │ │ │ + setDefaultStyle: function(style) { │ │ │ │ + this.defaultStyle = style; │ │ │ │ + this.propertyStyles = this.findPropertyStyles(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getSymbolizerPrefix │ │ │ │ + * Returns the correct symbolizer prefix according to the │ │ │ │ + * geometry type of the passed geometry │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} key of the according symbolizer │ │ │ │ + */ │ │ │ │ + getSymbolizerPrefix: function(geometry) { │ │ │ │ + var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ + for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ + if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ + return prefixes[i]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this style. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Style>} Clone of this style. │ │ │ │ + */ │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + // clone rules │ │ │ │ + if (this.rules) { │ │ │ │ + options.rules = []; │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ + options.rules.push(this.rules[i].clone()); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // clone context │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + //clone default style │ │ │ │ + var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ + return new OpenLayers.Style(defaultStyle, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Style" │ │ │ │ +}); │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: createLiteral │ │ │ │ + * converts a style value holding a combination of PropertyName and Literal │ │ │ │ + * into a Literal, taking the property values from the passed features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * value - {String} value to parse. If this string contains a construct like │ │ │ │ + * "foo ${bar}", then "foo " will be taken as literal, and "${bar}" │ │ │ │ + * will be replaced by the value of the "bar" attribute of the passed │ │ │ │ + * feature. │ │ │ │ + * context - {Object} context to take attribute values from │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} optional feature to pass to │ │ │ │ + * <OpenLayers.String.format> for evaluating functions in the │ │ │ │ + * context. │ │ │ │ + * property - {String} optional, name of the property for which the literal is │ │ │ │ + * being created for evaluating functions in the context. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} the parsed value. In the example of the value parameter above, the │ │ │ │ + * result would be "foo valueOfBar", assuming that the passed feature has an │ │ │ │ + * attribute named "bar" with the value "valueOfBar". │ │ │ │ + */ │ │ │ │ +OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ + if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ + value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ + value = (isNaN(value) || !value) ? value : parseFloat(value); │ │ │ │ + } │ │ │ │ + return value; │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Style.SYMBOLIZER_PREFIXES │ │ │ │ + * {Array} prefixes of the sld symbolizers. These are the │ │ │ │ + * same as the main geometry types │ │ │ │ + */ │ │ │ │ +OpenLayers.Style.SYMBOLIZER_PREFIXES = ['Point', 'Line', 'Polygon', 'Text', │ │ │ │ + 'Raster' │ │ │ │ +]; │ │ │ │ +/* ====================================================================== │ │ │ │ OpenLayers/StyleMap.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -11058,497 +11006,1331 @@ │ │ │ │ } │ │ │ │ this.styles[renderIntent].addRules(rules); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.StyleMap" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Kinetic.js │ │ │ │ + OpenLayers/Rule.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Animation.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Style.js │ │ │ │ */ │ │ │ │ │ │ │ │ -OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Rule │ │ │ │ + * This class represents an SLD Rule, as being used for rule-based SLD styling. │ │ │ │ + */ │ │ │ │ +OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: threshold │ │ │ │ - * In most cases changing the threshold isn't needed. │ │ │ │ - * In px/ms, default to 0. │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique id for this session. │ │ │ │ */ │ │ │ │ - threshold: 0, │ │ │ │ + id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: deceleration │ │ │ │ - * {Float} the deseleration in px/ms², default to 0.0035. │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} name of this rule │ │ │ │ */ │ │ │ │ - deceleration: 0.0035, │ │ │ │ + name: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: nbPoints │ │ │ │ - * {Integer} the number of points we use to calculate the kinetic │ │ │ │ - * initial values. │ │ │ │ + * Property: title │ │ │ │ + * {String} Title of this rule (set if included in SLD) │ │ │ │ */ │ │ │ │ - nbPoints: 100, │ │ │ │ + title: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: delay │ │ │ │ - * {Float} time to consider to calculate the kinetic initial values. │ │ │ │ - * In ms, default to 200. │ │ │ │ + * Property: description │ │ │ │ + * {String} Description of this rule (set if abstract is included in SLD) │ │ │ │ */ │ │ │ │ - delay: 200, │ │ │ │ + description: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: points │ │ │ │ - * List of points use to calculate the kinetic initial values. │ │ │ │ + * Property: context │ │ │ │ + * {Object} An optional object with properties that the rule should be │ │ │ │ + * evaluated against. If no context is specified, feature.attributes will │ │ │ │ + * be used. │ │ │ │ */ │ │ │ │ - points: undefined, │ │ │ │ + context: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timerId │ │ │ │ - * ID of the timer. │ │ │ │ + * Property: filter │ │ │ │ + * {<OpenLayers.Filter>} Optional filter for the rule. │ │ │ │ */ │ │ │ │ - timerId: undefined, │ │ │ │ + filter: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Kinetic │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * Property: elseFilter │ │ │ │ + * {Boolean} Determines whether this rule is only to be applied only if │ │ │ │ + * no other rules match (ElseFilter according to the SLD specification). │ │ │ │ + * Default is false. For instances of OpenLayers.Rule, if elseFilter is │ │ │ │ + * false, the rule will always apply. For subclasses, the else property is │ │ │ │ + * ignored. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - }, │ │ │ │ + elseFilter: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: begin │ │ │ │ - * Begins the dragging. │ │ │ │ + * Property: symbolizer │ │ │ │ + * {Object} Symbolizer or hash of symbolizers for this rule. If hash of │ │ │ │ + * symbolizers, keys are one or more of ["Point", "Line", "Polygon"]. The │ │ │ │ + * latter if useful if it is required to style e.g. vertices of a line │ │ │ │ + * with a point symbolizer. Note, however, that this is not implemented │ │ │ │ + * yet in OpenLayers, but it is the way how symbolizers are defined in │ │ │ │ + * SLD. │ │ │ │ */ │ │ │ │ - begin: function() { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = undefined; │ │ │ │ - this.points = []; │ │ │ │ - }, │ │ │ │ + symbolizer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Updates during the dragging. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The new position. │ │ │ │ + * Property: symbolizers │ │ │ │ + * {Array} Collection of symbolizers associated with this rule. If │ │ │ │ + * provided at construction, the symbolizers array has precedence │ │ │ │ + * over the deprecated symbolizer property. Note that multiple │ │ │ │ + * symbolizers are not currently supported by the vector renderers. │ │ │ │ + * Rules with multiple symbolizers are currently only useful for │ │ │ │ + * maintaining elements in an SLD document. │ │ │ │ */ │ │ │ │ - update: function(xy) { │ │ │ │ - this.points.unshift({ │ │ │ │ - xy: xy, │ │ │ │ - tick: new Date().getTime() │ │ │ │ - }); │ │ │ │ - if (this.points.length > this.nbPoints) { │ │ │ │ - this.points.pop(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + symbolizers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: end │ │ │ │ - * Ends the dragging, start the kinetic. │ │ │ │ + * APIProperty: minScaleDenominator │ │ │ │ + * {Number} or {String} minimum scale at which to draw the feature. │ │ │ │ + * In the case of a String, this can be a combination of text and │ │ │ │ + * propertyNames in the form "literal ${propertyName}" │ │ │ │ + */ │ │ │ │ + minScaleDenominator: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: maxScaleDenominator │ │ │ │ + * {Number} or {String} maximum scale at which to draw the feature. │ │ │ │ + * In the case of a String, this can be a combination of text and │ │ │ │ + * propertyNames in the form "literal ${propertyName}" │ │ │ │ + */ │ │ │ │ + maxScaleDenominator: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Rule │ │ │ │ + * Creates a Rule. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The last position. │ │ │ │ - * │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * rule │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object with two properties: "speed", and "theta". The │ │ │ │ - * "speed" and "theta" values are to be passed to the move │ │ │ │ - * function when starting the animation. │ │ │ │ + * {<OpenLayers.Rule>} │ │ │ │ */ │ │ │ │ - end: function(xy) { │ │ │ │ - var last, now = new Date().getTime(); │ │ │ │ - for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ - point = this.points[i]; │ │ │ │ - if (now - point.tick > this.delay) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - last = point; │ │ │ │ - } │ │ │ │ - if (!last) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var time = new Date().getTime() - last.tick; │ │ │ │ - var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + │ │ │ │ - Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ - var speed = dist / time; │ │ │ │ - if (speed == 0 || speed < this.threshold) { │ │ │ │ - return; │ │ │ │ + initialize: function(options) { │ │ │ │ + this.symbolizer = {}; │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + delete this.symbolizer; │ │ │ │ } │ │ │ │ - var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ - if (last.xy.x <= xy.x) { │ │ │ │ - theta = Math.PI - theta; │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + for (var i in this.symbolizer) { │ │ │ │ + this.symbolizer[i] = null; │ │ │ │ } │ │ │ │ - return { │ │ │ │ - speed: speed, │ │ │ │ - theta: theta │ │ │ │ - }; │ │ │ │ + this.symbolizer = null; │ │ │ │ + delete this.symbolizers; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: move │ │ │ │ - * Launch the kinetic move pan. │ │ │ │ - * │ │ │ │ + * APIMethod: evaluate │ │ │ │ + * evaluates this rule for a specific feature │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * info - {Object} An object with two properties, "speed", and "theta". │ │ │ │ - * These values are those returned from the "end" call. │ │ │ │ - * callback - {Function} Function called on every step of the animation, │ │ │ │ - * receives x, y (values to pan), end (is the last point). │ │ │ │ + * feature - {<OpenLayers.Feature>} feature to apply the rule to. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} true if the rule applies, false if it does not. │ │ │ │ + * This rule is the default rule and always returns true. │ │ │ │ */ │ │ │ │ - move: function(info, callback) { │ │ │ │ - var v0 = info.speed; │ │ │ │ - var fx = Math.cos(info.theta); │ │ │ │ - var fy = -Math.sin(info.theta); │ │ │ │ + evaluate: function(feature) { │ │ │ │ + var context = this.getContext(feature); │ │ │ │ + var applies = true; │ │ │ │ │ │ │ │ - var initialTime = new Date().getTime(); │ │ │ │ + if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ + var scale = feature.layer.map.getScale(); │ │ │ │ + } │ │ │ │ │ │ │ │ - var lastX = 0; │ │ │ │ - var lastY = 0; │ │ │ │ + // check if within minScale/maxScale bounds │ │ │ │ + if (this.minScaleDenominator) { │ │ │ │ + applies = scale >= OpenLayers.Style.createLiteral( │ │ │ │ + this.minScaleDenominator, context); │ │ │ │ + } │ │ │ │ + if (applies && this.maxScaleDenominator) { │ │ │ │ + applies = scale < OpenLayers.Style.createLiteral( │ │ │ │ + this.maxScaleDenominator, context); │ │ │ │ + } │ │ │ │ │ │ │ │ - var timerCallback = function() { │ │ │ │ - if (this.timerId == null) { │ │ │ │ - return; │ │ │ │ + // check if optional filter applies │ │ │ │ + if (applies && this.filter) { │ │ │ │ + // feature id filters get the feature, others get the context │ │ │ │ + if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ + applies = this.filter.evaluate(feature); │ │ │ │ + } else { │ │ │ │ + applies = this.filter.evaluate(context); │ │ │ │ } │ │ │ │ + } │ │ │ │ │ │ │ │ - var t = new Date().getTime() - initialTime; │ │ │ │ - │ │ │ │ - var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t; │ │ │ │ - var x = p * fx; │ │ │ │ - var y = p * fy; │ │ │ │ + return applies; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var args = {}; │ │ │ │ - args.end = false; │ │ │ │ - var v = -this.deceleration * t + v0; │ │ │ │ + /** │ │ │ │ + * Method: getContext │ │ │ │ + * Gets the context for evaluating this rule │ │ │ │ + * │ │ │ │ + * Paramters: │ │ │ │ + * feature - {<OpenLayers.Feature>} feature to take the context from if │ │ │ │ + * none is specified. │ │ │ │ + */ │ │ │ │ + getContext: function(feature) { │ │ │ │ + var context = this.context; │ │ │ │ + if (!context) { │ │ │ │ + context = feature.attributes || feature.data; │ │ │ │ + } │ │ │ │ + if (typeof this.context == "function") { │ │ │ │ + context = this.context(feature); │ │ │ │ + } │ │ │ │ + return context; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (v <= 0) { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - args.end = true; │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this rule. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Rule>} Clone of this rule. │ │ │ │ + */ │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + // clone symbolizers │ │ │ │ + var len = this.symbolizers.length; │ │ │ │ + options.symbolizers = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + options.symbolizers[i] = this.symbolizers[i].clone(); │ │ │ │ } │ │ │ │ - │ │ │ │ - args.x = x - lastX; │ │ │ │ - args.y = y - lastY; │ │ │ │ - lastX = x; │ │ │ │ - lastY = y; │ │ │ │ - callback(args.x, args.y, args.end); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - this.timerId = OpenLayers.Animation.start( │ │ │ │ - OpenLayers.Function.bind(timerCallback, this) │ │ │ │ - ); │ │ │ │ + } else { │ │ │ │ + // clone symbolizer │ │ │ │ + options.symbolizer = {}; │ │ │ │ + var value, type; │ │ │ │ + for (var key in this.symbolizer) { │ │ │ │ + value = this.symbolizer[key]; │ │ │ │ + type = typeof value; │ │ │ │ + if (type === "object") { │ │ │ │ + options.symbolizer[key] = OpenLayers.Util.extend({}, value); │ │ │ │ + } else if (type === "string") { │ │ │ │ + options.symbolizer[key] = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // clone filter │ │ │ │ + options.filter = this.filter && this.filter.clone(); │ │ │ │ + // clone context │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + return new OpenLayers.Rule(options); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ + CLASS_NAME: "OpenLayers.Rule" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer.js │ │ │ │ + OpenLayers/Strategy.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Map.js │ │ │ │ - * @requires OpenLayers/Projection.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer │ │ │ │ + * Class: OpenLayers.Strategy │ │ │ │ + * Abstract vector layer strategy class. Not to be instantiated directly. Use │ │ │ │ + * one of the strategy subclasses instead. │ │ │ │ */ │ │ │ │ -OpenLayers.Layer = OpenLayers.Class({ │ │ │ │ +OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: id │ │ │ │ - * {String} │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The layer this strategy belongs to. │ │ │ │ */ │ │ │ │ - id: null, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} │ │ │ │ + /** │ │ │ │ + * Property: options │ │ │ │ + * {Object} Any options sent to the constructor. │ │ │ │ */ │ │ │ │ - name: null, │ │ │ │ + options: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: div │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - div: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: opacity │ │ │ │ - * {Float} The layer's opacity. Float number between 0.0 and 1.0. Default │ │ │ │ - * is 1. │ │ │ │ + * Property: active │ │ │ │ + * {Boolean} The control is active. │ │ │ │ */ │ │ │ │ - opacity: 1, │ │ │ │ + active: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: alwaysInRange │ │ │ │ - * {Boolean} If a layer's display should not be scale-based, this should │ │ │ │ - * be set to true. This will cause the layer, as an overlay, to always │ │ │ │ - * be 'active', by always returning true from the calculateInRange() │ │ │ │ - * function. │ │ │ │ - * │ │ │ │ - * If not explicitly specified for a layer, its value will be │ │ │ │ - * determined on startup in initResolutions() based on whether or not │ │ │ │ - * any scale-specific properties have been set as options on the │ │ │ │ - * layer. If no scale-specific options have been set on the layer, we │ │ │ │ - * assume that it should always be in range. │ │ │ │ - * │ │ │ │ - * See #987 for more info. │ │ │ │ + * Property: autoActivate │ │ │ │ + * {Boolean} The creator of the strategy can set autoActivate to false │ │ │ │ + * to fully control when the protocol is activated and deactivated. │ │ │ │ + * Defaults to true. │ │ │ │ */ │ │ │ │ - alwaysInRange: null, │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: RESOLUTION_PROPERTIES │ │ │ │ - * {Array} The properties that are used for calculating resolutions │ │ │ │ - * information. │ │ │ │ + * Property: autoDestroy │ │ │ │ + * {Boolean} The creator of the strategy can set autoDestroy to false │ │ │ │ + * to fully control when the strategy is destroyed. Defaults to │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - RESOLUTION_PROPERTIES: [ │ │ │ │ - 'scales', 'resolutions', │ │ │ │ - 'maxScale', 'minScale', │ │ │ │ - 'maxResolution', 'minResolution', │ │ │ │ - 'numZoomLevels', 'maxZoomLevel' │ │ │ │ - ], │ │ │ │ + autoDestroy: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * layer.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 layer.events.object. │ │ │ │ - * element - {DOMElement} A reference to layer.events.element. │ │ │ │ + * Constructor: OpenLayers.Strategy │ │ │ │ + * Abstract class for vector strategies. Create instances of a subclass. │ │ │ │ * │ │ │ │ - * Supported map event types: │ │ │ │ - * loadstart - Triggered when layer loading starts. When using a Vector │ │ │ │ - * layer with a Fixed or BBOX strategy, the event object includes │ │ │ │ - * a *filter* property holding the OpenLayers.Filter used when │ │ │ │ - * calling read on the protocol. │ │ │ │ - * loadend - Triggered when layer loading ends. When using a Vector layer │ │ │ │ - * with a Fixed or BBOX strategy, the event object includes a │ │ │ │ - * *response* property holding an OpenLayers.Protocol.Response object. │ │ │ │ - * visibilitychanged - Triggered when the layer's visibility property is │ │ │ │ - * changed, e.g. by turning the layer on or off in the layer switcher. │ │ │ │ - * Note that the actual visibility of the layer can also change if it │ │ │ │ - * gets out of range (see <calculateInRange>). If you also want to catch │ │ │ │ - * these cases, register for the map's 'changelayer' event instead. │ │ │ │ - * move - Triggered when layer moves (triggered with every mousemove │ │ │ │ - * during a drag). │ │ │ │ - * moveend - Triggered when layer is done moving, object passed as │ │ │ │ - * argument has a zoomChanged boolean property which tells that the │ │ │ │ - * zoom has changed. │ │ │ │ - * added - Triggered after the layer is added to a map. Listeners will │ │ │ │ - * receive an object with a *map* property referencing the map and a │ │ │ │ - * *layer* property referencing the layer. │ │ │ │ - * removed - Triggered after the layer is removed from the map. Listeners │ │ │ │ - * will receive an object with a *map* property referencing the map and │ │ │ │ - * a *layer* property referencing the layer. │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - events: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ + // set the active property here, so that user cannot override it │ │ │ │ + this.active = false; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: map │ │ │ │ - * {<OpenLayers.Map>} This variable is set when the layer is added to │ │ │ │ - * the map, via the accessor function setMap(). │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the strategy. │ │ │ │ */ │ │ │ │ - map: null, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = null; │ │ │ │ + this.options = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: isBaseLayer │ │ │ │ - * {Boolean} Whether or not the layer is a base layer. This should be set │ │ │ │ - * individually by all subclasses. Default is false │ │ │ │ + * Method: setLayer │ │ │ │ + * Called to set the <layer> property. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ */ │ │ │ │ - isBaseLayer: false, │ │ │ │ + setLayer: function(layer) { │ │ │ │ + this.layer = layer; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: alpha │ │ │ │ - * {Boolean} The layer's images have an alpha channel. Default is false. │ │ │ │ - */ │ │ │ │ - alpha: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: displayInLayerSwitcher │ │ │ │ - * {Boolean} Display the layer's name in the layer switcher. Default is │ │ │ │ - * true. │ │ │ │ + * Method: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ */ │ │ │ │ - displayInLayerSwitcher: true, │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + this.active = true; │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: visibility │ │ │ │ - * {Boolean} The layer should be displayed in the map. Default is true. │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ + * the strategy was already inactive. │ │ │ │ */ │ │ │ │ - visibility: true, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.active = false; │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: attribution │ │ │ │ - * {String} Attribution string, displayed when an │ │ │ │ - * <OpenLayers.Control.Attribution> has been added to the map. │ │ │ │ - */ │ │ │ │ - attribution: null, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy/Fixed.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: inRange │ │ │ │ - * {Boolean} The current map resolution is within the layer's min/max │ │ │ │ - * range. This is set in <OpenLayers.Map.setCenter> whenever the zoom │ │ │ │ - * changes. │ │ │ │ - */ │ │ │ │ - inRange: false, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Propery: imageSize │ │ │ │ - * {<OpenLayers.Size>} For layers with a gutter, the image is larger than │ │ │ │ - * the tile by twice the gutter in each dimension. │ │ │ │ - */ │ │ │ │ - imageSize: null, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - // OPTIONS │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Fixed │ │ │ │ + * A simple strategy that requests features once and never requests new data. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: options │ │ │ │ - * {Object} An optional object whose properties will be set on the layer. │ │ │ │ - * Any of the layer properties can be set as a property of the options │ │ │ │ - * object and sent to the constructor when the layer is created. │ │ │ │ + /** │ │ │ │ + * APIProperty: preload │ │ │ │ + * {Boolean} Load data before layer made visible. Enabling this may result │ │ │ │ + * in considerable overhead if your application loads many data layers │ │ │ │ + * that are not visible by default. Default is false. │ │ │ │ */ │ │ │ │ - options: null, │ │ │ │ + preload: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: eventListeners │ │ │ │ - * {Object} If set as an option at construction, the eventListeners │ │ │ │ - * object will be registered with <OpenLayers.Events.on>. Object │ │ │ │ - * structure must be a listeners object as shown in the example for │ │ │ │ - * the events.on method. │ │ │ │ + * Constructor: OpenLayers.Strategy.Fixed │ │ │ │ + * Create a new Fixed strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - eventListeners: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: gutter │ │ │ │ - * {Integer} Determines the width (in pixels) of the gutter around image │ │ │ │ - * tiles to ignore. By setting this property to a non-zero value, │ │ │ │ - * images will be requested that are wider and taller than the tile │ │ │ │ - * size by a value of 2 x gutter. This allows artifacts of rendering │ │ │ │ - * at tile edges to be ignored. Set a gutter value that is equal to │ │ │ │ - * half the size of the widest symbol that needs to be displayed. │ │ │ │ - * Defaults to zero. Non-tiled layers always have zero gutter. │ │ │ │ + * Method: activate │ │ │ │ + * Activate the strategy: load data or add listener to load when visible │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ */ │ │ │ │ - gutter: 0, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "refresh": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (this.layer.visibility == true || this.preload) { │ │ │ │ + this.load(); │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: projection │ │ │ │ - * {<OpenLayers.Projection>} or {<String>} Specifies the projection of the layer. │ │ │ │ - * Can be set in the layer options. If not specified in the layer options, │ │ │ │ - * it is set to the default projection specified in the map, │ │ │ │ - * when the layer is added to the map. │ │ │ │ - * Projection along with default maxExtent and resolutions │ │ │ │ - * are set automatically with commercial baselayers in EPSG:3857, │ │ │ │ - * such as Google, Bing and OpenStreetMap, and do not need to be specified. │ │ │ │ - * Otherwise, if specifying projection, also set maxExtent, │ │ │ │ - * maxResolution or resolutions as appropriate. │ │ │ │ - * When using vector layers with strategies, layer projection should be set │ │ │ │ - * to the projection of the source data if that is different from the map default. │ │ │ │ - * │ │ │ │ - * Can be either a string or an <OpenLayers.Projection> object; │ │ │ │ - * if a string is passed, will be converted to an object when │ │ │ │ - * the layer is added to the map. │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the strategy. Undo what is done in <activate>. │ │ │ │ * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ */ │ │ │ │ - projection: null, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "refresh": this.load, │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: units │ │ │ │ - * {String} The layer map units. Defaults to null. Possible values │ │ │ │ - * are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. │ │ │ │ - * Normally taken from the projection. │ │ │ │ - * Only required if both map and layers do not define a projection, │ │ │ │ - * or if they define a projection which does not define units. │ │ │ │ + * Method: load │ │ │ │ + * Tells protocol to load data and unhooks the visibilitychanged event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} options to pass to protocol read. │ │ │ │ */ │ │ │ │ - units: null, │ │ │ │ + load: function(options) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.events.triggerEvent("loadstart", { │ │ │ │ + filter: layer.filter │ │ │ │ + }); │ │ │ │ + layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: this.merge, │ │ │ │ + filter: layer.filter, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ + layer.events.un({ │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: scales │ │ │ │ - * {Array} An array of map scales in descending order. The values in the │ │ │ │ - * array correspond to the map scale denominator. Note that these │ │ │ │ - * values only make sense if the display (monitor) resolution of the │ │ │ │ - * client is correctly guessed by whomever is configuring the │ │ │ │ - * application. In addition, the units property must also be set. │ │ │ │ - * Use <resolutions> instead wherever possible. │ │ │ │ + * Method: merge │ │ │ │ + * Add all features to the layer. │ │ │ │ + * If the layer projection differs from the map projection, features │ │ │ │ + * will be transformed from the layer projection to the map projection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ + * by the protocol. │ │ │ │ */ │ │ │ │ - scales: null, │ │ │ │ + merge: function(resp) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.destroyFeatures(); │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = layer.projection; │ │ │ │ + var local = layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + layer.addFeatures(features); │ │ │ │ + } │ │ │ │ + layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: resolutions │ │ │ │ - * {Array} 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, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Filter.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: maxExtent │ │ │ │ - * {<OpenLayers.Bounds>|Array} If provided as an array, the array │ │ │ │ - * should consist of four values (left, bottom, right, top). │ │ │ │ - * The maximum extent for the layer. Defaults to null. │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Style.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Filter │ │ │ │ + * This class represents an OGC Filter. │ │ │ │ + */ │ │ │ │ +OpenLayers.Filter = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Filter │ │ │ │ + * This class represents a generic filter. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ * │ │ │ │ - * The center of these bounds will not stray outside │ │ │ │ - * of the viewport extent during panning. In addition, if │ │ │ │ - * <displayOutsideMaxExtent> is set to false, data will not be │ │ │ │ - * requested that falls completely outside of these bounds. │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter>} │ │ │ │ */ │ │ │ │ - maxExtent: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: minExtent │ │ │ │ - * {<OpenLayers.Bounds>|Array} If provided as an array, the array │ │ │ │ - * should consist of four values (left, bottom, right, top). │ │ │ │ - * The minimum extent for the layer. Defaults to null. │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Remove reference to anything added. │ │ │ │ */ │ │ │ │ - minExtent: null, │ │ │ │ + destroy: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxResolution │ │ │ │ - * {Float} Default max is 360 deg / 256 px, which corresponds to │ │ │ │ - * zoom level 0 on gmaps. Specify a different value in the layer │ │ │ │ - * options if you are not using the default <OpenLayers.Map.tileSize> │ │ │ │ - * and displaying the whole world. │ │ │ │ + * APIMethod: evaluate │ │ │ │ + * Evaluates this filter in a specific context. Instances or subclasses │ │ │ │ + * are supposed to override this method. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} Context to use in evaluating the filter. If a vector │ │ │ │ + * feature is provided, the feature.attributes will be used as context. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The filter applies. │ │ │ │ */ │ │ │ │ - maxResolution: null, │ │ │ │ + evaluate: function(context) { │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: minResolution │ │ │ │ - * {Float} │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this filter. Should be implemented by subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter>} Clone of this filter. │ │ │ │ */ │ │ │ │ - minResolution: null, │ │ │ │ + clone: function() { │ │ │ │ + return null; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: numZoomLevels │ │ │ │ - * {Integer} │ │ │ │ + * APIMethod: toString │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} Include <OpenLayers.Format.CQL> in your build to get a CQL │ │ │ │ + * representation of the filter returned. Otherwise "[Object object]" │ │ │ │ + * will be returned. │ │ │ │ */ │ │ │ │ - numZoomLevels: null, │ │ │ │ + toString: function() { │ │ │ │ + var string; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.CQL) { │ │ │ │ + string = OpenLayers.Format.CQL.prototype.write(this); │ │ │ │ + } else { │ │ │ │ + string = Object.prototype.toString.call(this); │ │ │ │ + } │ │ │ │ + return string; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Filter" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Filter/Spatial.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Filter.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Filter.Spatial │ │ │ │ + * This class represents a spatial filter. │ │ │ │ + * Currently implemented: BBOX, DWithin and Intersects │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Filter> │ │ │ │ + */ │ │ │ │ +OpenLayers.Filter.Spatial = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} Type of spatial filter. │ │ │ │ + * │ │ │ │ + * The type should be one of: │ │ │ │ + * - OpenLayers.Filter.Spatial.BBOX │ │ │ │ + * - OpenLayers.Filter.Spatial.INTERSECTS │ │ │ │ + * - OpenLayers.Filter.Spatial.DWITHIN │ │ │ │ + * - OpenLayers.Filter.Spatial.WITHIN │ │ │ │ + * - OpenLayers.Filter.Spatial.CONTAINS │ │ │ │ + */ │ │ │ │ + type: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: property │ │ │ │ + * {String} Name of the context property to compare. │ │ │ │ + */ │ │ │ │ + property: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: value │ │ │ │ + * {<OpenLayers.Bounds> || <OpenLayers.Geometry>} The bounds or geometry │ │ │ │ + * to be used by the filter. Use bounds for BBOX filters and geometry │ │ │ │ + * for INTERSECTS or DWITHIN filters. │ │ │ │ + */ │ │ │ │ + value: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: distance │ │ │ │ + * {Number} The distance to use in a DWithin spatial filter. │ │ │ │ + */ │ │ │ │ + distance: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: distanceUnits │ │ │ │ + * {String} The units to use for the distance, e.g. 'm'. │ │ │ │ + */ │ │ │ │ + distanceUnits: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Filter.Spatial │ │ │ │ + * Creates a spatial filter. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * filter. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter.Spatial>} │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: evaluate │ │ │ │ + * Evaluates this filter for a specific feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} feature to apply the filter to. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The feature meets filter criteria. │ │ │ │ + */ │ │ │ │ + evaluate: function(feature) { │ │ │ │ + var intersect = false; │ │ │ │ + switch (this.type) { │ │ │ │ + case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ + case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ + if (feature.geometry) { │ │ │ │ + var geom = this.value; │ │ │ │ + if (this.value.CLASS_NAME == "OpenLayers.Bounds") { │ │ │ │ + geom = this.value.toGeometry(); │ │ │ │ + } │ │ │ │ + if (feature.geometry.intersects(geom)) { │ │ │ │ + intersect = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + throw new Error('evaluate is not implemented for this filter type.'); │ │ │ │ + } │ │ │ │ + return intersect; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this filter. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter.Spatial>} Clone of this filter. │ │ │ │ + */ │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.applyDefaults({ │ │ │ │ + value: this.value && this.value.clone && this.value.clone() │ │ │ │ + }, this); │ │ │ │ + return new OpenLayers.Filter.Spatial(options); │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Filter.Spatial" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +OpenLayers.Filter.Spatial.BBOX = "BBOX"; │ │ │ │ +OpenLayers.Filter.Spatial.INTERSECTS = "INTERSECTS"; │ │ │ │ +OpenLayers.Filter.Spatial.DWITHIN = "DWITHIN"; │ │ │ │ +OpenLayers.Filter.Spatial.WITHIN = "WITHIN"; │ │ │ │ +OpenLayers.Filter.Spatial.CONTAINS = "CONTAINS"; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy/BBOX.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.BBOX │ │ │ │ + * A simple strategy that reads new features when the viewport invalidates │ │ │ │ + * some bounds. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: bounds │ │ │ │ + * {<OpenLayers.Bounds>} The current data bounds (in the same projection │ │ │ │ + * as the layer - not always the same projection as the map). │ │ │ │ + */ │ │ │ │ + bounds: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: resolution │ │ │ │ + * {Float} The current data resolution. │ │ │ │ + */ │ │ │ │ + resolution: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: ratio │ │ │ │ + * {Float} The ratio of the data bounds to the viewport bounds (in each │ │ │ │ + * dimension). Default is 2. │ │ │ │ + */ │ │ │ │ + ratio: 2, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: resFactor │ │ │ │ + * {Float} Optional factor used to determine when previously requested │ │ │ │ + * features are invalid. If set, the resFactor will be compared to the │ │ │ │ + * resolution of the previous request to the current map resolution. │ │ │ │ + * If resFactor > (old / new) and 1/resFactor < (old / new). If you │ │ │ │ + * set a resFactor of 1, data will be requested every time the │ │ │ │ + * resolution changes. If you set a resFactor of 3, data will be │ │ │ │ + * requested if the old resolution is 3 times the new, or if the new is │ │ │ │ + * 3 times the old. If the old bounds do not contain the new bounds │ │ │ │ + * new data will always be requested (with or without considering │ │ │ │ + * resFactor). │ │ │ │ + */ │ │ │ │ + resFactor: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: response │ │ │ │ + * {<OpenLayers.Protocol.Response>} The protocol response object returned │ │ │ │ + * by the layer protocol. │ │ │ │ + */ │ │ │ │ + response: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Strategy.BBOX │ │ │ │ + * Create a new BBOX strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + * Set up strategy with regard to reading new batches of remote data. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully activated. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "moveend": this.update, │ │ │ │ + "refresh": this.update, │ │ │ │ + "visibilitychanged": this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.update(); │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + * Tear down strategy with regard to reading new batches of remote data. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "moveend": this.update, │ │ │ │ + "refresh": this.update, │ │ │ │ + "visibilitychanged": this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ + * Callback function called on "moveend" or "refresh" layer events. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will determine │ │ │ │ + * the behaviour of this Strategy │ │ │ │ + * │ │ │ │ + * Valid options include: │ │ │ │ + * force - {Boolean} if true, new data must be unconditionally read. │ │ │ │ + * noAbort - {Boolean} if true, do not abort previous requests. │ │ │ │ + */ │ │ │ │ + update: function(options) { │ │ │ │ + var mapBounds = this.getMapBounds(); │ │ │ │ + if (mapBounds !== null && ((options && options.force) || │ │ │ │ + (this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds)))) { │ │ │ │ + this.calculateBounds(mapBounds); │ │ │ │ + this.resolution = this.layer.map.getResolution(); │ │ │ │ + this.triggerRead(options); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getMapBounds │ │ │ │ + * Get the map bounds expressed in the same projection as this layer. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} Map bounds in the projection of the layer. │ │ │ │ + */ │ │ │ │ + getMapBounds: function() { │ │ │ │ + if (this.layer.map === null) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + var bounds = this.layer.map.getExtent(); │ │ │ │ + if (bounds && !this.layer.projection.equals( │ │ │ │ + this.layer.map.getProjectionObject())) { │ │ │ │ + bounds = bounds.clone().transform( │ │ │ │ + this.layer.map.getProjectionObject(), this.layer.projection │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return bounds; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: invalidBounds │ │ │ │ + * Determine whether the previously requested set of features is invalid. │ │ │ │ + * This occurs when the new map bounds do not contain the previously │ │ │ │ + * requested bounds. In addition, if <resFactor> is set, it will be │ │ │ │ + * considered. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ + * retrieved from the map object if not provided │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + invalidBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds(); │ │ │ │ + } │ │ │ │ + var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ + if (!invalid && this.resFactor) { │ │ │ │ + var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ + invalid = (ratio >= this.resFactor || ratio <= (1 / this.resFactor)); │ │ │ │ + } │ │ │ │ + return invalid; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: calculateBounds │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ + * retrieved from the map object if not provided │ │ │ │ + */ │ │ │ │ + calculateBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds(); │ │ │ │ + } │ │ │ │ + var center = mapBounds.getCenterLonLat(); │ │ │ │ + var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ + var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ + this.bounds = new OpenLayers.Bounds( │ │ │ │ + center.lon - (dataWidth / 2), │ │ │ │ + center.lat - (dataHeight / 2), │ │ │ │ + center.lon + (dataWidth / 2), │ │ │ │ + center.lat + (dataHeight / 2) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: triggerRead │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Additional options for the protocol's read method │ │ │ │ + * (optional) │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} The protocol response object │ │ │ │ + * returned by the layer protocol. │ │ │ │ + */ │ │ │ │ + triggerRead: function(options) { │ │ │ │ + if (this.response && !(options && options.noAbort === true)) { │ │ │ │ + this.layer.protocol.abort(this.response); │ │ │ │ + this.layer.events.triggerEvent("loadend"); │ │ │ │ + } │ │ │ │ + var evt = { │ │ │ │ + filter: this.createFilter() │ │ │ │ + }; │ │ │ │ + this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ + this.response = this.layer.protocol.read( │ │ │ │ + OpenLayers.Util.applyDefaults({ │ │ │ │ + filter: evt.filter, │ │ │ │ + callback: this.merge, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createFilter │ │ │ │ + * Creates a spatial BBOX filter. If the layer that this strategy belongs │ │ │ │ + * to has a filter property, this filter will be combined with the BBOX │ │ │ │ + * filter. │ │ │ │ + * │ │ │ │ + * Returns │ │ │ │ + * {<OpenLayers.Filter>} The filter object. │ │ │ │ + */ │ │ │ │ + createFilter: function() { │ │ │ │ + var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + value: this.bounds, │ │ │ │ + projection: this.layer.projection │ │ │ │ + }); │ │ │ │ + if (this.layer.filter) { │ │ │ │ + filter = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.layer.filter, filter] │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return filter; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: merge │ │ │ │ + * Given a list of features, determine which ones to add to the layer. │ │ │ │ + * If the layer projection differs from the map projection, features │ │ │ │ + * will be transformed from the layer projection to the map projection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ + * by the protocol. │ │ │ │ + */ │ │ │ │ + merge: function(resp) { │ │ │ │ + this.layer.destroyFeatures(); │ │ │ │ + if (resp.success()) { │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = this.layer.projection; │ │ │ │ + var local = this.layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.addFeatures(features); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.bounds = null; │ │ │ │ + } │ │ │ │ + this.response = null; │ │ │ │ + this.layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Layer.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Map.js │ │ │ │ + * @requires OpenLayers/Projection.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: id │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + id: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + name: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: div │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + div: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: opacity │ │ │ │ + * {Float} The layer's opacity. Float number between 0.0 and 1.0. Default │ │ │ │ + * is 1. │ │ │ │ + */ │ │ │ │ + opacity: 1, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: alwaysInRange │ │ │ │ + * {Boolean} If a layer's display should not be scale-based, this should │ │ │ │ + * be set to true. This will cause the layer, as an overlay, to always │ │ │ │ + * be 'active', by always returning true from the calculateInRange() │ │ │ │ + * function. │ │ │ │ + * │ │ │ │ + * If not explicitly specified for a layer, its value will be │ │ │ │ + * determined on startup in initResolutions() based on whether or not │ │ │ │ + * any scale-specific properties have been set as options on the │ │ │ │ + * layer. If no scale-specific options have been set on the layer, we │ │ │ │ + * assume that it should always be in range. │ │ │ │ + * │ │ │ │ + * See #987 for more info. │ │ │ │ + */ │ │ │ │ + alwaysInRange: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constant: RESOLUTION_PROPERTIES │ │ │ │ + * {Array} The properties that are used for calculating resolutions │ │ │ │ + * information. │ │ │ │ + */ │ │ │ │ + RESOLUTION_PROPERTIES: [ │ │ │ │ + 'scales', 'resolutions', │ │ │ │ + 'maxScale', 'minScale', │ │ │ │ + 'maxResolution', 'minResolution', │ │ │ │ + 'numZoomLevels', 'maxZoomLevel' │ │ │ │ + ], │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * layer.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 layer.events.object. │ │ │ │ + * element - {DOMElement} A reference to layer.events.element. │ │ │ │ + * │ │ │ │ + * Supported map event types: │ │ │ │ + * loadstart - Triggered when layer loading starts. When using a Vector │ │ │ │ + * layer with a Fixed or BBOX strategy, the event object includes │ │ │ │ + * a *filter* property holding the OpenLayers.Filter used when │ │ │ │ + * calling read on the protocol. │ │ │ │ + * loadend - Triggered when layer loading ends. When using a Vector layer │ │ │ │ + * with a Fixed or BBOX strategy, the event object includes a │ │ │ │ + * *response* property holding an OpenLayers.Protocol.Response object. │ │ │ │ + * visibilitychanged - Triggered when the layer's visibility property is │ │ │ │ + * changed, e.g. by turning the layer on or off in the layer switcher. │ │ │ │ + * Note that the actual visibility of the layer can also change if it │ │ │ │ + * gets out of range (see <calculateInRange>). If you also want to catch │ │ │ │ + * these cases, register for the map's 'changelayer' event instead. │ │ │ │ + * move - Triggered when layer moves (triggered with every mousemove │ │ │ │ + * during a drag). │ │ │ │ + * moveend - Triggered when layer is done moving, object passed as │ │ │ │ + * argument has a zoomChanged boolean property which tells that the │ │ │ │ + * zoom has changed. │ │ │ │ + * added - Triggered after the layer is added to a map. Listeners will │ │ │ │ + * receive an object with a *map* property referencing the map and a │ │ │ │ + * *layer* property referencing the layer. │ │ │ │ + * removed - Triggered after the layer is removed from the map. Listeners │ │ │ │ + * will receive an object with a *map* property referencing the map and │ │ │ │ + * a *layer* property referencing the layer. │ │ │ │ + */ │ │ │ │ + events: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: map │ │ │ │ + * {<OpenLayers.Map>} This variable is set when the layer is added to │ │ │ │ + * the map, via the accessor function setMap(). │ │ │ │ + */ │ │ │ │ + map: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: isBaseLayer │ │ │ │ + * {Boolean} Whether or not the layer is a base layer. This should be set │ │ │ │ + * individually by all subclasses. Default is false │ │ │ │ + */ │ │ │ │ + isBaseLayer: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: alpha │ │ │ │ + * {Boolean} The layer's images have an alpha channel. Default is false. │ │ │ │ + */ │ │ │ │ + alpha: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: displayInLayerSwitcher │ │ │ │ + * {Boolean} Display the layer's name in the layer switcher. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + displayInLayerSwitcher: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: visibility │ │ │ │ + * {Boolean} The layer should be displayed in the map. Default is true. │ │ │ │ + */ │ │ │ │ + visibility: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: attribution │ │ │ │ + * {String} Attribution string, displayed when an │ │ │ │ + * <OpenLayers.Control.Attribution> has been added to the map. │ │ │ │ + */ │ │ │ │ + attribution: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: inRange │ │ │ │ + * {Boolean} The current map resolution is within the layer's min/max │ │ │ │ + * range. This is set in <OpenLayers.Map.setCenter> whenever the zoom │ │ │ │ + * changes. │ │ │ │ + */ │ │ │ │ + inRange: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Propery: imageSize │ │ │ │ + * {<OpenLayers.Size>} For layers with a gutter, the image is larger than │ │ │ │ + * the tile by twice the gutter in each dimension. │ │ │ │ + */ │ │ │ │ + imageSize: null, │ │ │ │ + │ │ │ │ + // OPTIONS │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: options │ │ │ │ + * {Object} An optional object whose properties will be set on the layer. │ │ │ │ + * Any of the layer properties can be set as a property of the options │ │ │ │ + * object and sent to the constructor when the layer is created. │ │ │ │ + */ │ │ │ │ + options: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: eventListeners │ │ │ │ + * {Object} If set as an option at construction, the eventListeners │ │ │ │ + * object will be registered with <OpenLayers.Events.on>. Object │ │ │ │ + * structure must be a listeners object as shown in the example for │ │ │ │ + * the events.on method. │ │ │ │ + */ │ │ │ │ + eventListeners: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: gutter │ │ │ │ + * {Integer} Determines the width (in pixels) of the gutter around image │ │ │ │ + * tiles to ignore. By setting this property to a non-zero value, │ │ │ │ + * images will be requested that are wider and taller than the tile │ │ │ │ + * size by a value of 2 x gutter. This allows artifacts of rendering │ │ │ │ + * at tile edges to be ignored. Set a gutter value that is equal to │ │ │ │ + * half the size of the widest symbol that needs to be displayed. │ │ │ │ + * Defaults to zero. Non-tiled layers always have zero gutter. │ │ │ │ + */ │ │ │ │ + gutter: 0, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: projection │ │ │ │ + * {<OpenLayers.Projection>} or {<String>} Specifies the projection of the layer. │ │ │ │ + * Can be set in the layer options. If not specified in the layer options, │ │ │ │ + * it is set to the default projection specified in the map, │ │ │ │ + * when the layer is added to the map. │ │ │ │ + * Projection along with default maxExtent and resolutions │ │ │ │ + * are set automatically with commercial baselayers in EPSG:3857, │ │ │ │ + * such as Google, Bing and OpenStreetMap, and do not need to be specified. │ │ │ │ + * Otherwise, if specifying projection, also set maxExtent, │ │ │ │ + * maxResolution or resolutions as appropriate. │ │ │ │ + * When using vector layers with strategies, layer projection should be set │ │ │ │ + * to the projection of the source data if that is different from the map default. │ │ │ │ + * │ │ │ │ + * Can be either a string or an <OpenLayers.Projection> object; │ │ │ │ + * if a string is passed, will be converted to an object when │ │ │ │ + * the layer is added to the map. │ │ │ │ + * │ │ │ │ + */ │ │ │ │ + projection: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: units │ │ │ │ + * {String} The layer map units. Defaults to null. Possible values │ │ │ │ + * are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. │ │ │ │ + * Normally taken from the projection. │ │ │ │ + * Only required if both map and layers do not define a projection, │ │ │ │ + * or if they define a projection which does not define units. │ │ │ │ + */ │ │ │ │ + units: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: scales │ │ │ │ + * {Array} An array of map scales in descending order. The values in the │ │ │ │ + * array correspond to the map scale denominator. Note that these │ │ │ │ + * values only make sense if the display (monitor) resolution of the │ │ │ │ + * client is correctly guessed by whomever is configuring the │ │ │ │ + * application. In addition, the units property must also be set. │ │ │ │ + * Use <resolutions> instead wherever possible. │ │ │ │ + */ │ │ │ │ + scales: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: resolutions │ │ │ │ + * {Array} 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: maxExtent │ │ │ │ + * {<OpenLayers.Bounds>|Array} If provided as an array, the array │ │ │ │ + * should consist of four values (left, bottom, right, top). │ │ │ │ + * The maximum extent for the layer. Defaults to null. │ │ │ │ + * │ │ │ │ + * The center of these bounds will not stray outside │ │ │ │ + * of the viewport extent during panning. In addition, if │ │ │ │ + * <displayOutsideMaxExtent> is set to false, data will not be │ │ │ │ + * requested that falls completely outside of these bounds. │ │ │ │ + */ │ │ │ │ + maxExtent: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: minExtent │ │ │ │ + * {<OpenLayers.Bounds>|Array} If provided as an array, the array │ │ │ │ + * should consist of four values (left, bottom, right, top). │ │ │ │ + * The minimum extent for the layer. Defaults to null. │ │ │ │ + */ │ │ │ │ + minExtent: 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 layer │ │ │ │ + * options if you are not using the default <OpenLayers.Map.tileSize> │ │ │ │ + * and displaying the whole world. │ │ │ │ + */ │ │ │ │ + maxResolution: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: minResolution │ │ │ │ + * {Float} │ │ │ │ + */ │ │ │ │ + minResolution: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: numZoomLevels │ │ │ │ + * {Integer} │ │ │ │ + */ │ │ │ │ + numZoomLevels: null, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIProperty: minScale │ │ │ │ * {Float} │ │ │ │ */ │ │ │ │ minScale: null, │ │ │ │ │ │ │ │ @@ -15217,356 +15999,140 @@ │ │ │ │ this.maxExtent.bottom); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Bing.js │ │ │ │ + OpenLayers/Layer/OSM.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Layer/XYZ.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.Bing │ │ │ │ - * Bing layer using direct tile access as provided by Bing Maps REST Services. │ │ │ │ - * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more │ │ │ │ - * information. Note: Terms of Service compliant use requires the map to be │ │ │ │ - * configured with an <OpenLayers.Control.Attribution> control and the │ │ │ │ - * attribution placed on or near the map. │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.OSM │ │ │ │ + * This layer allows accessing OpenStreetMap tiles. By default the OpenStreetMap │ │ │ │ + * hosted tile.openstreetmap.org Mapnik tileset is used. If you wish to use │ │ │ │ + * a different layer instead, you need to provide a different │ │ │ │ + * URL to the constructor. Here's an example for using OpenCycleMap: │ │ │ │ * │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ * - <OpenLayers.Layer.XYZ> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ +OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: key │ │ │ │ - * {String} API key for Bing maps, get your own key │ │ │ │ - * at http://bingmapsportal.com/ . │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} The layer name. Defaults to "OpenStreetMap" if the first │ │ │ │ + * argument to the constructor is null or undefined. │ │ │ │ */ │ │ │ │ - key: null, │ │ │ │ + name: "OpenStreetMap", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: serverResolutions │ │ │ │ - * {Array} the resolutions provided by the Bing servers. │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} The tileset URL scheme. Defaults to │ │ │ │ + * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png │ │ │ │ + * (the official OSM tileset) if the second argument to the constructor │ │ │ │ + * is null or undefined. To use another tileset you can have something │ │ │ │ + * like this: │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - serverResolutions: [ │ │ │ │ - 156543.03390625, 78271.516953125, 39135.7584765625, │ │ │ │ - 19567.87923828125, 9783.939619140625, 4891.9698095703125, │ │ │ │ - 2445.9849047851562, 1222.9924523925781, 611.4962261962891, │ │ │ │ - 305.74811309814453, 152.87405654907226, 76.43702827453613, │ │ │ │ - 38.218514137268066, 19.109257068634033, 9.554628534317017, │ │ │ │ - 4.777314267158508, 2.388657133579254, 1.194328566789627, │ │ │ │ - 0.5971642833948135, 0.29858214169740677, 0.14929107084870338, │ │ │ │ - 0.07464553542435169 │ │ │ │ + url: [ │ │ │ │ + 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ + 'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ + 'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png' │ │ │ │ ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: attributionTemplate │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - attributionTemplate: '<span class="olBingAttribution ${type}">' + │ │ │ │ - '<div><a target="_blank" href="http://www.bing.com/maps/">' + │ │ │ │ - '<img src="${logo}" /></a></div>${copyrights}' + │ │ │ │ - '<a style="white-space: nowrap" target="_blank" ' + │ │ │ │ - 'href="http://www.microsoft.com/maps/product/terms.html">' + │ │ │ │ - 'Terms of Use</a></span>', │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: metadata │ │ │ │ - * {Object} Metadata for this layer, as returned by the callback script │ │ │ │ - */ │ │ │ │ - metadata: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: protocolRegex │ │ │ │ - * {RegExp} Regular expression to match and replace http: in bing urls │ │ │ │ - */ │ │ │ │ - protocolRegex: /^http:/i, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ - * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ - * used. Default is "Road". │ │ │ │ + * Property: attribution │ │ │ │ + * {String} The layer attribution. │ │ │ │ */ │ │ │ │ - type: "Road", │ │ │ │ + attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: culture │ │ │ │ - * {String} The culture identifier. See http://msdn.microsoft.com/en-us/library/ff701709.aspx │ │ │ │ - * for the definition and the possible values. Default is "en-US". │ │ │ │ + * Property: sphericalMercator │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - culture: "en-US", │ │ │ │ + sphericalMercator: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: metadataParams │ │ │ │ - * {Object} Optional url parameters for the Get Imagery Metadata request │ │ │ │ - * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx │ │ │ │ + * Property: wrapDateLine │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - metadataParams: null, │ │ │ │ + wrapDateLine: true, │ │ │ │ │ │ │ │ /** APIProperty: tileOptions │ │ │ │ * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ * created by this Layer. Default is │ │ │ │ * │ │ │ │ * (code) │ │ │ │ * {crossOriginKeyword: 'anonymous'} │ │ │ │ * (end) │ │ │ │ - */ │ │ │ │ - tileOptions: null, │ │ │ │ - │ │ │ │ - /** APIProperty: protocol │ │ │ │ - * {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo │ │ │ │ - * Can be 'http:' 'https:' or '' │ │ │ │ * │ │ │ │ - * Warning: tiles may not be available under both HTTP and HTTPS protocols. │ │ │ │ - * Microsoft approved use of both HTTP and HTTPS urls for tiles. However │ │ │ │ - * this is undocumented and the Imagery Metadata API always returns HTTP │ │ │ │ - * urls. │ │ │ │ + * When using OSM tilesets other than the default ones, it may be │ │ │ │ + * necessary to set this to │ │ │ │ * │ │ │ │ - * Default is '', unless when executed from a file:/// uri, in which case │ │ │ │ - * it is 'http:'. │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: null} │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * if the server does not send Access-Control-Allow-Origin headers. │ │ │ │ */ │ │ │ │ - protocol: ~window.location.href.indexOf('http') ? '' : 'http:', │ │ │ │ + tileOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Bing │ │ │ │ - * Create a new Bing layer. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var road = new OpenLayers.Layer.Bing({ │ │ │ │ - * name: "My Bing Aerial Layer", │ │ │ │ - * type: "Aerial", │ │ │ │ - * key: "my-api-key-here", │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ + * Constructor: OpenLayers.Layer.OSM │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Configuration properties for the layer. │ │ │ │ - * │ │ │ │ - * Required configuration properties: │ │ │ │ - * key - {String} Bing Maps API key for your application. Get one at │ │ │ │ - * http://bingmapsportal.com/. │ │ │ │ - * type - {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ - * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ - * used. │ │ │ │ - * │ │ │ │ - * Any other documented layer properties can be provided in the config object. │ │ │ │ + * name - {String} The layer name. │ │ │ │ + * url - {String} The tileset URL scheme. │ │ │ │ + * options - {Object} Configuration options for the layer. Any inherited │ │ │ │ + * layer option can be set in this object (e.g. │ │ │ │ + * <OpenLayers.Layer.Grid.buffer>). │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - sphericalMercator: true │ │ │ │ - }, options); │ │ │ │ - var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ - │ │ │ │ - var newArgs = [name, null, options]; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ crossOriginKeyword: 'anonymous' │ │ │ │ - }, this.options.tileOptions); │ │ │ │ - this.loadMetadata(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: loadMetadata │ │ │ │ - */ │ │ │ │ - loadMetadata: function() { │ │ │ │ - this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ - // link the processMetadata method to the global scope and bind it │ │ │ │ - // to this instance │ │ │ │ - window[this._callbackId] = OpenLayers.Function.bind( │ │ │ │ - OpenLayers.Layer.Bing.processMetadata, this │ │ │ │ - ); │ │ │ │ - var params = OpenLayers.Util.applyDefaults({ │ │ │ │ - key: this.key, │ │ │ │ - jsonp: this._callbackId, │ │ │ │ - include: "ImageryProviders" │ │ │ │ - }, this.metadataParams); │ │ │ │ - var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + │ │ │ │ - this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = this._callbackId; │ │ │ │ - document.getElementsByTagName("head")[0].appendChild(script); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: initLayer │ │ │ │ - * │ │ │ │ - * Sets layer properties according to the metadata provided by the API │ │ │ │ - */ │ │ │ │ - initLayer: function() { │ │ │ │ - var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ - var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ - url = url.replace("{culture}", this.culture); │ │ │ │ - url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.url = []; │ │ │ │ - for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ - this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])); │ │ │ │ - } │ │ │ │ - this.addOptions({ │ │ │ │ - maxResolution: Math.min( │ │ │ │ - this.serverResolutions[res.zoomMin], │ │ │ │ - this.maxResolution || Number.POSITIVE_INFINITY │ │ │ │ - ), │ │ │ │ - numZoomLevels: Math.min( │ │ │ │ - res.zoomMax + 1 - res.zoomMin, this.numZoomLevels │ │ │ │ - ) │ │ │ │ - }, true); │ │ │ │ - if (!this.isBaseLayer) { │ │ │ │ - this.redraw(); │ │ │ │ - } │ │ │ │ - this.updateAttribution(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getURL │ │ │ │ - * │ │ │ │ - * Paramters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - if (!this.url) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var xyz = this.getXYZ(bounds), │ │ │ │ - x = xyz.x, │ │ │ │ - y = xyz.y, │ │ │ │ - z = xyz.z; │ │ │ │ - var quadDigits = []; │ │ │ │ - for (var i = z; i > 0; --i) { │ │ │ │ - var digit = '0'; │ │ │ │ - var mask = 1 << (i - 1); │ │ │ │ - if ((x & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - } │ │ │ │ - if ((y & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - digit++; │ │ │ │ - } │ │ │ │ - quadDigits.push(digit); │ │ │ │ - } │ │ │ │ - var quadKey = quadDigits.join(""); │ │ │ │ - var url = this.selectUrl('' + x + y + z, this.url); │ │ │ │ - │ │ │ │ - return OpenLayers.String.format(url, { │ │ │ │ - 'quadkey': quadKey │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: updateAttribution │ │ │ │ - * Updates the attribution according to the requirements outlined in │ │ │ │ - * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html │ │ │ │ - */ │ │ │ │ - updateAttribution: function() { │ │ │ │ - var metadata = this.metadata; │ │ │ │ - if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var res = metadata.resourceSets[0].resources[0]; │ │ │ │ - var extent = this.map.getExtent().transform( │ │ │ │ - this.map.getProjectionObject(), │ │ │ │ - new OpenLayers.Projection("EPSG:4326") │ │ │ │ - ); │ │ │ │ - var providers = res.imageryProviders || [], │ │ │ │ - zoom = OpenLayers.Util.indexOf(this.serverResolutions, │ │ │ │ - this.getServerResolution()), │ │ │ │ - copyrights = "", │ │ │ │ - provider, i, ii, j, jj, bbox, coverage; │ │ │ │ - for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ - provider = providers[i]; │ │ │ │ - for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ - coverage = provider.coverageAreas[j]; │ │ │ │ - // axis order provided is Y,X │ │ │ │ - bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ - if (extent.intersectsBounds(bbox) && │ │ │ │ - zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ - copyrights += provider.attribution + " "; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ - type: this.type.toLowerCase(), │ │ │ │ - logo: logo, │ │ │ │ - copyrights: copyrights │ │ │ │ - }); │ │ │ │ - this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "attribution" │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - */ │ │ │ │ - setMap: function() { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("moveend", this, this.updateAttribution); │ │ │ │ + }, this.options && this.options.tileOptions); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing> │ │ │ │ + * Method: clone │ │ │ │ */ │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Bing(this.options); │ │ │ │ + obj = new OpenLayers.Layer.OSM( │ │ │ │ + this.name, this.url, this.getOptions()); │ │ │ │ } │ │ │ │ - //get all additions from superclasses │ │ │ │ obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.map && │ │ │ │ - this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ - OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Layer.Bing.processMetadata │ │ │ │ - * This function will be bound to an instance, linked to the global scope with │ │ │ │ - * an id, and called by the JSONP script returned by the API. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * metadata - {Object} metadata as returned by the API │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ - this.metadata = metadata; │ │ │ │ - this.initLayer(); │ │ │ │ - var script = document.getElementById(this._callbackId); │ │ │ │ - script.parentNode.removeChild(script); │ │ │ │ - window[this._callbackId] = undefined; // cannot delete from window in IE │ │ │ │ - delete this._callbackId; │ │ │ │ -}; │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Renderer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ @@ -17025,14 +17591,357 @@ │ │ │ │ } │ │ │ │ return maxExtent; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.Vector" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ + OpenLayers/Layer/Bing.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/XYZ.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.Bing │ │ │ │ + * Bing layer using direct tile access as provided by Bing Maps REST Services. │ │ │ │ + * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more │ │ │ │ + * information. Note: Terms of Service compliant use requires the map to be │ │ │ │ + * configured with an <OpenLayers.Control.Attribution> control and the │ │ │ │ + * attribution placed on or near the map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.XYZ> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: key │ │ │ │ + * {String} API key for Bing maps, get your own key │ │ │ │ + * at http://bingmapsportal.com/ . │ │ │ │ + */ │ │ │ │ + key: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: serverResolutions │ │ │ │ + * {Array} the resolutions provided by the Bing servers. │ │ │ │ + */ │ │ │ │ + serverResolutions: [ │ │ │ │ + 156543.03390625, 78271.516953125, 39135.7584765625, │ │ │ │ + 19567.87923828125, 9783.939619140625, 4891.9698095703125, │ │ │ │ + 2445.9849047851562, 1222.9924523925781, 611.4962261962891, │ │ │ │ + 305.74811309814453, 152.87405654907226, 76.43702827453613, │ │ │ │ + 38.218514137268066, 19.109257068634033, 9.554628534317017, │ │ │ │ + 4.777314267158508, 2.388657133579254, 1.194328566789627, │ │ │ │ + 0.5971642833948135, 0.29858214169740677, 0.14929107084870338, │ │ │ │ + 0.07464553542435169 │ │ │ │ + ], │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: attributionTemplate │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + attributionTemplate: '<span class="olBingAttribution ${type}">' + │ │ │ │ + '<div><a target="_blank" href="http://www.bing.com/maps/">' + │ │ │ │ + '<img src="${logo}" /></a></div>${copyrights}' + │ │ │ │ + '<a style="white-space: nowrap" target="_blank" ' + │ │ │ │ + 'href="http://www.microsoft.com/maps/product/terms.html">' + │ │ │ │ + 'Terms of Use</a></span>', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: metadata │ │ │ │ + * {Object} Metadata for this layer, as returned by the callback script │ │ │ │ + */ │ │ │ │ + metadata: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: protocolRegex │ │ │ │ + * {RegExp} Regular expression to match and replace http: in bing urls │ │ │ │ + */ │ │ │ │ + protocolRegex: /^http:/i, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ + * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ + * used. Default is "Road". │ │ │ │ + */ │ │ │ │ + type: "Road", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: culture │ │ │ │ + * {String} The culture identifier. See http://msdn.microsoft.com/en-us/library/ff701709.aspx │ │ │ │ + * for the definition and the possible values. Default is "en-US". │ │ │ │ + */ │ │ │ │ + culture: "en-US", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: metadataParams │ │ │ │ + * {Object} Optional url parameters for the Get Imagery Metadata request │ │ │ │ + * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx │ │ │ │ + */ │ │ │ │ + metadataParams: null, │ │ │ │ + │ │ │ │ + /** APIProperty: tileOptions │ │ │ │ + * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ + * created by this Layer. Default is │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: 'anonymous'} │ │ │ │ + * (end) │ │ │ │ + */ │ │ │ │ + tileOptions: null, │ │ │ │ + │ │ │ │ + /** APIProperty: protocol │ │ │ │ + * {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo │ │ │ │ + * Can be 'http:' 'https:' or '' │ │ │ │ + * │ │ │ │ + * Warning: tiles may not be available under both HTTP and HTTPS protocols. │ │ │ │ + * Microsoft approved use of both HTTP and HTTPS urls for tiles. However │ │ │ │ + * this is undocumented and the Imagery Metadata API always returns HTTP │ │ │ │ + * urls. │ │ │ │ + * │ │ │ │ + * Default is '', unless when executed from a file:/// uri, in which case │ │ │ │ + * it is 'http:'. │ │ │ │ + */ │ │ │ │ + protocol: ~window.location.href.indexOf('http') ? '' : 'http:', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.Bing │ │ │ │ + * Create a new Bing layer. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var road = new OpenLayers.Layer.Bing({ │ │ │ │ + * name: "My Bing Aerial Layer", │ │ │ │ + * type: "Aerial", │ │ │ │ + * key: "my-api-key-here", │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Configuration properties for the layer. │ │ │ │ + * │ │ │ │ + * Required configuration properties: │ │ │ │ + * key - {String} Bing Maps API key for your application. Get one at │ │ │ │ + * http://bingmapsportal.com/. │ │ │ │ + * type - {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ + * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ + * used. │ │ │ │ + * │ │ │ │ + * Any other documented layer properties can be provided in the config object. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + sphericalMercator: true │ │ │ │ + }, options); │ │ │ │ + var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ + │ │ │ │ + var newArgs = [name, null, options]; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: 'anonymous' │ │ │ │ + }, this.options.tileOptions); │ │ │ │ + this.loadMetadata(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: loadMetadata │ │ │ │ + */ │ │ │ │ + loadMetadata: function() { │ │ │ │ + this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ + // link the processMetadata method to the global scope and bind it │ │ │ │ + // to this instance │ │ │ │ + window[this._callbackId] = OpenLayers.Function.bind( │ │ │ │ + OpenLayers.Layer.Bing.processMetadata, this │ │ │ │ + ); │ │ │ │ + var params = OpenLayers.Util.applyDefaults({ │ │ │ │ + key: this.key, │ │ │ │ + jsonp: this._callbackId, │ │ │ │ + include: "ImageryProviders" │ │ │ │ + }, this.metadataParams); │ │ │ │ + var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + │ │ │ │ + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = this._callbackId; │ │ │ │ + document.getElementsByTagName("head")[0].appendChild(script); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: initLayer │ │ │ │ + * │ │ │ │ + * Sets layer properties according to the metadata provided by the API │ │ │ │ + */ │ │ │ │ + initLayer: function() { │ │ │ │ + var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ + var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ + url = url.replace("{culture}", this.culture); │ │ │ │ + url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.url = []; │ │ │ │ + for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ + this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])); │ │ │ │ + } │ │ │ │ + this.addOptions({ │ │ │ │ + maxResolution: Math.min( │ │ │ │ + this.serverResolutions[res.zoomMin], │ │ │ │ + this.maxResolution || Number.POSITIVE_INFINITY │ │ │ │ + ), │ │ │ │ + numZoomLevels: Math.min( │ │ │ │ + res.zoomMax + 1 - res.zoomMin, this.numZoomLevels │ │ │ │ + ) │ │ │ │ + }, true); │ │ │ │ + if (!this.isBaseLayer) { │ │ │ │ + this.redraw(); │ │ │ │ + } │ │ │ │ + this.updateAttribution(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ + * Paramters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + */ │ │ │ │ + getURL: function(bounds) { │ │ │ │ + if (!this.url) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var xyz = this.getXYZ(bounds), │ │ │ │ + x = xyz.x, │ │ │ │ + y = xyz.y, │ │ │ │ + z = xyz.z; │ │ │ │ + var quadDigits = []; │ │ │ │ + for (var i = z; i > 0; --i) { │ │ │ │ + var digit = '0'; │ │ │ │ + var mask = 1 << (i - 1); │ │ │ │ + if ((x & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + } │ │ │ │ + if ((y & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + digit++; │ │ │ │ + } │ │ │ │ + quadDigits.push(digit); │ │ │ │ + } │ │ │ │ + var quadKey = quadDigits.join(""); │ │ │ │ + var url = this.selectUrl('' + x + y + z, this.url); │ │ │ │ + │ │ │ │ + return OpenLayers.String.format(url, { │ │ │ │ + 'quadkey': quadKey │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: updateAttribution │ │ │ │ + * Updates the attribution according to the requirements outlined in │ │ │ │ + * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html │ │ │ │ + */ │ │ │ │ + updateAttribution: function() { │ │ │ │ + var metadata = this.metadata; │ │ │ │ + if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var res = metadata.resourceSets[0].resources[0]; │ │ │ │ + var extent = this.map.getExtent().transform( │ │ │ │ + this.map.getProjectionObject(), │ │ │ │ + new OpenLayers.Projection("EPSG:4326") │ │ │ │ + ); │ │ │ │ + var providers = res.imageryProviders || [], │ │ │ │ + zoom = OpenLayers.Util.indexOf(this.serverResolutions, │ │ │ │ + this.getServerResolution()), │ │ │ │ + copyrights = "", │ │ │ │ + provider, i, ii, j, jj, bbox, coverage; │ │ │ │ + for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ + provider = providers[i]; │ │ │ │ + for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ + coverage = provider.coverageAreas[j]; │ │ │ │ + // axis order provided is Y,X │ │ │ │ + bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ + if (extent.intersectsBounds(bbox) && │ │ │ │ + zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ + copyrights += provider.attribution + " "; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ + type: this.type.toLowerCase(), │ │ │ │ + logo: logo, │ │ │ │ + copyrights: copyrights │ │ │ │ + }); │ │ │ │ + this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "attribution" │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + */ │ │ │ │ + setMap: function() { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("moveend", this, this.updateAttribution); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing> │ │ │ │ + */ │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Bing(this.options); │ │ │ │ + } │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.map && │ │ │ │ + this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ + OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Layer.Bing.processMetadata │ │ │ │ + * This function will be bound to an instance, linked to the global scope with │ │ │ │ + * an id, and called by the JSONP script returned by the API. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * metadata - {Object} metadata as returned by the API │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ + this.metadata = metadata; │ │ │ │ + this.initLayer(); │ │ │ │ + var script = document.getElementById(this._callbackId); │ │ │ │ + script.parentNode.removeChild(script); │ │ │ │ + window[this._callbackId] = undefined; // cannot delete from window in IE │ │ │ │ + delete this._callbackId; │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ OpenLayers/Layer/WMS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -17297,141 +18206,14 @@ │ │ │ │ return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply( │ │ │ │ this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/OSM.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Layer/XYZ.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.OSM │ │ │ │ - * This layer allows accessing OpenStreetMap tiles. By default the OpenStreetMap │ │ │ │ - * hosted tile.openstreetmap.org Mapnik tileset is used. If you wish to use │ │ │ │ - * a different layer instead, you need to provide a different │ │ │ │ - * URL to the constructor. Here's an example for using OpenCycleMap: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ - * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.XYZ> │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} The layer name. Defaults to "OpenStreetMap" if the first │ │ │ │ - * argument to the constructor is null or undefined. │ │ │ │ - */ │ │ │ │ - name: "OpenStreetMap", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} The tileset URL scheme. Defaults to │ │ │ │ - * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png │ │ │ │ - * (the official OSM tileset) if the second argument to the constructor │ │ │ │ - * is null or undefined. To use another tileset you can have something │ │ │ │ - * like this: │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ - * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ - * (end) │ │ │ │ - */ │ │ │ │ - url: [ │ │ │ │ - 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ - 'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ - 'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png' │ │ │ │ - ], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: attribution │ │ │ │ - * {String} The layer attribution. │ │ │ │ - */ │ │ │ │ - attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: sphericalMercator │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - sphericalMercator: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: wrapDateLine │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - wrapDateLine: true, │ │ │ │ - │ │ │ │ - /** APIProperty: tileOptions │ │ │ │ - * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ - * created by this Layer. Default is │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: 'anonymous'} │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * When using OSM tilesets other than the default ones, it may be │ │ │ │ - * necessary to set this to │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: null} │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * if the server does not send Access-Control-Allow-Origin headers. │ │ │ │ - */ │ │ │ │ - tileOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.OSM │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} The layer name. │ │ │ │ - * url - {String} The tileset URL scheme. │ │ │ │ - * options - {Object} Configuration options for the layer. Any inherited │ │ │ │ - * layer option can be set in this object (e.g. │ │ │ │ - * <OpenLayers.Layer.Grid.buffer>). │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: 'anonymous' │ │ │ │ - }, this.options && this.options.tileOptions); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.OSM( │ │ │ │ - this.name, this.url, this.getOptions()); │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Layer/SphericalMercator.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -19517,6447 +20299,8503 @@ │ │ │ │ */ │ │ │ │ getMapObjectPixelFromXY: function(x, y) { │ │ │ │ return new google.maps.Point(x, y); │ │ │ │ } │ │ │ │ │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control.js │ │ │ │ + OpenLayers/Filter/Comparison.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Filter.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control │ │ │ │ - * Controls affect the display or behavior of the map. They allow everything │ │ │ │ - * from panning and zooming to displaying a scale indicator. Controls by │ │ │ │ - * default are added to the map they are contained within however it is │ │ │ │ - * possible to add a control to an external div by passing the div in the │ │ │ │ - * options parameter. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * The following example shows how to add many of the common controls │ │ │ │ - * to a map. │ │ │ │ - * │ │ │ │ - * > var map = new OpenLayers.Map('map', { controls: [] }); │ │ │ │ - * > │ │ │ │ - * > map.addControl(new OpenLayers.Control.PanZoomBar()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false})); │ │ │ │ - * > map.addControl(new OpenLayers.Control.Permalink()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.Permalink('permalink')); │ │ │ │ - * > map.addControl(new OpenLayers.Control.MousePosition()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.OverviewMap()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.KeyboardDefaults()); │ │ │ │ - * │ │ │ │ - * The next code fragment is a quick example of how to intercept │ │ │ │ - * shift-mouse click to display the extent of the bounding box │ │ │ │ - * dragged out by the user. Usually controls are not created │ │ │ │ - * in exactly this manner. See the source for a more complete │ │ │ │ - * example: │ │ │ │ - * │ │ │ │ - * > var control = new OpenLayers.Control(); │ │ │ │ - * > OpenLayers.Util.extend(control, { │ │ │ │ - * > draw: function () { │ │ │ │ - * > // this Handler.Box will intercept the shift-mousedown │ │ │ │ - * > // before Control.MouseDefault gets to see it │ │ │ │ - * > this.box = new OpenLayers.Handler.Box( control, │ │ │ │ - * > {"done": this.notice}, │ │ │ │ - * > {keyMask: OpenLayers.Handler.MOD_SHIFT}); │ │ │ │ - * > this.box.activate(); │ │ │ │ - * > }, │ │ │ │ - * > │ │ │ │ - * > notice: function (bounds) { │ │ │ │ - * > OpenLayers.Console.userError(bounds); │ │ │ │ - * > } │ │ │ │ - * > }); │ │ │ │ - * > map.addControl(control); │ │ │ │ + * Class: OpenLayers.Filter.Comparison │ │ │ │ + * This class represents a comparison filter. │ │ │ │ * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Filter> │ │ │ │ */ │ │ │ │ -OpenLayers.Control = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {<OpenLayers.Map>} this gets set in the addControl() function in │ │ │ │ - * OpenLayers.Map │ │ │ │ - */ │ │ │ │ - map: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: div │ │ │ │ - * {DOMElement} The element that contains the control, if not present the │ │ │ │ - * control is placed inside the map. │ │ │ │ - */ │ │ │ │ - div: null, │ │ │ │ +OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {Number} Controls can have a 'type'. The type determines the type of │ │ │ │ - * interactions which are possible with them when they are placed in an │ │ │ │ - * <OpenLayers.Control.Panel>. │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} type: type of the comparison. This is one of │ │ │ │ + * - OpenLayers.Filter.Comparison.EQUAL_TO = "=="; │ │ │ │ + * - OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!="; │ │ │ │ + * - OpenLayers.Filter.Comparison.LESS_THAN = "<"; │ │ │ │ + * - OpenLayers.Filter.Comparison.GREATER_THAN = ">"; │ │ │ │ + * - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; │ │ │ │ + * - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; │ │ │ │ + * - OpenLayers.Filter.Comparison.BETWEEN = ".."; │ │ │ │ + * - OpenLayers.Filter.Comparison.LIKE = "~"; │ │ │ │ + * - OpenLayers.Filter.Comparison.IS_NULL = "NULL"; │ │ │ │ */ │ │ │ │ type: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: allowSelection │ │ │ │ - * {Boolean} By default, controls do not allow selection, because │ │ │ │ - * it may interfere with map dragging. If this is true, OpenLayers │ │ │ │ - * will not prevent selection of the control. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - allowSelection: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: displayClass │ │ │ │ - * {string} This property is used for CSS related to the drawing of the │ │ │ │ - * Control. │ │ │ │ - */ │ │ │ │ - displayClass: "", │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: title │ │ │ │ - * {string} This property is used for showing a tooltip over the │ │ │ │ - * Control. │ │ │ │ + * APIProperty: property │ │ │ │ + * {String} │ │ │ │ + * name of the context property to compare │ │ │ │ */ │ │ │ │ - title: "", │ │ │ │ + property: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * false. │ │ │ │ - */ │ │ │ │ - autoActivate: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: active │ │ │ │ - * {Boolean} The control is active (read-only). Use <activate> and │ │ │ │ - * <deactivate> to change control state. │ │ │ │ + * APIProperty: value │ │ │ │ + * {Number} or {String} │ │ │ │ + * comparison value for binary comparisons. In the case of a String, this │ │ │ │ + * can be a combination of text and propertyNames in the form │ │ │ │ + * "literal ${propertyName}" │ │ │ │ */ │ │ │ │ - active: null, │ │ │ │ + value: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the control's handler │ │ │ │ + * Property: matchCase │ │ │ │ + * {Boolean} Force case sensitive searches for EQUAL_TO and NOT_EQUAL_TO │ │ │ │ + * comparisons. The Filter Encoding 1.1 specification added a matchCase │ │ │ │ + * attribute to ogc:PropertyIsEqualTo and ogc:PropertyIsNotEqualTo │ │ │ │ + * elements. This property will be serialized with those elements only │ │ │ │ + * if using the v1.1.0 filter format. However, when evaluating filters │ │ │ │ + * here, the matchCase property will always be respected (for EQUAL_TO │ │ │ │ + * and NOT_EQUAL_TO). Default is true. │ │ │ │ */ │ │ │ │ - handlerOptions: null, │ │ │ │ + matchCase: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: handler │ │ │ │ - * {<OpenLayers.Handler>} null │ │ │ │ + /** │ │ │ │ + * APIProperty: lowerBoundary │ │ │ │ + * {Number} or {String} │ │ │ │ + * lower boundary for between comparisons. In the case of a String, this │ │ │ │ + * can be a combination of text and propertyNames in the form │ │ │ │ + * "literal ${propertyName}" │ │ │ │ */ │ │ │ │ - handler: null, │ │ │ │ + lowerBoundary: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: eventListeners │ │ │ │ - * {Object} If set as an option at construction, the eventListeners │ │ │ │ - * object will be registered with <OpenLayers.Events.on>. Object │ │ │ │ - * structure must be a listeners object as shown in the example for │ │ │ │ - * the events.on method. │ │ │ │ + * APIProperty: upperBoundary │ │ │ │ + * {Number} or {String} │ │ │ │ + * upper boundary for between comparisons. In the case of a String, this │ │ │ │ + * can be a combination of text and propertyNames in the form │ │ │ │ + * "literal ${propertyName}" │ │ │ │ */ │ │ │ │ - eventListeners: null, │ │ │ │ + upperBoundary: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * 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. │ │ │ │ - */ │ │ │ │ - events: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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}); │ │ │ │ + * Constructor: OpenLayers.Filter.Comparison │ │ │ │ + * Creates a comparison rule. │ │ │ │ * │ │ │ │ - * Overrides the default div attribute value of null. │ │ │ │ - * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * rule │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter.Comparison>} │ │ │ │ */ │ │ │ │ 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); │ │ │ │ - if (this.eventListeners instanceof Object) { │ │ │ │ - this.events.on(this.eventListeners); │ │ │ │ - } │ │ │ │ - if (this.id == null) { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + OpenLayers.Filter.prototype.initialize.apply(this, [options]); │ │ │ │ + // since matchCase on PropertyIsLike is not schema compliant, we only │ │ │ │ + // want to use this if explicitly asked for │ │ │ │ + if (this.type === OpenLayers.Filter.Comparison.LIKE && │ │ │ │ + options.matchCase === undefined) { │ │ │ │ + this.matchCase = null; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * APIMethod: evaluate │ │ │ │ + * Evaluates this filter in a specific context. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} Context to use in evaluating the filter. If a vector │ │ │ │ + * feature is provided, the feature.attributes will be used as context. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The filter applies. │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ + evaluate: function(context) { │ │ │ │ + if (context instanceof OpenLayers.Feature.Vector) { │ │ │ │ + context = context.attributes; │ │ │ │ } │ │ │ │ - if (this.handlers) { │ │ │ │ - for (var key in this.handlers) { │ │ │ │ - if (this.handlers.hasOwnProperty(key) && │ │ │ │ - typeof this.handlers[key].destroy == "function") { │ │ │ │ - this.handlers[key].destroy(); │ │ │ │ + var result = false; │ │ │ │ + var got = context[this.property]; │ │ │ │ + var exp; │ │ │ │ + switch (this.type) { │ │ │ │ + case OpenLayers.Filter.Comparison.EQUAL_TO: │ │ │ │ + exp = this.value; │ │ │ │ + if (!this.matchCase && │ │ │ │ + typeof got == "string" && typeof exp == "string") { │ │ │ │ + result = (got.toUpperCase() == exp.toUpperCase()); │ │ │ │ + } else { │ │ │ │ + result = (got == exp); │ │ │ │ } │ │ │ │ - } │ │ │ │ - this.handlers = null; │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.removeControl(this); │ │ │ │ - this.map = null; │ │ │ │ - } │ │ │ │ - this.div = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. This is done through an accessor │ │ │ │ - * so that subclasses can override this and take special action once │ │ │ │ - * they have their map variable set. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.setMap(map); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.NOT_EQUAL_TO: │ │ │ │ + exp = this.value; │ │ │ │ + if (!this.matchCase && │ │ │ │ + typeof got == "string" && typeof exp == "string") { │ │ │ │ + result = (got.toUpperCase() != exp.toUpperCase()); │ │ │ │ + } else { │ │ │ │ + result = (got != exp); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.LESS_THAN: │ │ │ │ + result = got < this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.GREATER_THAN: │ │ │ │ + result = got > this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO: │ │ │ │ + result = got <= this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO: │ │ │ │ + result = got >= this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.BETWEEN: │ │ │ │ + result = (got >= this.lowerBoundary) && │ │ │ │ + (got <= this.upperBoundary); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.LIKE: │ │ │ │ + var regexp = new RegExp(this.value, "gi"); │ │ │ │ + result = regexp.test(got); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.IS_NULL: │ │ │ │ + result = (got === null); │ │ │ │ + break; │ │ │ │ } │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ - * │ │ │ │ + * APIMethod: value2regex │ │ │ │ + * Converts the value of this rule into a regular expression string, │ │ │ │ + * according to the wildcard characters specified. This method has to │ │ │ │ + * be called after instantiation of this class, if the value is not a │ │ │ │ + * regular expression already. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} The top-left pixel position of the control │ │ │ │ - * or null. │ │ │ │ - * │ │ │ │ + * wildCard - {Char} wildcard character in the above value, default │ │ │ │ + * is "*" │ │ │ │ + * singleChar - {Char} single-character wildcard in the above value │ │ │ │ + * default is "." │ │ │ │ + * escapeChar - {Char} escape character in the above value, default is │ │ │ │ + * "!" │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ + * {String} regular expression string │ │ │ │ */ │ │ │ │ - draw: function(px) { │ │ │ │ - if (this.div == null) { │ │ │ │ - this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ - this.div.className = this.displayClass; │ │ │ │ - if (!this.allowSelection) { │ │ │ │ - this.div.className += " olControlNoSelect"; │ │ │ │ - this.div.setAttribute("unselectable", "on", 0); │ │ │ │ - this.div.onselectstart = OpenLayers.Function.False; │ │ │ │ - } │ │ │ │ - if (this.title != "") { │ │ │ │ - this.div.title = this.title; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (px != null) { │ │ │ │ - this.position = px.clone(); │ │ │ │ + value2regex: function(wildCard, singleChar, escapeChar) { │ │ │ │ + if (wildCard == ".") { │ │ │ │ + throw new Error("'.' is an unsupported wildCard character for " + │ │ │ │ + "OpenLayers.Filter.Comparison"); │ │ │ │ } │ │ │ │ - this.moveTo(this.position); │ │ │ │ - return this.div; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveTo │ │ │ │ - * Sets the left and top style attributes to the passed in pixel │ │ │ │ - * coordinates. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - if ((px != null) && (this.div != null)) { │ │ │ │ - this.div.style.left = px.x + "px"; │ │ │ │ - this.div.style.top = px.y + "px"; │ │ │ │ - } │ │ │ │ + │ │ │ │ + // set UMN MapServer defaults for unspecified parameters │ │ │ │ + wildCard = wildCard ? wildCard : "*"; │ │ │ │ + singleChar = singleChar ? singleChar : "."; │ │ │ │ + escapeChar = escapeChar ? escapeChar : "!"; │ │ │ │ + │ │ │ │ + this.value = this.value.replace( │ │ │ │ + new RegExp("\\" + escapeChar + "(.|$)", "g"), "\\$1"); │ │ │ │ + this.value = this.value.replace( │ │ │ │ + new RegExp("\\" + singleChar, "g"), "."); │ │ │ │ + this.value = this.value.replace( │ │ │ │ + new RegExp("\\" + wildCard, "g"), ".*"); │ │ │ │ + this.value = this.value.replace( │ │ │ │ + new RegExp("\\\\.\\*", "g"), "\\" + wildCard); │ │ │ │ + this.value = this.value.replace( │ │ │ │ + new RegExp("\\\\\\.", "g"), "\\" + singleChar); │ │ │ │ + │ │ │ │ + return this.value; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Explicitly activates a control and it's associated │ │ │ │ - * handler if one has been set. Controls can be │ │ │ │ - * deactivated by calling the deactivate() method. │ │ │ │ + * Method: regex2value │ │ │ │ + * Convert the value of this rule from a regular expression string into an │ │ │ │ + * ogc literal string using a wildCard of *, a singleChar of ., and an │ │ │ │ + * escape of !. Leaves the <value> property unmodified. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the control was successfully activated or │ │ │ │ - * false if the control was already active. │ │ │ │ + * {String} A string value. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.activate(); │ │ │ │ - } │ │ │ │ - this.active = true; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, │ │ │ │ - this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("activate"); │ │ │ │ - return true; │ │ │ │ + regex2value: function() { │ │ │ │ + │ │ │ │ + var value = this.value; │ │ │ │ + │ │ │ │ + // replace ! with !! │ │ │ │ + value = value.replace(/!/g, "!!"); │ │ │ │ + │ │ │ │ + // replace \. with !. (watching out for \\.) │ │ │ │ + value = value.replace(/(\\)?\\\./g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "!."; │ │ │ │ + }); │ │ │ │ + │ │ │ │ + // replace \* with #* (watching out for \\*) │ │ │ │ + value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "!*"; │ │ │ │ + }); │ │ │ │ + │ │ │ │ + // replace \\ with \ │ │ │ │ + value = value.replace(/\\\\/g, "\\"); │ │ │ │ + │ │ │ │ + // convert .* to * (the sequence #.* is not allowed) │ │ │ │ + value = value.replace(/\.\*/g, "*"); │ │ │ │ + │ │ │ │ + return value; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivates a control and it's associated handler if any. The exact │ │ │ │ - * effect of this depends on the control itself. │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this filter. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the control was effectively deactivated or false │ │ │ │ - * if the control was already inactive. │ │ │ │ + * {<OpenLayers.Filter.Comparison>} Clone of this filter. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate(); │ │ │ │ - } │ │ │ │ - this.active = false; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, │ │ │ │ - this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("deactivate"); │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ + clone: function() { │ │ │ │ + return OpenLayers.Util.extend(new OpenLayers.Filter.Comparison(), this); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control" │ │ │ │ + CLASS_NAME: "OpenLayers.Filter.Comparison" │ │ │ │ }); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_BUTTON │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_TOGGLE │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_TOOL │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ +OpenLayers.Filter.Comparison.EQUAL_TO = "=="; │ │ │ │ +OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!="; │ │ │ │ +OpenLayers.Filter.Comparison.LESS_THAN = "<"; │ │ │ │ +OpenLayers.Filter.Comparison.GREATER_THAN = ">"; │ │ │ │ +OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; │ │ │ │ +OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; │ │ │ │ +OpenLayers.Filter.Comparison.BETWEEN = ".."; │ │ │ │ +OpenLayers.Filter.Comparison.LIKE = "~"; │ │ │ │ +OpenLayers.Filter.Comparison.IS_NULL = "NULL"; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Events/buttonclick.js │ │ │ │ + OpenLayers/Filter/Logical.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/Filter.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Events.buttonclick │ │ │ │ - * Extension event type for handling buttons on top of a dom element. This │ │ │ │ - * event type fires "buttonclick" on its <target> when a button was │ │ │ │ - * clicked. Buttons are detected by the "olButton" class. │ │ │ │ - * │ │ │ │ - * This event type makes sure that button clicks do not interfere with other │ │ │ │ - * events that are registered on the same <element>. │ │ │ │ - * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - *buttonclick* Triggered when a button is clicked. Listeners receive an │ │ │ │ - * object with a *buttonElement* property referencing the dom element of │ │ │ │ - * the clicked button, and an *buttonXY* property with the click position │ │ │ │ - * relative to the button. │ │ │ │ + * Class: OpenLayers.Filter.Logical │ │ │ │ + * This class represents ogc:And, ogc:Or and ogc:Not rules. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Filter> │ │ │ │ */ │ │ │ │ -OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: target │ │ │ │ - * {<OpenLayers.Events>} The events instance that the buttonclick event will │ │ │ │ - * be triggered on. │ │ │ │ - */ │ │ │ │ - target: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: events │ │ │ │ - * {Array} Events to observe and conditionally stop from propagating when │ │ │ │ - * an element with the olButton class (or its olAlphaImg child) is │ │ │ │ - * clicked. │ │ │ │ - */ │ │ │ │ - events: [ │ │ │ │ - 'mousedown', 'mouseup', 'click', 'dblclick', │ │ │ │ - 'touchstart', 'touchmove', 'touchend', 'keydown' │ │ │ │ - ], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: startRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that start │ │ │ │ - * a buttonclick sequence. │ │ │ │ - */ │ │ │ │ - startRegEx: /^mousedown|touchstart$/, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: cancelRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that cancel │ │ │ │ - * a buttonclick sequence. │ │ │ │ - */ │ │ │ │ - cancelRegEx: /^touchmove$/, │ │ │ │ +OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: completeRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that complete │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * APIProperty: filters │ │ │ │ + * {Array(<OpenLayers.Filter>)} Child filters for this filter. │ │ │ │ */ │ │ │ │ - completeRegEx: /^mouseup|touchend$/, │ │ │ │ + filters: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: startEvt │ │ │ │ - * {Event} The event that started the click sequence │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} type of logical operator. Available types are: │ │ │ │ + * - OpenLayers.Filter.Logical.AND = "&&"; │ │ │ │ + * - OpenLayers.Filter.Logical.OR = "||"; │ │ │ │ + * - OpenLayers.Filter.Logical.NOT = "!"; │ │ │ │ */ │ │ │ │ + type: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Events.buttonclick │ │ │ │ - * Construct a buttonclick event type. Applications are not supposed to │ │ │ │ - * create instances of this class - they are created on demand by │ │ │ │ - * <OpenLayers.Events> instances. │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Filter.Logical │ │ │ │ + * Creates a logical filter (And, Or, Not). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * target - {<OpenLayers.Events>} The events instance that the buttonclick │ │ │ │ - * event will be triggered on. │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * filter. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter.Logical>} │ │ │ │ */ │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + initialize: function(options) { │ │ │ │ + this.filters = []; │ │ │ │ + OpenLayers.Filter.prototype.initialize.apply(this, [options]); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Remove reference to child filters. │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.unregister(this.events[i], this, this.buttonClick); │ │ │ │ - } │ │ │ │ - delete this.target; │ │ │ │ + this.filters = null; │ │ │ │ + OpenLayers.Filter.prototype.destroy.apply(this); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getPressedButton │ │ │ │ - * Get the pressed button, if any. Returns undefined if no button │ │ │ │ - * was pressed. │ │ │ │ - * │ │ │ │ - * Arguments: │ │ │ │ - * element - {DOMElement} The event target. │ │ │ │ - * │ │ │ │ + * APIMethod: evaluate │ │ │ │ + * Evaluates this filter in a specific context. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * context - {Object} Context to use in evaluating the filter. A vector │ │ │ │ + * feature may also be provided to evaluate feature attributes in │ │ │ │ + * comparison filters or geometries in spatial filters. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} The button element, or undefined. │ │ │ │ + * {Boolean} The filter applies. │ │ │ │ */ │ │ │ │ - getPressedButton: function(element) { │ │ │ │ - var depth = 3, // limit the search depth │ │ │ │ - button; │ │ │ │ - do { │ │ │ │ - if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ - // hit! │ │ │ │ - button = element; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - element = element.parentNode; │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return button; │ │ │ │ - }, │ │ │ │ + evaluate: function(context) { │ │ │ │ + var i, len; │ │ │ │ + switch (this.type) { │ │ │ │ + case OpenLayers.Filter.Logical.AND: │ │ │ │ + for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ + if (this.filters[i].evaluate(context) == false) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: ignore │ │ │ │ - * Check for event target elements that should be ignored by OpenLayers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * element - {DOMElement} The event target. │ │ │ │ - */ │ │ │ │ - ignore: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - ignore = false; │ │ │ │ - do { │ │ │ │ - if (element.nodeName.toLowerCase() === 'a') { │ │ │ │ - ignore = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - element = element.parentNode; │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return ignore; │ │ │ │ + case OpenLayers.Filter.Logical.OR: │ │ │ │ + for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ + if (this.filters[i].evaluate(context) == true) { │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ + │ │ │ │ + case OpenLayers.Filter.Logical.NOT: │ │ │ │ + return (!this.filters[0].evaluate(context)); │ │ │ │ + } │ │ │ │ + return undefined; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: buttonClick │ │ │ │ - * Check if a button was clicked, and fire the buttonclick event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clones this filter. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Filter.Logical>} Clone of this filter. │ │ │ │ */ │ │ │ │ - buttonClick: function(evt) { │ │ │ │ - var propagate = true, │ │ │ │ - element = OpenLayers.Event.element(evt); │ │ │ │ - if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ - // was a button pressed? │ │ │ │ - var button = this.getPressedButton(element); │ │ │ │ - if (button) { │ │ │ │ - if (evt.type === "keydown") { │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_RETURN: │ │ │ │ - case OpenLayers.Event.KEY_SPACE: │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button │ │ │ │ - }); │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (this.startEvt) { │ │ │ │ - if (this.completeRegEx.test(evt.type)) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ - var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ - var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ - var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ - pos[0] = pos[0] - scrollLeft; │ │ │ │ - pos[1] = pos[1] - scrollTop; │ │ │ │ - │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button, │ │ │ │ - buttonXY: { │ │ │ │ - x: this.startEvt.clientX - pos[0], │ │ │ │ - y: this.startEvt.clientY - pos[1] │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (this.cancelRegEx.test(evt.type)) { │ │ │ │ - delete this.startEvt; │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - } │ │ │ │ - if (this.startRegEx.test(evt.type)) { │ │ │ │ - this.startEvt = evt; │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ - delete this.startEvt; │ │ │ │ - } │ │ │ │ + clone: function() { │ │ │ │ + var filters = []; │ │ │ │ + for (var i = 0, len = this.filters.length; i < len; ++i) { │ │ │ │ + filters.push(this.filters[i].clone()); │ │ │ │ } │ │ │ │ - return propagate; │ │ │ │ - } │ │ │ │ + return new OpenLayers.Filter.Logical({ │ │ │ │ + type: this.type, │ │ │ │ + filters: filters │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Filter.Logical" │ │ │ │ }); │ │ │ │ + │ │ │ │ + │ │ │ │ +OpenLayers.Filter.Logical.AND = "&&"; │ │ │ │ +OpenLayers.Filter.Logical.OR = "||"; │ │ │ │ +OpenLayers.Filter.Logical.NOT = "!"; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Panel.js │ │ │ │ + OpenLayers/Popup.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Panel │ │ │ │ - * The Panel control is a container for other controls. With it toolbars │ │ │ │ - * may be composed. │ │ │ │ + * 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 <OpenLayers.Marker>. Popup's don't require their own │ │ │ │ + * layer and are added the the map using the <OpenLayers.Map.addPopup> │ │ │ │ + * method. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * 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.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - /** │ │ │ │ - * Property: controls │ │ │ │ - * {Array(<OpenLayers.Control>)} │ │ │ │ +OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: events │ │ │ │ + * {<OpenLayers.Events>} custom event manager │ │ │ │ */ │ │ │ │ - controls: null, │ │ │ │ + events: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + /** Property: id │ │ │ │ + * {String} the unique identifier assigned to this popup. │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ + id: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: defaultControl │ │ │ │ - * {<OpenLayers.Control>} The control which is activated when the control is │ │ │ │ - * activated (turned on), which also happens at instantiation. │ │ │ │ - * If <saveState> is true, <defaultControl> will be nullified after the │ │ │ │ - * first activation of the panel. │ │ │ │ + * Property: lonlat │ │ │ │ + * {<OpenLayers.LonLat>} the position of this popup on the map │ │ │ │ */ │ │ │ │ - defaultControl: null, │ │ │ │ + lonlat: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: saveState │ │ │ │ - * {Boolean} If set to true, the active state of this panel's controls will │ │ │ │ - * be stored on panel deactivation, and restored on reactivation. Default │ │ │ │ - * is false. │ │ │ │ + /** │ │ │ │ + * Property: div │ │ │ │ + * {DOMElement} the div that contains this popup. │ │ │ │ */ │ │ │ │ - saveState: false, │ │ │ │ + div: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: allowDepress │ │ │ │ - * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can │ │ │ │ - * be deactivated by clicking the icon that represents them. Default │ │ │ │ - * is false. │ │ │ │ + /** │ │ │ │ + * Property: contentSize │ │ │ │ + * {<OpenLayers.Size>} the width and height of the content. │ │ │ │ */ │ │ │ │ - allowDepress: false, │ │ │ │ + contentSize: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: activeState │ │ │ │ - * {Object} stores the active state of this panel's controls. │ │ │ │ + /** │ │ │ │ + * Property: size │ │ │ │ + * {<OpenLayers.Size>} the width and height of the popup. │ │ │ │ */ │ │ │ │ - activeState: null, │ │ │ │ + size: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Control.Panel │ │ │ │ - * Create a new control panel. │ │ │ │ - * │ │ │ │ - * Each control in the panel is represented by an icon. When clicking │ │ │ │ - * on an icon, the <activateControl> method is called. │ │ │ │ - * │ │ │ │ - * Specific properties for controls on a panel: │ │ │ │ - * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>, │ │ │ │ - * <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>. │ │ │ │ - * If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed. │ │ │ │ - * title - {string} Text displayed when mouse is over the icon that │ │ │ │ - * represents the control. │ │ │ │ - * │ │ │ │ - * The <OpenLayers.Control.type> of a control determines the behavior when │ │ │ │ - * clicking its icon: │ │ │ │ - * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other │ │ │ │ - * controls of this type in the same panel are deactivated. This is │ │ │ │ - * the default type. │ │ │ │ - * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is │ │ │ │ - * toggled. │ │ │ │ - * <OpenLayers.Control.TYPE_BUTTON> - The │ │ │ │ - * <OpenLayers.Control.Button.trigger> method of the control is called, │ │ │ │ - * but its active state is not changed. │ │ │ │ - * │ │ │ │ - * If a control is <OpenLayers.Control.active>, it will be drawn with the │ │ │ │ - * olControl[Name]ItemActive class, otherwise with the │ │ │ │ - * olControl[Name]ItemInactive class. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ + /** │ │ │ │ + * Property: contentHTML │ │ │ │ + * {String} An HTML string for this popup to display. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.controls = []; │ │ │ │ - this.activeState = {}; │ │ │ │ - }, │ │ │ │ + contentHTML: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + /** │ │ │ │ + * Property: backgroundColor │ │ │ │ + * {String} the background color used by the popup. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ - ctl = this.controls[i]; │ │ │ │ - if (ctl.events) { │ │ │ │ - ctl.events.un({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - ctl.panel_div = null; │ │ │ │ - } │ │ │ │ - this.activeState = null; │ │ │ │ - }, │ │ │ │ + backgroundColor: "", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ + /** │ │ │ │ + * Property: opacity │ │ │ │ + * {float} the opacity of this popup (between 0.0 and 1.0) │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - if (control === this.defaultControl || │ │ │ │ - (this.saveState && this.activeState[control.id])) { │ │ │ │ - control.activate(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.saveState === true) { │ │ │ │ - this.defaultControl = null; │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + opacity: "", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ + /** │ │ │ │ + * Property: border │ │ │ │ + * {String} the border size of the popup. (eg 2px) │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - this.activeState[control.id] = control.deactivate(); │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + border: "", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ + /** │ │ │ │ + * Property: contentDiv │ │ │ │ + * {DOMElement} a reference to the element that holds the content of │ │ │ │ + * the div. │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - } │ │ │ │ - this.addControlsToMap(this.controls); │ │ │ │ - return this.div; │ │ │ │ - }, │ │ │ │ + contentDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: redraw │ │ │ │ + /** │ │ │ │ + * Property: groupDiv │ │ │ │ + * {DOMElement} First and only child of 'div'. The group Div contains the │ │ │ │ + * 'contentDiv' and the 'closeDiv'. │ │ │ │ */ │ │ │ │ - redraw: function() { │ │ │ │ - for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ - this.div.removeChild(this.div.childNodes[i]); │ │ │ │ - } │ │ │ │ - this.div.innerHTML = ""; │ │ │ │ - if (this.active) { │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - this.div.appendChild(this.controls[i].panel_div); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + groupDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: activateControl │ │ │ │ - * This method is called when the user click on the icon representing a │ │ │ │ - * control in the panel. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ + /** │ │ │ │ + * Property: closeDiv │ │ │ │ + * {DOMElement} the optional closer image │ │ │ │ */ │ │ │ │ - activateControl: function(control) { │ │ │ │ - if (!this.active) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ - control.trigger(); │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ - if (control.active) { │ │ │ │ - control.deactivate(); │ │ │ │ - } else { │ │ │ │ - control.activate(); │ │ │ │ - } │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - if (this.allowDepress && control.active) { │ │ │ │ - control.deactivate(); │ │ │ │ - } else { │ │ │ │ - var c; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - c = this.controls[i]; │ │ │ │ - if (c != control && │ │ │ │ - (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ - c.deactivate(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - control.activate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + closeDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: addControls │ │ │ │ - * To build a toolbar, you add a set of controls to it. addControls │ │ │ │ - * lets you add a single control or a list of controls to the │ │ │ │ - * Control Panel. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * controls - {<OpenLayers.Control>} Controls to add in the panel. │ │ │ │ + /** │ │ │ │ + * APIProperty: autoSize │ │ │ │ + * {Boolean} Resize the popup to auto-fit the contents. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - addControls: function(controls) { │ │ │ │ - if (!(OpenLayers.Util.isArray(controls))) { │ │ │ │ - controls = [controls]; │ │ │ │ - } │ │ │ │ - this.controls = this.controls.concat(controls); │ │ │ │ - │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - var control = controls[i], │ │ │ │ - element = this.createControlMarkup(control); │ │ │ │ - OpenLayers.Element.addClass(element, │ │ │ │ - control.displayClass + "ItemInactive"); │ │ │ │ - OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ - if (control.title != "" && !element.title) { │ │ │ │ - element.title = control.title; │ │ │ │ - } │ │ │ │ - control.panel_div = element; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.map) { // map.addControl() has already been called on the panel │ │ │ │ - this.addControlsToMap(controls); │ │ │ │ - this.redraw(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + autoSize: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: createControlMarkup │ │ │ │ - * This function just creates a div for the control. If specific HTML │ │ │ │ - * markup is needed this function can be overridden in specific classes, │ │ │ │ - * or at panel instantiation time: │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var panel = new OpenLayers.Control.Panel({ │ │ │ │ - * defaultControl: control, │ │ │ │ - * // ovverride createControlMarkup to create actual buttons │ │ │ │ - * // including texts wrapped into span elements. │ │ │ │ - * createControlMarkup: function(control) { │ │ │ │ - * var button = document.createElement('button'), │ │ │ │ - * span = document.createElement('span'); │ │ │ │ - * if (control.text) { │ │ │ │ - * span.innerHTML = control.text; │ │ │ │ - * } │ │ │ │ - * return button; │ │ │ │ - * } │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control to create the HTML │ │ │ │ - * markup for. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The markup. │ │ │ │ + * APIProperty: minSize │ │ │ │ + * {<OpenLayers.Size>} Minimum size allowed for the popup's contents. │ │ │ │ */ │ │ │ │ - createControlMarkup: function(control) { │ │ │ │ - return document.createElement("div"); │ │ │ │ - }, │ │ │ │ + minSize: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addControlsToMap │ │ │ │ - * Only for internal use in draw() and addControls() methods. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * controls - {Array(<OpenLayers.Control>)} Controls to add into map. │ │ │ │ + * APIProperty: maxSize │ │ │ │ + * {<OpenLayers.Size>} Maximum size allowed for the popup's contents. │ │ │ │ */ │ │ │ │ - addControlsToMap: function(controls) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - control = controls[i]; │ │ │ │ - if (control.autoActivate === true) { │ │ │ │ - control.autoActivate = false; │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.autoActivate = true; │ │ │ │ - } else { │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.deactivate(); │ │ │ │ - } │ │ │ │ - control.events.on({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + maxSize: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: iconOn │ │ │ │ - * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ + /** │ │ │ │ + * Property: displayClass │ │ │ │ + * {String} The CSS class of the popup. │ │ │ │ */ │ │ │ │ - iconOn: function() { │ │ │ │ - var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Active"); │ │ │ │ - }, │ │ │ │ + displayClass: "olPopup", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: iconOff │ │ │ │ - * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ + /** │ │ │ │ + * Property: contentDisplayClass │ │ │ │ + * {String} The CSS class of the popup content div. │ │ │ │ */ │ │ │ │ - iconOff: function() { │ │ │ │ - var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Inactive"); │ │ │ │ - }, │ │ │ │ + contentDisplayClass: "olPopupContent", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onButtonClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + /** │ │ │ │ + * Property: padding │ │ │ │ + * {int or <OpenLayers.Bounds>} 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. │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var controls = this.controls, │ │ │ │ - button = evt.buttonElement; │ │ │ │ - for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ - if (controls[i].panel_div === button) { │ │ │ │ - this.activateControl(controls[i]); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + padding: 0, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getControlsBy │ │ │ │ - * Get a list of controls with properties matching the given criteria. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * property - {String} A control property to be matched. │ │ │ │ - * match - {String | Object} A string to match. Can also be a regular │ │ │ │ - * expression literal or object. In addition, it can be any object │ │ │ │ - * with a method named test. For reqular expressions or other, if │ │ │ │ - * match.test(control[property]) evaluates to true, the control will be │ │ │ │ - * included in the array returned. If no controls are found, an empty │ │ │ │ - * array is returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Control>)} A list of controls matching the given criteria. │ │ │ │ - * An empty array is returned if no matches are found. │ │ │ │ + /** │ │ │ │ + * Property: disableFirefoxOverflowHack │ │ │ │ + * {Boolean} The hack for overflow in Firefox causes all elements │ │ │ │ + * to be re-drawn, which causes Flash elements to be │ │ │ │ + * re-initialized, which is troublesome. │ │ │ │ + * With this property the hack can be disabled. │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ - }, │ │ │ │ + disableFirefoxOverflowHack: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getControlsByName │ │ │ │ - * Get a list of contorls with names matching the given name. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * match - {String | Object} A control name. The name can also be a regular │ │ │ │ - * expression literal or object. In addition, it can be any object │ │ │ │ - * with a method named test. For reqular expressions or other, if │ │ │ │ - * name.test(control.name) evaluates to true, the control will be included │ │ │ │ - * in the list of controls returned. If no controls are found, an empty │ │ │ │ - * array is returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Control>)} A list of controls matching the given name. │ │ │ │ - * An empty array is returned if no matches are found. │ │ │ │ + * 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 <OpenLayers.Bounds> object. │ │ │ │ */ │ │ │ │ - getControlsByName: function(match) { │ │ │ │ - return this.getControlsBy("name", match); │ │ │ │ + fixPadding: function() { │ │ │ │ + if (typeof this.padding == "number") { │ │ │ │ + this.padding = new OpenLayers.Bounds( │ │ │ │ + this.padding, this.padding, this.padding, this.padding │ │ │ │ + ); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getControlsByClass │ │ │ │ - * Get a list of controls of a given type (CLASS_NAME). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * match - {String | Object} A control class name. The type can also be a │ │ │ │ - * regular expression literal or object. In addition, it can be any │ │ │ │ - * object with a method named test. For reqular expressions or other, │ │ │ │ - * if type.test(control.CLASS_NAME) evaluates to true, the control will │ │ │ │ - * be included in the list of controls returned. If no controls are │ │ │ │ - * found, an empty array is returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Control>)} A list of controls matching the given type. │ │ │ │ - * An empty array is returned if no matches are found. │ │ │ │ + * APIProperty: panMapIfOutOfView │ │ │ │ + * {Boolean} When drawn, pan map such that the entire popup is visible in │ │ │ │ + * the current viewport (if necessary). │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - getControlsByClass: function(match) { │ │ │ │ - return this.getControlsBy("CLASS_NAME", match); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Zoom.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Zoom │ │ │ │ - * The Zoom control is a pair of +/- links for zooming in and out. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + panMapIfOutOfView: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomInText │ │ │ │ - * {String} │ │ │ │ - * Text for zoom-in link. Default is "+". │ │ │ │ + * APIProperty: keepInMap │ │ │ │ + * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ + * contrain the popup such that it always fits in the available map │ │ │ │ + * space. By default, this is not set on the base class. If you are │ │ │ │ + * creating popups that are near map edges and not allowing pannning, │ │ │ │ + * and especially if you have a popup which has a │ │ │ │ + * fixedRelativePosition, setting this to false may be a smart thing to │ │ │ │ + * do. Subclasses may want to override this setting. │ │ │ │ + * │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - zoomInText: "+", │ │ │ │ + keepInMap: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomInId │ │ │ │ - * {String} │ │ │ │ - * Instead of having the control create a zoom in link, you can provide │ │ │ │ - * the identifier for an anchor element already added to the document. │ │ │ │ - * By default, an element with id "olZoomInLink" will be searched for │ │ │ │ - * and used if it exists. │ │ │ │ + * APIProperty: closeOnMove │ │ │ │ + * {Boolean} When map pans, close the popup. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - zoomInId: "olZoomInLink", │ │ │ │ + closeOnMove: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomOutText │ │ │ │ - * {String} │ │ │ │ - * Text for zoom-out link. Default is "\u2212". │ │ │ │ + /** │ │ │ │ + * Property: map │ │ │ │ + * {<OpenLayers.Map>} this gets set in Map.js when the popup is added to the map │ │ │ │ */ │ │ │ │ - zoomOutText: "\u2212", │ │ │ │ + map: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomOutId │ │ │ │ - * {String} │ │ │ │ - * Instead of having the control create a zoom out link, you can provide │ │ │ │ - * the identifier for an anchor element already added to the document. │ │ │ │ - * By default, an element with id "olZoomOutLink" will be searched for │ │ │ │ - * and used if it exists. │ │ │ │ + /** │ │ │ │ + * 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 - {<OpenLayers.LonLat>} The position on the map the popup will │ │ │ │ + * be shown. │ │ │ │ + * contentSize - {<OpenLayers.Size>} The size of the content. │ │ │ │ + * contentHTML - {String} An HTML string 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. │ │ │ │ */ │ │ │ │ - zoomOutId: "olZoomOutLink", │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ + if (id == null) { │ │ │ │ + id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A reference to the DOMElement containing the zoom links. │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ - links = this.getOrCreateLinks(div), │ │ │ │ - zoomIn = links.zoomIn, │ │ │ │ - zoomOut = links.zoomOut, │ │ │ │ - eventsInstance = this.map.events; │ │ │ │ + this.id = id; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ │ │ │ │ - if (zoomOut.parentNode !== div) { │ │ │ │ - eventsInstance = this.events; │ │ │ │ - eventsInstance.attachToElement(zoomOut.parentNode); │ │ │ │ + this.contentSize = (contentSize != null) ? contentSize : │ │ │ │ + new OpenLayers.Size( │ │ │ │ + OpenLayers.Popup.WIDTH, │ │ │ │ + OpenLayers.Popup.HEIGHT); │ │ │ │ + if (contentHTML != null) { │ │ │ │ + this.contentHTML = contentHTML; │ │ │ │ } │ │ │ │ - eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ + this.backgroundColor = OpenLayers.Popup.COLOR; │ │ │ │ + this.opacity = OpenLayers.Popup.OPACITY; │ │ │ │ + this.border = OpenLayers.Popup.BORDER; │ │ │ │ │ │ │ │ - this.zoomInLink = zoomIn; │ │ │ │ - this.zoomOutLink = zoomOut; │ │ │ │ - return div; │ │ │ │ - }, │ │ │ │ + this.div = OpenLayers.Util.createDiv(this.id, null, null, │ │ │ │ + null, null, null, "hidden"); │ │ │ │ + this.div.className = this.displayClass; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getOrCreateLinks │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * el - {DOMElement} │ │ │ │ - * │ │ │ │ - * Return: │ │ │ │ - * {Object} Object with zoomIn and zoomOut properties referencing links. │ │ │ │ - */ │ │ │ │ - getOrCreateLinks: function(el) { │ │ │ │ - var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ - zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ - if (!zoomIn) { │ │ │ │ - zoomIn = document.createElement("a"); │ │ │ │ - zoomIn.href = "#zoomIn"; │ │ │ │ - zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ - zoomIn.className = "olControlZoomIn"; │ │ │ │ - el.appendChild(zoomIn); │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ - if (!zoomOut) { │ │ │ │ - zoomOut = document.createElement("a"); │ │ │ │ - zoomOut.href = "#zoomOut"; │ │ │ │ - zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ - zoomOut.className = "olControlZoomOut"; │ │ │ │ - el.appendChild(zoomOut); │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ - return { │ │ │ │ - zoomIn: zoomIn, │ │ │ │ - zoomOut: zoomOut │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ + var groupDivId = this.id + "_GroupDiv"; │ │ │ │ + this.groupDiv = OpenLayers.Util.createDiv(groupDivId, null, null, │ │ │ │ + null, "relative", null, │ │ │ │ + "hidden"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: onZoomClick │ │ │ │ - * Called when zoomin/out link is clicked. │ │ │ │ - */ │ │ │ │ - onZoomClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.zoomInLink) { │ │ │ │ - this.map.zoomIn(); │ │ │ │ - } else if (button === this.zoomOutLink) { │ │ │ │ - this.map.zoomOut(); │ │ │ │ + var id = this.div.id + "_contentDiv"; │ │ │ │ + this.contentDiv = OpenLayers.Util.createDiv(id, null, this.contentSize.clone(), │ │ │ │ + null, "relative"); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass; │ │ │ │ + this.groupDiv.appendChild(this.contentDiv); │ │ │ │ + this.div.appendChild(this.groupDiv); │ │ │ │ + │ │ │ │ + if (closeBox) { │ │ │ │ + this.addCloseBox(closeBoxCallback); │ │ │ │ } │ │ │ │ + │ │ │ │ + this.registerEvents(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: destroy │ │ │ │ - * Clean up. │ │ │ │ + * nullify references to prevent circular references and memory leaks │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onZoomClick); │ │ │ │ + │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.size = null; │ │ │ │ + this.contentHTML = null; │ │ │ │ + │ │ │ │ + this.backgroundColor = null; │ │ │ │ + this.opacity = null; │ │ │ │ + this.border = null; │ │ │ │ + │ │ │ │ + if (this.closeOnMove && this.map) { │ │ │ │ + this.map.events.unregister("movestart", this, this.hide); │ │ │ │ } │ │ │ │ - delete this.zoomInLink; │ │ │ │ - delete this.zoomOutLink; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ - }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/LayerSwitcher.js │ │ │ │ - ====================================================================== */ │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + if (this.closeDiv) { │ │ │ │ + OpenLayers.Event.stopObservingElement(this.closeDiv); │ │ │ │ + this.groupDiv.removeChild(this.closeDiv); │ │ │ │ + } │ │ │ │ + this.closeDiv = null; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Lang.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ - */ │ │ │ │ + this.div.removeChild(this.groupDiv); │ │ │ │ + this.groupDiv = null; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.LayerSwitcher │ │ │ │ - * The LayerSwitcher control displays a table of contents for the map. This │ │ │ │ - * allows the user interface to switch between BaseLasyers and to show or hide │ │ │ │ - * Overlays. By default the switcher is shown minimized on the right edge of │ │ │ │ - * the map, the user may expand it by clicking on the handle. │ │ │ │ - * │ │ │ │ - * To create the LayerSwitcher outside of the map, pass the Id of a html div │ │ │ │ - * as the first argument to the constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + if (this.map != null) { │ │ │ │ + this.map.removePopup(this); │ │ │ │ + } │ │ │ │ + this.map = null; │ │ │ │ + this.div = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ + 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 - {<OpenLayers.Pixel>} the position the popup in pixels. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} Reference to a div that contains the drawn popup │ │ │ │ */ │ │ │ │ - layerStates: null, │ │ │ │ + draw: function(px) { │ │ │ │ + if (px == null) { │ │ │ │ + if ((this.lonlat != null) && (this.map != null)) { │ │ │ │ + px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - // DOM Elements │ │ │ │ + // this assumes that this.map already exists, which is okay because │ │ │ │ + // this.draw is only called once the popup has been added to the map. │ │ │ │ + if (this.closeOnMove) { │ │ │ │ + this.map.events.register("movestart", this, this.hide); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layersDiv │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - layersDiv: null, │ │ │ │ + //listen to movestart, moveend to disable overflow (FF bug) │ │ │ │ + if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == '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; │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: baseLayersDiv │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - baseLayersDiv: null, │ │ │ │ + this.moveTo(px); │ │ │ │ + if (!this.autoSize && !this.size) { │ │ │ │ + this.setSize(this.contentSize); │ │ │ │ + } │ │ │ │ + this.setBackgroundColor(); │ │ │ │ + this.setOpacity(); │ │ │ │ + this.setBorder(); │ │ │ │ + this.setContentHTML(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: baseLayers │ │ │ │ - * {Array(Object)} │ │ │ │ - */ │ │ │ │ - baseLayers: null, │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView(); │ │ │ │ + } │ │ │ │ │ │ │ │ + return this.div; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: dataLbl │ │ │ │ - * {DOMElement} │ │ │ │ + /** │ │ │ │ + * Method: updatePosition │ │ │ │ + * if the popup has a lonlat and its map members set, │ │ │ │ + * then have it move itself to its proper position │ │ │ │ */ │ │ │ │ - dataLbl: null, │ │ │ │ + updatePosition: function() { │ │ │ │ + if ((this.lonlat) && (this.map)) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + if (px) { │ │ │ │ + this.moveTo(px); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dataLayersDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: moveTo │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} the top and left position of the popup div. │ │ │ │ */ │ │ │ │ - dataLayersDiv: null, │ │ │ │ + moveTo: function(px) { │ │ │ │ + if ((px != null) && (this.div != null)) { │ │ │ │ + this.div.style.left = px.x + "px"; │ │ │ │ + this.div.style.top = px.y + "px"; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: dataLayers │ │ │ │ - * {Array(Object)} │ │ │ │ + * Method: visible │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Boolean indicating whether or not the popup is visible │ │ │ │ */ │ │ │ │ - dataLayers: null, │ │ │ │ - │ │ │ │ + visible: function() { │ │ │ │ + return OpenLayers.Element.visible(this.div); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: minimizeDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: toggle │ │ │ │ + * Toggles visibility of the popup. │ │ │ │ */ │ │ │ │ - minimizeDiv: null, │ │ │ │ + toggle: function() { │ │ │ │ + if (this.visible()) { │ │ │ │ + this.hide(); │ │ │ │ + } else { │ │ │ │ + this.show(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: maximizeDiv │ │ │ │ - * {DOMElement} │ │ │ │ + * Method: show │ │ │ │ + * Makes the popup visible. │ │ │ │ */ │ │ │ │ - maximizeDiv: null, │ │ │ │ + show: function() { │ │ │ │ + this.div.style.display = ''; │ │ │ │ + │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ascending │ │ │ │ - * {Boolean} │ │ │ │ + * Method: hide │ │ │ │ + * Makes the popup invisible. │ │ │ │ */ │ │ │ │ - ascending: true, │ │ │ │ + hide: function() { │ │ │ │ + this.div.style.display = 'none'; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.LayerSwitcher │ │ │ │ + * Method: setSize │ │ │ │ + * Used to adjust the size of the popup. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ + * contents div (in pixels). │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - this.layerStates = []; │ │ │ │ - }, │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + this.size = contentSize.clone(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ + // 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; │ │ │ │ │ │ │ │ - //clear out layers info and unregister their events │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ + // take into account the popup's 'padding' property │ │ │ │ + this.fixPadding(); │ │ │ │ + wPadding += this.padding.left + this.padding.right; │ │ │ │ + hPadding += this.padding.top + this.padding.bottom; │ │ │ │ │ │ │ │ - this.map.events.un({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - addlayer: this.redraw, │ │ │ │ - changelayer: this.redraw, │ │ │ │ - removelayer: this.redraw, │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ + // make extra space for the close div │ │ │ │ + if (this.closeDiv) { │ │ │ │ + var closeDivWidth = parseInt(this.closeDiv.style.width); │ │ │ │ + wPadding += closeDivWidth + contentDivPadding.right; │ │ │ │ + } │ │ │ │ │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + //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; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ - * Properties: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + //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.BROWSER_NAME == "msie") { │ │ │ │ + this.contentSize.w += │ │ │ │ + contentDivPadding.left + contentDivPadding.right; │ │ │ │ + this.contentSize.h += │ │ │ │ + contentDivPadding.bottom + contentDivPadding.top; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.map.events.on({ │ │ │ │ - addlayer: this.redraw, │ │ │ │ - changelayer: this.redraw, │ │ │ │ - removelayer: this.redraw, │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + 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: draw │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the │ │ │ │ - * switcher tabs. │ │ │ │ + * APIMethod: updateSize │ │ │ │ + * Auto size the popup so that it precisely fits its contents (as │ │ │ │ + * determined by this.contentDiv.innerHTML). Popup size will, of │ │ │ │ + * course, be limited by the available space on the current map │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ + updateSize: function() { │ │ │ │ │ │ │ │ - // create layout divs │ │ │ │ - this.loadContents(); │ │ │ │ + // determine actual render dimensions of the contents by putting its │ │ │ │ + // contents into a fake contentDiv (for the CSS) and then measuring it │ │ │ │ + var preparedHTML = "<div class='" + this.contentDisplayClass + "'>" + │ │ │ │ + this.contentDiv.innerHTML + │ │ │ │ + "</div>"; │ │ │ │ │ │ │ │ - // set mode to minimize │ │ │ │ - if (!this.outsideViewport) { │ │ │ │ - this.minimizeControl(); │ │ │ │ - } │ │ │ │ + var containerElement = (this.map) ? this.map.div : document.body; │ │ │ │ + var realSize = OpenLayers.Util.getRenderedDimensions( │ │ │ │ + preparedHTML, null, { │ │ │ │ + displayClass: this.displayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + } │ │ │ │ + ); │ │ │ │ │ │ │ │ - // populate div with current info │ │ │ │ - this.redraw(); │ │ │ │ + // is the "real" size of the div is safe to display in our map? │ │ │ │ + var safeSize = this.getSafeContentSize(realSize); │ │ │ │ │ │ │ │ - return this.div; │ │ │ │ + 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 'size' object with the clipped dimensions │ │ │ │ + // set or null if not clipped. │ │ │ │ + var fixedSize = { │ │ │ │ + w: (safeSize.w < realSize.w) ? safeSize.w : null, │ │ │ │ + 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( │ │ │ │ + preparedHTML, fixedSize, { │ │ │ │ + displayClass: this.contentDisplayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + │ │ │ │ + //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); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onButtonClick │ │ │ │ + * Method: setBackgroundColor │ │ │ │ + * Sets the background color of the popup. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * color - {String} the background color. eg "#FFBBBB" │ │ │ │ */ │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.minimizeDiv) { │ │ │ │ - this.minimizeControl(); │ │ │ │ - } else if (button === this.maximizeDiv) { │ │ │ │ - this.maximizeControl(); │ │ │ │ - } else if (button._layerSwitcher === this.id) { │ │ │ │ - if (button["for"]) { │ │ │ │ - button = document.getElementById(button["for"]); │ │ │ │ - } │ │ │ │ - if (!button.disabled) { │ │ │ │ - if (button.type == "radio") { │ │ │ │ - button.checked = true; │ │ │ │ - this.map.setBaseLayer(this.map.getLayer(button._layer)); │ │ │ │ - } else { │ │ │ │ - button.checked = !button.checked; │ │ │ │ - this.updateMap(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + setBackgroundColor: function(color) { │ │ │ │ + if (color != undefined) { │ │ │ │ + this.backgroundColor = color; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.backgroundColor = this.backgroundColor; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: clearLayersArray │ │ │ │ - * User specifies either "base" or "data". we then clear all the │ │ │ │ - * corresponding listeners, the div, and reinitialize a new array. │ │ │ │ - * │ │ │ │ + * Method: setOpacity │ │ │ │ + * Sets the opacity of the popup. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * layersType - {String} │ │ │ │ + * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ */ │ │ │ │ - clearLayersArray: function(layersType) { │ │ │ │ - this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ - this[layersType + "Layers"] = []; │ │ │ │ - }, │ │ │ │ + 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: checkRedraw │ │ │ │ - * Checks if the layer state has changed since the last redraw() call. │ │ │ │ + * Method: setBorder │ │ │ │ + * Sets the border style of the popup. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The layer state changed since the last redraw() call. │ │ │ │ + * Parameters: │ │ │ │ + * border - {String} The border style value. eg 2px │ │ │ │ */ │ │ │ │ - checkRedraw: function() { │ │ │ │ - if (!this.layerStates.length || │ │ │ │ - (this.map.layers.length != this.layerStates.length)) { │ │ │ │ - return true; │ │ │ │ + setBorder: function(border) { │ │ │ │ + if (border != undefined) { │ │ │ │ + this.border = border; │ │ │ │ } │ │ │ │ │ │ │ │ - for (var i = 0, len = this.layerStates.length; i < len; 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)) { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.border = this.border; │ │ │ │ } │ │ │ │ - │ │ │ │ - return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * Method: setContentHTML │ │ │ │ + * Allows the user to set the HTML content of the popup. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ + * Parameters: │ │ │ │ + * contentHTML - {String} HTML for the div. │ │ │ │ */ │ │ │ │ - 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; │ │ │ │ + setContentHTML: function(contentHTML) { │ │ │ │ + │ │ │ │ + if (contentHTML != null) { │ │ │ │ + this.contentHTML = contentHTML; │ │ │ │ } │ │ │ │ │ │ │ │ - //clear out previous layers │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ + if ((this.contentDiv != null) && │ │ │ │ + (this.contentHTML != null) && │ │ │ │ + (this.contentHTML != this.contentDiv.innerHTML)) { │ │ │ │ │ │ │ │ - var containsOverlays = false; │ │ │ │ - var containsBaseLayers = false; │ │ │ │ + this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ │ │ │ │ - // 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. │ │ │ │ - var len = this.map.layers.length; │ │ │ │ - this.layerStates = new Array(len); │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - this.layerStates[i] = { │ │ │ │ - 'name': layer.name, │ │ │ │ - 'visibility': layer.visibility, │ │ │ │ - 'inRange': layer.inRange, │ │ │ │ - 'id': layer.id │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + if (this.autoSize) { │ │ │ │ │ │ │ │ - var layers = this.map.layers.slice(); │ │ │ │ - if (!this.ascending) { │ │ │ │ - layers.reverse(); │ │ │ │ - } │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - var baseLayer = layer.isBaseLayer; │ │ │ │ + //if popup has images, listen for when they finish │ │ │ │ + // loading and resize accordingly │ │ │ │ + this.registerImageListeners(); │ │ │ │ │ │ │ │ - if (layer.displayInLayerSwitcher) { │ │ │ │ + //auto size the popup to its current contents │ │ │ │ + this.updateSize(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - 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(); │ │ │ │ + /** │ │ │ │ + * Method: registerImageListeners │ │ │ │ + * Called when an image contained by the popup loaded. this function │ │ │ │ + * updates the popup size, then unregisters the image load listener. │ │ │ │ + */ │ │ │ │ + registerImageListeners: function() { │ │ │ │ │ │ │ │ - // create input element │ │ │ │ - var inputElem = document.createElement("input"), │ │ │ │ - // The input shall have an id attribute so we can use │ │ │ │ - // labels to interact with them. │ │ │ │ - inputId = OpenLayers.Util.createUniqueID( │ │ │ │ - this.id + "_input_" │ │ │ │ - ); │ │ │ │ + // As the images load, this function will call updateSize() to │ │ │ │ + // resize the popup to fit the content div (which presumably is now │ │ │ │ + // bigger than when the image was not loaded). │ │ │ │ + // │ │ │ │ + // If the 'panMapIfOutOfView' property is set, we will pan the newly │ │ │ │ + // resized popup back into view. │ │ │ │ + // │ │ │ │ + // Note that this function, when called, will have 'popup' and │ │ │ │ + // 'img' properties in the context. │ │ │ │ + // │ │ │ │ + var onImgLoad = function() { │ │ │ │ + if (this.popup.id === null) { // this.popup has been destroyed! │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + this.popup.updateSize(); │ │ │ │ │ │ │ │ - inputElem.id = inputId; │ │ │ │ - inputElem.name = (baseLayer) ? this.id + "_baseLayers" : layer.name; │ │ │ │ - inputElem.type = (baseLayer) ? "radio" : "checkbox"; │ │ │ │ - inputElem.value = layer.name; │ │ │ │ - inputElem.checked = checked; │ │ │ │ - inputElem.defaultChecked = checked; │ │ │ │ - inputElem.className = "olButton"; │ │ │ │ - inputElem._layer = layer.id; │ │ │ │ - inputElem._layerSwitcher = this.id; │ │ │ │ + if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ + this.popup.panIntoView(); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - inputElem.disabled = true; │ │ │ │ - } │ │ │ │ + OpenLayers.Event.stopObserving( │ │ │ │ + this.img, "load", this.img._onImgLoad │ │ │ │ + ); │ │ │ │ │ │ │ │ - // create span │ │ │ │ - var labelSpan = document.createElement("label"); │ │ │ │ - // this isn't the DOM attribute 'for', but an arbitrary name we │ │ │ │ - // use to find the appropriate input element in <onButtonClick> │ │ │ │ - labelSpan["for"] = inputElem.id; │ │ │ │ - OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ - labelSpan._layer = layer.id; │ │ │ │ - labelSpan._layerSwitcher = this.id; │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - labelSpan.style.color = "gray"; │ │ │ │ - } │ │ │ │ - labelSpan.innerHTML = layer.name; │ │ │ │ - labelSpan.style.verticalAlign = (baseLayer) ? "bottom" : │ │ │ │ - "baseline"; │ │ │ │ - // create line break │ │ │ │ - var br = document.createElement("br"); │ │ │ │ + }; │ │ │ │ │ │ │ │ + //cycle through the images and if their size is 0x0, that means that │ │ │ │ + // they haven't been loaded yet, so we attach the listener, which │ │ │ │ + // will fire when the images finish loading and will resize the │ │ │ │ + // popup accordingly to its new size. │ │ │ │ + var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ + for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ + var img = images[i]; │ │ │ │ + if (img.width == 0 || img.height == 0) { │ │ │ │ │ │ │ │ - var groupArray = (baseLayer) ? this.baseLayers : │ │ │ │ - this.dataLayers; │ │ │ │ - groupArray.push({ │ │ │ │ - 'layer': layer, │ │ │ │ - 'inputElem': inputElem, │ │ │ │ - 'labelSpan': labelSpan │ │ │ │ - }); │ │ │ │ + var context = { │ │ │ │ + 'popup': this, │ │ │ │ + 'img': img │ │ │ │ + }; │ │ │ │ │ │ │ │ + //expando this function to the image itself before registering │ │ │ │ + // it. This way we can easily and properly unregister it. │ │ │ │ + img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ │ │ │ │ - var groupDiv = (baseLayer) ? this.baseLayersDiv : │ │ │ │ - this.dataLayersDiv; │ │ │ │ - groupDiv.appendChild(inputElem); │ │ │ │ - groupDiv.appendChild(labelSpan); │ │ │ │ - groupDiv.appendChild(br); │ │ │ │ + OpenLayers.Event.observe(img, 'load', img._onImgLoad); │ │ │ │ } │ │ │ │ } │ │ │ │ - │ │ │ │ - // 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: 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. │ │ │ │ + * APIMethod: getSafeContentSize │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * size - {<OpenLayers.Size>} Desired size to make the popup. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Size>} 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). │ │ │ │ */ │ │ │ │ - updateMap: function() { │ │ │ │ + getSafeContentSize: function(size) { │ │ │ │ │ │ │ │ - // set the newly selected base layer │ │ │ │ - for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.baseLayers[i]; │ │ │ │ - if (layerEntry.inputElem.checked) { │ │ │ │ - this.map.setBaseLayer(layerEntry.layer, false); │ │ │ │ - } │ │ │ │ + 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; │ │ │ │ } │ │ │ │ │ │ │ │ - // set the correct visibilities for the overlays │ │ │ │ - for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.dataLayers[i]; │ │ │ │ - layerEntry.layer.setVisibility(layerEntry.inputElem.checked); │ │ │ │ + // 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)); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: maximizeControl │ │ │ │ - * Set up the labels and divs for the control │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ - */ │ │ │ │ - maximizeControl: function(e) { │ │ │ │ + //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) { │ │ │ │ │ │ │ │ - // set the div's width and height to empty values, so │ │ │ │ - // the div dimensions can be controlled by CSS │ │ │ │ - this.div.style.width = ""; │ │ │ │ - this.div.style.height = ""; │ │ │ │ + var extraX = 0, │ │ │ │ + extraY = 0; │ │ │ │ + if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ + var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ + switch (this.relativePosition) { │ │ │ │ + case "tr": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "tl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "bl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + case "br": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - this.showControls(false); │ │ │ │ + var maxY = this.map.size.h - │ │ │ │ + this.map.paddingForPopups.top - │ │ │ │ + this.map.paddingForPopups.bottom - │ │ │ │ + hPadding - extraY; │ │ │ │ │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ + var maxX = this.map.size.w - │ │ │ │ + this.map.paddingForPopups.left - │ │ │ │ + this.map.paddingForPopups.right - │ │ │ │ + wPadding - extraX; │ │ │ │ + │ │ │ │ + safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ + safeContentSize.h = Math.min(safeContentSize.h, maxY); │ │ │ │ } │ │ │ │ + │ │ │ │ + return safeContentSize; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: minimizeControl │ │ │ │ - * Hide all the contents of the control, shrink the size, │ │ │ │ - * add the maximize icon │ │ │ │ + * 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. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ + * 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: │ │ │ │ + * {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - minimizeControl: function(e) { │ │ │ │ + getContentDivPadding: function() { │ │ │ │ │ │ │ │ - // to minimize the control we set its div's width │ │ │ │ - // and height to 0px, we cannot just set "display" │ │ │ │ - // to "none" because it would hide the maximize │ │ │ │ - // div │ │ │ │ - this.div.style.width = "0px"; │ │ │ │ - this.div.style.height = "0px"; │ │ │ │ + //use cached value if we have it │ │ │ │ + var contentDivPadding = this._contentDivPadding; │ │ │ │ + if (!contentDivPadding) { │ │ │ │ │ │ │ │ - this.showControls(true); │ │ │ │ + if (this.div.parentNode == null) { │ │ │ │ + //make the div invisible and add it to the page │ │ │ │ + this.div.style.display = "none"; │ │ │ │ + document.body.appendChild(this.div); │ │ │ │ + } │ │ │ │ │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ + //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; │ │ │ │ + │ │ │ │ + if (this.div.parentNode == document.body) { │ │ │ │ + //remove the div from the page and make it visible again │ │ │ │ + document.body.removeChild(this.div); │ │ │ │ + this.div.style.display = ""; │ │ │ │ + } │ │ │ │ } │ │ │ │ + return contentDivPadding; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: showControls │ │ │ │ - * Hide/Show all LayerSwitcher controls depending on whether we are │ │ │ │ - * minimized or not │ │ │ │ - * │ │ │ │ + * Method: addCloseBox │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * minimize - {Boolean} │ │ │ │ + * callback - {Function} The callback to be called when the close button │ │ │ │ + * is clicked. │ │ │ │ */ │ │ │ │ - showControls: function(minimize) { │ │ │ │ + addCloseBox: function(callback) { │ │ │ │ │ │ │ │ - this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ - this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ + this.closeDiv = OpenLayers.Util.createDiv( │ │ │ │ + this.id + "_close", null, { │ │ │ │ + w: 17, │ │ │ │ + h: 17 │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + this.closeDiv.className = "olPopupCloseBox"; │ │ │ │ │ │ │ │ - this.layersDiv.style.display = minimize ? "none" : ""; │ │ │ │ + // 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, "touchend", │ │ │ │ + OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ + OpenLayers.Event.observe(this.closeDiv, "click", │ │ │ │ + OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: loadContents │ │ │ │ - * Set up the labels and divs for the control │ │ │ │ + * Method: panIntoView │ │ │ │ + * Pans the map such that the popup is totaly viewable (if necessary) │ │ │ │ */ │ │ │ │ - loadContents: function() { │ │ │ │ + panIntoView: function() { │ │ │ │ │ │ │ │ - // layers list div │ │ │ │ - this.layersDiv = document.createElement("div"); │ │ │ │ - this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ - OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ + var mapSize = this.map.getSize(); │ │ │ │ │ │ │ │ - this.baseLbl = document.createElement("div"); │ │ │ │ - this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ + //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(); │ │ │ │ │ │ │ │ - this.baseLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ + //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; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.dataLbl = document.createElement("div"); │ │ │ │ - this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ + //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; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.dataLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ + var dx = origTL.x - newTL.x; │ │ │ │ + var dy = origTL.y - newTL.y; │ │ │ │ │ │ │ │ - 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.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. The same procedure is needed for │ │ │ │ + * touchmove and touchend events. │ │ │ │ + * │ │ │ │ + * 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); │ │ │ │ + │ │ │ │ + function onTouchstart(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ } │ │ │ │ + this.events.on({ │ │ │ │ + "mousedown": this.onmousedown, │ │ │ │ + "mousemove": this.onmousemove, │ │ │ │ + "mouseup": this.onmouseup, │ │ │ │ + "click": this.onclick, │ │ │ │ + "mouseout": this.onmouseout, │ │ │ │ + "dblclick": this.ondblclick, │ │ │ │ + "touchstart": onTouchstart, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ │ │ │ │ - this.div.appendChild(this.layersDiv); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // maximize button div │ │ │ │ - var img = OpenLayers.Util.getImageLocation('layer-switcher-maximize.png'); │ │ │ │ - this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - "OpenLayers_Control_MaximizeDiv", │ │ │ │ - null, │ │ │ │ - null, │ │ │ │ - img, │ │ │ │ - "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ - this.maximizeDiv.style.display = "none"; │ │ │ │ + /** │ │ │ │ + * 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); │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.div.appendChild(this.maximizeDiv); │ │ │ │ + /** │ │ │ │ + * 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); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - // minimize button div │ │ │ │ - var img = OpenLayers.Util.getImageLocation('layer-switcher-minimize.png'); │ │ │ │ - this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ - "OpenLayers_Control_MinimizeDiv", │ │ │ │ - null, │ │ │ │ - null, │ │ │ │ - img, │ │ │ │ - "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ - this.minimizeDiv.style.display = "none"; │ │ │ │ + /** │ │ │ │ + * 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); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.div.appendChild(this.minimizeDiv); │ │ │ │ + /** │ │ │ │ + * Method: onclick │ │ │ │ + * Ignore clicks, but allowing default browser handling │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + onclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ + /** │ │ │ │ + * 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/Control/Attribution.js │ │ │ │ + OpenLayers/Popup/Anchored.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Popup.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Attribution │ │ │ │ - * The attribution control adds attribution from layers to the map display. │ │ │ │ - * It uses 'attribution' property of each layer. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Popup.Anchored │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Popup> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Attribution = │ │ │ │ - OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Popup.Anchored = │ │ │ │ + OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: separator │ │ │ │ - * {String} String used to separate layers. │ │ │ │ + /** │ │ │ │ + * Property: relativePosition │ │ │ │ + * {String} Relative position of the popup ("br", "tr", "tl" or "bl"). │ │ │ │ */ │ │ │ │ - separator: ", ", │ │ │ │ + relativePosition: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: template │ │ │ │ - * {String} Template for the attribution. This has to include the substring │ │ │ │ - * "${layers}", which will be replaced by the layer specific │ │ │ │ - * attributions, separated by <separator>. The default is "${layers}". │ │ │ │ + * APIProperty: keepInMap │ │ │ │ + * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ + * contrain the popup such that it always fits in the available map │ │ │ │ + * space. By default, this is set. If you are creating popups that are │ │ │ │ + * near map edges and not allowing pannning, and especially if you have │ │ │ │ + * a popup which has a fixedRelativePosition, setting this to false may │ │ │ │ + * be a smart thing to do. │ │ │ │ + * │ │ │ │ + * For anchored popups, default is true, since subclasses will │ │ │ │ + * usually want this functionality. │ │ │ │ */ │ │ │ │ - template: "${layers}", │ │ │ │ + keepInMap: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Attribution │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Options for control. │ │ │ │ + * Property: anchor │ │ │ │ + * {Object} Object to which we'll anchor the popup. Must expose a │ │ │ │ + * 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>). │ │ │ │ */ │ │ │ │ + anchor: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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); │ │ │ │ + * Constructor: OpenLayers.Popup.Anchored │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {String} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * contentSize - {<OpenLayers.Size>} │ │ │ │ + * contentHTML - {String} │ │ │ │ + * anchor - {Object} Object which must expose a 'size' <OpenLayers.Size> │ │ │ │ + * and 'offset' <OpenLayers.Pixel> (generally an <OpenLayers.Icon>). │ │ │ │ + * closeBox - {Boolean} │ │ │ │ + * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ + */ │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ + closeBoxCallback) { │ │ │ │ + var newArguments = [ │ │ │ │ + id, lonlat, contentSize, 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) │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ - * Initialize control. │ │ │ │ + * 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. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ + * 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 - {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + moveTo: function(px) { │ │ │ │ + var oldRelativePosition = this.relativePosition; │ │ │ │ + this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ │ │ │ │ - this.map.events.on({ │ │ │ │ - 'changebaselayer': this.updateAttribution, │ │ │ │ - 'changelayer': this.updateAttribution, │ │ │ │ - 'addlayer': this.updateAttribution, │ │ │ │ - 'removelayer': this.updateAttribution, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.updateAttribution(); │ │ │ │ + OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ │ │ │ │ - return this.div; │ │ │ │ + //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(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: updateAttribution │ │ │ │ - * Update attribution string. │ │ │ │ + * APIMethod: setSize │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ + * contents div (in pixels). │ │ │ │ */ │ │ │ │ - updateAttribution: function() { │ │ │ │ - var attributions = []; │ │ │ │ - if (this.map && this.map.layers) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (layer.attribution && layer.getVisibility()) { │ │ │ │ - // add attribution only if attribution text is unique │ │ │ │ - if (OpenLayers.Util.indexOf( │ │ │ │ - attributions, layer.attribution) === -1) { │ │ │ │ - attributions.push(layer.attribution); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ - layers: attributions.join(this.separator) │ │ │ │ - }); │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ + │ │ │ │ + if ((this.lonlat) && (this.map)) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + this.moveTo(px); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ + /** │ │ │ │ + * Method: calculateRelativePosition │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * 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 Framed, however, will want to do something │ │ │ │ + * special here. │ │ │ │ + */ │ │ │ │ + updateRelativePosition: function() { │ │ │ │ + //to be overridden by subclasses │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: calculateNewPx │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} 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); │ │ │ │ + │ │ │ │ + //use contentSize if size is not already set │ │ │ │ + var size = this.size || this.contentSize; │ │ │ │ + │ │ │ │ + var top = (this.relativePosition.charAt(0) == 't'); │ │ │ │ + newPx.y += (top) ? -size.h : this.anchor.size.h; │ │ │ │ + │ │ │ │ + var left = (this.relativePosition.charAt(1) == 'l'); │ │ │ │ + newPx.x += (left) ? -size.w : this.anchor.size.w; │ │ │ │ + │ │ │ │ + return newPx; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler.js │ │ │ │ + OpenLayers/Popup/Framed.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/Popup/Anchored.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler │ │ │ │ - * Base class to construct a higher-level handler for event sequences. All │ │ │ │ - * handlers have activate and deactivate methods. In addition, they have │ │ │ │ - * methods named like browser events. When a handler is activated, any │ │ │ │ - * additional methods named like a browser event is registered as a │ │ │ │ - * listener for the corresponding event. When a handler is deactivated, │ │ │ │ - * those same methods are unregistered as event listeners. │ │ │ │ - * │ │ │ │ - * Handlers also typically have a callbacks object with keys named like │ │ │ │ - * the abstracted events or event sequences that they are in charge of │ │ │ │ - * handling. The controls that wrap handlers define the methods that │ │ │ │ - * correspond to these abstract events - so instead of listening for │ │ │ │ - * individual browser events, they only listen for the abstract events │ │ │ │ - * defined by the handler. │ │ │ │ - * │ │ │ │ - * Handlers are created by controls, which ultimately have the responsibility │ │ │ │ - * of making changes to the the state of the application. Handlers │ │ │ │ - * themselves may make temporary changes, but in general are expected to │ │ │ │ - * return the application in the same state that they found it. │ │ │ │ + * Class: OpenLayers.Popup.Framed │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Popup.Anchored> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ +OpenLayers.Popup.Framed = │ │ │ │ + OpenLayers.Class(OpenLayers.Popup.Anchored, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ + /** │ │ │ │ + * Property: imageSrc │ │ │ │ + * {String} location of the image to be used as the popup frame │ │ │ │ + */ │ │ │ │ + imageSrc: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: control │ │ │ │ - * {<OpenLayers.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. │ │ │ │ - */ │ │ │ │ - control: null, │ │ │ │ + /** │ │ │ │ + * Property: imageSize │ │ │ │ + * {<OpenLayers.Size>} Size (measured in pixels) of the image located │ │ │ │ + * by the 'imageSrc' property. │ │ │ │ + */ │ │ │ │ + imageSize: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - map: 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, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: keyMask │ │ │ │ - * {Integer} Use bitwise operators and one or more of the OpenLayers.Handler │ │ │ │ - * constants to construct a keyMask. The keyMask is used by │ │ │ │ - * <checkModifiers>. 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: 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: active │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - active: false, │ │ │ │ + /** │ │ │ │ + * 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, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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, │ │ │ │ + /** │ │ │ │ + * 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, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: touch │ │ │ │ - * {Boolean} Indicates the support of touch events. When touch events are │ │ │ │ - * started touch will be true and all mouse related listeners will do │ │ │ │ - * nothing. │ │ │ │ - */ │ │ │ │ - touch: false, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Popup.Framed │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {String} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * contentSize - {<OpenLayers.Size>} │ │ │ │ + * contentHTML - {String} │ │ │ │ + * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ + * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ + * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ + * closeBox - {Boolean} │ │ │ │ + * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ + */ │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ + closeBoxCallback) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Handler │ │ │ │ - * Construct a handler. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.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. If a map property │ │ │ │ - * is present in the options argument it will be used instead. │ │ │ │ - * 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; │ │ │ │ + OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - var map = this.map || control.map; │ │ │ │ - if (map) { │ │ │ │ - this.setMap(map); │ │ │ │ - } │ │ │ │ + if (this.fixedRelativePosition) { │ │ │ │ + //based on our decided relativePostion, set the current padding │ │ │ │ + // this keeps us from getting into trouble │ │ │ │ + this.updateRelativePosition(); │ │ │ │ │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ + //make calculateRelativePosition always return the specified │ │ │ │ + // fixed position. │ │ │ │ + this.calculateRelativePosition = function(px) { │ │ │ │ + return this.relativePosition; │ │ │ │ + }; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - }, │ │ │ │ + this.contentDiv.style.position = "absolute"; │ │ │ │ + this.contentDiv.style.zIndex = 1; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: checkModifiers │ │ │ │ - * Check the keyMask on the handler. If no <keyMask> is set, this always │ │ │ │ - * returns true. If a <keyMask> 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) | │ │ │ │ - (evt.metaKey ? OpenLayers.Handler.MOD_META : 0); │ │ │ │ + if (closeBox) { │ │ │ │ + this.closeDiv.style.zIndex = 1; │ │ │ │ + } │ │ │ │ │ │ │ │ - /* if it differs from the handler object's key mask, │ │ │ │ - bail out of the event handler */ │ │ │ │ - return (keyModifiers == this.keyMask); │ │ │ │ - }, │ │ │ │ + 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: 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, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.register(events[i], this[events[i]]); │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.imageSrc = null; │ │ │ │ + this.imageSize = null; │ │ │ │ + this.isAlphaImage = null; │ │ │ │ + │ │ │ │ + this.fixedRelativePosition = false; │ │ │ │ + this.positionBlocks = null; │ │ │ │ + │ │ │ │ + //remove our blocks │ │ │ │ + for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ + var block = this.blocks[i]; │ │ │ │ + │ │ │ │ + if (block.image) { │ │ │ │ + block.div.removeChild(block.image); │ │ │ │ + } │ │ │ │ + block.image = null; │ │ │ │ + │ │ │ │ + if (block.div) { │ │ │ │ + this.groupDiv.removeChild(block.div); │ │ │ │ + } │ │ │ │ + block.div = null; │ │ │ │ } │ │ │ │ - } │ │ │ │ - this.active = true; │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ + this.blocks = null; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.unregister(events[i], this[events[i]]); │ │ │ │ + OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setBackgroundColor │ │ │ │ + */ │ │ │ │ + setBackgroundColor: function(color) { │ │ │ │ + //does nothing since the framed popup's entire scheme is based on a │ │ │ │ + // an image -- changing the background color makes no sense. │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setBorder │ │ │ │ + */ │ │ │ │ + setBorder: function() { │ │ │ │ + //does nothing since the framed popup's entire scheme is based on a │ │ │ │ + // an image -- changing the popup's border makes no sense. │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setOpacity │ │ │ │ + * Sets the opacity of the popup. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ + */ │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + //does nothing since we suppose that we'll never apply an opacity │ │ │ │ + // to a framed popup │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: setSize │ │ │ │ + * Overridden here, because we need to update the blocks whenever the size │ │ │ │ + * of the popup has changed. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ + * contents div (in pixels). │ │ │ │ + */ │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ + │ │ │ │ + this.updateBlocks(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: updateRelativePosition │ │ │ │ + * When the relative position changes, we need to set the new padding │ │ │ │ + * BBOX on the popup, reposition the close div, and update the blocks. │ │ │ │ + */ │ │ │ │ + updateRelativePosition: function() { │ │ │ │ + │ │ │ │ + //update the padding │ │ │ │ + this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ + │ │ │ │ + //update the position of our close box to new padding │ │ │ │ + if (this.closeDiv) { │ │ │ │ + // 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 + │ │ │ │ + this.padding.right + "px"; │ │ │ │ + this.closeDiv.style.top = contentDivPadding.top + │ │ │ │ + this.padding.top + "px"; │ │ │ │ } │ │ │ │ - } │ │ │ │ - this.touch = false; │ │ │ │ - this.active = false; │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: startTouch │ │ │ │ - * Start touch events, this method must be called by subclasses in │ │ │ │ - * "touchstart" method. When touch events are started <touch> will be │ │ │ │ - * true and all mouse related listeners will do nothing. │ │ │ │ - */ │ │ │ │ - startTouch: function() { │ │ │ │ - if (!this.touch) { │ │ │ │ - this.touch = true; │ │ │ │ - var events = [ │ │ │ │ - "mousedown", "mouseup", "mousemove", "click", "dblclick", │ │ │ │ - "mouseout" │ │ │ │ - ]; │ │ │ │ - for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.unregister(events[i], this[events[i]]); │ │ │ │ - } │ │ │ │ + this.updateBlocks(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: calculateNewPx │ │ │ │ + * Besides the standard offset as determined by the Anchored class, our │ │ │ │ + * Framed popups have a special 'offset' property for each of their │ │ │ │ + * positions, which is used to offset the popup relative to its anchor. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Pixel>} The the new px position of the popup on the screen │ │ │ │ + * relative to the passed-in px. │ │ │ │ + */ │ │ │ │ + calculateNewPx: function(px) { │ │ │ │ + var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ + │ │ │ │ + newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ + │ │ │ │ + return newPx; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: createBlocks │ │ │ │ + */ │ │ │ │ + createBlocks: function() { │ │ │ │ + this.blocks = []; │ │ │ │ + │ │ │ │ + //since all positions contain the same number of blocks, we can │ │ │ │ + // just pick the first position and use its blocks array to create │ │ │ │ + // our blocks array │ │ │ │ + var firstPosition = null; │ │ │ │ + for (var key in this.positionBlocks) { │ │ │ │ + firstPosition = key; │ │ │ │ + break; │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + var position = this.positionBlocks[firstPosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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); │ │ │ │ - }, │ │ │ │ + var block = {}; │ │ │ │ + this.blocks.push(block); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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); │ │ │ │ - }, │ │ │ │ + var divId = this.id + '_FrameDecorationDiv_' + i; │ │ │ │ + block.div = OpenLayers.Util.createDiv(divId, │ │ │ │ + null, null, null, "absolute", null, "hidden", null │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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, ctrl, │ │ │ │ - * and meta 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 || handler.evt.metaKey(end). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The browser event. │ │ │ │ - */ │ │ │ │ - setEvent: function(evt) { │ │ │ │ - this.evt = evt; │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ + var imgId = this.id + '_FrameDecorationImg_' + i; │ │ │ │ + var imageCreator = │ │ │ │ + (this.isAlphaImage) ? OpenLayers.Util.createAlphaImageDiv : │ │ │ │ + OpenLayers.Util.createImage; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * Deconstruct the handler. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - // unregister event listeners │ │ │ │ - this.deactivate(); │ │ │ │ - // eliminate circular references │ │ │ │ - this.control = this.map = null; │ │ │ │ - }, │ │ │ │ + block.image = imageCreator(imgId, │ │ │ │ + null, this.imageSize, this.imageSrc, │ │ │ │ + "absolute", null, null, null │ │ │ │ + ); │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler" │ │ │ │ -}); │ │ │ │ + block.div.appendChild(block.image); │ │ │ │ + this.groupDiv.appendChild(block.div); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_NONE │ │ │ │ - * If set as the <keyMask>, <checkModifiers> returns false if any key is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_NONE = 0; │ │ │ │ + /** │ │ │ │ + * Method: updateBlocks │ │ │ │ + * Internal method, called on initialize and when the popup's relative │ │ │ │ + * position has changed. This function takes care of re-positioning │ │ │ │ + * the popup's blocks in their appropropriate places. │ │ │ │ + */ │ │ │ │ + updateBlocks: function() { │ │ │ │ + if (!this.blocks) { │ │ │ │ + this.createBlocks(); │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_SHIFT │ │ │ │ - * If set as the <keyMask>, <checkModifiers> returns false if Shift is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_SHIFT = 1; │ │ │ │ + if (this.size && this.relativePosition) { │ │ │ │ + var position = this.positionBlocks[this.relativePosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_CTRL │ │ │ │ - * If set as the <keyMask>, <checkModifiers> returns false if Ctrl is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_CTRL = 2; │ │ │ │ + var positionBlock = position.blocks[i]; │ │ │ │ + var block = this.blocks[i]; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_ALT │ │ │ │ - * If set as the <keyMask>, <checkModifiers> returns false if Alt is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_ALT = 4; │ │ │ │ + // adjust sizes │ │ │ │ + var l = positionBlock.anchor.left; │ │ │ │ + var b = positionBlock.anchor.bottom; │ │ │ │ + var r = positionBlock.anchor.right; │ │ │ │ + var t = positionBlock.anchor.top; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Handler.MOD_META │ │ │ │ - * If set as the <keyMask>, <checkModifiers> returns false if Cmd is down. │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MOD_META = 8; │ │ │ │ + //note that we use the isNaN() test here because if the │ │ │ │ + // size object is initialized with a "auto" parameter, the │ │ │ │ + // size constructor calls parseFloat() on the string, │ │ │ │ + // which will turn it into NaN │ │ │ │ + // │ │ │ │ + var w = (isNaN(positionBlock.size.w)) ? this.size.w - (r + l) : │ │ │ │ + positionBlock.size.w; │ │ │ │ + │ │ │ │ + var h = (isNaN(positionBlock.size.h)) ? this.size.h - (b + t) : │ │ │ │ + positionBlock.size.h; │ │ │ │ + │ │ │ │ + block.div.style.width = (w < 0 ? 0 : w) + 'px'; │ │ │ │ + block.div.style.height = (h < 0 ? 0 : h) + 'px'; │ │ │ │ + │ │ │ │ + block.div.style.left = (l != null) ? l + 'px' : ''; │ │ │ │ + block.div.style.bottom = (b != null) ? b + 'px' : ''; │ │ │ │ + block.div.style.right = (r != null) ? r + 'px' : ''; │ │ │ │ + block.div.style.top = (t != null) ? t + 'px' : ''; │ │ │ │ + │ │ │ │ + block.image.style.left = positionBlock.position.x + 'px'; │ │ │ │ + block.image.style.top = positionBlock.position.y + 'px'; │ │ │ │ + } │ │ │ │ │ │ │ │ + this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ + this.contentDiv.style.top = this.padding.top + "px"; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Drag.js │ │ │ │ + OpenLayers/Popup/FramedCloud.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Popup/Framed.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Bounds.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Pixel.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Size.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Drag │ │ │ │ - * The drag handler is used to deal with sequences of browser events related │ │ │ │ - * to dragging. The handler is used by controls that want to know when │ │ │ │ - * a drag sequence begins, when a drag is happening, and when it has │ │ │ │ - * finished. │ │ │ │ - * │ │ │ │ - * Controls that use the drag handler typically construct it with callbacks │ │ │ │ - * for 'down', 'move', and 'done'. Callbacks for these keys are called │ │ │ │ - * when the drag begins, with each move, and when the drag is done. In │ │ │ │ - * addition, controls can have callbacks keyed to 'up' and 'out' if they │ │ │ │ - * care to differentiate between the types of events that correspond with │ │ │ │ - * the end of a drag sequence. If no drag actually occurs (no mouse move) │ │ │ │ - * the 'down' and 'up' callbacks will be called, but not the 'done' │ │ │ │ - * callback. │ │ │ │ - * │ │ │ │ - * Create a new drag handler with the <OpenLayers.Handler.Drag> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * Class: OpenLayers.Popup.FramedCloud │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Popup.Framed> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ +OpenLayers.Popup.FramedCloud = │ │ │ │ + OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: started │ │ │ │ - * {Boolean} When a mousedown or touchstart event is received, we want to │ │ │ │ - * record it, but not set 'dragging' until the mouse moves after starting. │ │ │ │ - */ │ │ │ │ - started: false, │ │ │ │ + /** │ │ │ │ + * Property: contentDisplayClass │ │ │ │ + * {String} The CSS class of the popup content div. │ │ │ │ + */ │ │ │ │ + contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: stopDown │ │ │ │ - * {Boolean} Stop propagation of mousedown events from getting to listeners │ │ │ │ - * on the same element. Default is true. │ │ │ │ - */ │ │ │ │ - stopDown: true, │ │ │ │ + /** │ │ │ │ + * APIProperty: autoSize │ │ │ │ + * {Boolean} Framed Cloud is autosizing by default. │ │ │ │ + */ │ │ │ │ + autoSize: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: dragging │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - dragging: false, │ │ │ │ + /** │ │ │ │ + * APIProperty: panMapIfOutOfView │ │ │ │ + * {Boolean} Framed Cloud does pan into view by default. │ │ │ │ + */ │ │ │ │ + panMapIfOutOfView: true, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: last │ │ │ │ - * {<OpenLayers.Pixel>} The last pixel location of the drag. │ │ │ │ - */ │ │ │ │ - last: null, │ │ │ │ + /** │ │ │ │ + * APIProperty: imageSize │ │ │ │ + * {<OpenLayers.Size>} │ │ │ │ + */ │ │ │ │ + imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: start │ │ │ │ - * {<OpenLayers.Pixel>} The first pixel location of the drag. │ │ │ │ - */ │ │ │ │ - start: null, │ │ │ │ + /** │ │ │ │ + * APIProperty: isAlphaImage │ │ │ │ + * {Boolean} The FramedCloud does not use an alpha image (in honor of the │ │ │ │ + * good ie6 folk out there) │ │ │ │ + */ │ │ │ │ + isAlphaImage: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: lastMoveEvt │ │ │ │ - * {Object} The last mousemove event that occurred. Used to │ │ │ │ - * position the map correctly when our "delay drag" │ │ │ │ - * timeout expired. │ │ │ │ - */ │ │ │ │ - lastMoveEvt: null, │ │ │ │ + /** │ │ │ │ + * APIProperty: fixedRelativePosition │ │ │ │ + * {Boolean} The Framed Cloud popup works in just one fixed position. │ │ │ │ + */ │ │ │ │ + fixedRelativePosition: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: oldOnselectstart │ │ │ │ - * {Function} │ │ │ │ - */ │ │ │ │ - oldOnselectstart: null, │ │ │ │ + /** │ │ │ │ + * Property: positionBlocks │ │ │ │ + * {Object} Hash of differen position blocks, keyed by relativePosition │ │ │ │ + * two-character code string (ie "tl", "tr", "bl", "br") │ │ │ │ + */ │ │ │ │ + positionBlocks: { │ │ │ │ + "tl": { │ │ │ │ + 'offset': new OpenLayers.Pixel(44, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 18), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -688) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + "tr": { │ │ │ │ + 'offset': new OpenLayers.Pixel(-45, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 19), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ + position: new OpenLayers.Pixel(-215, -687) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + "bl": { │ │ │ │ + 'offset': new OpenLayers.Pixel(45, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-101, -674) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + "br": { │ │ │ │ + 'offset': new OpenLayers.Pixel(-44, 0), │ │ │ │ + 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + 'blocks': [{ // top-left │ │ │ │ + size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { //top-right │ │ │ │ + size: new OpenLayers.Size(22, 'auto'), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { //bottom-left │ │ │ │ + size: new OpenLayers.Size('auto', 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { //bottom-right │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { // stem │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ + position: new OpenLayers.Pixel(-311, -674) │ │ │ │ + }] │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: minSize │ │ │ │ + * {<OpenLayers.Size>} │ │ │ │ + */ │ │ │ │ + minSize: new OpenLayers.Size(105, 10), │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: maxSize │ │ │ │ + * {<OpenLayers.Size>} │ │ │ │ + */ │ │ │ │ + maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Popup.FramedCloud │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {String} │ │ │ │ + * lonlat - {<OpenLayers.LonLat>} │ │ │ │ + * contentSize - {<OpenLayers.Size>} │ │ │ │ + * contentHTML - {String} │ │ │ │ + * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ + * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ + * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ + * closeBox - {Boolean} │ │ │ │ + * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ + */ │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ + closeBoxCallback) { │ │ │ │ + │ │ │ │ + this.imageSrc = OpenLayers.Util.getImageLocation('cloud-popup-relative.png'); │ │ │ │ + OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @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({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: interval │ │ │ │ - * {Integer} In order to increase performance, an interval (in │ │ │ │ - * milliseconds) can be set to reduce the number of drag events │ │ │ │ - * called. If set, a new drag event will not be set until the │ │ │ │ - * interval has passed. │ │ │ │ - * Defaults to 0, meaning no interval. │ │ │ │ + * Property: options │ │ │ │ + * {Object} A reference to options passed to the constructor. │ │ │ │ */ │ │ │ │ - interval: 0, │ │ │ │ + options: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timeoutId │ │ │ │ - * {String} The id of the timeout used for the mousedown interval. │ │ │ │ - * This is "private", and should be left alone. │ │ │ │ + * APIProperty: externalProjection │ │ │ │ + * {<OpenLayers.Projection>} 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 │ │ │ │ + * {<OpenLayers.Projection.addTransform>} for more information on │ │ │ │ + * custom transformations. │ │ │ │ */ │ │ │ │ - timeoutId: null, │ │ │ │ + externalProjection: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} If set to true, the handler will also handle mouse moves when │ │ │ │ - * the cursor has moved out of the map viewport. Default is false. │ │ │ │ + * APIProperty: internalProjection │ │ │ │ + * {<OpenLayers.Projection>} 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 │ │ │ │ + * {<OpenLayers.Projection.addTransform>} for more information on │ │ │ │ + * custom transformations. │ │ │ │ */ │ │ │ │ - documentDrag: false, │ │ │ │ + internalProjection: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: documentEvents │ │ │ │ - * {Boolean} Are we currently observing document events? │ │ │ │ + * APIProperty: data │ │ │ │ + * {Object} When <keepData> is true, this is the parsed string sent to │ │ │ │ + * <read>. │ │ │ │ */ │ │ │ │ - documentEvents: null, │ │ │ │ + data: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Drag │ │ │ │ - * Returns OpenLayers.Handler.Drag │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ - * this handler. If a handler is being used without a control, the │ │ │ │ - * handlers setMap method must be overridden to deal properly with │ │ │ │ - * the map. │ │ │ │ - * callbacks - {Object} An object containing a single function to be │ │ │ │ - * called when the drag operation is finished. The callback should │ │ │ │ - * expect to recieve a single argument, the pixel location of the event. │ │ │ │ - * Callbacks for 'move' and 'done' are supported. You can also speficy │ │ │ │ - * callbacks for 'down', 'up', and 'out' to respond to those events. │ │ │ │ - * options - {Object} │ │ │ │ + * APIProperty: keepData │ │ │ │ + * {Object} Maintain a reference (<data>) to the most recently read data. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - var me = this; │ │ │ │ - this._docMove = function(evt) { │ │ │ │ - me.mousemove({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - }, │ │ │ │ - element: document │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - this._docUp = function(evt) { │ │ │ │ - me.mouseup({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ + keepData: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragstart │ │ │ │ - * This private method is factorized from mousedown and touchstart methods │ │ │ │ + * Constructor: OpenLayers.Format │ │ │ │ + * Instances of this class are not useful. See one of the subclasses. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} The event │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * format │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * keepData - {Boolean} If true, upon <read>, the data property will be │ │ │ │ + * set to the parsed object (e.g. the json or xml object). │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * An instance of OpenLayers.Format │ │ │ │ */ │ │ │ │ - dragstart: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - this.dragging = false; │ │ │ │ - if (this.checkModifiers(evt) && │ │ │ │ - (OpenLayers.Event.isLeftClick(evt) || │ │ │ │ - OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ - this.started = true; │ │ │ │ - this.start = evt.xy; │ │ │ │ - this.last = evt.xy; │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - this.down(evt); │ │ │ │ - this.callback("down", [evt.xy]); │ │ │ │ - │ │ │ │ - // prevent document dragging │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart ? │ │ │ │ - document.onselectstart : OpenLayers.Function.True; │ │ │ │ - } │ │ │ │ - document.onselectstart = OpenLayers.Function.False; │ │ │ │ - │ │ │ │ - propagate = !this.stopDown; │ │ │ │ - } else { │ │ │ │ - this.started = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - } │ │ │ │ - return propagate; │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragmove │ │ │ │ - * This private method is factorized from mousemove and touchmove methods │ │ │ │ - * │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up. │ │ │ │ + */ │ │ │ │ + destroy: function() {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: read │ │ │ │ + * Read data from a string, and return an object whose type depends on the │ │ │ │ + * subclass. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} The event │ │ │ │ + * data - {string} Data to read/parse. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Depends on the subclass │ │ │ │ */ │ │ │ │ - dragmove: function(evt) { │ │ │ │ - this.lastMoveEvt = evt; │ │ │ │ - if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || │ │ │ │ - evt.xy.y != this.last.y)) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - if (evt.element === document) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - // do setEvent manually because the documentEvents are not │ │ │ │ - // registered with the map │ │ │ │ - this.setEvent(evt); │ │ │ │ - } else { │ │ │ │ - this.removeDocumentEvents(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.interval > 0) { │ │ │ │ - this.timeoutId = setTimeout( │ │ │ │ - OpenLayers.Function.bind(this.removeTimeout, this), │ │ │ │ - this.interval); │ │ │ │ - } │ │ │ │ - this.dragging = true; │ │ │ │ - │ │ │ │ - this.move(evt); │ │ │ │ - this.callback("move", [evt.xy]); │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart; │ │ │ │ - document.onselectstart = OpenLayers.Function.False; │ │ │ │ - } │ │ │ │ - this.last = evt.xy; │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ + read: function(data) { │ │ │ │ + throw new Error('Read not implemented.'); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dragend │ │ │ │ - * This private method is factorized from mouseup and touchend methods │ │ │ │ + * Method: write │ │ │ │ + * Accept an object, and return a string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} The event │ │ │ │ + * object - {Object} Object to be serialized │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {String} A string representation of the object. │ │ │ │ */ │ │ │ │ - dragend: function(evt) { │ │ │ │ - if (this.started) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - this.removeDocumentEvents(); │ │ │ │ - } │ │ │ │ - var dragged = (this.start != this.last); │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - this.up(evt); │ │ │ │ - this.callback("up", [evt.xy]); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]); │ │ │ │ - } │ │ │ │ - document.onselectstart = this.oldOnselectstart; │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ + write: function(object) { │ │ │ │ + throw new Error('Write not implemented.'); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Format" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/JSON.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository 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 │ │ │ │ + * <OpenLayers.Format.JSON> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + │ │ │ │ /** │ │ │ │ - * The four methods below (down, move, up, and out) are used by subclasses │ │ │ │ - * to do their own processing related to these mouse events. │ │ │ │ + * APIProperty: indent │ │ │ │ + * {String} For "pretty" printing, the indent string will be used once for │ │ │ │ + * each indentation level. │ │ │ │ */ │ │ │ │ + indent: " ", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: down │ │ │ │ - * This method is called during the handling of the mouse down event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse down event │ │ │ │ + * APIProperty: space │ │ │ │ + * {String} For "pretty" printing, the space string will be used after │ │ │ │ + * the ":" separating a name/value pair. │ │ │ │ */ │ │ │ │ - down: function(evt) {}, │ │ │ │ + space: " ", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: move │ │ │ │ - * This method is called during the handling of the mouse move event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse move event │ │ │ │ - * │ │ │ │ + * APIProperty: newline │ │ │ │ + * {String} For "pretty" printing, the newline string will be used at the │ │ │ │ + * end of each name/value pair or array item. │ │ │ │ */ │ │ │ │ - move: function(evt) {}, │ │ │ │ + newline: "\n", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: up │ │ │ │ - * This method is called during the handling of the mouse up event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse up event │ │ │ │ + * Property: level │ │ │ │ + * {Integer} For "pretty" printing, this is incremented/decremented during │ │ │ │ + * serialization. │ │ │ │ */ │ │ │ │ - up: function(evt) {}, │ │ │ │ + level: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: out │ │ │ │ - * This method is called during the handling of the mouse out event. │ │ │ │ - * Subclasses can do their own processing here. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} The mouse out event │ │ │ │ + * Property: pretty │ │ │ │ + * {Boolean} Serialize with extra whitespace for structure. This is set │ │ │ │ + * by the <write> method. │ │ │ │ */ │ │ │ │ - out: function(evt) {}, │ │ │ │ + pretty: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * The methods below are part of the magic of event handling. Because │ │ │ │ - * they are named like browser events, they are registered as listeners │ │ │ │ - * for the events they represent. │ │ │ │ + * Property: nativeJSON │ │ │ │ + * {Boolean} Does the browser support native json? │ │ │ │ */ │ │ │ │ + nativeJSON: (function() { │ │ │ │ + return !!(window.JSON && typeof JSON.parse == "function" && typeof JSON.stringify == "function"); │ │ │ │ + })(), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mousedown events │ │ │ │ + * Constructor: OpenLayers.Format.JSON │ │ │ │ + * Create a new parser for JSON. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - return this.dragstart(evt); │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart events │ │ │ │ + * APIMethod: read │ │ │ │ + * Deserialize a json string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ + * 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: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {Object} An object, array, string, or number . │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return this.dragstart(evt); │ │ │ │ + read: function(json, filter) { │ │ │ │ + var object; │ │ │ │ + if (this.nativeJSON) { │ │ │ │ + object = JSON.parse(json, filter); │ │ │ │ + } else try { │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ + */ │ │ │ │ + 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. │ │ │ │ + */ │ │ │ │ + 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); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } catch (e) { │ │ │ │ + // Fall through if the regexp test fails. │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (this.keepData) { │ │ │ │ + this.data = object; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return object; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousemove │ │ │ │ - * Handle mousemove events │ │ │ │ + * APIMethod: write │ │ │ │ + * Serialize an object into a JSON string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * 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: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {String} The JSON string representation of the input value. │ │ │ │ */ │ │ │ │ - mousemove: function(evt) { │ │ │ │ - return this.dragmove(evt); │ │ │ │ + write: function(value, pretty) { │ │ │ │ + this.pretty = !!pretty; │ │ │ │ + var json = null; │ │ │ │ + var type = typeof value; │ │ │ │ + if (this.serialize[type]) { │ │ │ │ + try { │ │ │ │ + json = (!this.pretty && this.nativeJSON) ? │ │ │ │ + JSON.stringify(value) : │ │ │ │ + this.serialize[type].apply(this, [value]); │ │ │ │ + } catch (err) { │ │ │ │ + OpenLayers.Console.error("Trouble serializing: " + err); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return json; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Handle touchmove events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: writeIndent │ │ │ │ + * Output an indentation string depending on the indentation level. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ - */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - return this.dragmove(evt); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: removeTimeout │ │ │ │ - * Private. Called by mousemove() to remove the drag timeout. │ │ │ │ + * {String} An appropriate indentation string. │ │ │ │ */ │ │ │ │ - removeTimeout: function() { │ │ │ │ - this.timeoutId = null; │ │ │ │ - // if timeout expires while we're still dragging (mouseup │ │ │ │ - // hasn't occurred) then call mousemove to move to the │ │ │ │ - // correct position │ │ │ │ - if (this.dragging) { │ │ │ │ - this.mousemove(this.lastMoveEvt); │ │ │ │ + writeIndent: function() { │ │ │ │ + var pieces = []; │ │ │ │ + if (this.pretty) { │ │ │ │ + for (var i = 0; i < this.level; ++i) { │ │ │ │ + pieces.push(this.indent); │ │ │ │ + } │ │ │ │ } │ │ │ │ + return pieces.join(''); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouseup events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: writeNewline │ │ │ │ + * Output a string representing a newline if in pretty printing mode. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {String} A string representing a new line. │ │ │ │ */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - return this.dragend(evt); │ │ │ │ + writeNewline: function() { │ │ │ │ + return (this.pretty) ? this.newline : ''; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchend │ │ │ │ - * Handle touchend events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: writeSpace │ │ │ │ + * Output a string representing a space if in pretty printing mode. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * {String} A space. │ │ │ │ */ │ │ │ │ - touchend: function(evt) { │ │ │ │ - // override evt.xy with last position since touchend does not have │ │ │ │ - // any touch position │ │ │ │ - evt.xy = this.last; │ │ │ │ - return this.dragend(evt); │ │ │ │ + writeSpace: function() { │ │ │ │ + return (this.pretty) ? this.space : ''; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mouseout │ │ │ │ - * Handle mouseout events │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Property: serialize │ │ │ │ + * Object with properties corresponding to the serializable data types. │ │ │ │ + * Property values are functions that do the actual serializing. │ │ │ │ */ │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - this.addDocumentEvents(); │ │ │ │ - } else { │ │ │ │ - var dragged = (this.start != this.last); │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - this.out(evt); │ │ │ │ - this.callback("out", []); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]); │ │ │ │ + serialize: { │ │ │ │ + /** │ │ │ │ + * Method: serialize.object │ │ │ │ + * Transform an object into a JSON string. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * object - {Object} The object to be serialized. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A JSON string representing the object. │ │ │ │ + */ │ │ │ │ + 'object': function(object) { │ │ │ │ + // three special objects that we want to treat differently │ │ │ │ + if (object == null) { │ │ │ │ + return "null"; │ │ │ │ + } │ │ │ │ + if (object.constructor == Date) { │ │ │ │ + return this.serialize.date.apply(this, [object]); │ │ │ │ + } │ │ │ │ + if (object.constructor == Array) { │ │ │ │ + return this.serialize.array.apply(this, [object]); │ │ │ │ + } │ │ │ │ + var pieces = ['{']; │ │ │ │ + this.level += 1; │ │ │ │ + var key, keyJSON, valueJSON; │ │ │ │ + │ │ │ │ + var addComma = false; │ │ │ │ + for (key in object) { │ │ │ │ + if (object.hasOwnProperty(key)) { │ │ │ │ + // recursive calls need to allow for sub-classing │ │ │ │ + keyJSON = OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ + [key, this.pretty]); │ │ │ │ + valueJSON = OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ + [object[key], this.pretty]); │ │ │ │ + if (keyJSON != null && valueJSON != null) { │ │ │ │ + if (addComma) { │ │ │ │ + pieces.push(','); │ │ │ │ + } │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), │ │ │ │ + keyJSON, ':', this.writeSpace(), valueJSON); │ │ │ │ + addComma = true; │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (document.onselectstart) { │ │ │ │ - document.onselectstart = this.oldOnselectstart; │ │ │ │ + } │ │ │ │ + │ │ │ │ + this.level -= 1; │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), '}'); │ │ │ │ + return pieces.join(''); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: serialize.array │ │ │ │ + * Transform an array into a JSON string. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Array} The array to be serialized │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A JSON string representing the array. │ │ │ │ + */ │ │ │ │ + 'array': function(array) { │ │ │ │ + var json; │ │ │ │ + var pieces = ['[']; │ │ │ │ + this.level += 1; │ │ │ │ + │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + // recursive calls need to allow for sub-classing │ │ │ │ + json = OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ + [array[i], this.pretty]); │ │ │ │ + if (json != null) { │ │ │ │ + if (i > 0) { │ │ │ │ + pieces.push(','); │ │ │ │ + } │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), json); │ │ │ │ } │ │ │ │ } │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: click │ │ │ │ - * The drag handler captures the click event. If something else registers │ │ │ │ - * for clicks on the same element, its listener will not be called │ │ │ │ - * after a drag. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ - */ │ │ │ │ - click: function(evt) { │ │ │ │ - // let the click event propagate only if the mouse moved │ │ │ │ - return (this.start == this.last); │ │ │ │ - }, │ │ │ │ + this.level -= 1; │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), ']'); │ │ │ │ + return pieces.join(''); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully activated. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragging = false; │ │ │ │ - activated = true; │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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: deactivate │ │ │ │ - * Deactivate the handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated. │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDragDown" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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: adjustXY │ │ │ │ - * Converts event coordinates that are relative to the document body to │ │ │ │ - * ones that are relative to the map viewport. The latter is the default in │ │ │ │ - * OpenLayers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ - */ │ │ │ │ - adjustXY: function(evt) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ - evt.xy.x -= pos[0]; │ │ │ │ - evt.xy.y -= pos[1]; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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: addDocumentEvents │ │ │ │ - * Start observing document events when documentDrag is true and the mouse │ │ │ │ - * cursor leaves the map viewport while dragging. │ │ │ │ - */ │ │ │ │ - addDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = true; │ │ │ │ - OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.observe(document, "mouseup", this._docUp); │ │ │ │ + /** │ │ │ │ + * 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()) + '"'; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeDocumentEvents │ │ │ │ - * Stops observing document events when documentDrag is true and the mouse │ │ │ │ - * cursor re-enters the map viewport while dragging. │ │ │ │ - */ │ │ │ │ - removeDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = false; │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mouseup", this._docUp); │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.JSON" │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Box.js │ │ │ │ + OpenLayers/Geometry.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Box │ │ │ │ - * Handler for dragging a rectangle across the map. Box is displayed │ │ │ │ - * on mouse down, moves on mouse move, and is finished on mouse up. │ │ │ │ + * Class: OpenLayers.Geometry │ │ │ │ + * A Geometry is a description of a geographic object. Create an instance of │ │ │ │ + * this class with the <OpenLayers.Geometry> constructor. This is a base class, │ │ │ │ + * typical geometry types are described by subclasses of this class. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * Note that if you use the <OpenLayers.Geometry.fromWKT> method, you must │ │ │ │ + * explicitly include the OpenLayers.Format.WKT in your build. │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ +OpenLayers.Geometry = OpenLayers.Class({ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: dragHandler │ │ │ │ - * {<OpenLayers.Handler.Drag>} │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} A unique identifier for this geometry. │ │ │ │ */ │ │ │ │ - dragHandler: null, │ │ │ │ + id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: boxDivClassName │ │ │ │ - * {String} The CSS class to use for drawing the box. Default is │ │ │ │ - * olHandlerBoxZoomBox │ │ │ │ + * Property: parent │ │ │ │ + * {<OpenLayers.Geometry>}This is set when a Geometry is added as component │ │ │ │ + * of another geometry │ │ │ │ */ │ │ │ │ - boxDivClassName: 'olHandlerBoxZoomBox', │ │ │ │ + parent: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: boxOffsets │ │ │ │ - * {Object} Caches box offsets from css. This is used by the getBoxOffsets │ │ │ │ - * method. │ │ │ │ + * Property: bounds │ │ │ │ + * {<OpenLayers.Bounds>} The bounds of this geometry │ │ │ │ */ │ │ │ │ - boxOffsets: null, │ │ │ │ + bounds: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Box │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - * callbacks - {Object} An object with a properties whose values are │ │ │ │ - * functions. Various callbacks described below. │ │ │ │ - * options - {Object} │ │ │ │ - * │ │ │ │ - * Named callbacks: │ │ │ │ - * start - Called when the box drag operation starts. │ │ │ │ - * done - Called when the box drag operation is finished. │ │ │ │ - * The callback should expect to receive a single argument, the box │ │ │ │ - * bounds or a pixel. If the box dragging didn't span more than a 5 │ │ │ │ - * pixel distance, a pixel will be returned instead of a bounds object. │ │ │ │ + * Constructor: OpenLayers.Geometry │ │ │ │ + * Creates a geometry object. │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.dragHandler = new OpenLayers.Handler.Drag( │ │ │ │ - this, { │ │ │ │ - down: this.startBox, │ │ │ │ - move: this.moveBox, │ │ │ │ - out: this.removeBox, │ │ │ │ - up: this.endBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ - } │ │ │ │ - ); │ │ │ │ + initialize: function() { │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * Method: destroy │ │ │ │ + * Destroy this geometry. │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.dragHandler) { │ │ │ │ - this.dragHandler.destroy(); │ │ │ │ - this.dragHandler = null; │ │ │ │ - } │ │ │ │ + this.id = null; │ │ │ │ + this.bounds = null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setMap │ │ │ │ + * APIMethod: clone │ │ │ │ + * Create a clone of this geometry. Does not set any non-standard │ │ │ │ + * properties of the cloned geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} An exact clone of this geometry. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Handler.prototype.setMap.apply(this, arguments); │ │ │ │ - if (this.dragHandler) { │ │ │ │ - this.dragHandler.setMap(map); │ │ │ │ - } │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Geometry(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: startBox │ │ │ │ - * │ │ │ │ + * Method: setBounds │ │ │ │ + * Set the bounds for this Geometry. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - startBox: function(xy) { │ │ │ │ - this.callback("start", []); │ │ │ │ - this.zoomBox = OpenLayers.Util.createDiv('zoomBox', { │ │ │ │ - x: -9999, │ │ │ │ - y: -9999 │ │ │ │ - }); │ │ │ │ - this.zoomBox.className = this.boxDivClassName; │ │ │ │ - this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; │ │ │ │ - │ │ │ │ - this.map.viewPortDiv.appendChild(this.zoomBox); │ │ │ │ - │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, "olDrawBox" │ │ │ │ - ); │ │ │ │ + setBounds: function(bounds) { │ │ │ │ + if (bounds) { │ │ │ │ + this.bounds = bounds.clone(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveBox │ │ │ │ + * Method: clearBounds │ │ │ │ + * Nullify this components bounds and that of its parent as well. │ │ │ │ */ │ │ │ │ - moveBox: function(xy) { │ │ │ │ - var startX = this.dragHandler.start.x; │ │ │ │ - var startY = this.dragHandler.start.y; │ │ │ │ - var deltaX = Math.abs(startX - xy.x); │ │ │ │ - var deltaY = Math.abs(startY - xy.y); │ │ │ │ - │ │ │ │ - var offset = this.getBoxOffsets(); │ │ │ │ - this.zoomBox.style.width = (deltaX + offset.width + 1) + "px"; │ │ │ │ - this.zoomBox.style.height = (deltaY + offset.height + 1) + "px"; │ │ │ │ - this.zoomBox.style.left = (xy.x < startX ? │ │ │ │ - startX - deltaX - offset.left : startX - offset.left) + "px"; │ │ │ │ - this.zoomBox.style.top = (xy.y < startY ? │ │ │ │ - startY - deltaY - offset.top : startY - offset.top) + "px"; │ │ │ │ + clearBounds: function() { │ │ │ │ + this.bounds = null; │ │ │ │ + if (this.parent) { │ │ │ │ + this.parent.clearBounds(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: endBox │ │ │ │ + * Method: extendBounds │ │ │ │ + * Extend the existing bounds to include the new bounds. │ │ │ │ + * If geometry's bounds is not yet set, then set a new Bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * newBounds - {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - endBox: function(end) { │ │ │ │ - var result; │ │ │ │ - if (Math.abs(this.dragHandler.start.x - end.x) > 5 || │ │ │ │ - Math.abs(this.dragHandler.start.y - end.y) > 5) { │ │ │ │ - var start = this.dragHandler.start; │ │ │ │ - var top = Math.min(start.y, end.y); │ │ │ │ - var bottom = Math.max(start.y, end.y); │ │ │ │ - var left = Math.min(start.x, end.x); │ │ │ │ - var right = Math.max(start.x, end.x); │ │ │ │ - result = new OpenLayers.Bounds(left, bottom, right, top); │ │ │ │ + extendBounds: function(newBounds) { │ │ │ │ + var bounds = this.getBounds(); │ │ │ │ + if (!bounds) { │ │ │ │ + this.setBounds(newBounds); │ │ │ │ } else { │ │ │ │ - result = this.dragHandler.start.clone(); // i.e. OL.Pixel │ │ │ │ + this.bounds.extend(newBounds); │ │ │ │ } │ │ │ │ - this.removeBox(); │ │ │ │ - │ │ │ │ - this.callback("done", [result]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: removeBox │ │ │ │ - * Remove the zoombox from the screen and nullify our reference to it. │ │ │ │ - */ │ │ │ │ - removeBox: function() { │ │ │ │ - this.map.viewPortDiv.removeChild(this.zoomBox); │ │ │ │ - this.zoomBox = null; │ │ │ │ - this.boxOffsets = null; │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, "olDrawBox" │ │ │ │ - ); │ │ │ │ - │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ + * APIMethod: getBounds │ │ │ │ + * Get the bounds for this Geometry. If bounds is not set, it │ │ │ │ + * is calculated again, this makes queries faster. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Bounds>} │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragHandler.activate(); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + getBounds: function() { │ │ │ │ + if (this.bounds == null) { │ │ │ │ + this.calculateBounds(); │ │ │ │ } │ │ │ │ + return this.bounds; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ + /** │ │ │ │ + * APIMethod: calculateBounds │ │ │ │ + * Recalculate the bounds for the geometry. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - if (this.dragHandler.deactivate()) { │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.removeBox(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + calculateBounds: function() { │ │ │ │ + // │ │ │ │ + // This should be overridden by subclasses. │ │ │ │ + // │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getBoxOffsets │ │ │ │ - * Determines border offsets for a box, according to the box model. │ │ │ │ + * APIMethod: distanceTo │ │ │ │ + * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Optional properties for configuring the distance │ │ │ │ + * calculation. │ │ │ │ + * │ │ │ │ + * Valid options depend on the specific geometry type. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} an object with the following offsets: │ │ │ │ - * - left │ │ │ │ - * - right │ │ │ │ - * - top │ │ │ │ - * - bottom │ │ │ │ - * - width │ │ │ │ - * - height │ │ │ │ + * {Number | Object} The distance between this geometry and the target. │ │ │ │ + * If details is true, the return will be an object with distance, │ │ │ │ + * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ + * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ + * properties represent the coordinates of the closest point on the │ │ │ │ + * target geometry. │ │ │ │ */ │ │ │ │ - getBoxOffsets: function() { │ │ │ │ - if (!this.boxOffsets) { │ │ │ │ - // Determine the box model. If the testDiv's clientWidth is 3, then │ │ │ │ - // the borders are outside and we are dealing with the w3c box │ │ │ │ - // model. Otherwise, the browser uses the traditional box model and │ │ │ │ - // the borders are inside the box bounds, leaving us with a │ │ │ │ - // clientWidth of 1. │ │ │ │ - var testDiv = document.createElement("div"); │ │ │ │ - //testDiv.style.visibility = "hidden"; │ │ │ │ - testDiv.style.position = "absolute"; │ │ │ │ - testDiv.style.border = "1px solid black"; │ │ │ │ - testDiv.style.width = "3px"; │ │ │ │ - document.body.appendChild(testDiv); │ │ │ │ - var w3cBoxModel = testDiv.clientWidth == 3; │ │ │ │ - document.body.removeChild(testDiv); │ │ │ │ - │ │ │ │ - var left = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ - "border-left-width")); │ │ │ │ - var right = parseInt(OpenLayers.Element.getStyle( │ │ │ │ - this.zoomBox, "border-right-width")); │ │ │ │ - var top = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ - "border-top-width")); │ │ │ │ - var bottom = parseInt(OpenLayers.Element.getStyle( │ │ │ │ - this.zoomBox, "border-bottom-width")); │ │ │ │ - this.boxOffsets = { │ │ │ │ - left: left, │ │ │ │ - right: right, │ │ │ │ - top: top, │ │ │ │ - bottom: bottom, │ │ │ │ - width: w3cBoxModel === false ? left + right : 0, │ │ │ │ - height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - return this.boxOffsets; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/ZoomBox.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Box.js │ │ │ │ - */ │ │ │ │ + distanceTo: function(geometry, options) {}, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.ZoomBox │ │ │ │ - * The ZoomBox control enables zooming directly to a given extent, by drawing │ │ │ │ - * a box on the map. The box is drawn by holding down shift, whilst dragging │ │ │ │ - * the mouse. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ /** │ │ │ │ - * Property: type │ │ │ │ - * {OpenLayers.Control.TYPE} │ │ │ │ + * APIMethod: getVertices │ │ │ │ + * Return a list of all points in this geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ + * endpoints. If false, for lines, only vertices that are not │ │ │ │ + * endpoints will be returned. If not provided, all vertices will │ │ │ │ + * be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} A list of all vertices in the geometry. │ │ │ │ */ │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + getVertices: function(nodes) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: out │ │ │ │ - * {Boolean} Should the control be used for zooming out? │ │ │ │ + * Method: atPoint │ │ │ │ + * Note - This is only an approximation based on the bounds of the │ │ │ │ + * geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * lonlat - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an │ │ │ │ + * object with a 'lon' and 'lat' properties. │ │ │ │ + * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ + * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Whether or not the geometry is at the specified location │ │ │ │ */ │ │ │ │ - out: false, │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + var bounds = this.getBounds(); │ │ │ │ + if ((bounds != null) && (lonlat != null)) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: keyMask │ │ │ │ - * {Integer} Zoom only occurs if the keyMask matches the combination of │ │ │ │ - * keys down. Use bitwise operators and one or more of the │ │ │ │ - * <OpenLayers.Handler> constants to construct a keyMask. Leave null if │ │ │ │ - * not used mask. Default is null. │ │ │ │ - */ │ │ │ │ - keyMask: null, │ │ │ │ + var dX = (toleranceLon != null) ? toleranceLon : 0; │ │ │ │ + var dY = (toleranceLat != null) ? toleranceLat : 0; │ │ │ │ + │ │ │ │ + var toleranceBounds = │ │ │ │ + new OpenLayers.Bounds(this.bounds.left - dX, │ │ │ │ + this.bounds.bottom - dY, │ │ │ │ + this.bounds.right + dX, │ │ │ │ + this.bounds.top + dY); │ │ │ │ + │ │ │ │ + atPoint = toleranceBounds.containsLonLat(lonlat); │ │ │ │ + } │ │ │ │ + return atPoint; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: alwaysZoom │ │ │ │ - * {Boolean} Always zoom in/out when box drawn, even if the zoom level does │ │ │ │ - * not change. │ │ │ │ + * Method: getLength │ │ │ │ + * Calculate the length of this geometry. This method is defined in │ │ │ │ + * subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The length of the collection by summing its parts │ │ │ │ */ │ │ │ │ - alwaysZoom: false, │ │ │ │ + getLength: function() { │ │ │ │ + //to be overridden by geometries that actually have a length │ │ │ │ + // │ │ │ │ + return 0.0; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomOnClick │ │ │ │ - * {Boolean} Should we zoom when no box was dragged, i.e. the user only │ │ │ │ - * clicked? Default is true. │ │ │ │ + * Method: getArea │ │ │ │ + * Calculate the area of this geometry. This method is defined in subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The area of the collection by summing its parts │ │ │ │ */ │ │ │ │ - zoomOnClick: true, │ │ │ │ + getArea: function() { │ │ │ │ + //to be overridden by geometries that actually have an area │ │ │ │ + // │ │ │ │ + return 0.0; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: draw │ │ │ │ + * APIMethod: getCentroid │ │ │ │ + * Calculate the centroid of this geometry. This method is defined in subclasses. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ */ │ │ │ │ - draw: function() { │ │ │ │ - this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.zoomBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ - }); │ │ │ │ + getCentroid: function() { │ │ │ │ + return null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: zoomBox │ │ │ │ + * Method: toString │ │ │ │ + * Returns a text representation of the geometry. If the WKT format is │ │ │ │ + * included in a build, this will be the Well-Known Text │ │ │ │ + * representation. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * position - {<OpenLayers.Bounds>} or {<OpenLayers.Pixel>} │ │ │ │ + * Returns: │ │ │ │ + * {String} String representation of this geometry. │ │ │ │ */ │ │ │ │ - zoomBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var bounds, │ │ │ │ - targetCenterPx = position.getCenterPixel(); │ │ │ │ - if (!this.out) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, │ │ │ │ - maxXY.lon, maxXY.lat); │ │ │ │ - } else { │ │ │ │ - var pixWidth = position.right - position.left; │ │ │ │ - var pixHeight = position.bottom - position.top; │ │ │ │ - var zoomFactor = Math.min((this.map.size.h / pixHeight), │ │ │ │ - (this.map.size.w / pixWidth)); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ - var xmin = center.lon - (extent.getWidth() / 2) * zoomFactor; │ │ │ │ - var xmax = center.lon + (extent.getWidth() / 2) * zoomFactor; │ │ │ │ - var ymin = center.lat - (extent.getHeight() / 2) * zoomFactor; │ │ │ │ - var ymax = center.lat + (extent.getHeight() / 2) * zoomFactor; │ │ │ │ - bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax); │ │ │ │ + toString: function() { │ │ │ │ + var string; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ + string = OpenLayers.Format.WKT.prototype.write( │ │ │ │ + new OpenLayers.Feature.Vector(this) │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + string = Object.prototype.toString.call(this); │ │ │ │ + } │ │ │ │ + return string; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Geometry.fromWKT │ │ │ │ + * Generate a geometry given a Well-Known Text string. For this method to │ │ │ │ + * work, you must include the OpenLayers.Format.WKT in your build │ │ │ │ + * explicitly. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * wkt - {String} A string representing the geometry in Well-Known Text. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry of the appropriate class. │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.fromWKT = function(wkt) { │ │ │ │ + var geom; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ + var format = OpenLayers.Geometry.fromWKT.format; │ │ │ │ + if (!format) { │ │ │ │ + format = new OpenLayers.Format.WKT(); │ │ │ │ + OpenLayers.Geometry.fromWKT.format = format; │ │ │ │ + } │ │ │ │ + var result = format.read(wkt); │ │ │ │ + if (result instanceof OpenLayers.Feature.Vector) { │ │ │ │ + geom = result.geometry; │ │ │ │ + } else if (OpenLayers.Util.isArray(result)) { │ │ │ │ + var len = result.length; │ │ │ │ + var components = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + components[i] = result[i].geometry; │ │ │ │ } │ │ │ │ - // always zoom in/out │ │ │ │ - var lastZoom = this.map.getZoom(), │ │ │ │ - size = this.map.getSize(), │ │ │ │ - centerPx = { │ │ │ │ - x: size.w / 2, │ │ │ │ - y: size.h / 2 │ │ │ │ - }, │ │ │ │ - zoom = this.map.getZoomForExtent(bounds), │ │ │ │ - oldRes = this.map.getResolution(), │ │ │ │ - newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ - if (oldRes == newRes) { │ │ │ │ - this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)); │ │ │ │ + geom = new OpenLayers.Geometry.Collection(components); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return geom; │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Method: OpenLayers.Geometry.segmentsIntersect │ │ │ │ + * Determine whether two line segments intersect. Optionally calculates │ │ │ │ + * and returns the intersection point. This function is optimized for │ │ │ │ + * cases where seg1.x2 >= seg2.x1 || seg2.x2 >= seg1.x1. In those │ │ │ │ + * obvious cases where there is no intersection, the function should │ │ │ │ + * not be called. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * seg1 - {Object} Object representing a segment with properties x1, y1, x2, │ │ │ │ + * and y2. The start point is represented by x1 and y1. The end point │ │ │ │ + * is represented by x2 and y2. Start and end are ordered so that x1 < x2. │ │ │ │ + * seg2 - {Object} Object representing a segment with properties x1, y1, x2, │ │ │ │ + * and y2. The start point is represented by x1 and y1. The end point │ │ │ │ + * is represented by x2 and y2. Start and end are ordered so that x1 < x2. │ │ │ │ + * options - {Object} Optional properties for calculating the intersection. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * point - {Boolean} Return the intersection point. If false, the actual │ │ │ │ + * intersection point will not be calculated. If true and the segments │ │ │ │ + * intersect, the intersection point will be returned. If true and │ │ │ │ + * the segments do not intersect, false will be returned. If true and │ │ │ │ + * the segments are coincident, true will be returned. │ │ │ │ + * tolerance - {Number} If a non-null value is provided, if the segments are │ │ │ │ + * within the tolerance distance, this will be considered an intersection. │ │ │ │ + * In addition, if the point option is true and the calculated intersection │ │ │ │ + * is within the tolerance distance of an end point, the endpoint will be │ │ │ │ + * returned instead of the calculated intersection. Further, if the │ │ │ │ + * intersection is within the tolerance of endpoints on both segments, or │ │ │ │ + * if two segment endpoints are within the tolerance distance of eachother │ │ │ │ + * (but no intersection is otherwise calculated), an endpoint on the │ │ │ │ + * first segment provided will be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean | <OpenLayers.Geometry.Point>} The two segments intersect. │ │ │ │ + * If the point argument is true, the return will be the intersection │ │ │ │ + * point or false if none exists. If point is true and the segments │ │ │ │ + * are coincident, return will be true (and the instersection is equal │ │ │ │ + * to the shorter segment). │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.segmentsIntersect = function(seg1, seg2, options) { │ │ │ │ + var point = options && options.point; │ │ │ │ + var tolerance = options && options.tolerance; │ │ │ │ + var intersection = false; │ │ │ │ + var x11_21 = seg1.x1 - seg2.x1; │ │ │ │ + var y11_21 = seg1.y1 - seg2.y1; │ │ │ │ + var x12_11 = seg1.x2 - seg1.x1; │ │ │ │ + var y12_11 = seg1.y2 - seg1.y1; │ │ │ │ + var y22_21 = seg2.y2 - seg2.y1; │ │ │ │ + var x22_21 = seg2.x2 - seg2.x1; │ │ │ │ + var d = (y22_21 * x12_11) - (x22_21 * y12_11); │ │ │ │ + var n1 = (x22_21 * y11_21) - (y22_21 * x11_21); │ │ │ │ + var n2 = (x12_11 * y11_21) - (y12_11 * x11_21); │ │ │ │ + if (d == 0) { │ │ │ │ + // parallel │ │ │ │ + if (n1 == 0 && n2 == 0) { │ │ │ │ + // coincident │ │ │ │ + intersection = true; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + var along1 = n1 / d; │ │ │ │ + var along2 = n2 / d; │ │ │ │ + if (along1 >= 0 && along1 <= 1 && along2 >= 0 && along2 <= 1) { │ │ │ │ + // intersect │ │ │ │ + if (!point) { │ │ │ │ + intersection = true; │ │ │ │ } else { │ │ │ │ - var zoomOriginPx = { │ │ │ │ - x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / │ │ │ │ - (oldRes - newRes), │ │ │ │ - y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / │ │ │ │ - (oldRes - newRes) │ │ │ │ - }; │ │ │ │ - this.map.zoomTo(zoom, zoomOriginPx); │ │ │ │ + // calculate the intersection point │ │ │ │ + var x = seg1.x1 + (along1 * x12_11); │ │ │ │ + var y = seg1.y1 + (along1 * y12_11); │ │ │ │ + intersection = new OpenLayers.Geometry.Point(x, y); │ │ │ │ } │ │ │ │ - if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ - this.map.zoomTo(lastZoom + (this.out ? -1 : 1)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (tolerance) { │ │ │ │ + var dist; │ │ │ │ + if (intersection) { │ │ │ │ + if (point) { │ │ │ │ + var segs = [seg1, seg2]; │ │ │ │ + var seg, x, y; │ │ │ │ + // check segment endpoints for proximity to intersection │ │ │ │ + // set intersection to first endpoint within the tolerance │ │ │ │ + outer: for (var i = 0; i < 2; ++i) { │ │ │ │ + seg = segs[i]; │ │ │ │ + for (var j = 1; j < 3; ++j) { │ │ │ │ + x = seg["x" + j]; │ │ │ │ + y = seg["y" + j]; │ │ │ │ + dist = Math.sqrt( │ │ │ │ + Math.pow(x - intersection.x, 2) + │ │ │ │ + Math.pow(y - intersection.y, 2) │ │ │ │ + ); │ │ │ │ + if (dist < tolerance) { │ │ │ │ + intersection.x = x; │ │ │ │ + intersection.y = y; │ │ │ │ + break outer; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ } │ │ │ │ - } else if (this.zoomOnClick) { // it's a pixel │ │ │ │ - if (!this.out) { │ │ │ │ - this.map.zoomTo(this.map.getZoom() + 1, position); │ │ │ │ - } else { │ │ │ │ - this.map.zoomTo(this.map.getZoom() - 1, position); │ │ │ │ + } else { │ │ │ │ + // no calculated intersection, but segments could be within │ │ │ │ + // the tolerance of one another │ │ │ │ + var segs = [seg1, seg2]; │ │ │ │ + var source, target, x, y, p, result; │ │ │ │ + // check segment endpoints for proximity to intersection │ │ │ │ + // set intersection to first endpoint within the tolerance │ │ │ │ + outer: for (var i = 0; i < 2; ++i) { │ │ │ │ + source = segs[i]; │ │ │ │ + target = segs[(i + 1) % 2]; │ │ │ │ + for (var j = 1; j < 3; ++j) { │ │ │ │ + p = { │ │ │ │ + x: source["x" + j], │ │ │ │ + y: source["y" + j] │ │ │ │ + }; │ │ │ │ + result = OpenLayers.Geometry.distanceToSegment(p, target); │ │ │ │ + if (result.distance < tolerance) { │ │ │ │ + if (point) { │ │ │ │ + intersection = new OpenLayers.Geometry.Point(p.x, p.y); │ │ │ │ + } else { │ │ │ │ + intersection = true; │ │ │ │ + } │ │ │ │ + break outer; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ + } │ │ │ │ + return intersection; │ │ │ │ +}; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ -}); │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Geometry.distanceToSegment │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {Object} An object with x and y properties representing the │ │ │ │ + * point coordinates. │ │ │ │ + * segment - {Object} An object with x1, y1, x2, and y2 properties │ │ │ │ + * representing endpoint coordinates. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with distance, along, x, and y properties. The distance │ │ │ │ + * will be the shortest distance between the input point and segment. │ │ │ │ + * The x and y properties represent the coordinates along the segment │ │ │ │ + * where the shortest distance meets the segment. The along attribute │ │ │ │ + * describes how far between the two segment points the given point is. │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.distanceToSegment = function(point, segment) { │ │ │ │ + var result = OpenLayers.Geometry.distanceSquaredToSegment(point, segment); │ │ │ │ + result.distance = Math.sqrt(result.distance); │ │ │ │ + return result; │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Geometry.distanceSquaredToSegment │ │ │ │ + * │ │ │ │ + * Usually the distanceToSegment function should be used. This variant however │ │ │ │ + * can be used for comparisons where the exact distance is not important. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {Object} An object with x and y properties representing the │ │ │ │ + * point coordinates. │ │ │ │ + * segment - {Object} An object with x1, y1, x2, and y2 properties │ │ │ │ + * representing endpoint coordinates. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with squared distance, along, x, and y properties. │ │ │ │ + * The distance will be the shortest distance between the input point and │ │ │ │ + * segment. The x and y properties represent the coordinates along the │ │ │ │ + * segment where the shortest distance meets the segment. The along │ │ │ │ + * attribute describes how far between the two segment points the given │ │ │ │ + * point is. │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.distanceSquaredToSegment = function(point, segment) { │ │ │ │ + var x0 = point.x; │ │ │ │ + var y0 = point.y; │ │ │ │ + var x1 = segment.x1; │ │ │ │ + var y1 = segment.y1; │ │ │ │ + var x2 = segment.x2; │ │ │ │ + var y2 = segment.y2; │ │ │ │ + var dx = x2 - x1; │ │ │ │ + var dy = y2 - y1; │ │ │ │ + var along = ((dx * (x0 - x1)) + (dy * (y0 - y1))) / │ │ │ │ + (Math.pow(dx, 2) + Math.pow(dy, 2)); │ │ │ │ + var x, y; │ │ │ │ + if (along <= 0.0) { │ │ │ │ + x = x1; │ │ │ │ + y = y1; │ │ │ │ + } else if (along >= 1.0) { │ │ │ │ + x = x2; │ │ │ │ + y = y2; │ │ │ │ + } else { │ │ │ │ + x = x1 + along * dx; │ │ │ │ + y = y1 + along * dy; │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + distance: Math.pow(x - x0, 2) + Math.pow(y - y0, 2), │ │ │ │ + x: x, │ │ │ │ + y: y, │ │ │ │ + along: along │ │ │ │ + }; │ │ │ │ +}; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/DragPan.js │ │ │ │ + OpenLayers/Geometry/Point.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Handler/Drag.js │ │ │ │ + * @requires OpenLayers/Geometry.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.DragPan │ │ │ │ - * The DragPan control pans the map with a drag of the mouse. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Geometry.Point │ │ │ │ + * Point geometry class. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Geometry> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Geometry.Point = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: type │ │ │ │ - * {OpenLayers.Control.TYPES} │ │ │ │ - */ │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: panned │ │ │ │ - * {Boolean} The map moved. │ │ │ │ - */ │ │ │ │ - panned: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: interval │ │ │ │ - * {Integer} The number of milliseconds that should ellapse before │ │ │ │ - * panning the map again. Defaults to 0 milliseconds, which means that │ │ │ │ - * no separate cycle is used for panning. In most cases you won't want │ │ │ │ - * to change this value. For slow machines/devices larger values can be │ │ │ │ - * tried out. │ │ │ │ + * APIProperty: x │ │ │ │ + * {float} │ │ │ │ */ │ │ │ │ - interval: 0, │ │ │ │ + x: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} If set to true, mouse dragging will continue even if the │ │ │ │ - * mouse cursor leaves the map viewport. Default is false. │ │ │ │ + /** │ │ │ │ + * APIProperty: y │ │ │ │ + * {float} │ │ │ │ */ │ │ │ │ - documentDrag: false, │ │ │ │ + y: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: kinetic │ │ │ │ - * {<OpenLayers.Kinetic>} The OpenLayers.Kinetic object. │ │ │ │ + * Constructor: OpenLayers.Geometry.Point │ │ │ │ + * Construct a point geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {float} │ │ │ │ + * y - {float} │ │ │ │ + * │ │ │ │ */ │ │ │ │ - kinetic: null, │ │ │ │ + initialize: function(x, y) { │ │ │ │ + OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: enableKinetic │ │ │ │ - * {Boolean} Set this option to enable "kinetic dragging". Can be │ │ │ │ - * set to true or to an object. If set to an object this │ │ │ │ - * object will be passed to the {<OpenLayers.Kinetic>} │ │ │ │ - * constructor. Defaults to true. │ │ │ │ - * To get kinetic dragging, ensure that OpenLayers/Kinetic.js is │ │ │ │ - * included in your build config. │ │ │ │ - */ │ │ │ │ - enableKinetic: true, │ │ │ │ + this.x = parseFloat(x); │ │ │ │ + this.y = parseFloat(y); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: kineticInterval │ │ │ │ - * {Integer} Interval in milliseconds between 2 steps in the "kinetic │ │ │ │ - * scrolling". Applies only if enableKinetic is set. Defaults │ │ │ │ - * to 10 milliseconds. │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Point>} An exact clone of this OpenLayers.Geometry.Point │ │ │ │ */ │ │ │ │ - kineticInterval: 10, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Geometry.Point(this.x, this.y); │ │ │ │ + } │ │ │ │ │ │ │ │ + // catch any randomly tagged-on properties │ │ │ │ + OpenLayers.Util.applyDefaults(obj, this); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * Creates a Drag handler, using <panMap> and │ │ │ │ - * <panMapDone> as callbacks. │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ - var config = { │ │ │ │ - interval: this.kineticInterval │ │ │ │ - }; │ │ │ │ - if (typeof this.enableKinetic === "object") { │ │ │ │ - config = OpenLayers.Util.extend(config, this.enableKinetic); │ │ │ │ - } │ │ │ │ - this.kinetic = new OpenLayers.Kinetic(config); │ │ │ │ - } │ │ │ │ - this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ - "move": this.panMap, │ │ │ │ - "done": this.panMapDone, │ │ │ │ - "down": this.panMapStart │ │ │ │ - }, { │ │ │ │ - interval: this.interval, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }); │ │ │ │ + return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: panMapStart │ │ │ │ + /** │ │ │ │ + * Method: calculateBounds │ │ │ │ + * Create a new Bounds based on the lon/lat │ │ │ │ */ │ │ │ │ - panMapStart: function() { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.begin(); │ │ │ │ - } │ │ │ │ + calculateBounds: function() { │ │ │ │ + this.bounds = new OpenLayers.Bounds(this.x, this.y, │ │ │ │ + this.x, this.y); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: panMap │ │ │ │ + * APIMethod: distanceTo │ │ │ │ + * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ - */ │ │ │ │ - panMap: function(xy) { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.update(xy); │ │ │ │ - } │ │ │ │ - this.panned = true; │ │ │ │ - this.map.pan( │ │ │ │ - this.handler.last.x - xy.x, │ │ │ │ - this.handler.last.y - xy.y, { │ │ │ │ - dragging: true, │ │ │ │ - animate: false │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: panMapDone │ │ │ │ - * Finish the panning operation. Only call setCenter (through <panMap>) │ │ │ │ - * if the map has actually been moved. │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Optional properties for configuring the distance │ │ │ │ + * calculation. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ + * Valid options: │ │ │ │ + * details - {Boolean} Return details from the distance calculation. │ │ │ │ + * Default is false. │ │ │ │ + * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ + * nearest edge of the target geometry. Default is true. If true, │ │ │ │ + * calling distanceTo from a geometry that is wholly contained within │ │ │ │ + * the target will result in a non-zero distance. If false, whenever │ │ │ │ + * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ + * details cannot be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number | Object} The distance between this geometry and the target. │ │ │ │ + * If details is true, the return will be an object with distance, │ │ │ │ + * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ + * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ + * properties represent the coordinates of the closest point on the │ │ │ │ + * target geometry. │ │ │ │ */ │ │ │ │ - panMapDone: function(xy) { │ │ │ │ - if (this.panned) { │ │ │ │ - var res = null; │ │ │ │ - if (this.kinetic) { │ │ │ │ - res = this.kinetic.end(xy); │ │ │ │ - } │ │ │ │ - this.map.pan( │ │ │ │ - this.handler.last.x - xy.x, │ │ │ │ - this.handler.last.y - xy.y, { │ │ │ │ - dragging: !!res, │ │ │ │ - animate: false │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - if (res) { │ │ │ │ - var self = this; │ │ │ │ - this.kinetic.move(res, function(x, y, end) { │ │ │ │ - self.map.pan(x, y, { │ │ │ │ - dragging: !end, │ │ │ │ - animate: false │ │ │ │ - }); │ │ │ │ - }); │ │ │ │ + distanceTo: function(geometry, options) { │ │ │ │ + var edge = !(options && options.edge === false); │ │ │ │ + var details = edge && options && options.details; │ │ │ │ + var distance, x0, y0, x1, y1, result; │ │ │ │ + if (geometry instanceof OpenLayers.Geometry.Point) { │ │ │ │ + x0 = this.x; │ │ │ │ + y0 = this.y; │ │ │ │ + x1 = geometry.x; │ │ │ │ + y1 = geometry.y; │ │ │ │ + distance = Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2)); │ │ │ │ + result = !details ? │ │ │ │ + distance : { │ │ │ │ + x0: x0, │ │ │ │ + y0: y0, │ │ │ │ + x1: x1, │ │ │ │ + y1: y1, │ │ │ │ + distance: distance │ │ │ │ + }; │ │ │ │ + } else { │ │ │ │ + result = geometry.distanceTo(this, options); │ │ │ │ + if (details) { │ │ │ │ + // switch coord order since this geom is target │ │ │ │ + result = { │ │ │ │ + x0: result.x1, │ │ │ │ + y0: result.y1, │ │ │ │ + x1: result.x0, │ │ │ │ + y1: result.y0, │ │ │ │ + distance: result.distance │ │ │ │ + }; │ │ │ │ } │ │ │ │ - this.panned = false; │ │ │ │ } │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Handler/MouseWheel.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Handler.MouseWheel │ │ │ │ - * Handler for wheel up/down events. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ - */ │ │ │ │ -OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ /** │ │ │ │ - * Property: wheelListener │ │ │ │ - * {function} │ │ │ │ - */ │ │ │ │ - wheelListener: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: interval │ │ │ │ - * {Integer} In order to increase server performance, an interval (in │ │ │ │ - * milliseconds) can be set to reduce the number of up/down events │ │ │ │ - * called. If set, a new up/down event will not be set until the │ │ │ │ - * interval has passed. │ │ │ │ - * Defaults to 0, meaning no interval. │ │ │ │ - */ │ │ │ │ - interval: 0, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: maxDelta │ │ │ │ - * {Integer} Maximum delta to collect before breaking from the current │ │ │ │ - * interval. In cumulative mode, this also limits the maximum delta │ │ │ │ - * returned from the handler. Default is Number.POSITIVE_INFINITY. │ │ │ │ + * APIMethod: equals │ │ │ │ + * Determine whether another geometry is equivalent to this one. Geometries │ │ │ │ + * are considered equivalent if all components have the same coordinates. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geom - {<OpenLayers.Geometry.Point>} The geometry to test. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The supplied geometry is equivalent to this geometry. │ │ │ │ */ │ │ │ │ - maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ + equals: function(geom) { │ │ │ │ + var equals = false; │ │ │ │ + if (geom != null) { │ │ │ │ + equals = ((this.x == geom.x && this.y == geom.y) || │ │ │ │ + (isNaN(this.x) && isNaN(this.y) && isNaN(geom.x) && isNaN(geom.y))); │ │ │ │ + } │ │ │ │ + return equals; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: delta │ │ │ │ - * {Integer} When interval is set, delta collects the mousewheel z-deltas │ │ │ │ - * of the events that occur within the interval. │ │ │ │ - * See also the cumulative option │ │ │ │ + * Method: toShortString │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} Shortened String representation of Point object. │ │ │ │ + * (ex. <i>"5, 42"</i>) │ │ │ │ */ │ │ │ │ - delta: 0, │ │ │ │ + toShortString: function() { │ │ │ │ + return (this.x + ", " + this.y); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: cumulative │ │ │ │ - * {Boolean} When interval is set: true to collect all the mousewheel │ │ │ │ - * z-deltas, false to only record the delta direction (positive or │ │ │ │ - * negative) │ │ │ │ + * APIMethod: move │ │ │ │ + * Moves a geometry by the given displacement along positive x and y axes. │ │ │ │ + * This modifies the position of the geometry and clears the cached │ │ │ │ + * bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Float} Distance to move geometry in positive x direction. │ │ │ │ + * y - {Float} Distance to move geometry in positive y direction. │ │ │ │ */ │ │ │ │ - cumulative: true, │ │ │ │ + move: function(x, y) { │ │ │ │ + this.x = this.x + x; │ │ │ │ + this.y = this.y + y; │ │ │ │ + this.clearBounds(); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.MouseWheel │ │ │ │ + * APIMethod: rotate │ │ │ │ + * Rotate a point around another. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - * callbacks - {Object} An object containing a single function to be │ │ │ │ - * called when the drag operation is finished. │ │ │ │ - * The callback should expect to recieve a single │ │ │ │ - * argument, the point geometry. │ │ │ │ - * options - {Object} │ │ │ │ + * angle - {Float} Rotation angle in degrees (measured counterclockwise │ │ │ │ + * from the positive x-axis) │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} Center point for the rotation │ │ │ │ */ │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.wheelListener = OpenLayers.Function.bindAsEventListener( │ │ │ │ - this.onWheelEvent, this │ │ │ │ - ); │ │ │ │ + rotate: function(angle, origin) { │ │ │ │ + angle *= Math.PI / 180; │ │ │ │ + var radius = this.distanceTo(origin); │ │ │ │ + var theta = angle + Math.atan2(this.y - origin.y, this.x - origin.x); │ │ │ │ + this.x = origin.x + (radius * Math.cos(theta)); │ │ │ │ + this.y = origin.y + (radius * Math.sin(theta)); │ │ │ │ + this.clearBounds(); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * APIMethod: getCentroid │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ - this.wheelListener = null; │ │ │ │ + getCentroid: function() { │ │ │ │ + return new OpenLayers.Geometry.Point(this.x, this.y); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Mouse ScrollWheel code thanks to http://adomas.org/javascript-mouse-wheel/ │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: onWheelEvent │ │ │ │ - * Catch the wheel event and handle it xbrowserly │ │ │ │ - * │ │ │ │ + * APIMethod: resize │ │ │ │ + * Resize a point relative to some origin. For points, this has the effect │ │ │ │ + * of scaling a vector (from the origin to the point). This method is │ │ │ │ + * more useful on geometry collection subclasses. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ + * scale - {Float} Ratio of the new distance from the origin to the old │ │ │ │ + * distance from the origin. A scale of 2 doubles the │ │ │ │ + * distance between the point and origin. │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing │ │ │ │ + * ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} - The current geometry. │ │ │ │ */ │ │ │ │ - onWheelEvent: function(e) { │ │ │ │ - │ │ │ │ - // make sure we have a map and check keyboard modifiers │ │ │ │ - if (!this.map || !this.checkModifiers(e)) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // Ride up the element's DOM hierarchy to determine if it or any of │ │ │ │ - // its ancestors was: │ │ │ │ - // * specifically marked as scrollable (CSS overflow property) │ │ │ │ - // * one of our layer divs or a div marked as scrollable │ │ │ │ - // ('olScrollable' CSS class) │ │ │ │ - // * the map div │ │ │ │ - // │ │ │ │ - var overScrollableDiv = false; │ │ │ │ - var allowScroll = false; │ │ │ │ - var overMapDiv = false; │ │ │ │ - │ │ │ │ - var elem = OpenLayers.Event.element(e); │ │ │ │ - while ((elem != null) && !overMapDiv && !overScrollableDiv) { │ │ │ │ - │ │ │ │ - if (!overScrollableDiv) { │ │ │ │ - try { │ │ │ │ - var overflow; │ │ │ │ - if (elem.currentStyle) { │ │ │ │ - overflow = elem.currentStyle["overflow"]; │ │ │ │ - } else { │ │ │ │ - var style = │ │ │ │ - document.defaultView.getComputedStyle(elem, null); │ │ │ │ - overflow = style.getPropertyValue("overflow"); │ │ │ │ - } │ │ │ │ - overScrollableDiv = (overflow && │ │ │ │ - (overflow == "auto") || (overflow == "scroll")); │ │ │ │ - } catch (err) { │ │ │ │ - //sometimes when scrolling in a popup, this causes │ │ │ │ - // obscure browser error │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (!allowScroll) { │ │ │ │ - allowScroll = OpenLayers.Element.hasClass(elem, 'olScrollable'); │ │ │ │ - if (!allowScroll) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - // Are we in the layer div? Note that we have two cases │ │ │ │ - // here: one is to catch EventPane layers, which have a │ │ │ │ - // pane above the layer (layer.pane) │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (elem == layer.div || elem == layer.pane) { │ │ │ │ - allowScroll = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - overMapDiv = (elem == this.map.div); │ │ │ │ - │ │ │ │ - elem = elem.parentNode; │ │ │ │ - } │ │ │ │ - │ │ │ │ - // Logic below is the following: │ │ │ │ - // │ │ │ │ - // If we are over a scrollable div or not over the map div: │ │ │ │ - // * do nothing (let the browser handle scrolling) │ │ │ │ - // │ │ │ │ - // otherwise │ │ │ │ - // │ │ │ │ - // If we are over the layer div or a 'olScrollable' div: │ │ │ │ - // * zoom/in out │ │ │ │ - // then │ │ │ │ - // * kill event (so as not to also scroll the page after zooming) │ │ │ │ - // │ │ │ │ - // otherwise │ │ │ │ - // │ │ │ │ - // Kill the event (dont scroll the page if we wheel over the │ │ │ │ - // layerswitcher or the pan/zoom control) │ │ │ │ - // │ │ │ │ - if (!overScrollableDiv && overMapDiv) { │ │ │ │ - if (allowScroll) { │ │ │ │ - var delta = 0; │ │ │ │ - │ │ │ │ - if (e.wheelDelta) { │ │ │ │ - delta = e.wheelDelta; │ │ │ │ - if (delta % 160 === 0) { │ │ │ │ - // opera have steps of 160 instead of 120 │ │ │ │ - delta = delta * 0.75; │ │ │ │ - } │ │ │ │ - delta = delta / 120; │ │ │ │ - } else if (e.detail) { │ │ │ │ - // detail in Firefox on OS X is 1/3 of Windows │ │ │ │ - // so force delta 1 / -1 │ │ │ │ - delta = -(e.detail / Math.abs(e.detail)); │ │ │ │ - } │ │ │ │ - this.delta += delta; │ │ │ │ - │ │ │ │ - window.clearTimeout(this._timeoutId); │ │ │ │ - if (this.interval && Math.abs(this.delta) < this.maxDelta) { │ │ │ │ - // store e because window.event might change during delay │ │ │ │ - var evt = OpenLayers.Util.extend({}, e); │ │ │ │ - this._timeoutId = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(function() { │ │ │ │ - this.wheelZoom(evt); │ │ │ │ - }, this), │ │ │ │ - this.interval │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.wheelZoom(e); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ - } │ │ │ │ + resize: function(scale, origin, ratio) { │ │ │ │ + ratio = (ratio == undefined) ? 1 : ratio; │ │ │ │ + this.x = origin.x + (scale * ratio * (this.x - origin.x)); │ │ │ │ + this.y = origin.y + (scale * (this.y - origin.y)); │ │ │ │ + this.clearBounds(); │ │ │ │ + return this; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: wheelZoom │ │ │ │ - * Given the wheel event, we carry out the appropriate zooming in or out, │ │ │ │ - * based on the 'wheelDelta' or 'detail' property of the event. │ │ │ │ - * │ │ │ │ + * APIMethod: intersects │ │ │ │ + * Determine if the input geometry intersects this one. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * e - {Event} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The input geometry intersects this one. │ │ │ │ */ │ │ │ │ - wheelZoom: function(e) { │ │ │ │ - var delta = this.delta; │ │ │ │ - this.delta = 0; │ │ │ │ - │ │ │ │ - if (delta) { │ │ │ │ - e.xy = this.map.events.getMousePosition(e); │ │ │ │ - if (delta < 0) { │ │ │ │ - this.callback("down", │ │ │ │ - [e, this.cumulative ? Math.max(-this.maxDelta, delta) : -1]); │ │ │ │ - } else { │ │ │ │ - this.callback("up", │ │ │ │ - [e, this.cumulative ? Math.min(this.maxDelta, delta) : 1]); │ │ │ │ - } │ │ │ │ + intersects: function(geometry) { │ │ │ │ + var intersect = false; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + intersect = this.equals(geometry); │ │ │ │ + } else { │ │ │ │ + intersect = geometry.intersects(this); │ │ │ │ } │ │ │ │ + return intersect; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ + * APIMethod: transform │ │ │ │ + * Translate the x,y properties of the point from source to dest. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * source - {<OpenLayers.Projection>} │ │ │ │ + * dest - {<OpenLayers.Projection>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - activate: function(evt) { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - //register mousewheel events specifically on the window and document │ │ │ │ - var wheelListener = this.wheelListener; │ │ │ │ - OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener); │ │ │ │ - OpenLayers.Event.observe(window, "mousewheel", wheelListener); │ │ │ │ - OpenLayers.Event.observe(document, "mousewheel", wheelListener); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ + transform: function(source, dest) { │ │ │ │ + if ((source && dest)) { │ │ │ │ + OpenLayers.Projection.transform( │ │ │ │ + this, source, dest); │ │ │ │ + this.bounds = null; │ │ │ │ } │ │ │ │ + return this; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ + * APIMethod: getVertices │ │ │ │ + * Return a list of all points in this geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ + * endpoints. If false, for lines, only vertices that are not │ │ │ │ + * endpoints will be returned. If not provided, all vertices will │ │ │ │ + * be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} A list of all vertices in the geometry. │ │ │ │ */ │ │ │ │ - deactivate: function(evt) { │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - // unregister mousewheel events specifically on the window and document │ │ │ │ - var wheelListener = this.wheelListener; │ │ │ │ - OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener); │ │ │ │ - OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ + getVertices: function(nodes) { │ │ │ │ + return [this]; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.Point" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Click.js │ │ │ │ + OpenLayers/Geometry/Collection.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Geometry.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Click │ │ │ │ - * A handler for mouse clicks. The intention of this handler is to give │ │ │ │ - * controls more flexibility with handling clicks. Browsers trigger │ │ │ │ - * click events twice for a double-click. In addition, the mousedown, │ │ │ │ - * mousemove, mouseup sequence fires a click event. With this handler, │ │ │ │ - * controls can decide whether to ignore clicks associated with a double │ │ │ │ - * click. By setting a <pixelTolerance>, controls can also ignore clicks │ │ │ │ - * that include a drag. Create a new instance with the │ │ │ │ - * <OpenLayers.Handler.Click> constructor. │ │ │ │ + * Class: OpenLayers.Geometry.Collection │ │ │ │ + * A Collection is exactly what it sounds like: A collection of different │ │ │ │ + * Geometries. These are stored in the local parameter <components> (which │ │ │ │ + * can be passed as a parameter to the constructor). │ │ │ │ + * │ │ │ │ + * As new geometries are added to the collection, they are NOT cloned. │ │ │ │ + * When removing geometries, they need to be specified by reference (ie you │ │ │ │ + * have to pass in the *exact* geometry to be removed). │ │ │ │ * │ │ │ │ + * The <getArea> and <getLength> functions here merely iterate through │ │ │ │ + * the components, summing their respective areas and lengths. │ │ │ │ + * │ │ │ │ + * Create a new instance with the <OpenLayers.Geometry.Collection> constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Geometry> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - /** │ │ │ │ - * APIProperty: delay │ │ │ │ - * {Number} Number of milliseconds between clicks before the event is │ │ │ │ - * considered a double-click. │ │ │ │ - */ │ │ │ │ - delay: 300, │ │ │ │ +OpenLayers.Geometry.Collection = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: single │ │ │ │ - * {Boolean} Handle single clicks. Default is true. If false, clicks │ │ │ │ - * will not be reported. If true, single-clicks will be reported. │ │ │ │ + * APIProperty: components │ │ │ │ + * {Array(<OpenLayers.Geometry>)} The component parts of this geometry │ │ │ │ */ │ │ │ │ - single: true, │ │ │ │ + components: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: double │ │ │ │ - * {Boolean} Handle double-clicks. Default is false. │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null value means the │ │ │ │ + * component types are not restricted. │ │ │ │ */ │ │ │ │ - 'double': false, │ │ │ │ + componentTypes: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: pixelTolerance │ │ │ │ - * {Number} Maximum number of pixels between mouseup and mousedown for an │ │ │ │ - * event to be considered a click. Default is 0. If set to an │ │ │ │ - * integer value, clicks with a drag greater than the value will be │ │ │ │ - * ignored. This property can only be set when the handler is │ │ │ │ - * constructed. │ │ │ │ + * Constructor: OpenLayers.Geometry.Collection │ │ │ │ + * Creates a Geometry Collection -- a list of geoms. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry>)} Optional array of geometries │ │ │ │ + * │ │ │ │ */ │ │ │ │ - pixelTolerance: 0, │ │ │ │ + initialize: function(components) { │ │ │ │ + OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ + this.components = []; │ │ │ │ + if (components != null) { │ │ │ │ + this.addComponents(components); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: dblclickTolerance │ │ │ │ - * {Number} Maximum distance in pixels between clicks for a sequence of │ │ │ │ - * events to be considered a double click. Default is 13. If the │ │ │ │ - * distance between two clicks is greater than this value, a double- │ │ │ │ - * click will not be fired. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Destroy this geometry. │ │ │ │ */ │ │ │ │ - dblclickTolerance: 13, │ │ │ │ + destroy: function() { │ │ │ │ + this.components.length = 0; │ │ │ │ + this.components = null; │ │ │ │ + OpenLayers.Geometry.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: stopSingle │ │ │ │ - * {Boolean} Stop other listeners from being notified of clicks. Default │ │ │ │ - * is false. If true, any listeners registered before this one for │ │ │ │ - * click or rightclick events will not be notified. │ │ │ │ + * APIMethod: clone │ │ │ │ + * Clone this geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Collection>} An exact clone of this collection │ │ │ │ */ │ │ │ │ - stopSingle: false, │ │ │ │ + clone: function() { │ │ │ │ + var geometry = eval("new " + this.CLASS_NAME + "()"); │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + geometry.addComponent(this.components[i].clone()); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: stopDouble │ │ │ │ - * {Boolean} Stop other listeners from being notified of double-clicks. │ │ │ │ - * Default is false. If true, any click listeners registered before │ │ │ │ - * this one will not be notified of *any* double-click events. │ │ │ │ - * │ │ │ │ - * The one caveat with stopDouble is that given a map with two click │ │ │ │ - * handlers, one with stopDouble true and the other with stopSingle │ │ │ │ - * true, the stopSingle handler should be activated last to get │ │ │ │ - * uniform cross-browser performance. Since IE triggers one click │ │ │ │ - * with a dblclick and FF triggers two, if a stopSingle handler is │ │ │ │ - * activated first, all it gets in IE is a single click when the │ │ │ │ - * second handler stops propagation on the dblclick. │ │ │ │ - */ │ │ │ │ - stopDouble: false, │ │ │ │ + // catch any randomly tagged-on properties │ │ │ │ + OpenLayers.Util.applyDefaults(geometry, this); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: timerId │ │ │ │ - * {Number} The id of the timeout waiting to clear the <delayedCall>. │ │ │ │ - */ │ │ │ │ - timerId: null, │ │ │ │ + return geometry; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: down │ │ │ │ - * {Object} Object that store relevant information about the last │ │ │ │ - * mousedown or touchstart. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ - * the average location of the mouse/touch event. Its 'touches' │ │ │ │ - * property records clientX/clientY of each touches. │ │ │ │ + * Method: getComponentsString │ │ │ │ + * Get a string representing the components for this collection │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} A string representation of the components of this geometry │ │ │ │ */ │ │ │ │ - down: null, │ │ │ │ + getComponentsString: function() { │ │ │ │ + var strings = []; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + strings.push(this.components[i].toShortString()); │ │ │ │ + } │ │ │ │ + return strings.join(","); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: last │ │ │ │ - * {Object} Object that store relevant information about the last │ │ │ │ - * mousemove or touchmove. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ - * the average location of the mouse/touch event. Its 'touches' │ │ │ │ - * property records clientX/clientY of each touches. │ │ │ │ - */ │ │ │ │ - last: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: first │ │ │ │ - * {Object} When waiting for double clicks, this object will store │ │ │ │ - * information about the first click in a two click sequence. │ │ │ │ + * APIMethod: calculateBounds │ │ │ │ + * Recalculate the bounds by iterating through the components and │ │ │ │ + * calling calling extendBounds() on each item. │ │ │ │ */ │ │ │ │ - first: null, │ │ │ │ + calculateBounds: function() { │ │ │ │ + this.bounds = null; │ │ │ │ + var bounds = new OpenLayers.Bounds(); │ │ │ │ + var components = this.components; │ │ │ │ + if (components) { │ │ │ │ + for (var i = 0, len = components.length; i < len; i++) { │ │ │ │ + bounds.extend(components[i].getBounds()); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // to preserve old behavior, we only set bounds if non-null │ │ │ │ + // in the future, we could add bounds.isEmpty() │ │ │ │ + if (bounds.left != null && bounds.bottom != null && │ │ │ │ + bounds.right != null && bounds.top != null) { │ │ │ │ + this.setBounds(bounds); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: rightclickTimerId │ │ │ │ - * {Number} The id of the right mouse timeout waiting to clear the │ │ │ │ - * <delayedEvent>. │ │ │ │ + * APIMethod: addComponents │ │ │ │ + * Add components to this geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry>)} An array of geometries to add │ │ │ │ */ │ │ │ │ - rightclickTimerId: null, │ │ │ │ + addComponents: function(components) { │ │ │ │ + if (!(OpenLayers.Util.isArray(components))) { │ │ │ │ + components = [components]; │ │ │ │ + } │ │ │ │ + for (var i = 0, len = components.length; i < len; i++) { │ │ │ │ + this.addComponent(components[i]); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Click │ │ │ │ - * Create a new click handler. │ │ │ │ + * Method: addComponent │ │ │ │ + * Add a new component (geometry) to the collection. If this.componentTypes │ │ │ │ + * is set, then the component class name must be in the componentTypes array. │ │ │ │ + * │ │ │ │ + * The bounds cache is reset. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ - * this handler. If a handler is being used without a control, the │ │ │ │ - * handler's setMap method must be overridden to deal properly with │ │ │ │ - * the map. │ │ │ │ - * callbacks - {Object} An object with keys corresponding to callbacks │ │ │ │ - * that will be called by the handler. The callbacks should │ │ │ │ - * expect to recieve a single argument, the click event. │ │ │ │ - * Callbacks for 'click' and 'dblclick' are supported. │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * handler. │ │ │ │ + * component - {<OpenLayers.Geometry>} A geometry to add │ │ │ │ + * index - {int} Optional index into the array to insert the component │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The component geometry was successfully added │ │ │ │ */ │ │ │ │ + addComponent: function(component, index) { │ │ │ │ + var added = false; │ │ │ │ + if (component) { │ │ │ │ + if (this.componentTypes == null || │ │ │ │ + (OpenLayers.Util.indexOf(this.componentTypes, │ │ │ │ + component.CLASS_NAME) > -1)) { │ │ │ │ + │ │ │ │ + if (index != null && (index < this.components.length)) { │ │ │ │ + var components1 = this.components.slice(0, index); │ │ │ │ + var components2 = this.components.slice(index, │ │ │ │ + this.components.length); │ │ │ │ + components1.push(component); │ │ │ │ + this.components = components1.concat(components2); │ │ │ │ + } else { │ │ │ │ + this.components.push(component); │ │ │ │ + } │ │ │ │ + component.parent = this; │ │ │ │ + this.clearBounds(); │ │ │ │ + added = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return added; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart. │ │ │ │ + * APIMethod: removeComponents │ │ │ │ + * Remove components from this geometry. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry>)} The components to be removed │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} A component was removed. │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true; │ │ │ │ + removeComponents: function(components) { │ │ │ │ + var removed = false; │ │ │ │ + │ │ │ │ + if (!(OpenLayers.Util.isArray(components))) { │ │ │ │ + components = [components]; │ │ │ │ + } │ │ │ │ + for (var i = components.length - 1; i >= 0; --i) { │ │ │ │ + removed = this.removeComponent(components[i]) || removed; │ │ │ │ + } │ │ │ │ + return removed; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Store position of last move, because touchend event can have │ │ │ │ - * an empty "touches" property. │ │ │ │ + * Method: removeComponent │ │ │ │ + * Remove a component from this geometry. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * Parameters: │ │ │ │ + * component - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The component was removed. │ │ │ │ */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ + removeComponent: function(component) { │ │ │ │ + │ │ │ │ + OpenLayers.Util.removeItem(this.components, component); │ │ │ │ + │ │ │ │ + // clearBounds() so that it gets recalculated on the next call │ │ │ │ + // to this.getBounds(); │ │ │ │ + this.clearBounds(); │ │ │ │ return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchend │ │ │ │ - * Correctly set event xy property, and add lastTouches to have │ │ │ │ - * touches property from last touchstart or touchmove │ │ │ │ + * APIMethod: getLength │ │ │ │ + * Calculate the length of this geometry │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Float} The length of the geometry │ │ │ │ */ │ │ │ │ - touchend: function(evt) { │ │ │ │ - // touchstart may not have been allowed to propagate │ │ │ │ - if (this.down) { │ │ │ │ - evt.xy = this.last.xy; │ │ │ │ - evt.lastTouches = this.last.touches; │ │ │ │ - this.handleSingle(evt); │ │ │ │ - this.down = null; │ │ │ │ + getLength: function() { │ │ │ │ + var length = 0.0; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + length += this.components[i].getLength(); │ │ │ │ } │ │ │ │ - return true; │ │ │ │ + return length; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mousedown. │ │ │ │ + * APIMethod: getArea │ │ │ │ + * Calculate the area of this geometry. Note how this function is overridden │ │ │ │ + * in <OpenLayers.Geometry.Polygon>. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Float} The area of the collection by summing its parts │ │ │ │ */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true; │ │ │ │ + getArea: function() { │ │ │ │ + var area = 0.0; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + area += this.components[i].getArea(); │ │ │ │ + } │ │ │ │ + return area; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouseup. Installed to support collection of right mouse events. │ │ │ │ + /** │ │ │ │ + * APIMethod: getGeodesicArea │ │ │ │ + * Calculate the approximate area of the polygon were it projected onto │ │ │ │ + * the earth. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ + * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ + * assumed. │ │ │ │ * │ │ │ │ + * Reference: │ │ │ │ + * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for │ │ │ │ + * Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion │ │ │ │ + * Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {float} The approximate geodesic area of the geometry in square meters. │ │ │ │ */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - │ │ │ │ - // Collect right mouse clicks from the mouseup │ │ │ │ - // IE - ignores the second right click in mousedown so using │ │ │ │ - // mouseup instead │ │ │ │ - if (this.checkModifiers(evt) && this.control.handleRightClicks && │ │ │ │ - OpenLayers.Event.isRightClick(evt)) { │ │ │ │ - propagate = this.rightclick(evt); │ │ │ │ + getGeodesicArea: function(projection) { │ │ │ │ + var area = 0.0; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + area += this.components[i].getGeodesicArea(projection); │ │ │ │ } │ │ │ │ - │ │ │ │ - return propagate; │ │ │ │ + return area; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: rightclick │ │ │ │ - * Handle rightclick. For a dblrightclick, we get two clicks so we need │ │ │ │ - * to always register for dblrightclick to properly handle single │ │ │ │ - * clicks. │ │ │ │ - * │ │ │ │ + * APIMethod: getCentroid │ │ │ │ + * │ │ │ │ + * Compute the centroid for this geometry collection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * weighted - {Boolean} Perform the getCentroid computation recursively, │ │ │ │ + * returning an area weighted average of all geometries in this collection. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ */ │ │ │ │ - rightclick: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - //Second click received before timeout this must be │ │ │ │ - // a double click │ │ │ │ - this.clearTimer(); │ │ │ │ - this.callback('dblrightclick', [evt]); │ │ │ │ - return !this.stopDouble; │ │ │ │ - } else { │ │ │ │ - //Set the rightclickTimerId, send evt only if double is │ │ │ │ - // true else trigger single │ │ │ │ - var clickEvent = this['double'] ? │ │ │ │ - OpenLayers.Util.extend({}, evt) : │ │ │ │ - this.callback('rightclick', [evt]); │ │ │ │ + getCentroid: function(weighted) { │ │ │ │ + if (!weighted) { │ │ │ │ + return this.components.length && this.components[0].getCentroid(); │ │ │ │ + } │ │ │ │ + var len = this.components.length; │ │ │ │ + if (!len) { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ │ │ │ │ - var delayedRightCall = OpenLayers.Function.bind( │ │ │ │ - this.delayedRightCall, │ │ │ │ - this, │ │ │ │ - clickEvent │ │ │ │ - ); │ │ │ │ - this.rightclickTimerId = window.setTimeout( │ │ │ │ - delayedRightCall, this.delay │ │ │ │ - ); │ │ │ │ + var areas = []; │ │ │ │ + var centroids = []; │ │ │ │ + var areaSum = 0; │ │ │ │ + var minArea = Number.MAX_VALUE; │ │ │ │ + var component; │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + component = this.components[i]; │ │ │ │ + var area = component.getArea(); │ │ │ │ + var centroid = component.getCentroid(true); │ │ │ │ + if (isNaN(area) || isNaN(centroid.x) || isNaN(centroid.y)) { │ │ │ │ + continue; │ │ │ │ } │ │ │ │ + areas.push(area); │ │ │ │ + areaSum += area; │ │ │ │ + minArea = (area < minArea && area > 0) ? area : minArea; │ │ │ │ + centroids.push(centroid); │ │ │ │ + } │ │ │ │ + len = areas.length; │ │ │ │ + if (areaSum === 0) { │ │ │ │ + // all the components in this collection have 0 area │ │ │ │ + // probably a collection of points -- weight all the points the same │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + areas[i] = 1; │ │ │ │ + } │ │ │ │ + areaSum = areas.length; │ │ │ │ + } else { │ │ │ │ + // normalize all the areas where the smallest area will get │ │ │ │ + // a value of 1 │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + areas[i] /= minArea; │ │ │ │ + } │ │ │ │ + areaSum /= minArea; │ │ │ │ } │ │ │ │ - return !this.stopSingle; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: delayedRightCall │ │ │ │ - * Sets <rightclickTimerId> to null. And optionally triggers the │ │ │ │ - * rightclick callback if evt is set. │ │ │ │ - */ │ │ │ │ - delayedRightCall: function(evt) { │ │ │ │ - this.rightclickTimerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback('rightclick', [evt]); │ │ │ │ + var xSum = 0, │ │ │ │ + ySum = 0, │ │ │ │ + centroid, area; │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + centroid = centroids[i]; │ │ │ │ + area = areas[i]; │ │ │ │ + xSum += centroid.x * area; │ │ │ │ + ySum += centroid.y * area; │ │ │ │ } │ │ │ │ + │ │ │ │ + return new OpenLayers.Geometry.Point(xSum / areaSum, ySum / areaSum); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: click │ │ │ │ - * Handle click events from the browser. This is registered as a listener │ │ │ │ - * for click events and should not be called from other events in this │ │ │ │ - * handler. │ │ │ │ + * APIMethod: getGeodesicLength │ │ │ │ + * Calculate the approximate length of the geometry were it projected onto │ │ │ │ + * the earth. │ │ │ │ * │ │ │ │ + * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ + * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ + * assumed. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ + * {Float} The appoximate geodesic length of the geometry in meters. │ │ │ │ */ │ │ │ │ - click: function(evt) { │ │ │ │ - if (!this.last) { │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ + getGeodesicLength: function(projection) { │ │ │ │ + var length = 0.0; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + length += this.components[i].getGeodesicLength(projection); │ │ │ │ } │ │ │ │ - this.handleSingle(evt); │ │ │ │ - return !this.stopSingle; │ │ │ │ + return length; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dblclick │ │ │ │ - * Handle dblclick. For a dblclick, we get two clicks in some browsers │ │ │ │ - * (FF) and one in others (IE). So we need to always register for │ │ │ │ - * dblclick to properly handle single clicks. This method is registered │ │ │ │ - * as a listener for the dblclick browser event. It should *not* be │ │ │ │ - * called by other methods in this handler. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Continue propagating this event. │ │ │ │ - */ │ │ │ │ - dblclick: function(evt) { │ │ │ │ - this.handleDouble(evt); │ │ │ │ - return !this.stopDouble; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: handleDouble │ │ │ │ - * Handle double-click sequence. │ │ │ │ + * APIMethod: move │ │ │ │ + * Moves a geometry by the given displacement along positive x and y axes. │ │ │ │ + * This modifies the position of the geometry and clears the cached │ │ │ │ + * bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Float} Distance to move geometry in positive x direction. │ │ │ │ + * y - {Float} Distance to move geometry in positive y direction. │ │ │ │ */ │ │ │ │ - handleDouble: function(evt) { │ │ │ │ - if (this.passesDblclickTolerance(evt)) { │ │ │ │ - if (this["double"]) { │ │ │ │ - this.callback("dblclick", [evt]); │ │ │ │ - } │ │ │ │ - // to prevent a dblclick from firing the click callback in IE │ │ │ │ - this.clearTimer(); │ │ │ │ + move: function(x, y) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + this.components[i].move(x, y); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleSingle │ │ │ │ - * Handle single click sequence. │ │ │ │ + /** │ │ │ │ + * APIMethod: rotate │ │ │ │ + * Rotate a geometry around some origin │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * angle - {Float} Rotation angle in degrees (measured counterclockwise │ │ │ │ + * from the positive x-axis) │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} Center point for the rotation │ │ │ │ */ │ │ │ │ - handleSingle: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - // already received a click │ │ │ │ - if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ - // touch device, no dblclick event - this may be a double │ │ │ │ - if (this["double"]) { │ │ │ │ - // on Android don't let the browser zoom on the page │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - } │ │ │ │ - this.handleDouble(evt); │ │ │ │ - } │ │ │ │ - // if we're not in a touch environment we clear the click timer │ │ │ │ - // if we've got a second touch, we'll get two touchend events │ │ │ │ - if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ - this.clearTimer(); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // remember the first click info so we can compare to the second │ │ │ │ - this.first = this.getEventInfo(evt); │ │ │ │ - // set the timer, send evt only if single is true │ │ │ │ - //use a clone of the event object because it will no longer │ │ │ │ - //be a valid event object in IE in the timer callback │ │ │ │ - var clickEvent = this.single ? │ │ │ │ - OpenLayers.Util.extend({}, evt) : null; │ │ │ │ - this.queuePotentialClick(clickEvent); │ │ │ │ - } │ │ │ │ + rotate: function(angle, origin) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + this.components[i].rotate(angle, origin); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: queuePotentialClick │ │ │ │ - * This method is separated out largely to make testing easier (so we │ │ │ │ - * don't have to override window.setTimeout) │ │ │ │ + /** │ │ │ │ + * APIMethod: resize │ │ │ │ + * Resize a geometry relative to some origin. Use this method to apply │ │ │ │ + * a uniform scaling to a geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * scale - {Float} Factor by which to scale the geometry. A scale of 2 │ │ │ │ + * doubles the size of the geometry in each dimension │ │ │ │ + * (lines, for example, will be twice as long, and polygons │ │ │ │ + * will have four times the area). │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing │ │ │ │ + * ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} - The current geometry. │ │ │ │ */ │ │ │ │ - queuePotentialClick: function(evt) { │ │ │ │ - this.timerId = window.setTimeout( │ │ │ │ - OpenLayers.Function.bind(this.delayedCall, this, evt), │ │ │ │ - this.delay │ │ │ │ - ); │ │ │ │ + resize: function(scale, origin, ratio) { │ │ │ │ + for (var i = 0; i < this.components.length; ++i) { │ │ │ │ + this.components[i].resize(scale, origin, ratio); │ │ │ │ + } │ │ │ │ + return this; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: passesTolerance │ │ │ │ - * Determine whether the event is within the optional pixel tolerance. Note │ │ │ │ - * that the pixel tolerance check only works if mousedown events get to │ │ │ │ - * the listeners registered here. If they are stopped by other elements, │ │ │ │ - * the <pixelTolerance> will have no effect here (this method will always │ │ │ │ - * return true). │ │ │ │ + * APIMethod: distanceTo │ │ │ │ + * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Optional properties for configuring the distance │ │ │ │ + * calculation. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * details - {Boolean} Return details from the distance calculation. │ │ │ │ + * Default is false. │ │ │ │ + * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ + * nearest edge of the target geometry. Default is true. If true, │ │ │ │ + * calling distanceTo from a geometry that is wholly contained within │ │ │ │ + * the target will result in a non-zero distance. If false, whenever │ │ │ │ + * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ + * details cannot be returned. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The click is within the pixel tolerance (if specified). │ │ │ │ + * {Number | Object} The distance between this geometry and the target. │ │ │ │ + * If details is true, the return will be an object with distance, │ │ │ │ + * x0, y0, x1, and y1 properties. The x0 and y0 properties represent │ │ │ │ + * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ + * properties represent the coordinates of the closest point on the │ │ │ │ + * target geometry. │ │ │ │ */ │ │ │ │ - passesTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ - passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ - // for touch environments, we also enforce that all touches │ │ │ │ - // start and end within the given tolerance to be considered a click │ │ │ │ - if (passes && this.touch && │ │ │ │ - this.down.touches.length === this.last.touches.length) { │ │ │ │ - // the touchend event doesn't come with touches, so we check │ │ │ │ - // down and last │ │ │ │ - for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ - if (this.getTouchDistance( │ │ │ │ - this.down.touches[i], │ │ │ │ - this.last.touches[i] │ │ │ │ - ) > this.pixelTolerance) { │ │ │ │ - passes = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + distanceTo: function(geometry, options) { │ │ │ │ + var edge = !(options && options.edge === false); │ │ │ │ + var details = edge && options && options.details; │ │ │ │ + var result, best, distance; │ │ │ │ + var min = Number.POSITIVE_INFINITY; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + result = this.components[i].distanceTo(geometry, options); │ │ │ │ + distance = details ? result.distance : result; │ │ │ │ + if (distance < min) { │ │ │ │ + min = distance; │ │ │ │ + best = result; │ │ │ │ + if (min == 0) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - return passes; │ │ │ │ + return best; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getTouchDistance │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The pixel displacement between two touches. │ │ │ │ - */ │ │ │ │ - getTouchDistance: function(from, to) { │ │ │ │ - return Math.sqrt( │ │ │ │ - Math.pow(from.clientX - to.clientX, 2) + │ │ │ │ - Math.pow(from.clientY - to.clientY, 2) │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: passesDblclickTolerance │ │ │ │ - * Determine whether the event is within the optional double-cick pixel │ │ │ │ - * tolerance. │ │ │ │ + * APIMethod: equals │ │ │ │ + * Determine whether another geometry is equivalent to this one. Geometries │ │ │ │ + * are considered equivalent if all components have the same coordinates. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The geometry to test. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The click is within the double-click pixel tolerance. │ │ │ │ - */ │ │ │ │ - passesDblclickTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.down && this.first) { │ │ │ │ - passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance; │ │ │ │ - } │ │ │ │ - return passes; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clearTimer │ │ │ │ - * Clear the timer and set <timerId> to null. │ │ │ │ + * {Boolean} The supplied geometry is equivalent to this geometry. │ │ │ │ */ │ │ │ │ - clearTimer: function() { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - } │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - window.clearTimeout(this.rightclickTimerId); │ │ │ │ - this.rightclickTimerId = null; │ │ │ │ + equals: function(geometry) { │ │ │ │ + var equivalent = true; │ │ │ │ + if (!geometry || !geometry.CLASS_NAME || │ │ │ │ + (this.CLASS_NAME != geometry.CLASS_NAME)) { │ │ │ │ + equivalent = false; │ │ │ │ + } else if (!(OpenLayers.Util.isArray(geometry.components)) || │ │ │ │ + (geometry.components.length != this.components.length)) { │ │ │ │ + equivalent = false; │ │ │ │ + } else { │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + if (!this.components[i].equals(geometry.components[i])) { │ │ │ │ + equivalent = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return equivalent; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: delayedCall │ │ │ │ - * Sets <timerId> to null. And optionally triggers the click callback if │ │ │ │ - * evt is set. │ │ │ │ + * APIMethod: transform │ │ │ │ + * Reproject the components geometry from source to dest. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * source - {<OpenLayers.Projection>} │ │ │ │ + * dest - {<OpenLayers.Projection>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} │ │ │ │ */ │ │ │ │ - delayedCall: function(evt) { │ │ │ │ - this.timerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback("click", [evt]); │ │ │ │ + transform: function(source, dest) { │ │ │ │ + if (source && dest) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + var component = this.components[i]; │ │ │ │ + component.transform(source, dest); │ │ │ │ + } │ │ │ │ + this.bounds = null; │ │ │ │ } │ │ │ │ + return this; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getEventInfo │ │ │ │ - * This method allows us to store event information without storing the │ │ │ │ - * actual event. In touch devices (at least), the same event is │ │ │ │ - * modified between touchstart, touchmove, and touchend. │ │ │ │ + * APIMethod: intersects │ │ │ │ + * Determine if the input geometry intersects this one. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object with event related info. │ │ │ │ + * {Boolean} The input geometry intersects this one. │ │ │ │ */ │ │ │ │ - getEventInfo: function(evt) { │ │ │ │ - var touches; │ │ │ │ - if (evt.touches) { │ │ │ │ - var len = evt.touches.length; │ │ │ │ - touches = new Array(len); │ │ │ │ - var touch; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - touch = evt.touches[i]; │ │ │ │ - touches[i] = { │ │ │ │ - clientX: touch.olClientX, │ │ │ │ - clientY: touch.olClientY │ │ │ │ - }; │ │ │ │ + intersects: function(geometry) { │ │ │ │ + var intersect = false; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + intersect = geometry.intersects(this.components[i]); │ │ │ │ + if (intersect) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ - return { │ │ │ │ - xy: evt.xy, │ │ │ │ - touches: touches │ │ │ │ - }; │ │ │ │ + return intersect; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivate the handler. │ │ │ │ + * APIMethod: getVertices │ │ │ │ + * Return a list of all points in this geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ + * endpoints. If false, for lines, only vertices that are not │ │ │ │ + * endpoints will be returned. If not provided, all vertices will │ │ │ │ + * be returned. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The handler was successfully deactivated. │ │ │ │ + * {Array} A list of all vertices in the geometry. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.down = null; │ │ │ │ - this.first = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ + getVertices: function(nodes) { │ │ │ │ + var vertices = []; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + Array.prototype.push.apply( │ │ │ │ + vertices, this.components[i].getVertices(nodes) │ │ │ │ + ); │ │ │ │ } │ │ │ │ - return deactivated; │ │ │ │ + return vertices; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.Collection" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/Navigation.js │ │ │ │ + OpenLayers/Geometry/MultiPoint.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control/ZoomBox.js │ │ │ │ - * @requires OpenLayers/Control/DragPan.js │ │ │ │ - * @requires OpenLayers/Handler/MouseWheel.js │ │ │ │ - * @requires OpenLayers/Handler/Click.js │ │ │ │ + * @requires OpenLayers/Geometry/Collection.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.Navigation │ │ │ │ - * The navigation control handles map browsing with mouse events (dragging, │ │ │ │ - * double-clicking, and scrolling the wheel). Create a new navigation │ │ │ │ - * control with the <OpenLayers.Control.Navigation> control. │ │ │ │ - * │ │ │ │ - * Note that this control is added to the map by default (if no controls │ │ │ │ - * array is sent in the options object to the <OpenLayers.Map> │ │ │ │ - * constructor). │ │ │ │ - * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * Class: OpenLayers.Geometry.MultiPoint │ │ │ │ + * MultiPoint is a collection of Points. Create a new instance with the │ │ │ │ + * <OpenLayers.Geometry.MultiPoint> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Geometry.Collection> │ │ │ │ + * - <OpenLayers.Geometry> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: dragPan │ │ │ │ - * {<OpenLayers.Control.DragPan>} │ │ │ │ - */ │ │ │ │ - dragPan: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: dragPanOptions │ │ │ │ - * {Object} Options passed to the DragPan control. │ │ │ │ - */ │ │ │ │ - dragPanOptions: null, │ │ │ │ +OpenLayers.Geometry.MultiPoint = OpenLayers.Class( │ │ │ │ + OpenLayers.Geometry.Collection, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: pinchZoom │ │ │ │ - * {<OpenLayers.Control.PinchZoom>} │ │ │ │ - */ │ │ │ │ - pinchZoom: null, │ │ │ │ + /** │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null value means the │ │ │ │ + * component types are not restricted. │ │ │ │ + */ │ │ │ │ + componentTypes: ["OpenLayers.Geometry.Point"], │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: pinchZoomOptions │ │ │ │ - * {Object} Options passed to the PinchZoom control. │ │ │ │ - */ │ │ │ │ - pinchZoomOptions: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Geometry.MultiPoint │ │ │ │ + * Create a new MultiPoint Geometry │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry.Point>)} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.MultiPoint>} │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: documentDrag │ │ │ │ - * {Boolean} Allow panning of the map by dragging outside map viewport. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - documentDrag: false, │ │ │ │ + /** │ │ │ │ + * APIMethod: addPoint │ │ │ │ + * Wrapper for <OpenLayers.Geometry.Collection.addComponent> │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} Point to be added │ │ │ │ + * index - {Integer} Optional index │ │ │ │ + */ │ │ │ │ + addPoint: function(point, index) { │ │ │ │ + this.addComponent(point, index); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: zoomBox │ │ │ │ - * {<OpenLayers.Control.ZoomBox>} │ │ │ │ - */ │ │ │ │ - zoomBox: null, │ │ │ │ + /** │ │ │ │ + * APIMethod: removePoint │ │ │ │ + * Wrapper for <OpenLayers.Geometry.Collection.removeComponent> │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} Point to be removed │ │ │ │ + */ │ │ │ │ + removePoint: function(point) { │ │ │ │ + this.removeComponent(point); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomBoxEnabled │ │ │ │ - * {Boolean} Whether the user can draw a box to zoom │ │ │ │ - */ │ │ │ │ - zoomBoxEnabled: true, │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.MultiPoint" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Geometry/Curve.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: zoomWheelEnabled │ │ │ │ - * {Boolean} Whether the mousewheel should zoom the map │ │ │ │ - */ │ │ │ │ - zoomWheelEnabled: true, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: mouseWheelOptions │ │ │ │ - * {Object} Options passed to the MouseWheel control (only useful if │ │ │ │ - * <zoomWheelEnabled> is set to true). Default is no options for maps │ │ │ │ - * with fractionalZoom set to true, otherwise │ │ │ │ - * {cumulative: false, interval: 50, maxDelta: 6} │ │ │ │ - */ │ │ │ │ - mouseWheelOptions: null, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Geometry/MultiPoint.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: handleRightClicks │ │ │ │ - * {Boolean} Whether or not to handle right clicks. Default is false. │ │ │ │ - */ │ │ │ │ - handleRightClicks: false, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Geometry.Curve │ │ │ │ + * A Curve is a MultiPoint, whose points are assumed to be connected. To │ │ │ │ + * this end, we provide a "getLength()" function, which iterates through │ │ │ │ + * the points, summing the distances between them. │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Geometry.MultiPoint> │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.Curve = OpenLayers.Class(OpenLayers.Geometry.MultiPoint, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: zoomBoxKeyMask │ │ │ │ - * {Integer} <OpenLayers.Handler> key code of the key, which has to be │ │ │ │ - * pressed, while drawing the zoom box with the mouse on the screen. │ │ │ │ - * You should probably set handleRightClicks to true if you use this │ │ │ │ - * with MOD_CTRL, to disable the context menu for machines which use │ │ │ │ - * CTRL-Click as a right click. │ │ │ │ - * Default: <OpenLayers.Handler.MOD_SHIFT> │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null │ │ │ │ + * value means the component types are not restricted. │ │ │ │ */ │ │ │ │ - zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ + componentTypes: ["OpenLayers.Geometry.Point"], │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ + * Constructor: OpenLayers.Geometry.Curve │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {Array(<OpenLayers.Geometry.Point>)} │ │ │ │ */ │ │ │ │ - autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Navigation │ │ │ │ - * Create a new navigation control │ │ │ │ + * APIMethod: getLength │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * the control │ │ │ │ + * Returns: │ │ │ │ + * {Float} The length of the curve │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + getLength: function() { │ │ │ │ + var length = 0.0; │ │ │ │ + if (this.components && (this.components.length > 1)) { │ │ │ │ + for (var i = 1, len = this.components.length; i < len; i++) { │ │ │ │ + length += this.components[i - 1].distanceTo(this.components[i]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return length; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ + * APIMethod: getGeodesicLength │ │ │ │ + * Calculate the approximate length of the geometry were it projected onto │ │ │ │ + * the earth. │ │ │ │ + * │ │ │ │ + * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ + * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ + * assumed. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The appoximate geodesic length of the geometry in meters. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - │ │ │ │ - if (this.dragPan) { │ │ │ │ - this.dragPan.destroy(); │ │ │ │ - } │ │ │ │ - this.dragPan = null; │ │ │ │ - │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.zoomBox.destroy(); │ │ │ │ + getGeodesicLength: function(projection) { │ │ │ │ + var geom = this; // so we can work with a clone if needed │ │ │ │ + if (projection) { │ │ │ │ + var gg = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + if (!gg.equals(projection)) { │ │ │ │ + geom = this.clone().transform(projection, gg); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.zoomBox = null; │ │ │ │ - │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.destroy(); │ │ │ │ + var length = 0.0; │ │ │ │ + if (geom.components && (geom.components.length > 1)) { │ │ │ │ + var p1, p2; │ │ │ │ + for (var i = 1, len = geom.components.length; i < len; i++) { │ │ │ │ + p1 = geom.components[i - 1]; │ │ │ │ + p2 = geom.components[i]; │ │ │ │ + // this returns km and requires lon/lat properties │ │ │ │ + length += OpenLayers.Util.distVincenty({ │ │ │ │ + lon: p1.x, │ │ │ │ + lat: p1.y │ │ │ │ + }, { │ │ │ │ + lon: p2.x, │ │ │ │ + lat: p2.y │ │ │ │ + }); │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.pinchZoom = null; │ │ │ │ - │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + // convert to m │ │ │ │ + return length * 1000; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: activate │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - this.dragPan.activate(); │ │ │ │ - if (this.zoomWheelEnabled) { │ │ │ │ - this.handlers.wheel.activate(); │ │ │ │ - } │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - if (this.zoomBoxEnabled) { │ │ │ │ - this.zoomBox.activate(); │ │ │ │ - } │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.activate(); │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.deactivate(); │ │ │ │ - } │ │ │ │ - this.zoomBox.deactivate(); │ │ │ │ - this.dragPan.deactivate(); │ │ │ │ - this.handlers.click.deactivate(); │ │ │ │ - this.handlers.wheel.deactivate(); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - */ │ │ │ │ - draw: function() { │ │ │ │ - // disable right mouse context menu for support of right click events │ │ │ │ - if (this.handleRightClicks) { │ │ │ │ - this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var clickCallbacks = { │ │ │ │ - 'click': this.defaultClick, │ │ │ │ - 'dblclick': this.defaultDblClick, │ │ │ │ - 'dblrightclick': this.defaultDblRightClick │ │ │ │ - }; │ │ │ │ - var clickOptions = { │ │ │ │ - 'double': true, │ │ │ │ - 'stopDouble': true │ │ │ │ - }; │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ - this, clickCallbacks, clickOptions │ │ │ │ - ); │ │ │ │ - this.dragPan = new OpenLayers.Control.DragPan( │ │ │ │ - OpenLayers.Util.extend({ │ │ │ │ - map: this.map, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }, this.dragPanOptions) │ │ │ │ - ); │ │ │ │ - this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ - map: this.map, │ │ │ │ - keyMask: this.zoomBoxKeyMask │ │ │ │ - }); │ │ │ │ - this.dragPan.draw(); │ │ │ │ - this.zoomBox.draw(); │ │ │ │ - var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ - cumulative: false, │ │ │ │ - interval: 50, │ │ │ │ - maxDelta: 6 │ │ │ │ - }; │ │ │ │ - this.handlers.wheel = new OpenLayers.Handler.MouseWheel( │ │ │ │ - this, { │ │ │ │ - up: this.wheelUp, │ │ │ │ - down: this.wheelDown │ │ │ │ - }, │ │ │ │ - OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions) │ │ │ │ - ); │ │ │ │ - if (OpenLayers.Control.PinchZoom) { │ │ │ │ - this.pinchZoom = new OpenLayers.Control.PinchZoom( │ │ │ │ - OpenLayers.Util.extend({ │ │ │ │ - map: this.map │ │ │ │ - }, this.pinchZoomOptions)); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: defaultClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - defaultClick: function(evt) { │ │ │ │ - if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ - this.map.zoomOut(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: defaultDblClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - defaultDblClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom + 1, evt.xy); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: defaultDblRightClick │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - defaultDblRightClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom - 1, evt.xy); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: wheelChange │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * deltaZ - {Integer} │ │ │ │ - */ │ │ │ │ - wheelChange: function(evt, deltaZ) { │ │ │ │ - if (!this.map.fractionalZoom) { │ │ │ │ - deltaZ = Math.round(deltaZ); │ │ │ │ - } │ │ │ │ - var currentZoom = this.map.getZoom(), │ │ │ │ - newZoom = currentZoom + deltaZ; │ │ │ │ - newZoom = Math.max(newZoom, 0); │ │ │ │ - newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ - if (newZoom === currentZoom) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - this.map.zoomTo(newZoom, evt.xy); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: wheelUp │ │ │ │ - * User spun scroll wheel up │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * delta - {Integer} │ │ │ │ - */ │ │ │ │ - wheelUp: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || 1); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: wheelDown │ │ │ │ - * User spun scroll wheel down │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - * delta - {Integer} │ │ │ │ - */ │ │ │ │ - wheelDown: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || -1); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: disableZoomBox │ │ │ │ - */ │ │ │ │ - disableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = false; │ │ │ │ - this.zoomBox.deactivate(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: enableZoomBox │ │ │ │ - */ │ │ │ │ - enableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.zoomBox.activate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: disableZoomWheel │ │ │ │ - */ │ │ │ │ - │ │ │ │ - disableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = false; │ │ │ │ - this.handlers.wheel.deactivate(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: enableZoomWheel │ │ │ │ - */ │ │ │ │ - │ │ │ │ - enableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.wheel.activate(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.Curve" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Handler/Feature.js │ │ │ │ + OpenLayers/Geometry/LineString.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Geometry/Curve.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Handler.Feature │ │ │ │ - * Handler to respond to mouse events related to a drawn feature. Callbacks │ │ │ │ - * with the following keys will be notified of the following events │ │ │ │ - * associated with features: click, clickout, over, out, and dblclick. │ │ │ │ - * │ │ │ │ - * This handler stops event propagation for mousedown and mouseup if those │ │ │ │ - * browser events target features that can be selected. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Geometry.LineString │ │ │ │ + * A LineString is a Curve which, once two points have been added to it, can │ │ │ │ + * never be less than two points long. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Handler> │ │ │ │ + * - <OpenLayers.Geometry.Curve> │ │ │ │ */ │ │ │ │ -OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: EVENTMAP │ │ │ │ - * {Object} A object mapping the browser events to objects with callback │ │ │ │ - * keys for in and out. │ │ │ │ - */ │ │ │ │ - EVENTMAP: { │ │ │ │ - 'click': { │ │ │ │ - 'in': 'click', │ │ │ │ - 'out': 'clickout' │ │ │ │ - }, │ │ │ │ - 'mousemove': { │ │ │ │ - 'in': 'over', │ │ │ │ - 'out': 'out' │ │ │ │ - }, │ │ │ │ - 'dblclick': { │ │ │ │ - 'in': 'dblclick', │ │ │ │ - 'out': null │ │ │ │ - }, │ │ │ │ - 'mousedown': { │ │ │ │ - 'in': null, │ │ │ │ - 'out': null │ │ │ │ - }, │ │ │ │ - 'mouseup': { │ │ │ │ - 'in': null, │ │ │ │ - 'out': null │ │ │ │ - }, │ │ │ │ - 'touchstart': { │ │ │ │ - 'in': 'click', │ │ │ │ - 'out': 'clickout' │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: feature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The last feature that was hovered. │ │ │ │ - */ │ │ │ │ - feature: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: lastFeature │ │ │ │ - * {<OpenLayers.Feature.Vector>} The last feature that was handled. │ │ │ │ - */ │ │ │ │ - lastFeature: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: down │ │ │ │ - * {<OpenLayers.Pixel>} The location of the last mousedown. │ │ │ │ - */ │ │ │ │ - down: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: up │ │ │ │ - * {<OpenLayers.Pixel>} The location of the last mouseup. │ │ │ │ - */ │ │ │ │ - up: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: clickTolerance │ │ │ │ - * {Number} The number of pixels the mouse can move between mousedown │ │ │ │ - * and mouseup for the event to still be considered a click. │ │ │ │ - * Dragging the map should not trigger the click and clickout callbacks │ │ │ │ - * unless the map is moved by less than this tolerance. Defaults to 4. │ │ │ │ - */ │ │ │ │ - clickTolerance: 4, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: geometryTypes │ │ │ │ - * To restrict dragging to a limited set of geometry types, send a list │ │ │ │ - * of strings corresponding to the geometry class names. │ │ │ │ - * │ │ │ │ - * @type Array(String) │ │ │ │ - */ │ │ │ │ - geometryTypes: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: stopClick │ │ │ │ - * {Boolean} If stopClick is set to true, handled clicks do not │ │ │ │ - * propagate to other click listeners. Otherwise, handled clicks │ │ │ │ - * do propagate. Unhandled clicks always propagate, whatever the │ │ │ │ - * value of stopClick. Defaults to true. │ │ │ │ - */ │ │ │ │ - stopClick: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: stopDown │ │ │ │ - * {Boolean} If stopDown is set to true, handled mousedowns do not │ │ │ │ - * propagate to other mousedown listeners. Otherwise, handled │ │ │ │ - * mousedowns do propagate. Unhandled mousedowns always propagate, │ │ │ │ - * whatever the value of stopDown. Defaults to true. │ │ │ │ - */ │ │ │ │ - stopDown: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: stopUp │ │ │ │ - * {Boolean} If stopUp is set to true, handled mouseups do not │ │ │ │ - * propagate to other mouseup listeners. Otherwise, handled mouseups │ │ │ │ - * do propagate. Unhandled mouseups always propagate, whatever the │ │ │ │ - * value of stopUp. Defaults to false. │ │ │ │ - */ │ │ │ │ - stopUp: false, │ │ │ │ +OpenLayers.Geometry.LineString = OpenLayers.Class(OpenLayers.Geometry.Curve, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Handler.Feature │ │ │ │ + * Constructor: OpenLayers.Geometry.LineString │ │ │ │ + * Create a new LineString geometry │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * control - {<OpenLayers.Control>} │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ - * callbacks - {Object} An object with a 'over' property whos value is │ │ │ │ - * a function to be called when the mouse is over a feature. The │ │ │ │ - * callback should expect to recieve a single argument, the feature. │ │ │ │ - * options - {Object} │ │ │ │ + * points - {Array(<OpenLayers.Geometry.Point>)} An array of points used to │ │ │ │ + * generate the linestring │ │ │ │ + * │ │ │ │ */ │ │ │ │ - initialize: function(control, layer, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ - this.layer = layer; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchstart │ │ │ │ - * Handle touchstart events │ │ │ │ + * APIMethod: removeComponent │ │ │ │ + * Only allows removal of a point if there are three or more points in │ │ │ │ + * the linestring. (otherwise the result would be just a single point) │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} The point to be removed │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Let the event propagate. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The component was removed. │ │ │ │ */ │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return OpenLayers.Event.isMultiTouch(evt) ? │ │ │ │ - true : this.mousedown(evt); │ │ │ │ + removeComponent: function(point) { │ │ │ │ + var removed = this.components && (this.components.length > 2); │ │ │ │ + if (removed) { │ │ │ │ + OpenLayers.Geometry.Collection.prototype.removeComponent.apply(this, │ │ │ │ + arguments); │ │ │ │ + } │ │ │ │ + return removed; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: touchmove │ │ │ │ - * Handle touchmove events. We just prevent the browser default behavior, │ │ │ │ - * for Android Webkit not to select text when moving the finger after │ │ │ │ - * selecting a feature. │ │ │ │ + * APIMethod: intersects │ │ │ │ + * Test for instersection between two geometries. This is a cheapo │ │ │ │ + * implementation of the Bently-Ottmann algorigithm. It doesn't │ │ │ │ + * really keep track of a sweep line data structure. It is closer │ │ │ │ + * to the brute force method, except that segments are sorted and │ │ │ │ + * potential intersections are only calculated when bounding boxes │ │ │ │ + * intersect. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - touchmove: function(evt) { │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: mousedown │ │ │ │ - * Handle mouse down. Stop propagation if a feature is targeted by this │ │ │ │ - * event (stops map dragging during feature selection). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The input geometry intersects this geometry. │ │ │ │ */ │ │ │ │ - mousedown: function(evt) { │ │ │ │ - // Feature selection is only done with a left click. Other handlers may stop the │ │ │ │ - // propagation of left-click mousedown events but not right-click mousedown events. │ │ │ │ - // This mismatch causes problems when comparing the location of the down and up │ │ │ │ - // events in the click function so it is important ignore right-clicks. │ │ │ │ - if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ - this.down = evt.xy; │ │ │ │ + intersects: function(geometry) { │ │ │ │ + var intersect = false; │ │ │ │ + var type = geometry.CLASS_NAME; │ │ │ │ + if (type == "OpenLayers.Geometry.LineString" || │ │ │ │ + type == "OpenLayers.Geometry.LinearRing" || │ │ │ │ + type == "OpenLayers.Geometry.Point") { │ │ │ │ + var segs1 = this.getSortedSegments(); │ │ │ │ + var segs2; │ │ │ │ + if (type == "OpenLayers.Geometry.Point") { │ │ │ │ + segs2 = [{ │ │ │ │ + x1: geometry.x, │ │ │ │ + y1: geometry.y, │ │ │ │ + x2: geometry.x, │ │ │ │ + y2: geometry.y │ │ │ │ + }]; │ │ │ │ + } else { │ │ │ │ + segs2 = geometry.getSortedSegments(); │ │ │ │ + } │ │ │ │ + var seg1, seg1x1, seg1x2, seg1y1, seg1y2, │ │ │ │ + seg2, seg2y1, seg2y2; │ │ │ │ + // sweep right │ │ │ │ + outer: for (var i = 0, len = segs1.length; i < len; ++i) { │ │ │ │ + seg1 = segs1[i]; │ │ │ │ + seg1x1 = seg1.x1; │ │ │ │ + seg1x2 = seg1.x2; │ │ │ │ + seg1y1 = seg1.y1; │ │ │ │ + seg1y2 = seg1.y2; │ │ │ │ + inner: for (var j = 0, jlen = segs2.length; j < jlen; ++j) { │ │ │ │ + seg2 = segs2[j]; │ │ │ │ + if (seg2.x1 > seg1x2) { │ │ │ │ + // seg1 still left of seg2 │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + if (seg2.x2 < seg1x1) { │ │ │ │ + // seg2 still left of seg1 │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + seg2y1 = seg2.y1; │ │ │ │ + seg2y2 = seg2.y2; │ │ │ │ + if (Math.min(seg2y1, seg2y2) > Math.max(seg1y1, seg1y2)) { │ │ │ │ + // seg2 above seg1 │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + if (Math.max(seg2y1, seg2y2) < Math.min(seg1y1, seg1y2)) { │ │ │ │ + // seg2 below seg1 │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + if (OpenLayers.Geometry.segmentsIntersect(seg1, seg2)) { │ │ │ │ + intersect = true; │ │ │ │ + break outer; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + intersect = geometry.intersects(this); │ │ │ │ } │ │ │ │ - return this.handle(evt) ? !this.stopDown : true; │ │ │ │ + return intersect; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mouseup │ │ │ │ - * Handle mouse up. Stop propagation if a feature is targeted by this │ │ │ │ - * event. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * Method: getSortedSegments │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of segment objects. Segment objects have properties │ │ │ │ + * x1, y1, x2, and y2. The start point is represented by x1 and y1. │ │ │ │ + * The end point is represented by x2 and y2. Start and end are │ │ │ │ + * ordered so that x1 < x2. │ │ │ │ */ │ │ │ │ - mouseup: function(evt) { │ │ │ │ - this.up = evt.xy; │ │ │ │ - return this.handle(evt) ? !this.stopUp : true; │ │ │ │ + getSortedSegments: function() { │ │ │ │ + var numSeg = this.components.length - 1; │ │ │ │ + var segments = new Array(numSeg), │ │ │ │ + point1, point2; │ │ │ │ + for (var i = 0; i < numSeg; ++i) { │ │ │ │ + point1 = this.components[i]; │ │ │ │ + point2 = this.components[i + 1]; │ │ │ │ + if (point1.x < point2.x) { │ │ │ │ + segments[i] = { │ │ │ │ + x1: point1.x, │ │ │ │ + y1: point1.y, │ │ │ │ + x2: point2.x, │ │ │ │ + y2: point2.y │ │ │ │ + }; │ │ │ │ + } else { │ │ │ │ + segments[i] = { │ │ │ │ + x1: point2.x, │ │ │ │ + y1: point2.y, │ │ │ │ + x2: point1.x, │ │ │ │ + y2: point1.y │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // more efficient to define this somewhere static │ │ │ │ + function byX1(seg1, seg2) { │ │ │ │ + return seg1.x1 - seg2.x1; │ │ │ │ + } │ │ │ │ + return segments.sort(byX1); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: click │ │ │ │ - * Handle click. Call the "click" callback if click on a feature, │ │ │ │ - * or the "clickout" callback if click outside any feature. │ │ │ │ - * │ │ │ │ + * Method: splitWithSegment │ │ │ │ + * Split this geometry with the given segment. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * seg - {Object} An object with x1, y1, x2, and y2 properties referencing │ │ │ │ + * segment endpoint coordinates. │ │ │ │ + * options - {Object} Properties of this object will be used to determine │ │ │ │ + * how the split is conducted. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ + * true. If false, a vertex on the source segment must be within the │ │ │ │ + * tolerance distance of the intersection to be considered a split. │ │ │ │ + * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ + * within the tolerance distance of one of the source segment's │ │ │ │ + * endpoints will be assumed to occur at the endpoint. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {Object} An object with *lines* and *points* properties. If the given │ │ │ │ + * segment intersects this linestring, the lines array will reference │ │ │ │ + * geometries that result from the split. The points array will contain │ │ │ │ + * all intersection points. Intersection points are sorted along the │ │ │ │ + * segment (in order from x1,y1 to x2,y2). │ │ │ │ */ │ │ │ │ - click: function(evt) { │ │ │ │ - return this.handle(evt) ? !this.stopClick : true; │ │ │ │ + splitWithSegment: function(seg, options) { │ │ │ │ + var edge = !(options && options.edge === false); │ │ │ │ + var tolerance = options && options.tolerance; │ │ │ │ + var lines = []; │ │ │ │ + var verts = this.getVertices(); │ │ │ │ + var points = []; │ │ │ │ + var intersections = []; │ │ │ │ + var split = false; │ │ │ │ + var vert1, vert2, point; │ │ │ │ + var node, vertex, target; │ │ │ │ + var interOptions = { │ │ │ │ + point: true, │ │ │ │ + tolerance: tolerance │ │ │ │ + }; │ │ │ │ + var result = null; │ │ │ │ + for (var i = 0, stop = verts.length - 2; i <= stop; ++i) { │ │ │ │ + vert1 = verts[i]; │ │ │ │ + points.push(vert1.clone()); │ │ │ │ + vert2 = verts[i + 1]; │ │ │ │ + target = { │ │ │ │ + x1: vert1.x, │ │ │ │ + y1: vert1.y, │ │ │ │ + x2: vert2.x, │ │ │ │ + y2: vert2.y │ │ │ │ + }; │ │ │ │ + point = OpenLayers.Geometry.segmentsIntersect( │ │ │ │ + seg, target, interOptions │ │ │ │ + ); │ │ │ │ + if (point instanceof OpenLayers.Geometry.Point) { │ │ │ │ + if ((point.x === seg.x1 && point.y === seg.y1) || │ │ │ │ + (point.x === seg.x2 && point.y === seg.y2) || │ │ │ │ + point.equals(vert1) || point.equals(vert2)) { │ │ │ │ + vertex = true; │ │ │ │ + } else { │ │ │ │ + vertex = false; │ │ │ │ + } │ │ │ │ + if (vertex || edge) { │ │ │ │ + // push intersections different than the previous │ │ │ │ + if (!point.equals(intersections[intersections.length - 1])) { │ │ │ │ + intersections.push(point.clone()); │ │ │ │ + } │ │ │ │ + if (i === 0) { │ │ │ │ + if (point.equals(vert1)) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (point.equals(vert2)) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + split = true; │ │ │ │ + if (!point.equals(vert1)) { │ │ │ │ + points.push(point); │ │ │ │ + } │ │ │ │ + lines.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ + points = [point.clone()]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (split) { │ │ │ │ + points.push(vert2.clone()); │ │ │ │ + lines.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ + } │ │ │ │ + if (intersections.length > 0) { │ │ │ │ + // sort intersections along segment │ │ │ │ + var xDir = seg.x1 < seg.x2 ? 1 : -1; │ │ │ │ + var yDir = seg.y1 < seg.y2 ? 1 : -1; │ │ │ │ + result = { │ │ │ │ + lines: lines, │ │ │ │ + points: intersections.sort(function(p1, p2) { │ │ │ │ + return (xDir * p1.x - xDir * p2.x) || (yDir * p1.y - yDir * p2.y); │ │ │ │ + }) │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + return result; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: mousemove │ │ │ │ - * Handle mouse moves. Call the "over" callback if moving in to a feature, │ │ │ │ - * or the "out" callback if moving out of a feature. │ │ │ │ + * Method: split │ │ │ │ + * Use this geometry (the source) to attempt to split a target geometry. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * target - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Properties of this object will be used to determine │ │ │ │ + * how the split is conducted. │ │ │ │ * │ │ │ │ + * Valid options: │ │ │ │ + * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ + * geometry. Default is false. │ │ │ │ + * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ + * true. If false, a vertex on the source must be within the tolerance │ │ │ │ + * distance of the intersection to be considered a split. │ │ │ │ + * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ + * within the tolerance distance of an existing vertex on the source │ │ │ │ + * will be assumed to occur at the vertex. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {Array} A list of geometries (of this same type as the target) that │ │ │ │ + * result from splitting the target with the source geometry. The │ │ │ │ + * source and target geometry will remain unmodified. If no split │ │ │ │ + * results, null will be returned. If mutual is true and a split │ │ │ │ + * results, return will be an array of two arrays - the first will be │ │ │ │ + * all geometries that result from splitting the source geometry and │ │ │ │ + * the second will be all geometries that result from splitting the │ │ │ │ + * target geometry. │ │ │ │ */ │ │ │ │ - mousemove: function(evt) { │ │ │ │ - if (!this.callbacks['over'] && !this.callbacks['out']) { │ │ │ │ - return true; │ │ │ │ + split: function(target, options) { │ │ │ │ + var results = null; │ │ │ │ + var mutual = options && options.mutual; │ │ │ │ + var sourceSplit, targetSplit, sourceParts, targetParts; │ │ │ │ + if (target instanceof OpenLayers.Geometry.LineString) { │ │ │ │ + var verts = this.getVertices(); │ │ │ │ + var vert1, vert2, seg, splits, lines, point; │ │ │ │ + var points = []; │ │ │ │ + sourceParts = []; │ │ │ │ + for (var i = 0, stop = verts.length - 2; i <= stop; ++i) { │ │ │ │ + vert1 = verts[i]; │ │ │ │ + vert2 = verts[i + 1]; │ │ │ │ + seg = { │ │ │ │ + x1: vert1.x, │ │ │ │ + y1: vert1.y, │ │ │ │ + x2: vert2.x, │ │ │ │ + y2: vert2.y │ │ │ │ + }; │ │ │ │ + targetParts = targetParts || [target]; │ │ │ │ + if (mutual) { │ │ │ │ + points.push(vert1.clone()); │ │ │ │ + } │ │ │ │ + for (var j = 0; j < targetParts.length; ++j) { │ │ │ │ + splits = targetParts[j].splitWithSegment(seg, options); │ │ │ │ + if (splits) { │ │ │ │ + // splice in new features │ │ │ │ + lines = splits.lines; │ │ │ │ + if (lines.length > 0) { │ │ │ │ + lines.unshift(j, 1); │ │ │ │ + Array.prototype.splice.apply(targetParts, lines); │ │ │ │ + j += lines.length - 2; │ │ │ │ + } │ │ │ │ + if (mutual) { │ │ │ │ + for (var k = 0, len = splits.points.length; k < len; ++k) { │ │ │ │ + point = splits.points[k]; │ │ │ │ + if (!point.equals(vert1)) { │ │ │ │ + points.push(point); │ │ │ │ + sourceParts.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ + if (point.equals(vert2)) { │ │ │ │ + points = []; │ │ │ │ + } else { │ │ │ │ + points = [point.clone()]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (mutual && sourceParts.length > 0 && points.length > 0) { │ │ │ │ + points.push(vert2.clone()); │ │ │ │ + sourceParts.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + results = target.splitWith(this, options); │ │ │ │ } │ │ │ │ - this.handle(evt); │ │ │ │ - return true; │ │ │ │ + if (targetParts && targetParts.length > 1) { │ │ │ │ + targetSplit = true; │ │ │ │ + } else { │ │ │ │ + targetParts = []; │ │ │ │ + } │ │ │ │ + if (sourceParts && sourceParts.length > 1) { │ │ │ │ + sourceSplit = true; │ │ │ │ + } else { │ │ │ │ + sourceParts = []; │ │ │ │ + } │ │ │ │ + if (targetSplit || sourceSplit) { │ │ │ │ + if (mutual) { │ │ │ │ + results = [sourceParts, targetParts]; │ │ │ │ + } else { │ │ │ │ + results = targetParts; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return results; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: dblclick │ │ │ │ - * Handle dblclick. Call the "dblclick" callback if dblclick on a feature. │ │ │ │ + * Method: splitWith │ │ │ │ + * Split this geometry (the target) with the given geometry (the source). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} A geometry used to split this │ │ │ │ + * geometry (the source). │ │ │ │ + * options - {Object} Properties of this object will be used to determine │ │ │ │ + * how the split is conducted. │ │ │ │ * │ │ │ │ + * Valid options: │ │ │ │ + * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ + * geometry. Default is false. │ │ │ │ + * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ + * true. If false, a vertex on the source must be within the tolerance │ │ │ │ + * distance of the intersection to be considered a split. │ │ │ │ + * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ + * within the tolerance distance of an existing vertex on the source │ │ │ │ + * will be assumed to occur at the vertex. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {Array} A list of geometries (of this same type as the target) that │ │ │ │ + * result from splitting the target with the source geometry. The │ │ │ │ + * source and target geometry will remain unmodified. If no split │ │ │ │ + * results, null will be returned. If mutual is true and a split │ │ │ │ + * results, return will be an array of two arrays - the first will be │ │ │ │ + * all geometries that result from splitting the source geometry and │ │ │ │ + * the second will be all geometries that result from splitting the │ │ │ │ + * target geometry. │ │ │ │ */ │ │ │ │ - dblclick: function(evt) { │ │ │ │ - return !this.handle(evt); │ │ │ │ + splitWith: function(geometry, options) { │ │ │ │ + return geometry.split(this, options); │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: geometryTypeMatches │ │ │ │ - * Return true if the geometry type of the passed feature matches │ │ │ │ - * one of the geometry types in the geometryTypes array. │ │ │ │ + * APIMethod: getVertices │ │ │ │ + * Return a list of all points in this geometry. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ + * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ + * endpoints. If false, for lines, only vertices that are not │ │ │ │ + * endpoints will be returned. If not provided, all vertices will │ │ │ │ + * be returned. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {Array} A list of all vertices in the geometry. │ │ │ │ */ │ │ │ │ - geometryTypeMatches: function(feature) { │ │ │ │ - return this.geometryTypes == null || │ │ │ │ - OpenLayers.Util.indexOf(this.geometryTypes, │ │ │ │ - feature.geometry.CLASS_NAME) > -1; │ │ │ │ + getVertices: function(nodes) { │ │ │ │ + var vertices; │ │ │ │ + if (nodes === true) { │ │ │ │ + vertices = [ │ │ │ │ + this.components[0], │ │ │ │ + this.components[this.components.length - 1] │ │ │ │ + ]; │ │ │ │ + } else if (nodes === false) { │ │ │ │ + vertices = this.components.slice(1, this.components.length - 1); │ │ │ │ + } else { │ │ │ │ + vertices = this.components.slice(); │ │ │ │ + } │ │ │ │ + return vertices; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handle │ │ │ │ + * APIMethod: distanceTo │ │ │ │ + * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Optional properties for configuring the distance │ │ │ │ + * calculation. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * details - {Boolean} Return details from the distance calculation. │ │ │ │ + * Default is false. │ │ │ │ + * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ + * nearest edge of the target geometry. Default is true. If true, │ │ │ │ + * calling distanceTo from a geometry that is wholly contained within │ │ │ │ + * the target will result in a non-zero distance. If false, whenever │ │ │ │ + * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ + * details cannot be returned. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The event occurred over a relevant feature. │ │ │ │ + * {Number | Object} The distance between this geometry and the target. │ │ │ │ + * If details is true, the return will be an object with distance, │ │ │ │ + * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ + * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ + * properties represent the coordinates of the closest point on the │ │ │ │ + * target geometry. │ │ │ │ */ │ │ │ │ - handle: function(evt) { │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - // feature has been destroyed │ │ │ │ - this.feature = null; │ │ │ │ - } │ │ │ │ - var type = evt.type; │ │ │ │ - var handled = false; │ │ │ │ - var previouslyIn = !!(this.feature); // previously in a feature │ │ │ │ - var click = (type == "click" || type == "dblclick" || type == "touchstart"); │ │ │ │ - this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - // feature has been destroyed │ │ │ │ - this.feature = null; │ │ │ │ - } │ │ │ │ - if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ - // last feature has been destroyed │ │ │ │ - this.lastFeature = null; │ │ │ │ - } │ │ │ │ - if (this.feature) { │ │ │ │ - if (type === "touchstart") { │ │ │ │ - // stop the event to prevent Android Webkit from │ │ │ │ - // "flashing" the map div │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - } │ │ │ │ - var inNew = (this.feature != this.lastFeature); │ │ │ │ - if (this.geometryTypeMatches(this.feature)) { │ │ │ │ - // in to a feature │ │ │ │ - if (previouslyIn && inNew) { │ │ │ │ - // out of last feature and in to another │ │ │ │ - if (this.lastFeature) { │ │ │ │ - this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ + distanceTo: function(geometry, options) { │ │ │ │ + var edge = !(options && options.edge === false); │ │ │ │ + var details = edge && options && options.details; │ │ │ │ + var result, best = {}; │ │ │ │ + var min = Number.POSITIVE_INFINITY; │ │ │ │ + if (geometry instanceof OpenLayers.Geometry.Point) { │ │ │ │ + var segs = this.getSortedSegments(); │ │ │ │ + var x = geometry.x; │ │ │ │ + var y = geometry.y; │ │ │ │ + var seg; │ │ │ │ + for (var i = 0, len = segs.length; i < len; ++i) { │ │ │ │ + seg = segs[i]; │ │ │ │ + result = OpenLayers.Geometry.distanceToSegment(geometry, seg); │ │ │ │ + if (result.distance < min) { │ │ │ │ + min = result.distance; │ │ │ │ + best = result; │ │ │ │ + if (min === 0) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // if distance increases and we cross y0 to the right of x0, no need to keep looking. │ │ │ │ + if (seg.x2 > x && ((y > seg.y1 && y < seg.y2) || (y < seg.y1 && y > seg.y2))) { │ │ │ │ + break; │ │ │ │ } │ │ │ │ - this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ - } else if (!previouslyIn || click) { │ │ │ │ - // in feature for the first time │ │ │ │ - this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ } │ │ │ │ - this.lastFeature = this.feature; │ │ │ │ - handled = true; │ │ │ │ + } │ │ │ │ + if (details) { │ │ │ │ + best = { │ │ │ │ + distance: best.distance, │ │ │ │ + x0: best.x, │ │ │ │ + y0: best.y, │ │ │ │ + x1: x, │ │ │ │ + y1: y │ │ │ │ + }; │ │ │ │ } else { │ │ │ │ - // not in to a feature │ │ │ │ - if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ - // out of last feature for the first time │ │ │ │ - this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ + best = best.distance; │ │ │ │ + } │ │ │ │ + } else if (geometry instanceof OpenLayers.Geometry.LineString) { │ │ │ │ + var segs0 = this.getSortedSegments(); │ │ │ │ + var segs1 = geometry.getSortedSegments(); │ │ │ │ + var seg0, seg1, intersection, x0, y0; │ │ │ │ + var len1 = segs1.length; │ │ │ │ + var interOptions = { │ │ │ │ + point: true │ │ │ │ + }; │ │ │ │ + outer: for (var i = 0, len = segs0.length; i < len; ++i) { │ │ │ │ + seg0 = segs0[i]; │ │ │ │ + x0 = seg0.x1; │ │ │ │ + y0 = seg0.y1; │ │ │ │ + for (var j = 0; j < len1; ++j) { │ │ │ │ + seg1 = segs1[j]; │ │ │ │ + intersection = OpenLayers.Geometry.segmentsIntersect(seg0, seg1, interOptions); │ │ │ │ + if (intersection) { │ │ │ │ + min = 0; │ │ │ │ + best = { │ │ │ │ + distance: 0, │ │ │ │ + x0: intersection.x, │ │ │ │ + y0: intersection.y, │ │ │ │ + x1: intersection.x, │ │ │ │ + y1: intersection.y │ │ │ │ + }; │ │ │ │ + break outer; │ │ │ │ + } else { │ │ │ │ + result = OpenLayers.Geometry.distanceToSegment({ │ │ │ │ + x: x0, │ │ │ │ + y: y0 │ │ │ │ + }, seg1); │ │ │ │ + if (result.distance < min) { │ │ │ │ + min = result.distance; │ │ │ │ + best = { │ │ │ │ + distance: min, │ │ │ │ + x0: x0, │ │ │ │ + y0: y0, │ │ │ │ + x1: result.x, │ │ │ │ + y1: result.y │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - // next time the mouse goes in a feature whose geometry type │ │ │ │ - // doesn't match we don't want to call the 'out' callback │ │ │ │ - // again, so let's set this.feature to null so that │ │ │ │ - // previouslyIn will evaluate to false the next time │ │ │ │ - // we enter handle. Yes, a bit hackish... │ │ │ │ - this.feature = null; │ │ │ │ } │ │ │ │ - } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ - this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ - } │ │ │ │ - return handled; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: triggerCallback │ │ │ │ - * Call the callback keyed in the event map with the supplied arguments. │ │ │ │ - * For click and clickout, the <clickTolerance> is checked first. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * type - {String} │ │ │ │ - */ │ │ │ │ - triggerCallback: function(type, mode, args) { │ │ │ │ - var key = this.EVENTMAP[type][mode]; │ │ │ │ - if (key) { │ │ │ │ - if (type == 'click' && this.up && this.down) { │ │ │ │ - // for click/clickout, only trigger callback if tolerance is met │ │ │ │ - var dpx = Math.sqrt( │ │ │ │ - Math.pow(this.up.x - this.down.x, 2) + │ │ │ │ - Math.pow(this.up.y - this.down.y, 2) │ │ │ │ - ); │ │ │ │ - if (dpx <= this.clickTolerance) { │ │ │ │ - this.callback(key, args); │ │ │ │ + if (!details) { │ │ │ │ + best = best.distance; │ │ │ │ + } │ │ │ │ + if (min !== 0) { │ │ │ │ + // check the final vertex in this line's sorted segments │ │ │ │ + if (seg0) { │ │ │ │ + result = geometry.distanceTo( │ │ │ │ + new OpenLayers.Geometry.Point(seg0.x2, seg0.y2), │ │ │ │ + options │ │ │ │ + ); │ │ │ │ + var dist = details ? result.distance : result; │ │ │ │ + if (dist < min) { │ │ │ │ + if (details) { │ │ │ │ + best = { │ │ │ │ + distance: min, │ │ │ │ + x0: result.x1, │ │ │ │ + y0: result.y1, │ │ │ │ + x1: result.x0, │ │ │ │ + y1: result.y0 │ │ │ │ + }; │ │ │ │ + } else { │ │ │ │ + best = dist; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - // we're done with this set of events now: clear the cached │ │ │ │ - // positions so we can't trip over them later (this can occur │ │ │ │ - // if one of the up/down events gets eaten before it gets to us │ │ │ │ - // but we still get the click) │ │ │ │ - this.up = this.down = null; │ │ │ │ - } else { │ │ │ │ - this.callback(key, args); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + best = geometry.distanceTo(this, options); │ │ │ │ + // swap since target comes from this line │ │ │ │ + if (details) { │ │ │ │ + best = { │ │ │ │ + distance: best.distance, │ │ │ │ + x0: best.x1, │ │ │ │ + y0: best.y1, │ │ │ │ + x1: best.x0, │ │ │ │ + y1: best.y0 │ │ │ │ + }; │ │ │ │ } │ │ │ │ } │ │ │ │ + return best; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Turn on the handler. Returns false if the handler was already active. │ │ │ │ + * APIMethod: simplify │ │ │ │ + * This function will return a simplified LineString. │ │ │ │ + * Simplification is based on the Douglas-Peucker algorithm. │ │ │ │ + * │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * tolerance - {number} threshhold for simplification in map units │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {OpenLayers.Geometry.LineString} the simplified LineString │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - this.map.events.on({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - activated = true; │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ + simplify: function(tolerance) { │ │ │ │ + if (this && this !== null) { │ │ │ │ + var points = this.getVertices(); │ │ │ │ + if (points.length < 3) { │ │ │ │ + return this; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Turn off the handler. Returns false if the handler was already active. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.moveLayerBack(); │ │ │ │ - this.feature = null; │ │ │ │ - this.lastFeature = null; │ │ │ │ - this.down = null; │ │ │ │ - this.up = null; │ │ │ │ - this.map.events.un({ │ │ │ │ - "removelayer": this.handleMapEvents, │ │ │ │ - "changelayer": this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - deactivated = true; │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ - }, │ │ │ │ + var compareNumbers = function(a, b) { │ │ │ │ + return (a - b); │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleMapEvents │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ - */ │ │ │ │ - handleMapEvents: function(evt) { │ │ │ │ - if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Private function doing the Douglas-Peucker reduction │ │ │ │ + */ │ │ │ │ + var douglasPeuckerReduction = function(points, firstPoint, lastPoint, tolerance) { │ │ │ │ + var maxDistance = 0; │ │ │ │ + var indexFarthest = 0; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveLayerToTop │ │ │ │ - * Moves the layer for this handler to the top, so mouse events can reach │ │ │ │ - * it. │ │ │ │ - */ │ │ │ │ - moveLayerToTop: function() { │ │ │ │ - var index = Math.max(this.map.Z_INDEX_BASE['Feature'] - 1, │ │ │ │ - this.layer.getZIndex()) + 1; │ │ │ │ - this.layer.setZIndex(index); │ │ │ │ + for (var index = firstPoint, distance; index < lastPoint; index++) { │ │ │ │ + distance = perpendicularDistance(points[firstPoint], points[lastPoint], points[index]); │ │ │ │ + if (distance > maxDistance) { │ │ │ │ + maxDistance = distance; │ │ │ │ + indexFarthest = index; │ │ │ │ + } │ │ │ │ + } │ │ │ │ │ │ │ │ - }, │ │ │ │ + if (maxDistance > tolerance && indexFarthest != firstPoint) { │ │ │ │ + //Add the largest point that exceeds the tolerance │ │ │ │ + pointIndexsToKeep.push(indexFarthest); │ │ │ │ + douglasPeuckerReduction(points, firstPoint, indexFarthest, tolerance); │ │ │ │ + douglasPeuckerReduction(points, indexFarthest, lastPoint, tolerance); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Private function calculating the perpendicular distance │ │ │ │ + * TODO: check whether OpenLayers.Geometry.LineString::distanceTo() is faster or slower │ │ │ │ + */ │ │ │ │ + var perpendicularDistance = function(point1, point2, point) { │ │ │ │ + //Area = |(1/2)(x1y2 + x2y3 + x3y1 - x2y1 - x3y2 - x1y3)| *Area of triangle │ │ │ │ + //Base = v((x1-x2)²+(x1-x2)²) *Base of Triangle* │ │ │ │ + //Area = .5*Base*H *Solve for height │ │ │ │ + //Height = Area/.5/Base │ │ │ │ + │ │ │ │ + var area = Math.abs(0.5 * (point1.x * point2.y + point2.x * point.y + point.x * point1.y - point2.x * point1.y - point.x * point2.y - point1.x * point.y)); │ │ │ │ + var bottom = Math.sqrt(Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2)); │ │ │ │ + var height = area / bottom * 2; │ │ │ │ + │ │ │ │ + return height; │ │ │ │ + }; │ │ │ │ + │ │ │ │ + var firstPoint = 0; │ │ │ │ + var lastPoint = points.length - 1; │ │ │ │ + var pointIndexsToKeep = []; │ │ │ │ + │ │ │ │ + //Add the first and last index to the keepers │ │ │ │ + pointIndexsToKeep.push(firstPoint); │ │ │ │ + pointIndexsToKeep.push(lastPoint); │ │ │ │ + │ │ │ │ + //The first and the last point cannot be the same │ │ │ │ + while (points[firstPoint].equals(points[lastPoint])) { │ │ │ │ + lastPoint--; │ │ │ │ + //Addition: the first point not equal to first point in the LineString is kept as well │ │ │ │ + pointIndexsToKeep.push(lastPoint); │ │ │ │ + } │ │ │ │ + │ │ │ │ + douglasPeuckerReduction(points, firstPoint, lastPoint, tolerance); │ │ │ │ + var returnPoints = []; │ │ │ │ + pointIndexsToKeep.sort(compareNumbers); │ │ │ │ + for (var index = 0; index < pointIndexsToKeep.length; index++) { │ │ │ │ + returnPoints.push(points[pointIndexsToKeep[index]]); │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.LineString(returnPoints); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveLayerBack │ │ │ │ - * Moves the layer back to the position determined by the map's layers │ │ │ │ - * array. │ │ │ │ - */ │ │ │ │ - moveLayerBack: function() { │ │ │ │ - var index = this.layer.getZIndex() - 1; │ │ │ │ - if (index >= this.map.Z_INDEX_BASE['Feature']) { │ │ │ │ - this.layer.setZIndex(index); │ │ │ │ } else { │ │ │ │ - this.map.setLayerZIndex(this.layer, │ │ │ │ - this.map.getLayerIndex(this.layer)); │ │ │ │ + return this; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.LineString" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ + OpenLayers/Geometry/MultiLineString.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Collection.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.Vector.RootContainer │ │ │ │ - * A special layer type to combine multiple vector layers inside a single │ │ │ │ - * renderer root container. This class is not supposed to be instantiated │ │ │ │ - * from user space, it is a helper class for controls that require event │ │ │ │ - * processing for multiple vector layers. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Geometry.MultiLineString │ │ │ │ + * A MultiLineString is a geometry with multiple <OpenLayers.Geometry.LineString> │ │ │ │ + * components. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.Vector> │ │ │ │ + * - <OpenLayers.Geometry.Collection> │ │ │ │ + * - <OpenLayers.Geometry> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ +OpenLayers.Geometry.MultiLineString = OpenLayers.Class( │ │ │ │ + OpenLayers.Geometry.Collection, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: displayInLayerSwitcher │ │ │ │ - * Set to false for this layer type │ │ │ │ - */ │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ + /** │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null value means the │ │ │ │ + * component types are not restricted. │ │ │ │ + */ │ │ │ │ + componentTypes: ["OpenLayers.Geometry.LineString"], │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: layers │ │ │ │ - * Layers that are attached to this container. Required config option. │ │ │ │ - */ │ │ │ │ - layers: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Geometry.MultiLineString │ │ │ │ + * Constructor for a MultiLineString Geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry.LineString>)} │ │ │ │ + * │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Layer.Vector.RootContainer │ │ │ │ - * Create a new root container for multiple vector layer. This constructor │ │ │ │ - * is not supposed to be used from user space, it is only to be used by │ │ │ │ - * controls that need feature selection across multiple vector layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * name - {String} A name for the layer │ │ │ │ - * options - {Object} Optional object with non-default properties to set on │ │ │ │ - * the layer. │ │ │ │ - * │ │ │ │ - * Required options properties: │ │ │ │ - * layers - {Array(<OpenLayers.Layer.Vector>)} The layers managed by this │ │ │ │ - * container │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Vector.RootContainer>} A new vector layer root │ │ │ │ - * container │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Method: split │ │ │ │ + * Use this geometry (the source) to attempt to split a target geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Properties of this object will be used to determine │ │ │ │ + * how the split is conducted. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ + * geometry. Default is false. │ │ │ │ + * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ + * true. If false, a vertex on the source must be within the tolerance │ │ │ │ + * distance of the intersection to be considered a split. │ │ │ │ + * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ + * within the tolerance distance of an existing vertex on the source │ │ │ │ + * will be assumed to occur at the vertex. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} A list of geometries (of this same type as the target) that │ │ │ │ + * result from splitting the target with the source geometry. The │ │ │ │ + * source and target geometry will remain unmodified. If no split │ │ │ │ + * results, null will be returned. If mutual is true and a split │ │ │ │ + * results, return will be an array of two arrays - the first will be │ │ │ │ + * all geometries that result from splitting the source geometry and │ │ │ │ + * the second will be all geometries that result from splitting the │ │ │ │ + * target geometry. │ │ │ │ + */ │ │ │ │ + split: function(geometry, options) { │ │ │ │ + var results = null; │ │ │ │ + var mutual = options && options.mutual; │ │ │ │ + var splits, sourceLine, sourceLines, sourceSplit, targetSplit; │ │ │ │ + var sourceParts = []; │ │ │ │ + var targetParts = [geometry]; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + sourceLine = this.components[i]; │ │ │ │ + sourceSplit = false; │ │ │ │ + for (var j = 0; j < targetParts.length; ++j) { │ │ │ │ + splits = sourceLine.split(targetParts[j], options); │ │ │ │ + if (splits) { │ │ │ │ + if (mutual) { │ │ │ │ + sourceLines = splits[0]; │ │ │ │ + for (var k = 0, klen = sourceLines.length; k < klen; ++k) { │ │ │ │ + if (k === 0 && sourceParts.length) { │ │ │ │ + sourceParts[sourceParts.length - 1].addComponent( │ │ │ │ + sourceLines[k] │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + sourceParts.push( │ │ │ │ + new OpenLayers.Geometry.MultiLineString([ │ │ │ │ + sourceLines[k] │ │ │ │ + ]) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + sourceSplit = true; │ │ │ │ + splits = splits[1]; │ │ │ │ + } │ │ │ │ + if (splits.length) { │ │ │ │ + // splice in new target parts │ │ │ │ + splits.unshift(j, 1); │ │ │ │ + Array.prototype.splice.apply(targetParts, splits); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!sourceSplit) { │ │ │ │ + // source line was not hit │ │ │ │ + if (sourceParts.length) { │ │ │ │ + // add line to existing multi │ │ │ │ + sourceParts[sourceParts.length - 1].addComponent( │ │ │ │ + sourceLine.clone() │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + // create a fresh multi │ │ │ │ + sourceParts = [ │ │ │ │ + new OpenLayers.Geometry.MultiLineString( │ │ │ │ + sourceLine.clone() │ │ │ │ + ) │ │ │ │ + ]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (sourceParts && sourceParts.length > 1) { │ │ │ │ + sourceSplit = true; │ │ │ │ + } else { │ │ │ │ + sourceParts = []; │ │ │ │ + } │ │ │ │ + if (targetParts && targetParts.length > 1) { │ │ │ │ + targetSplit = true; │ │ │ │ + } else { │ │ │ │ + targetParts = []; │ │ │ │ + } │ │ │ │ + if (sourceSplit || targetSplit) { │ │ │ │ + if (mutual) { │ │ │ │ + results = [sourceParts, targetParts]; │ │ │ │ + } else { │ │ │ │ + results = targetParts; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return results; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: display │ │ │ │ - */ │ │ │ │ - display: function() {}, │ │ │ │ + /** │ │ │ │ + * Method: splitWith │ │ │ │ + * Split this geometry (the target) with the given geometry (the source). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} A geometry used to split this │ │ │ │ + * geometry (the source). │ │ │ │ + * options - {Object} Properties of this object will be used to determine │ │ │ │ + * how the split is conducted. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ + * geometry. Default is false. │ │ │ │ + * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ + * true. If false, a vertex on the source must be within the tolerance │ │ │ │ + * distance of the intersection to be considered a split. │ │ │ │ + * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ + * within the tolerance distance of an existing vertex on the source │ │ │ │ + * will be assumed to occur at the vertex. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} A list of geometries (of this same type as the target) that │ │ │ │ + * result from splitting the target with the source geometry. The │ │ │ │ + * source and target geometry will remain unmodified. If no split │ │ │ │ + * results, null will be returned. If mutual is true and a split │ │ │ │ + * results, return will be an array of two arrays - the first will be │ │ │ │ + * all geometries that result from splitting the source geometry and │ │ │ │ + * the second will be all geometries that result from splitting the │ │ │ │ + * target geometry. │ │ │ │ + */ │ │ │ │ + splitWith: function(geometry, options) { │ │ │ │ + var results = null; │ │ │ │ + var mutual = options && options.mutual; │ │ │ │ + var splits, targetLine, sourceLines, sourceSplit, targetSplit, sourceParts, targetParts; │ │ │ │ + if (geometry instanceof OpenLayers.Geometry.LineString) { │ │ │ │ + targetParts = []; │ │ │ │ + sourceParts = [geometry]; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + targetSplit = false; │ │ │ │ + targetLine = this.components[i]; │ │ │ │ + for (var j = 0; j < sourceParts.length; ++j) { │ │ │ │ + splits = sourceParts[j].split(targetLine, options); │ │ │ │ + if (splits) { │ │ │ │ + if (mutual) { │ │ │ │ + sourceLines = splits[0]; │ │ │ │ + if (sourceLines.length) { │ │ │ │ + // splice in new source parts │ │ │ │ + sourceLines.unshift(j, 1); │ │ │ │ + Array.prototype.splice.apply(sourceParts, sourceLines); │ │ │ │ + j += sourceLines.length - 2; │ │ │ │ + } │ │ │ │ + splits = splits[1]; │ │ │ │ + if (splits.length === 0) { │ │ │ │ + splits = [targetLine.clone()]; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + for (var k = 0, klen = splits.length; k < klen; ++k) { │ │ │ │ + if (k === 0 && targetParts.length) { │ │ │ │ + targetParts[targetParts.length - 1].addComponent( │ │ │ │ + splits[k] │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + targetParts.push( │ │ │ │ + new OpenLayers.Geometry.MultiLineString([ │ │ │ │ + splits[k] │ │ │ │ + ]) │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + targetSplit = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!targetSplit) { │ │ │ │ + // target component was not hit │ │ │ │ + if (targetParts.length) { │ │ │ │ + // add it to any existing multi-line │ │ │ │ + targetParts[targetParts.length - 1].addComponent( │ │ │ │ + targetLine.clone() │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + // or start with a fresh multi-line │ │ │ │ + targetParts = [ │ │ │ │ + new OpenLayers.Geometry.MultiLineString([ │ │ │ │ + targetLine.clone() │ │ │ │ + ]) │ │ │ │ + ]; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getFeatureFromEvent │ │ │ │ - * walk through the layers to find the feature returned by the event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} event object with a feature property │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - getFeatureFromEvent: function(evt) { │ │ │ │ - var layers = this.layers; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0; i < layers.length; i++) { │ │ │ │ - feature = layers[i].getFeatureFromEvent(evt); │ │ │ │ - if (feature) { │ │ │ │ - return feature; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + results = geometry.split(this); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + if (sourceParts && sourceParts.length > 1) { │ │ │ │ + sourceSplit = true; │ │ │ │ + } else { │ │ │ │ + sourceParts = []; │ │ │ │ + } │ │ │ │ + if (targetParts && targetParts.length > 1) { │ │ │ │ + targetSplit = true; │ │ │ │ + } else { │ │ │ │ + targetParts = []; │ │ │ │ + } │ │ │ │ + if (sourceSplit || targetSplit) { │ │ │ │ + if (mutual) { │ │ │ │ + results = [sourceParts, targetParts]; │ │ │ │ + } else { │ │ │ │ + results = targetParts; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return results; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ - this.collectRoots(); │ │ │ │ - map.events.register("changelayer", this, this.handleChangeLayer); │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.MultiLineString" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Geometry/LinearRing.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeMap │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - removeMap: function(map) { │ │ │ │ - map.events.unregister("changelayer", this, this.handleChangeLayer); │ │ │ │ - this.resetRoots(); │ │ │ │ - OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments); │ │ │ │ - }, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: collectRoots │ │ │ │ - * Collects the root nodes of all layers this control is configured with │ │ │ │ - * and moveswien the nodes to this control's layer │ │ │ │ - */ │ │ │ │ - collectRoots: function() { │ │ │ │ - var layer; │ │ │ │ - // walk through all map layers, because we want to keep the order │ │ │ │ - for (var i = 0; i < this.map.layers.length; ++i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ - layer.renderer.moveRoot(this.renderer); │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Geometry.LinearRing │ │ │ │ + * │ │ │ │ + * A Linear Ring is a special LineString which is closed. It closes itself │ │ │ │ + * automatically on every addPoint/removePoint by adding a copy of the first │ │ │ │ + * point as the last point. │ │ │ │ + * │ │ │ │ + * Also, as it is the first in the line family to close itself, a getArea() │ │ │ │ + * function is defined to calculate the enclosed area of the linearRing │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Geometry.LineString> │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.LinearRing = OpenLayers.Class( │ │ │ │ + OpenLayers.Geometry.LineString, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null │ │ │ │ + * value means the component types are not restricted. │ │ │ │ + */ │ │ │ │ + componentTypes: ["OpenLayers.Geometry.Point"], │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Geometry.LinearRing │ │ │ │ + * Linear rings are constructed with an array of points. This array │ │ │ │ + * can represent a closed or open ring. If the ring is open (the last │ │ │ │ + * point does not equal the first point), the constructor will close │ │ │ │ + * the ring. If the ring is already closed (the last point does equal │ │ │ │ + * the first point), it will be left closed. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * points - {Array(<OpenLayers.Geometry.Point>)} points │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: addComponent │ │ │ │ + * Adds a point to geometry components. If the point is to be added to │ │ │ │ + * the end of the components array and it is the same as the last point │ │ │ │ + * already in that array, the duplicate point is not added. This has │ │ │ │ + * the effect of closing the ring if it is not already closed, and │ │ │ │ + * doing the right thing if it is already closed. This behavior can │ │ │ │ + * be overridden by calling the method with a non-null index as the │ │ │ │ + * second argument. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * index - {Integer} Index into the array to insert the component │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Was the Point successfully added? │ │ │ │ + */ │ │ │ │ + addComponent: function(point, index) { │ │ │ │ + var added = false; │ │ │ │ + │ │ │ │ + //remove last point │ │ │ │ + var lastPoint = this.components.pop(); │ │ │ │ + │ │ │ │ + // given an index, add the point │ │ │ │ + // without an index only add non-duplicate points │ │ │ │ + if (index != null || !point.equals(lastPoint)) { │ │ │ │ + added = OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, │ │ │ │ + arguments); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: resetRoots │ │ │ │ - * Resets the root nodes back into the layers they belong to. │ │ │ │ - */ │ │ │ │ - resetRoots: function() { │ │ │ │ - var layer; │ │ │ │ - for (var i = 0; i < this.layers.length; ++i) { │ │ │ │ - layer = this.layers[i]; │ │ │ │ - if (this.renderer && layer.renderer.getRenderLayerId() == this.id) { │ │ │ │ - this.renderer.moveRoot(layer.renderer); │ │ │ │ + //append copy of first point │ │ │ │ + var firstPoint = this.components[0]; │ │ │ │ + OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, │ │ │ │ + [firstPoint]); │ │ │ │ + │ │ │ │ + return added; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: removeComponent │ │ │ │ + * Removes a point from geometry components. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The component was removed. │ │ │ │ + */ │ │ │ │ + removeComponent: function(point) { │ │ │ │ + var removed = this.components && (this.components.length > 3); │ │ │ │ + if (removed) { │ │ │ │ + //remove last point │ │ │ │ + this.components.pop(); │ │ │ │ + │ │ │ │ + //remove our point │ │ │ │ + OpenLayers.Geometry.Collection.prototype.removeComponent.apply(this, │ │ │ │ + arguments); │ │ │ │ + //append copy of first point │ │ │ │ + var firstPoint = this.components[0]; │ │ │ │ + OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, │ │ │ │ + [firstPoint]); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + return removed; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleChangeLayer │ │ │ │ - * Event handler for the map's changelayer event. We need to rebuild │ │ │ │ - * this container's layer dom if order of one of its layers changes. │ │ │ │ - * This handler is added with the setMap method, and removed with the │ │ │ │ - * removeMap method. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} │ │ │ │ - */ │ │ │ │ - handleChangeLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (evt.property == "order" && │ │ │ │ - OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ - this.resetRoots(); │ │ │ │ - this.collectRoots(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: move │ │ │ │ + * Moves a geometry by the given displacement along positive x and y axes. │ │ │ │ + * This modifies the position of the geometry and clears the cached │ │ │ │ + * bounds. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Float} Distance to move geometry in positive x direction. │ │ │ │ + * y - {Float} Distance to move geometry in positive y direction. │ │ │ │ + */ │ │ │ │ + move: function(x, y) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len - 1; i++) { │ │ │ │ + this.components[i].move(x, y); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * APIMethod: rotate │ │ │ │ + * Rotate a geometry around some origin │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * angle - {Float} Rotation angle in degrees (measured counterclockwise │ │ │ │ + * from the positive x-axis) │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} Center point for the rotation │ │ │ │ + */ │ │ │ │ + rotate: function(angle, origin) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len - 1; ++i) { │ │ │ │ + this.components[i].rotate(angle, origin); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: resize │ │ │ │ + * Resize a geometry relative to some origin. Use this method to apply │ │ │ │ + * a uniform scaling to a geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * scale - {Float} Factor by which to scale the geometry. A scale of 2 │ │ │ │ + * doubles the size of the geometry in each dimension │ │ │ │ + * (lines, for example, will be twice as long, and polygons │ │ │ │ + * will have four times the area). │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing │ │ │ │ + * ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} - The current geometry. │ │ │ │ + */ │ │ │ │ + resize: function(scale, origin, ratio) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len - 1; ++i) { │ │ │ │ + this.components[i].resize(scale, origin, ratio); │ │ │ │ + } │ │ │ │ + return this; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: transform │ │ │ │ + * Reproject the components geometry from source to dest. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * source - {<OpenLayers.Projection>} │ │ │ │ + * dest - {<OpenLayers.Projection>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} │ │ │ │ + */ │ │ │ │ + transform: function(source, dest) { │ │ │ │ + if (source && dest) { │ │ │ │ + for (var i = 0, len = this.components.length; i < len - 1; i++) { │ │ │ │ + var component = this.components[i]; │ │ │ │ + component.transform(source, dest); │ │ │ │ + } │ │ │ │ + this.bounds = null; │ │ │ │ + } │ │ │ │ + return this; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getCentroid │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ + */ │ │ │ │ + getCentroid: function() { │ │ │ │ + if (this.components) { │ │ │ │ + var len = this.components.length; │ │ │ │ + if (len > 0 && len <= 2) { │ │ │ │ + return this.components[0].clone(); │ │ │ │ + } else if (len > 2) { │ │ │ │ + var sumX = 0.0; │ │ │ │ + var sumY = 0.0; │ │ │ │ + var x0 = this.components[0].x; │ │ │ │ + var y0 = this.components[0].y; │ │ │ │ + var area = -1 * this.getArea(); │ │ │ │ + if (area != 0) { │ │ │ │ + for (var i = 0; i < len - 1; i++) { │ │ │ │ + var b = this.components[i]; │ │ │ │ + var c = this.components[i + 1]; │ │ │ │ + sumX += (b.x + c.x - 2 * x0) * ((b.x - x0) * (c.y - y0) - (c.x - x0) * (b.y - y0)); │ │ │ │ + sumY += (b.y + c.y - 2 * y0) * ((b.x - x0) * (c.y - y0) - (c.x - x0) * (b.y - y0)); │ │ │ │ + } │ │ │ │ + var x = x0 + sumX / (6 * area); │ │ │ │ + var y = y0 + sumY / (6 * area); │ │ │ │ + } else { │ │ │ │ + for (var i = 0; i < len - 1; i++) { │ │ │ │ + sumX += this.components[i].x; │ │ │ │ + sumY += this.components[i].y; │ │ │ │ + } │ │ │ │ + var x = sumX / (len - 1); │ │ │ │ + var y = sumY / (len - 1); │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Point(x, y); │ │ │ │ + } else { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getArea │ │ │ │ + * Note - The area is positive if the ring is oriented CW, otherwise │ │ │ │ + * it will be negative. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Float} The signed area for a ring. │ │ │ │ + */ │ │ │ │ + getArea: function() { │ │ │ │ + var area = 0.0; │ │ │ │ + if (this.components && (this.components.length > 2)) { │ │ │ │ + var sum = 0.0; │ │ │ │ + for (var i = 0, len = this.components.length; i < len - 1; i++) { │ │ │ │ + var b = this.components[i]; │ │ │ │ + var c = this.components[i + 1]; │ │ │ │ + sum += (b.x + c.x) * (c.y - b.y); │ │ │ │ + } │ │ │ │ + area = -sum / 2.0; │ │ │ │ + } │ │ │ │ + return area; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getGeodesicArea │ │ │ │ + * Calculate the approximate area of the polygon were it projected onto │ │ │ │ + * the earth. Note that this area will be positive if ring is oriented │ │ │ │ + * clockwise, otherwise it will be negative. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ + * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ + * assumed. │ │ │ │ + * │ │ │ │ + * Reference: │ │ │ │ + * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for │ │ │ │ + * Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion │ │ │ │ + * Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {float} The approximate signed geodesic area of the polygon in square │ │ │ │ + * meters. │ │ │ │ + */ │ │ │ │ + getGeodesicArea: function(projection) { │ │ │ │ + var ring = this; // so we can work with a clone if needed │ │ │ │ + if (projection) { │ │ │ │ + var gg = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + if (!gg.equals(projection)) { │ │ │ │ + ring = this.clone().transform(projection, gg); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var area = 0.0; │ │ │ │ + var len = ring.components && ring.components.length; │ │ │ │ + if (len > 2) { │ │ │ │ + var p1, p2; │ │ │ │ + for (var i = 0; i < len - 1; i++) { │ │ │ │ + p1 = ring.components[i]; │ │ │ │ + p2 = ring.components[i + 1]; │ │ │ │ + area += OpenLayers.Util.rad(p2.x - p1.x) * │ │ │ │ + (2 + Math.sin(OpenLayers.Util.rad(p1.y)) + │ │ │ │ + Math.sin(OpenLayers.Util.rad(p2.y))); │ │ │ │ + } │ │ │ │ + area = area * 6378137.0 * 6378137.0 / 2.0; │ │ │ │ + } │ │ │ │ + return area; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: containsPoint │ │ │ │ + * Test if a point is inside a linear ring. For the case where a point │ │ │ │ + * is coincident with a linear ring edge, returns 1. Otherwise, │ │ │ │ + * returns boolean. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean | Number} The point is inside the linear ring. Returns 1 if │ │ │ │ + * the point is coincident with an edge. Returns boolean otherwise. │ │ │ │ + */ │ │ │ │ + containsPoint: function(point) { │ │ │ │ + var approx = OpenLayers.Number.limitSigDigs; │ │ │ │ + var digs = 14; │ │ │ │ + var px = approx(point.x, digs); │ │ │ │ + var py = approx(point.y, digs); │ │ │ │ + │ │ │ │ + function getX(y, x1, y1, x2, y2) { │ │ │ │ + return (y - y2) * ((x2 - x1) / (y2 - y1)) + x2; │ │ │ │ + } │ │ │ │ + var numSeg = this.components.length - 1; │ │ │ │ + var start, end, x1, y1, x2, y2, cx, cy; │ │ │ │ + var crosses = 0; │ │ │ │ + for (var i = 0; i < numSeg; ++i) { │ │ │ │ + start = this.components[i]; │ │ │ │ + x1 = approx(start.x, digs); │ │ │ │ + y1 = approx(start.y, digs); │ │ │ │ + end = this.components[i + 1]; │ │ │ │ + x2 = approx(end.x, digs); │ │ │ │ + y2 = approx(end.y, digs); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * The following conditions enforce five edge-crossing rules: │ │ │ │ + * 1. points coincident with edges are considered contained; │ │ │ │ + * 2. an upward edge includes its starting endpoint, and │ │ │ │ + * excludes its final endpoint; │ │ │ │ + * 3. a downward edge excludes its starting endpoint, and │ │ │ │ + * includes its final endpoint; │ │ │ │ + * 4. horizontal edges are excluded; and │ │ │ │ + * 5. the edge-ray intersection point must be strictly right │ │ │ │ + * of the point P. │ │ │ │ + */ │ │ │ │ + if (y1 == y2) { │ │ │ │ + // horizontal edge │ │ │ │ + if (py == y1) { │ │ │ │ + // point on horizontal line │ │ │ │ + if (x1 <= x2 && (px >= x1 && px <= x2) || // right or vert │ │ │ │ + x1 >= x2 && (px <= x1 && px >= x2)) { // left or vert │ │ │ │ + // point on edge │ │ │ │ + crosses = -1; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // ignore other horizontal edges │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + cx = approx(getX(py, x1, y1, x2, y2), digs); │ │ │ │ + if (cx == px) { │ │ │ │ + // point on line │ │ │ │ + if (y1 < y2 && (py >= y1 && py <= y2) || // upward │ │ │ │ + y1 > y2 && (py <= y1 && py >= y2)) { // downward │ │ │ │ + // point on edge │ │ │ │ + crosses = -1; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (cx <= px) { │ │ │ │ + // no crossing to the right │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + if (x1 != x2 && (cx < Math.min(x1, x2) || cx > Math.max(x1, x2))) { │ │ │ │ + // no crossing │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ + if (y1 < y2 && (py >= y1 && py < y2) || // upward │ │ │ │ + y1 > y2 && (py < y1 && py >= y2)) { // downward │ │ │ │ + ++crosses; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var contained = (crosses == -1) ? │ │ │ │ + // on edge │ │ │ │ + 1 : │ │ │ │ + // even (out) or odd (in) │ │ │ │ + !!(crosses & 1); │ │ │ │ + │ │ │ │ + return contained; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: intersects │ │ │ │ + * Determine if the input geometry intersects this one. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The input geometry intersects this one. │ │ │ │ + */ │ │ │ │ + intersects: function(geometry) { │ │ │ │ + var intersect = false; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + intersect = this.containsPoint(geometry); │ │ │ │ + } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") { │ │ │ │ + intersect = geometry.intersects(this); │ │ │ │ + } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ + intersect = OpenLayers.Geometry.LineString.prototype.intersects.apply( │ │ │ │ + this, [geometry] │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + // check for component intersections │ │ │ │ + for (var i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ + intersect = geometry.components[i].intersects(this); │ │ │ │ + if (intersect) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return intersect; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: getVertices │ │ │ │ + * Return a list of all points in this geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ + * endpoints. If false, for lines, only vertices that are not │ │ │ │ + * endpoints will be returned. If not provided, all vertices will │ │ │ │ + * be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} A list of all vertices in the geometry. │ │ │ │ + */ │ │ │ │ + getVertices: function(nodes) { │ │ │ │ + return (nodes === true) ? [] : this.components.slice(0, this.components.length - 1); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.LinearRing" │ │ │ │ + }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Control/SelectFeature.js │ │ │ │ + OpenLayers/Geometry/Polygon.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Handler/Feature.js │ │ │ │ - * @requires OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ + * @requires OpenLayers/Geometry/Collection.js │ │ │ │ + * @requires OpenLayers/Geometry/LinearRing.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Control.SelectFeature │ │ │ │ - * The SelectFeature control selects vector features from a given layer on │ │ │ │ - * click or hover. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Geometry.Polygon │ │ │ │ + * Polygon is a collection of Geometry.LinearRings. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ + * - <OpenLayers.Geometry.Collection> │ │ │ │ + * - <OpenLayers.Geometry> │ │ │ │ */ │ │ │ │ -OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ +OpenLayers.Geometry.Polygon = OpenLayers.Class( │ │ │ │ + OpenLayers.Geometry.Collection, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * Register a listener for a particular event with the following syntax: │ │ │ │ - * (code) │ │ │ │ - * control.events.register(type, obj, listener); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ - * beforefeaturehighlighted - Triggered before a feature is highlighted │ │ │ │ - * featurehighlighted - Triggered when a feature is highlighted │ │ │ │ - * featureunhighlighted - Triggered when a feature is unhighlighted │ │ │ │ - * boxselectionstart - Triggered before box selection starts │ │ │ │ - * boxselectionend - Triggered after box selection ends │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null value means the │ │ │ │ + * component types are not restricted. │ │ │ │ + */ │ │ │ │ + componentTypes: ["OpenLayers.Geometry.LinearRing"], │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: multipleKey │ │ │ │ - * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ - * the <multiple> property to true. Default is null. │ │ │ │ - */ │ │ │ │ - multipleKey: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Geometry.Polygon │ │ │ │ + * Constructor for a Polygon geometry. │ │ │ │ + * The first ring (this.component[0])is the outer bounds of the polygon and │ │ │ │ + * all subsequent rings (this.component[1-n]) are internal holes. │ │ │ │ + * │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry.LinearRing>)} │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: toggleKey │ │ │ │ - * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ - * the <toggle> property to true. Default is null. │ │ │ │ - */ │ │ │ │ - toggleKey: null, │ │ │ │ + /** │ │ │ │ + * APIMethod: getArea │ │ │ │ + * Calculated by subtracting the areas of the internal holes from the │ │ │ │ + * area of the outer hole. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {float} The area of the geometry │ │ │ │ + */ │ │ │ │ + getArea: function() { │ │ │ │ + var area = 0.0; │ │ │ │ + if (this.components && (this.components.length > 0)) { │ │ │ │ + area += Math.abs(this.components[0].getArea()); │ │ │ │ + for (var i = 1, len = this.components.length; i < len; i++) { │ │ │ │ + area -= Math.abs(this.components[i].getArea()); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return area; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: multiple │ │ │ │ - * {Boolean} Allow selection of multiple geometries. Default is false. │ │ │ │ - */ │ │ │ │ - multiple: false, │ │ │ │ + /** │ │ │ │ + * APIMethod: getGeodesicArea │ │ │ │ + * Calculate the approximate area of the polygon were it projected onto │ │ │ │ + * the earth. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ + * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ + * assumed. │ │ │ │ + * │ │ │ │ + * Reference: │ │ │ │ + * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for │ │ │ │ + * Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion │ │ │ │ + * Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {float} The approximate geodesic area of the polygon in square meters. │ │ │ │ + */ │ │ │ │ + getGeodesicArea: function(projection) { │ │ │ │ + var area = 0.0; │ │ │ │ + if (this.components && (this.components.length > 0)) { │ │ │ │ + area += Math.abs(this.components[0].getGeodesicArea(projection)); │ │ │ │ + for (var i = 1, len = this.components.length; i < len; i++) { │ │ │ │ + area -= Math.abs(this.components[i].getGeodesicArea(projection)); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return area; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: clickout │ │ │ │ - * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ - * Default is true. │ │ │ │ - */ │ │ │ │ - clickout: true, │ │ │ │ + /** │ │ │ │ + * Method: containsPoint │ │ │ │ + * Test if a point is inside a polygon. Points on a polygon edge are │ │ │ │ + * considered inside. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean | Number} The point is inside the polygon. Returns 1 if the │ │ │ │ + * point is on an edge. Returns boolean otherwise. │ │ │ │ + */ │ │ │ │ + containsPoint: function(point) { │ │ │ │ + var numRings = this.components.length; │ │ │ │ + var contained = false; │ │ │ │ + if (numRings > 0) { │ │ │ │ + // check exterior ring - 1 means on edge, boolean otherwise │ │ │ │ + contained = this.components[0].containsPoint(point); │ │ │ │ + if (contained !== 1) { │ │ │ │ + if (contained && numRings > 1) { │ │ │ │ + // check interior rings │ │ │ │ + var hole; │ │ │ │ + for (var i = 1; i < numRings; ++i) { │ │ │ │ + hole = this.components[i].containsPoint(point); │ │ │ │ + if (hole) { │ │ │ │ + if (hole === 1) { │ │ │ │ + // on edge │ │ │ │ + contained = 1; │ │ │ │ + } else { │ │ │ │ + // in hole │ │ │ │ + contained = false; │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return contained; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: toggle │ │ │ │ - * {Boolean} Unselect a selected feature on click. Default is false. Only │ │ │ │ - * has meaning if hover is false. │ │ │ │ - */ │ │ │ │ - toggle: false, │ │ │ │ + /** │ │ │ │ + * APIMethod: intersects │ │ │ │ + * Determine if the input geometry intersects this one. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The input geometry intersects this one. │ │ │ │ + */ │ │ │ │ + intersects: function(geometry) { │ │ │ │ + var intersect = false; │ │ │ │ + var i, len; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + intersect = this.containsPoint(geometry); │ │ │ │ + } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" || │ │ │ │ + geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ + // check if rings/linestrings intersect │ │ │ │ + for (i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ + intersect = geometry.intersects(this.components[i]); │ │ │ │ + if (intersect) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!intersect) { │ │ │ │ + // check if this poly contains points of the ring/linestring │ │ │ │ + for (i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ + intersect = this.containsPoint(geometry.components[i]); │ │ │ │ + if (intersect) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + for (i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ + intersect = this.intersects(geometry.components[i]); │ │ │ │ + if (intersect) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // check case where this poly is wholly contained by another │ │ │ │ + if (!intersect && geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") { │ │ │ │ + // exterior ring points will be contained in the other geometry │ │ │ │ + var ring = this.components[0]; │ │ │ │ + for (i = 0, len = ring.components.length; i < len; ++i) { │ │ │ │ + intersect = geometry.containsPoint(ring.components[i]); │ │ │ │ + if (intersect) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return intersect; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: hover │ │ │ │ - * {Boolean} Select on mouse over and deselect on mouse out. If true, this │ │ │ │ - * ignores clicks and only listens to mouse moves. │ │ │ │ - */ │ │ │ │ - hover: false, │ │ │ │ + /** │ │ │ │ + * APIMethod: distanceTo │ │ │ │ + * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ + * options - {Object} Optional properties for configuring the distance │ │ │ │ + * calculation. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * details - {Boolean} Return details from the distance calculation. │ │ │ │ + * Default is false. │ │ │ │ + * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ + * nearest edge of the target geometry. Default is true. If true, │ │ │ │ + * calling distanceTo from a geometry that is wholly contained within │ │ │ │ + * the target will result in a non-zero distance. If false, whenever │ │ │ │ + * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ + * details cannot be returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number | Object} The distance between this geometry and the target. │ │ │ │ + * If details is true, the return will be an object with distance, │ │ │ │ + * x0, y0, x1, and y1 properties. The x0 and y0 properties represent │ │ │ │ + * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ + * properties represent the coordinates of the closest point on the │ │ │ │ + * target geometry. │ │ │ │ + */ │ │ │ │ + distanceTo: function(geometry, options) { │ │ │ │ + var edge = !(options && options.edge === false); │ │ │ │ + var result; │ │ │ │ + // this is the case where we might not be looking for distance to edge │ │ │ │ + if (!edge && this.intersects(geometry)) { │ │ │ │ + result = 0; │ │ │ │ + } else { │ │ │ │ + result = OpenLayers.Geometry.Collection.prototype.distanceTo.apply( │ │ │ │ + this, [geometry, options] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return result; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: highlightOnly │ │ │ │ - * {Boolean} If true do not actually select features (that is place them in │ │ │ │ - * the layer's selected features array), just highlight them. This property │ │ │ │ - * has no effect if hover is false. Defaults to false. │ │ │ │ - */ │ │ │ │ - highlightOnly: false, │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.Polygon" │ │ │ │ + }); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: box │ │ │ │ - * {Boolean} Allow feature selection by drawing a box. │ │ │ │ - */ │ │ │ │ - box: false, │ │ │ │ +/** │ │ │ │ + * APIMethod: createRegularPolygon │ │ │ │ + * Create a regular polygon around a radius. Useful for creating circles │ │ │ │ + * and the like. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * origin - {<OpenLayers.Geometry.Point>} center of polygon. │ │ │ │ + * radius - {Float} distance to vertex, in map units. │ │ │ │ + * sides - {Integer} Number of sides. 20 approximates a circle. │ │ │ │ + * rotation - {Float} original angle of rotation, in degrees. │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.Polygon.createRegularPolygon = function(origin, radius, sides, rotation) { │ │ │ │ + var angle = Math.PI * ((1 / sides) - (1 / 2)); │ │ │ │ + if (rotation) { │ │ │ │ + angle += (rotation / 180) * Math.PI; │ │ │ │ + } │ │ │ │ + var rotatedAngle, x, y; │ │ │ │ + var points = []; │ │ │ │ + for (var i = 0; i < sides; ++i) { │ │ │ │ + rotatedAngle = angle + (i * 2 * Math.PI / sides); │ │ │ │ + x = origin.x + (radius * Math.cos(rotatedAngle)); │ │ │ │ + y = origin.y + (radius * Math.sin(rotatedAngle)); │ │ │ │ + points.push(new OpenLayers.Geometry.Point(x, y)); │ │ │ │ + } │ │ │ │ + var ring = new OpenLayers.Geometry.LinearRing(points); │ │ │ │ + return new OpenLayers.Geometry.Polygon([ring]); │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Geometry/MultiPolygon.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: onBeforeSelect │ │ │ │ - * {Function} Optional function to be called before a feature is selected. │ │ │ │ - * The function should expect to be called with a feature. │ │ │ │ - */ │ │ │ │ - onBeforeSelect: function() {}, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: onSelect │ │ │ │ - * {Function} Optional function to be called when a feature is selected. │ │ │ │ - * The function should expect to be called with a feature. │ │ │ │ - */ │ │ │ │ - onSelect: function() {}, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Geometry/Collection.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: onUnselect │ │ │ │ - * {Function} Optional function to be called when a feature is unselected. │ │ │ │ - * The function should expect to be called with a feature. │ │ │ │ - */ │ │ │ │ - onUnselect: function() {}, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Geometry.MultiPolygon │ │ │ │ + * MultiPolygon is a geometry with multiple <OpenLayers.Geometry.Polygon> │ │ │ │ + * components. Create a new instance with the <OpenLayers.Geometry.MultiPolygon> │ │ │ │ + * constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Geometry.Collection> │ │ │ │ + */ │ │ │ │ +OpenLayers.Geometry.MultiPolygon = OpenLayers.Class( │ │ │ │ + OpenLayers.Geometry.Collection, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: scope │ │ │ │ - * {Object} The scope to use with the onBeforeSelect, onSelect, onUnselect │ │ │ │ - * callbacks. If null the scope will be this control. │ │ │ │ - */ │ │ │ │ - scope: null, │ │ │ │ + /** │ │ │ │ + * Property: componentTypes │ │ │ │ + * {Array(String)} An array of class names representing the types of │ │ │ │ + * components that the collection can include. A null value means the │ │ │ │ + * component types are not restricted. │ │ │ │ + */ │ │ │ │ + componentTypes: ["OpenLayers.Geometry.Polygon"], │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: geometryTypes │ │ │ │ - * {Array(String)} To restrict selecting to a limited set of geometry types, │ │ │ │ - * send a list of strings corresponding to the geometry class names. │ │ │ │ - */ │ │ │ │ - geometryTypes: null, │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Geometry.MultiPolygon │ │ │ │ + * Create a new MultiPolygon geometry │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * components - {Array(<OpenLayers.Geometry.Polygon>)} An array of polygons │ │ │ │ + * used to generate the MultiPolygon │ │ │ │ + * │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The vector layer with a common renderer │ │ │ │ - * root for all layers this control is configured with (if an array of │ │ │ │ - * layers was passed to the constructor), or the vector layer the control │ │ │ │ - * was configured with (if a single layer was passed to the constructor). │ │ │ │ - */ │ │ │ │ - layer: null, │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.MultiPolygon" │ │ │ │ + }); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Format/GeoJSON.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: layers │ │ │ │ - * {Array(<OpenLayers.Layer.Vector>)} The layers this control will work on, │ │ │ │ - * or null if the control was configured with a single layer │ │ │ │ - */ │ │ │ │ - layers: null, │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: callbacks │ │ │ │ - * {Object} The functions that are sent to the handlers.feature for callback │ │ │ │ - */ │ │ │ │ - callbacks: null, │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Format/JSON.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * @requires OpenLayers/Geometry/MultiPoint.js │ │ │ │ + * @requires OpenLayers/Geometry/LineString.js │ │ │ │ + * @requires OpenLayers/Geometry/MultiLineString.js │ │ │ │ + * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + * @requires OpenLayers/Geometry/MultiPolygon.js │ │ │ │ + * @requires OpenLayers/Console.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: selectStyle │ │ │ │ - * {Object} Hash of styles │ │ │ │ - */ │ │ │ │ - selectStyle: null, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.GeoJSON │ │ │ │ + * Read and write GeoJSON. Create a new parser with the │ │ │ │ + * <OpenLayers.Format.GeoJSON> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format.JSON> │ │ │ │ + */ │ │ │ │ +OpenLayers.Format.GeoJSON = OpenLayers.Class(OpenLayers.Format.JSON, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: renderIntent │ │ │ │ - * {String} key used to retrieve the select style from the layer's │ │ │ │ - * style map. │ │ │ │ + * APIProperty: ignoreExtraDims │ │ │ │ + * {Boolean} Ignore dimensions higher than 2 when reading geometry │ │ │ │ + * coordinates. │ │ │ │ */ │ │ │ │ - renderIntent: "select", │ │ │ │ + ignoreExtraDims: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: handlers │ │ │ │ - * {Object} Object with references to multiple <OpenLayers.Handler> │ │ │ │ - * instances. │ │ │ │ + * Constructor: OpenLayers.Format.GeoJSON │ │ │ │ + * Create a new parser for GeoJSON. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - handlers: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.SelectFeature │ │ │ │ - * Create a new control for selecting features. │ │ │ │ + * APIMethod: read │ │ │ │ + * Deserialize a GeoJSON string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. The │ │ │ │ - * layer(s) this control will select features from. │ │ │ │ - * options - {Object} │ │ │ │ + * json - {String} A GeoJSON string │ │ │ │ + * type - {String} Optional string that determines the structure of │ │ │ │ + * the output. Supported values are "Geometry", "Feature", and │ │ │ │ + * "FeatureCollection". If absent or null, a default of │ │ │ │ + * "FeatureCollection" is assumed. │ │ │ │ + * 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} The return depends on the value of the type argument. If type │ │ │ │ + * is "FeatureCollection" (the default), the return will be an array │ │ │ │ + * of <OpenLayers.Feature.Vector>. If type is "Geometry", the input json │ │ │ │ + * must represent a single geometry, and the return will be an │ │ │ │ + * <OpenLayers.Geometry>. If type is "Feature", the input json must │ │ │ │ + * represent a single feature, and the return will be an │ │ │ │ + * <OpenLayers.Feature.Vector>. │ │ │ │ */ │ │ │ │ - initialize: function(layers, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - │ │ │ │ - if (this.scope === null) { │ │ │ │ - this.scope = this; │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - var callbacks = { │ │ │ │ - click: this.clickFeature, │ │ │ │ - clickout: this.clickoutFeature │ │ │ │ - }; │ │ │ │ - if (this.hover) { │ │ │ │ - callbacks.over = this.overFeature; │ │ │ │ - callbacks.out = this.outFeature; │ │ │ │ + read: function(json, type, filter) { │ │ │ │ + type = (type) ? type : "FeatureCollection"; │ │ │ │ + var results = null; │ │ │ │ + var obj = null; │ │ │ │ + if (typeof json == "string") { │ │ │ │ + obj = OpenLayers.Format.JSON.prototype.read.apply(this, │ │ │ │ + [json, filter]); │ │ │ │ + } else { │ │ │ │ + obj = json; │ │ │ │ } │ │ │ │ - │ │ │ │ - this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ - this.handlers = { │ │ │ │ - feature: new OpenLayers.Handler.Feature( │ │ │ │ - this, this.layer, this.callbacks, { │ │ │ │ - geometryTypes: this.geometryTypes │ │ │ │ - } │ │ │ │ - ) │ │ │ │ - }; │ │ │ │ - │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box = new OpenLayers.Handler.Box( │ │ │ │ - this, { │ │ │ │ - done: this.selectBox │ │ │ │ - }, { │ │ │ │ - boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ - } │ │ │ │ - ); │ │ │ │ + if (!obj) { │ │ │ │ + OpenLayers.Console.error("Bad JSON: " + json); │ │ │ │ + } else if (typeof(obj.type) != "string") { │ │ │ │ + OpenLayers.Console.error("Bad GeoJSON - no type: " + json); │ │ │ │ + } else if (this.isValidType(obj, type)) { │ │ │ │ + switch (type) { │ │ │ │ + case "Geometry": │ │ │ │ + try { │ │ │ │ + results = this.parseGeometry(obj); │ │ │ │ + } catch (err) { │ │ │ │ + OpenLayers.Console.error(err); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "Feature": │ │ │ │ + try { │ │ │ │ + results = this.parseFeature(obj); │ │ │ │ + results.type = "Feature"; │ │ │ │ + } catch (err) { │ │ │ │ + OpenLayers.Console.error(err); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "FeatureCollection": │ │ │ │ + // for type FeatureCollection, we allow input to be any type │ │ │ │ + results = []; │ │ │ │ + switch (obj.type) { │ │ │ │ + case "Feature": │ │ │ │ + try { │ │ │ │ + results.push(this.parseFeature(obj)); │ │ │ │ + } catch (err) { │ │ │ │ + results = null; │ │ │ │ + OpenLayers.Console.error(err); │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "FeatureCollection": │ │ │ │ + for (var i = 0, len = obj.features.length; i < len; ++i) { │ │ │ │ + try { │ │ │ │ + results.push(this.parseFeature(obj.features[i])); │ │ │ │ + } catch (err) { │ │ │ │ + results = null; │ │ │ │ + OpenLayers.Console.error(err); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + try { │ │ │ │ + var geom = this.parseGeometry(obj); │ │ │ │ + results.push(new OpenLayers.Feature.Vector(geom)); │ │ │ │ + } catch (err) { │ │ │ │ + results = null; │ │ │ │ + OpenLayers.Console.error(err); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + } │ │ │ │ } │ │ │ │ + return results; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: initLayer │ │ │ │ - * Assign the layer property. If layers is an array, we need to use │ │ │ │ - * a RootContainer. │ │ │ │ + * Method: isValidType │ │ │ │ + * Check if a GeoJSON object is a valid representative of the given type. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The object is valid GeoJSON object of the given type. │ │ │ │ */ │ │ │ │ - initLayer: function(layers) { │ │ │ │ - if (OpenLayers.Util.isArray(layers)) { │ │ │ │ - this.layers = layers; │ │ │ │ - this.layer = new OpenLayers.Layer.Vector.RootContainer( │ │ │ │ - this.id + "_container", { │ │ │ │ - layers: layers │ │ │ │ + isValidType: function(obj, type) { │ │ │ │ + var valid = false; │ │ │ │ + switch (type) { │ │ │ │ + case "Geometry": │ │ │ │ + if (OpenLayers.Util.indexOf( │ │ │ │ + ["Point", "MultiPoint", "LineString", "MultiLineString", │ │ │ │ + "Polygon", "MultiPolygon", "Box", "GeometryCollection" │ │ │ │ + ], │ │ │ │ + obj.type) == -1) { │ │ │ │ + // unsupported geometry type │ │ │ │ + OpenLayers.Console.error("Unsupported geometry type: " + │ │ │ │ + obj.type); │ │ │ │ + } else { │ │ │ │ + valid = true; │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "FeatureCollection": │ │ │ │ + // allow for any type to be converted to a feature collection │ │ │ │ + valid = true; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + // for Feature types must match │ │ │ │ + if (obj.type == type) { │ │ │ │ + valid = true; │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.error("Cannot convert types from " + │ │ │ │ + obj.type + " to " + type); │ │ │ │ } │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - this.layer = layers; │ │ │ │ } │ │ │ │ + return valid; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ + * Method: parseFeature │ │ │ │ + * Convert a feature object from GeoJSON into an │ │ │ │ + * <OpenLayers.Feature.Vector>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} An object created from a GeoJSON object │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} A feature. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active && this.layers) { │ │ │ │ - this.map.removeLayer(this.layer); │ │ │ │ + parseFeature: function(obj) { │ │ │ │ + var feature, geometry, attributes, bbox; │ │ │ │ + attributes = (obj.properties) ? obj.properties : {}; │ │ │ │ + bbox = (obj.geometry && obj.geometry.bbox) || obj.bbox; │ │ │ │ + try { │ │ │ │ + geometry = this.parseGeometry(obj.geometry); │ │ │ │ + } catch (err) { │ │ │ │ + // deal with bad geometries │ │ │ │ + throw err; │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy(); │ │ │ │ + feature = new OpenLayers.Feature.Vector(geometry, attributes); │ │ │ │ + if (bbox) { │ │ │ │ + feature.bounds = OpenLayers.Bounds.fromArray(bbox); │ │ │ │ + } │ │ │ │ + if (obj.id) { │ │ │ │ + feature.fid = obj.id; │ │ │ │ } │ │ │ │ + return feature; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activates the control. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The control was effectively activated. │ │ │ │ + * Method: parseGeometry │ │ │ │ + * Convert a geometry object from GeoJSON into an <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} An object created from a GeoJSON object │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.addLayer(this.layer); │ │ │ │ + parseGeometry: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + var geometry, collection = false; │ │ │ │ + if (obj.type == "GeometryCollection") { │ │ │ │ + if (!(OpenLayers.Util.isArray(obj.geometries))) { │ │ │ │ + throw "GeometryCollection must have geometries array: " + obj; │ │ │ │ } │ │ │ │ - this.handlers.feature.activate(); │ │ │ │ - if (this.box && this.handlers.box) { │ │ │ │ - this.handlers.box.activate(); │ │ │ │ + var numGeom = obj.geometries.length; │ │ │ │ + var components = new Array(numGeom); │ │ │ │ + for (var i = 0; i < numGeom; ++i) { │ │ │ │ + components[i] = this.parseGeometry.apply( │ │ │ │ + this, [obj.geometries[i]] │ │ │ │ + ); │ │ │ │ } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivates the control. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The control was effectively deactivated. │ │ │ │ - */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.feature.deactivate(); │ │ │ │ - if (this.handlers.box) { │ │ │ │ - this.handlers.box.deactivate(); │ │ │ │ + geometry = new OpenLayers.Geometry.Collection(components); │ │ │ │ + collection = true; │ │ │ │ + } else { │ │ │ │ + if (!(OpenLayers.Util.isArray(obj.coordinates))) { │ │ │ │ + throw "Geometry must have coordinates array: " + obj; │ │ │ │ } │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.removeLayer(this.layer); │ │ │ │ + if (!this.parseCoords[obj.type.toLowerCase()]) { │ │ │ │ + throw "Unsupported geometry type: " + obj.type; │ │ │ │ + } │ │ │ │ + try { │ │ │ │ + geometry = this.parseCoords[obj.type.toLowerCase()].apply( │ │ │ │ + this, [obj.coordinates] │ │ │ │ + ); │ │ │ │ + } catch (err) { │ │ │ │ + // deal with bad coordinates │ │ │ │ + throw err; │ │ │ │ } │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ - this, arguments │ │ │ │ - ); │ │ │ │ + // We don't reproject collections because the children are reprojected │ │ │ │ + // for us when they are created. │ │ │ │ + if (this.internalProjection && this.externalProjection && !collection) { │ │ │ │ + geometry.transform(this.externalProjection, │ │ │ │ + this.internalProjection); │ │ │ │ + } │ │ │ │ + return geometry; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: unselectAll │ │ │ │ - * Unselect all selected features. To unselect all except for a single │ │ │ │ - * feature, set the options.except property to the feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional configuration object. │ │ │ │ + * Property: parseCoords │ │ │ │ + * Object with properties corresponding to the GeoJSON geometry types. │ │ │ │ + * Property values are functions that do the actual parsing. │ │ │ │ */ │ │ │ │ - unselectAll: function(options) { │ │ │ │ - // we'll want an option to supress notification here │ │ │ │ - var layers = this.layers || [this.layer], │ │ │ │ - layer, feature, l, numExcept; │ │ │ │ - for (l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - numExcept = 0; │ │ │ │ - //layer.selectedFeatures is null when layer is destroyed and │ │ │ │ - //one of it's preremovelayer listener calls setLayer │ │ │ │ - //with another layer on this control │ │ │ │ - if (layer.selectedFeatures != null) { │ │ │ │ - while (layer.selectedFeatures.length > numExcept) { │ │ │ │ - feature = layer.selectedFeatures[numExcept]; │ │ │ │ - if (!options || options.except != feature) { │ │ │ │ - this.unselect(feature); │ │ │ │ - } else { │ │ │ │ - ++numExcept; │ │ │ │ - } │ │ │ │ + parseCoords: { │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.point │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "point": function(array) { │ │ │ │ + if (this.ignoreExtraDims == false && │ │ │ │ + array.length != 2) { │ │ │ │ + throw "Only 2D points are supported: " + array; │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Point(array[0], array[1]); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.multipoint │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "multipoint": function(array) { │ │ │ │ + var points = []; │ │ │ │ + var p = null; │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + try { │ │ │ │ + p = this.parseCoords["point"].apply(this, [array[i]]); │ │ │ │ + } catch (err) { │ │ │ │ + throw err; │ │ │ │ } │ │ │ │ + points.push(p); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + return new OpenLayers.Geometry.MultiPoint(points); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clickFeature │ │ │ │ - * Called on click in a feature │ │ │ │ - * Only responds if this.hover is false. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - clickFeature: function(feature) { │ │ │ │ - if (!this.hover) { │ │ │ │ - var selected = (OpenLayers.Util.indexOf( │ │ │ │ - feature.layer.selectedFeatures, feature) > -1); │ │ │ │ - if (selected) { │ │ │ │ - if (this.toggleSelect()) { │ │ │ │ - this.unselect(feature); │ │ │ │ - } else if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.linestring │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "linestring": function(array) { │ │ │ │ + var points = []; │ │ │ │ + var p = null; │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + try { │ │ │ │ + p = this.parseCoords["point"].apply(this, [array[i]]); │ │ │ │ + } catch (err) { │ │ │ │ + throw err; │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }); │ │ │ │ + points.push(p); │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.LineString(points); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.multilinestring │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "multilinestring": function(array) { │ │ │ │ + var lines = []; │ │ │ │ + var l = null; │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + try { │ │ │ │ + l = this.parseCoords["linestring"].apply(this, [array[i]]); │ │ │ │ + } catch (err) { │ │ │ │ + throw err; │ │ │ │ } │ │ │ │ - this.select(feature); │ │ │ │ + lines.push(l); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + return new OpenLayers.Geometry.MultiLineString(lines); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: multipleSelect │ │ │ │ - * Allow for multiple selected features based on <multiple> property and │ │ │ │ - * <multipleKey> event modifier. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Allow for multiple selected features. │ │ │ │ - */ │ │ │ │ - multipleSelect: function() { │ │ │ │ - return this.multiple || (this.handlers.feature.evt && │ │ │ │ - this.handlers.feature.evt[this.multipleKey]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.polygon │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "polygon": function(array) { │ │ │ │ + var rings = []; │ │ │ │ + var r, l; │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + try { │ │ │ │ + l = this.parseCoords["linestring"].apply(this, [array[i]]); │ │ │ │ + } catch (err) { │ │ │ │ + throw err; │ │ │ │ + } │ │ │ │ + r = new OpenLayers.Geometry.LinearRing(l.components); │ │ │ │ + rings.push(r); │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Polygon(rings); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: toggleSelect │ │ │ │ - * Event should toggle the selected state of a feature based on <toggle> │ │ │ │ - * property and <toggleKey> event modifier. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Toggle the selected state of a feature. │ │ │ │ - */ │ │ │ │ - toggleSelect: function() { │ │ │ │ - return this.toggle || (this.handlers.feature.evt && │ │ │ │ - this.handlers.feature.evt[this.toggleKey]); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.multipolygon │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "multipolygon": function(array) { │ │ │ │ + var polys = []; │ │ │ │ + var p = null; │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + try { │ │ │ │ + p = this.parseCoords["polygon"].apply(this, [array[i]]); │ │ │ │ + } catch (err) { │ │ │ │ + throw err; │ │ │ │ + } │ │ │ │ + polys.push(p); │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.MultiPolygon(polys); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clickoutFeature │ │ │ │ - * Called on click outside a previously clicked (selected) feature. │ │ │ │ - * Only responds if this.hover is false. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ - */ │ │ │ │ - clickoutFeature: function(feature) { │ │ │ │ - if (!this.hover && this.clickout) { │ │ │ │ - this.unselectAll(); │ │ │ │ + /** │ │ │ │ + * Method: parseCoords.box │ │ │ │ + * Convert a coordinate array from GeoJSON into an │ │ │ │ + * <OpenLayers.Geometry>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + */ │ │ │ │ + "box": function(array) { │ │ │ │ + if (array.length != 2) { │ │ │ │ + throw "GeoJSON box coordinates must have 2 elements"; │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Polygon([ │ │ │ │ + new OpenLayers.Geometry.LinearRing([ │ │ │ │ + new OpenLayers.Geometry.Point(array[0][0], array[0][1]), │ │ │ │ + new OpenLayers.Geometry.Point(array[1][0], array[0][1]), │ │ │ │ + new OpenLayers.Geometry.Point(array[1][0], array[1][1]), │ │ │ │ + new OpenLayers.Geometry.Point(array[0][0], array[1][1]), │ │ │ │ + new OpenLayers.Geometry.Point(array[0][0], array[0][1]) │ │ │ │ + ]) │ │ │ │ + ]); │ │ │ │ } │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: overFeature │ │ │ │ - * Called on over a feature. │ │ │ │ - * Only responds if this.hover is true. │ │ │ │ + * APIMethod: write │ │ │ │ + * Serialize a feature, geometry, array of features into a GeoJSON string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * obj - {Object} An <OpenLayers.Feature.Vector>, <OpenLayers.Geometry>, │ │ │ │ + * or an array of features. │ │ │ │ + * pretty - {Boolean} Structure the output with newlines and indentation. │ │ │ │ + * Default is false. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The GeoJSON string representation of the input geometry, │ │ │ │ + * features, or array of features. │ │ │ │ */ │ │ │ │ - overFeature: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - this.highlight(feature); │ │ │ │ - } else if (OpenLayers.Util.indexOf( │ │ │ │ - layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature); │ │ │ │ + write: function(obj, pretty) { │ │ │ │ + var geojson = { │ │ │ │ + "type": null │ │ │ │ + }; │ │ │ │ + if (OpenLayers.Util.isArray(obj)) { │ │ │ │ + geojson.type = "FeatureCollection"; │ │ │ │ + var numFeatures = obj.length; │ │ │ │ + geojson.features = new Array(numFeatures); │ │ │ │ + for (var i = 0; i < numFeatures; ++i) { │ │ │ │ + var element = obj[i]; │ │ │ │ + if (!element instanceof OpenLayers.Feature.Vector) { │ │ │ │ + var msg = "FeatureCollection only supports collections " + │ │ │ │ + "of features: " + element; │ │ │ │ + throw msg; │ │ │ │ + } │ │ │ │ + geojson.features[i] = this.extract.feature.apply( │ │ │ │ + this, [element] │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } else if (obj.CLASS_NAME.indexOf("OpenLayers.Geometry") == 0) { │ │ │ │ + geojson = this.extract.geometry.apply(this, [obj]); │ │ │ │ + } else if (obj instanceof OpenLayers.Feature.Vector) { │ │ │ │ + geojson = this.extract.feature.apply(this, [obj]); │ │ │ │ + if (obj.layer && obj.layer.projection) { │ │ │ │ + geojson.crs = this.createCRSObject(obj); │ │ │ │ } │ │ │ │ } │ │ │ │ + return OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ + [geojson, pretty]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: outFeature │ │ │ │ - * Called on out of a selected feature. │ │ │ │ - * Only responds if this.hover is true. │ │ │ │ + * Method: createCRSObject │ │ │ │ + * Create the CRS object for an object. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * object - {<OpenLayers.Feature.Vector>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object which can be assigned to the crs property │ │ │ │ + * of a GeoJSON object. │ │ │ │ */ │ │ │ │ - outFeature: function(feature) { │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - // we do nothing if we're not the last highlighter of the │ │ │ │ - // feature │ │ │ │ - if (feature._lastHighlighter == this.id) { │ │ │ │ - // if another select control had highlighted the feature before │ │ │ │ - // we did it ourself then we use that control to highlight the │ │ │ │ - // feature as it was before we highlighted it, else we just │ │ │ │ - // unhighlight it │ │ │ │ - if (feature._prevHighlighter && │ │ │ │ - feature._prevHighlighter != this.id) { │ │ │ │ - delete feature._lastHighlighter; │ │ │ │ - var control = this.map.getControl( │ │ │ │ - feature._prevHighlighter); │ │ │ │ - if (control) { │ │ │ │ - control.highlight(feature); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unhighlight(feature); │ │ │ │ + createCRSObject: function(object) { │ │ │ │ + var proj = object.layer.projection.toString(); │ │ │ │ + var crs = {}; │ │ │ │ + if (proj.match(/epsg:/i)) { │ │ │ │ + var code = parseInt(proj.substring(proj.indexOf(":") + 1)); │ │ │ │ + if (code == 4326) { │ │ │ │ + crs = { │ │ │ │ + "type": "name", │ │ │ │ + "properties": { │ │ │ │ + "name": "urn:ogc:def:crs:OGC:1.3:CRS84" │ │ │ │ } │ │ │ │ - } │ │ │ │ + }; │ │ │ │ } else { │ │ │ │ - this.unselect(feature); │ │ │ │ + crs = { │ │ │ │ + "type": "name", │ │ │ │ + "properties": { │ │ │ │ + "name": "EPSG:" + code │ │ │ │ + } │ │ │ │ + }; │ │ │ │ } │ │ │ │ } │ │ │ │ + return crs; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: highlight │ │ │ │ - * Redraw feature with the select style. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * Property: extract │ │ │ │ + * Object with properties corresponding to the GeoJSON types. │ │ │ │ + * Property values are functions that do the actual value extraction. │ │ │ │ */ │ │ │ │ - highlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ - feature._lastHighlighter = this.id; │ │ │ │ - var style = this.selectStyle || this.renderIntent; │ │ │ │ - layer.drawFeature(feature, style); │ │ │ │ - this.events.triggerEvent("featurehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + extract: { │ │ │ │ + /** │ │ │ │ + * Method: extract.feature │ │ │ │ + * Return a partial GeoJSON object representing a single feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object representing the point. │ │ │ │ + */ │ │ │ │ + 'feature': function(feature) { │ │ │ │ + var geom = this.extract.geometry.apply(this, [feature.geometry]); │ │ │ │ + var json = { │ │ │ │ + "type": "Feature", │ │ │ │ + "properties": feature.attributes, │ │ │ │ + "geometry": geom │ │ │ │ + }; │ │ │ │ + if (feature.fid != null) { │ │ │ │ + json.id = feature.fid; │ │ │ │ + } │ │ │ │ + return json; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: unhighlight │ │ │ │ - * Redraw feature with the "default" style │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - unhighlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - // three cases: │ │ │ │ - // 1. there's no other highlighter, in that case _prev is undefined, │ │ │ │ - // and we just need to undef _last │ │ │ │ - // 2. another control highlighted the feature after we did it, in │ │ │ │ - // that case _last references this other control, and we just │ │ │ │ - // need to undef _prev │ │ │ │ - // 3. another control highlighted the feature before we did it, in │ │ │ │ - // that case _prev references this other control, and we need to │ │ │ │ - // set _last to _prev and undef _prev │ │ │ │ - if (feature._prevHighlighter == undefined) { │ │ │ │ - delete feature._lastHighlighter; │ │ │ │ - } else if (feature._prevHighlighter == this.id) { │ │ │ │ - delete feature._prevHighlighter; │ │ │ │ - } else { │ │ │ │ - feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ - delete feature._prevHighlighter; │ │ │ │ - } │ │ │ │ - layer.drawFeature(feature, feature.style || feature.layer.style || │ │ │ │ - "default"); │ │ │ │ - this.events.triggerEvent("featureunhighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: extract.geometry │ │ │ │ + * Return a GeoJSON object representing a single geometry. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object representing the geometry. │ │ │ │ + */ │ │ │ │ + 'geometry': function(geometry) { │ │ │ │ + if (geometry == null) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + geometry.transform(this.internalProjection, │ │ │ │ + this.externalProjection); │ │ │ │ + } │ │ │ │ + var geometryType = geometry.CLASS_NAME.split('.')[2]; │ │ │ │ + var data = this.extract[geometryType.toLowerCase()].apply(this, [geometry]); │ │ │ │ + var json; │ │ │ │ + if (geometryType == "Collection") { │ │ │ │ + json = { │ │ │ │ + "type": "GeometryCollection", │ │ │ │ + "geometries": data │ │ │ │ + }; │ │ │ │ + } else { │ │ │ │ + json = { │ │ │ │ + "type": geometryType, │ │ │ │ + "coordinates": data │ │ │ │ + }; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: select │ │ │ │ - * Add feature to the layer's selectedFeature array, render the feature as │ │ │ │ - * selected, and call the onSelect function. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - select: function(feature) { │ │ │ │ - var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (cont !== false) { │ │ │ │ - cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - layer.selectedFeatures.push(feature); │ │ │ │ - this.highlight(feature); │ │ │ │ - // if the feature handler isn't involved in the feature │ │ │ │ - // selection (because the box handler is used or the │ │ │ │ - // feature is selected programatically) we fake the │ │ │ │ - // feature handler to allow unselecting on click │ │ │ │ - if (!this.handlers.feature.lastFeature) { │ │ │ │ - this.handlers.feature.lastFeature = layer.selectedFeatures[0]; │ │ │ │ - } │ │ │ │ - layer.events.triggerEvent("featureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onSelect.call(this.scope, feature); │ │ │ │ + return json; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: extract.point │ │ │ │ + * Return an array of coordinates from a point. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of coordinates representing the point. │ │ │ │ + */ │ │ │ │ + 'point': function(point) { │ │ │ │ + return [point.x, point.y]; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: extract.multipoint │ │ │ │ + * Return an array of point coordinates from a multipoint. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * multipoint - {<OpenLayers.Geometry.MultiPoint>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of point coordinate arrays representing │ │ │ │ + * the multipoint. │ │ │ │ + */ │ │ │ │ + 'multipoint': function(multipoint) { │ │ │ │ + var array = []; │ │ │ │ + for (var i = 0, len = multipoint.components.length; i < len; ++i) { │ │ │ │ + array.push(this.extract.point.apply(this, [multipoint.components[i]])); │ │ │ │ } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + return array; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: unselect │ │ │ │ - * Remove feature from the layer's selectedFeature array, render the feature as │ │ │ │ - * normal, and call the onUnselect function. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - */ │ │ │ │ - unselect: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - // Store feature style for restoration later │ │ │ │ - this.unhighlight(feature); │ │ │ │ - OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ - layer.events.triggerEvent("featureunselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onUnselect.call(this.scope, feature); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: extract.linestring │ │ │ │ + * Return an array of coordinate arrays from a linestring. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * linestring - {<OpenLayers.Geometry.LineString>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of coordinate arrays representing │ │ │ │ + * the linestring. │ │ │ │ + */ │ │ │ │ + 'linestring': function(linestring) { │ │ │ │ + var array = []; │ │ │ │ + for (var i = 0, len = linestring.components.length; i < len; ++i) { │ │ │ │ + array.push(this.extract.point.apply(this, [linestring.components[i]])); │ │ │ │ + } │ │ │ │ + return array; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: selectBox │ │ │ │ - * Callback from the handlers.box set up when <box> selection is true │ │ │ │ - * on. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * position - {<OpenLayers.Bounds> || <OpenLayers.Pixel> } │ │ │ │ - */ │ │ │ │ - selectBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - var bounds = new OpenLayers.Bounds( │ │ │ │ - minXY.lon, minXY.lat, maxXY.lon, maxXY.lat │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * Method: extract.multilinestring │ │ │ │ + * Return an array of linestring arrays from a linestring. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * multilinestring - {<OpenLayers.Geometry.MultiLineString>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of linestring arrays representing │ │ │ │ + * the multilinestring. │ │ │ │ + */ │ │ │ │ + 'multilinestring': function(multilinestring) { │ │ │ │ + var array = []; │ │ │ │ + for (var i = 0, len = multilinestring.components.length; i < len; ++i) { │ │ │ │ + array.push(this.extract.linestring.apply(this, [multilinestring.components[i]])); │ │ │ │ + } │ │ │ │ + return array; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // if multiple is false, first deselect currently selected features │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll(); │ │ │ │ + /** │ │ │ │ + * Method: extract.polygon │ │ │ │ + * Return an array of linear ring arrays from a polygon. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * polygon - {<OpenLayers.Geometry.Polygon>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of linear ring arrays representing the polygon. │ │ │ │ + */ │ │ │ │ + 'polygon': function(polygon) { │ │ │ │ + var array = []; │ │ │ │ + for (var i = 0, len = polygon.components.length; i < len; ++i) { │ │ │ │ + array.push(this.extract.linestring.apply(this, [polygon.components[i]])); │ │ │ │ } │ │ │ │ + return array; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // because we're using a box, we consider we want multiple selection │ │ │ │ - var prevMultiple = this.multiple; │ │ │ │ - this.multiple = true; │ │ │ │ - var layers = this.layers || [this.layer]; │ │ │ │ - this.events.triggerEvent("boxselectionstart", { │ │ │ │ - layers: layers │ │ │ │ - }); │ │ │ │ - var layer; │ │ │ │ - for (var l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ - var feature = layer.features[i]; │ │ │ │ - // check if the feature is displayed │ │ │ │ - if (!feature.getVisibility()) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: extract.multipolygon │ │ │ │ + * Return an array of polygon arrays from a multipolygon. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * multipolygon - {<OpenLayers.Geometry.MultiPolygon>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of polygon arrays representing │ │ │ │ + * the multipolygon │ │ │ │ + */ │ │ │ │ + 'multipolygon': function(multipolygon) { │ │ │ │ + var array = []; │ │ │ │ + for (var i = 0, len = multipolygon.components.length; i < len; ++i) { │ │ │ │ + array.push(this.extract.polygon.apply(this, [multipolygon.components[i]])); │ │ │ │ + } │ │ │ │ + return array; │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.geometryTypes == null || OpenLayers.Util.indexOf( │ │ │ │ - this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ - if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ - if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: extract.collection │ │ │ │ + * Return an array of geometries from a geometry collection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * collection - {<OpenLayers.Geometry.Collection>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array} An array of geometry objects representing the geometry │ │ │ │ + * collection. │ │ │ │ + */ │ │ │ │ + 'collection': function(collection) { │ │ │ │ + var len = collection.components.length; │ │ │ │ + var array = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + array[i] = this.extract.geometry.apply( │ │ │ │ + this, [collection.components[i]] │ │ │ │ + ); │ │ │ │ } │ │ │ │ - this.multiple = prevMultiple; │ │ │ │ - this.events.triggerEvent("boxselectionend", { │ │ │ │ - layers: layers │ │ │ │ - }); │ │ │ │ + return array; │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ - */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.feature.setMap(map); │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box.setMap(map); │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setLayer │ │ │ │ - * Attach a new layer to the control, overriding any existing layers. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * layers - Array of {<OpenLayers.Layer.Vector>} or a single │ │ │ │ - * {<OpenLayers.Layer.Vector>} │ │ │ │ - */ │ │ │ │ - setLayer: function(layers) { │ │ │ │ - var isActive = this.active; │ │ │ │ - this.unselectAll(); │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy(); │ │ │ │ - this.layers = null; │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - this.handlers.feature.layer = this.layer; │ │ │ │ - if (isActive) { │ │ │ │ - this.activate(); │ │ │ │ - } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.GeoJSON" │ │ │ │ + │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy.js │ │ │ │ + OpenLayers/Protocol.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy │ │ │ │ - * Abstract vector layer strategy class. Not to be instantiated directly. Use │ │ │ │ - * one of the strategy subclasses instead. │ │ │ │ + * Class: OpenLayers.Protocol │ │ │ │ + * Abstract vector layer protocol class. Not to be instantiated directly. Use │ │ │ │ + * one of the protocol subclasses instead. │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ +OpenLayers.Protocol = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: layer │ │ │ │ - * {<OpenLayers.Layer.Vector>} The layer this strategy belongs to. │ │ │ │ + * Property: format │ │ │ │ + * {<OpenLayers.Format>} The format used by this protocol. │ │ │ │ */ │ │ │ │ - layer: null, │ │ │ │ + format: null, │ │ │ │ │ │ │ │ /** │ │ │ │ * Property: options │ │ │ │ * {Object} Any options sent to the constructor. │ │ │ │ */ │ │ │ │ options: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: active │ │ │ │ - * {Boolean} The control is active. │ │ │ │ - */ │ │ │ │ - active: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: autoActivate │ │ │ │ - * {Boolean} The creator of the strategy can set autoActivate to false │ │ │ │ - * to fully control when the protocol is activated and deactivated. │ │ │ │ - * Defaults to true. │ │ │ │ - */ │ │ │ │ - autoActivate: true, │ │ │ │ - │ │ │ │ /** │ │ │ │ * Property: autoDestroy │ │ │ │ - * {Boolean} The creator of the strategy can set autoDestroy to false │ │ │ │ - * to fully control when the strategy is destroyed. Defaults to │ │ │ │ + * {Boolean} The creator of the protocol can set autoDestroy to false │ │ │ │ + * to fully control when the protocol is destroyed. Defaults to │ │ │ │ * true. │ │ │ │ */ │ │ │ │ autoDestroy: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy │ │ │ │ - * Abstract class for vector strategies. Create instances of a subclass. │ │ │ │ + * Property: defaultFilter │ │ │ │ + * {<OpenLayers.Filter>} Optional default filter to read requests │ │ │ │ + */ │ │ │ │ + defaultFilter: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Protocol │ │ │ │ + * Abstract class for vector protocols. Create instances of a subclass. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ * instance. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ this.options = options; │ │ │ │ - // set the active property here, so that user cannot override it │ │ │ │ - this.active = false; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: mergeWithDefaultFilter │ │ │ │ + * Merge filter passed to the read method with the default one │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {<OpenLayers.Filter>} │ │ │ │ + */ │ │ │ │ + mergeWithDefaultFilter: function(filter) { │ │ │ │ + var merged; │ │ │ │ + if (filter && this.defaultFilter) { │ │ │ │ + merged = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.defaultFilter, filter] │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + merged = filter || this.defaultFilter || undefined; │ │ │ │ + } │ │ │ │ + return merged; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ * APIMethod: destroy │ │ │ │ - * Clean up the strategy. │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layer = null; │ │ │ │ this.options = null; │ │ │ │ + this.format = null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setLayer │ │ │ │ - * Called to set the <layer> property. │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new features. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ */ │ │ │ │ - setLayer: function(layer) { │ │ │ │ - this.layer = layer; │ │ │ │ + read: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.filter = this.mergeWithDefaultFilter(options.filter); │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ + * APIMethod: create │ │ │ │ + * Construct a request for writing newly created features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ - * the strategy was already active. │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - this.active = true; │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ + create: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ - * tear-down. │ │ │ │ + * APIMethod: update │ │ │ │ + * Construct a request updating modified features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ - * the strategy was already inactive. │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.active = false; │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Filter.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/Style.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Filter │ │ │ │ - * This class represents an OGC Filter. │ │ │ │ - */ │ │ │ │ -OpenLayers.Filter = OpenLayers.Class({ │ │ │ │ + update: function() {}, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Filter │ │ │ │ - * This class represents a generic filter. │ │ │ │ + /** │ │ │ │ + * APIMethod: delete │ │ │ │ + * Construct a request deleting a removed feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Filter>} │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Remove reference to anything added. │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, the same object will be passed to the callback function passed │ │ │ │ + * if one exists in the options object. │ │ │ │ */ │ │ │ │ - destroy: function() {}, │ │ │ │ + "delete": function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: evaluate │ │ │ │ - * Evaluates this filter in a specific context. Instances or subclasses │ │ │ │ - * are supposed to override this method. │ │ │ │ - * │ │ │ │ + * APIMethod: commit │ │ │ │ + * Go over the features and for each take action │ │ │ │ + * based on the feature state. Possible actions are create, │ │ │ │ + * update and delete. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * context - {Object} Context to use in evaluating the filter. If a vector │ │ │ │ - * feature is provided, the feature.attributes will be used as context. │ │ │ │ - * │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} │ │ │ │ + * options - {Object} Object whose possible keys are "create", "update", │ │ │ │ + * "delete", "callback" and "scope", the values referenced by the │ │ │ │ + * first three are objects as passed to the "create", "update", and │ │ │ │ + * "delete" methods, the value referenced by the "callback" key is │ │ │ │ + * a function which is called when the commit operation is complete │ │ │ │ + * using the scope referenced by the "scope" key. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The filter applies. │ │ │ │ + * {Array({<OpenLayers.Protocol.Response>})} An array of │ │ │ │ + * <OpenLayers.Protocol.Response> objects. │ │ │ │ */ │ │ │ │ - evaluate: function(context) { │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ + commit: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this filter. Should be implemented by subclasses. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter>} Clone of this filter. │ │ │ │ + * Method: abort │ │ │ │ + * Abort an ongoing request. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - return null; │ │ │ │ - }, │ │ │ │ + abort: function(response) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: toString │ │ │ │ + * Method: createCallback │ │ │ │ + * Returns a function that applies the given public method with resp and │ │ │ │ + * options arguments. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {String} Include <OpenLayers.Format.CQL> in your build to get a CQL │ │ │ │ - * representation of the filter returned. Otherwise "[Object object]" │ │ │ │ - * will be returned. │ │ │ │ + * Parameters: │ │ │ │ + * method - {Function} The method to be applied by the callback. │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} The protocol response object. │ │ │ │ + * options - {Object} Options sent to the protocol method │ │ │ │ */ │ │ │ │ - toString: function() { │ │ │ │ - var string; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.CQL) { │ │ │ │ - string = OpenLayers.Format.CQL.prototype.write(this); │ │ │ │ - } else { │ │ │ │ - string = Object.prototype.toString.call(this); │ │ │ │ - } │ │ │ │ - return string; │ │ │ │ + createCallback: function(method, response, options) { │ │ │ │ + return OpenLayers.Function.bind(function() { │ │ │ │ + method.apply(this, [response, options]); │ │ │ │ + }, this); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Filter" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol" │ │ │ │ }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Filter/Spatial.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Filter.js │ │ │ │ + * Class: OpenLayers.Protocol.Response │ │ │ │ + * Protocols return Response objects to their users. │ │ │ │ */ │ │ │ │ +OpenLayers.Protocol.Response = OpenLayers.Class({ │ │ │ │ + /** │ │ │ │ + * Property: code │ │ │ │ + * {Number} - OpenLayers.Protocol.Response.SUCCESS or │ │ │ │ + * OpenLayers.Protocol.Response.FAILURE │ │ │ │ + */ │ │ │ │ + code: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Filter.Spatial │ │ │ │ - * This class represents a spatial filter. │ │ │ │ - * Currently implemented: BBOX, DWithin and Intersects │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Filter> │ │ │ │ - */ │ │ │ │ -OpenLayers.Filter.Spatial = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ + /** │ │ │ │ + * Property: requestType │ │ │ │ + * {String} The type of request this response corresponds to. Either │ │ │ │ + * "create", "read", "update" or "delete". │ │ │ │ + */ │ │ │ │ + requestType: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} Type of spatial filter. │ │ │ │ - * │ │ │ │ - * The type should be one of: │ │ │ │ - * - OpenLayers.Filter.Spatial.BBOX │ │ │ │ - * - OpenLayers.Filter.Spatial.INTERSECTS │ │ │ │ - * - OpenLayers.Filter.Spatial.DWITHIN │ │ │ │ - * - OpenLayers.Filter.Spatial.WITHIN │ │ │ │ - * - OpenLayers.Filter.Spatial.CONTAINS │ │ │ │ + * Property: last │ │ │ │ + * {Boolean} - true if this is the last response expected in a commit, │ │ │ │ + * false otherwise, defaults to true. │ │ │ │ */ │ │ │ │ - type: null, │ │ │ │ + last: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: property │ │ │ │ - * {String} Name of the context property to compare. │ │ │ │ + * Property: features │ │ │ │ + * {Array({<OpenLayers.Feature.Vector>})} or {<OpenLayers.Feature.Vector>} │ │ │ │ + * The features returned in the response by the server. Depending on the │ │ │ │ + * protocol's read payload, either features or data will be populated. │ │ │ │ */ │ │ │ │ - property: null, │ │ │ │ + features: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: value │ │ │ │ - * {<OpenLayers.Bounds> || <OpenLayers.Geometry>} The bounds or geometry │ │ │ │ - * to be used by the filter. Use bounds for BBOX filters and geometry │ │ │ │ - * for INTERSECTS or DWITHIN filters. │ │ │ │ + * Property: data │ │ │ │ + * {Object} │ │ │ │ + * The data returned in the response by the server. Depending on the │ │ │ │ + * protocol's read payload, either features or data will be populated. │ │ │ │ */ │ │ │ │ - value: null, │ │ │ │ + data: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: distance │ │ │ │ - * {Number} The distance to use in a DWithin spatial filter. │ │ │ │ + * Property: reqFeatures │ │ │ │ + * {Array({<OpenLayers.Feature.Vector>})} or {<OpenLayers.Feature.Vector>} │ │ │ │ + * The features provided by the user and placed in the request by the │ │ │ │ + * protocol. │ │ │ │ */ │ │ │ │ - distance: null, │ │ │ │ + reqFeatures: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: distanceUnits │ │ │ │ - * {String} The units to use for the distance, e.g. 'm'. │ │ │ │ + * Property: priv │ │ │ │ */ │ │ │ │ - distanceUnits: null, │ │ │ │ + priv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Filter.Spatial │ │ │ │ - * Creates a spatial filter. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * filter. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter.Spatial>} │ │ │ │ + /** │ │ │ │ + * Property: error │ │ │ │ + * {Object} The error object in case a service exception was encountered. │ │ │ │ */ │ │ │ │ + error: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: evaluate │ │ │ │ - * Evaluates this filter for a specific feature. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Protocol.Response │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} feature to apply the filter to. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The feature meets filter criteria. │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ - evaluate: function(feature) { │ │ │ │ - var intersect = false; │ │ │ │ - switch (this.type) { │ │ │ │ - case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ - case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ - if (feature.geometry) { │ │ │ │ - var geom = this.value; │ │ │ │ - if (this.value.CLASS_NAME == "OpenLayers.Bounds") { │ │ │ │ - geom = this.value.toGeometry(); │ │ │ │ - } │ │ │ │ - if (feature.geometry.intersects(geom)) { │ │ │ │ - intersect = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - throw new Error('evaluate is not implemented for this filter type.'); │ │ │ │ - } │ │ │ │ - return intersect; │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this filter. │ │ │ │ - * │ │ │ │ + * Method: success │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Filter.Spatial>} Clone of this filter. │ │ │ │ + * {Boolean} - true on success, false otherwise │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.applyDefaults({ │ │ │ │ - value: this.value && this.value.clone && this.value.clone() │ │ │ │ - }, this); │ │ │ │ - return new OpenLayers.Filter.Spatial(options); │ │ │ │ + success: function() { │ │ │ │ + return this.code > 0; │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Filter.Spatial" │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.Response" │ │ │ │ }); │ │ │ │ │ │ │ │ -OpenLayers.Filter.Spatial.BBOX = "BBOX"; │ │ │ │ -OpenLayers.Filter.Spatial.INTERSECTS = "INTERSECTS"; │ │ │ │ -OpenLayers.Filter.Spatial.DWITHIN = "DWITHIN"; │ │ │ │ -OpenLayers.Filter.Spatial.WITHIN = "WITHIN"; │ │ │ │ -OpenLayers.Filter.Spatial.CONTAINS = "CONTAINS"; │ │ │ │ +OpenLayers.Protocol.Response.SUCCESS = 1; │ │ │ │ +OpenLayers.Protocol.Response.FAILURE = 0; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/BBOX.js │ │ │ │ + OpenLayers/Request.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ - * @requires OpenLayers/Filter/Spatial.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.BBOX │ │ │ │ - * A simple strategy that reads new features when the viewport invalidates │ │ │ │ - * some bounds. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * TODO: deprecate me │ │ │ │ + * Use OpenLayers.Request.proxy instead. │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ +OpenLayers.ProxyHost = ""; │ │ │ │ │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Request │ │ │ │ + * The OpenLayers.Request namespace contains convenience methods for working │ │ │ │ + * with XMLHttpRequests. These methods work with a cross-browser │ │ │ │ + * W3C compliant <OpenLayers.Request.XMLHttpRequest> class. │ │ │ │ + */ │ │ │ │ +if (!OpenLayers.Request) { │ │ │ │ /** │ │ │ │ - * Property: bounds │ │ │ │ - * {<OpenLayers.Bounds>} The current data bounds (in the same projection │ │ │ │ - * as the layer - not always the same projection as the map). │ │ │ │ - */ │ │ │ │ - bounds: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: resolution │ │ │ │ - * {Float} The current data resolution. │ │ │ │ + * This allows for OpenLayers/Request/XMLHttpRequest.js to be included │ │ │ │ + * before or after this script. │ │ │ │ */ │ │ │ │ - resolution: null, │ │ │ │ + OpenLayers.Request = {}; │ │ │ │ +} │ │ │ │ +OpenLayers.Util.extend(OpenLayers.Request, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ratio │ │ │ │ - * {Float} The ratio of the data bounds to the viewport bounds (in each │ │ │ │ - * dimension). Default is 2. │ │ │ │ - */ │ │ │ │ - ratio: 2, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: resFactor │ │ │ │ - * {Float} Optional factor used to determine when previously requested │ │ │ │ - * features are invalid. If set, the resFactor will be compared to the │ │ │ │ - * resolution of the previous request to the current map resolution. │ │ │ │ - * If resFactor > (old / new) and 1/resFactor < (old / new). If you │ │ │ │ - * set a resFactor of 1, data will be requested every time the │ │ │ │ - * resolution changes. If you set a resFactor of 3, data will be │ │ │ │ - * requested if the old resolution is 3 times the new, or if the new is │ │ │ │ - * 3 times the old. If the old bounds do not contain the new bounds │ │ │ │ - * new data will always be requested (with or without considering │ │ │ │ - * resFactor). │ │ │ │ + * Constant: DEFAULT_CONFIG │ │ │ │ + * {Object} Default configuration for all requests. │ │ │ │ */ │ │ │ │ - resFactor: null, │ │ │ │ + DEFAULT_CONFIG: { │ │ │ │ + method: "GET", │ │ │ │ + url: window.location.href, │ │ │ │ + async: true, │ │ │ │ + user: undefined, │ │ │ │ + password: undefined, │ │ │ │ + params: null, │ │ │ │ + proxy: OpenLayers.ProxyHost, │ │ │ │ + headers: {}, │ │ │ │ + data: null, │ │ │ │ + callback: function() {}, │ │ │ │ + success: null, │ │ │ │ + failure: null, │ │ │ │ + scope: null │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: response │ │ │ │ - * {<OpenLayers.Protocol.Response>} The protocol response object returned │ │ │ │ - * by the layer protocol. │ │ │ │ + * Constant: URL_SPLIT_REGEX │ │ │ │ */ │ │ │ │ - response: null, │ │ │ │ + URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.BBOX │ │ │ │ - * Create a new BBOX strategy. │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} An events object that handles all │ │ │ │ + * events on the {<OpenLayers.Request>} object. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: activate │ │ │ │ - * Set up strategy with regard to reading new batches of remote data. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully activated. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "moveend": this.update, │ │ │ │ - "refresh": this.update, │ │ │ │ - "visibilitychanged": this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.update(); │ │ │ │ - } │ │ │ │ - return activated; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Tear down strategy with regard to reading new batches of remote data. │ │ │ │ + * All event listeners will receive an event object with three properties: │ │ │ │ + * request - {<OpenLayers.Request.XMLHttpRequest>} The request object. │ │ │ │ + * config - {Object} The config object sent to the specific request method. │ │ │ │ + * requestUrl - {String} The request url. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ + * Supported event types: │ │ │ │ + * complete - Triggered when we have a response from the request, if a │ │ │ │ + * listener returns false, no further response processing will take │ │ │ │ + * place. │ │ │ │ + * success - Triggered when the HTTP response has a success code (200-299). │ │ │ │ + * failure - Triggered when the HTTP response does not have a success code. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - "moveend": this.update, │ │ │ │ - "refresh": this.update, │ │ │ │ - "visibilitychanged": this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ - }, │ │ │ │ + events: new OpenLayers.Events(this), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Callback function called on "moveend" or "refresh" layer events. │ │ │ │ + * Method: makeSameOrigin │ │ │ │ + * Using the specified proxy, returns a same origin url of the provided url. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will determine │ │ │ │ - * the behaviour of this Strategy │ │ │ │ - * │ │ │ │ - * Valid options include: │ │ │ │ - * force - {Boolean} if true, new data must be unconditionally read. │ │ │ │ - * noAbort - {Boolean} if true, do not abort previous requests. │ │ │ │ - */ │ │ │ │ - update: function(options) { │ │ │ │ - var mapBounds = this.getMapBounds(); │ │ │ │ - if (mapBounds !== null && ((options && options.force) || │ │ │ │ - (this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds)))) { │ │ │ │ - this.calculateBounds(mapBounds); │ │ │ │ - this.resolution = this.layer.map.getResolution(); │ │ │ │ - this.triggerRead(options); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getMapBounds │ │ │ │ - * Get the map bounds expressed in the same projection as this layer. │ │ │ │ + * url - {String} An arbitrary url │ │ │ │ + * proxy {String|Function} The proxy to use to make the provided url a │ │ │ │ + * same origin url. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} Map bounds in the projection of the layer. │ │ │ │ + * Returns │ │ │ │ + * {String} the same origin url. If no proxy is provided, the returned url │ │ │ │ + * will be the same as the provided url. │ │ │ │ */ │ │ │ │ - getMapBounds: function() { │ │ │ │ - if (this.layer.map === null) { │ │ │ │ - return null; │ │ │ │ + makeSameOrigin: function(url, proxy) { │ │ │ │ + var sameOrigin = url.indexOf("http") !== 0; │ │ │ │ + var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX); │ │ │ │ + if (urlParts) { │ │ │ │ + var location = window.location; │ │ │ │ + sameOrigin = │ │ │ │ + urlParts[1] == location.protocol && │ │ │ │ + urlParts[3] == location.hostname; │ │ │ │ + var uPort = urlParts[4], │ │ │ │ + lPort = location.port; │ │ │ │ + if (uPort != 80 && uPort != "" || lPort != "80" && lPort != "") { │ │ │ │ + sameOrigin = sameOrigin && uPort == lPort; │ │ │ │ + } │ │ │ │ } │ │ │ │ - var bounds = this.layer.map.getExtent(); │ │ │ │ - if (bounds && !this.layer.projection.equals( │ │ │ │ - this.layer.map.getProjectionObject())) { │ │ │ │ - bounds = bounds.clone().transform( │ │ │ │ - this.layer.map.getProjectionObject(), this.layer.projection │ │ │ │ - ); │ │ │ │ + if (!sameOrigin) { │ │ │ │ + if (proxy) { │ │ │ │ + if (typeof proxy == "function") { │ │ │ │ + url = proxy(url); │ │ │ │ + } else { │ │ │ │ + url = proxy + encodeURIComponent(url); │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - return bounds; │ │ │ │ + return url; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: invalidBounds │ │ │ │ - * Determine whether the previously requested set of features is invalid. │ │ │ │ - * This occurs when the new map bounds do not contain the previously │ │ │ │ - * requested bounds. In addition, if <resFactor> is set, it will be │ │ │ │ - * considered. │ │ │ │ + * APIMethod: issue │ │ │ │ + * Create a new XMLHttpRequest object, open it, set any headers, bind │ │ │ │ + * a callback to done state, and send any data. It is recommended that │ │ │ │ + * you use one <GET>, <POST>, <PUT>, <DELETE>, <OPTIONS>, or <HEAD>. │ │ │ │ + * This method is only documented to provide detail on the configuration │ │ │ │ + * options available to all request methods. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ - * retrieved from the map object if not provided │ │ │ │ + * config - {Object} Object containing properties for configuring the │ │ │ │ + * request. Allowed configuration properties are described below. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Allowed config properties: │ │ │ │ + * method - {String} One of GET, POST, PUT, DELETE, HEAD, or │ │ │ │ + * OPTIONS. Default is GET. │ │ │ │ + * url - {String} URL for the request. │ │ │ │ + * async - {Boolean} Open an asynchronous request. Default is true. │ │ │ │ + * user - {String} User for relevant authentication scheme. Set │ │ │ │ + * to null to clear current user. │ │ │ │ + * password - {String} Password for relevant authentication scheme. │ │ │ │ + * Set to null to clear current password. │ │ │ │ + * proxy - {String} Optional proxy. Defaults to │ │ │ │ + * <OpenLayers.ProxyHost>. │ │ │ │ + * params - {Object} Any key:value pairs to be appended to the │ │ │ │ + * url as a query string. Assumes url doesn't already include a query │ │ │ │ + * string or hash. Typically, this is only appropriate for <GET> │ │ │ │ + * requests where the query string will be appended to the url. │ │ │ │ + * Parameter values that are arrays will be │ │ │ │ + * concatenated with a comma (note that this goes against form-encoding) │ │ │ │ + * as is done with <OpenLayers.Util.getParameterString>. │ │ │ │ + * headers - {Object} Object with header:value pairs to be set on │ │ │ │ + * the request. │ │ │ │ + * data - {String | Document} Optional data to send with the request. │ │ │ │ + * Typically, this is only used with <POST> and <PUT> requests. │ │ │ │ + * Make sure to provide the appropriate "Content-Type" header for your │ │ │ │ + * data. For <POST> and <PUT> requests, the content type defaults to │ │ │ │ + * "application-xml". If your data is a different content type, or │ │ │ │ + * if you are using a different HTTP method, set the "Content-Type" │ │ │ │ + * header to match your data type. │ │ │ │ + * callback - {Function} Function to call when request is done. │ │ │ │ + * To determine if the request failed, check request.status (200 │ │ │ │ + * indicates success). │ │ │ │ + * success - {Function} Optional function to call if request status is in │ │ │ │ + * the 200s. This will be called in addition to callback above and │ │ │ │ + * would typically only be used as an alternative. │ │ │ │ + * failure - {Function} Optional function to call if request status is not │ │ │ │ + * in the 200s. This will be called in addition to callback above and │ │ │ │ + * would typically only be used as an alternative. │ │ │ │ + * scope - {Object} If callback is a public method on some object, │ │ │ │ + * set the scope to that object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} │ │ │ │ + * {XMLHttpRequest} Request object. To abort the request before a response │ │ │ │ + * is received, call abort() on the request object. │ │ │ │ */ │ │ │ │ - invalidBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds(); │ │ │ │ + issue: function(config) { │ │ │ │ + // apply default config - proxy host may have changed │ │ │ │ + var defaultConfig = OpenLayers.Util.extend( │ │ │ │ + this.DEFAULT_CONFIG, { │ │ │ │ + proxy: OpenLayers.ProxyHost │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + config = config || {}; │ │ │ │ + config.headers = config.headers || {}; │ │ │ │ + config = OpenLayers.Util.applyDefaults(config, defaultConfig); │ │ │ │ + config.headers = OpenLayers.Util.applyDefaults(config.headers, defaultConfig.headers); │ │ │ │ + // Always set the "X-Requested-With" header to signal that this request │ │ │ │ + // was issued through the XHR-object. Since header keys are case │ │ │ │ + // insensitive and we want to allow overriding of the "X-Requested-With" │ │ │ │ + // header through the user we cannot use applyDefaults, but have to │ │ │ │ + // check manually whether we were called with a "X-Requested-With" │ │ │ │ + // header. │ │ │ │ + var customRequestedWithHeader = false, │ │ │ │ + headerKey; │ │ │ │ + for (headerKey in config.headers) { │ │ │ │ + if (config.headers.hasOwnProperty(headerKey)) { │ │ │ │ + if (headerKey.toLowerCase() === 'x-requested-with') { │ │ │ │ + customRequestedWithHeader = true; │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ - if (!invalid && this.resFactor) { │ │ │ │ - var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ - invalid = (ratio >= this.resFactor || ratio <= (1 / this.resFactor)); │ │ │ │ + if (customRequestedWithHeader === false) { │ │ │ │ + // we did not have a custom "X-Requested-With" header │ │ │ │ + config.headers['X-Requested-With'] = 'XMLHttpRequest'; │ │ │ │ } │ │ │ │ - return invalid; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: calculateBounds │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be │ │ │ │ - * retrieved from the map object if not provided │ │ │ │ - */ │ │ │ │ - calculateBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds(); │ │ │ │ - } │ │ │ │ - var center = mapBounds.getCenterLonLat(); │ │ │ │ - var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ - var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ - this.bounds = new OpenLayers.Bounds( │ │ │ │ - center.lon - (dataWidth / 2), │ │ │ │ - center.lat - (dataHeight / 2), │ │ │ │ - center.lon + (dataWidth / 2), │ │ │ │ - center.lat + (dataHeight / 2) │ │ │ │ + // create request, open, and set headers │ │ │ │ + var request = new OpenLayers.Request.XMLHttpRequest(); │ │ │ │ + var url = OpenLayers.Util.urlAppend(config.url, │ │ │ │ + OpenLayers.Util.getParameterString(config.params || {})); │ │ │ │ + url = OpenLayers.Request.makeSameOrigin(url, config.proxy); │ │ │ │ + request.open( │ │ │ │ + config.method, url, config.async, config.user, config.password │ │ │ │ ); │ │ │ │ + for (var header in config.headers) { │ │ │ │ + request.setRequestHeader(header, config.headers[header]); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var events = this.events; │ │ │ │ + │ │ │ │ + // we want to execute runCallbacks with "this" as the │ │ │ │ + // execution scope │ │ │ │ + var self = this; │ │ │ │ + │ │ │ │ + request.onreadystatechange = function() { │ │ │ │ + if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) { │ │ │ │ + var proceed = events.triggerEvent( │ │ │ │ + "complete", { │ │ │ │ + request: request, │ │ │ │ + config: config, │ │ │ │ + requestUrl: url │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + if (proceed !== false) { │ │ │ │ + self.runCallbacks({ │ │ │ │ + request: request, │ │ │ │ + config: config, │ │ │ │ + requestUrl: url │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // send request (optionally with data) and return │ │ │ │ + // call in a timeout for asynchronous requests so the return is │ │ │ │ + // available before readyState == 4 for cached docs │ │ │ │ + if (config.async === false) { │ │ │ │ + request.send(config.data); │ │ │ │ + } else { │ │ │ │ + window.setTimeout(function() { │ │ │ │ + if (request.readyState !== 0) { // W3C: 0-UNSENT │ │ │ │ + request.send(config.data); │ │ │ │ + } │ │ │ │ + }, 0); │ │ │ │ + } │ │ │ │ + return request; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: triggerRead │ │ │ │ + * Method: runCallbacks │ │ │ │ + * Calls the complete, success and failure callbacks. Application │ │ │ │ + * can listen to the "complete" event, have the listener │ │ │ │ + * display a confirm window and always return false, and │ │ │ │ + * execute OpenLayers.Request.runCallbacks if the user │ │ │ │ + * hits "yes" in the confirm window. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Additional options for the protocol's read method │ │ │ │ - * (optional) │ │ │ │ + * options - {Object} Hash containing request, config and requestUrl keys │ │ │ │ + */ │ │ │ │ + runCallbacks: function(options) { │ │ │ │ + var request = options.request; │ │ │ │ + var config = options.config; │ │ │ │ + │ │ │ │ + // bind callbacks to readyState 4 (done) │ │ │ │ + var complete = (config.scope) ? │ │ │ │ + OpenLayers.Function.bind(config.callback, config.scope) : │ │ │ │ + config.callback; │ │ │ │ + │ │ │ │ + // optional success callback │ │ │ │ + var success; │ │ │ │ + if (config.success) { │ │ │ │ + success = (config.scope) ? │ │ │ │ + OpenLayers.Function.bind(config.success, config.scope) : │ │ │ │ + config.success; │ │ │ │ + } │ │ │ │ + │ │ │ │ + // optional failure callback │ │ │ │ + var failure; │ │ │ │ + if (config.failure) { │ │ │ │ + failure = (config.scope) ? │ │ │ │ + OpenLayers.Function.bind(config.failure, config.scope) : │ │ │ │ + config.failure; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (OpenLayers.Util.createUrlObject(config.url).protocol == "file:" && │ │ │ │ + request.responseText) { │ │ │ │ + request.status = 200; │ │ │ │ + } │ │ │ │ + complete(request); │ │ │ │ + │ │ │ │ + if (!request.status || (request.status >= 200 && request.status < 300)) { │ │ │ │ + this.events.triggerEvent("success", options); │ │ │ │ + if (success) { │ │ │ │ + success(request); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ + this.events.triggerEvent("failure", options); │ │ │ │ + if (failure) { │ │ │ │ + failure(request); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: GET │ │ │ │ + * Send an HTTP GET request. Additional configuration properties are │ │ │ │ + * documented in the <issue> method, with the method property set │ │ │ │ + * to GET. │ │ │ │ * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the <issue> method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} The protocol response object │ │ │ │ - * returned by the layer protocol. │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - triggerRead: function(options) { │ │ │ │ - if (this.response && !(options && options.noAbort === true)) { │ │ │ │ - this.layer.protocol.abort(this.response); │ │ │ │ - this.layer.events.triggerEvent("loadend"); │ │ │ │ + GET: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "GET" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: POST │ │ │ │ + * Send a POST request. Additional configuration properties are │ │ │ │ + * documented in the <issue> method, with the method property set │ │ │ │ + * to POST and "Content-Type" header set to "application/xml". │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the <issue> method for documentation of allowed properties. The │ │ │ │ + * default "Content-Type" header will be set to "application-xml" if │ │ │ │ + * none is provided. This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ + */ │ │ │ │ + POST: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "POST" │ │ │ │ + }); │ │ │ │ + // set content type to application/xml if it isn't already set │ │ │ │ + config.headers = config.headers ? config.headers : {}; │ │ │ │ + if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ + config.headers["Content-Type"] = "application/xml"; │ │ │ │ } │ │ │ │ - var evt = { │ │ │ │ - filter: this.createFilter() │ │ │ │ - }; │ │ │ │ - this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ - this.response = this.layer.protocol.read( │ │ │ │ - OpenLayers.Util.applyDefaults({ │ │ │ │ - filter: evt.filter, │ │ │ │ - callback: this.merge, │ │ │ │ - scope: this │ │ │ │ - }, options)); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createFilter │ │ │ │ - * Creates a spatial BBOX filter. If the layer that this strategy belongs │ │ │ │ - * to has a filter property, this filter will be combined with the BBOX │ │ │ │ - * filter. │ │ │ │ + * APIMethod: PUT │ │ │ │ + * Send an HTTP PUT request. Additional configuration properties are │ │ │ │ + * documented in the <issue> method, with the method property set │ │ │ │ + * to PUT and "Content-Type" header set to "application/xml". │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the <issue> method for documentation of allowed properties. The │ │ │ │ + * default "Content-Type" header will be set to "application-xml" if │ │ │ │ + * none is provided. This object is modified and should not be reused. │ │ │ │ * │ │ │ │ - * Returns │ │ │ │ - * {<OpenLayers.Filter>} The filter object. │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - createFilter: function() { │ │ │ │ - var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - value: this.bounds, │ │ │ │ - projection: this.layer.projection │ │ │ │ + PUT: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "PUT" │ │ │ │ }); │ │ │ │ - if (this.layer.filter) { │ │ │ │ - filter = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.layer.filter, filter] │ │ │ │ - }); │ │ │ │ + // set content type to application/xml if it isn't already set │ │ │ │ + config.headers = config.headers ? config.headers : {}; │ │ │ │ + if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ + config.headers["Content-Type"] = "application/xml"; │ │ │ │ } │ │ │ │ - return filter; │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: merge │ │ │ │ - * Given a list of features, determine which ones to add to the layer. │ │ │ │ - * If the layer projection differs from the map projection, features │ │ │ │ - * will be transformed from the layer projection to the map projection. │ │ │ │ + * APIMethod: DELETE │ │ │ │ + * Send an HTTP DELETE request. Additional configuration properties are │ │ │ │ + * documented in the <issue> method, with the method property set │ │ │ │ + * to DELETE. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ - * by the protocol. │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the <issue> method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ */ │ │ │ │ - merge: function(resp) { │ │ │ │ - this.layer.destroyFeatures(); │ │ │ │ - if (resp.success()) { │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = this.layer.projection; │ │ │ │ - var local = this.layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + DELETE: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "DELETE" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: HEAD │ │ │ │ + * Send an HTTP HEAD request. Additional configuration properties are │ │ │ │ + * documented in the <issue> method, with the method property set │ │ │ │ + * to HEAD. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the <issue> method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ + */ │ │ │ │ + HEAD: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "HEAD" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: OPTIONS │ │ │ │ + * Send an HTTP OPTIONS request. Additional configuration properties are │ │ │ │ + * documented in the <issue> method, with the method property set │ │ │ │ + * to OPTIONS. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * config - {Object} Object with properties for configuring the request. │ │ │ │ + * See the <issue> method for documentation of allowed properties. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {XMLHttpRequest} Request object. │ │ │ │ + */ │ │ │ │ + OPTIONS: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "OPTIONS" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config); │ │ │ │ + } │ │ │ │ + │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +// XMLHttpRequest.js Copyright (C) 2010 Sergey Ilinsky (http://www.ilinsky.com) │ │ │ │ +// │ │ │ │ +// 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. │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Request.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +(function() { │ │ │ │ + │ │ │ │ + // Save reference to earlier defined object implementation (if any) │ │ │ │ + var oXMLHttpRequest = window.XMLHttpRequest; │ │ │ │ + │ │ │ │ + // Define on browser type │ │ │ │ + var bGecko = !!window.controllers, │ │ │ │ + bIE = window.document.all && !window.opera, │ │ │ │ + bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/); │ │ │ │ + │ │ │ │ + // Enables "XMLHttpRequest()" call next to "new XMLHttpReques()" │ │ │ │ + function fXMLHttpRequest() { │ │ │ │ + this._object = oXMLHttpRequest && !bIE7 ? new oXMLHttpRequest : new window.ActiveXObject("Microsoft.XMLHTTP"); │ │ │ │ + this._listeners = []; │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // Constructor │ │ │ │ + function cXMLHttpRequest() { │ │ │ │ + return new fXMLHttpRequest; │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype = fXMLHttpRequest.prototype; │ │ │ │ + │ │ │ │ + // BUGFIX: Firefox with Firebug installed would break pages if not executed │ │ │ │ + if (bGecko && oXMLHttpRequest.wrapped) │ │ │ │ + cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped; │ │ │ │ + │ │ │ │ + // Constants │ │ │ │ + cXMLHttpRequest.UNSENT = 0; │ │ │ │ + cXMLHttpRequest.OPENED = 1; │ │ │ │ + cXMLHttpRequest.HEADERS_RECEIVED = 2; │ │ │ │ + cXMLHttpRequest.LOADING = 3; │ │ │ │ + cXMLHttpRequest.DONE = 4; │ │ │ │ + │ │ │ │ + // Public Properties │ │ │ │ + cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + cXMLHttpRequest.prototype.responseText = ''; │ │ │ │ + cXMLHttpRequest.prototype.responseXML = null; │ │ │ │ + cXMLHttpRequest.prototype.status = 0; │ │ │ │ + cXMLHttpRequest.prototype.statusText = ''; │ │ │ │ + │ │ │ │ + // Priority proposal │ │ │ │ + cXMLHttpRequest.prototype.priority = "NORMAL"; │ │ │ │ + │ │ │ │ + // Instance-level Events Handlers │ │ │ │ + cXMLHttpRequest.prototype.onreadystatechange = null; │ │ │ │ + │ │ │ │ + // Class-level Events Handlers │ │ │ │ + cXMLHttpRequest.onreadystatechange = null; │ │ │ │ + cXMLHttpRequest.onopen = null; │ │ │ │ + cXMLHttpRequest.onsend = null; │ │ │ │ + cXMLHttpRequest.onabort = null; │ │ │ │ + │ │ │ │ + // Public Methods │ │ │ │ + cXMLHttpRequest.prototype.open = function(sMethod, sUrl, bAsync, sUser, sPassword) { │ │ │ │ + // Delete headers, required when object is reused │ │ │ │ + delete this._headers; │ │ │ │ + │ │ │ │ + // When bAsync parameter value is omitted, use true as default │ │ │ │ + if (arguments.length < 3) │ │ │ │ + bAsync = true; │ │ │ │ + │ │ │ │ + // Save async parameter for fixing Gecko bug with missing readystatechange in synchronous requests │ │ │ │ + this._async = bAsync; │ │ │ │ + │ │ │ │ + // Set the onreadystatechange handler │ │ │ │ + var oRequest = this, │ │ │ │ + nState = this.readyState, │ │ │ │ + fOnUnload; │ │ │ │ + │ │ │ │ + // BUGFIX: IE - memory leak on page unload (inter-page leak) │ │ │ │ + if (bIE && bAsync) { │ │ │ │ + fOnUnload = function() { │ │ │ │ + if (nState != cXMLHttpRequest.DONE) { │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + // Safe to abort here since onreadystatechange handler removed │ │ │ │ + oRequest.abort(); │ │ │ │ } │ │ │ │ - this.layer.addFeatures(features); │ │ │ │ + }; │ │ │ │ + window.attachEvent("onunload", fOnUnload); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // Add method sniffer │ │ │ │ + if (cXMLHttpRequest.onopen) │ │ │ │ + cXMLHttpRequest.onopen.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (arguments.length > 4) │ │ │ │ + this._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ + else │ │ │ │ + if (arguments.length > 3) │ │ │ │ + this._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ + else │ │ │ │ + this._object.open(sMethod, sUrl, bAsync); │ │ │ │ + │ │ │ │ + this.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + fReadyStateChange(this); │ │ │ │ + │ │ │ │ + this._object.onreadystatechange = function() { │ │ │ │ + if (bGecko && !bAsync) │ │ │ │ + return; │ │ │ │ + │ │ │ │ + // Synchronize state │ │ │ │ + oRequest.readyState = oRequest._object.readyState; │ │ │ │ + │ │ │ │ + // │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + │ │ │ │ + // BUGFIX: Firefox fires unnecessary DONE when aborting │ │ │ │ + if (oRequest._aborted) { │ │ │ │ + // Reset readyState to UNSENT │ │ │ │ + oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + │ │ │ │ + // Return now │ │ │ │ + return; │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - this.bounds = null; │ │ │ │ + │ │ │ │ + if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ + // Free up queue │ │ │ │ + delete oRequest._data; │ │ │ │ + /* if (bAsync) │ │ │ │ + fQueue_remove(oRequest);*/ │ │ │ │ + // │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + // Uncomment this block if you need a fix for IE cache │ │ │ │ + /* │ │ │ │ + // BUGFIX: IE - cache issue │ │ │ │ + if (!oRequest._object.getResponseHeader("Date")) { │ │ │ │ + // Save object to cache │ │ │ │ + oRequest._cached = oRequest._object; │ │ │ │ + │ │ │ │ + // Instantiate a new transport object │ │ │ │ + cXMLHttpRequest.call(oRequest); │ │ │ │ + │ │ │ │ + // Re-send request │ │ │ │ + if (sUser) { │ │ │ │ + if (sPassword) │ │ │ │ + oRequest._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ + else │ │ │ │ + oRequest._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ + } │ │ │ │ + else │ │ │ │ + oRequest._object.open(sMethod, sUrl, bAsync); │ │ │ │ + oRequest._object.setRequestHeader("If-Modified-Since", oRequest._cached.getResponseHeader("Last-Modified") || new window.Date(0)); │ │ │ │ + // Copy headers set │ │ │ │ + if (oRequest._headers) │ │ │ │ + for (var sHeader in oRequest._headers) │ │ │ │ + if (typeof oRequest._headers[sHeader] == "string") // Some frameworks prototype objects with functions │ │ │ │ + oRequest._object.setRequestHeader(sHeader, oRequest._headers[sHeader]); │ │ │ │ + │ │ │ │ + oRequest._object.onreadystatechange = function() { │ │ │ │ + // Synchronize state │ │ │ │ + oRequest.readyState = oRequest._object.readyState; │ │ │ │ + │ │ │ │ + if (oRequest._aborted) { │ │ │ │ + // │ │ │ │ + oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + │ │ │ │ + // Return │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ + // Clean Object │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + │ │ │ │ + // get cached request │ │ │ │ + if (oRequest.status == 304) │ │ │ │ + oRequest._object = oRequest._cached; │ │ │ │ + │ │ │ │ + // │ │ │ │ + delete oRequest._cached; │ │ │ │ + │ │ │ │ + // │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + │ │ │ │ + // │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + │ │ │ │ + // BUGFIX: IE - memory leak in interrupted │ │ │ │ + if (bIE && bAsync) │ │ │ │ + window.detachEvent("onunload", fOnUnload); │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + oRequest._object.send(null); │ │ │ │ + │ │ │ │ + // Return now - wait until re-sent request is finished │ │ │ │ + return; │ │ │ │ + }; │ │ │ │ + */ │ │ │ │ + // BUGFIX: IE - memory leak in interrupted │ │ │ │ + if (bIE && bAsync) │ │ │ │ + window.detachEvent("onunload", fOnUnload); │ │ │ │ + } │ │ │ │ + │ │ │ │ + // BUGFIX: Some browsers (Internet Explorer, Gecko) fire OPEN readystate twice │ │ │ │ + if (nState != oRequest.readyState) │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + │ │ │ │ + nState = oRequest.readyState; │ │ │ │ } │ │ │ │ - this.response = null; │ │ │ │ - this.layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fXMLHttpRequest_send(oRequest) { │ │ │ │ + oRequest._object.send(oRequest._data); │ │ │ │ + │ │ │ │ + // BUGFIX: Gecko - missing readystatechange calls in synchronous requests │ │ │ │ + if (bGecko && !oRequest._async) { │ │ │ │ + oRequest.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + │ │ │ │ + // Synchronize state │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + │ │ │ │ + // Simulate missing states │ │ │ │ + while (oRequest.readyState < cXMLHttpRequest.DONE) { │ │ │ │ + oRequest.readyState++; │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + // Check if we are aborted │ │ │ │ + if (oRequest._aborted) │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.send = function(vData) { │ │ │ │ + // Add method sniffer │ │ │ │ + if (cXMLHttpRequest.onsend) │ │ │ │ + cXMLHttpRequest.onsend.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (!arguments.length) │ │ │ │ + vData = null; │ │ │ │ + │ │ │ │ + // BUGFIX: Safari - fails sending documents created/modified dynamically, so an explicit serialization required │ │ │ │ + // BUGFIX: IE - rewrites any custom mime-type to "text/xml" in case an XMLNode is sent │ │ │ │ + // BUGFIX: Gecko - fails sending Element (this is up to the implementation either to standard) │ │ │ │ + if (vData && vData.nodeType) { │ │ │ │ + vData = window.XMLSerializer ? new window.XMLSerializer().serializeToString(vData) : vData.xml; │ │ │ │ + if (!this._headers["Content-Type"]) │ │ │ │ + this._object.setRequestHeader("Content-Type", "application/xml"); │ │ │ │ + } │ │ │ │ + │ │ │ │ + this._data = vData; │ │ │ │ + /* │ │ │ │ + // Add to queue │ │ │ │ + if (this._async) │ │ │ │ + fQueue_add(this); │ │ │ │ + else*/ │ │ │ │ + fXMLHttpRequest_send(this); │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.abort = function() { │ │ │ │ + // Add method sniffer │ │ │ │ + if (cXMLHttpRequest.onabort) │ │ │ │ + cXMLHttpRequest.onabort.apply(this, arguments); │ │ │ │ + │ │ │ │ + // BUGFIX: Gecko - unnecessary DONE when aborting │ │ │ │ + if (this.readyState > cXMLHttpRequest.UNSENT) │ │ │ │ + this._aborted = true; │ │ │ │ + │ │ │ │ + this._object.abort(); │ │ │ │ + │ │ │ │ + // BUGFIX: IE - memory leak │ │ │ │ + fCleanTransport(this); │ │ │ │ + │ │ │ │ + this.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + │ │ │ │ + delete this._data; │ │ │ │ + /* if (this._async) │ │ │ │ + fQueue_remove(this);*/ │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.getAllResponseHeaders = function() { │ │ │ │ + return this._object.getAllResponseHeaders(); │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.getResponseHeader = function(sName) { │ │ │ │ + return this._object.getResponseHeader(sName); │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) { │ │ │ │ + // BUGFIX: IE - cache issue │ │ │ │ + if (!this._headers) │ │ │ │ + this._headers = {}; │ │ │ │ + this._headers[sName] = sValue; │ │ │ │ + │ │ │ │ + return this._object.setRequestHeader(sName, sValue); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // EventTarget interface implementation │ │ │ │ + cXMLHttpRequest.prototype.addEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ + return; │ │ │ │ + // Add listener │ │ │ │ + this._listeners.push([sName, fHandler, bUseCapture]); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + cXMLHttpRequest.prototype.removeEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ + break; │ │ │ │ + // Remove listener │ │ │ │ + if (oListener) │ │ │ │ + this._listeners.splice(nIndex, 1); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) { │ │ │ │ + var oEventPseudo = { │ │ │ │ + 'type': oEvent.type, │ │ │ │ + 'target': this, │ │ │ │ + 'currentTarget': this, │ │ │ │ + 'eventPhase': 2, │ │ │ │ + 'bubbles': oEvent.bubbles, │ │ │ │ + 'cancelable': oEvent.cancelable, │ │ │ │ + 'timeStamp': oEvent.timeStamp, │ │ │ │ + 'stopPropagation': function() {}, // There is no flow │ │ │ │ + 'preventDefault': function() {}, // There is no default action │ │ │ │ + 'initEvent': function() {} // Original event object should be initialized │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // Execute onreadystatechange │ │ │ │ + if (oEventPseudo.type == "readystatechange" && this.onreadystatechange) │ │ │ │ + (this.onreadystatechange.handleEvent || this.onreadystatechange).apply(this, [oEventPseudo]); │ │ │ │ + │ │ │ │ + // Execute listeners │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == oEventPseudo.type && !oListener[2]) │ │ │ │ + (oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // │ │ │ │ + cXMLHttpRequest.prototype.toString = function() { │ │ │ │ + return '[' + "object" + ' ' + "XMLHttpRequest" + ']'; │ │ │ │ + }; │ │ │ │ + │ │ │ │ + cXMLHttpRequest.toString = function() { │ │ │ │ + return '[' + "XMLHttpRequest" + ']'; │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // Helper function │ │ │ │ + function fReadyStateChange(oRequest) { │ │ │ │ + // Sniffing code │ │ │ │ + if (cXMLHttpRequest.onreadystatechange) │ │ │ │ + cXMLHttpRequest.onreadystatechange.apply(oRequest); │ │ │ │ + │ │ │ │ + // Fake event │ │ │ │ + oRequest.dispatchEvent({ │ │ │ │ + 'type': "readystatechange", │ │ │ │ + 'bubbles': false, │ │ │ │ + 'cancelable': false, │ │ │ │ + 'timeStamp': new Date + 0 │ │ │ │ }); │ │ │ │ - }, │ │ │ │ + }; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ -}); │ │ │ │ + function fGetDocument(oRequest) { │ │ │ │ + var oDocument = oRequest.responseXML, │ │ │ │ + sResponse = oRequest.responseText; │ │ │ │ + // Try parsing responseText │ │ │ │ + if (bIE && sResponse && oDocument && !oDocument.documentElement && oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)) { │ │ │ │ + oDocument = new window.ActiveXObject("Microsoft.XMLDOM"); │ │ │ │ + oDocument.async = false; │ │ │ │ + oDocument.validateOnParse = false; │ │ │ │ + oDocument.loadXML(sResponse); │ │ │ │ + } │ │ │ │ + // Check if there is no error in document │ │ │ │ + if (oDocument) │ │ │ │ + if ((bIE && oDocument.parseError != 0) || !oDocument.documentElement || (oDocument.documentElement && oDocument.documentElement.tagName == "parsererror")) │ │ │ │ + return null; │ │ │ │ + return oDocument; │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fSynchronizeValues(oRequest) { │ │ │ │ + try { │ │ │ │ + oRequest.responseText = oRequest._object.responseText; │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.responseXML = fGetDocument(oRequest._object); │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.status = oRequest._object.status; │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.statusText = oRequest._object.statusText; │ │ │ │ + } catch (e) {} │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fCleanTransport(oRequest) { │ │ │ │ + // BUGFIX: IE - memory leak (on-page leak) │ │ │ │ + oRequest._object.onreadystatechange = new window.Function; │ │ │ │ + }; │ │ │ │ + /* │ │ │ │ + // Queue manager │ │ │ │ + var oQueuePending = {"CRITICAL":[],"HIGH":[],"NORMAL":[],"LOW":[],"LOWEST":[]}, │ │ │ │ + aQueueRunning = []; │ │ │ │ + function fQueue_add(oRequest) { │ │ │ │ + oQueuePending[oRequest.priority in oQueuePending ? oRequest.priority : "NORMAL"].push(oRequest); │ │ │ │ + // │ │ │ │ + setTimeout(fQueue_process); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fQueue_remove(oRequest) { │ │ │ │ + for (var nIndex = 0, bFound = false; nIndex < aQueueRunning.length; nIndex++) │ │ │ │ + if (bFound) │ │ │ │ + aQueueRunning[nIndex - 1] = aQueueRunning[nIndex]; │ │ │ │ + else │ │ │ │ + if (aQueueRunning[nIndex] == oRequest) │ │ │ │ + bFound = true; │ │ │ │ + if (bFound) │ │ │ │ + aQueueRunning.length--; │ │ │ │ + // │ │ │ │ + setTimeout(fQueue_process); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fQueue_process() { │ │ │ │ + if (aQueueRunning.length < 6) { │ │ │ │ + for (var sPriority in oQueuePending) { │ │ │ │ + if (oQueuePending[sPriority].length) { │ │ │ │ + var oRequest = oQueuePending[sPriority][0]; │ │ │ │ + oQueuePending[sPriority] = oQueuePending[sPriority].slice(1); │ │ │ │ + // │ │ │ │ + aQueueRunning.push(oRequest); │ │ │ │ + // Send request │ │ │ │ + fXMLHttpRequest_send(oRequest); │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + */ │ │ │ │ + // Internet Explorer 5.0 (missing apply) │ │ │ │ + if (!window.Function.prototype.apply) { │ │ │ │ + window.Function.prototype.apply = function(oRequest, oArguments) { │ │ │ │ + if (!oArguments) │ │ │ │ + oArguments = []; │ │ │ │ + oRequest.__func = this; │ │ │ │ + oRequest.__func(oArguments[0], oArguments[1], oArguments[2], oArguments[3], oArguments[4]); │ │ │ │ + delete oRequest.__func; │ │ │ │ + }; │ │ │ │ + }; │ │ │ │ + │ │ │ │ + // Register new object with window │ │ │ │ + /** │ │ │ │ + * Class: OpenLayers.Request.XMLHttpRequest │ │ │ │ + * Standard-compliant (W3C) cross-browser implementation of the │ │ │ │ + * XMLHttpRequest object. From │ │ │ │ + * http://code.google.com/p/xmlhttprequest/. │ │ │ │ + */ │ │ │ │ + if (!OpenLayers.Request) { │ │ │ │ + /** │ │ │ │ + * This allows for OpenLayers/Request.js to be included │ │ │ │ + * before or after this script. │ │ │ │ + */ │ │ │ │ + OpenLayers.Request = {}; │ │ │ │ + } │ │ │ │ + OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest; │ │ │ │ +})(); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Strategy/Fixed.js │ │ │ │ + OpenLayers/Protocol/HTTP.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Strategy.js │ │ │ │ + * @requires OpenLayers/Protocol.js │ │ │ │ + * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Strategy.Fixed │ │ │ │ - * A simple strategy that requests features once and never requests new data. │ │ │ │ + * if application uses the query string, for example, for BBOX parameters, │ │ │ │ + * OpenLayers/Format/QueryStringFilter.js should be included in the build config file │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Protocol.HTTP │ │ │ │ + * A basic HTTP protocol for vector layers. Create a new instance with the │ │ │ │ + * <OpenLayers.Protocol.HTTP> constructor. │ │ │ │ * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Strategy> │ │ │ │ + * - <OpenLayers.Protocol> │ │ │ │ */ │ │ │ │ -OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ +OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: preload │ │ │ │ - * {Boolean} Load data before layer made visible. Enabling this may result │ │ │ │ - * in considerable overhead if your application loads many data layers │ │ │ │ - * that are not visible by default. Default is false. │ │ │ │ + * Property: url │ │ │ │ + * {String} Service URL, read-only, set through the options │ │ │ │ + * passed to constructor. │ │ │ │ */ │ │ │ │ - preload: false, │ │ │ │ + url: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Strategy.Fixed │ │ │ │ - * Create a new Fixed strategy. │ │ │ │ + * Property: headers │ │ │ │ + * {Object} HTTP request headers, read-only, set through the options │ │ │ │ + * passed to the constructor, │ │ │ │ + * Example: {'Content-Type': 'plain/text'} │ │ │ │ + */ │ │ │ │ + headers: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: params │ │ │ │ + * {Object} Parameters of GET requests, read-only, set through the options │ │ │ │ + * passed to the constructor, │ │ │ │ + * Example: {'bbox': '5,5,5,5'} │ │ │ │ + */ │ │ │ │ + params: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: callback │ │ │ │ + * {Object} Function to be called when the <read>, <create>, │ │ │ │ + * <update>, <delete> or <commit> operation completes, read-only, │ │ │ │ + * set through the options passed to the constructor. │ │ │ │ + */ │ │ │ │ + callback: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: scope │ │ │ │ + * {Object} Callback execution scope, read-only, set through the │ │ │ │ + * options passed to the constructor. │ │ │ │ + */ │ │ │ │ + scope: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: readWithPOST │ │ │ │ + * {Boolean} true if read operations are done with POST requests │ │ │ │ + * instead of GET, defaults to false. │ │ │ │ + */ │ │ │ │ + readWithPOST: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: updateWithPOST │ │ │ │ + * {Boolean} true if update operations are done with POST requests │ │ │ │ + * defaults to false. │ │ │ │ + */ │ │ │ │ + updateWithPOST: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: deleteWithPOST │ │ │ │ + * {Boolean} true if delete operations are done with POST requests │ │ │ │ + * defaults to false. │ │ │ │ + * if true, POST data is set to output of format.write(). │ │ │ │ + */ │ │ │ │ + deleteWithPOST: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: wildcarded. │ │ │ │ + * {Boolean} If true percent signs are added around values │ │ │ │ + * read from LIKE filters, for example if the protocol │ │ │ │ + * read method is passed a LIKE filter whose property │ │ │ │ + * is "foo" and whose value is "bar" the string │ │ │ │ + * "foo__ilike=%bar%" will be sent in the query string; │ │ │ │ + * defaults to false. │ │ │ │ + */ │ │ │ │ + wildcarded: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: srsInBBOX │ │ │ │ + * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ + * Default is false. If true and the layer has a projection object set, │ │ │ │ + * any BBOX filter will be serialized with a fifth item identifying the │ │ │ │ + * projection. E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ + */ │ │ │ │ + srsInBBOX: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Protocol.HTTP │ │ │ │ + * A class for giving layers generic HTTP protocol. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ * instance. │ │ │ │ + * │ │ │ │ + * Valid options include: │ │ │ │ + * url - {String} │ │ │ │ + * headers - {Object} │ │ │ │ + * params - {Object} URL parameters for GET requests │ │ │ │ + * format - {<OpenLayers.Format>} │ │ │ │ + * callback - {Function} │ │ │ │ + * scope - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + this.params = {}; │ │ │ │ + this.headers = {}; │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ + var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ + wildcarded: this.wildcarded, │ │ │ │ + srsInBBOX: this.srsInBBOX │ │ │ │ + }); │ │ │ │ + this.filterToParams = function(filter, params) { │ │ │ │ + return format.write(filter, params); │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the protocol. │ │ │ │ */ │ │ │ │ + destroy: function() { │ │ │ │ + this.params = null; │ │ │ │ + this.headers = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: activate │ │ │ │ - * Activate the strategy: load data or add listener to load when visible │ │ │ │ + * APIMethod: filterToParams │ │ │ │ + * Optional method to translate an <OpenLayers.Filter> object into an object │ │ │ │ + * that can be serialized as request query string provided. If a custom │ │ │ │ + * method is not provided, the filter will be serialized using the │ │ │ │ + * <OpenLayers.Format.QueryStringFilter> class. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ + * params - {Object} The parameters object. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ - * the strategy was already active. │ │ │ │ + * {Object} The resulting parameters object. │ │ │ │ */ │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "refresh": this.load, │ │ │ │ - scope: this │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: read │ │ │ │ + * Construct a request for reading new features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * url - {String} Url for the request. │ │ │ │ + * params - {Object} Parameters to get serialized as a query string. │ │ │ │ + * headers - {Object} Headers to be set on the request. │ │ │ │ + * filter - {<OpenLayers.Filter>} Filter to get serialized as a │ │ │ │ + * query string. │ │ │ │ + * readWithPOST - {Boolean} If the request should be done with POST. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property │ │ │ │ + * references the HTTP request, this object is also passed to the │ │ │ │ + * callback function when the request completes, its "features" property │ │ │ │ + * is then populated with the features received from the server. │ │ │ │ + */ │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = options || {}; │ │ │ │ + options.params = OpenLayers.Util.applyDefaults( │ │ │ │ + options.params, this.options.params); │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + if (options.filter && this.filterToParams) { │ │ │ │ + options.params = this.filterToParams( │ │ │ │ + options.filter, options.params │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + var readWithPOST = (options.readWithPOST !== undefined) ? │ │ │ │ + options.readWithPOST : this.readWithPOST; │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + if (readWithPOST) { │ │ │ │ + var headers = options.headers || {}; │ │ │ │ + headers["Content-Type"] = "application/x-www-form-urlencoded"; │ │ │ │ + resp.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ + data: OpenLayers.Util.getParameterString(options.params), │ │ │ │ + headers: headers │ │ │ │ + }); │ │ │ │ + } else { │ │ │ │ + resp.priv = OpenLayers.Request.GET({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers │ │ │ │ }); │ │ │ │ - if (this.layer.visibility == true || this.preload) { │ │ │ │ - this.load(); │ │ │ │ - } else { │ │ │ │ - this.layer.events.on({ │ │ │ │ - "visibilitychanged": this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ } │ │ │ │ - return activated; │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: deactivate │ │ │ │ - * Deactivate the strategy. Undo what is done in <activate>. │ │ │ │ - * │ │ │ │ + * Method: handleRead │ │ │ │ + * Individual callbacks are created for read, create and update, should │ │ │ │ + * a subclass need to override each one separately. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * the user callback. │ │ │ │ + * options - {Object} The user options passed to the read call. │ │ │ │ + */ │ │ │ │ + handleRead: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: create │ │ │ │ + * Construct a request for writing newly created features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The strategy was successfully deactivated. │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, whose "priv" property references the HTTP request, this │ │ │ │ + * object is also passed to the callback function when the request │ │ │ │ + * completes, its "features" property is then populated with the │ │ │ │ + * the features received from the server. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - "refresh": this.load, │ │ │ │ - "visibilitychanged": this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - return deactivated; │ │ │ │ + create: function(features, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: features, │ │ │ │ + requestType: "create" │ │ │ │ + }); │ │ │ │ + │ │ │ │ + resp.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleCreate, resp, options), │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(features) │ │ │ │ + }); │ │ │ │ + │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: load │ │ │ │ - * Tells protocol to load data and unhooks the visibilitychanged event │ │ │ │ + * Method: handleCreate │ │ │ │ + * Called the the request issued by <create> is complete. May be overridden │ │ │ │ + * by subclasses. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} options to pass to protocol read. │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the create call. │ │ │ │ */ │ │ │ │ - load: function(options) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.events.triggerEvent("loadstart", { │ │ │ │ - filter: layer.filter │ │ │ │ + handleCreate: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: update │ │ │ │ + * Construct a request updating modified feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, whose "priv" property references the HTTP request, this │ │ │ │ + * object is also passed to the callback function when the request │ │ │ │ + * completes, its "features" property is then populated with the │ │ │ │ + * the feature received from the server. │ │ │ │ + */ │ │ │ │ + update: function(feature, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var url = options.url || │ │ │ │ + feature.url || │ │ │ │ + this.options.url + "/" + feature.fid; │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: feature, │ │ │ │ + requestType: "update" │ │ │ │ }); │ │ │ │ - layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: this.merge, │ │ │ │ - filter: layer.filter, │ │ │ │ - scope: this │ │ │ │ - }, options)); │ │ │ │ - layer.events.un({ │ │ │ │ - "visibilitychanged": this.load, │ │ │ │ - scope: this │ │ │ │ + │ │ │ │ + var method = this.updateWithPOST ? "POST" : "PUT"; │ │ │ │ + resp.priv = OpenLayers.Request[method]({ │ │ │ │ + url: url, │ │ │ │ + callback: this.createCallback(this.handleUpdate, resp, options), │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(feature) │ │ │ │ }); │ │ │ │ + │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: merge │ │ │ │ - * Add all features to the layer. │ │ │ │ - * If the layer projection differs from the map projection, features │ │ │ │ - * will be transformed from the layer projection to the map projection. │ │ │ │ + * Method: handleUpdate │ │ │ │ + * Called the the request issued by <update> is complete. May be overridden │ │ │ │ + * by subclasses. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ - * by the protocol. │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the update call. │ │ │ │ */ │ │ │ │ - merge: function(resp) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.destroyFeatures(); │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = layer.projection; │ │ │ │ - var local = layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local); │ │ │ │ - } │ │ │ │ + handleUpdate: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: delete │ │ │ │ + * Construct a request deleting a removed feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + * options - {Object} Optional object for configuring the request. │ │ │ │ + * This object is modified and should not be reused. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ + * object, whose "priv" property references the HTTP request, this │ │ │ │ + * object is also passed to the callback function when the request │ │ │ │ + * completes. │ │ │ │ + */ │ │ │ │ + "delete": function(feature, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var url = options.url || │ │ │ │ + feature.url || │ │ │ │ + this.options.url + "/" + feature.fid; │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: feature, │ │ │ │ + requestType: "delete" │ │ │ │ + }); │ │ │ │ + │ │ │ │ + var method = this.deleteWithPOST ? "POST" : "DELETE"; │ │ │ │ + var requestOptions = { │ │ │ │ + url: url, │ │ │ │ + callback: this.createCallback(this.handleDelete, resp, options), │ │ │ │ + headers: options.headers │ │ │ │ + }; │ │ │ │ + if (this.deleteWithPOST) { │ │ │ │ + requestOptions.data = this.format.write(feature); │ │ │ │ + } │ │ │ │ + resp.priv = OpenLayers.Request[method](requestOptions); │ │ │ │ + │ │ │ │ + return resp; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: handleDelete │ │ │ │ + * Called the the request issued by <delete> is complete. May be overridden │ │ │ │ + * by subclasses. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the delete call. │ │ │ │ + */ │ │ │ │ + handleDelete: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: handleResponse │ │ │ │ + * Called by CRUD specific handlers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ + * any user callback. │ │ │ │ + * options - {Object} The user options passed to the create, read, update, │ │ │ │ + * or delete call. │ │ │ │ + */ │ │ │ │ + handleResponse: function(resp, options) { │ │ │ │ + var request = resp.priv; │ │ │ │ + if (options.callback) { │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + // success │ │ │ │ + if (resp.requestType != "delete") { │ │ │ │ + resp.features = this.parseFeatures(request); │ │ │ │ } │ │ │ │ + resp.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ + } else { │ │ │ │ + // failure │ │ │ │ + resp.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ } │ │ │ │ - layer.addFeatures(features); │ │ │ │ + options.callback.call(options.scope, resp); │ │ │ │ } │ │ │ │ - layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: parseFeatures │ │ │ │ + * Read HTTP response body and return features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * request - {XMLHttpRequest} The request object │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ + * {<OpenLayers.Feature.Vector>} Array of features or a single feature. │ │ │ │ + */ │ │ │ │ + parseFeatures: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText; │ │ │ │ + } │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + return this.format.read(doc); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: commit │ │ │ │ + * Iterate over each feature and take action based on the feature state. │ │ │ │ + * Possible actions are create, update and delete. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * features - {Array({<OpenLayers.Feature.Vector>})} │ │ │ │ + * options - {Object} Optional object for setting up intermediate commit │ │ │ │ + * callbacks. │ │ │ │ + * │ │ │ │ + * Valid options: │ │ │ │ + * create - {Object} Optional object to be passed to the <create> method. │ │ │ │ + * update - {Object} Optional object to be passed to the <update> method. │ │ │ │ + * delete - {Object} Optional object to be passed to the <delete> method. │ │ │ │ + * callback - {Function} Optional function to be called when the commit │ │ │ │ + * is complete. │ │ │ │ + * scope - {Object} Optional object to be set as the scope of the callback. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Protocol.Response>)} An array of response objects, │ │ │ │ + * one per request made to the server, each object's "priv" property │ │ │ │ + * references the corresponding HTTP request. │ │ │ │ + */ │ │ │ │ + commit: function(features, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var resp = [], │ │ │ │ + nResponses = 0; │ │ │ │ + │ │ │ │ + // Divide up features before issuing any requests. This properly │ │ │ │ + // counts requests in the event that any responses come in before │ │ │ │ + // all requests have been issued. │ │ │ │ + var types = {}; │ │ │ │ + types[OpenLayers.State.INSERT] = []; │ │ │ │ + types[OpenLayers.State.UPDATE] = []; │ │ │ │ + types[OpenLayers.State.DELETE] = []; │ │ │ │ + var feature, list, requestFeatures = []; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + list = types[feature.state]; │ │ │ │ + if (list) { │ │ │ │ + list.push(feature); │ │ │ │ + requestFeatures.push(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // tally up number of requests │ │ │ │ + var nRequests = (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) + │ │ │ │ + types[OpenLayers.State.UPDATE].length + │ │ │ │ + types[OpenLayers.State.DELETE].length; │ │ │ │ + │ │ │ │ + // This response will be sent to the final callback after all the others │ │ │ │ + // have been fired. │ │ │ │ + var success = true; │ │ │ │ + var finalResponse = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: requestFeatures │ │ │ │ }); │ │ │ │ + │ │ │ │ + function insertCallback(response) { │ │ │ │ + var len = response.features ? response.features.length : 0; │ │ │ │ + var fids = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + fids[i] = response.features[i].fid; │ │ │ │ + } │ │ │ │ + finalResponse.insertIds = fids; │ │ │ │ + callback.apply(this, [response]); │ │ │ │ + } │ │ │ │ + │ │ │ │ + function callback(response) { │ │ │ │ + this.callUserCallback(response, options); │ │ │ │ + success = success && response.success(); │ │ │ │ + nResponses++; │ │ │ │ + if (nResponses >= nRequests) { │ │ │ │ + if (options.callback) { │ │ │ │ + finalResponse.code = success ? │ │ │ │ + OpenLayers.Protocol.Response.SUCCESS : │ │ │ │ + OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + options.callback.apply(options.scope, [finalResponse]); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + // start issuing requests │ │ │ │ + var queue = types[OpenLayers.State.INSERT]; │ │ │ │ + if (queue.length > 0) { │ │ │ │ + resp.push(this.create( │ │ │ │ + queue, OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: insertCallback, │ │ │ │ + scope: this │ │ │ │ + }, options.create) │ │ │ │ + )); │ │ │ │ + } │ │ │ │ + queue = types[OpenLayers.State.UPDATE]; │ │ │ │ + for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ + resp.push(this.update( │ │ │ │ + queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: callback, │ │ │ │ + scope: this │ │ │ │ + }, options.update))); │ │ │ │ + } │ │ │ │ + queue = types[OpenLayers.State.DELETE]; │ │ │ │ + for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ + resp.push(this["delete"]( │ │ │ │ + queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: callback, │ │ │ │ + scope: this │ │ │ │ + }, options["delete"]))); │ │ │ │ + } │ │ │ │ + return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ + /** │ │ │ │ + * APIMethod: abort │ │ │ │ + * Abort an ongoing request, the response object passed to │ │ │ │ + * this method must come from this HTTP protocol (as a result │ │ │ │ + * of a create, read, update, delete or commit operation). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * response - {<OpenLayers.Protocol.Response>} │ │ │ │ + */ │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + response.priv.abort(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: callUserCallback │ │ │ │ + * This method is used from within the commit method each time an │ │ │ │ + * an HTTP response is received from the server, it is responsible │ │ │ │ + * for calling the user-supplied callbacks. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} │ │ │ │ + * options - {Object} The map of options passed to the commit call. │ │ │ │ + */ │ │ │ │ + callUserCallback: function(resp, options) { │ │ │ │ + var opt = options[resp.requestType]; │ │ │ │ + if (opt && opt.callback) { │ │ │ │ + opt.callback.call(opt.scope, resp); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Renderer/Elements.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -27007,1037 +29845,14 @@ │ │ │ │ return (graphicName != "circle") && !!graphicName; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Renderer.Elements" │ │ │ │ }); │ │ │ │ │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Renderer/SVG.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Renderer/Elements.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Renderer.SVG │ │ │ │ - * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Renderer.Elements> │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: xmlns │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - xmlns: "http://www.w3.org/2000/svg", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: xlinkns │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constant: MAX_PIXEL │ │ │ │ - * {Integer} Firefox has a limitation where values larger or smaller than │ │ │ │ - * about 15000 in an SVG document lock the browser up. This │ │ │ │ - * works around it. │ │ │ │ - */ │ │ │ │ - MAX_PIXEL: 15000, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: translationParameters │ │ │ │ - * {Object} Hash with "x" and "y" properties │ │ │ │ - */ │ │ │ │ - translationParameters: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: symbolMetrics │ │ │ │ - * {Object} Cache for symbol metrics according to their svg coordinate │ │ │ │ - * space. This is an object keyed by the symbol's id, and values are │ │ │ │ - * an array of [width, centerX, centerY]. │ │ │ │ - */ │ │ │ │ - symbolMetrics: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Renderer.SVG │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * containerID - {String} │ │ │ │ - */ │ │ │ │ - initialize: function(containerID) { │ │ │ │ - if (!this.supported()) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - OpenLayers.Renderer.Elements.prototype.initialize.apply(this, │ │ │ │ - arguments); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: 0, │ │ │ │ - y: 0 │ │ │ │ - }; │ │ │ │ - │ │ │ │ - this.symbolMetrics = {}; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: supported │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the browser supports the SVG renderer │ │ │ │ - */ │ │ │ │ - supported: function() { │ │ │ │ - var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ - return (document.implementation && │ │ │ │ - (document.implementation.hasFeature("org.w3c.svg", "1.0") || │ │ │ │ - document.implementation.hasFeature(svgFeature + "SVG", "1.1") || │ │ │ │ - document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1"))); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: inValidRange │ │ │ │ - * See #669 for more information │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Integer} │ │ │ │ - * y - {Integer} │ │ │ │ - * xyOnly - {Boolean} whether or not to just check for x and y, which means │ │ │ │ - * to not take the current translation parameters into account if true. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the 'x' and 'y' coordinates are in the │ │ │ │ - * valid range. │ │ │ │ - */ │ │ │ │ - inValidRange: function(x, y, xyOnly) { │ │ │ │ - var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ - var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ - return (left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && │ │ │ │ - top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setExtent │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * extent - {<OpenLayers.Bounds>} │ │ │ │ - * resolutionChanged - {Boolean} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} true to notify the layer that the new extent does not exceed │ │ │ │ - * the coordinate range, and the features will not need to be redrawn. │ │ │ │ - * False otherwise. │ │ │ │ - */ │ │ │ │ - setExtent: function(extent, resolutionChanged) { │ │ │ │ - var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ - │ │ │ │ - var resolution = this.getResolution(), │ │ │ │ - left = -extent.left / resolution, │ │ │ │ - top = extent.top / resolution; │ │ │ │ - │ │ │ │ - // If the resolution has changed, start over changing the corner, because │ │ │ │ - // the features will redraw. │ │ │ │ - if (resolutionChanged) { │ │ │ │ - this.left = left; │ │ │ │ - this.top = top; │ │ │ │ - // Set the viewbox │ │ │ │ - var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ - │ │ │ │ - this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ - this.translate(this.xOffset, 0); │ │ │ │ - return true; │ │ │ │ - } else { │ │ │ │ - var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ - if (!inRange) { │ │ │ │ - // recenter the coordinate system │ │ │ │ - this.setExtent(extent, true); │ │ │ │ - } │ │ │ │ - return coordSysUnchanged && inRange; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: translate │ │ │ │ - * Transforms the SVG coordinate system │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Float} │ │ │ │ - * y - {Float} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} true if the translation parameters are in the valid coordinates │ │ │ │ - * range, false otherwise. │ │ │ │ - */ │ │ │ │ - translate: function(x, y) { │ │ │ │ - if (!this.inValidRange(x, y, true)) { │ │ │ │ - return false; │ │ │ │ - } else { │ │ │ │ - var transformString = ""; │ │ │ │ - if (x || y) { │ │ │ │ - transformString = "translate(" + x + "," + y + ")"; │ │ │ │ - } │ │ │ │ - this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: x, │ │ │ │ - y: y │ │ │ │ - }; │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setSize │ │ │ │ - * Sets the size of the drawing surface. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * size - {<OpenLayers.Size>} The size of the drawing surface │ │ │ │ - */ │ │ │ │ - setSize: function(size) { │ │ │ │ - OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ - │ │ │ │ - this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ - this.rendererRoot.setAttributeNS(null, "height", this.size.h); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getNodeType │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * style - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The corresponding node type for the specified geometry │ │ │ │ - */ │ │ │ │ - getNodeType: function(geometry, style) { │ │ │ │ - var nodeType = null; │ │ │ │ - switch (geometry.CLASS_NAME) { │ │ │ │ - case "OpenLayers.Geometry.Point": │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - nodeType = "image"; │ │ │ │ - } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "svg"; │ │ │ │ - } else { │ │ │ │ - nodeType = "circle"; │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "rect"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LineString": │ │ │ │ - nodeType = "polyline"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LinearRing": │ │ │ │ - nodeType = "polygon"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Polygon": │ │ │ │ - case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "path"; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - return nodeType; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setStyle │ │ │ │ - * Use to set all the style attributes to a SVG node. │ │ │ │ - * │ │ │ │ - * Takes care to adjust stroke width and point radius to be │ │ │ │ - * resolution-relative │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {SVGDomElement} An SVG element to decorate │ │ │ │ - * style - {Object} │ │ │ │ - * options - {Object} Currently supported options include │ │ │ │ - * 'isFilled' {Boolean} and │ │ │ │ - * 'isStroked' {Boolean} │ │ │ │ - */ │ │ │ │ - setStyle: function(node, style, options) { │ │ │ │ - style = style || node._style; │ │ │ │ - options = options || node._options; │ │ │ │ - │ │ │ │ - var title = style.title || style.graphicTitle; │ │ │ │ - if (title) { │ │ │ │ - node.setAttributeNS(null, "title", title); │ │ │ │ - //Standards-conformant SVG │ │ │ │ - // Prevent duplicate nodes. See issue https://github.com/openlayers/openlayers/issues/92 │ │ │ │ - var titleNode = node.getElementsByTagName("title"); │ │ │ │ - if (titleNode.length > 0) { │ │ │ │ - titleNode[0].firstChild.textContent = title; │ │ │ │ - } else { │ │ │ │ - var label = this.nodeFactory(null, "title"); │ │ │ │ - label.textContent = title; │ │ │ │ - node.appendChild(label); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ - var widthFactor = 1; │ │ │ │ - var pos; │ │ │ │ - if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ - node.style.visibility = ""; │ │ │ │ - if (style.graphic === false) { │ │ │ │ - node.style.visibility = "hidden"; │ │ │ │ - } else if (style.externalGraphic) { │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - if (style.graphicWidth && style.graphicHeight) { │ │ │ │ - node.setAttributeNS(null, "preserveAspectRatio", "none"); │ │ │ │ - } │ │ │ │ - var width = style.graphicWidth || style.graphicHeight; │ │ │ │ - var height = style.graphicHeight || style.graphicWidth; │ │ │ │ - width = width ? width : style.pointRadius * 2; │ │ │ │ - height = height ? height : style.pointRadius * 2; │ │ │ │ - var xOffset = (style.graphicXOffset != undefined) ? │ │ │ │ - style.graphicXOffset : -(0.5 * width); │ │ │ │ - var yOffset = (style.graphicYOffset != undefined) ? │ │ │ │ - style.graphicYOffset : -(0.5 * height); │ │ │ │ - │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ - │ │ │ │ - node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "width", width); │ │ │ │ - node.setAttributeNS(null, "height", height); │ │ │ │ - node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ - node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ - node.onclick = OpenLayers.Event.preventDefault; │ │ │ │ - } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - // the symbol viewBox is three times as large as the symbol │ │ │ │ - var offset = style.pointRadius * 3; │ │ │ │ - var size = offset * 2; │ │ │ │ - var src = this.importSymbol(style.graphicName); │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ - │ │ │ │ - // remove the node from the dom before we modify it. This │ │ │ │ - // prevents various rendering issues in Safari and FF │ │ │ │ - var parent = node.parentNode; │ │ │ │ - var nextSibling = node.nextSibling; │ │ │ │ - if (parent) { │ │ │ │ - parent.removeChild(node); │ │ │ │ - } │ │ │ │ - │ │ │ │ - // The more appropriate way to implement this would be use/defs, │ │ │ │ - // but due to various issues in several browsers, it is safer to │ │ │ │ - // copy the symbols instead of referencing them. │ │ │ │ - // See e.g. ticket http://trac.osgeo.org/openlayers/ticket/2985 │ │ │ │ - // and this email thread │ │ │ │ - // http://osgeo-org.1803224.n2.nabble.com/Select-Control-Ctrl-click-on-Feature-with-a-graphicName-opens-new-browser-window-tc5846039.html │ │ │ │ - node.firstChild && node.removeChild(node.firstChild); │ │ │ │ - node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ - node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ - │ │ │ │ - node.setAttributeNS(null, "width", size); │ │ │ │ - node.setAttributeNS(null, "height", size); │ │ │ │ - node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ - node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ - │ │ │ │ - // now that the node has all its new properties, insert it │ │ │ │ - // back into the dom where it was │ │ │ │ - if (nextSibling) { │ │ │ │ - parent.insertBefore(node, nextSibling); │ │ │ │ - } else if (parent) { │ │ │ │ - parent.appendChild(node); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "r", style.pointRadius); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var rotation = style.rotation; │ │ │ │ - │ │ │ │ - if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - rotation |= 0; │ │ │ │ - if (node.nodeName !== "svg") { │ │ │ │ - node.setAttributeNS(null, "transform", │ │ │ │ - "rotate(" + rotation + " " + pos.x + " " + │ │ │ │ - pos.y + ")"); │ │ │ │ - } else { │ │ │ │ - var metrics = this.symbolMetrics[src.id]; │ │ │ │ - node.firstChild.setAttributeNS(null, "transform", "rotate(" + │ │ │ │ - rotation + " " + │ │ │ │ - metrics[1] + " " + │ │ │ │ - metrics[2] + ")"); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (options.isFilled) { │ │ │ │ - node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ - node.setAttributeNS(null, "fill-opacity", style.fillOpacity); │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "fill", "none"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (options.isStroked) { │ │ │ │ - node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ - node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ - node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ - node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ - // Hard-coded linejoin for now, to make it look the same as in VML. │ │ │ │ - // There is no strokeLinejoin property yet for symbolizers. │ │ │ │ - node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ - style.strokeDashstyle && node.setAttributeNS(null, │ │ │ │ - "stroke-dasharray", this.dashStyle(style, widthFactor)); │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "stroke", "none"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (style.pointerEvents) { │ │ │ │ - node.setAttributeNS(null, "pointer-events", style.pointerEvents); │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (style.cursor != null) { │ │ │ │ - node.setAttributeNS(null, "cursor", style.cursor); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: dashStyle │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * style - {Object} │ │ │ │ - * widthFactor - {Number} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A SVG compliant 'stroke-dasharray' value │ │ │ │ - */ │ │ │ │ - dashStyle: function(style, widthFactor) { │ │ │ │ - var w = style.strokeWidth * widthFactor; │ │ │ │ - var str = style.strokeDashstyle; │ │ │ │ - switch (str) { │ │ │ │ - case 'solid': │ │ │ │ - return 'none'; │ │ │ │ - case 'dot': │ │ │ │ - return [1, 4 * w].join(); │ │ │ │ - case 'dash': │ │ │ │ - return [4 * w, 4 * w].join(); │ │ │ │ - case 'dashdot': │ │ │ │ - return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ - case 'longdash': │ │ │ │ - return [8 * w, 4 * w].join(); │ │ │ │ - case 'longdashdot': │ │ │ │ - return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ - default: │ │ │ │ - return OpenLayers.String.trim(str).replace(/\s+/g, ","); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createNode │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * type - {String} Kind of node to draw │ │ │ │ - * id - {String} Id for node │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} A new node of the given type and id │ │ │ │ - */ │ │ │ │ - createNode: function(type, id) { │ │ │ │ - var node = document.createElementNS(this.xmlns, type); │ │ │ │ - if (id) { │ │ │ │ - node.setAttributeNS(null, "id", id); │ │ │ │ - } │ │ │ │ - return node; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: nodeTypeCompare │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {SVGDomElement} An SVG element │ │ │ │ - * type - {String} Kind of node │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the specified node is of the specified type │ │ │ │ - */ │ │ │ │ - nodeTypeCompare: function(node, type) { │ │ │ │ - return (type == node.nodeName); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createRenderRoot │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The specific render engine's root element │ │ │ │ - */ │ │ │ │ - createRenderRoot: function() { │ │ │ │ - var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ - svg.style.display = "block"; │ │ │ │ - return svg; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createRoot │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * suffix - {String} suffix to append to the id │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} │ │ │ │ - */ │ │ │ │ - createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "g"); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: createDefs │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The element to which we'll add the symbol definitions │ │ │ │ - */ │ │ │ │ - createDefs: function() { │ │ │ │ - var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ - this.rendererRoot.appendChild(defs); │ │ │ │ - return defs; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /************************************** │ │ │ │ - * * │ │ │ │ - * GEOMETRY DRAWING FUNCTIONS * │ │ │ │ - * * │ │ │ │ - **************************************/ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawPoint │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} or false if the renderer could not draw the point │ │ │ │ - */ │ │ │ │ - drawPoint: function(node, geometry) { │ │ │ │ - return this.drawCircle(node, geometry, 1); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawCircle │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * radius - {Float} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} or false if the renderer could not draw the circle │ │ │ │ - */ │ │ │ │ - drawCircle: function(node, geometry, radius) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (this.top - geometry.y / resolution); │ │ │ │ - │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "cx", x); │ │ │ │ - node.setAttributeNS(null, "cy", y); │ │ │ │ - node.setAttributeNS(null, "r", radius); │ │ │ │ - return node; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawLineString │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} or null if the renderer could not draw all components of │ │ │ │ - * the linestring, or false if nothing could be drawn │ │ │ │ - */ │ │ │ │ - drawLineString: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return (componentsResult.complete ? node : null); │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawLinearRing │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} or null if the renderer could not draw all components │ │ │ │ - * of the linear ring, or false if nothing could be drawn │ │ │ │ - */ │ │ │ │ - drawLinearRing: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return (componentsResult.complete ? node : null); │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawPolygon │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} or null if the renderer could not draw all components │ │ │ │ - * of the polygon, or false if nothing could be drawn │ │ │ │ - */ │ │ │ │ - drawPolygon: function(node, geometry) { │ │ │ │ - var d = ""; │ │ │ │ - var draw = true; │ │ │ │ - var complete = true; │ │ │ │ - var linearRingResult, path; │ │ │ │ - for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ - d += " M"; │ │ │ │ - linearRingResult = this.getComponentsString( │ │ │ │ - geometry.components[j].components, " "); │ │ │ │ - path = linearRingResult.path; │ │ │ │ - if (path) { │ │ │ │ - d += " " + path; │ │ │ │ - complete = linearRingResult.complete && complete; │ │ │ │ - } else { │ │ │ │ - draw = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - d += " z"; │ │ │ │ - if (draw) { │ │ │ │ - node.setAttributeNS(null, "d", d); │ │ │ │ - node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ - return complete ? node : null; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawRectangle │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} or false if the renderer could not draw the rectangle │ │ │ │ - */ │ │ │ │ - drawRectangle: function(node, geometry) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (this.top - geometry.y / resolution); │ │ │ │ - │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "x", x); │ │ │ │ - node.setAttributeNS(null, "y", y); │ │ │ │ - node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ - node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ - return node; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: drawText │ │ │ │ - * This method is only called by the renderer itself. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * featureId - {String} │ │ │ │ - * style - │ │ │ │ - * location - {<OpenLayers.Geometry.Point>} │ │ │ │ - */ │ │ │ │ - drawText: function(featureId, style, location) { │ │ │ │ - var drawOutline = (!!style.labelOutlineWidth); │ │ │ │ - // First draw text in halo color and size and overlay the │ │ │ │ - // normal text afterwards │ │ │ │ - if (drawOutline) { │ │ │ │ - var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ - outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ - if (style.labelOutlineOpacity) { │ │ │ │ - outlineStyle.fontOpacity = style.labelOutlineOpacity; │ │ │ │ - } │ │ │ │ - delete outlineStyle.labelOutlineWidth; │ │ │ │ - this.drawText(featureId, outlineStyle, location); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - │ │ │ │ - var x = ((location.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (location.y / resolution - this.top); │ │ │ │ - │ │ │ │ - var suffix = (drawOutline) ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ - var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ - │ │ │ │ - label.setAttributeNS(null, "x", x); │ │ │ │ - label.setAttributeNS(null, "y", -y); │ │ │ │ - │ │ │ │ - if (style.fontColor) { │ │ │ │ - label.setAttributeNS(null, "fill", style.fontColor); │ │ │ │ - } │ │ │ │ - if (style.fontStrokeColor) { │ │ │ │ - label.setAttributeNS(null, "stroke", style.fontStrokeColor); │ │ │ │ - } │ │ │ │ - if (style.fontStrokeWidth) { │ │ │ │ - label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth); │ │ │ │ - } │ │ │ │ - if (style.fontOpacity) { │ │ │ │ - label.setAttributeNS(null, "opacity", style.fontOpacity); │ │ │ │ - } │ │ │ │ - if (style.fontFamily) { │ │ │ │ - label.setAttributeNS(null, "font-family", style.fontFamily); │ │ │ │ - } │ │ │ │ - if (style.fontSize) { │ │ │ │ - label.setAttributeNS(null, "font-size", style.fontSize); │ │ │ │ - } │ │ │ │ - if (style.fontWeight) { │ │ │ │ - label.setAttributeNS(null, "font-weight", style.fontWeight); │ │ │ │ - } │ │ │ │ - if (style.fontStyle) { │ │ │ │ - label.setAttributeNS(null, "font-style", style.fontStyle); │ │ │ │ - } │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ - label._featureId = featureId; │ │ │ │ - } else { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "none"); │ │ │ │ - } │ │ │ │ - var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ - label.setAttributeNS(null, "text-anchor", │ │ │ │ - OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ - │ │ │ │ - if (OpenLayers.IS_GECKO === true) { │ │ │ │ - label.setAttributeNS(null, "dominant-baseline", │ │ │ │ - OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var labelRows = style.label.split('\n'); │ │ │ │ - var numRows = labelRows.length; │ │ │ │ - while (label.childNodes.length > numRows) { │ │ │ │ - label.removeChild(label.lastChild); │ │ │ │ - } │ │ │ │ - for (var i = 0; i < numRows; i++) { │ │ │ │ - var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - tspan._featureId = featureId; │ │ │ │ - tspan._geometry = location; │ │ │ │ - tspan._geometryClass = location.CLASS_NAME; │ │ │ │ - } │ │ │ │ - if (OpenLayers.IS_GECKO === false) { │ │ │ │ - tspan.setAttributeNS(null, "baseline-shift", │ │ │ │ - OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%"); │ │ │ │ - } │ │ │ │ - tspan.setAttribute("x", x); │ │ │ │ - if (i == 0) { │ │ │ │ - var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ - if (vfactor == null) { │ │ │ │ - vfactor = -.5; │ │ │ │ - } │ │ │ │ - tspan.setAttribute("dy", (vfactor * (numRows - 1)) + "em"); │ │ │ │ - } else { │ │ │ │ - tspan.setAttribute("dy", "1em"); │ │ │ │ - } │ │ │ │ - tspan.textContent = (labelRows[i] === '') ? ' ' : labelRows[i]; │ │ │ │ - if (!tspan.parentNode) { │ │ │ │ - label.appendChild(tspan); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (!label.parentNode) { │ │ │ │ - this.textRoot.appendChild(label); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getComponentString │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry.Point>)} Array of points │ │ │ │ - * separator - {String} character between coordinate pairs. Defaults to "," │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} hash with properties "path" (the string created from the │ │ │ │ - * components and "complete" (false if the renderer was unable to │ │ │ │ - * draw all components) │ │ │ │ - */ │ │ │ │ - getComponentsString: function(components, separator) { │ │ │ │ - var renderCmp = []; │ │ │ │ - var complete = true; │ │ │ │ - var len = components.length; │ │ │ │ - var strings = []; │ │ │ │ - var str, component; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - component = components[i]; │ │ │ │ - renderCmp.push(component); │ │ │ │ - str = this.getShortString(component); │ │ │ │ - if (str) { │ │ │ │ - strings.push(str); │ │ │ │ - } else { │ │ │ │ - // The current component is outside the valid range. Let's │ │ │ │ - // see if the previous or next component is inside the range. │ │ │ │ - // If so, add the coordinate of the intersection with the │ │ │ │ - // valid range bounds. │ │ │ │ - if (i > 0) { │ │ │ │ - if (this.getShortString(components[i - 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], │ │ │ │ - components[i - 1])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i < len - 1) { │ │ │ │ - if (this.getShortString(components[i + 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], │ │ │ │ - components[i + 1])); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - complete = false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - path: strings.join(separator || ","), │ │ │ │ - complete: complete │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clipLine │ │ │ │ - * Given two points (one inside the valid range, and one outside), │ │ │ │ - * clips the line betweeen the two points so that the new points are both │ │ │ │ - * inside the valid range. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * badComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ - * invalid point │ │ │ │ - * goodComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ - * valid point │ │ │ │ - * Returns │ │ │ │ - * {String} the SVG coordinate pair of the clipped point (like │ │ │ │ - * getShortString), or an empty string if both passed componets are at │ │ │ │ - * the same point. │ │ │ │ - */ │ │ │ │ - clipLine: function(badComponent, goodComponent) { │ │ │ │ - if (goodComponent.equals(badComponent)) { │ │ │ │ - return ""; │ │ │ │ - } │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ - var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ - var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y1 = this.top - goodComponent.y / resolution; │ │ │ │ - var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y2 = this.top - badComponent.y / resolution; │ │ │ │ - var k; │ │ │ │ - if (x2 < -maxX || x2 > maxX) { │ │ │ │ - k = (y2 - y1) / (x2 - x1); │ │ │ │ - x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ - y2 = y1 + (x2 - x1) * k; │ │ │ │ - } │ │ │ │ - if (y2 < -maxY || y2 > maxY) { │ │ │ │ - k = (x2 - x1) / (y2 - y1); │ │ │ │ - y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ - x2 = x1 + (y2 - y1) * k; │ │ │ │ - } │ │ │ │ - return x2 + "," + y2; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getShortString │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} or false if point is outside the valid range │ │ │ │ - */ │ │ │ │ - getShortString: function(point) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = ((point.x - this.featureDx) / resolution + this.left); │ │ │ │ - var y = (this.top - point.y / resolution); │ │ │ │ - │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - return x + "," + y; │ │ │ │ - } else { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getPosition │ │ │ │ - * Finds the position of an svg node. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * node - {DOMElement} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} hash with x and y properties, representing the coordinates │ │ │ │ - * within the svg coordinate system │ │ │ │ - */ │ │ │ │ - getPosition: function(node) { │ │ │ │ - return ({ │ │ │ │ - x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ - y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: importSymbol │ │ │ │ - * add a new symbol definition from the rendererer's symbol hash │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * graphicName - {String} name of the symbol to import │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} - the imported symbol │ │ │ │ - */ │ │ │ │ - importSymbol: function(graphicName) { │ │ │ │ - if (!this.defs) { │ │ │ │ - // create svg defs tag │ │ │ │ - this.defs = this.createDefs(); │ │ │ │ - } │ │ │ │ - var id = this.container.id + "-" + graphicName; │ │ │ │ - │ │ │ │ - // check if symbol already exists in the defs │ │ │ │ - var existing = document.getElementById(id); │ │ │ │ - if (existing != null) { │ │ │ │ - return existing; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ - if (!symbol) { │ │ │ │ - throw new Error(graphicName + ' is not a valid symbol name'); │ │ │ │ - } │ │ │ │ - │ │ │ │ - var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ - var node = this.nodeFactory(null, "polygon"); │ │ │ │ - symbolNode.appendChild(node); │ │ │ │ - var symbolExtent = new OpenLayers.Bounds( │ │ │ │ - Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ - │ │ │ │ - var points = []; │ │ │ │ - var x, y; │ │ │ │ - for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - x = symbol[i]; │ │ │ │ - y = symbol[i + 1]; │ │ │ │ - symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ - symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ - symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ - symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - points.push(x, ",", y); │ │ │ │ - } │ │ │ │ - │ │ │ │ - node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ - │ │ │ │ - var width = symbolExtent.getWidth(); │ │ │ │ - var height = symbolExtent.getHeight(); │ │ │ │ - // create a viewBox three times as large as the symbol itself, │ │ │ │ - // to allow for strokeWidth being displayed correctly at the corners. │ │ │ │ - var viewBox = [symbolExtent.left - width, │ │ │ │ - symbolExtent.bottom - height, width * 3, height * 3 │ │ │ │ - ]; │ │ │ │ - symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ - this.symbolMetrics[id] = [ │ │ │ │ - Math.max(width, height), │ │ │ │ - symbolExtent.getCenterLonLat().lon, │ │ │ │ - symbolExtent.getCenterLonLat().lat │ │ │ │ - ]; │ │ │ │ - │ │ │ │ - this.defs.appendChild(symbolNode); │ │ │ │ - return symbolNode; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getFeatureIdFromEvent │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Object} An <OpenLayers.Event> object │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A feature id or undefined. │ │ │ │ - */ │ │ │ │ - getFeatureIdFromEvent: function(evt) { │ │ │ │ - var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ - if (!featureId) { │ │ │ │ - var target = evt.target; │ │ │ │ - featureId = target.parentNode && target != this.rendererRoot ? │ │ │ │ - target.parentNode._featureId : undefined; │ │ │ │ - } │ │ │ │ - return featureId; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Renderer.SVG.LABEL_ALIGN │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ - "l": "start", │ │ │ │ - "r": "end", │ │ │ │ - "b": "bottom", │ │ │ │ - "t": "hanging" │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Renderer.SVG.LABEL_VSHIFT │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ - // according to │ │ │ │ - // http://www.w3.org/Graphics/SVG/Test/20061213/htmlObjectHarness/full-text-align-02-b.html │ │ │ │ - // a baseline-shift of -70% shifts the text exactly from the │ │ │ │ - // bottom to the top of the baseline, so -35% moves the text to │ │ │ │ - // the center of the baseline. │ │ │ │ - "t": "-70%", │ │ │ │ - "b": "0" │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Renderer.SVG.LABEL_VFACTOR │ │ │ │ - * {Object} │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ - "t": 0, │ │ │ │ - "b": -1 │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Renderer.SVG.preventDefault │ │ │ │ - * *Deprecated*. Use <OpenLayers.Event.preventDefault> method instead. │ │ │ │ - * Used to prevent default events (especially opening images in a new tab on │ │ │ │ - * ctrl-click) from being executed for externalGraphic symbols │ │ │ │ - */ │ │ │ │ -OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ - OpenLayers.Event.preventDefault(e); │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Renderer/VML.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -29022,8497 +30837,6682 @@ │ │ │ │ "c": .5, │ │ │ │ "r": 1, │ │ │ │ "t": 0, │ │ │ │ "m": .5, │ │ │ │ "b": 1 │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format.js │ │ │ │ + OpenLayers/Renderer/SVG.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Renderer/Elements.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. │ │ │ │ + * Class: OpenLayers.Renderer.SVG │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Renderer.Elements> │ │ │ │ */ │ │ │ │ -OpenLayers.Format = OpenLayers.Class({ │ │ │ │ +OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: options │ │ │ │ - * {Object} A reference to options passed to the constructor. │ │ │ │ + /** │ │ │ │ + * Property: xmlns │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - options: null, │ │ │ │ + xmlns: "http://www.w3.org/2000/svg", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: externalProjection │ │ │ │ - * {<OpenLayers.Projection>} 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 │ │ │ │ - * {<OpenLayers.Projection.addTransform>} for more information on │ │ │ │ - * custom transformations. │ │ │ │ + * Property: xlinkns │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - externalProjection: null, │ │ │ │ + xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: internalProjection │ │ │ │ - * {<OpenLayers.Projection>} 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 │ │ │ │ - * {<OpenLayers.Projection.addTransform>} for more information on │ │ │ │ - * custom transformations. │ │ │ │ + * Constant: MAX_PIXEL │ │ │ │ + * {Integer} Firefox has a limitation where values larger or smaller than │ │ │ │ + * about 15000 in an SVG document lock the browser up. This │ │ │ │ + * works around it. │ │ │ │ */ │ │ │ │ - internalProjection: null, │ │ │ │ + MAX_PIXEL: 15000, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: data │ │ │ │ - * {Object} When <keepData> is true, this is the parsed string sent to │ │ │ │ - * <read>. │ │ │ │ + * Property: translationParameters │ │ │ │ + * {Object} Hash with "x" and "y" properties │ │ │ │ */ │ │ │ │ - data: null, │ │ │ │ + translationParameters: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: keepData │ │ │ │ - * {Object} Maintain a reference (<data>) to the most recently read data. │ │ │ │ - * Default is false. │ │ │ │ + * Property: symbolMetrics │ │ │ │ + * {Object} Cache for symbol metrics according to their svg coordinate │ │ │ │ + * space. This is an object keyed by the symbol's id, and values are │ │ │ │ + * an array of [width, centerX, centerY]. │ │ │ │ */ │ │ │ │ - keepData: false, │ │ │ │ + symbolMetrics: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format │ │ │ │ - * Instances of this class are not useful. See one of the subclasses. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Renderer.SVG │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * format │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * keepData - {Boolean} If true, upon <read>, the data property will be │ │ │ │ - * set to the parsed object (e.g. the json or xml object). │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * An instance of OpenLayers.Format │ │ │ │ + * containerID - {String} │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options; │ │ │ │ - }, │ │ │ │ + initialize: function(containerID) { │ │ │ │ + if (!this.supported()) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + OpenLayers.Renderer.Elements.prototype.initialize.apply(this, │ │ │ │ + arguments); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: 0, │ │ │ │ + y: 0 │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up. │ │ │ │ - */ │ │ │ │ - destroy: function() {}, │ │ │ │ + this.symbolMetrics = {}; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: read │ │ │ │ - * Read data from a string, and return an object whose type depends on the │ │ │ │ - * subclass. │ │ │ │ + * APIMethod: supported │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * data - {string} Data to read/parse. │ │ │ │ - * │ │ │ │ * Returns: │ │ │ │ - * Depends on the subclass │ │ │ │ + * {Boolean} Whether or not the browser supports the SVG renderer │ │ │ │ */ │ │ │ │ - read: function(data) { │ │ │ │ - throw new Error('Read not implemented.'); │ │ │ │ + supported: function() { │ │ │ │ + var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ + return (document.implementation && │ │ │ │ + (document.implementation.hasFeature("org.w3c.svg", "1.0") || │ │ │ │ + document.implementation.hasFeature(svgFeature + "SVG", "1.1") || │ │ │ │ + document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1"))); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: write │ │ │ │ - * Accept an object, and return a string. │ │ │ │ + * Method: inValidRange │ │ │ │ + * See #669 for more information │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * object - {Object} Object to be serialized │ │ │ │ - * │ │ │ │ + * x - {Integer} │ │ │ │ + * y - {Integer} │ │ │ │ + * xyOnly - {Boolean} whether or not to just check for x and y, which means │ │ │ │ + * to not take the current translation parameters into account if true. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} A string representation of the object. │ │ │ │ + * {Boolean} Whether or not the 'x' and 'y' coordinates are in the │ │ │ │ + * valid range. │ │ │ │ */ │ │ │ │ - write: function(object) { │ │ │ │ - throw new Error('Write not implemented.'); │ │ │ │ + inValidRange: function(x, y, xyOnly) { │ │ │ │ + var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ + var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ + return (left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && │ │ │ │ + top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Format/JSON.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository 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 │ │ │ │ - * <OpenLayers.Format.JSON> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format> │ │ │ │ - */ │ │ │ │ -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 <write> method. │ │ │ │ - */ │ │ │ │ - pretty: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: nativeJSON │ │ │ │ - * {Boolean} Does the browser support native json? │ │ │ │ - */ │ │ │ │ - nativeJSON: (function() { │ │ │ │ - return !!(window.JSON && typeof JSON.parse == "function" && typeof JSON.stringify == "function"); │ │ │ │ - })(), │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Format.JSON │ │ │ │ - * Create a new parser for JSON. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Deserialize a json string. │ │ │ │ - * │ │ │ │ + * Method: setExtent │ │ │ │ + * │ │ │ │ * 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. │ │ │ │ - * │ │ │ │ + * extent - {<OpenLayers.Bounds>} │ │ │ │ + * resolutionChanged - {Boolean} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object, array, string, or number . │ │ │ │ + * {Boolean} true to notify the layer that the new extent does not exceed │ │ │ │ + * the coordinate range, and the features will not need to be redrawn. │ │ │ │ + * False otherwise. │ │ │ │ */ │ │ │ │ - read: function(json, filter) { │ │ │ │ - var object; │ │ │ │ - if (this.nativeJSON) { │ │ │ │ - object = JSON.parse(json, filter); │ │ │ │ - } else try { │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ - */ │ │ │ │ - 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. │ │ │ │ - */ │ │ │ │ - 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); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } catch (e) { │ │ │ │ - // Fall through if the regexp test fails. │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (this.keepData) { │ │ │ │ - this.data = object; │ │ │ │ - } │ │ │ │ + setExtent: function(extent, resolutionChanged) { │ │ │ │ + var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ │ │ │ │ - return object; │ │ │ │ - }, │ │ │ │ + var resolution = this.getResolution(), │ │ │ │ + left = -extent.left / resolution, │ │ │ │ + top = extent.top / resolution; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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]) { │ │ │ │ - try { │ │ │ │ - json = (!this.pretty && this.nativeJSON) ? │ │ │ │ - JSON.stringify(value) : │ │ │ │ - this.serialize[type].apply(this, [value]); │ │ │ │ - } catch (err) { │ │ │ │ - OpenLayers.Console.error("Trouble serializing: " + err); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return json; │ │ │ │ - }, │ │ │ │ + // If the resolution has changed, start over changing the corner, because │ │ │ │ + // the features will redraw. │ │ │ │ + if (resolutionChanged) { │ │ │ │ + this.left = left; │ │ │ │ + this.top = top; │ │ │ │ + // Set the viewbox │ │ │ │ + var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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 < this.level; ++i) { │ │ │ │ - pieces.push(this.indent); │ │ │ │ + this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ + this.translate(this.xOffset, 0); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ + if (!inRange) { │ │ │ │ + // recenter the coordinate system │ │ │ │ + this.setExtent(extent, true); │ │ │ │ } │ │ │ │ + return coordSysUnchanged && inRange; │ │ │ │ } │ │ │ │ - return pieces.join(''); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: writeNewline │ │ │ │ - * Output a string representing a newline if in pretty printing mode. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string representing a new line. │ │ │ │ - */ │ │ │ │ - writeNewline: function() { │ │ │ │ - return (this.pretty) ? this.newline : ''; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: writeSpace │ │ │ │ - * Output a string representing a space if in pretty printing mode. │ │ │ │ - * │ │ │ │ + * Method: translate │ │ │ │ + * Transforms the SVG coordinate system │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * x - {Float} │ │ │ │ + * y - {Float} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} A space. │ │ │ │ - */ │ │ │ │ - writeSpace: function() { │ │ │ │ - return (this.pretty) ? this.space : ''; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: serialize │ │ │ │ - * Object with properties corresponding to the serializable data types. │ │ │ │ - * Property values are functions that do the actual serializing. │ │ │ │ + * {Boolean} true if the translation parameters are in the valid coordinates │ │ │ │ + * range, false otherwise. │ │ │ │ */ │ │ │ │ - serialize: { │ │ │ │ - /** │ │ │ │ - * Method: serialize.object │ │ │ │ - * Transform an object into a JSON string. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * object - {Object} The object to be serialized. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A JSON string representing the object. │ │ │ │ - */ │ │ │ │ - 'object': function(object) { │ │ │ │ - // three special objects that we want to treat differently │ │ │ │ - if (object == null) { │ │ │ │ - return "null"; │ │ │ │ - } │ │ │ │ - if (object.constructor == Date) { │ │ │ │ - return this.serialize.date.apply(this, [object]); │ │ │ │ - } │ │ │ │ - if (object.constructor == Array) { │ │ │ │ - return this.serialize.array.apply(this, [object]); │ │ │ │ - } │ │ │ │ - var pieces = ['{']; │ │ │ │ - this.level += 1; │ │ │ │ - var key, keyJSON, valueJSON; │ │ │ │ - │ │ │ │ - var addComma = false; │ │ │ │ - for (key in object) { │ │ │ │ - if (object.hasOwnProperty(key)) { │ │ │ │ - // recursive calls need to allow for sub-classing │ │ │ │ - keyJSON = OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ - [key, this.pretty]); │ │ │ │ - valueJSON = OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ - [object[key], this.pretty]); │ │ │ │ - if (keyJSON != null && valueJSON != null) { │ │ │ │ - if (addComma) { │ │ │ │ - pieces.push(','); │ │ │ │ - } │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), │ │ │ │ - keyJSON, ':', this.writeSpace(), valueJSON); │ │ │ │ - addComma = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.level -= 1; │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), '}'); │ │ │ │ - return pieces.join(''); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: serialize.array │ │ │ │ - * Transform an array into a JSON string. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Array} The array to be serialized │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A JSON string representing the array. │ │ │ │ - */ │ │ │ │ - 'array': function(array) { │ │ │ │ - var json; │ │ │ │ - var pieces = ['[']; │ │ │ │ - this.level += 1; │ │ │ │ - │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - // recursive calls need to allow for sub-classing │ │ │ │ - json = OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ - [array[i], this.pretty]); │ │ │ │ - if (json != null) { │ │ │ │ - if (i > 0) { │ │ │ │ - pieces.push(','); │ │ │ │ - } │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), json); │ │ │ │ - } │ │ │ │ + translate: function(x, y) { │ │ │ │ + if (!this.inValidRange(x, y, true)) { │ │ │ │ + return false; │ │ │ │ + } else { │ │ │ │ + var transformString = ""; │ │ │ │ + if (x || y) { │ │ │ │ + transformString = "translate(" + x + "," + y + ")"; │ │ │ │ } │ │ │ │ - │ │ │ │ - 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', │ │ │ │ - '"': '\\"', │ │ │ │ - '\\': '\\\\' │ │ │ │ + this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: x, │ │ │ │ + y: y │ │ │ │ }; │ │ │ │ - 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()) + '"'; │ │ │ │ + return true; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.JSON" │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry │ │ │ │ - * A Geometry is a description of a geographic object. Create an instance of │ │ │ │ - * this class with the <OpenLayers.Geometry> constructor. This is a base class, │ │ │ │ - * typical geometry types are described by subclasses of this class. │ │ │ │ - * │ │ │ │ - * Note that if you use the <OpenLayers.Geometry.fromWKT> method, you must │ │ │ │ - * explicitly include the OpenLayers.Format.WKT in your build. │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} A unique identifier for this geometry. │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: parent │ │ │ │ - * {<OpenLayers.Geometry>}This is set when a Geometry is added as component │ │ │ │ - * of another geometry │ │ │ │ - */ │ │ │ │ - parent: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: bounds │ │ │ │ - * {<OpenLayers.Bounds>} The bounds of this geometry │ │ │ │ - */ │ │ │ │ - bounds: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry │ │ │ │ - * Creates a geometry object. │ │ │ │ - */ │ │ │ │ - initialize: function() { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - }, │ │ │ │ - │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - * Destroy this geometry. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.id = null; │ │ │ │ - this.bounds = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Create a clone of this geometry. Does not set any non-standard │ │ │ │ - * properties of the cloned geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} An exact clone of this geometry. │ │ │ │ - */ │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Geometry(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setBounds │ │ │ │ - * Set the bounds for this Geometry. │ │ │ │ + * Method: setSize │ │ │ │ + * Sets the size of the drawing surface. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ + * size - {<OpenLayers.Size>} The size of the drawing surface │ │ │ │ */ │ │ │ │ - setBounds: function(bounds) { │ │ │ │ - if (bounds) { │ │ │ │ - this.bounds = bounds.clone(); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + setSize: function(size) { │ │ │ │ + OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: clearBounds │ │ │ │ - * Nullify this components bounds and that of its parent as well. │ │ │ │ - */ │ │ │ │ - clearBounds: function() { │ │ │ │ - this.bounds = null; │ │ │ │ - if (this.parent) { │ │ │ │ - this.parent.clearBounds(); │ │ │ │ - } │ │ │ │ + this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ + this.rendererRoot.setAttributeNS(null, "height", this.size.h); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extendBounds │ │ │ │ - * Extend the existing bounds to include the new bounds. │ │ │ │ - * If geometry's bounds is not yet set, then set a new Bounds. │ │ │ │ + /** │ │ │ │ + * Method: getNodeType │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * newBounds - {<OpenLayers.Bounds>} │ │ │ │ - */ │ │ │ │ - extendBounds: function(newBounds) { │ │ │ │ - var bounds = this.getBounds(); │ │ │ │ - if (!bounds) { │ │ │ │ - this.setBounds(newBounds); │ │ │ │ - } else { │ │ │ │ - this.bounds.extend(newBounds); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getBounds │ │ │ │ - * Get the bounds for this Geometry. If bounds is not set, it │ │ │ │ - * is calculated again, this makes queries faster. │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * style - {Object} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} │ │ │ │ + * {String} The corresponding node type for the specified geometry │ │ │ │ */ │ │ │ │ - getBounds: function() { │ │ │ │ - if (this.bounds == null) { │ │ │ │ - this.calculateBounds(); │ │ │ │ + getNodeType: function(geometry, style) { │ │ │ │ + var nodeType = null; │ │ │ │ + switch (geometry.CLASS_NAME) { │ │ │ │ + case "OpenLayers.Geometry.Point": │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + nodeType = "image"; │ │ │ │ + } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ + nodeType = "svg"; │ │ │ │ + } else { │ │ │ │ + nodeType = "circle"; │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.Rectangle": │ │ │ │ + nodeType = "rect"; │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.LineString": │ │ │ │ + nodeType = "polyline"; │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.LinearRing": │ │ │ │ + nodeType = "polygon"; │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.Polygon": │ │ │ │ + case "OpenLayers.Geometry.Curve": │ │ │ │ + nodeType = "path"; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + break; │ │ │ │ } │ │ │ │ - return this.bounds; │ │ │ │ + return nodeType; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: calculateBounds │ │ │ │ - * Recalculate the bounds for the geometry. │ │ │ │ - */ │ │ │ │ - calculateBounds: function() { │ │ │ │ - // │ │ │ │ - // This should be overridden by subclasses. │ │ │ │ - // │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: distanceTo │ │ │ │ - * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Optional properties for configuring the distance │ │ │ │ - * calculation. │ │ │ │ - * │ │ │ │ - * Valid options depend on the specific geometry type. │ │ │ │ + * Method: setStyle │ │ │ │ + * Use to set all the style attributes to a SVG node. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Number | Object} The distance between this geometry and the target. │ │ │ │ - * If details is true, the return will be an object with distance, │ │ │ │ - * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ - * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ - * properties represent the coordinates of the closest point on the │ │ │ │ - * target geometry. │ │ │ │ - */ │ │ │ │ - distanceTo: function(geometry, options) {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getVertices │ │ │ │ - * Return a list of all points in this geometry. │ │ │ │ + * Takes care to adjust stroke width and point radius to be │ │ │ │ + * resolution-relative │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ - * endpoints. If false, for lines, only vertices that are not │ │ │ │ - * endpoints will be returned. If not provided, all vertices will │ │ │ │ - * be returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} A list of all vertices in the geometry. │ │ │ │ - */ │ │ │ │ - getVertices: function(nodes) {}, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: atPoint │ │ │ │ - * Note - This is only an approximation based on the bounds of the │ │ │ │ - * geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * lonlat - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an │ │ │ │ - * object with a 'lon' and 'lat' properties. │ │ │ │ - * toleranceLon - {float} Optional tolerance in Geometric Coords │ │ │ │ - * toleranceLat - {float} Optional tolerance in Geographic Coords │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Whether or not the geometry is at the specified location │ │ │ │ + * node - {SVGDomElement} An SVG element to decorate │ │ │ │ + * style - {Object} │ │ │ │ + * options - {Object} Currently supported options include │ │ │ │ + * 'isFilled' {Boolean} and │ │ │ │ + * 'isStroked' {Boolean} │ │ │ │ */ │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - var bounds = this.getBounds(); │ │ │ │ - if ((bounds != null) && (lonlat != null)) { │ │ │ │ - │ │ │ │ - var dX = (toleranceLon != null) ? toleranceLon : 0; │ │ │ │ - var dY = (toleranceLat != null) ? toleranceLat : 0; │ │ │ │ - │ │ │ │ - var toleranceBounds = │ │ │ │ - new OpenLayers.Bounds(this.bounds.left - dX, │ │ │ │ - this.bounds.bottom - dY, │ │ │ │ - this.bounds.right + dX, │ │ │ │ - this.bounds.top + dY); │ │ │ │ + setStyle: function(node, style, options) { │ │ │ │ + style = style || node._style; │ │ │ │ + options = options || node._options; │ │ │ │ │ │ │ │ - atPoint = toleranceBounds.containsLonLat(lonlat); │ │ │ │ + var title = style.title || style.graphicTitle; │ │ │ │ + if (title) { │ │ │ │ + node.setAttributeNS(null, "title", title); │ │ │ │ + //Standards-conformant SVG │ │ │ │ + // Prevent duplicate nodes. See issue https://github.com/openlayers/openlayers/issues/92 │ │ │ │ + var titleNode = node.getElementsByTagName("title"); │ │ │ │ + if (titleNode.length > 0) { │ │ │ │ + titleNode[0].firstChild.textContent = title; │ │ │ │ + } else { │ │ │ │ + var label = this.nodeFactory(null, "title"); │ │ │ │ + label.textContent = title; │ │ │ │ + node.appendChild(label); │ │ │ │ + } │ │ │ │ } │ │ │ │ - return atPoint; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getLength │ │ │ │ - * Calculate the length of this geometry. This method is defined in │ │ │ │ - * subclasses. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The length of the collection by summing its parts │ │ │ │ - */ │ │ │ │ - getLength: function() { │ │ │ │ - //to be overridden by geometries that actually have a length │ │ │ │ - // │ │ │ │ - return 0.0; │ │ │ │ - }, │ │ │ │ + var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ + var widthFactor = 1; │ │ │ │ + var pos; │ │ │ │ + if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ + node.style.visibility = ""; │ │ │ │ + if (style.graphic === false) { │ │ │ │ + node.style.visibility = "hidden"; │ │ │ │ + } else if (style.externalGraphic) { │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + if (style.graphicWidth && style.graphicHeight) { │ │ │ │ + node.setAttributeNS(null, "preserveAspectRatio", "none"); │ │ │ │ + } │ │ │ │ + var width = style.graphicWidth || style.graphicHeight; │ │ │ │ + var height = style.graphicHeight || style.graphicWidth; │ │ │ │ + width = width ? width : style.pointRadius * 2; │ │ │ │ + height = height ? height : style.pointRadius * 2; │ │ │ │ + var xOffset = (style.graphicXOffset != undefined) ? │ │ │ │ + style.graphicXOffset : -(0.5 * width); │ │ │ │ + var yOffset = (style.graphicYOffset != undefined) ? │ │ │ │ + style.graphicYOffset : -(0.5 * height); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: getArea │ │ │ │ - * Calculate the area of this geometry. This method is defined in subclasses. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The area of the collection by summing its parts │ │ │ │ - */ │ │ │ │ - getArea: function() { │ │ │ │ - //to be overridden by geometries that actually have an area │ │ │ │ - // │ │ │ │ - return 0.0; │ │ │ │ - }, │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getCentroid │ │ │ │ - * Calculate the centroid of this geometry. This method is defined in subclasses. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ - */ │ │ │ │ - getCentroid: function() { │ │ │ │ - return null; │ │ │ │ - }, │ │ │ │ + node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "width", width); │ │ │ │ + node.setAttributeNS(null, "height", height); │ │ │ │ + node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ + node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ + node.onclick = OpenLayers.Event.preventDefault; │ │ │ │ + } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ + // the symbol viewBox is three times as large as the symbol │ │ │ │ + var offset = style.pointRadius * 3; │ │ │ │ + var size = offset * 2; │ │ │ │ + var src = this.importSymbol(style.graphicName); │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: toString │ │ │ │ - * Returns a text representation of the geometry. If the WKT format is │ │ │ │ - * included in a build, this will be the Well-Known Text │ │ │ │ - * representation. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} String representation of this geometry. │ │ │ │ - */ │ │ │ │ - toString: function() { │ │ │ │ - var string; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ - string = OpenLayers.Format.WKT.prototype.write( │ │ │ │ - new OpenLayers.Feature.Vector(this) │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - string = Object.prototype.toString.call(this); │ │ │ │ - } │ │ │ │ - return string; │ │ │ │ - }, │ │ │ │ + // remove the node from the dom before we modify it. This │ │ │ │ + // prevents various rendering issues in Safari and FF │ │ │ │ + var parent = node.parentNode; │ │ │ │ + var nextSibling = node.nextSibling; │ │ │ │ + if (parent) { │ │ │ │ + parent.removeChild(node); │ │ │ │ + } │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry" │ │ │ │ -}); │ │ │ │ + // The more appropriate way to implement this would be use/defs, │ │ │ │ + // but due to various issues in several browsers, it is safer to │ │ │ │ + // copy the symbols instead of referencing them. │ │ │ │ + // See e.g. ticket http://trac.osgeo.org/openlayers/ticket/2985 │ │ │ │ + // and this email thread │ │ │ │ + // http://osgeo-org.1803224.n2.nabble.com/Select-Control-Ctrl-click-on-Feature-with-a-graphicName-opens-new-browser-window-tc5846039.html │ │ │ │ + node.firstChild && node.removeChild(node.firstChild); │ │ │ │ + node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ + node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Geometry.fromWKT │ │ │ │ - * Generate a geometry given a Well-Known Text string. For this method to │ │ │ │ - * work, you must include the OpenLayers.Format.WKT in your build │ │ │ │ - * explicitly. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * wkt - {String} A string representing the geometry in Well-Known Text. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry of the appropriate class. │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.fromWKT = function(wkt) { │ │ │ │ - var geom; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ - var format = OpenLayers.Geometry.fromWKT.format; │ │ │ │ - if (!format) { │ │ │ │ - format = new OpenLayers.Format.WKT(); │ │ │ │ - OpenLayers.Geometry.fromWKT.format = format; │ │ │ │ - } │ │ │ │ - var result = format.read(wkt); │ │ │ │ - if (result instanceof OpenLayers.Feature.Vector) { │ │ │ │ - geom = result.geometry; │ │ │ │ - } else if (OpenLayers.Util.isArray(result)) { │ │ │ │ - var len = result.length; │ │ │ │ - var components = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - components[i] = result[i].geometry; │ │ │ │ - } │ │ │ │ - geom = new OpenLayers.Geometry.Collection(components); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return geom; │ │ │ │ -}; │ │ │ │ + node.setAttributeNS(null, "width", size); │ │ │ │ + node.setAttributeNS(null, "height", size); │ │ │ │ + node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ + node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Method: OpenLayers.Geometry.segmentsIntersect │ │ │ │ - * Determine whether two line segments intersect. Optionally calculates │ │ │ │ - * and returns the intersection point. This function is optimized for │ │ │ │ - * cases where seg1.x2 >= seg2.x1 || seg2.x2 >= seg1.x1. In those │ │ │ │ - * obvious cases where there is no intersection, the function should │ │ │ │ - * not be called. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * seg1 - {Object} Object representing a segment with properties x1, y1, x2, │ │ │ │ - * and y2. The start point is represented by x1 and y1. The end point │ │ │ │ - * is represented by x2 and y2. Start and end are ordered so that x1 < x2. │ │ │ │ - * seg2 - {Object} Object representing a segment with properties x1, y1, x2, │ │ │ │ - * and y2. The start point is represented by x1 and y1. The end point │ │ │ │ - * is represented by x2 and y2. Start and end are ordered so that x1 < x2. │ │ │ │ - * options - {Object} Optional properties for calculating the intersection. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * point - {Boolean} Return the intersection point. If false, the actual │ │ │ │ - * intersection point will not be calculated. If true and the segments │ │ │ │ - * intersect, the intersection point will be returned. If true and │ │ │ │ - * the segments do not intersect, false will be returned. If true and │ │ │ │ - * the segments are coincident, true will be returned. │ │ │ │ - * tolerance - {Number} If a non-null value is provided, if the segments are │ │ │ │ - * within the tolerance distance, this will be considered an intersection. │ │ │ │ - * In addition, if the point option is true and the calculated intersection │ │ │ │ - * is within the tolerance distance of an end point, the endpoint will be │ │ │ │ - * returned instead of the calculated intersection. Further, if the │ │ │ │ - * intersection is within the tolerance of endpoints on both segments, or │ │ │ │ - * if two segment endpoints are within the tolerance distance of eachother │ │ │ │ - * (but no intersection is otherwise calculated), an endpoint on the │ │ │ │ - * first segment provided will be returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean | <OpenLayers.Geometry.Point>} The two segments intersect. │ │ │ │ - * If the point argument is true, the return will be the intersection │ │ │ │ - * point or false if none exists. If point is true and the segments │ │ │ │ - * are coincident, return will be true (and the instersection is equal │ │ │ │ - * to the shorter segment). │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.segmentsIntersect = function(seg1, seg2, options) { │ │ │ │ - var point = options && options.point; │ │ │ │ - var tolerance = options && options.tolerance; │ │ │ │ - var intersection = false; │ │ │ │ - var x11_21 = seg1.x1 - seg2.x1; │ │ │ │ - var y11_21 = seg1.y1 - seg2.y1; │ │ │ │ - var x12_11 = seg1.x2 - seg1.x1; │ │ │ │ - var y12_11 = seg1.y2 - seg1.y1; │ │ │ │ - var y22_21 = seg2.y2 - seg2.y1; │ │ │ │ - var x22_21 = seg2.x2 - seg2.x1; │ │ │ │ - var d = (y22_21 * x12_11) - (x22_21 * y12_11); │ │ │ │ - var n1 = (x22_21 * y11_21) - (y22_21 * x11_21); │ │ │ │ - var n2 = (x12_11 * y11_21) - (y12_11 * x11_21); │ │ │ │ - if (d == 0) { │ │ │ │ - // parallel │ │ │ │ - if (n1 == 0 && n2 == 0) { │ │ │ │ - // coincident │ │ │ │ - intersection = true; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - var along1 = n1 / d; │ │ │ │ - var along2 = n2 / d; │ │ │ │ - if (along1 >= 0 && along1 <= 1 && along2 >= 0 && along2 <= 1) { │ │ │ │ - // intersect │ │ │ │ - if (!point) { │ │ │ │ - intersection = true; │ │ │ │ + // now that the node has all its new properties, insert it │ │ │ │ + // back into the dom where it was │ │ │ │ + if (nextSibling) { │ │ │ │ + parent.insertBefore(node, nextSibling); │ │ │ │ + } else if (parent) { │ │ │ │ + parent.appendChild(node); │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - // calculate the intersection point │ │ │ │ - var x = seg1.x1 + (along1 * x12_11); │ │ │ │ - var y = seg1.y1 + (along1 * y12_11); │ │ │ │ - intersection = new OpenLayers.Geometry.Point(x, y); │ │ │ │ + node.setAttributeNS(null, "r", style.pointRadius); │ │ │ │ } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (tolerance) { │ │ │ │ - var dist; │ │ │ │ - if (intersection) { │ │ │ │ - if (point) { │ │ │ │ - var segs = [seg1, seg2]; │ │ │ │ - var seg, x, y; │ │ │ │ - // check segment endpoints for proximity to intersection │ │ │ │ - // set intersection to first endpoint within the tolerance │ │ │ │ - outer: for (var i = 0; i < 2; ++i) { │ │ │ │ - seg = segs[i]; │ │ │ │ - for (var j = 1; j < 3; ++j) { │ │ │ │ - x = seg["x" + j]; │ │ │ │ - y = seg["y" + j]; │ │ │ │ - dist = Math.sqrt( │ │ │ │ - Math.pow(x - intersection.x, 2) + │ │ │ │ - Math.pow(y - intersection.y, 2) │ │ │ │ - ); │ │ │ │ - if (dist < tolerance) { │ │ │ │ - intersection.x = x; │ │ │ │ - intersection.y = y; │ │ │ │ - break outer; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // no calculated intersection, but segments could be within │ │ │ │ - // the tolerance of one another │ │ │ │ - var segs = [seg1, seg2]; │ │ │ │ - var source, target, x, y, p, result; │ │ │ │ - // check segment endpoints for proximity to intersection │ │ │ │ - // set intersection to first endpoint within the tolerance │ │ │ │ - outer: for (var i = 0; i < 2; ++i) { │ │ │ │ - source = segs[i]; │ │ │ │ - target = segs[(i + 1) % 2]; │ │ │ │ - for (var j = 1; j < 3; ++j) { │ │ │ │ - p = { │ │ │ │ - x: source["x" + j], │ │ │ │ - y: source["y" + j] │ │ │ │ - }; │ │ │ │ - result = OpenLayers.Geometry.distanceToSegment(p, target); │ │ │ │ - if (result.distance < tolerance) { │ │ │ │ - if (point) { │ │ │ │ - intersection = new OpenLayers.Geometry.Point(p.x, p.y); │ │ │ │ - } else { │ │ │ │ - intersection = true; │ │ │ │ - } │ │ │ │ - break outer; │ │ │ │ - } │ │ │ │ + var rotation = style.rotation; │ │ │ │ + │ │ │ │ + if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + rotation |= 0; │ │ │ │ + if (node.nodeName !== "svg") { │ │ │ │ + node.setAttributeNS(null, "transform", │ │ │ │ + "rotate(" + rotation + " " + pos.x + " " + │ │ │ │ + pos.y + ")"); │ │ │ │ + } else { │ │ │ │ + var metrics = this.symbolMetrics[src.id]; │ │ │ │ + node.firstChild.setAttributeNS(null, "transform", "rotate(" + │ │ │ │ + rotation + " " + │ │ │ │ + metrics[1] + " " + │ │ │ │ + metrics[2] + ")"); │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - } │ │ │ │ - return intersection; │ │ │ │ -}; │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Geometry.distanceToSegment │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {Object} An object with x and y properties representing the │ │ │ │ - * point coordinates. │ │ │ │ - * segment - {Object} An object with x1, y1, x2, and y2 properties │ │ │ │ - * representing endpoint coordinates. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object with distance, along, x, and y properties. The distance │ │ │ │ - * will be the shortest distance between the input point and segment. │ │ │ │ - * The x and y properties represent the coordinates along the segment │ │ │ │ - * where the shortest distance meets the segment. The along attribute │ │ │ │ - * describes how far between the two segment points the given point is. │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.distanceToSegment = function(point, segment) { │ │ │ │ - var result = OpenLayers.Geometry.distanceSquaredToSegment(point, segment); │ │ │ │ - result.distance = Math.sqrt(result.distance); │ │ │ │ - return result; │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Geometry.distanceSquaredToSegment │ │ │ │ - * │ │ │ │ - * Usually the distanceToSegment function should be used. This variant however │ │ │ │ - * can be used for comparisons where the exact distance is not important. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {Object} An object with x and y properties representing the │ │ │ │ - * point coordinates. │ │ │ │ - * segment - {Object} An object with x1, y1, x2, and y2 properties │ │ │ │ - * representing endpoint coordinates. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object with squared distance, along, x, and y properties. │ │ │ │ - * The distance will be the shortest distance between the input point and │ │ │ │ - * segment. The x and y properties represent the coordinates along the │ │ │ │ - * segment where the shortest distance meets the segment. The along │ │ │ │ - * attribute describes how far between the two segment points the given │ │ │ │ - * point is. │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.distanceSquaredToSegment = function(point, segment) { │ │ │ │ - var x0 = point.x; │ │ │ │ - var y0 = point.y; │ │ │ │ - var x1 = segment.x1; │ │ │ │ - var y1 = segment.y1; │ │ │ │ - var x2 = segment.x2; │ │ │ │ - var y2 = segment.y2; │ │ │ │ - var dx = x2 - x1; │ │ │ │ - var dy = y2 - y1; │ │ │ │ - var along = ((dx * (x0 - x1)) + (dy * (y0 - y1))) / │ │ │ │ - (Math.pow(dx, 2) + Math.pow(dy, 2)); │ │ │ │ - var x, y; │ │ │ │ - if (along <= 0.0) { │ │ │ │ - x = x1; │ │ │ │ - y = y1; │ │ │ │ - } else if (along >= 1.0) { │ │ │ │ - x = x2; │ │ │ │ - y = y2; │ │ │ │ - } else { │ │ │ │ - x = x1 + along * dx; │ │ │ │ - y = y1 + along * dy; │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - distance: Math.pow(x - x0, 2) + Math.pow(y - y0, 2), │ │ │ │ - x: x, │ │ │ │ - y: y, │ │ │ │ - along: along │ │ │ │ - }; │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/Point.js │ │ │ │ - ====================================================================== */ │ │ │ │ + if (options.isFilled) { │ │ │ │ + node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ + node.setAttributeNS(null, "fill-opacity", style.fillOpacity); │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "fill", "none"); │ │ │ │ + } │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + if (options.isStroked) { │ │ │ │ + node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ + node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ + node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ + node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ + // Hard-coded linejoin for now, to make it look the same as in VML. │ │ │ │ + // There is no strokeLinejoin property yet for symbolizers. │ │ │ │ + node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ + style.strokeDashstyle && node.setAttributeNS(null, │ │ │ │ + "stroke-dasharray", this.dashStyle(style, widthFactor)); │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "stroke", "none"); │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Geometry.js │ │ │ │ - */ │ │ │ │ + if (style.pointerEvents) { │ │ │ │ + node.setAttributeNS(null, "pointer-events", style.pointerEvents); │ │ │ │ + } │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry.Point │ │ │ │ - * Point geometry class. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry> │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.Point = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ + if (style.cursor != null) { │ │ │ │ + node.setAttributeNS(null, "cursor", style.cursor); │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: x │ │ │ │ - * {float} │ │ │ │ - */ │ │ │ │ - x: null, │ │ │ │ + return node; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: y │ │ │ │ - * {float} │ │ │ │ - */ │ │ │ │ - y: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.Point │ │ │ │ - * Construct a point geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {float} │ │ │ │ - * y - {float} │ │ │ │ + * Method: dashStyle │ │ │ │ * │ │ │ │ - */ │ │ │ │ - initialize: function(x, y) { │ │ │ │ - OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ - this.x = parseFloat(x); │ │ │ │ - this.y = parseFloat(y); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: clone │ │ │ │ + * Parameters: │ │ │ │ + * style - {Object} │ │ │ │ + * widthFactor - {Number} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} An exact clone of this OpenLayers.Geometry.Point │ │ │ │ + * {String} A SVG compliant 'stroke-dasharray' value │ │ │ │ */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Geometry.Point(this.x, this.y); │ │ │ │ + dashStyle: function(style, widthFactor) { │ │ │ │ + var w = style.strokeWidth * widthFactor; │ │ │ │ + var str = style.strokeDashstyle; │ │ │ │ + switch (str) { │ │ │ │ + case 'solid': │ │ │ │ + return 'none'; │ │ │ │ + case 'dot': │ │ │ │ + return [1, 4 * w].join(); │ │ │ │ + case 'dash': │ │ │ │ + return [4 * w, 4 * w].join(); │ │ │ │ + case 'dashdot': │ │ │ │ + return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ + case 'longdash': │ │ │ │ + return [8 * w, 4 * w].join(); │ │ │ │ + case 'longdashdot': │ │ │ │ + return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ + default: │ │ │ │ + return OpenLayers.String.trim(str).replace(/\s+/g, ","); │ │ │ │ } │ │ │ │ - │ │ │ │ - // catch any randomly tagged-on properties │ │ │ │ - OpenLayers.Util.applyDefaults(obj, this); │ │ │ │ - │ │ │ │ - return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: calculateBounds │ │ │ │ - * Create a new Bounds based on the lon/lat │ │ │ │ - */ │ │ │ │ - calculateBounds: function() { │ │ │ │ - this.bounds = new OpenLayers.Bounds(this.x, this.y, │ │ │ │ - this.x, this.y); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: distanceTo │ │ │ │ - * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ - * │ │ │ │ + * Method: createNode │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Optional properties for configuring the distance │ │ │ │ - * calculation. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * details - {Boolean} Return details from the distance calculation. │ │ │ │ - * Default is false. │ │ │ │ - * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ - * nearest edge of the target geometry. Default is true. If true, │ │ │ │ - * calling distanceTo from a geometry that is wholly contained within │ │ │ │ - * the target will result in a non-zero distance. If false, whenever │ │ │ │ - * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ - * details cannot be returned. │ │ │ │ - * │ │ │ │ + * type - {String} Kind of node to draw │ │ │ │ + * id - {String} Id for node │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Number | Object} The distance between this geometry and the target. │ │ │ │ - * If details is true, the return will be an object with distance, │ │ │ │ - * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ - * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ - * properties represent the coordinates of the closest point on the │ │ │ │ - * target geometry. │ │ │ │ + * {DOMElement} A new node of the given type and id │ │ │ │ */ │ │ │ │ - distanceTo: function(geometry, options) { │ │ │ │ - var edge = !(options && options.edge === false); │ │ │ │ - var details = edge && options && options.details; │ │ │ │ - var distance, x0, y0, x1, y1, result; │ │ │ │ - if (geometry instanceof OpenLayers.Geometry.Point) { │ │ │ │ - x0 = this.x; │ │ │ │ - y0 = this.y; │ │ │ │ - x1 = geometry.x; │ │ │ │ - y1 = geometry.y; │ │ │ │ - distance = Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2)); │ │ │ │ - result = !details ? │ │ │ │ - distance : { │ │ │ │ - x0: x0, │ │ │ │ - y0: y0, │ │ │ │ - x1: x1, │ │ │ │ - y1: y1, │ │ │ │ - distance: distance │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - result = geometry.distanceTo(this, options); │ │ │ │ - if (details) { │ │ │ │ - // switch coord order since this geom is target │ │ │ │ - result = { │ │ │ │ - x0: result.x1, │ │ │ │ - y0: result.y1, │ │ │ │ - x1: result.x0, │ │ │ │ - y1: result.y0, │ │ │ │ - distance: result.distance │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + createNode: function(type, id) { │ │ │ │ + var node = document.createElementNS(this.xmlns, type); │ │ │ │ + if (id) { │ │ │ │ + node.setAttributeNS(null, "id", id); │ │ │ │ } │ │ │ │ - return result; │ │ │ │ + return node; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: equals │ │ │ │ - * Determine whether another geometry is equivalent to this one. Geometries │ │ │ │ - * are considered equivalent if all components have the same coordinates. │ │ │ │ + * Method: nodeTypeCompare │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geom - {<OpenLayers.Geometry.Point>} The geometry to test. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The supplied geometry is equivalent to this geometry. │ │ │ │ - */ │ │ │ │ - equals: function(geom) { │ │ │ │ - var equals = false; │ │ │ │ - if (geom != null) { │ │ │ │ - equals = ((this.x == geom.x && this.y == geom.y) || │ │ │ │ - (isNaN(this.x) && isNaN(this.y) && isNaN(geom.x) && isNaN(geom.y))); │ │ │ │ - } │ │ │ │ - return equals; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: toShortString │ │ │ │ - * │ │ │ │ + * node - {SVGDomElement} An SVG element │ │ │ │ + * type - {String} Kind of node │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} Shortened String representation of Point object. │ │ │ │ - * (ex. <i>"5, 42"</i>) │ │ │ │ - */ │ │ │ │ - toShortString: function() { │ │ │ │ - return (this.x + ", " + this.y); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: move │ │ │ │ - * Moves a geometry by the given displacement along positive x and y axes. │ │ │ │ - * This modifies the position of the geometry and clears the cached │ │ │ │ - * bounds. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Float} Distance to move geometry in positive x direction. │ │ │ │ - * y - {Float} Distance to move geometry in positive y direction. │ │ │ │ - */ │ │ │ │ - move: function(x, y) { │ │ │ │ - this.x = this.x + x; │ │ │ │ - this.y = this.y + y; │ │ │ │ - this.clearBounds(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: rotate │ │ │ │ - * Rotate a point around another. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * angle - {Float} Rotation angle in degrees (measured counterclockwise │ │ │ │ - * from the positive x-axis) │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} Center point for the rotation │ │ │ │ + * {Boolean} Whether or not the specified node is of the specified type │ │ │ │ */ │ │ │ │ - rotate: function(angle, origin) { │ │ │ │ - angle *= Math.PI / 180; │ │ │ │ - var radius = this.distanceTo(origin); │ │ │ │ - var theta = angle + Math.atan2(this.y - origin.y, this.x - origin.x); │ │ │ │ - this.x = origin.x + (radius * Math.cos(theta)); │ │ │ │ - this.y = origin.y + (radius * Math.sin(theta)); │ │ │ │ - this.clearBounds(); │ │ │ │ + nodeTypeCompare: function(node, type) { │ │ │ │ + return (type == node.nodeName); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getCentroid │ │ │ │ - * │ │ │ │ + * Method: createRenderRoot │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ + * {DOMElement} The specific render engine's root element │ │ │ │ */ │ │ │ │ - getCentroid: function() { │ │ │ │ - return new OpenLayers.Geometry.Point(this.x, this.y); │ │ │ │ + createRenderRoot: function() { │ │ │ │ + var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ + svg.style.display = "block"; │ │ │ │ + return svg; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: resize │ │ │ │ - * Resize a point relative to some origin. For points, this has the effect │ │ │ │ - * of scaling a vector (from the origin to the point). This method is │ │ │ │ - * more useful on geometry collection subclasses. │ │ │ │ - * │ │ │ │ + * Method: createRoot │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * scale - {Float} Ratio of the new distance from the origin to the old │ │ │ │ - * distance from the origin. A scale of 2 doubles the │ │ │ │ - * distance between the point and origin. │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing │ │ │ │ - * ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1. │ │ │ │ + * suffix - {String} suffix to append to the id │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} - The current geometry. │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - resize: function(scale, origin, ratio) { │ │ │ │ - ratio = (ratio == undefined) ? 1 : ratio; │ │ │ │ - this.x = origin.x + (scale * ratio * (this.x - origin.x)); │ │ │ │ - this.y = origin.y + (scale * (this.y - origin.y)); │ │ │ │ - this.clearBounds(); │ │ │ │ - return this; │ │ │ │ + createRoot: function(suffix) { │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "g"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: intersects │ │ │ │ - * Determine if the input geometry intersects this one. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ + * Method: createDefs │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The input geometry intersects this one. │ │ │ │ + * {DOMElement} The element to which we'll add the symbol definitions │ │ │ │ */ │ │ │ │ - intersects: function(geometry) { │ │ │ │ - var intersect = false; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - intersect = this.equals(geometry); │ │ │ │ - } else { │ │ │ │ - intersect = geometry.intersects(this); │ │ │ │ - } │ │ │ │ - return intersect; │ │ │ │ + createDefs: function() { │ │ │ │ + var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ + this.rendererRoot.appendChild(defs); │ │ │ │ + return defs; │ │ │ │ }, │ │ │ │ │ │ │ │ + /************************************** │ │ │ │ + * * │ │ │ │ + * GEOMETRY DRAWING FUNCTIONS * │ │ │ │ + * * │ │ │ │ + **************************************/ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * APIMethod: transform │ │ │ │ - * Translate the x,y properties of the point from source to dest. │ │ │ │ + * Method: drawPoint │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * source - {<OpenLayers.Projection>} │ │ │ │ - * dest - {<OpenLayers.Projection>} │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} │ │ │ │ + * {DOMElement} or false if the renderer could not draw the point │ │ │ │ */ │ │ │ │ - transform: function(source, dest) { │ │ │ │ - if ((source && dest)) { │ │ │ │ - OpenLayers.Projection.transform( │ │ │ │ - this, source, dest); │ │ │ │ - this.bounds = null; │ │ │ │ - } │ │ │ │ - return this; │ │ │ │ + drawPoint: function(node, geometry) { │ │ │ │ + return this.drawCircle(node, geometry, 1); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getVertices │ │ │ │ - * Return a list of all points in this geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ - * endpoints. If false, for lines, only vertices that are not │ │ │ │ - * endpoints will be returned. If not provided, all vertices will │ │ │ │ - * be returned. │ │ │ │ - * │ │ │ │ + * Method: drawCircle │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * radius - {Float} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Array} A list of all vertices in the geometry. │ │ │ │ - */ │ │ │ │ - getVertices: function(nodes) { │ │ │ │ - return [this]; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.Point" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/Collection.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Geometry.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry.Collection │ │ │ │ - * A Collection is exactly what it sounds like: A collection of different │ │ │ │ - * Geometries. These are stored in the local parameter <components> (which │ │ │ │ - * can be passed as a parameter to the constructor). │ │ │ │ - * │ │ │ │ - * As new geometries are added to the collection, they are NOT cloned. │ │ │ │ - * When removing geometries, they need to be specified by reference (ie you │ │ │ │ - * have to pass in the *exact* geometry to be removed). │ │ │ │ - * │ │ │ │ - * The <getArea> and <getLength> functions here merely iterate through │ │ │ │ - * the components, summing their respective areas and lengths. │ │ │ │ - * │ │ │ │ - * Create a new instance with the <OpenLayers.Geometry.Collection> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry> │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.Collection = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: components │ │ │ │ - * {Array(<OpenLayers.Geometry>)} The component parts of this geometry │ │ │ │ - */ │ │ │ │ - components: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null value means the │ │ │ │ - * component types are not restricted. │ │ │ │ + * {DOMElement} or false if the renderer could not draw the circle │ │ │ │ */ │ │ │ │ - componentTypes: null, │ │ │ │ + drawCircle: function(node, geometry, radius) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (this.top - geometry.y / resolution); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.Collection │ │ │ │ - * Creates a Geometry Collection -- a list of geoms. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry>)} Optional array of geometries │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - initialize: function(components) { │ │ │ │ - OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ - this.components = []; │ │ │ │ - if (components != null) { │ │ │ │ - this.addComponents(components); │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "cx", x); │ │ │ │ + node.setAttributeNS(null, "cy", y); │ │ │ │ + node.setAttributeNS(null, "r", radius); │ │ │ │ + return node; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Destroy this geometry. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.components.length = 0; │ │ │ │ - this.components = null; │ │ │ │ - OpenLayers.Geometry.prototype.destroy.apply(this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clone this geometry. │ │ │ │ - * │ │ │ │ + * Method: drawLineString │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Collection>} An exact clone of this collection │ │ │ │ + * {DOMElement} or null if the renderer could not draw all components of │ │ │ │ + * the linestring, or false if nothing could be drawn │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - var geometry = eval("new " + this.CLASS_NAME + "()"); │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - geometry.addComponent(this.components[i].clone()); │ │ │ │ + drawLineString: function(node, geometry) { │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return (componentsResult.complete ? node : null); │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - │ │ │ │ - // catch any randomly tagged-on properties │ │ │ │ - OpenLayers.Util.applyDefaults(geometry, this); │ │ │ │ - │ │ │ │ - return geometry; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getComponentsString │ │ │ │ - * Get a string representing the components for this collection │ │ │ │ + * Method: drawLinearRing │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {String} A string representation of the components of this geometry │ │ │ │ + * {DOMElement} or null if the renderer could not draw all components │ │ │ │ + * of the linear ring, or false if nothing could be drawn │ │ │ │ */ │ │ │ │ - getComponentsString: function() { │ │ │ │ - var strings = []; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - strings.push(this.components[i].toShortString()); │ │ │ │ + drawLinearRing: function(node, geometry) { │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return (componentsResult.complete ? node : null); │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - return strings.join(","); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: calculateBounds │ │ │ │ - * Recalculate the bounds by iterating through the components and │ │ │ │ - * calling calling extendBounds() on each item. │ │ │ │ + * Method: drawPolygon │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} or null if the renderer could not draw all components │ │ │ │ + * of the polygon, or false if nothing could be drawn │ │ │ │ */ │ │ │ │ - calculateBounds: function() { │ │ │ │ - this.bounds = null; │ │ │ │ - var bounds = new OpenLayers.Bounds(); │ │ │ │ - var components = this.components; │ │ │ │ - if (components) { │ │ │ │ - for (var i = 0, len = components.length; i < len; i++) { │ │ │ │ - bounds.extend(components[i].getBounds()); │ │ │ │ + drawPolygon: function(node, geometry) { │ │ │ │ + var d = ""; │ │ │ │ + var draw = true; │ │ │ │ + var complete = true; │ │ │ │ + var linearRingResult, path; │ │ │ │ + for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ + d += " M"; │ │ │ │ + linearRingResult = this.getComponentsString( │ │ │ │ + geometry.components[j].components, " "); │ │ │ │ + path = linearRingResult.path; │ │ │ │ + if (path) { │ │ │ │ + d += " " + path; │ │ │ │ + complete = linearRingResult.complete && complete; │ │ │ │ + } else { │ │ │ │ + draw = false; │ │ │ │ } │ │ │ │ } │ │ │ │ - // to preserve old behavior, we only set bounds if non-null │ │ │ │ - // in the future, we could add bounds.isEmpty() │ │ │ │ - if (bounds.left != null && bounds.bottom != null && │ │ │ │ - bounds.right != null && bounds.top != null) { │ │ │ │ - this.setBounds(bounds); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: addComponents │ │ │ │ - * Add components to this geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry>)} An array of geometries to add │ │ │ │ - */ │ │ │ │ - addComponents: function(components) { │ │ │ │ - if (!(OpenLayers.Util.isArray(components))) { │ │ │ │ - components = [components]; │ │ │ │ - } │ │ │ │ - for (var i = 0, len = components.length; i < len; i++) { │ │ │ │ - this.addComponent(components[i]); │ │ │ │ + d += " z"; │ │ │ │ + if (draw) { │ │ │ │ + node.setAttributeNS(null, "d", d); │ │ │ │ + node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ + return complete ? node : null; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addComponent │ │ │ │ - * Add a new component (geometry) to the collection. If this.componentTypes │ │ │ │ - * is set, then the component class name must be in the componentTypes array. │ │ │ │ - * │ │ │ │ - * The bounds cache is reset. │ │ │ │ + * Method: drawRectangle │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * node - {DOMElement} │ │ │ │ + * geometry - {<OpenLayers.Geometry>} │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * component - {<OpenLayers.Geometry>} A geometry to add │ │ │ │ - * index - {int} Optional index into the array to insert the component │ │ │ │ - * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The component geometry was successfully added │ │ │ │ + * {DOMElement} or false if the renderer could not draw the rectangle │ │ │ │ */ │ │ │ │ - addComponent: function(component, index) { │ │ │ │ - var added = false; │ │ │ │ - if (component) { │ │ │ │ - if (this.componentTypes == null || │ │ │ │ - (OpenLayers.Util.indexOf(this.componentTypes, │ │ │ │ - component.CLASS_NAME) > -1)) { │ │ │ │ + drawRectangle: function(node, geometry) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = ((geometry.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (this.top - geometry.y / resolution); │ │ │ │ │ │ │ │ - if (index != null && (index < this.components.length)) { │ │ │ │ - var components1 = this.components.slice(0, index); │ │ │ │ - var components2 = this.components.slice(index, │ │ │ │ - this.components.length); │ │ │ │ - components1.push(component); │ │ │ │ - this.components = components1.concat(components2); │ │ │ │ - } else { │ │ │ │ - this.components.push(component); │ │ │ │ - } │ │ │ │ - component.parent = this; │ │ │ │ - this.clearBounds(); │ │ │ │ - added = true; │ │ │ │ - } │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "x", x); │ │ │ │ + node.setAttributeNS(null, "y", y); │ │ │ │ + node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ + node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ + return node; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - return added; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: removeComponents │ │ │ │ - * Remove components from this geometry. │ │ │ │ + * Method: drawText │ │ │ │ + * This method is only called by the renderer itself. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry>)} The components to be removed │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} A component was removed. │ │ │ │ + * featureId - {String} │ │ │ │ + * style - │ │ │ │ + * location - {<OpenLayers.Geometry.Point>} │ │ │ │ */ │ │ │ │ - removeComponents: function(components) { │ │ │ │ - var removed = false; │ │ │ │ - │ │ │ │ - if (!(OpenLayers.Util.isArray(components))) { │ │ │ │ - components = [components]; │ │ │ │ - } │ │ │ │ - for (var i = components.length - 1; i >= 0; --i) { │ │ │ │ - removed = this.removeComponent(components[i]) || removed; │ │ │ │ + drawText: function(featureId, style, location) { │ │ │ │ + var drawOutline = (!!style.labelOutlineWidth); │ │ │ │ + // First draw text in halo color and size and overlay the │ │ │ │ + // normal text afterwards │ │ │ │ + if (drawOutline) { │ │ │ │ + var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ + outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ + if (style.labelOutlineOpacity) { │ │ │ │ + outlineStyle.fontOpacity = style.labelOutlineOpacity; │ │ │ │ + } │ │ │ │ + delete outlineStyle.labelOutlineWidth; │ │ │ │ + this.drawText(featureId, outlineStyle, location); │ │ │ │ } │ │ │ │ - return removed; │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: removeComponent │ │ │ │ - * Remove a component from this geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * component - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The component was removed. │ │ │ │ - */ │ │ │ │ - removeComponent: function(component) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ │ │ │ │ - OpenLayers.Util.removeItem(this.components, component); │ │ │ │ + var x = ((location.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (location.y / resolution - this.top); │ │ │ │ │ │ │ │ - // clearBounds() so that it gets recalculated on the next call │ │ │ │ - // to this.getBounds(); │ │ │ │ - this.clearBounds(); │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ + var suffix = (drawOutline) ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ + var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getLength │ │ │ │ - * Calculate the length of this geometry │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The length of the geometry │ │ │ │ - */ │ │ │ │ - getLength: function() { │ │ │ │ - var length = 0.0; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - length += this.components[i].getLength(); │ │ │ │ - } │ │ │ │ - return length; │ │ │ │ - }, │ │ │ │ + label.setAttributeNS(null, "x", x); │ │ │ │ + label.setAttributeNS(null, "y", -y); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getArea │ │ │ │ - * Calculate the area of this geometry. Note how this function is overridden │ │ │ │ - * in <OpenLayers.Geometry.Polygon>. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The area of the collection by summing its parts │ │ │ │ - */ │ │ │ │ - getArea: function() { │ │ │ │ - var area = 0.0; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - area += this.components[i].getArea(); │ │ │ │ + if (style.fontColor) { │ │ │ │ + label.setAttributeNS(null, "fill", style.fontColor); │ │ │ │ } │ │ │ │ - return area; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getGeodesicArea │ │ │ │ - * Calculate the approximate area of the polygon were it projected onto │ │ │ │ - * the earth. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ - * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ - * assumed. │ │ │ │ - * │ │ │ │ - * Reference: │ │ │ │ - * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for │ │ │ │ - * Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion │ │ │ │ - * Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {float} The approximate geodesic area of the geometry in square meters. │ │ │ │ - */ │ │ │ │ - getGeodesicArea: function(projection) { │ │ │ │ - var area = 0.0; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - area += this.components[i].getGeodesicArea(projection); │ │ │ │ + if (style.fontStrokeColor) { │ │ │ │ + label.setAttributeNS(null, "stroke", style.fontStrokeColor); │ │ │ │ } │ │ │ │ - return area; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getCentroid │ │ │ │ - * │ │ │ │ - * Compute the centroid for this geometry collection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * weighted - {Boolean} Perform the getCentroid computation recursively, │ │ │ │ - * returning an area weighted average of all geometries in this collection. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ - */ │ │ │ │ - getCentroid: function(weighted) { │ │ │ │ - if (!weighted) { │ │ │ │ - return this.components.length && this.components[0].getCentroid(); │ │ │ │ + if (style.fontStrokeWidth) { │ │ │ │ + label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth); │ │ │ │ } │ │ │ │ - var len = this.components.length; │ │ │ │ - if (!len) { │ │ │ │ - return false; │ │ │ │ + if (style.fontOpacity) { │ │ │ │ + label.setAttributeNS(null, "opacity", style.fontOpacity); │ │ │ │ } │ │ │ │ - │ │ │ │ - var areas = []; │ │ │ │ - var centroids = []; │ │ │ │ - var areaSum = 0; │ │ │ │ - var minArea = Number.MAX_VALUE; │ │ │ │ - var component; │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - component = this.components[i]; │ │ │ │ - var area = component.getArea(); │ │ │ │ - var centroid = component.getCentroid(true); │ │ │ │ - if (isNaN(area) || isNaN(centroid.x) || isNaN(centroid.y)) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - areas.push(area); │ │ │ │ - areaSum += area; │ │ │ │ - minArea = (area < minArea && area > 0) ? area : minArea; │ │ │ │ - centroids.push(centroid); │ │ │ │ + if (style.fontFamily) { │ │ │ │ + label.setAttributeNS(null, "font-family", style.fontFamily); │ │ │ │ } │ │ │ │ - len = areas.length; │ │ │ │ - if (areaSum === 0) { │ │ │ │ - // all the components in this collection have 0 area │ │ │ │ - // probably a collection of points -- weight all the points the same │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - areas[i] = 1; │ │ │ │ - } │ │ │ │ - areaSum = areas.length; │ │ │ │ + if (style.fontSize) { │ │ │ │ + label.setAttributeNS(null, "font-size", style.fontSize); │ │ │ │ + } │ │ │ │ + if (style.fontWeight) { │ │ │ │ + label.setAttributeNS(null, "font-weight", style.fontWeight); │ │ │ │ + } │ │ │ │ + if (style.fontStyle) { │ │ │ │ + label.setAttributeNS(null, "font-style", style.fontStyle); │ │ │ │ + } │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ + label._featureId = featureId; │ │ │ │ } else { │ │ │ │ - // normalize all the areas where the smallest area will get │ │ │ │ - // a value of 1 │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - areas[i] /= minArea; │ │ │ │ - } │ │ │ │ - areaSum /= minArea; │ │ │ │ + label.setAttributeNS(null, "pointer-events", "none"); │ │ │ │ } │ │ │ │ + var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ + label.setAttributeNS(null, "text-anchor", │ │ │ │ + OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ │ │ │ │ - var xSum = 0, │ │ │ │ - ySum = 0, │ │ │ │ - centroid, area; │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - centroid = centroids[i]; │ │ │ │ - area = areas[i]; │ │ │ │ - xSum += centroid.x * area; │ │ │ │ - ySum += centroid.y * area; │ │ │ │ + if (OpenLayers.IS_GECKO === true) { │ │ │ │ + label.setAttributeNS(null, "dominant-baseline", │ │ │ │ + OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central"); │ │ │ │ } │ │ │ │ │ │ │ │ - return new OpenLayers.Geometry.Point(xSum / areaSum, ySum / areaSum); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getGeodesicLength │ │ │ │ - * Calculate the approximate length of the geometry were it projected onto │ │ │ │ - * the earth. │ │ │ │ - * │ │ │ │ - * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ - * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ - * assumed. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The appoximate geodesic length of the geometry in meters. │ │ │ │ - */ │ │ │ │ - getGeodesicLength: function(projection) { │ │ │ │ - var length = 0.0; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - length += this.components[i].getGeodesicLength(projection); │ │ │ │ + var labelRows = style.label.split('\n'); │ │ │ │ + var numRows = labelRows.length; │ │ │ │ + while (label.childNodes.length > numRows) { │ │ │ │ + label.removeChild(label.lastChild); │ │ │ │ } │ │ │ │ - return length; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: move │ │ │ │ - * Moves a geometry by the given displacement along positive x and y axes. │ │ │ │ - * This modifies the position of the geometry and clears the cached │ │ │ │ - * bounds. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Float} Distance to move geometry in positive x direction. │ │ │ │ - * y - {Float} Distance to move geometry in positive y direction. │ │ │ │ - */ │ │ │ │ - move: function(x, y) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - this.components[i].move(x, y); │ │ │ │ + for (var i = 0; i < numRows; i++) { │ │ │ │ + var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + tspan._featureId = featureId; │ │ │ │ + tspan._geometry = location; │ │ │ │ + tspan._geometryClass = location.CLASS_NAME; │ │ │ │ + } │ │ │ │ + if (OpenLayers.IS_GECKO === false) { │ │ │ │ + tspan.setAttributeNS(null, "baseline-shift", │ │ │ │ + OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%"); │ │ │ │ + } │ │ │ │ + tspan.setAttribute("x", x); │ │ │ │ + if (i == 0) { │ │ │ │ + var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ + if (vfactor == null) { │ │ │ │ + vfactor = -.5; │ │ │ │ + } │ │ │ │ + tspan.setAttribute("dy", (vfactor * (numRows - 1)) + "em"); │ │ │ │ + } else { │ │ │ │ + tspan.setAttribute("dy", "1em"); │ │ │ │ + } │ │ │ │ + tspan.textContent = (labelRows[i] === '') ? ' ' : labelRows[i]; │ │ │ │ + if (!tspan.parentNode) { │ │ │ │ + label.appendChild(tspan); │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: rotate │ │ │ │ - * Rotate a geometry around some origin │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * angle - {Float} Rotation angle in degrees (measured counterclockwise │ │ │ │ - * from the positive x-axis) │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} Center point for the rotation │ │ │ │ - */ │ │ │ │ - rotate: function(angle, origin) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - this.components[i].rotate(angle, origin); │ │ │ │ + if (!label.parentNode) { │ │ │ │ + this.textRoot.appendChild(label); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: resize │ │ │ │ - * Resize a geometry relative to some origin. Use this method to apply │ │ │ │ - * a uniform scaling to a geometry. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: getComponentString │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * scale - {Float} Factor by which to scale the geometry. A scale of 2 │ │ │ │ - * doubles the size of the geometry in each dimension │ │ │ │ - * (lines, for example, will be twice as long, and polygons │ │ │ │ - * will have four times the area). │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing │ │ │ │ - * ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1. │ │ │ │ + * components - {Array(<OpenLayers.Geometry.Point>)} Array of points │ │ │ │ + * separator - {String} character between coordinate pairs. Defaults to "," │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} - The current geometry. │ │ │ │ + * {Object} hash with properties "path" (the string created from the │ │ │ │ + * components and "complete" (false if the renderer was unable to │ │ │ │ + * draw all components) │ │ │ │ */ │ │ │ │ - resize: function(scale, origin, ratio) { │ │ │ │ - for (var i = 0; i < this.components.length; ++i) { │ │ │ │ - this.components[i].resize(scale, origin, ratio); │ │ │ │ + getComponentsString: function(components, separator) { │ │ │ │ + var renderCmp = []; │ │ │ │ + var complete = true; │ │ │ │ + var len = components.length; │ │ │ │ + var strings = []; │ │ │ │ + var str, component; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + component = components[i]; │ │ │ │ + renderCmp.push(component); │ │ │ │ + str = this.getShortString(component); │ │ │ │ + if (str) { │ │ │ │ + strings.push(str); │ │ │ │ + } else { │ │ │ │ + // The current component is outside the valid range. Let's │ │ │ │ + // see if the previous or next component is inside the range. │ │ │ │ + // If so, add the coordinate of the intersection with the │ │ │ │ + // valid range bounds. │ │ │ │ + if (i > 0) { │ │ │ │ + if (this.getShortString(components[i - 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], │ │ │ │ + components[i - 1])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (i < len - 1) { │ │ │ │ + if (this.getShortString(components[i + 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], │ │ │ │ + components[i + 1])); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + complete = false; │ │ │ │ + } │ │ │ │ } │ │ │ │ - return this; │ │ │ │ + │ │ │ │ + return { │ │ │ │ + path: strings.join(separator || ","), │ │ │ │ + complete: complete │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: distanceTo │ │ │ │ - * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ - * │ │ │ │ + * Method: clipLine │ │ │ │ + * Given two points (one inside the valid range, and one outside), │ │ │ │ + * clips the line betweeen the two points so that the new points are both │ │ │ │ + * inside the valid range. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Optional properties for configuring the distance │ │ │ │ - * calculation. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * details - {Boolean} Return details from the distance calculation. │ │ │ │ - * Default is false. │ │ │ │ - * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ - * nearest edge of the target geometry. Default is true. If true, │ │ │ │ - * calling distanceTo from a geometry that is wholly contained within │ │ │ │ - * the target will result in a non-zero distance. If false, whenever │ │ │ │ - * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ - * details cannot be returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number | Object} The distance between this geometry and the target. │ │ │ │ - * If details is true, the return will be an object with distance, │ │ │ │ - * x0, y0, x1, and y1 properties. The x0 and y0 properties represent │ │ │ │ - * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ - * properties represent the coordinates of the closest point on the │ │ │ │ - * target geometry. │ │ │ │ + * badComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ + * invalid point │ │ │ │ + * goodComponent - {<OpenLayers.Geometry.Point>} original geometry of the │ │ │ │ + * valid point │ │ │ │ + * Returns │ │ │ │ + * {String} the SVG coordinate pair of the clipped point (like │ │ │ │ + * getShortString), or an empty string if both passed componets are at │ │ │ │ + * the same point. │ │ │ │ */ │ │ │ │ - distanceTo: function(geometry, options) { │ │ │ │ - var edge = !(options && options.edge === false); │ │ │ │ - var details = edge && options && options.details; │ │ │ │ - var result, best, distance; │ │ │ │ - var min = Number.POSITIVE_INFINITY; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - result = this.components[i].distanceTo(geometry, options); │ │ │ │ - distance = details ? result.distance : result; │ │ │ │ - if (distance < min) { │ │ │ │ - min = distance; │ │ │ │ - best = result; │ │ │ │ - if (min == 0) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + clipLine: function(badComponent, goodComponent) { │ │ │ │ + if (goodComponent.equals(badComponent)) { │ │ │ │ + return ""; │ │ │ │ } │ │ │ │ - return best; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ + var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ + var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y1 = this.top - goodComponent.y / resolution; │ │ │ │ + var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y2 = this.top - badComponent.y / resolution; │ │ │ │ + var k; │ │ │ │ + if (x2 < -maxX || x2 > maxX) { │ │ │ │ + k = (y2 - y1) / (x2 - x1); │ │ │ │ + x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ + y2 = y1 + (x2 - x1) * k; │ │ │ │ + } │ │ │ │ + if (y2 < -maxY || y2 > maxY) { │ │ │ │ + k = (x2 - x1) / (y2 - y1); │ │ │ │ + y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ + x2 = x1 + (y2 - y1) * k; │ │ │ │ + } │ │ │ │ + return x2 + "," + y2; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: equals │ │ │ │ - * Determine whether another geometry is equivalent to this one. Geometries │ │ │ │ - * are considered equivalent if all components have the same coordinates. │ │ │ │ + * Method: getShortString │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The geometry to test. │ │ │ │ - * │ │ │ │ + * point - {<OpenLayers.Geometry.Point>} │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The supplied geometry is equivalent to this geometry. │ │ │ │ + * {String} or false if point is outside the valid range │ │ │ │ */ │ │ │ │ - equals: function(geometry) { │ │ │ │ - var equivalent = true; │ │ │ │ - if (!geometry || !geometry.CLASS_NAME || │ │ │ │ - (this.CLASS_NAME != geometry.CLASS_NAME)) { │ │ │ │ - equivalent = false; │ │ │ │ - } else if (!(OpenLayers.Util.isArray(geometry.components)) || │ │ │ │ - (geometry.components.length != this.components.length)) { │ │ │ │ - equivalent = false; │ │ │ │ + getShortString: function(point) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = ((point.x - this.featureDx) / resolution + this.left); │ │ │ │ + var y = (this.top - point.y / resolution); │ │ │ │ + │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + return x + "," + y; │ │ │ │ } else { │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - if (!this.components[i].equals(geometry.components[i])) { │ │ │ │ - equivalent = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - return equivalent; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: transform │ │ │ │ - * Reproject the components geometry from source to dest. │ │ │ │ + * Method: getPosition │ │ │ │ + * Finds the position of an svg node. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * source - {<OpenLayers.Projection>} │ │ │ │ - * dest - {<OpenLayers.Projection>} │ │ │ │ + * node - {DOMElement} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} │ │ │ │ + * {Object} hash with x and y properties, representing the coordinates │ │ │ │ + * within the svg coordinate system │ │ │ │ */ │ │ │ │ - transform: function(source, dest) { │ │ │ │ - if (source && dest) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - var component = this.components[i]; │ │ │ │ - component.transform(source, dest); │ │ │ │ - } │ │ │ │ - this.bounds = null; │ │ │ │ - } │ │ │ │ - return this; │ │ │ │ + getPosition: function(node) { │ │ │ │ + return ({ │ │ │ │ + x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ + y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: intersects │ │ │ │ - * Determine if the input geometry intersects this one. │ │ │ │ - * │ │ │ │ + * Method: importSymbol │ │ │ │ + * add a new symbol definition from the rendererer's symbol hash │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ - * │ │ │ │ + * graphicName - {String} name of the symbol to import │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} The input geometry intersects this one. │ │ │ │ + * {DOMElement} - the imported symbol │ │ │ │ */ │ │ │ │ - intersects: function(geometry) { │ │ │ │ - var intersect = false; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - intersect = geometry.intersects(this.components[i]); │ │ │ │ - if (intersect) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + importSymbol: function(graphicName) { │ │ │ │ + if (!this.defs) { │ │ │ │ + // create svg defs tag │ │ │ │ + this.defs = this.createDefs(); │ │ │ │ } │ │ │ │ - return intersect; │ │ │ │ + var id = this.container.id + "-" + graphicName; │ │ │ │ + │ │ │ │ + // check if symbol already exists in the defs │ │ │ │ + var existing = document.getElementById(id); │ │ │ │ + if (existing != null) { │ │ │ │ + return existing; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ + if (!symbol) { │ │ │ │ + throw new Error(graphicName + ' is not a valid symbol name'); │ │ │ │ + } │ │ │ │ + │ │ │ │ + var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ + var node = this.nodeFactory(null, "polygon"); │ │ │ │ + symbolNode.appendChild(node); │ │ │ │ + var symbolExtent = new OpenLayers.Bounds( │ │ │ │ + Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ + │ │ │ │ + var points = []; │ │ │ │ + var x, y; │ │ │ │ + for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ + x = symbol[i]; │ │ │ │ + y = symbol[i + 1]; │ │ │ │ + symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ + symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ + symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ + symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ + points.push(x, ",", y); │ │ │ │ + } │ │ │ │ + │ │ │ │ + node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ + │ │ │ │ + var width = symbolExtent.getWidth(); │ │ │ │ + var height = symbolExtent.getHeight(); │ │ │ │ + // create a viewBox three times as large as the symbol itself, │ │ │ │ + // to allow for strokeWidth being displayed correctly at the corners. │ │ │ │ + var viewBox = [symbolExtent.left - width, │ │ │ │ + symbolExtent.bottom - height, width * 3, height * 3 │ │ │ │ + ]; │ │ │ │ + symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ + this.symbolMetrics[id] = [ │ │ │ │ + Math.max(width, height), │ │ │ │ + symbolExtent.getCenterLonLat().lon, │ │ │ │ + symbolExtent.getCenterLonLat().lat │ │ │ │ + ]; │ │ │ │ + │ │ │ │ + this.defs.appendChild(symbolNode); │ │ │ │ + return symbolNode; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getVertices │ │ │ │ - * Return a list of all points in this geometry. │ │ │ │ - * │ │ │ │ + * Method: getFeatureIdFromEvent │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ - * endpoints. If false, for lines, only vertices that are not │ │ │ │ - * endpoints will be returned. If not provided, all vertices will │ │ │ │ - * be returned. │ │ │ │ + * evt - {Object} An <OpenLayers.Event> object │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array} A list of all vertices in the geometry. │ │ │ │ + * {String} A feature id or undefined. │ │ │ │ */ │ │ │ │ - getVertices: function(nodes) { │ │ │ │ - var vertices = []; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - Array.prototype.push.apply( │ │ │ │ - vertices, this.components[i].getVertices(nodes) │ │ │ │ - ); │ │ │ │ + getFeatureIdFromEvent: function(evt) { │ │ │ │ + var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ + if (!featureId) { │ │ │ │ + var target = evt.target; │ │ │ │ + featureId = target.parentNode && target != this.rendererRoot ? │ │ │ │ + target.parentNode._featureId : undefined; │ │ │ │ } │ │ │ │ - return vertices; │ │ │ │ + return featureId; │ │ │ │ }, │ │ │ │ │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.Collection" │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/MultiPoint.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Geometry/Collection.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ + * Constant: OpenLayers.Renderer.SVG.LABEL_ALIGN │ │ │ │ + * {Object} │ │ │ │ */ │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ + "l": "start", │ │ │ │ + "r": "end", │ │ │ │ + "b": "bottom", │ │ │ │ + "t": "hanging" │ │ │ │ +}; │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Geometry.MultiPoint │ │ │ │ - * MultiPoint is a collection of Points. Create a new instance with the │ │ │ │ - * <OpenLayers.Geometry.MultiPoint> constructor. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry.Collection> │ │ │ │ - * - <OpenLayers.Geometry> │ │ │ │ + * Constant: OpenLayers.Renderer.SVG.LABEL_VSHIFT │ │ │ │ + * {Object} │ │ │ │ */ │ │ │ │ -OpenLayers.Geometry.MultiPoint = OpenLayers.Class( │ │ │ │ - OpenLayers.Geometry.Collection, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null value means the │ │ │ │ - * component types are not restricted. │ │ │ │ - */ │ │ │ │ - componentTypes: ["OpenLayers.Geometry.Point"], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.MultiPoint │ │ │ │ - * Create a new MultiPoint Geometry │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry.Point>)} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.MultiPoint>} │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: addPoint │ │ │ │ - * Wrapper for <OpenLayers.Geometry.Collection.addComponent> │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} Point to be added │ │ │ │ - * index - {Integer} Optional index │ │ │ │ - */ │ │ │ │ - addPoint: function(point, index) { │ │ │ │ - this.addComponent(point, index); │ │ │ │ - }, │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ + // according to │ │ │ │ + // http://www.w3.org/Graphics/SVG/Test/20061213/htmlObjectHarness/full-text-align-02-b.html │ │ │ │ + // a baseline-shift of -70% shifts the text exactly from the │ │ │ │ + // bottom to the top of the baseline, so -35% moves the text to │ │ │ │ + // the center of the baseline. │ │ │ │ + "t": "-70%", │ │ │ │ + "b": "0" │ │ │ │ +}; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: removePoint │ │ │ │ - * Wrapper for <OpenLayers.Geometry.Collection.removeComponent> │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} Point to be removed │ │ │ │ - */ │ │ │ │ - removePoint: function(point) { │ │ │ │ - this.removeComponent(point); │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Renderer.SVG.LABEL_VFACTOR │ │ │ │ + * {Object} │ │ │ │ + */ │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ + "t": 0, │ │ │ │ + "b": -1 │ │ │ │ +}; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.MultiPoint" │ │ │ │ - }); │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Renderer.SVG.preventDefault │ │ │ │ + * *Deprecated*. Use <OpenLayers.Event.preventDefault> method instead. │ │ │ │ + * Used to prevent default events (especially opening images in a new tab on │ │ │ │ + * ctrl-click) from being executed for externalGraphic symbols │ │ │ │ + */ │ │ │ │ +OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ + OpenLayers.Event.preventDefault(e); │ │ │ │ +}; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Geometry/Curve.js │ │ │ │ + OpenLayers/Control.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Geometry/MultiPoint.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Geometry.Curve │ │ │ │ - * A Curve is a MultiPoint, whose points are assumed to be connected. To │ │ │ │ - * this end, we provide a "getLength()" function, which iterates through │ │ │ │ - * the points, summing the distances between them. │ │ │ │ + * Class: OpenLayers.Control │ │ │ │ + * Controls affect the display or behavior of the map. They allow everything │ │ │ │ + * from panning and zooming to displaying a scale indicator. Controls by │ │ │ │ + * default are added to the map they are contained within however it is │ │ │ │ + * possible to add a control to an external div by passing the div in the │ │ │ │ + * options parameter. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * The following example shows how to add many of the common controls │ │ │ │ + * to a map. │ │ │ │ + * │ │ │ │ + * > var map = new OpenLayers.Map('map', { controls: [] }); │ │ │ │ + * > │ │ │ │ + * > map.addControl(new OpenLayers.Control.PanZoomBar()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false})); │ │ │ │ + * > map.addControl(new OpenLayers.Control.Permalink()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.Permalink('permalink')); │ │ │ │ + * > map.addControl(new OpenLayers.Control.MousePosition()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.OverviewMap()); │ │ │ │ + * > map.addControl(new OpenLayers.Control.KeyboardDefaults()); │ │ │ │ + * │ │ │ │ + * The next code fragment is a quick example of how to intercept │ │ │ │ + * shift-mouse click to display the extent of the bounding box │ │ │ │ + * dragged out by the user. Usually controls are not created │ │ │ │ + * in exactly this manner. See the source for a more complete │ │ │ │ + * example: │ │ │ │ + * │ │ │ │ + * > var control = new OpenLayers.Control(); │ │ │ │ + * > OpenLayers.Util.extend(control, { │ │ │ │ + * > draw: function () { │ │ │ │ + * > // this Handler.Box will intercept the shift-mousedown │ │ │ │ + * > // before Control.MouseDefault gets to see it │ │ │ │ + * > this.box = new OpenLayers.Handler.Box( control, │ │ │ │ + * > {"done": this.notice}, │ │ │ │ + * > {keyMask: OpenLayers.Handler.MOD_SHIFT}); │ │ │ │ + * > this.box.activate(); │ │ │ │ + * > }, │ │ │ │ + * > │ │ │ │ + * > notice: function (bounds) { │ │ │ │ + * > OpenLayers.Console.userError(bounds); │ │ │ │ + * > } │ │ │ │ + * > }); │ │ │ │ + * > map.addControl(control); │ │ │ │ * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Geometry.MultiPoint> │ │ │ │ */ │ │ │ │ -OpenLayers.Geometry.Curve = OpenLayers.Class(OpenLayers.Geometry.MultiPoint, { │ │ │ │ +OpenLayers.Control = OpenLayers.Class({ │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null │ │ │ │ - * value means the component types are not restricted. │ │ │ │ + /** │ │ │ │ + * Property: id │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - componentTypes: ["OpenLayers.Geometry.Point"], │ │ │ │ + id: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.Curve │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {Array(<OpenLayers.Geometry.Point>)} │ │ │ │ + /** │ │ │ │ + * Property: map │ │ │ │ + * {<OpenLayers.Map>} this gets set in the addControl() function in │ │ │ │ + * OpenLayers.Map │ │ │ │ */ │ │ │ │ + map: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getLength │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The length of the curve │ │ │ │ + /** │ │ │ │ + * APIProperty: div │ │ │ │ + * {DOMElement} The element that contains the control, if not present the │ │ │ │ + * control is placed inside the map. │ │ │ │ */ │ │ │ │ - getLength: function() { │ │ │ │ - var length = 0.0; │ │ │ │ - if (this.components && (this.components.length > 1)) { │ │ │ │ - for (var i = 1, len = this.components.length; i < len; i++) { │ │ │ │ - length += this.components[i - 1].distanceTo(this.components[i]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return length; │ │ │ │ - }, │ │ │ │ + div: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: getGeodesicLength │ │ │ │ - * Calculate the approximate length of the geometry were it projected onto │ │ │ │ - * the earth. │ │ │ │ - * │ │ │ │ - * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ - * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ - * assumed. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The appoximate geodesic length of the geometry in meters. │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {Number} Controls can have a 'type'. The type determines the type of │ │ │ │ + * interactions which are possible with them when they are placed in an │ │ │ │ + * <OpenLayers.Control.Panel>. │ │ │ │ */ │ │ │ │ - getGeodesicLength: function(projection) { │ │ │ │ - var geom = this; // so we can work with a clone if needed │ │ │ │ - if (projection) { │ │ │ │ - var gg = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - if (!gg.equals(projection)) { │ │ │ │ - geom = this.clone().transform(projection, gg); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var length = 0.0; │ │ │ │ - if (geom.components && (geom.components.length > 1)) { │ │ │ │ - var p1, p2; │ │ │ │ - for (var i = 1, len = geom.components.length; i < len; i++) { │ │ │ │ - p1 = geom.components[i - 1]; │ │ │ │ - p2 = geom.components[i]; │ │ │ │ - // this returns km and requires lon/lat properties │ │ │ │ - length += OpenLayers.Util.distVincenty({ │ │ │ │ - lon: p1.x, │ │ │ │ - lat: p1.y │ │ │ │ - }, { │ │ │ │ - lon: p2.x, │ │ │ │ - lat: p2.y │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // convert to m │ │ │ │ - return length * 1000; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.Curve" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/LineString.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + type: null, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Geometry/Curve.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Property: allowSelection │ │ │ │ + * {Boolean} By default, 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, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry.LineString │ │ │ │ - * A LineString is a Curve which, once two points have been added to it, can │ │ │ │ - * never be less than two points long. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry.Curve> │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.LineString = OpenLayers.Class(OpenLayers.Geometry.Curve, { │ │ │ │ + /** │ │ │ │ + * Property: displayClass │ │ │ │ + * {string} This property is used for CSS related to the drawing of the │ │ │ │ + * Control. │ │ │ │ + */ │ │ │ │ + displayClass: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Geometry.LineString │ │ │ │ - * Create a new LineString geometry │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * points - {Array(<OpenLayers.Geometry.Point>)} An array of points used to │ │ │ │ - * generate the linestring │ │ │ │ - * │ │ │ │ + * APIProperty: title │ │ │ │ + * {string} This property is used for showing a tooltip over the │ │ │ │ + * Control. │ │ │ │ */ │ │ │ │ + title: "", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: removeComponent │ │ │ │ - * Only allows removal of a point if there are three or more points in │ │ │ │ - * the linestring. (otherwise the result would be just a single point) │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} The point to be removed │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The component was removed. │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * false. │ │ │ │ */ │ │ │ │ - removeComponent: function(point) { │ │ │ │ - var removed = this.components && (this.components.length > 2); │ │ │ │ - if (removed) { │ │ │ │ - OpenLayers.Geometry.Collection.prototype.removeComponent.apply(this, │ │ │ │ - arguments); │ │ │ │ - } │ │ │ │ - return removed; │ │ │ │ - }, │ │ │ │ + autoActivate: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: active │ │ │ │ + * {Boolean} The control is active (read-only). Use <activate> and │ │ │ │ + * <deactivate> to change control state. │ │ │ │ + */ │ │ │ │ + active: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: intersects │ │ │ │ - * Test for instersection between two geometries. This is a cheapo │ │ │ │ - * implementation of the Bently-Ottmann algorigithm. It doesn't │ │ │ │ - * really keep track of a sweep line data structure. It is closer │ │ │ │ - * to the brute force method, except that segments are sorted and │ │ │ │ - * potential intersections are only calculated when bounding boxes │ │ │ │ - * intersect. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The input geometry intersects this geometry. │ │ │ │ + * Property: handlerOptions │ │ │ │ + * {Object} Used to set non-default properties on the control's handler │ │ │ │ */ │ │ │ │ - intersects: function(geometry) { │ │ │ │ - var intersect = false; │ │ │ │ - var type = geometry.CLASS_NAME; │ │ │ │ - if (type == "OpenLayers.Geometry.LineString" || │ │ │ │ - type == "OpenLayers.Geometry.LinearRing" || │ │ │ │ - type == "OpenLayers.Geometry.Point") { │ │ │ │ - var segs1 = this.getSortedSegments(); │ │ │ │ - var segs2; │ │ │ │ - if (type == "OpenLayers.Geometry.Point") { │ │ │ │ - segs2 = [{ │ │ │ │ - x1: geometry.x, │ │ │ │ - y1: geometry.y, │ │ │ │ - x2: geometry.x, │ │ │ │ - y2: geometry.y │ │ │ │ - }]; │ │ │ │ - } else { │ │ │ │ - segs2 = geometry.getSortedSegments(); │ │ │ │ - } │ │ │ │ - var seg1, seg1x1, seg1x2, seg1y1, seg1y2, │ │ │ │ - seg2, seg2y1, seg2y2; │ │ │ │ - // sweep right │ │ │ │ - outer: for (var i = 0, len = segs1.length; i < len; ++i) { │ │ │ │ - seg1 = segs1[i]; │ │ │ │ - seg1x1 = seg1.x1; │ │ │ │ - seg1x2 = seg1.x2; │ │ │ │ - seg1y1 = seg1.y1; │ │ │ │ - seg1y2 = seg1.y2; │ │ │ │ - inner: for (var j = 0, jlen = segs2.length; j < jlen; ++j) { │ │ │ │ - seg2 = segs2[j]; │ │ │ │ - if (seg2.x1 > seg1x2) { │ │ │ │ - // seg1 still left of seg2 │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - if (seg2.x2 < seg1x1) { │ │ │ │ - // seg2 still left of seg1 │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - seg2y1 = seg2.y1; │ │ │ │ - seg2y2 = seg2.y2; │ │ │ │ - if (Math.min(seg2y1, seg2y2) > Math.max(seg1y1, seg1y2)) { │ │ │ │ - // seg2 above seg1 │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - if (Math.max(seg2y1, seg2y2) < Math.min(seg1y1, seg1y2)) { │ │ │ │ - // seg2 below seg1 │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - if (OpenLayers.Geometry.segmentsIntersect(seg1, seg2)) { │ │ │ │ - intersect = true; │ │ │ │ - break outer; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - intersect = geometry.intersects(this); │ │ │ │ - } │ │ │ │ - return intersect; │ │ │ │ - }, │ │ │ │ + handlerOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: handler │ │ │ │ + * {<OpenLayers.Handler>} null │ │ │ │ + */ │ │ │ │ + handler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: getSortedSegments │ │ │ │ + * APIProperty: eventListeners │ │ │ │ + * {Object} If set as an option at construction, the eventListeners │ │ │ │ + * object will be registered with <OpenLayers.Events.on>. Object │ │ │ │ + * structure must be a listeners object as shown in the example for │ │ │ │ + * the events.on method. │ │ │ │ + */ │ │ │ │ + eventListeners: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of segment objects. Segment objects have properties │ │ │ │ - * x1, y1, x2, and y2. The start point is represented by x1 and y1. │ │ │ │ - * The end point is represented by x2 and y2. Start and end are │ │ │ │ - * ordered so that x1 < x2. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - getSortedSegments: function() { │ │ │ │ - var numSeg = this.components.length - 1; │ │ │ │ - var segments = new Array(numSeg), │ │ │ │ - point1, point2; │ │ │ │ - for (var i = 0; i < numSeg; ++i) { │ │ │ │ - point1 = this.components[i]; │ │ │ │ - point2 = this.components[i + 1]; │ │ │ │ - if (point1.x < point2.x) { │ │ │ │ - segments[i] = { │ │ │ │ - x1: point1.x, │ │ │ │ - y1: point1.y, │ │ │ │ - x2: point2.x, │ │ │ │ - y2: point2.y │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - segments[i] = { │ │ │ │ - x1: point2.x, │ │ │ │ - y1: point2.y, │ │ │ │ - x2: point1.x, │ │ │ │ - y2: point1.y │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // more efficient to define this somewhere static │ │ │ │ - function byX1(seg1, seg2) { │ │ │ │ - return seg1.x1 - seg2.x1; │ │ │ │ - } │ │ │ │ - return segments.sort(byX1); │ │ │ │ - }, │ │ │ │ + events: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: splitWithSegment │ │ │ │ - * Split this geometry with the given segment. │ │ │ │ + * 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: │ │ │ │ - * seg - {Object} An object with x1, y1, x2, and y2 properties referencing │ │ │ │ - * segment endpoint coordinates. │ │ │ │ - * options - {Object} Properties of this object will be used to determine │ │ │ │ - * how the split is conducted. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ - * true. If false, a vertex on the source segment must be within the │ │ │ │ - * tolerance distance of the intersection to be considered a split. │ │ │ │ - * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ - * within the tolerance distance of one of the source segment's │ │ │ │ - * endpoints will be assumed to occur at the endpoint. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object with *lines* and *points* properties. If the given │ │ │ │ - * segment intersects this linestring, the lines array will reference │ │ │ │ - * geometries that result from the split. The points array will contain │ │ │ │ - * all intersection points. Intersection points are sorted along the │ │ │ │ - * segment (in order from x1,y1 to x2,y2). │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - splitWithSegment: function(seg, options) { │ │ │ │ - var edge = !(options && options.edge === false); │ │ │ │ - var tolerance = options && options.tolerance; │ │ │ │ - var lines = []; │ │ │ │ - var verts = this.getVertices(); │ │ │ │ - var points = []; │ │ │ │ - var intersections = []; │ │ │ │ - var split = false; │ │ │ │ - var vert1, vert2, point; │ │ │ │ - var node, vertex, target; │ │ │ │ - var interOptions = { │ │ │ │ - point: true, │ │ │ │ - tolerance: tolerance │ │ │ │ - }; │ │ │ │ - var result = null; │ │ │ │ - for (var i = 0, stop = verts.length - 2; i <= stop; ++i) { │ │ │ │ - vert1 = verts[i]; │ │ │ │ - points.push(vert1.clone()); │ │ │ │ - vert2 = verts[i + 1]; │ │ │ │ - target = { │ │ │ │ - x1: vert1.x, │ │ │ │ - y1: vert1.y, │ │ │ │ - x2: vert2.x, │ │ │ │ - y2: vert2.y │ │ │ │ - }; │ │ │ │ - point = OpenLayers.Geometry.segmentsIntersect( │ │ │ │ - seg, target, interOptions │ │ │ │ - ); │ │ │ │ - if (point instanceof OpenLayers.Geometry.Point) { │ │ │ │ - if ((point.x === seg.x1 && point.y === seg.y1) || │ │ │ │ - (point.x === seg.x2 && point.y === seg.y2) || │ │ │ │ - point.equals(vert1) || point.equals(vert2)) { │ │ │ │ - vertex = true; │ │ │ │ - } else { │ │ │ │ - vertex = false; │ │ │ │ - } │ │ │ │ - if (vertex || edge) { │ │ │ │ - // push intersections different than the previous │ │ │ │ - if (!point.equals(intersections[intersections.length - 1])) { │ │ │ │ - intersections.push(point.clone()); │ │ │ │ - } │ │ │ │ - if (i === 0) { │ │ │ │ - if (point.equals(vert1)) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (point.equals(vert2)) { │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - split = true; │ │ │ │ - if (!point.equals(vert1)) { │ │ │ │ - points.push(point); │ │ │ │ - } │ │ │ │ - lines.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ - points = [point.clone()]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (split) { │ │ │ │ - points.push(vert2.clone()); │ │ │ │ - lines.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ + 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); │ │ │ │ + if (this.eventListeners instanceof Object) { │ │ │ │ + this.events.on(this.eventListeners); │ │ │ │ } │ │ │ │ - if (intersections.length > 0) { │ │ │ │ - // sort intersections along segment │ │ │ │ - var xDir = seg.x1 < seg.x2 ? 1 : -1; │ │ │ │ - var yDir = seg.y1 < seg.y2 ? 1 : -1; │ │ │ │ - result = { │ │ │ │ - lines: lines, │ │ │ │ - points: intersections.sort(function(p1, p2) { │ │ │ │ - return (xDir * p1.x - xDir * p2.x) || (yDir * p1.y - yDir * p2.y); │ │ │ │ - }) │ │ │ │ - }; │ │ │ │ + if (this.id == null) { │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ } │ │ │ │ - return result; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: split │ │ │ │ - * Use this geometry (the source) to attempt to split a target geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * target - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Properties of this object will be used to determine │ │ │ │ - * how the split is conducted. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ - * geometry. Default is false. │ │ │ │ - * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ - * true. If false, a vertex on the source must be within the tolerance │ │ │ │ - * distance of the intersection to be considered a split. │ │ │ │ - * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ - * within the tolerance distance of an existing vertex on the source │ │ │ │ - * will be assumed to occur at the vertex. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} A list of geometries (of this same type as the target) that │ │ │ │ - * result from splitting the target with the source geometry. The │ │ │ │ - * source and target geometry will remain unmodified. If no split │ │ │ │ - * results, null will be returned. If mutual is true and a split │ │ │ │ - * results, return will be an array of two arrays - the first will be │ │ │ │ - * all geometries that result from splitting the source geometry and │ │ │ │ - * the second will be all geometries that result from splitting the │ │ │ │ - * target geometry. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - split: function(target, options) { │ │ │ │ - var results = null; │ │ │ │ - var mutual = options && options.mutual; │ │ │ │ - var sourceSplit, targetSplit, sourceParts, targetParts; │ │ │ │ - if (target instanceof OpenLayers.Geometry.LineString) { │ │ │ │ - var verts = this.getVertices(); │ │ │ │ - var vert1, vert2, seg, splits, lines, point; │ │ │ │ - var points = []; │ │ │ │ - sourceParts = []; │ │ │ │ - for (var i = 0, stop = verts.length - 2; i <= stop; ++i) { │ │ │ │ - vert1 = verts[i]; │ │ │ │ - vert2 = verts[i + 1]; │ │ │ │ - seg = { │ │ │ │ - x1: vert1.x, │ │ │ │ - y1: vert1.y, │ │ │ │ - x2: vert2.x, │ │ │ │ - y2: vert2.y │ │ │ │ - }; │ │ │ │ - targetParts = targetParts || [target]; │ │ │ │ - if (mutual) { │ │ │ │ - points.push(vert1.clone()); │ │ │ │ - } │ │ │ │ - for (var j = 0; j < targetParts.length; ++j) { │ │ │ │ - splits = targetParts[j].splitWithSegment(seg, options); │ │ │ │ - if (splits) { │ │ │ │ - // splice in new features │ │ │ │ - lines = splits.lines; │ │ │ │ - if (lines.length > 0) { │ │ │ │ - lines.unshift(j, 1); │ │ │ │ - Array.prototype.splice.apply(targetParts, lines); │ │ │ │ - j += lines.length - 2; │ │ │ │ - } │ │ │ │ - if (mutual) { │ │ │ │ - for (var k = 0, len = splits.points.length; k < len; ++k) { │ │ │ │ - point = splits.points[k]; │ │ │ │ - if (!point.equals(vert1)) { │ │ │ │ - points.push(point); │ │ │ │ - sourceParts.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ - if (point.equals(vert2)) { │ │ │ │ - points = []; │ │ │ │ - } else { │ │ │ │ - points = [point.clone()]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (mutual && sourceParts.length > 0 && points.length > 0) { │ │ │ │ - points.push(vert2.clone()); │ │ │ │ - sourceParts.push(new OpenLayers.Geometry.LineString(points)); │ │ │ │ + destroy: function() { │ │ │ │ + if (this.events) { │ │ │ │ + if (this.eventListeners) { │ │ │ │ + this.events.un(this.eventListeners); │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - results = target.splitWith(this, options); │ │ │ │ - } │ │ │ │ - if (targetParts && targetParts.length > 1) { │ │ │ │ - targetSplit = true; │ │ │ │ - } else { │ │ │ │ - targetParts = []; │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ } │ │ │ │ - if (sourceParts && sourceParts.length > 1) { │ │ │ │ - sourceSplit = true; │ │ │ │ - } else { │ │ │ │ - sourceParts = []; │ │ │ │ + this.eventListeners = null; │ │ │ │ + │ │ │ │ + // eliminate circular references │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.destroy(); │ │ │ │ + this.handler = null; │ │ │ │ } │ │ │ │ - if (targetSplit || sourceSplit) { │ │ │ │ - if (mutual) { │ │ │ │ - results = [sourceParts, targetParts]; │ │ │ │ - } else { │ │ │ │ - results = targetParts; │ │ │ │ + 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; │ │ │ │ } │ │ │ │ - return results; │ │ │ │ + if (this.map) { │ │ │ │ + this.map.removeControl(this); │ │ │ │ + this.map = null; │ │ │ │ + } │ │ │ │ + this.div = null; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: splitWith │ │ │ │ - * Split this geometry (the target) with the given geometry (the source). │ │ │ │ + /** │ │ │ │ + * 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: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} A geometry used to split this │ │ │ │ - * geometry (the source). │ │ │ │ - * options - {Object} Properties of this object will be used to determine │ │ │ │ - * how the split is conducted. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ - * geometry. Default is false. │ │ │ │ - * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ - * true. If false, a vertex on the source must be within the tolerance │ │ │ │ - * distance of the intersection to be considered a split. │ │ │ │ - * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ - * within the tolerance distance of an existing vertex on the source │ │ │ │ - * will be assumed to occur at the vertex. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} A list of geometries (of this same type as the target) that │ │ │ │ - * result from splitting the target with the source geometry. The │ │ │ │ - * source and target geometry will remain unmodified. If no split │ │ │ │ - * results, null will be returned. If mutual is true and a split │ │ │ │ - * results, return will be an array of two arrays - the first will be │ │ │ │ - * all geometries that result from splitting the source geometry and │ │ │ │ - * the second will be all geometries that result from splitting the │ │ │ │ - * target geometry. │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - splitWith: function(geometry, options) { │ │ │ │ - return geometry.split(this, options); │ │ │ │ - │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.setMap(map); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getVertices │ │ │ │ - * Return a list of all points in this geometry. │ │ │ │ + * 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: │ │ │ │ - * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ - * endpoints. If false, for lines, only vertices that are not │ │ │ │ - * endpoints will be returned. If not provided, all vertices will │ │ │ │ - * be returned. │ │ │ │ + * px - {<OpenLayers.Pixel>} The top-left pixel position of the control │ │ │ │ + * or null. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array} A list of all vertices in the geometry. │ │ │ │ + * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ */ │ │ │ │ - getVertices: function(nodes) { │ │ │ │ - var vertices; │ │ │ │ - if (nodes === true) { │ │ │ │ - vertices = [ │ │ │ │ - this.components[0], │ │ │ │ - this.components[this.components.length - 1] │ │ │ │ - ]; │ │ │ │ - } else if (nodes === false) { │ │ │ │ - vertices = this.components.slice(1, this.components.length - 1); │ │ │ │ - } else { │ │ │ │ - vertices = this.components.slice(); │ │ │ │ + draw: function(px) { │ │ │ │ + if (this.div == null) { │ │ │ │ + this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ + this.div.className = this.displayClass; │ │ │ │ + if (!this.allowSelection) { │ │ │ │ + this.div.className += " olControlNoSelect"; │ │ │ │ + this.div.setAttribute("unselectable", "on", 0); │ │ │ │ + this.div.onselectstart = OpenLayers.Function.False; │ │ │ │ + } │ │ │ │ + if (this.title != "") { │ │ │ │ + this.div.title = this.title; │ │ │ │ + } │ │ │ │ } │ │ │ │ - return vertices; │ │ │ │ + if (px != null) { │ │ │ │ + this.position = px.clone(); │ │ │ │ + } │ │ │ │ + this.moveTo(this.position); │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: distanceTo │ │ │ │ - * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ + * Method: moveTo │ │ │ │ + * Sets the left and top style attributes to the passed in pixel │ │ │ │ + * coordinates. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Optional properties for configuring the distance │ │ │ │ - * calculation. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * details - {Boolean} Return details from the distance calculation. │ │ │ │ - * Default is false. │ │ │ │ - * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ - * nearest edge of the target geometry. Default is true. If true, │ │ │ │ - * calling distanceTo from a geometry that is wholly contained within │ │ │ │ - * the target will result in a non-zero distance. If false, whenever │ │ │ │ - * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ - * details cannot be returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number | Object} The distance between this geometry and the target. │ │ │ │ - * If details is true, the return will be an object with distance, │ │ │ │ - * x0, y0, x1, and x2 properties. The x0 and y0 properties represent │ │ │ │ - * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ - * properties represent the coordinates of the closest point on the │ │ │ │ - * target geometry. │ │ │ │ + * px - {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - distanceTo: function(geometry, options) { │ │ │ │ - var edge = !(options && options.edge === false); │ │ │ │ - var details = edge && options && options.details; │ │ │ │ - var result, best = {}; │ │ │ │ - var min = Number.POSITIVE_INFINITY; │ │ │ │ - if (geometry instanceof OpenLayers.Geometry.Point) { │ │ │ │ - var segs = this.getSortedSegments(); │ │ │ │ - var x = geometry.x; │ │ │ │ - var y = geometry.y; │ │ │ │ - var seg; │ │ │ │ - for (var i = 0, len = segs.length; i < len; ++i) { │ │ │ │ - seg = segs[i]; │ │ │ │ - result = OpenLayers.Geometry.distanceToSegment(geometry, seg); │ │ │ │ - if (result.distance < min) { │ │ │ │ - min = result.distance; │ │ │ │ - best = result; │ │ │ │ - if (min === 0) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - // if distance increases and we cross y0 to the right of x0, no need to keep looking. │ │ │ │ - if (seg.x2 > x && ((y > seg.y1 && y < seg.y2) || (y < seg.y1 && y > seg.y2))) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (details) { │ │ │ │ - best = { │ │ │ │ - distance: best.distance, │ │ │ │ - x0: best.x, │ │ │ │ - y0: best.y, │ │ │ │ - x1: x, │ │ │ │ - y1: y │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - best = best.distance; │ │ │ │ - } │ │ │ │ - } else if (geometry instanceof OpenLayers.Geometry.LineString) { │ │ │ │ - var segs0 = this.getSortedSegments(); │ │ │ │ - var segs1 = geometry.getSortedSegments(); │ │ │ │ - var seg0, seg1, intersection, x0, y0; │ │ │ │ - var len1 = segs1.length; │ │ │ │ - var interOptions = { │ │ │ │ - point: true │ │ │ │ - }; │ │ │ │ - outer: for (var i = 0, len = segs0.length; i < len; ++i) { │ │ │ │ - seg0 = segs0[i]; │ │ │ │ - x0 = seg0.x1; │ │ │ │ - y0 = seg0.y1; │ │ │ │ - for (var j = 0; j < len1; ++j) { │ │ │ │ - seg1 = segs1[j]; │ │ │ │ - intersection = OpenLayers.Geometry.segmentsIntersect(seg0, seg1, interOptions); │ │ │ │ - if (intersection) { │ │ │ │ - min = 0; │ │ │ │ - best = { │ │ │ │ - distance: 0, │ │ │ │ - x0: intersection.x, │ │ │ │ - y0: intersection.y, │ │ │ │ - x1: intersection.x, │ │ │ │ - y1: intersection.y │ │ │ │ - }; │ │ │ │ - break outer; │ │ │ │ - } else { │ │ │ │ - result = OpenLayers.Geometry.distanceToSegment({ │ │ │ │ - x: x0, │ │ │ │ - y: y0 │ │ │ │ - }, seg1); │ │ │ │ - if (result.distance < min) { │ │ │ │ - min = result.distance; │ │ │ │ - best = { │ │ │ │ - distance: min, │ │ │ │ - x0: x0, │ │ │ │ - y0: y0, │ │ │ │ - x1: result.x, │ │ │ │ - y1: result.y │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!details) { │ │ │ │ - best = best.distance; │ │ │ │ - } │ │ │ │ - if (min !== 0) { │ │ │ │ - // check the final vertex in this line's sorted segments │ │ │ │ - if (seg0) { │ │ │ │ - result = geometry.distanceTo( │ │ │ │ - new OpenLayers.Geometry.Point(seg0.x2, seg0.y2), │ │ │ │ - options │ │ │ │ - ); │ │ │ │ - var dist = details ? result.distance : result; │ │ │ │ - if (dist < min) { │ │ │ │ - if (details) { │ │ │ │ - best = { │ │ │ │ - distance: min, │ │ │ │ - x0: result.x1, │ │ │ │ - y0: result.y1, │ │ │ │ - x1: result.x0, │ │ │ │ - y1: result.y0 │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - best = dist; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - best = geometry.distanceTo(this, options); │ │ │ │ - // swap since target comes from this line │ │ │ │ - if (details) { │ │ │ │ - best = { │ │ │ │ - distance: best.distance, │ │ │ │ - x0: best.x1, │ │ │ │ - y0: best.y1, │ │ │ │ - x1: best.x0, │ │ │ │ - y1: best.y0 │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + moveTo: function(px) { │ │ │ │ + if ((px != null) && (this.div != null)) { │ │ │ │ + this.div.style.left = px.x + "px"; │ │ │ │ + this.div.style.top = px.y + "px"; │ │ │ │ } │ │ │ │ - return best; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: simplify │ │ │ │ - * This function will return a simplified LineString. │ │ │ │ - * Simplification is based on the Douglas-Peucker algorithm. │ │ │ │ - * │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * tolerance - {number} threshhold for simplification in map units │ │ │ │ - * │ │ │ │ + * APIMethod: activate │ │ │ │ + * Explicitly activates a control and it's associated │ │ │ │ + * handler if one has been set. Controls can be │ │ │ │ + * deactivated by calling the deactivate() method. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {OpenLayers.Geometry.LineString} the simplified LineString │ │ │ │ + * {Boolean} True if the control was successfully activated or │ │ │ │ + * false if the control was already active. │ │ │ │ */ │ │ │ │ - simplify: function(tolerance) { │ │ │ │ - if (this && this !== null) { │ │ │ │ - var points = this.getVertices(); │ │ │ │ - if (points.length < 3) { │ │ │ │ - return this; │ │ │ │ - } │ │ │ │ - │ │ │ │ - var compareNumbers = function(a, b) { │ │ │ │ - return (a - b); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Private function doing the Douglas-Peucker reduction │ │ │ │ - */ │ │ │ │ - var douglasPeuckerReduction = function(points, firstPoint, lastPoint, tolerance) { │ │ │ │ - var maxDistance = 0; │ │ │ │ - var indexFarthest = 0; │ │ │ │ - │ │ │ │ - for (var index = firstPoint, distance; index < lastPoint; index++) { │ │ │ │ - distance = perpendicularDistance(points[firstPoint], points[lastPoint], points[index]); │ │ │ │ - if (distance > maxDistance) { │ │ │ │ - maxDistance = distance; │ │ │ │ - indexFarthest = index; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (maxDistance > tolerance && indexFarthest != firstPoint) { │ │ │ │ - //Add the largest point that exceeds the tolerance │ │ │ │ - pointIndexsToKeep.push(indexFarthest); │ │ │ │ - douglasPeuckerReduction(points, firstPoint, indexFarthest, tolerance); │ │ │ │ - douglasPeuckerReduction(points, indexFarthest, lastPoint, tolerance); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Private function calculating the perpendicular distance │ │ │ │ - * TODO: check whether OpenLayers.Geometry.LineString::distanceTo() is faster or slower │ │ │ │ - */ │ │ │ │ - var perpendicularDistance = function(point1, point2, point) { │ │ │ │ - //Area = |(1/2)(x1y2 + x2y3 + x3y1 - x2y1 - x3y2 - x1y3)| *Area of triangle │ │ │ │ - //Base = v((x1-x2)²+(x1-x2)²) *Base of Triangle* │ │ │ │ - //Area = .5*Base*H *Solve for height │ │ │ │ - //Height = Area/.5/Base │ │ │ │ - │ │ │ │ - var area = Math.abs(0.5 * (point1.x * point2.y + point2.x * point.y + point.x * point1.y - point2.x * point1.y - point.x * point2.y - point1.x * point.y)); │ │ │ │ - var bottom = Math.sqrt(Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2)); │ │ │ │ - var height = area / bottom * 2; │ │ │ │ - │ │ │ │ - return height; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - var firstPoint = 0; │ │ │ │ - var lastPoint = points.length - 1; │ │ │ │ - var pointIndexsToKeep = []; │ │ │ │ - │ │ │ │ - //Add the first and last index to the keepers │ │ │ │ - pointIndexsToKeep.push(firstPoint); │ │ │ │ - pointIndexsToKeep.push(lastPoint); │ │ │ │ - │ │ │ │ - //The first and the last point cannot be the same │ │ │ │ - while (points[firstPoint].equals(points[lastPoint])) { │ │ │ │ - lastPoint--; │ │ │ │ - //Addition: the first point not equal to first point in the LineString is kept as well │ │ │ │ - pointIndexsToKeep.push(lastPoint); │ │ │ │ - } │ │ │ │ - │ │ │ │ - douglasPeuckerReduction(points, firstPoint, lastPoint, tolerance); │ │ │ │ - var returnPoints = []; │ │ │ │ - pointIndexsToKeep.sort(compareNumbers); │ │ │ │ - for (var index = 0; index < pointIndexsToKeep.length; index++) { │ │ │ │ - returnPoints.push(points[pointIndexsToKeep[index]]); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.LineString(returnPoints); │ │ │ │ - │ │ │ │ - } else { │ │ │ │ - return this; │ │ │ │ + activate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.activate(); │ │ │ │ + } │ │ │ │ + this.active = true; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.addClass( │ │ │ │ + this.map.viewPortDiv, │ │ │ │ + this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("activate"); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.LineString" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/MultiLineString.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Geometry/Collection.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry.MultiLineString │ │ │ │ - * A MultiLineString is a geometry with multiple <OpenLayers.Geometry.LineString> │ │ │ │ - * components. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry.Collection> │ │ │ │ - * - <OpenLayers.Geometry> │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.MultiLineString = OpenLayers.Class( │ │ │ │ - OpenLayers.Geometry.Collection, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null value means the │ │ │ │ - * component types are not restricted. │ │ │ │ - */ │ │ │ │ - componentTypes: ["OpenLayers.Geometry.LineString"], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.MultiLineString │ │ │ │ - * Constructor for a MultiLineString Geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry.LineString>)} │ │ │ │ - * │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: split │ │ │ │ - * Use this geometry (the source) to attempt to split a target geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Properties of this object will be used to determine │ │ │ │ - * how the split is conducted. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ - * geometry. Default is false. │ │ │ │ - * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ - * true. If false, a vertex on the source must be within the tolerance │ │ │ │ - * distance of the intersection to be considered a split. │ │ │ │ - * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ - * within the tolerance distance of an existing vertex on the source │ │ │ │ - * will be assumed to occur at the vertex. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} A list of geometries (of this same type as the target) that │ │ │ │ - * result from splitting the target with the source geometry. The │ │ │ │ - * source and target geometry will remain unmodified. If no split │ │ │ │ - * results, null will be returned. If mutual is true and a split │ │ │ │ - * results, return will be an array of two arrays - the first will be │ │ │ │ - * all geometries that result from splitting the source geometry and │ │ │ │ - * the second will be all geometries that result from splitting the │ │ │ │ - * target geometry. │ │ │ │ - */ │ │ │ │ - split: function(geometry, options) { │ │ │ │ - var results = null; │ │ │ │ - var mutual = options && options.mutual; │ │ │ │ - var splits, sourceLine, sourceLines, sourceSplit, targetSplit; │ │ │ │ - var sourceParts = []; │ │ │ │ - var targetParts = [geometry]; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - sourceLine = this.components[i]; │ │ │ │ - sourceSplit = false; │ │ │ │ - for (var j = 0; j < targetParts.length; ++j) { │ │ │ │ - splits = sourceLine.split(targetParts[j], options); │ │ │ │ - if (splits) { │ │ │ │ - if (mutual) { │ │ │ │ - sourceLines = splits[0]; │ │ │ │ - for (var k = 0, klen = sourceLines.length; k < klen; ++k) { │ │ │ │ - if (k === 0 && sourceParts.length) { │ │ │ │ - sourceParts[sourceParts.length - 1].addComponent( │ │ │ │ - sourceLines[k] │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - sourceParts.push( │ │ │ │ - new OpenLayers.Geometry.MultiLineString([ │ │ │ │ - sourceLines[k] │ │ │ │ - ]) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - sourceSplit = true; │ │ │ │ - splits = splits[1]; │ │ │ │ - } │ │ │ │ - if (splits.length) { │ │ │ │ - // splice in new target parts │ │ │ │ - splits.unshift(j, 1); │ │ │ │ - Array.prototype.splice.apply(targetParts, splits); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!sourceSplit) { │ │ │ │ - // source line was not hit │ │ │ │ - if (sourceParts.length) { │ │ │ │ - // add line to existing multi │ │ │ │ - sourceParts[sourceParts.length - 1].addComponent( │ │ │ │ - sourceLine.clone() │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - // create a fresh multi │ │ │ │ - sourceParts = [ │ │ │ │ - new OpenLayers.Geometry.MultiLineString( │ │ │ │ - sourceLine.clone() │ │ │ │ - ) │ │ │ │ - ]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (sourceParts && sourceParts.length > 1) { │ │ │ │ - sourceSplit = true; │ │ │ │ - } else { │ │ │ │ - sourceParts = []; │ │ │ │ - } │ │ │ │ - if (targetParts && targetParts.length > 1) { │ │ │ │ - targetSplit = true; │ │ │ │ - } else { │ │ │ │ - targetParts = []; │ │ │ │ - } │ │ │ │ - if (sourceSplit || targetSplit) { │ │ │ │ - if (mutual) { │ │ │ │ - results = [sourceParts, targetParts]; │ │ │ │ - } else { │ │ │ │ - results = targetParts; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return results; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: splitWith │ │ │ │ - * Split this geometry (the target) with the given geometry (the source). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} A geometry used to split this │ │ │ │ - * geometry (the source). │ │ │ │ - * options - {Object} Properties of this object will be used to determine │ │ │ │ - * how the split is conducted. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * mutual - {Boolean} Split the source geometry in addition to the target │ │ │ │ - * geometry. Default is false. │ │ │ │ - * edge - {Boolean} Allow splitting when only edges intersect. Default is │ │ │ │ - * true. If false, a vertex on the source must be within the tolerance │ │ │ │ - * distance of the intersection to be considered a split. │ │ │ │ - * tolerance - {Number} If a non-null value is provided, intersections │ │ │ │ - * within the tolerance distance of an existing vertex on the source │ │ │ │ - * will be assumed to occur at the vertex. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} A list of geometries (of this same type as the target) that │ │ │ │ - * result from splitting the target with the source geometry. The │ │ │ │ - * source and target geometry will remain unmodified. If no split │ │ │ │ - * results, null will be returned. If mutual is true and a split │ │ │ │ - * results, return will be an array of two arrays - the first will be │ │ │ │ - * all geometries that result from splitting the source geometry and │ │ │ │ - * the second will be all geometries that result from splitting the │ │ │ │ - * target geometry. │ │ │ │ - */ │ │ │ │ - splitWith: function(geometry, options) { │ │ │ │ - var results = null; │ │ │ │ - var mutual = options && options.mutual; │ │ │ │ - var splits, targetLine, sourceLines, sourceSplit, targetSplit, sourceParts, targetParts; │ │ │ │ - if (geometry instanceof OpenLayers.Geometry.LineString) { │ │ │ │ - targetParts = []; │ │ │ │ - sourceParts = [geometry]; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - targetSplit = false; │ │ │ │ - targetLine = this.components[i]; │ │ │ │ - for (var j = 0; j < sourceParts.length; ++j) { │ │ │ │ - splits = sourceParts[j].split(targetLine, options); │ │ │ │ - if (splits) { │ │ │ │ - if (mutual) { │ │ │ │ - sourceLines = splits[0]; │ │ │ │ - if (sourceLines.length) { │ │ │ │ - // splice in new source parts │ │ │ │ - sourceLines.unshift(j, 1); │ │ │ │ - Array.prototype.splice.apply(sourceParts, sourceLines); │ │ │ │ - j += sourceLines.length - 2; │ │ │ │ - } │ │ │ │ - splits = splits[1]; │ │ │ │ - if (splits.length === 0) { │ │ │ │ - splits = [targetLine.clone()]; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - for (var k = 0, klen = splits.length; k < klen; ++k) { │ │ │ │ - if (k === 0 && targetParts.length) { │ │ │ │ - targetParts[targetParts.length - 1].addComponent( │ │ │ │ - splits[k] │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - targetParts.push( │ │ │ │ - new OpenLayers.Geometry.MultiLineString([ │ │ │ │ - splits[k] │ │ │ │ - ]) │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - targetSplit = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!targetSplit) { │ │ │ │ - // target component was not hit │ │ │ │ - if (targetParts.length) { │ │ │ │ - // add it to any existing multi-line │ │ │ │ - targetParts[targetParts.length - 1].addComponent( │ │ │ │ - targetLine.clone() │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - // or start with a fresh multi-line │ │ │ │ - targetParts = [ │ │ │ │ - new OpenLayers.Geometry.MultiLineString([ │ │ │ │ - targetLine.clone() │ │ │ │ - ]) │ │ │ │ - ]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - results = geometry.split(this); │ │ │ │ - } │ │ │ │ - if (sourceParts && sourceParts.length > 1) { │ │ │ │ - sourceSplit = true; │ │ │ │ - } else { │ │ │ │ - sourceParts = []; │ │ │ │ - } │ │ │ │ - if (targetParts && targetParts.length > 1) { │ │ │ │ - targetSplit = true; │ │ │ │ - } else { │ │ │ │ - targetParts = []; │ │ │ │ - } │ │ │ │ - if (sourceSplit || targetSplit) { │ │ │ │ - if (mutual) { │ │ │ │ - results = [sourceParts, targetParts]; │ │ │ │ - } else { │ │ │ │ - results = targetParts; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return results; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.MultiLineString" │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/LinearRing.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry.LinearRing │ │ │ │ - * │ │ │ │ - * A Linear Ring is a special LineString which is closed. It closes itself │ │ │ │ - * automatically on every addPoint/removePoint by adding a copy of the first │ │ │ │ - * point as the last point. │ │ │ │ - * │ │ │ │ - * Also, as it is the first in the line family to close itself, a getArea() │ │ │ │ - * function is defined to calculate the enclosed area of the linearRing │ │ │ │ - * │ │ │ │ - * Inherits: │ │ │ │ - * - <OpenLayers.Geometry.LineString> │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.LinearRing = OpenLayers.Class( │ │ │ │ - OpenLayers.Geometry.LineString, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null │ │ │ │ - * value means the component types are not restricted. │ │ │ │ - */ │ │ │ │ - componentTypes: ["OpenLayers.Geometry.Point"], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.LinearRing │ │ │ │ - * Linear rings are constructed with an array of points. This array │ │ │ │ - * can represent a closed or open ring. If the ring is open (the last │ │ │ │ - * point does not equal the first point), the constructor will close │ │ │ │ - * the ring. If the ring is already closed (the last point does equal │ │ │ │ - * the first point), it will be left closed. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * points - {Array(<OpenLayers.Geometry.Point>)} points │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: addComponent │ │ │ │ - * Adds a point to geometry components. If the point is to be added to │ │ │ │ - * the end of the components array and it is the same as the last point │ │ │ │ - * already in that array, the duplicate point is not added. This has │ │ │ │ - * the effect of closing the ring if it is not already closed, and │ │ │ │ - * doing the right thing if it is already closed. This behavior can │ │ │ │ - * be overridden by calling the method with a non-null index as the │ │ │ │ - * second argument. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * index - {Integer} Index into the array to insert the component │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Was the Point successfully added? │ │ │ │ - */ │ │ │ │ - addComponent: function(point, index) { │ │ │ │ - var added = false; │ │ │ │ - │ │ │ │ - //remove last point │ │ │ │ - var lastPoint = this.components.pop(); │ │ │ │ - │ │ │ │ - // given an index, add the point │ │ │ │ - // without an index only add non-duplicate points │ │ │ │ - if (index != null || !point.equals(lastPoint)) { │ │ │ │ - added = OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, │ │ │ │ - arguments); │ │ │ │ - } │ │ │ │ - │ │ │ │ - //append copy of first point │ │ │ │ - var firstPoint = this.components[0]; │ │ │ │ - OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, │ │ │ │ - [firstPoint]); │ │ │ │ - │ │ │ │ - return added; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: removeComponent │ │ │ │ - * Removes a point from geometry components. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The component was removed. │ │ │ │ - */ │ │ │ │ - removeComponent: function(point) { │ │ │ │ - var removed = this.components && (this.components.length > 3); │ │ │ │ - if (removed) { │ │ │ │ - //remove last point │ │ │ │ - this.components.pop(); │ │ │ │ - │ │ │ │ - //remove our point │ │ │ │ - OpenLayers.Geometry.Collection.prototype.removeComponent.apply(this, │ │ │ │ - arguments); │ │ │ │ - //append copy of first point │ │ │ │ - var firstPoint = this.components[0]; │ │ │ │ - OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, │ │ │ │ - [firstPoint]); │ │ │ │ - } │ │ │ │ - return removed; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: move │ │ │ │ - * Moves a geometry by the given displacement along positive x and y axes. │ │ │ │ - * This modifies the position of the geometry and clears the cached │ │ │ │ - * bounds. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * x - {Float} Distance to move geometry in positive x direction. │ │ │ │ - * y - {Float} Distance to move geometry in positive y direction. │ │ │ │ - */ │ │ │ │ - move: function(x, y) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len - 1; i++) { │ │ │ │ - this.components[i].move(x, y); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: rotate │ │ │ │ - * Rotate a geometry around some origin │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * angle - {Float} Rotation angle in degrees (measured counterclockwise │ │ │ │ - * from the positive x-axis) │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} Center point for the rotation │ │ │ │ - */ │ │ │ │ - rotate: function(angle, origin) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len - 1; ++i) { │ │ │ │ - this.components[i].rotate(angle, origin); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: resize │ │ │ │ - * Resize a geometry relative to some origin. Use this method to apply │ │ │ │ - * a uniform scaling to a geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * scale - {Float} Factor by which to scale the geometry. A scale of 2 │ │ │ │ - * doubles the size of the geometry in each dimension │ │ │ │ - * (lines, for example, will be twice as long, and polygons │ │ │ │ - * will have four times the area). │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} Point of origin for resizing │ │ │ │ - * ratio - {Float} Optional x:y ratio for resizing. Default ratio is 1. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} - The current geometry. │ │ │ │ - */ │ │ │ │ - resize: function(scale, origin, ratio) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len - 1; ++i) { │ │ │ │ - this.components[i].resize(scale, origin, ratio); │ │ │ │ - } │ │ │ │ - return this; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: transform │ │ │ │ - * Reproject the components geometry from source to dest. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * source - {<OpenLayers.Projection>} │ │ │ │ - * dest - {<OpenLayers.Projection>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} │ │ │ │ - */ │ │ │ │ - transform: function(source, dest) { │ │ │ │ - if (source && dest) { │ │ │ │ - for (var i = 0, len = this.components.length; i < len - 1; i++) { │ │ │ │ - var component = this.components[i]; │ │ │ │ - component.transform(source, dest); │ │ │ │ - } │ │ │ │ - this.bounds = null; │ │ │ │ - } │ │ │ │ - return this; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getCentroid │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry.Point>} The centroid of the collection │ │ │ │ - */ │ │ │ │ - getCentroid: function() { │ │ │ │ - if (this.components) { │ │ │ │ - var len = this.components.length; │ │ │ │ - if (len > 0 && len <= 2) { │ │ │ │ - return this.components[0].clone(); │ │ │ │ - } else if (len > 2) { │ │ │ │ - var sumX = 0.0; │ │ │ │ - var sumY = 0.0; │ │ │ │ - var x0 = this.components[0].x; │ │ │ │ - var y0 = this.components[0].y; │ │ │ │ - var area = -1 * this.getArea(); │ │ │ │ - if (area != 0) { │ │ │ │ - for (var i = 0; i < len - 1; i++) { │ │ │ │ - var b = this.components[i]; │ │ │ │ - var c = this.components[i + 1]; │ │ │ │ - sumX += (b.x + c.x - 2 * x0) * ((b.x - x0) * (c.y - y0) - (c.x - x0) * (b.y - y0)); │ │ │ │ - sumY += (b.y + c.y - 2 * y0) * ((b.x - x0) * (c.y - y0) - (c.x - x0) * (b.y - y0)); │ │ │ │ - } │ │ │ │ - var x = x0 + sumX / (6 * area); │ │ │ │ - var y = y0 + sumY / (6 * area); │ │ │ │ - } else { │ │ │ │ - for (var i = 0; i < len - 1; i++) { │ │ │ │ - sumX += this.components[i].x; │ │ │ │ - sumY += this.components[i].y; │ │ │ │ - } │ │ │ │ - var x = sumX / (len - 1); │ │ │ │ - var y = sumY / (len - 1); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.Point(x, y); │ │ │ │ - } else { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getArea │ │ │ │ - * Note - The area is positive if the ring is oriented CW, otherwise │ │ │ │ - * it will be negative. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Float} The signed area for a ring. │ │ │ │ - */ │ │ │ │ - getArea: function() { │ │ │ │ - var area = 0.0; │ │ │ │ - if (this.components && (this.components.length > 2)) { │ │ │ │ - var sum = 0.0; │ │ │ │ - for (var i = 0, len = this.components.length; i < len - 1; i++) { │ │ │ │ - var b = this.components[i]; │ │ │ │ - var c = this.components[i + 1]; │ │ │ │ - sum += (b.x + c.x) * (c.y - b.y); │ │ │ │ - } │ │ │ │ - area = -sum / 2.0; │ │ │ │ - } │ │ │ │ - return area; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getGeodesicArea │ │ │ │ - * Calculate the approximate area of the polygon were it projected onto │ │ │ │ - * the earth. Note that this area will be positive if ring is oriented │ │ │ │ - * clockwise, otherwise it will be negative. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ - * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ - * assumed. │ │ │ │ - * │ │ │ │ - * Reference: │ │ │ │ - * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for │ │ │ │ - * Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion │ │ │ │ - * Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {float} The approximate signed geodesic area of the polygon in square │ │ │ │ - * meters. │ │ │ │ - */ │ │ │ │ - getGeodesicArea: function(projection) { │ │ │ │ - var ring = this; // so we can work with a clone if needed │ │ │ │ - if (projection) { │ │ │ │ - var gg = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - if (!gg.equals(projection)) { │ │ │ │ - ring = this.clone().transform(projection, gg); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var area = 0.0; │ │ │ │ - var len = ring.components && ring.components.length; │ │ │ │ - if (len > 2) { │ │ │ │ - var p1, p2; │ │ │ │ - for (var i = 0; i < len - 1; i++) { │ │ │ │ - p1 = ring.components[i]; │ │ │ │ - p2 = ring.components[i + 1]; │ │ │ │ - area += OpenLayers.Util.rad(p2.x - p1.x) * │ │ │ │ - (2 + Math.sin(OpenLayers.Util.rad(p1.y)) + │ │ │ │ - Math.sin(OpenLayers.Util.rad(p2.y))); │ │ │ │ - } │ │ │ │ - area = area * 6378137.0 * 6378137.0 / 2.0; │ │ │ │ - } │ │ │ │ - return area; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: containsPoint │ │ │ │ - * Test if a point is inside a linear ring. For the case where a point │ │ │ │ - * is coincident with a linear ring edge, returns 1. Otherwise, │ │ │ │ - * returns boolean. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean | Number} The point is inside the linear ring. Returns 1 if │ │ │ │ - * the point is coincident with an edge. Returns boolean otherwise. │ │ │ │ - */ │ │ │ │ - containsPoint: function(point) { │ │ │ │ - var approx = OpenLayers.Number.limitSigDigs; │ │ │ │ - var digs = 14; │ │ │ │ - var px = approx(point.x, digs); │ │ │ │ - var py = approx(point.y, digs); │ │ │ │ - │ │ │ │ - function getX(y, x1, y1, x2, y2) { │ │ │ │ - return (y - y2) * ((x2 - x1) / (y2 - y1)) + x2; │ │ │ │ - } │ │ │ │ - var numSeg = this.components.length - 1; │ │ │ │ - var start, end, x1, y1, x2, y2, cx, cy; │ │ │ │ - var crosses = 0; │ │ │ │ - for (var i = 0; i < numSeg; ++i) { │ │ │ │ - start = this.components[i]; │ │ │ │ - x1 = approx(start.x, digs); │ │ │ │ - y1 = approx(start.y, digs); │ │ │ │ - end = this.components[i + 1]; │ │ │ │ - x2 = approx(end.x, digs); │ │ │ │ - y2 = approx(end.y, digs); │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * The following conditions enforce five edge-crossing rules: │ │ │ │ - * 1. points coincident with edges are considered contained; │ │ │ │ - * 2. an upward edge includes its starting endpoint, and │ │ │ │ - * excludes its final endpoint; │ │ │ │ - * 3. a downward edge excludes its starting endpoint, and │ │ │ │ - * includes its final endpoint; │ │ │ │ - * 4. horizontal edges are excluded; and │ │ │ │ - * 5. the edge-ray intersection point must be strictly right │ │ │ │ - * of the point P. │ │ │ │ - */ │ │ │ │ - if (y1 == y2) { │ │ │ │ - // horizontal edge │ │ │ │ - if (py == y1) { │ │ │ │ - // point on horizontal line │ │ │ │ - if (x1 <= x2 && (px >= x1 && px <= x2) || // right or vert │ │ │ │ - x1 >= x2 && (px <= x1 && px >= x2)) { // left or vert │ │ │ │ - // point on edge │ │ │ │ - crosses = -1; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // ignore other horizontal edges │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - cx = approx(getX(py, x1, y1, x2, y2), digs); │ │ │ │ - if (cx == px) { │ │ │ │ - // point on line │ │ │ │ - if (y1 < y2 && (py >= y1 && py <= y2) || // upward │ │ │ │ - y1 > y2 && (py <= y1 && py >= y2)) { // downward │ │ │ │ - // point on edge │ │ │ │ - crosses = -1; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (cx <= px) { │ │ │ │ - // no crossing to the right │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - if (x1 != x2 && (cx < Math.min(x1, x2) || cx > Math.max(x1, x2))) { │ │ │ │ - // no crossing │ │ │ │ - continue; │ │ │ │ - } │ │ │ │ - if (y1 < y2 && (py >= y1 && py < y2) || // upward │ │ │ │ - y1 > y2 && (py < y1 && py >= y2)) { // downward │ │ │ │ - ++crosses; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var contained = (crosses == -1) ? │ │ │ │ - // on edge │ │ │ │ - 1 : │ │ │ │ - // even (out) or odd (in) │ │ │ │ - !!(crosses & 1); │ │ │ │ - │ │ │ │ - return contained; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: intersects │ │ │ │ - * Determine if the input geometry intersects this one. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The input geometry intersects this one. │ │ │ │ - */ │ │ │ │ - intersects: function(geometry) { │ │ │ │ - var intersect = false; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - intersect = this.containsPoint(geometry); │ │ │ │ - } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") { │ │ │ │ - intersect = geometry.intersects(this); │ │ │ │ - } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ - intersect = OpenLayers.Geometry.LineString.prototype.intersects.apply( │ │ │ │ - this, [geometry] │ │ │ │ - ); │ │ │ │ - } else { │ │ │ │ - // check for component intersections │ │ │ │ - for (var i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ - intersect = geometry.components[i].intersects(this); │ │ │ │ - if (intersect) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return intersect; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getVertices │ │ │ │ - * Return a list of all points in this geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * nodes - {Boolean} For lines, only return vertices that are │ │ │ │ - * endpoints. If false, for lines, only vertices that are not │ │ │ │ - * endpoints will be returned. If not provided, all vertices will │ │ │ │ - * be returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} A list of all vertices in the geometry. │ │ │ │ - */ │ │ │ │ - getVertices: function(nodes) { │ │ │ │ - return (nodes === true) ? [] : this.components.slice(0, this.components.length - 1); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.LinearRing" │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Geometry/Polygon.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Geometry/Collection.js │ │ │ │ - * @requires OpenLayers/Geometry/LinearRing.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Geometry.Polygon │ │ │ │ - * Polygon is a collection of Geometry.LinearRings. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry.Collection> │ │ │ │ - * - <OpenLayers.Geometry> │ │ │ │ - */ │ │ │ │ -OpenLayers.Geometry.Polygon = OpenLayers.Class( │ │ │ │ - OpenLayers.Geometry.Collection, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null value means the │ │ │ │ - * component types are not restricted. │ │ │ │ - */ │ │ │ │ - componentTypes: ["OpenLayers.Geometry.LinearRing"], │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Geometry.Polygon │ │ │ │ - * Constructor for a Polygon geometry. │ │ │ │ - * The first ring (this.component[0])is the outer bounds of the polygon and │ │ │ │ - * all subsequent rings (this.component[1-n]) are internal holes. │ │ │ │ - * │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry.LinearRing>)} │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getArea │ │ │ │ - * Calculated by subtracting the areas of the internal holes from the │ │ │ │ - * area of the outer hole. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {float} The area of the geometry │ │ │ │ - */ │ │ │ │ - getArea: function() { │ │ │ │ - var area = 0.0; │ │ │ │ - if (this.components && (this.components.length > 0)) { │ │ │ │ - area += Math.abs(this.components[0].getArea()); │ │ │ │ - for (var i = 1, len = this.components.length; i < len; i++) { │ │ │ │ - area -= Math.abs(this.components[i].getArea()); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return area; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: getGeodesicArea │ │ │ │ - * Calculate the approximate area of the polygon were it projected onto │ │ │ │ - * the earth. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * projection - {<OpenLayers.Projection>} The spatial reference system │ │ │ │ - * for the geometry coordinates. If not provided, Geographic/WGS84 is │ │ │ │ - * assumed. │ │ │ │ - * │ │ │ │ - * Reference: │ │ │ │ - * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for │ │ │ │ - * Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion │ │ │ │ - * Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {float} The approximate geodesic area of the polygon in square meters. │ │ │ │ - */ │ │ │ │ - getGeodesicArea: function(projection) { │ │ │ │ - var area = 0.0; │ │ │ │ - if (this.components && (this.components.length > 0)) { │ │ │ │ - area += Math.abs(this.components[0].getGeodesicArea(projection)); │ │ │ │ - for (var i = 1, len = this.components.length; i < len; i++) { │ │ │ │ - area -= Math.abs(this.components[i].getGeodesicArea(projection)); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return area; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: containsPoint │ │ │ │ - * Test if a point is inside a polygon. Points on a polygon edge are │ │ │ │ - * considered inside. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean | Number} The point is inside the polygon. Returns 1 if the │ │ │ │ - * point is on an edge. Returns boolean otherwise. │ │ │ │ - */ │ │ │ │ - containsPoint: function(point) { │ │ │ │ - var numRings = this.components.length; │ │ │ │ - var contained = false; │ │ │ │ - if (numRings > 0) { │ │ │ │ - // check exterior ring - 1 means on edge, boolean otherwise │ │ │ │ - contained = this.components[0].containsPoint(point); │ │ │ │ - if (contained !== 1) { │ │ │ │ - if (contained && numRings > 1) { │ │ │ │ - // check interior rings │ │ │ │ - var hole; │ │ │ │ - for (var i = 1; i < numRings; ++i) { │ │ │ │ - hole = this.components[i].containsPoint(point); │ │ │ │ - if (hole) { │ │ │ │ - if (hole === 1) { │ │ │ │ - // on edge │ │ │ │ - contained = 1; │ │ │ │ - } else { │ │ │ │ - // in hole │ │ │ │ - contained = false; │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return contained; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: intersects │ │ │ │ - * Determine if the input geometry intersects this one. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} Any type of geometry. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The input geometry intersects this one. │ │ │ │ - */ │ │ │ │ - intersects: function(geometry) { │ │ │ │ - var intersect = false; │ │ │ │ - var i, len; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - intersect = this.containsPoint(geometry); │ │ │ │ - } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" || │ │ │ │ - geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ - // check if rings/linestrings intersect │ │ │ │ - for (i = 0, len = this.components.length; i < len; ++i) { │ │ │ │ - intersect = geometry.intersects(this.components[i]); │ │ │ │ - if (intersect) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!intersect) { │ │ │ │ - // check if this poly contains points of the ring/linestring │ │ │ │ - for (i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ - intersect = this.containsPoint(geometry.components[i]); │ │ │ │ - if (intersect) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - for (i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ - intersect = this.intersects(geometry.components[i]); │ │ │ │ - if (intersect) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // check case where this poly is wholly contained by another │ │ │ │ - if (!intersect && geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") { │ │ │ │ - // exterior ring points will be contained in the other geometry │ │ │ │ - var ring = this.components[0]; │ │ │ │ - for (i = 0, len = ring.components.length; i < len; ++i) { │ │ │ │ - intersect = geometry.containsPoint(ring.components[i]); │ │ │ │ - if (intersect) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivates a control and it's associated handler if any. The exact │ │ │ │ + * effect of this depends on the control itself. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the control was effectively deactivated or false │ │ │ │ + * if the control was already inactive. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.deactivate(); │ │ │ │ } │ │ │ │ - return intersect; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: distanceTo │ │ │ │ - * Calculate the closest distance between two geometries (on the x-y plane). │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} The target geometry. │ │ │ │ - * options - {Object} Optional properties for configuring the distance │ │ │ │ - * calculation. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * details - {Boolean} Return details from the distance calculation. │ │ │ │ - * Default is false. │ │ │ │ - * edge - {Boolean} Calculate the distance from this geometry to the │ │ │ │ - * nearest edge of the target geometry. Default is true. If true, │ │ │ │ - * calling distanceTo from a geometry that is wholly contained within │ │ │ │ - * the target will result in a non-zero distance. If false, whenever │ │ │ │ - * geometries intersect, calling distanceTo will return 0. If false, │ │ │ │ - * details cannot be returned. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number | Object} The distance between this geometry and the target. │ │ │ │ - * If details is true, the return will be an object with distance, │ │ │ │ - * x0, y0, x1, and y1 properties. The x0 and y0 properties represent │ │ │ │ - * the coordinates of the closest point on this geometry. The x1 and y1 │ │ │ │ - * properties represent the coordinates of the closest point on the │ │ │ │ - * target geometry. │ │ │ │ - */ │ │ │ │ - distanceTo: function(geometry, options) { │ │ │ │ - var edge = !(options && options.edge === false); │ │ │ │ - var result; │ │ │ │ - // this is the case where we might not be looking for distance to edge │ │ │ │ - if (!edge && this.intersects(geometry)) { │ │ │ │ - result = 0; │ │ │ │ - } else { │ │ │ │ - result = OpenLayers.Geometry.Collection.prototype.distanceTo.apply( │ │ │ │ - this, [geometry, options] │ │ │ │ + this.active = false; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, │ │ │ │ + this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ ); │ │ │ │ } │ │ │ │ - return result; │ │ │ │ - }, │ │ │ │ + this.events.triggerEvent("deactivate"); │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.Polygon" │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control" │ │ │ │ +}); │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: createRegularPolygon │ │ │ │ - * Create a regular polygon around a radius. Useful for creating circles │ │ │ │ - * and the like. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * origin - {<OpenLayers.Geometry.Point>} center of polygon. │ │ │ │ - * radius - {Float} distance to vertex, in map units. │ │ │ │ - * sides - {Integer} Number of sides. 20 approximates a circle. │ │ │ │ - * rotation - {Float} original angle of rotation, in degrees. │ │ │ │ + * Constant: OpenLayers.Control.TYPE_BUTTON │ │ │ │ */ │ │ │ │ -OpenLayers.Geometry.Polygon.createRegularPolygon = function(origin, radius, sides, rotation) { │ │ │ │ - var angle = Math.PI * ((1 / sides) - (1 / 2)); │ │ │ │ - if (rotation) { │ │ │ │ - angle += (rotation / 180) * Math.PI; │ │ │ │ - } │ │ │ │ - var rotatedAngle, x, y; │ │ │ │ - var points = []; │ │ │ │ - for (var i = 0; i < sides; ++i) { │ │ │ │ - rotatedAngle = angle + (i * 2 * Math.PI / sides); │ │ │ │ - x = origin.x + (radius * Math.cos(rotatedAngle)); │ │ │ │ - y = origin.y + (radius * Math.sin(rotatedAngle)); │ │ │ │ - points.push(new OpenLayers.Geometry.Point(x, y)); │ │ │ │ - } │ │ │ │ - var ring = new OpenLayers.Geometry.LinearRing(points); │ │ │ │ - return new OpenLayers.Geometry.Polygon([ring]); │ │ │ │ -}; │ │ │ │ +OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Control.TYPE_TOGGLE │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Control.TYPE_TOOL │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Geometry/MultiPolygon.js │ │ │ │ + OpenLayers/Control/Attribution.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Geometry/Collection.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Geometry.MultiPolygon │ │ │ │ - * MultiPolygon is a geometry with multiple <OpenLayers.Geometry.Polygon> │ │ │ │ - * components. Create a new instance with the <OpenLayers.Geometry.MultiPolygon> │ │ │ │ - * constructor. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.Attribution │ │ │ │ + * The attribution control adds attribution from layers to the map display. │ │ │ │ + * It uses 'attribution' property of each layer. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Geometry.Collection> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Geometry.MultiPolygon = OpenLayers.Class( │ │ │ │ - OpenLayers.Geometry.Collection, { │ │ │ │ +OpenLayers.Control.Attribution = │ │ │ │ + OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: componentTypes │ │ │ │ - * {Array(String)} An array of class names representing the types of │ │ │ │ - * components that the collection can include. A null value means the │ │ │ │ - * component types are not restricted. │ │ │ │ + * APIProperty: separator │ │ │ │ + * {String} String used to separate layers. │ │ │ │ */ │ │ │ │ - componentTypes: ["OpenLayers.Geometry.Polygon"], │ │ │ │ + separator: ", ", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Geometry.MultiPolygon │ │ │ │ - * Create a new MultiPolygon geometry │ │ │ │ - * │ │ │ │ + * APIProperty: template │ │ │ │ + * {String} Template for the attribution. This has to include the substring │ │ │ │ + * "${layers}", which will be replaced by the layer specific │ │ │ │ + * attributions, separated by <separator>. The default is "${layers}". │ │ │ │ + */ │ │ │ │ + template: "${layers}", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.Attribution │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * components - {Array(<OpenLayers.Geometry.Polygon>)} An array of polygons │ │ │ │ - * used to generate the MultiPolygon │ │ │ │ - * │ │ │ │ + * options - {Object} Options for control. │ │ │ │ */ │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.MultiPolygon" │ │ │ │ + /** │ │ │ │ + * 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, len = this.map.layers.length; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (layer.attribution && layer.getVisibility()) { │ │ │ │ + // add attribution only if attribution text is unique │ │ │ │ + if (OpenLayers.Util.indexOf( │ │ │ │ + attributions, layer.attribution) === -1) { │ │ │ │ + attributions.push(layer.attribution); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ + layers: attributions.join(this.separator) │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Format/GeoJSON.js │ │ │ │ + OpenLayers/Handler.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Format/JSON.js │ │ │ │ - * @requires OpenLayers/Feature/Vector.js │ │ │ │ - * @requires OpenLayers/Geometry/Point.js │ │ │ │ - * @requires OpenLayers/Geometry/MultiPoint.js │ │ │ │ - * @requires OpenLayers/Geometry/LineString.js │ │ │ │ - * @requires OpenLayers/Geometry/MultiLineString.js │ │ │ │ - * @requires OpenLayers/Geometry/Polygon.js │ │ │ │ - * @requires OpenLayers/Geometry/MultiPolygon.js │ │ │ │ - * @requires OpenLayers/Console.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Format.GeoJSON │ │ │ │ - * Read and write GeoJSON. Create a new parser with the │ │ │ │ - * <OpenLayers.Format.GeoJSON> constructor. │ │ │ │ + * Class: OpenLayers.Handler │ │ │ │ + * Base class to construct a higher-level handler for event sequences. All │ │ │ │ + * handlers have activate and deactivate methods. In addition, they have │ │ │ │ + * methods named like browser events. When a handler is activated, any │ │ │ │ + * additional methods named like a browser event is registered as a │ │ │ │ + * listener for the corresponding event. When a handler is deactivated, │ │ │ │ + * those same methods are unregistered as event listeners. │ │ │ │ * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Format.JSON> │ │ │ │ + * Handlers also typically have a callbacks object with keys named like │ │ │ │ + * the abstracted events or event sequences that they are in charge of │ │ │ │ + * handling. The controls that wrap handlers define the methods that │ │ │ │ + * correspond to these abstract events - so instead of listening for │ │ │ │ + * individual browser events, they only listen for the abstract events │ │ │ │ + * defined by the handler. │ │ │ │ + * │ │ │ │ + * Handlers are created by controls, which ultimately have the responsibility │ │ │ │ + * of making changes to the the state of the application. Handlers │ │ │ │ + * themselves may make temporary changes, but in general are expected to │ │ │ │ + * return the application in the same state that they found it. │ │ │ │ */ │ │ │ │ -OpenLayers.Format.GeoJSON = OpenLayers.Class(OpenLayers.Format.JSON, { │ │ │ │ +OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: ignoreExtraDims │ │ │ │ - * {Boolean} Ignore dimensions higher than 2 when reading geometry │ │ │ │ - * coordinates. │ │ │ │ + * Property: id │ │ │ │ + * {String} │ │ │ │ */ │ │ │ │ - ignoreExtraDims: false, │ │ │ │ + id: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Format.GeoJSON │ │ │ │ - * Create a new parser for GeoJSON. │ │ │ │ + * APIProperty: control │ │ │ │ + * {<OpenLayers.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. │ │ │ │ + */ │ │ │ │ + control: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: map │ │ │ │ + * {<OpenLayers.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 │ │ │ │ + * <checkModifiers>. If the keyMask matches the combination of keys │ │ │ │ + * down on an event, checkModifiers returns true. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be set on │ │ │ │ - * this instance. │ │ │ │ + * 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, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Deserialize a GeoJSON string. │ │ │ │ + * 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, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: touch │ │ │ │ + * {Boolean} Indicates the support of touch events. When touch events are │ │ │ │ + * started touch will be true and all mouse related listeners will do │ │ │ │ + * nothing. │ │ │ │ + */ │ │ │ │ + touch: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler │ │ │ │ + * Construct a handler. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * json - {String} A GeoJSON string │ │ │ │ - * type - {String} Optional string that determines the structure of │ │ │ │ - * the output. Supported values are "Geometry", "Feature", and │ │ │ │ - * "FeatureCollection". If absent or null, a default of │ │ │ │ - * "FeatureCollection" is assumed. │ │ │ │ - * 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} The return depends on the value of the type argument. If type │ │ │ │ - * is "FeatureCollection" (the default), the return will be an array │ │ │ │ - * of <OpenLayers.Feature.Vector>. If type is "Geometry", the input json │ │ │ │ - * must represent a single geometry, and the return will be an │ │ │ │ - * <OpenLayers.Geometry>. If type is "Feature", the input json must │ │ │ │ - * represent a single feature, and the return will be an │ │ │ │ - * <OpenLayers.Feature.Vector>. │ │ │ │ + * control - {<OpenLayers.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. If a map property │ │ │ │ + * is present in the options argument it will be used instead. │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - read: function(json, type, filter) { │ │ │ │ - type = (type) ? type : "FeatureCollection"; │ │ │ │ - var results = null; │ │ │ │ - var obj = null; │ │ │ │ - if (typeof json == "string") { │ │ │ │ - obj = OpenLayers.Format.JSON.prototype.read.apply(this, │ │ │ │ - [json, filter]); │ │ │ │ - } else { │ │ │ │ - obj = json; │ │ │ │ - } │ │ │ │ - if (!obj) { │ │ │ │ - OpenLayers.Console.error("Bad JSON: " + json); │ │ │ │ - } else if (typeof(obj.type) != "string") { │ │ │ │ - OpenLayers.Console.error("Bad GeoJSON - no type: " + json); │ │ │ │ - } else if (this.isValidType(obj, type)) { │ │ │ │ - switch (type) { │ │ │ │ - case "Geometry": │ │ │ │ - try { │ │ │ │ - results = this.parseGeometry(obj); │ │ │ │ - } catch (err) { │ │ │ │ - OpenLayers.Console.error(err); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "Feature": │ │ │ │ - try { │ │ │ │ - results = this.parseFeature(obj); │ │ │ │ - results.type = "Feature"; │ │ │ │ - } catch (err) { │ │ │ │ - OpenLayers.Console.error(err); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "FeatureCollection": │ │ │ │ - // for type FeatureCollection, we allow input to be any type │ │ │ │ - results = []; │ │ │ │ - switch (obj.type) { │ │ │ │ - case "Feature": │ │ │ │ - try { │ │ │ │ - results.push(this.parseFeature(obj)); │ │ │ │ - } catch (err) { │ │ │ │ - results = null; │ │ │ │ - OpenLayers.Console.error(err); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "FeatureCollection": │ │ │ │ - for (var i = 0, len = obj.features.length; i < len; ++i) { │ │ │ │ - try { │ │ │ │ - results.push(this.parseFeature(obj.features[i])); │ │ │ │ - } catch (err) { │ │ │ │ - results = null; │ │ │ │ - OpenLayers.Console.error(err); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - try { │ │ │ │ - var geom = this.parseGeometry(obj); │ │ │ │ - results.push(new OpenLayers.Feature.Vector(geom)); │ │ │ │ - } catch (err) { │ │ │ │ - results = null; │ │ │ │ - OpenLayers.Console.error(err); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - } │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.control = control; │ │ │ │ + this.callbacks = callbacks; │ │ │ │ + │ │ │ │ + var map = this.map || control.map; │ │ │ │ + if (map) { │ │ │ │ + this.setMap(map); │ │ │ │ } │ │ │ │ - return results; │ │ │ │ + │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: isValidType │ │ │ │ - * Check if a GeoJSON object is a valid representative of the given type. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The object is valid GeoJSON object of the given type. │ │ │ │ + * Method: setMap │ │ │ │ */ │ │ │ │ - isValidType: function(obj, type) { │ │ │ │ - var valid = false; │ │ │ │ - switch (type) { │ │ │ │ - case "Geometry": │ │ │ │ - if (OpenLayers.Util.indexOf( │ │ │ │ - ["Point", "MultiPoint", "LineString", "MultiLineString", │ │ │ │ - "Polygon", "MultiPolygon", "Box", "GeometryCollection" │ │ │ │ - ], │ │ │ │ - obj.type) == -1) { │ │ │ │ - // unsupported geometry type │ │ │ │ - OpenLayers.Console.error("Unsupported geometry type: " + │ │ │ │ - obj.type); │ │ │ │ - } else { │ │ │ │ - valid = true; │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "FeatureCollection": │ │ │ │ - // allow for any type to be converted to a feature collection │ │ │ │ - valid = true; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - // for Feature types must match │ │ │ │ - if (obj.type == type) { │ │ │ │ - valid = true; │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.error("Cannot convert types from " + │ │ │ │ - obj.type + " to " + type); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return valid; │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeature │ │ │ │ - * Convert a feature object from GeoJSON into an │ │ │ │ - * <OpenLayers.Feature.Vector>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} An object created from a GeoJSON object │ │ │ │ + * Method: checkModifiers │ │ │ │ + * Check the keyMask on the handler. If no <keyMask> is set, this always │ │ │ │ + * returns true. If a <keyMask> is set and it matches the combination │ │ │ │ + * of keys down on an event, this returns true. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Feature.Vector>} A feature. │ │ │ │ + * {Boolean} The keyMask matches the keys down on an event. │ │ │ │ */ │ │ │ │ - parseFeature: function(obj) { │ │ │ │ - var feature, geometry, attributes, bbox; │ │ │ │ - attributes = (obj.properties) ? obj.properties : {}; │ │ │ │ - bbox = (obj.geometry && obj.geometry.bbox) || obj.bbox; │ │ │ │ - try { │ │ │ │ - geometry = this.parseGeometry(obj.geometry); │ │ │ │ - } catch (err) { │ │ │ │ - // deal with bad geometries │ │ │ │ - throw err; │ │ │ │ - } │ │ │ │ - feature = new OpenLayers.Feature.Vector(geometry, attributes); │ │ │ │ - if (bbox) { │ │ │ │ - feature.bounds = OpenLayers.Bounds.fromArray(bbox); │ │ │ │ - } │ │ │ │ - if (obj.id) { │ │ │ │ - feature.fid = obj.id; │ │ │ │ + checkModifiers: function(evt) { │ │ │ │ + if (this.keyMask == null) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ - return feature; │ │ │ │ + /* 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) | │ │ │ │ + (evt.metaKey ? OpenLayers.Handler.MOD_META : 0); │ │ │ │ + │ │ │ │ + /* if it differs from the handler object's key mask, │ │ │ │ + bail out of the event handler */ │ │ │ │ + return (keyModifiers == this.keyMask); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseGeometry │ │ │ │ - * Convert a geometry object from GeoJSON into an <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} An object created from a GeoJSON object │ │ │ │ - * │ │ │ │ + * APIMethod: activate │ │ │ │ + * Turn on the handler. Returns false if the handler was already active. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ + * {Boolean} The handler was activated. │ │ │ │ */ │ │ │ │ - parseGeometry: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - return null; │ │ │ │ + activate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - var geometry, collection = false; │ │ │ │ - if (obj.type == "GeometryCollection") { │ │ │ │ - if (!(OpenLayers.Util.isArray(obj.geometries))) { │ │ │ │ - throw "GeometryCollection must have geometries array: " + obj; │ │ │ │ - } │ │ │ │ - var numGeom = obj.geometries.length; │ │ │ │ - var components = new Array(numGeom); │ │ │ │ - for (var i = 0; i < numGeom; ++i) { │ │ │ │ - components[i] = this.parseGeometry.apply( │ │ │ │ - this, [obj.geometries[i]] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - geometry = new OpenLayers.Geometry.Collection(components); │ │ │ │ - collection = true; │ │ │ │ - } else { │ │ │ │ - if (!(OpenLayers.Util.isArray(obj.coordinates))) { │ │ │ │ - throw "Geometry must have coordinates array: " + obj; │ │ │ │ - } │ │ │ │ - if (!this.parseCoords[obj.type.toLowerCase()]) { │ │ │ │ - throw "Unsupported geometry type: " + obj.type; │ │ │ │ - } │ │ │ │ - try { │ │ │ │ - geometry = this.parseCoords[obj.type.toLowerCase()].apply( │ │ │ │ - this, [obj.coordinates] │ │ │ │ - ); │ │ │ │ - } catch (err) { │ │ │ │ - // deal with bad coordinates │ │ │ │ - throw err; │ │ │ │ + // register for event handlers defined on this class. │ │ │ │ + var events = OpenLayers.Events.prototype.BROWSER_EVENTS; │ │ │ │ + for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.register(events[i], this[events[i]]); │ │ │ │ } │ │ │ │ } │ │ │ │ - // We don't reproject collections because the children are reprojected │ │ │ │ - // for us when they are created. │ │ │ │ - if (this.internalProjection && this.externalProjection && !collection) { │ │ │ │ - geometry.transform(this.externalProjection, │ │ │ │ - this.internalProjection); │ │ │ │ - } │ │ │ │ - return geometry; │ │ │ │ + this.active = true; │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: parseCoords │ │ │ │ - * Object with properties corresponding to the GeoJSON geometry types. │ │ │ │ - * Property values are functions that do the actual parsing. │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Turn off the handler. Returns false if the handler was already inactive. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was deactivated. │ │ │ │ */ │ │ │ │ - parseCoords: { │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.point │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "point": function(array) { │ │ │ │ - if (this.ignoreExtraDims == false && │ │ │ │ - array.length != 2) { │ │ │ │ - throw "Only 2D points are supported: " + array; │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.Point(array[0], array[1]); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.multipoint │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "multipoint": function(array) { │ │ │ │ - var points = []; │ │ │ │ - var p = null; │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - try { │ │ │ │ - p = this.parseCoords["point"].apply(this, [array[i]]); │ │ │ │ - } catch (err) { │ │ │ │ - throw err; │ │ │ │ - } │ │ │ │ - points.push(p); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.MultiPoint(points); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.linestring │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "linestring": function(array) { │ │ │ │ - var points = []; │ │ │ │ - var p = null; │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - try { │ │ │ │ - p = this.parseCoords["point"].apply(this, [array[i]]); │ │ │ │ - } catch (err) { │ │ │ │ - throw err; │ │ │ │ - } │ │ │ │ - points.push(p); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.LineString(points); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.multilinestring │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "multilinestring": function(array) { │ │ │ │ - var lines = []; │ │ │ │ - var l = null; │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - try { │ │ │ │ - l = this.parseCoords["linestring"].apply(this, [array[i]]); │ │ │ │ - } catch (err) { │ │ │ │ - throw err; │ │ │ │ - } │ │ │ │ - lines.push(l); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.MultiLineString(lines); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.polygon │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "polygon": function(array) { │ │ │ │ - var rings = []; │ │ │ │ - var r, l; │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - try { │ │ │ │ - l = this.parseCoords["linestring"].apply(this, [array[i]]); │ │ │ │ - } catch (err) { │ │ │ │ - throw err; │ │ │ │ - } │ │ │ │ - r = new OpenLayers.Geometry.LinearRing(l.components); │ │ │ │ - rings.push(r); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.Polygon(rings); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.multipolygon │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "multipolygon": function(array) { │ │ │ │ - var polys = []; │ │ │ │ - var p = null; │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - try { │ │ │ │ - p = this.parseCoords["polygon"].apply(this, [array[i]]); │ │ │ │ - } catch (err) { │ │ │ │ - throw err; │ │ │ │ - } │ │ │ │ - polys.push(p); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Geometry.MultiPolygon(polys); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: parseCoords.box │ │ │ │ - * Convert a coordinate array from GeoJSON into an │ │ │ │ - * <OpenLayers.Geometry>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * array - {Object} The coordinates array from the GeoJSON fragment. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Geometry>} A geometry. │ │ │ │ - */ │ │ │ │ - "box": function(array) { │ │ │ │ - if (array.length != 2) { │ │ │ │ - throw "GeoJSON box coordinates must have 2 elements"; │ │ │ │ + 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, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.unregister(events[i], this[events[i]]); │ │ │ │ } │ │ │ │ - return new OpenLayers.Geometry.Polygon([ │ │ │ │ - new OpenLayers.Geometry.LinearRing([ │ │ │ │ - new OpenLayers.Geometry.Point(array[0][0], array[0][1]), │ │ │ │ - new OpenLayers.Geometry.Point(array[1][0], array[0][1]), │ │ │ │ - new OpenLayers.Geometry.Point(array[1][0], array[1][1]), │ │ │ │ - new OpenLayers.Geometry.Point(array[0][0], array[1][1]), │ │ │ │ - new OpenLayers.Geometry.Point(array[0][0], array[0][1]) │ │ │ │ - ]) │ │ │ │ - ]); │ │ │ │ } │ │ │ │ - │ │ │ │ + this.touch = false; │ │ │ │ + this.active = false; │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: write │ │ │ │ - * Serialize a feature, geometry, array of features into a GeoJSON string. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} An <OpenLayers.Feature.Vector>, <OpenLayers.Geometry>, │ │ │ │ - * or an array of features. │ │ │ │ - * pretty - {Boolean} Structure the output with newlines and indentation. │ │ │ │ - * Default is false. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The GeoJSON string representation of the input geometry, │ │ │ │ - * features, or array of features. │ │ │ │ + * Method: startTouch │ │ │ │ + * Start touch events, this method must be called by subclasses in │ │ │ │ + * "touchstart" method. When touch events are started <touch> will be │ │ │ │ + * true and all mouse related listeners will do nothing. │ │ │ │ */ │ │ │ │ - write: function(obj, pretty) { │ │ │ │ - var geojson = { │ │ │ │ - "type": null │ │ │ │ - }; │ │ │ │ - if (OpenLayers.Util.isArray(obj)) { │ │ │ │ - geojson.type = "FeatureCollection"; │ │ │ │ - var numFeatures = obj.length; │ │ │ │ - geojson.features = new Array(numFeatures); │ │ │ │ - for (var i = 0; i < numFeatures; ++i) { │ │ │ │ - var element = obj[i]; │ │ │ │ - if (!element instanceof OpenLayers.Feature.Vector) { │ │ │ │ - var msg = "FeatureCollection only supports collections " + │ │ │ │ - "of features: " + element; │ │ │ │ - throw msg; │ │ │ │ + startTouch: function() { │ │ │ │ + if (!this.touch) { │ │ │ │ + this.touch = true; │ │ │ │ + var events = [ │ │ │ │ + "mousedown", "mouseup", "mousemove", "click", "dblclick", │ │ │ │ + "mouseout" │ │ │ │ + ]; │ │ │ │ + for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.unregister(events[i], this[events[i]]); │ │ │ │ } │ │ │ │ - geojson.features[i] = this.extract.feature.apply( │ │ │ │ - this, [element] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - } else if (obj.CLASS_NAME.indexOf("OpenLayers.Geometry") == 0) { │ │ │ │ - geojson = this.extract.geometry.apply(this, [obj]); │ │ │ │ - } else if (obj instanceof OpenLayers.Feature.Vector) { │ │ │ │ - geojson = this.extract.feature.apply(this, [obj]); │ │ │ │ - if (obj.layer && obj.layer.projection) { │ │ │ │ - geojson.crs = this.createCRSObject(obj); │ │ │ │ } │ │ │ │ } │ │ │ │ - return OpenLayers.Format.JSON.prototype.write.apply(this, │ │ │ │ - [geojson, pretty]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createCRSObject │ │ │ │ - * Create the CRS object for an object. │ │ │ │ + * Method: callback │ │ │ │ + * Trigger the control's named callback with the given arguments │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * object - {<OpenLayers.Feature.Vector>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object which can be assigned to the crs property │ │ │ │ - * of a GeoJSON object. │ │ │ │ + * 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). │ │ │ │ */ │ │ │ │ - createCRSObject: function(object) { │ │ │ │ - var proj = object.layer.projection.toString(); │ │ │ │ - var crs = {}; │ │ │ │ - if (proj.match(/epsg:/i)) { │ │ │ │ - var code = parseInt(proj.substring(proj.indexOf(":") + 1)); │ │ │ │ - if (code == 4326) { │ │ │ │ - crs = { │ │ │ │ - "type": "name", │ │ │ │ - "properties": { │ │ │ │ - "name": "urn:ogc:def:crs:OGC:1.3:CRS84" │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - crs = { │ │ │ │ - "type": "name", │ │ │ │ - "properties": { │ │ │ │ - "name": "EPSG:" + code │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + callback: function(name, args) { │ │ │ │ + if (name && this.callbacks[name]) { │ │ │ │ + this.callbacks[name].apply(this.control, args); │ │ │ │ } │ │ │ │ - return crs; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: extract │ │ │ │ - * Object with properties corresponding to the GeoJSON types. │ │ │ │ - * Property values are functions that do the actual value extraction. │ │ │ │ + * Method: register │ │ │ │ + * register an event on the map │ │ │ │ */ │ │ │ │ - extract: { │ │ │ │ - /** │ │ │ │ - * Method: extract.feature │ │ │ │ - * Return a partial GeoJSON object representing a single feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object representing the point. │ │ │ │ - */ │ │ │ │ - 'feature': function(feature) { │ │ │ │ - var geom = this.extract.geometry.apply(this, [feature.geometry]); │ │ │ │ - var json = { │ │ │ │ - "type": "Feature", │ │ │ │ - "properties": feature.attributes, │ │ │ │ - "geometry": geom │ │ │ │ - }; │ │ │ │ - if (feature.fid != null) { │ │ │ │ - json.id = feature.fid; │ │ │ │ - } │ │ │ │ - return json; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: extract.geometry │ │ │ │ - * Return a GeoJSON object representing a single geometry. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * geometry - {<OpenLayers.Geometry>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} An object representing the geometry. │ │ │ │ - */ │ │ │ │ - 'geometry': function(geometry) { │ │ │ │ - if (geometry == null) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - geometry.transform(this.internalProjection, │ │ │ │ - this.externalProjection); │ │ │ │ - } │ │ │ │ - var geometryType = geometry.CLASS_NAME.split('.')[2]; │ │ │ │ - var data = this.extract[geometryType.toLowerCase()].apply(this, [geometry]); │ │ │ │ - var json; │ │ │ │ - if (geometryType == "Collection") { │ │ │ │ - json = { │ │ │ │ - "type": "GeometryCollection", │ │ │ │ - "geometries": data │ │ │ │ - }; │ │ │ │ - } else { │ │ │ │ - json = { │ │ │ │ - "type": geometryType, │ │ │ │ - "coordinates": data │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return json; │ │ │ │ - }, │ │ │ │ + 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: extract.point │ │ │ │ - * Return an array of coordinates from a point. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * point - {<OpenLayers.Geometry.Point>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of coordinates representing the point. │ │ │ │ - */ │ │ │ │ - 'point': function(point) { │ │ │ │ - return [point.x, point.y]; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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: extract.multipoint │ │ │ │ - * Return an array of point coordinates from a multipoint. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * multipoint - {<OpenLayers.Geometry.MultiPoint>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of point coordinate arrays representing │ │ │ │ - * the multipoint. │ │ │ │ - */ │ │ │ │ - 'multipoint': function(multipoint) { │ │ │ │ - var array = []; │ │ │ │ - for (var i = 0, len = multipoint.components.length; i < len; ++i) { │ │ │ │ - array.push(this.extract.point.apply(this, [multipoint.components[i]])); │ │ │ │ - } │ │ │ │ - return array; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * 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, ctrl, │ │ │ │ + * and meta 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 || handler.evt.metaKey(end). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The browser event. │ │ │ │ + */ │ │ │ │ + setEvent: function(evt) { │ │ │ │ + this.evt = evt; │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extract.linestring │ │ │ │ - * Return an array of coordinate arrays from a linestring. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * linestring - {<OpenLayers.Geometry.LineString>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of coordinate arrays representing │ │ │ │ - * the linestring. │ │ │ │ - */ │ │ │ │ - 'linestring': function(linestring) { │ │ │ │ - var array = []; │ │ │ │ - for (var i = 0, len = linestring.components.length; i < len; ++i) { │ │ │ │ - array.push(this.extract.point.apply(this, [linestring.components[i]])); │ │ │ │ - } │ │ │ │ - return array; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Deconstruct the handler. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + // unregister event listeners │ │ │ │ + this.deactivate(); │ │ │ │ + // eliminate circular references │ │ │ │ + this.control = this.map = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extract.multilinestring │ │ │ │ - * Return an array of linestring arrays from a linestring. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * multilinestring - {<OpenLayers.Geometry.MultiLineString>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of linestring arrays representing │ │ │ │ - * the multilinestring. │ │ │ │ - */ │ │ │ │ - 'multilinestring': function(multilinestring) { │ │ │ │ - var array = []; │ │ │ │ - for (var i = 0, len = multilinestring.components.length; i < len; ++i) { │ │ │ │ - array.push(this.extract.linestring.apply(this, [multilinestring.components[i]])); │ │ │ │ - } │ │ │ │ - return array; │ │ │ │ - }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler" │ │ │ │ +}); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extract.polygon │ │ │ │ - * Return an array of linear ring arrays from a polygon. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * polygon - {<OpenLayers.Geometry.Polygon>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of linear ring arrays representing the polygon. │ │ │ │ - */ │ │ │ │ - 'polygon': function(polygon) { │ │ │ │ - var array = []; │ │ │ │ - for (var i = 0, len = polygon.components.length; i < len; ++i) { │ │ │ │ - array.push(this.extract.linestring.apply(this, [polygon.components[i]])); │ │ │ │ - } │ │ │ │ - return array; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Handler.MOD_NONE │ │ │ │ + * If set as the <keyMask>, <checkModifiers> returns false if any key is down. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MOD_NONE = 0; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extract.multipolygon │ │ │ │ - * Return an array of polygon arrays from a multipolygon. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * multipolygon - {<OpenLayers.Geometry.MultiPolygon>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of polygon arrays representing │ │ │ │ - * the multipolygon │ │ │ │ - */ │ │ │ │ - 'multipolygon': function(multipolygon) { │ │ │ │ - var array = []; │ │ │ │ - for (var i = 0, len = multipolygon.components.length; i < len; ++i) { │ │ │ │ - array.push(this.extract.polygon.apply(this, [multipolygon.components[i]])); │ │ │ │ - } │ │ │ │ - return array; │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Handler.MOD_SHIFT │ │ │ │ + * If set as the <keyMask>, <checkModifiers> returns false if Shift is down. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MOD_SHIFT = 1; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: extract.collection │ │ │ │ - * Return an array of geometries from a geometry collection. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * collection - {<OpenLayers.Geometry.Collection>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array} An array of geometry objects representing the geometry │ │ │ │ - * collection. │ │ │ │ - */ │ │ │ │ - 'collection': function(collection) { │ │ │ │ - var len = collection.components.length; │ │ │ │ - var array = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - array[i] = this.extract.geometry.apply( │ │ │ │ - this, [collection.components[i]] │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - return array; │ │ │ │ - } │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Handler.MOD_CTRL │ │ │ │ + * If set as the <keyMask>, <checkModifiers> returns false if Ctrl is down. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MOD_CTRL = 2; │ │ │ │ │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Handler.MOD_ALT │ │ │ │ + * If set as the <keyMask>, <checkModifiers> returns false if Alt is down. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MOD_ALT = 4; │ │ │ │ │ │ │ │ - }, │ │ │ │ +/** │ │ │ │ + * Constant: OpenLayers.Handler.MOD_META │ │ │ │ + * If set as the <keyMask>, <checkModifiers> returns false if Cmd is down. │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MOD_META = 8; │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Format.GeoJSON" │ │ │ │ │ │ │ │ -}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol.js │ │ │ │ + OpenLayers/Handler/Drag.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol │ │ │ │ - * Abstract vector layer protocol class. Not to be instantiated directly. Use │ │ │ │ - * one of the protocol subclasses instead. │ │ │ │ + * Class: OpenLayers.Handler.Drag │ │ │ │ + * The drag handler is used to deal with sequences of browser events related │ │ │ │ + * to dragging. The handler is used by controls that want to know when │ │ │ │ + * a drag sequence begins, when a drag is happening, and when it has │ │ │ │ + * finished. │ │ │ │ + * │ │ │ │ + * Controls that use the drag handler typically construct it with callbacks │ │ │ │ + * for 'down', 'move', and 'done'. Callbacks for these keys are called │ │ │ │ + * when the drag begins, with each move, and when the drag is done. In │ │ │ │ + * addition, controls can have callbacks keyed to 'up' and 'out' if they │ │ │ │ + * care to differentiate between the types of events that correspond with │ │ │ │ + * the end of a drag sequence. If no drag actually occurs (no mouse move) │ │ │ │ + * the 'down' and 'up' callbacks will be called, but not the 'done' │ │ │ │ + * callback. │ │ │ │ + * │ │ │ │ + * Create a new drag handler with the <OpenLayers.Handler.Drag> constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol = OpenLayers.Class({ │ │ │ │ +OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: started │ │ │ │ + * {Boolean} When a mousedown or touchstart event is received, we want to │ │ │ │ + * record it, but not set 'dragging' until the mouse moves after starting. │ │ │ │ + */ │ │ │ │ + started: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: format │ │ │ │ - * {<OpenLayers.Format>} The format used by this protocol. │ │ │ │ + * Property: stopDown │ │ │ │ + * {Boolean} Stop propagation of mousedown events from getting to listeners │ │ │ │ + * on the same element. Default is true. │ │ │ │ */ │ │ │ │ - format: null, │ │ │ │ + stopDown: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: dragging │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + dragging: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: last │ │ │ │ + * {<OpenLayers.Pixel>} The last pixel location of the drag. │ │ │ │ + */ │ │ │ │ + last: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: start │ │ │ │ + * {<OpenLayers.Pixel>} The first pixel location of the drag. │ │ │ │ + */ │ │ │ │ + start: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: options │ │ │ │ - * {Object} Any options sent to the constructor. │ │ │ │ + * Property: lastMoveEvt │ │ │ │ + * {Object} The last mousemove event that occurred. Used to │ │ │ │ + * position the map correctly when our "delay drag" │ │ │ │ + * timeout expired. │ │ │ │ */ │ │ │ │ - options: null, │ │ │ │ + lastMoveEvt: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: autoDestroy │ │ │ │ - * {Boolean} The creator of the protocol can set autoDestroy to false │ │ │ │ - * to fully control when the protocol is destroyed. Defaults to │ │ │ │ - * true. │ │ │ │ + * Property: oldOnselectstart │ │ │ │ + * {Function} │ │ │ │ */ │ │ │ │ - autoDestroy: true, │ │ │ │ + oldOnselectstart: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: defaultFilter │ │ │ │ - * {<OpenLayers.Filter>} Optional default filter to read requests │ │ │ │ + * Property: interval │ │ │ │ + * {Integer} In order to increase performance, an interval (in │ │ │ │ + * milliseconds) can be set to reduce the number of drag events │ │ │ │ + * called. If set, a new drag event will not be set until the │ │ │ │ + * interval has passed. │ │ │ │ + * Defaults to 0, meaning no interval. │ │ │ │ */ │ │ │ │ - defaultFilter: null, │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol │ │ │ │ - * Abstract class for vector protocols. Create instances of a subclass. │ │ │ │ - * │ │ │ │ + * Property: timeoutId │ │ │ │ + * {String} The id of the timeout used for the mousedown interval. │ │ │ │ + * This is "private", and should be left alone. │ │ │ │ + */ │ │ │ │ + timeoutId: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} If set to true, the handler will also handle mouse moves when │ │ │ │ + * the cursor has moved out of the map viewport. Default is false. │ │ │ │ + */ │ │ │ │ + documentDrag: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: documentEvents │ │ │ │ + * {Boolean} Are we currently observing document events? │ │ │ │ + */ │ │ │ │ + documentEvents: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler.Drag │ │ │ │ + * Returns OpenLayers.Handler.Drag │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ + * this handler. If a handler is being used without a control, the │ │ │ │ + * handlers setMap method must be overridden to deal properly with │ │ │ │ + * the map. │ │ │ │ + * callbacks - {Object} An object containing a single function to be │ │ │ │ + * called when the drag operation is finished. The callback should │ │ │ │ + * expect to recieve a single argument, the pixel location of the event. │ │ │ │ + * Callbacks for 'move' and 'done' are supported. You can also speficy │ │ │ │ + * callbacks for 'down', 'up', and 'out' to respond to those events. │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options; │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + var me = this; │ │ │ │ + this._docMove = function(evt) { │ │ │ │ + me.mousemove({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + }, │ │ │ │ + element: document │ │ │ │ + }); │ │ │ │ + }; │ │ │ │ + this._docUp = function(evt) { │ │ │ │ + me.mouseup({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + }; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * Method: mergeWithDefaultFilter │ │ │ │ - * Merge filter passed to the read method with the default one │ │ │ │ + * Method: dragstart │ │ │ │ + * This private method is factorized from mousedown and touchstart methods │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} │ │ │ │ + * evt - {Event} The event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - mergeWithDefaultFilter: function(filter) { │ │ │ │ - var merged; │ │ │ │ - if (filter && this.defaultFilter) { │ │ │ │ - merged = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.defaultFilter, filter] │ │ │ │ - }); │ │ │ │ + dragstart: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + this.dragging = false; │ │ │ │ + if (this.checkModifiers(evt) && │ │ │ │ + (OpenLayers.Event.isLeftClick(evt) || │ │ │ │ + OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ + this.started = true; │ │ │ │ + this.start = evt.xy; │ │ │ │ + this.last = evt.xy; │ │ │ │ + OpenLayers.Element.addClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + this.down(evt); │ │ │ │ + this.callback("down", [evt.xy]); │ │ │ │ + │ │ │ │ + // prevent document dragging │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart ? │ │ │ │ + document.onselectstart : OpenLayers.Function.True; │ │ │ │ + } │ │ │ │ + document.onselectstart = OpenLayers.Function.False; │ │ │ │ + │ │ │ │ + propagate = !this.stopDown; │ │ │ │ } else { │ │ │ │ - merged = filter || this.defaultFilter || undefined; │ │ │ │ + this.started = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ } │ │ │ │ - return merged; │ │ │ │ + return propagate; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * Method: dragmove │ │ │ │ + * This private method is factorized from mousemove and touchmove methods │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The event │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.options = null; │ │ │ │ - this.format = null; │ │ │ │ + dragmove: function(evt) { │ │ │ │ + this.lastMoveEvt = evt; │ │ │ │ + if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || │ │ │ │ + evt.xy.y != this.last.y)) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + if (evt.element === document) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + // do setEvent manually because the documentEvents are not │ │ │ │ + // registered with the map │ │ │ │ + this.setEvent(evt); │ │ │ │ + } else { │ │ │ │ + this.removeDocumentEvents(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.interval > 0) { │ │ │ │ + this.timeoutId = setTimeout( │ │ │ │ + OpenLayers.Function.bind(this.removeTimeout, this), │ │ │ │ + this.interval); │ │ │ │ + } │ │ │ │ + this.dragging = true; │ │ │ │ + │ │ │ │ + this.move(evt); │ │ │ │ + this.callback("move", [evt.xy]); │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart; │ │ │ │ + document.onselectstart = OpenLayers.Function.False; │ │ │ │ + } │ │ │ │ + this.last = evt.xy; │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new features. │ │ │ │ + * Method: dragend │ │ │ │ + * This private method is factorized from mouseup and touchend methods │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ + * evt - {Event} The event │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.filter = this.mergeWithDefaultFilter(options.filter); │ │ │ │ + dragend: function(evt) { │ │ │ │ + if (this.started) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + this.removeDocumentEvents(); │ │ │ │ + } │ │ │ │ + var dragged = (this.start != this.last); │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + this.up(evt); │ │ │ │ + this.callback("up", [evt.xy]); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]); │ │ │ │ + } │ │ │ │ + document.onselectstart = this.oldOnselectstart; │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ + /** │ │ │ │ + * The four methods below (down, move, up, and out) are used by subclasses │ │ │ │ + * to do their own processing related to these mouse events. │ │ │ │ + */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: create │ │ │ │ - * Construct a request for writing newly created features. │ │ │ │ + * Method: down │ │ │ │ + * This method is called during the handling of the mouse down event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ + * evt - {Event} The mouse down event │ │ │ │ + */ │ │ │ │ + down: function(evt) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * This method is called during the handling of the mouse move event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The mouse move event │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ */ │ │ │ │ - create: function() {}, │ │ │ │ + move: function(evt) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: update │ │ │ │ - * Construct a request updating modified features. │ │ │ │ + * Method: up │ │ │ │ + * This method is called during the handling of the mouse up event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ + * evt - {Event} The mouse up event │ │ │ │ + */ │ │ │ │ + up: function(evt) {}, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: out │ │ │ │ + * This method is called during the handling of the mouse out event. │ │ │ │ + * Subclasses can do their own processing here. │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} The mouse out event │ │ │ │ */ │ │ │ │ - update: function() {}, │ │ │ │ + out: function(evt) {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: delete │ │ │ │ - * Construct a request deleting a removed feature. │ │ │ │ + * The methods below are part of the magic of event handling. Because │ │ │ │ + * they are named like browser events, they are registered as listeners │ │ │ │ + * for the events they represent. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mousedown events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, the same object will be passed to the callback function passed │ │ │ │ - * if one exists in the options object. │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - "delete": function() {}, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + return this.dragstart(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: commit │ │ │ │ - * Go over the features and for each take action │ │ │ │ - * based on the feature state. Possible actions are create, │ │ │ │ - * update and delete. │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} │ │ │ │ - * options - {Object} Object whose possible keys are "create", "update", │ │ │ │ - * "delete", "callback" and "scope", the values referenced by the │ │ │ │ - * first three are objects as passed to the "create", "update", and │ │ │ │ - * "delete" methods, the value referenced by the "callback" key is │ │ │ │ - * a function which is called when the commit operation is complete │ │ │ │ - * using the scope referenced by the "scope" key. │ │ │ │ + * evt - {Event} │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array({<OpenLayers.Protocol.Response>})} An array of │ │ │ │ - * <OpenLayers.Protocol.Response> objects. │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - commit: function() {}, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return this.dragstart(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: abort │ │ │ │ - * Abort an ongoing request. │ │ │ │ + * Method: mousemove │ │ │ │ + * Handle mousemove events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - abort: function(response) {}, │ │ │ │ + mousemove: function(evt) { │ │ │ │ + return this.dragmove(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: createCallback │ │ │ │ - * Returns a function that applies the given public method with resp and │ │ │ │ - * options arguments. │ │ │ │ + * Method: touchmove │ │ │ │ + * Handle touchmove events │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * method - {Function} The method to be applied by the callback. │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} The protocol response object. │ │ │ │ - * options - {Object} Options sent to the protocol method │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - createCallback: function(method, response, options) { │ │ │ │ - return OpenLayers.Function.bind(function() { │ │ │ │ - method.apply(this, [response, options]); │ │ │ │ - }, this); │ │ │ │ + touchmove: function(evt) { │ │ │ │ + return this.dragmove(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol" │ │ │ │ -}); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Protocol.Response │ │ │ │ - * Protocols return Response objects to their users. │ │ │ │ - */ │ │ │ │ -OpenLayers.Protocol.Response = OpenLayers.Class({ │ │ │ │ /** │ │ │ │ - * Property: code │ │ │ │ - * {Number} - OpenLayers.Protocol.Response.SUCCESS or │ │ │ │ - * OpenLayers.Protocol.Response.FAILURE │ │ │ │ + * Method: removeTimeout │ │ │ │ + * Private. Called by mousemove() to remove the drag timeout. │ │ │ │ */ │ │ │ │ - code: null, │ │ │ │ + removeTimeout: function() { │ │ │ │ + this.timeoutId = null; │ │ │ │ + // if timeout expires while we're still dragging (mouseup │ │ │ │ + // hasn't occurred) then call mousemove to move to the │ │ │ │ + // correct position │ │ │ │ + if (this.dragging) { │ │ │ │ + this.mousemove(this.lastMoveEvt); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: requestType │ │ │ │ - * {String} The type of request this response corresponds to. Either │ │ │ │ - * "create", "read", "update" or "delete". │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouseup events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - requestType: null, │ │ │ │ + mouseup: function(evt) { │ │ │ │ + return this.dragend(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: last │ │ │ │ - * {Boolean} - true if this is the last response expected in a commit, │ │ │ │ - * false otherwise, defaults to true. │ │ │ │ + * Method: touchend │ │ │ │ + * Handle touchend events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - last: true, │ │ │ │ + touchend: function(evt) { │ │ │ │ + // override evt.xy with last position since touchend does not have │ │ │ │ + // any touch position │ │ │ │ + evt.xy = this.last; │ │ │ │ + return this.dragend(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: features │ │ │ │ - * {Array({<OpenLayers.Feature.Vector>})} or {<OpenLayers.Feature.Vector>} │ │ │ │ - * The features returned in the response by the server. Depending on the │ │ │ │ - * protocol's read payload, either features or data will be populated. │ │ │ │ + * Method: mouseout │ │ │ │ + * Handle mouseout events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - features: null, │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + this.addDocumentEvents(); │ │ │ │ + } else { │ │ │ │ + var dragged = (this.start != this.last); │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + this.out(evt); │ │ │ │ + this.callback("out", []); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]); │ │ │ │ + } │ │ │ │ + if (document.onselectstart) { │ │ │ │ + document.onselectstart = this.oldOnselectstart; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: data │ │ │ │ - * {Object} │ │ │ │ - * The data returned in the response by the server. Depending on the │ │ │ │ - * protocol's read payload, either features or data will be populated. │ │ │ │ + * Method: click │ │ │ │ + * The drag handler captures the click event. If something else registers │ │ │ │ + * for clicks on the same element, its listener will not be called │ │ │ │ + * after a drag. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ */ │ │ │ │ - data: null, │ │ │ │ + click: function(evt) { │ │ │ │ + // let the click event propagate only if the mouse moved │ │ │ │ + return (this.start == this.last); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: reqFeatures │ │ │ │ - * {Array({<OpenLayers.Feature.Vector>})} or {<OpenLayers.Feature.Vector>} │ │ │ │ - * The features provided by the user and placed in the request by the │ │ │ │ - * protocol. │ │ │ │ + * Method: activate │ │ │ │ + * Activate the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully activated. │ │ │ │ */ │ │ │ │ - reqFeatures: null, │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragging = false; │ │ │ │ + activated = true; │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: priv │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The handler was successfully deactivated. │ │ │ │ */ │ │ │ │ - priv: null, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDragDown" │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: error │ │ │ │ - * {Object} The error object in case a service exception was encountered. │ │ │ │ + * Method: adjustXY │ │ │ │ + * Converts event coordinates that are relative to the document body to │ │ │ │ + * ones that are relative to the map viewport. The latter is the default in │ │ │ │ + * OpenLayers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - error: null, │ │ │ │ + adjustXY: function(evt) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ + evt.xy.x -= pos[0]; │ │ │ │ + evt.xy.y -= pos[1]; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.Response │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ + * Method: addDocumentEvents │ │ │ │ + * Start observing document events when documentDrag is true and the mouse │ │ │ │ + * cursor leaves the map viewport while dragging. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ + addDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = true; │ │ │ │ + OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.observe(document, "mouseup", this._docUp); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: success │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} - true on success, false otherwise │ │ │ │ + * Method: removeDocumentEvents │ │ │ │ + * Stops observing document events when documentDrag is true and the mouse │ │ │ │ + * cursor re-enters the map viewport while dragging. │ │ │ │ */ │ │ │ │ - success: function() { │ │ │ │ - return this.code > 0; │ │ │ │ + removeDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = false; │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mouseup", this._docUp); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.Response" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ }); │ │ │ │ - │ │ │ │ -OpenLayers.Protocol.Response.SUCCESS = 1; │ │ │ │ -OpenLayers.Protocol.Response.FAILURE = 0; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Request.js │ │ │ │ + OpenLayers/Handler/Box.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * TODO: deprecate me │ │ │ │ - * Use OpenLayers.Request.proxy instead. │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ */ │ │ │ │ -OpenLayers.ProxyHost = ""; │ │ │ │ │ │ │ │ /** │ │ │ │ - * Namespace: OpenLayers.Request │ │ │ │ - * The OpenLayers.Request namespace contains convenience methods for working │ │ │ │ - * with XMLHttpRequests. These methods work with a cross-browser │ │ │ │ - * W3C compliant <OpenLayers.Request.XMLHttpRequest> class. │ │ │ │ + * Class: OpenLayers.Handler.Box │ │ │ │ + * Handler for dragging a rectangle across the map. Box is displayed │ │ │ │ + * on mouse down, moves on mouse move, and is finished on mouse up. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -if (!OpenLayers.Request) { │ │ │ │ - /** │ │ │ │ - * This allows for OpenLayers/Request/XMLHttpRequest.js to be included │ │ │ │ - * before or after this script. │ │ │ │ - */ │ │ │ │ - OpenLayers.Request = {}; │ │ │ │ -} │ │ │ │ -OpenLayers.Util.extend(OpenLayers.Request, { │ │ │ │ +OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constant: DEFAULT_CONFIG │ │ │ │ - * {Object} Default configuration for all requests. │ │ │ │ + /** │ │ │ │ + * Property: dragHandler │ │ │ │ + * {<OpenLayers.Handler.Drag>} │ │ │ │ */ │ │ │ │ - DEFAULT_CONFIG: { │ │ │ │ - method: "GET", │ │ │ │ - url: window.location.href, │ │ │ │ - async: true, │ │ │ │ - user: undefined, │ │ │ │ - password: undefined, │ │ │ │ - params: null, │ │ │ │ - proxy: OpenLayers.ProxyHost, │ │ │ │ - headers: {}, │ │ │ │ - data: null, │ │ │ │ - callback: function() {}, │ │ │ │ - success: null, │ │ │ │ - failure: null, │ │ │ │ - scope: null │ │ │ │ - }, │ │ │ │ + dragHandler: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constant: URL_SPLIT_REGEX │ │ │ │ + * APIProperty: boxDivClassName │ │ │ │ + * {String} The CSS class to use for drawing the box. Default is │ │ │ │ + * olHandlerBoxZoomBox │ │ │ │ */ │ │ │ │ - URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/, │ │ │ │ + boxDivClassName: 'olHandlerBoxZoomBox', │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} An events object that handles all │ │ │ │ - * events on the {<OpenLayers.Request>} object. │ │ │ │ - * │ │ │ │ - * All event listeners will receive an event object with three properties: │ │ │ │ - * request - {<OpenLayers.Request.XMLHttpRequest>} The request object. │ │ │ │ - * config - {Object} The config object sent to the specific request method. │ │ │ │ - * requestUrl - {String} The request url. │ │ │ │ - * │ │ │ │ - * Supported event types: │ │ │ │ - * complete - Triggered when we have a response from the request, if a │ │ │ │ - * listener returns false, no further response processing will take │ │ │ │ - * place. │ │ │ │ - * success - Triggered when the HTTP response has a success code (200-299). │ │ │ │ - * failure - Triggered when the HTTP response does not have a success code. │ │ │ │ + * Property: boxOffsets │ │ │ │ + * {Object} Caches box offsets from css. This is used by the getBoxOffsets │ │ │ │ + * method. │ │ │ │ */ │ │ │ │ - events: new OpenLayers.Events(this), │ │ │ │ + boxOffsets: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: makeSameOrigin │ │ │ │ - * Using the specified proxy, returns a same origin url of the provided url. │ │ │ │ + * Constructor: OpenLayers.Handler.Box │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * url - {String} An arbitrary url │ │ │ │ - * proxy {String|Function} The proxy to use to make the provided url a │ │ │ │ - * same origin url. │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ + * callbacks - {Object} An object with a properties whose values are │ │ │ │ + * functions. Various callbacks described below. │ │ │ │ + * options - {Object} │ │ │ │ * │ │ │ │ - * Returns │ │ │ │ - * {String} the same origin url. If no proxy is provided, the returned url │ │ │ │ - * will be the same as the provided url. │ │ │ │ + * Named callbacks: │ │ │ │ + * start - Called when the box drag operation starts. │ │ │ │ + * done - Called when the box drag operation is finished. │ │ │ │ + * The callback should expect to receive a single argument, the box │ │ │ │ + * bounds or a pixel. If the box dragging didn't span more than a 5 │ │ │ │ + * pixel distance, a pixel will be returned instead of a bounds object. │ │ │ │ */ │ │ │ │ - makeSameOrigin: function(url, proxy) { │ │ │ │ - var sameOrigin = url.indexOf("http") !== 0; │ │ │ │ - var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX); │ │ │ │ - if (urlParts) { │ │ │ │ - var location = window.location; │ │ │ │ - sameOrigin = │ │ │ │ - urlParts[1] == location.protocol && │ │ │ │ - urlParts[3] == location.hostname; │ │ │ │ - var uPort = urlParts[4], │ │ │ │ - lPort = location.port; │ │ │ │ - if (uPort != 80 && uPort != "" || lPort != "80" && lPort != "") { │ │ │ │ - sameOrigin = sameOrigin && uPort == lPort; │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.dragHandler = new OpenLayers.Handler.Drag( │ │ │ │ + this, { │ │ │ │ + down: this.startBox, │ │ │ │ + move: this.moveBox, │ │ │ │ + out: this.removeBox, │ │ │ │ + up: this.endBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.dragHandler) { │ │ │ │ + this.dragHandler.destroy(); │ │ │ │ + this.dragHandler = null; │ │ │ │ } │ │ │ │ - if (!sameOrigin) { │ │ │ │ - if (proxy) { │ │ │ │ - if (typeof proxy == "function") { │ │ │ │ - url = proxy(url); │ │ │ │ - } else { │ │ │ │ - url = proxy + encodeURIComponent(url); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Handler.prototype.setMap.apply(this, arguments); │ │ │ │ + if (this.dragHandler) { │ │ │ │ + this.dragHandler.setMap(map); │ │ │ │ } │ │ │ │ - return url; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: issue │ │ │ │ - * Create a new XMLHttpRequest object, open it, set any headers, bind │ │ │ │ - * a callback to done state, and send any data. It is recommended that │ │ │ │ - * you use one <GET>, <POST>, <PUT>, <DELETE>, <OPTIONS>, or <HEAD>. │ │ │ │ - * This method is only documented to provide detail on the configuration │ │ │ │ - * options available to all request methods. │ │ │ │ + * Method: startBox │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * config - {Object} Object containing properties for configuring the │ │ │ │ - * request. Allowed configuration properties are described below. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Allowed config properties: │ │ │ │ - * method - {String} One of GET, POST, PUT, DELETE, HEAD, or │ │ │ │ - * OPTIONS. Default is GET. │ │ │ │ - * url - {String} URL for the request. │ │ │ │ - * async - {Boolean} Open an asynchronous request. Default is true. │ │ │ │ - * user - {String} User for relevant authentication scheme. Set │ │ │ │ - * to null to clear current user. │ │ │ │ - * password - {String} Password for relevant authentication scheme. │ │ │ │ - * Set to null to clear current password. │ │ │ │ - * proxy - {String} Optional proxy. Defaults to │ │ │ │ - * <OpenLayers.ProxyHost>. │ │ │ │ - * params - {Object} Any key:value pairs to be appended to the │ │ │ │ - * url as a query string. Assumes url doesn't already include a query │ │ │ │ - * string or hash. Typically, this is only appropriate for <GET> │ │ │ │ - * requests where the query string will be appended to the url. │ │ │ │ - * Parameter values that are arrays will be │ │ │ │ - * concatenated with a comma (note that this goes against form-encoding) │ │ │ │ - * as is done with <OpenLayers.Util.getParameterString>. │ │ │ │ - * headers - {Object} Object with header:value pairs to be set on │ │ │ │ - * the request. │ │ │ │ - * data - {String | Document} Optional data to send with the request. │ │ │ │ - * Typically, this is only used with <POST> and <PUT> requests. │ │ │ │ - * Make sure to provide the appropriate "Content-Type" header for your │ │ │ │ - * data. For <POST> and <PUT> requests, the content type defaults to │ │ │ │ - * "application-xml". If your data is a different content type, or │ │ │ │ - * if you are using a different HTTP method, set the "Content-Type" │ │ │ │ - * header to match your data type. │ │ │ │ - * callback - {Function} Function to call when request is done. │ │ │ │ - * To determine if the request failed, check request.status (200 │ │ │ │ - * indicates success). │ │ │ │ - * success - {Function} Optional function to call if request status is in │ │ │ │ - * the 200s. This will be called in addition to callback above and │ │ │ │ - * would typically only be used as an alternative. │ │ │ │ - * failure - {Function} Optional function to call if request status is not │ │ │ │ - * in the 200s. This will be called in addition to callback above and │ │ │ │ - * would typically only be used as an alternative. │ │ │ │ - * scope - {Object} If callback is a public method on some object, │ │ │ │ - * set the scope to that object. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. To abort the request before a response │ │ │ │ - * is received, call abort() on the request object. │ │ │ │ + * xy - {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - issue: function(config) { │ │ │ │ - // apply default config - proxy host may have changed │ │ │ │ - var defaultConfig = OpenLayers.Util.extend( │ │ │ │ - this.DEFAULT_CONFIG, { │ │ │ │ - proxy: OpenLayers.ProxyHost │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - config = config || {}; │ │ │ │ - config.headers = config.headers || {}; │ │ │ │ - config = OpenLayers.Util.applyDefaults(config, defaultConfig); │ │ │ │ - config.headers = OpenLayers.Util.applyDefaults(config.headers, defaultConfig.headers); │ │ │ │ - // Always set the "X-Requested-With" header to signal that this request │ │ │ │ - // was issued through the XHR-object. Since header keys are case │ │ │ │ - // insensitive and we want to allow overriding of the "X-Requested-With" │ │ │ │ - // header through the user we cannot use applyDefaults, but have to │ │ │ │ - // check manually whether we were called with a "X-Requested-With" │ │ │ │ - // header. │ │ │ │ - var customRequestedWithHeader = false, │ │ │ │ - headerKey; │ │ │ │ - for (headerKey in config.headers) { │ │ │ │ - if (config.headers.hasOwnProperty(headerKey)) { │ │ │ │ - if (headerKey.toLowerCase() === 'x-requested-with') { │ │ │ │ - customRequestedWithHeader = true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (customRequestedWithHeader === false) { │ │ │ │ - // we did not have a custom "X-Requested-With" header │ │ │ │ - config.headers['X-Requested-With'] = 'XMLHttpRequest'; │ │ │ │ - } │ │ │ │ + startBox: function(xy) { │ │ │ │ + this.callback("start", []); │ │ │ │ + this.zoomBox = OpenLayers.Util.createDiv('zoomBox', { │ │ │ │ + x: -9999, │ │ │ │ + y: -9999 │ │ │ │ + }); │ │ │ │ + this.zoomBox.className = this.boxDivClassName; │ │ │ │ + this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; │ │ │ │ │ │ │ │ - // create request, open, and set headers │ │ │ │ - var request = new OpenLayers.Request.XMLHttpRequest(); │ │ │ │ - var url = OpenLayers.Util.urlAppend(config.url, │ │ │ │ - OpenLayers.Util.getParameterString(config.params || {})); │ │ │ │ - url = OpenLayers.Request.makeSameOrigin(url, config.proxy); │ │ │ │ - request.open( │ │ │ │ - config.method, url, config.async, config.user, config.password │ │ │ │ - ); │ │ │ │ - for (var header in config.headers) { │ │ │ │ - request.setRequestHeader(header, config.headers[header]); │ │ │ │ - } │ │ │ │ + this.map.viewPortDiv.appendChild(this.zoomBox); │ │ │ │ │ │ │ │ - var events = this.events; │ │ │ │ + OpenLayers.Element.addClass( │ │ │ │ + this.map.viewPortDiv, "olDrawBox" │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // we want to execute runCallbacks with "this" as the │ │ │ │ - // execution scope │ │ │ │ - var self = this; │ │ │ │ + /** │ │ │ │ + * Method: moveBox │ │ │ │ + */ │ │ │ │ + moveBox: function(xy) { │ │ │ │ + var startX = this.dragHandler.start.x; │ │ │ │ + var startY = this.dragHandler.start.y; │ │ │ │ + var deltaX = Math.abs(startX - xy.x); │ │ │ │ + var deltaY = Math.abs(startY - xy.y); │ │ │ │ │ │ │ │ - request.onreadystatechange = function() { │ │ │ │ - if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) { │ │ │ │ - var proceed = events.triggerEvent( │ │ │ │ - "complete", { │ │ │ │ - request: request, │ │ │ │ - config: config, │ │ │ │ - requestUrl: url │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - if (proceed !== false) { │ │ │ │ - self.runCallbacks({ │ │ │ │ - request: request, │ │ │ │ - config: config, │ │ │ │ - requestUrl: url │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ + var offset = this.getBoxOffsets(); │ │ │ │ + this.zoomBox.style.width = (deltaX + offset.width + 1) + "px"; │ │ │ │ + this.zoomBox.style.height = (deltaY + offset.height + 1) + "px"; │ │ │ │ + this.zoomBox.style.left = (xy.x < startX ? │ │ │ │ + startX - deltaX - offset.left : startX - offset.left) + "px"; │ │ │ │ + this.zoomBox.style.top = (xy.y < startY ? │ │ │ │ + startY - deltaY - offset.top : startY - offset.top) + "px"; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // send request (optionally with data) and return │ │ │ │ - // call in a timeout for asynchronous requests so the return is │ │ │ │ - // available before readyState == 4 for cached docs │ │ │ │ - if (config.async === false) { │ │ │ │ - request.send(config.data); │ │ │ │ + /** │ │ │ │ + * Method: endBox │ │ │ │ + */ │ │ │ │ + endBox: function(end) { │ │ │ │ + var result; │ │ │ │ + if (Math.abs(this.dragHandler.start.x - end.x) > 5 || │ │ │ │ + Math.abs(this.dragHandler.start.y - end.y) > 5) { │ │ │ │ + var start = this.dragHandler.start; │ │ │ │ + var top = Math.min(start.y, end.y); │ │ │ │ + var bottom = Math.max(start.y, end.y); │ │ │ │ + var left = Math.min(start.x, end.x); │ │ │ │ + var right = Math.max(start.x, end.x); │ │ │ │ + result = new OpenLayers.Bounds(left, bottom, right, top); │ │ │ │ } else { │ │ │ │ - window.setTimeout(function() { │ │ │ │ - if (request.readyState !== 0) { // W3C: 0-UNSENT │ │ │ │ - request.send(config.data); │ │ │ │ - } │ │ │ │ - }, 0); │ │ │ │ + result = this.dragHandler.start.clone(); // i.e. OL.Pixel │ │ │ │ } │ │ │ │ - return request; │ │ │ │ + this.removeBox(); │ │ │ │ + │ │ │ │ + this.callback("done", [result]); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: runCallbacks │ │ │ │ - * Calls the complete, success and failure callbacks. Application │ │ │ │ - * can listen to the "complete" event, have the listener │ │ │ │ - * display a confirm window and always return false, and │ │ │ │ - * execute OpenLayers.Request.runCallbacks if the user │ │ │ │ - * hits "yes" in the confirm window. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Hash containing request, config and requestUrl keys │ │ │ │ + * Method: removeBox │ │ │ │ + * Remove the zoombox from the screen and nullify our reference to it. │ │ │ │ */ │ │ │ │ - runCallbacks: function(options) { │ │ │ │ - var request = options.request; │ │ │ │ - var config = options.config; │ │ │ │ - │ │ │ │ - // bind callbacks to readyState 4 (done) │ │ │ │ - var complete = (config.scope) ? │ │ │ │ - OpenLayers.Function.bind(config.callback, config.scope) : │ │ │ │ - config.callback; │ │ │ │ - │ │ │ │ - // optional success callback │ │ │ │ - var success; │ │ │ │ - if (config.success) { │ │ │ │ - success = (config.scope) ? │ │ │ │ - OpenLayers.Function.bind(config.success, config.scope) : │ │ │ │ - config.success; │ │ │ │ - } │ │ │ │ + removeBox: function() { │ │ │ │ + this.map.viewPortDiv.removeChild(this.zoomBox); │ │ │ │ + this.zoomBox = null; │ │ │ │ + this.boxOffsets = null; │ │ │ │ + OpenLayers.Element.removeClass( │ │ │ │ + this.map.viewPortDiv, "olDrawBox" │ │ │ │ + ); │ │ │ │ │ │ │ │ - // optional failure callback │ │ │ │ - var failure; │ │ │ │ - if (config.failure) { │ │ │ │ - failure = (config.scope) ? │ │ │ │ - OpenLayers.Function.bind(config.failure, config.scope) : │ │ │ │ - config.failure; │ │ │ │ - } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (OpenLayers.Util.createUrlObject(config.url).protocol == "file:" && │ │ │ │ - request.responseText) { │ │ │ │ - request.status = 200; │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragHandler.activate(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - complete(request); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!request.status || (request.status >= 200 && request.status < 300)) { │ │ │ │ - this.events.triggerEvent("success", options); │ │ │ │ - if (success) { │ │ │ │ - success(request); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ - this.events.triggerEvent("failure", options); │ │ │ │ - if (failure) { │ │ │ │ - failure(request); │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + if (this.dragHandler.deactivate()) { │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.removeBox(); │ │ │ │ + } │ │ │ │ } │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: GET │ │ │ │ - * Send an HTTP GET request. Additional configuration properties are │ │ │ │ - * documented in the <issue> method, with the method property set │ │ │ │ - * to GET. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the <issue> method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ + * Method: getBoxOffsets │ │ │ │ + * Determines border offsets for a box, according to the box model. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ + * {Object} an object with the following offsets: │ │ │ │ + * - left │ │ │ │ + * - right │ │ │ │ + * - top │ │ │ │ + * - bottom │ │ │ │ + * - width │ │ │ │ + * - height │ │ │ │ */ │ │ │ │ - GET: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "GET" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ + getBoxOffsets: function() { │ │ │ │ + if (!this.boxOffsets) { │ │ │ │ + // Determine the box model. If the testDiv's clientWidth is 3, then │ │ │ │ + // the borders are outside and we are dealing with the w3c box │ │ │ │ + // model. Otherwise, the browser uses the traditional box model and │ │ │ │ + // the borders are inside the box bounds, leaving us with a │ │ │ │ + // clientWidth of 1. │ │ │ │ + var testDiv = document.createElement("div"); │ │ │ │ + //testDiv.style.visibility = "hidden"; │ │ │ │ + testDiv.style.position = "absolute"; │ │ │ │ + testDiv.style.border = "1px solid black"; │ │ │ │ + testDiv.style.width = "3px"; │ │ │ │ + document.body.appendChild(testDiv); │ │ │ │ + var w3cBoxModel = testDiv.clientWidth == 3; │ │ │ │ + document.body.removeChild(testDiv); │ │ │ │ + │ │ │ │ + var left = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ + "border-left-width")); │ │ │ │ + var right = parseInt(OpenLayers.Element.getStyle( │ │ │ │ + this.zoomBox, "border-right-width")); │ │ │ │ + var top = parseInt(OpenLayers.Element.getStyle(this.zoomBox, │ │ │ │ + "border-top-width")); │ │ │ │ + var bottom = parseInt(OpenLayers.Element.getStyle( │ │ │ │ + this.zoomBox, "border-bottom-width")); │ │ │ │ + this.boxOffsets = { │ │ │ │ + left: left, │ │ │ │ + right: right, │ │ │ │ + top: top, │ │ │ │ + bottom: bottom, │ │ │ │ + width: w3cBoxModel === false ? left + right : 0, │ │ │ │ + height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ + }; │ │ │ │ + } │ │ │ │ + return this.boxOffsets; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/ZoomBox.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Box.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.ZoomBox │ │ │ │ + * The ZoomBox control enables zooming directly to a given extent, by drawing │ │ │ │ + * a box on the map. The box is drawn by holding down shift, whilst dragging │ │ │ │ + * the mouse. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ /** │ │ │ │ - * APIMethod: POST │ │ │ │ - * Send a POST request. Additional configuration properties are │ │ │ │ - * documented in the <issue> method, with the method property set │ │ │ │ - * to POST and "Content-Type" header set to "application/xml". │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the <issue> method for documentation of allowed properties. The │ │ │ │ - * default "Content-Type" header will be set to "application-xml" if │ │ │ │ - * none is provided. This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ + * Property: type │ │ │ │ + * {OpenLayers.Control.TYPE} │ │ │ │ */ │ │ │ │ - POST: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "POST" │ │ │ │ - }); │ │ │ │ - // set content type to application/xml if it isn't already set │ │ │ │ - config.headers = config.headers ? config.headers : {}; │ │ │ │ - if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ - config.headers["Content-Type"] = "application/xml"; │ │ │ │ - } │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: PUT │ │ │ │ - * Send an HTTP PUT request. Additional configuration properties are │ │ │ │ - * documented in the <issue> method, with the method property set │ │ │ │ - * to PUT and "Content-Type" header set to "application/xml". │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the <issue> method for documentation of allowed properties. The │ │ │ │ - * default "Content-Type" header will be set to "application-xml" if │ │ │ │ - * none is provided. This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ + * Property: out │ │ │ │ + * {Boolean} Should the control be used for zooming out? │ │ │ │ */ │ │ │ │ - PUT: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "PUT" │ │ │ │ - }); │ │ │ │ - // set content type to application/xml if it isn't already set │ │ │ │ - config.headers = config.headers ? config.headers : {}; │ │ │ │ - if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ - config.headers["Content-Type"] = "application/xml"; │ │ │ │ - } │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ + out: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: DELETE │ │ │ │ - * Send an HTTP DELETE request. Additional configuration properties are │ │ │ │ - * documented in the <issue> method, with the method property set │ │ │ │ - * to DELETE. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the <issue> method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ + * APIProperty: keyMask │ │ │ │ + * {Integer} Zoom only occurs if the keyMask matches the combination of │ │ │ │ + * keys down. Use bitwise operators and one or more of the │ │ │ │ + * <OpenLayers.Handler> constants to construct a keyMask. Leave null if │ │ │ │ + * not used mask. Default is null. │ │ │ │ */ │ │ │ │ - DELETE: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "DELETE" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - }, │ │ │ │ + keyMask: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: HEAD │ │ │ │ - * Send an HTTP HEAD request. Additional configuration properties are │ │ │ │ - * documented in the <issue> method, with the method property set │ │ │ │ - * to HEAD. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the <issue> method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ + * APIProperty: alwaysZoom │ │ │ │ + * {Boolean} Always zoom in/out when box drawn, even if the zoom level does │ │ │ │ + * not change. │ │ │ │ */ │ │ │ │ - HEAD: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "HEAD" │ │ │ │ + alwaysZoom: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomOnClick │ │ │ │ + * {Boolean} Should we zoom when no box was dragged, i.e. the user only │ │ │ │ + * clicked? Default is true. │ │ │ │ + */ │ │ │ │ + zoomOnClick: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.zoomBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: OPTIONS │ │ │ │ - * Send an HTTP OPTIONS request. Additional configuration properties are │ │ │ │ - * documented in the <issue> method, with the method property set │ │ │ │ - * to OPTIONS. │ │ │ │ + * Method: zoomBox │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * config - {Object} Object with properties for configuring the request. │ │ │ │ - * See the <issue> method for documentation of allowed properties. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {XMLHttpRequest} Request object. │ │ │ │ + * position - {<OpenLayers.Bounds>} or {<OpenLayers.Pixel>} │ │ │ │ */ │ │ │ │ - OPTIONS: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "OPTIONS" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config); │ │ │ │ - } │ │ │ │ + zoomBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var bounds, │ │ │ │ + targetCenterPx = position.getCenterPixel(); │ │ │ │ + if (!this.out) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, │ │ │ │ + maxXY.lon, maxXY.lat); │ │ │ │ + } else { │ │ │ │ + var pixWidth = position.right - position.left; │ │ │ │ + var pixHeight = position.bottom - position.top; │ │ │ │ + var zoomFactor = Math.min((this.map.size.h / pixHeight), │ │ │ │ + (this.map.size.w / pixWidth)); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ + var xmin = center.lon - (extent.getWidth() / 2) * zoomFactor; │ │ │ │ + var xmax = center.lon + (extent.getWidth() / 2) * zoomFactor; │ │ │ │ + var ymin = center.lat - (extent.getHeight() / 2) * zoomFactor; │ │ │ │ + var ymax = center.lat + (extent.getHeight() / 2) * zoomFactor; │ │ │ │ + bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax); │ │ │ │ + } │ │ │ │ + // always zoom in/out │ │ │ │ + var lastZoom = this.map.getZoom(), │ │ │ │ + size = this.map.getSize(), │ │ │ │ + centerPx = { │ │ │ │ + x: size.w / 2, │ │ │ │ + y: size.h / 2 │ │ │ │ + }, │ │ │ │ + zoom = this.map.getZoomForExtent(bounds), │ │ │ │ + oldRes = this.map.getResolution(), │ │ │ │ + newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ + if (oldRes == newRes) { │ │ │ │ + this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)); │ │ │ │ + } else { │ │ │ │ + var zoomOriginPx = { │ │ │ │ + x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / │ │ │ │ + (oldRes - newRes), │ │ │ │ + y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / │ │ │ │ + (oldRes - newRes) │ │ │ │ + }; │ │ │ │ + this.map.zoomTo(zoom, zoomOriginPx); │ │ │ │ + } │ │ │ │ + if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ + this.map.zoomTo(lastZoom + (this.out ? -1 : 1)); │ │ │ │ + } │ │ │ │ + } else if (this.zoomOnClick) { // it's a pixel │ │ │ │ + if (!this.out) { │ │ │ │ + this.map.zoomTo(this.map.getZoom() + 1, position); │ │ │ │ + } else { │ │ │ │ + this.map.zoomTo(this.map.getZoom() - 1, position); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Request/XMLHttpRequest.js │ │ │ │ + OpenLayers/Control/DragPan.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ -// XMLHttpRequest.js Copyright (C) 2010 Sergey Ilinsky (http://www.ilinsky.com) │ │ │ │ -// │ │ │ │ -// 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. │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Request.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Handler/Drag.js │ │ │ │ */ │ │ │ │ │ │ │ │ -(function() { │ │ │ │ - │ │ │ │ - // Save reference to earlier defined object implementation (if any) │ │ │ │ - var oXMLHttpRequest = window.XMLHttpRequest; │ │ │ │ - │ │ │ │ - // Define on browser type │ │ │ │ - var bGecko = !!window.controllers, │ │ │ │ - bIE = window.document.all && !window.opera, │ │ │ │ - bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/); │ │ │ │ - │ │ │ │ - // Enables "XMLHttpRequest()" call next to "new XMLHttpReques()" │ │ │ │ - function fXMLHttpRequest() { │ │ │ │ - this._object = oXMLHttpRequest && !bIE7 ? new oXMLHttpRequest : new window.ActiveXObject("Microsoft.XMLHTTP"); │ │ │ │ - this._listeners = []; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Constructor │ │ │ │ - function cXMLHttpRequest() { │ │ │ │ - return new fXMLHttpRequest; │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype = fXMLHttpRequest.prototype; │ │ │ │ - │ │ │ │ - // BUGFIX: Firefox with Firebug installed would break pages if not executed │ │ │ │ - if (bGecko && oXMLHttpRequest.wrapped) │ │ │ │ - cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped; │ │ │ │ - │ │ │ │ - // Constants │ │ │ │ - cXMLHttpRequest.UNSENT = 0; │ │ │ │ - cXMLHttpRequest.OPENED = 1; │ │ │ │ - cXMLHttpRequest.HEADERS_RECEIVED = 2; │ │ │ │ - cXMLHttpRequest.LOADING = 3; │ │ │ │ - cXMLHttpRequest.DONE = 4; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.DragPan │ │ │ │ + * The DragPan control pans the map with a drag of the mouse. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - // Public Properties │ │ │ │ - cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - cXMLHttpRequest.prototype.responseText = ''; │ │ │ │ - cXMLHttpRequest.prototype.responseXML = null; │ │ │ │ - cXMLHttpRequest.prototype.status = 0; │ │ │ │ - cXMLHttpRequest.prototype.statusText = ''; │ │ │ │ + /** │ │ │ │ + * Property: type │ │ │ │ + * {OpenLayers.Control.TYPES} │ │ │ │ + */ │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ │ │ │ │ - // Priority proposal │ │ │ │ - cXMLHttpRequest.prototype.priority = "NORMAL"; │ │ │ │ + /** │ │ │ │ + * Property: panned │ │ │ │ + * {Boolean} The map moved. │ │ │ │ + */ │ │ │ │ + panned: false, │ │ │ │ │ │ │ │ - // Instance-level Events Handlers │ │ │ │ - cXMLHttpRequest.prototype.onreadystatechange = null; │ │ │ │ + /** │ │ │ │ + * Property: interval │ │ │ │ + * {Integer} The number of milliseconds that should ellapse before │ │ │ │ + * panning the map again. Defaults to 0 milliseconds, which means that │ │ │ │ + * no separate cycle is used for panning. In most cases you won't want │ │ │ │ + * to change this value. For slow machines/devices larger values can be │ │ │ │ + * tried out. │ │ │ │ + */ │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ - // Class-level Events Handlers │ │ │ │ - cXMLHttpRequest.onreadystatechange = null; │ │ │ │ - cXMLHttpRequest.onopen = null; │ │ │ │ - cXMLHttpRequest.onsend = null; │ │ │ │ - cXMLHttpRequest.onabort = null; │ │ │ │ + /** │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} If set to true, mouse dragging will continue even if the │ │ │ │ + * mouse cursor leaves the map viewport. Default is false. │ │ │ │ + */ │ │ │ │ + documentDrag: false, │ │ │ │ │ │ │ │ - // Public Methods │ │ │ │ - cXMLHttpRequest.prototype.open = function(sMethod, sUrl, bAsync, sUser, sPassword) { │ │ │ │ - // Delete headers, required when object is reused │ │ │ │ - delete this._headers; │ │ │ │ + /** │ │ │ │ + * Property: kinetic │ │ │ │ + * {<OpenLayers.Kinetic>} The OpenLayers.Kinetic object. │ │ │ │ + */ │ │ │ │ + kinetic: null, │ │ │ │ │ │ │ │ - // When bAsync parameter value is omitted, use true as default │ │ │ │ - if (arguments.length < 3) │ │ │ │ - bAsync = true; │ │ │ │ + /** │ │ │ │ + * APIProperty: enableKinetic │ │ │ │ + * {Boolean} Set this option to enable "kinetic dragging". Can be │ │ │ │ + * set to true or to an object. If set to an object this │ │ │ │ + * object will be passed to the {<OpenLayers.Kinetic>} │ │ │ │ + * constructor. Defaults to true. │ │ │ │ + * To get kinetic dragging, ensure that OpenLayers/Kinetic.js is │ │ │ │ + * included in your build config. │ │ │ │ + */ │ │ │ │ + enableKinetic: true, │ │ │ │ │ │ │ │ - // Save async parameter for fixing Gecko bug with missing readystatechange in synchronous requests │ │ │ │ - this._async = bAsync; │ │ │ │ + /** │ │ │ │ + * APIProperty: kineticInterval │ │ │ │ + * {Integer} Interval in milliseconds between 2 steps in the "kinetic │ │ │ │ + * scrolling". Applies only if enableKinetic is set. Defaults │ │ │ │ + * to 10 milliseconds. │ │ │ │ + */ │ │ │ │ + kineticInterval: 10, │ │ │ │ │ │ │ │ - // Set the onreadystatechange handler │ │ │ │ - var oRequest = this, │ │ │ │ - nState = this.readyState, │ │ │ │ - fOnUnload; │ │ │ │ │ │ │ │ - // BUGFIX: IE - memory leak on page unload (inter-page leak) │ │ │ │ - if (bIE && bAsync) { │ │ │ │ - fOnUnload = function() { │ │ │ │ - if (nState != cXMLHttpRequest.DONE) { │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - // Safe to abort here since onreadystatechange handler removed │ │ │ │ - oRequest.abort(); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * Creates a Drag handler, using <panMap> and │ │ │ │ + * <panMapDone> as callbacks. │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ + var config = { │ │ │ │ + interval: this.kineticInterval │ │ │ │ }; │ │ │ │ - window.attachEvent("onunload", fOnUnload); │ │ │ │ + if (typeof this.enableKinetic === "object") { │ │ │ │ + config = OpenLayers.Util.extend(config, this.enableKinetic); │ │ │ │ + } │ │ │ │ + this.kinetic = new OpenLayers.Kinetic(config); │ │ │ │ } │ │ │ │ + this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ + "move": this.panMap, │ │ │ │ + "done": this.panMapDone, │ │ │ │ + "down": this.panMapStart │ │ │ │ + }, { │ │ │ │ + interval: this.interval, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // Add method sniffer │ │ │ │ - if (cXMLHttpRequest.onopen) │ │ │ │ - cXMLHttpRequest.onopen.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (arguments.length > 4) │ │ │ │ - this._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ - else │ │ │ │ - if (arguments.length > 3) │ │ │ │ - this._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ - else │ │ │ │ - this._object.open(sMethod, sUrl, bAsync); │ │ │ │ - │ │ │ │ - this.readyState = cXMLHttpRequest.OPENED; │ │ │ │ - fReadyStateChange(this); │ │ │ │ + /** │ │ │ │ + * Method: panMapStart │ │ │ │ + */ │ │ │ │ + panMapStart: function() { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.begin(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - this._object.onreadystatechange = function() { │ │ │ │ - if (bGecko && !bAsync) │ │ │ │ - return; │ │ │ │ + /** │ │ │ │ + * Method: panMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ + */ │ │ │ │ + panMap: function(xy) { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.update(xy); │ │ │ │ + } │ │ │ │ + this.panned = true; │ │ │ │ + this.map.pan( │ │ │ │ + this.handler.last.x - xy.x, │ │ │ │ + this.handler.last.y - xy.y, { │ │ │ │ + dragging: true, │ │ │ │ + animate: false │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // Synchronize state │ │ │ │ - oRequest.readyState = oRequest._object.readyState; │ │ │ │ + /** │ │ │ │ + * Method: panMapDone │ │ │ │ + * Finish the panning operation. Only call setCenter (through <panMap>) │ │ │ │ + * if the map has actually been moved. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} Pixel of the mouse position │ │ │ │ + */ │ │ │ │ + panMapDone: function(xy) { │ │ │ │ + if (this.panned) { │ │ │ │ + var res = null; │ │ │ │ + if (this.kinetic) { │ │ │ │ + res = this.kinetic.end(xy); │ │ │ │ + } │ │ │ │ + this.map.pan( │ │ │ │ + this.handler.last.x - xy.x, │ │ │ │ + this.handler.last.y - xy.y, { │ │ │ │ + dragging: !!res, │ │ │ │ + animate: false │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + if (res) { │ │ │ │ + var self = this; │ │ │ │ + this.kinetic.move(res, function(x, y, end) { │ │ │ │ + self.map.pan(x, y, { │ │ │ │ + dragging: !end, │ │ │ │ + animate: false │ │ │ │ + }); │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.panned = false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - // │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Handler/MouseWheel.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - // BUGFIX: Firefox fires unnecessary DONE when aborting │ │ │ │ - if (oRequest._aborted) { │ │ │ │ - // Reset readyState to UNSENT │ │ │ │ - oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - // Return now │ │ │ │ - return; │ │ │ │ - } │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ - // Free up queue │ │ │ │ - delete oRequest._data; │ │ │ │ - /* if (bAsync) │ │ │ │ - fQueue_remove(oRequest);*/ │ │ │ │ - // │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - // Uncomment this block if you need a fix for IE cache │ │ │ │ - /* │ │ │ │ - // BUGFIX: IE - cache issue │ │ │ │ - if (!oRequest._object.getResponseHeader("Date")) { │ │ │ │ - // Save object to cache │ │ │ │ - oRequest._cached = oRequest._object; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Handler.MouseWheel │ │ │ │ + * Handler for wheel up/down events. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + /** │ │ │ │ + * Property: wheelListener │ │ │ │ + * {function} │ │ │ │ + */ │ │ │ │ + wheelListener: null, │ │ │ │ │ │ │ │ - // Instantiate a new transport object │ │ │ │ - cXMLHttpRequest.call(oRequest); │ │ │ │ + /** │ │ │ │ + * Property: interval │ │ │ │ + * {Integer} In order to increase server performance, an interval (in │ │ │ │ + * milliseconds) can be set to reduce the number of up/down events │ │ │ │ + * called. If set, a new up/down event will not be set until the │ │ │ │ + * interval has passed. │ │ │ │ + * Defaults to 0, meaning no interval. │ │ │ │ + */ │ │ │ │ + interval: 0, │ │ │ │ │ │ │ │ - // Re-send request │ │ │ │ - if (sUser) { │ │ │ │ - if (sPassword) │ │ │ │ - oRequest._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ - else │ │ │ │ - oRequest._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ - } │ │ │ │ - else │ │ │ │ - oRequest._object.open(sMethod, sUrl, bAsync); │ │ │ │ - oRequest._object.setRequestHeader("If-Modified-Since", oRequest._cached.getResponseHeader("Last-Modified") || new window.Date(0)); │ │ │ │ - // Copy headers set │ │ │ │ - if (oRequest._headers) │ │ │ │ - for (var sHeader in oRequest._headers) │ │ │ │ - if (typeof oRequest._headers[sHeader] == "string") // Some frameworks prototype objects with functions │ │ │ │ - oRequest._object.setRequestHeader(sHeader, oRequest._headers[sHeader]); │ │ │ │ + /** │ │ │ │ + * Property: maxDelta │ │ │ │ + * {Integer} Maximum delta to collect before breaking from the current │ │ │ │ + * interval. In cumulative mode, this also limits the maximum delta │ │ │ │ + * returned from the handler. Default is Number.POSITIVE_INFINITY. │ │ │ │ + */ │ │ │ │ + maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ │ │ │ │ - oRequest._object.onreadystatechange = function() { │ │ │ │ - // Synchronize state │ │ │ │ - oRequest.readyState = oRequest._object.readyState; │ │ │ │ + /** │ │ │ │ + * Property: delta │ │ │ │ + * {Integer} When interval is set, delta collects the mousewheel z-deltas │ │ │ │ + * of the events that occur within the interval. │ │ │ │ + * See also the cumulative option │ │ │ │ + */ │ │ │ │ + delta: 0, │ │ │ │ │ │ │ │ - if (oRequest._aborted) { │ │ │ │ - // │ │ │ │ - oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + /** │ │ │ │ + * Property: cumulative │ │ │ │ + * {Boolean} When interval is set: true to collect all the mousewheel │ │ │ │ + * z-deltas, false to only record the delta direction (positive or │ │ │ │ + * negative) │ │ │ │ + */ │ │ │ │ + cumulative: true, │ │ │ │ │ │ │ │ - // Return │ │ │ │ - return; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler.MouseWheel │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ + * callbacks - {Object} An object containing a single function to be │ │ │ │ + * called when the drag operation is finished. │ │ │ │ + * The callback should expect to recieve a single │ │ │ │ + * argument, the point geometry. │ │ │ │ + * options - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.wheelListener = OpenLayers.Function.bindAsEventListener( │ │ │ │ + this.onWheelEvent, this │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ - // Clean Object │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + this.wheelListener = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // get cached request │ │ │ │ - if (oRequest.status == 304) │ │ │ │ - oRequest._object = oRequest._cached; │ │ │ │ + /** │ │ │ │ + * Mouse ScrollWheel code thanks to http://adomas.org/javascript-mouse-wheel/ │ │ │ │ + */ │ │ │ │ │ │ │ │ - // │ │ │ │ - delete oRequest._cached; │ │ │ │ + /** │ │ │ │ + * Method: onWheelEvent │ │ │ │ + * Catch the wheel event and handle it xbrowserly │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * e - {Event} │ │ │ │ + */ │ │ │ │ + onWheelEvent: function(e) { │ │ │ │ │ │ │ │ - // │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ + // make sure we have a map and check keyboard modifiers │ │ │ │ + if (!this.map || !this.checkModifiers(e)) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ │ │ │ │ - // │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ + // Ride up the element's DOM hierarchy to determine if it or any of │ │ │ │ + // its ancestors was: │ │ │ │ + // * specifically marked as scrollable (CSS overflow property) │ │ │ │ + // * one of our layer divs or a div marked as scrollable │ │ │ │ + // ('olScrollable' CSS class) │ │ │ │ + // * the map div │ │ │ │ + // │ │ │ │ + var overScrollableDiv = false; │ │ │ │ + var allowScroll = false; │ │ │ │ + var overMapDiv = false; │ │ │ │ │ │ │ │ - // BUGFIX: IE - memory leak in interrupted │ │ │ │ - if (bIE && bAsync) │ │ │ │ - window.detachEvent("onunload", fOnUnload); │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - oRequest._object.send(null); │ │ │ │ + var elem = OpenLayers.Event.element(e); │ │ │ │ + while ((elem != null) && !overMapDiv && !overScrollableDiv) { │ │ │ │ │ │ │ │ - // Return now - wait until re-sent request is finished │ │ │ │ - return; │ │ │ │ - }; │ │ │ │ - */ │ │ │ │ - // BUGFIX: IE - memory leak in interrupted │ │ │ │ - if (bIE && bAsync) │ │ │ │ - window.detachEvent("onunload", fOnUnload); │ │ │ │ + if (!overScrollableDiv) { │ │ │ │ + try { │ │ │ │ + var overflow; │ │ │ │ + if (elem.currentStyle) { │ │ │ │ + overflow = elem.currentStyle["overflow"]; │ │ │ │ + } else { │ │ │ │ + var style = │ │ │ │ + document.defaultView.getComputedStyle(elem, null); │ │ │ │ + overflow = style.getPropertyValue("overflow"); │ │ │ │ + } │ │ │ │ + overScrollableDiv = (overflow && │ │ │ │ + (overflow == "auto") || (overflow == "scroll")); │ │ │ │ + } catch (err) { │ │ │ │ + //sometimes when scrolling in a popup, this causes │ │ │ │ + // obscure browser error │ │ │ │ + } │ │ │ │ } │ │ │ │ │ │ │ │ - // BUGFIX: Some browsers (Internet Explorer, Gecko) fire OPEN readystate twice │ │ │ │ - if (nState != oRequest.readyState) │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ + if (!allowScroll) { │ │ │ │ + allowScroll = OpenLayers.Element.hasClass(elem, 'olScrollable'); │ │ │ │ + if (!allowScroll) { │ │ │ │ + for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ + // Are we in the layer div? Note that we have two cases │ │ │ │ + // here: one is to catch EventPane layers, which have a │ │ │ │ + // pane above the layer (layer.pane) │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (elem == layer.div || elem == layer.pane) { │ │ │ │ + allowScroll = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + overMapDiv = (elem == this.map.div); │ │ │ │ │ │ │ │ - nState = oRequest.readyState; │ │ │ │ + elem = elem.parentNode; │ │ │ │ } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fXMLHttpRequest_send(oRequest) { │ │ │ │ - oRequest._object.send(oRequest._data); │ │ │ │ │ │ │ │ - // BUGFIX: Gecko - missing readystatechange calls in synchronous requests │ │ │ │ - if (bGecko && !oRequest._async) { │ │ │ │ - oRequest.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + // Logic below is the following: │ │ │ │ + // │ │ │ │ + // If we are over a scrollable div or not over the map div: │ │ │ │ + // * do nothing (let the browser handle scrolling) │ │ │ │ + // │ │ │ │ + // otherwise │ │ │ │ + // │ │ │ │ + // If we are over the layer div or a 'olScrollable' div: │ │ │ │ + // * zoom/in out │ │ │ │ + // then │ │ │ │ + // * kill event (so as not to also scroll the page after zooming) │ │ │ │ + // │ │ │ │ + // otherwise │ │ │ │ + // │ │ │ │ + // Kill the event (dont scroll the page if we wheel over the │ │ │ │ + // layerswitcher or the pan/zoom control) │ │ │ │ + // │ │ │ │ + if (!overScrollableDiv && overMapDiv) { │ │ │ │ + if (allowScroll) { │ │ │ │ + var delta = 0; │ │ │ │ │ │ │ │ - // Synchronize state │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ + if (e.wheelDelta) { │ │ │ │ + delta = e.wheelDelta; │ │ │ │ + if (delta % 160 === 0) { │ │ │ │ + // opera have steps of 160 instead of 120 │ │ │ │ + delta = delta * 0.75; │ │ │ │ + } │ │ │ │ + delta = delta / 120; │ │ │ │ + } else if (e.detail) { │ │ │ │ + // detail in Firefox on OS X is 1/3 of Windows │ │ │ │ + // so force delta 1 / -1 │ │ │ │ + delta = -(e.detail / Math.abs(e.detail)); │ │ │ │ + } │ │ │ │ + this.delta += delta; │ │ │ │ │ │ │ │ - // Simulate missing states │ │ │ │ - while (oRequest.readyState < cXMLHttpRequest.DONE) { │ │ │ │ - oRequest.readyState++; │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ - // Check if we are aborted │ │ │ │ - if (oRequest._aborted) │ │ │ │ - return; │ │ │ │ + window.clearTimeout(this._timeoutId); │ │ │ │ + if (this.interval && Math.abs(this.delta) < this.maxDelta) { │ │ │ │ + // store e because window.event might change during delay │ │ │ │ + var evt = OpenLayers.Util.extend({}, e); │ │ │ │ + this._timeoutId = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(function() { │ │ │ │ + this.wheelZoom(evt); │ │ │ │ + }, this), │ │ │ │ + this.interval │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.wheelZoom(e); │ │ │ │ + } │ │ │ │ } │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ } │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.send = function(vData) { │ │ │ │ - // Add method sniffer │ │ │ │ - if (cXMLHttpRequest.onsend) │ │ │ │ - cXMLHttpRequest.onsend.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (!arguments.length) │ │ │ │ - vData = null; │ │ │ │ + /** │ │ │ │ + * Method: wheelZoom │ │ │ │ + * Given the wheel event, we carry out the appropriate zooming in or out, │ │ │ │ + * based on the 'wheelDelta' or 'detail' property of the event. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * e - {Event} │ │ │ │ + */ │ │ │ │ + wheelZoom: function(e) { │ │ │ │ + var delta = this.delta; │ │ │ │ + this.delta = 0; │ │ │ │ │ │ │ │ - // BUGFIX: Safari - fails sending documents created/modified dynamically, so an explicit serialization required │ │ │ │ - // BUGFIX: IE - rewrites any custom mime-type to "text/xml" in case an XMLNode is sent │ │ │ │ - // BUGFIX: Gecko - fails sending Element (this is up to the implementation either to standard) │ │ │ │ - if (vData && vData.nodeType) { │ │ │ │ - vData = window.XMLSerializer ? new window.XMLSerializer().serializeToString(vData) : vData.xml; │ │ │ │ - if (!this._headers["Content-Type"]) │ │ │ │ - this._object.setRequestHeader("Content-Type", "application/xml"); │ │ │ │ + if (delta) { │ │ │ │ + e.xy = this.map.events.getMousePosition(e); │ │ │ │ + if (delta < 0) { │ │ │ │ + this.callback("down", │ │ │ │ + [e, this.cumulative ? Math.max(-this.maxDelta, delta) : -1]); │ │ │ │ + } else { │ │ │ │ + this.callback("up", │ │ │ │ + [e, this.cumulative ? Math.min(this.maxDelta, delta) : 1]); │ │ │ │ + } │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - this._data = vData; │ │ │ │ - /* │ │ │ │ - // Add to queue │ │ │ │ - if (this._async) │ │ │ │ - fQueue_add(this); │ │ │ │ - else*/ │ │ │ │ - fXMLHttpRequest_send(this); │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.abort = function() { │ │ │ │ - // Add method sniffer │ │ │ │ - if (cXMLHttpRequest.onabort) │ │ │ │ - cXMLHttpRequest.onabort.apply(this, arguments); │ │ │ │ - │ │ │ │ - // BUGFIX: Gecko - unnecessary DONE when aborting │ │ │ │ - if (this.readyState > cXMLHttpRequest.UNSENT) │ │ │ │ - this._aborted = true; │ │ │ │ - │ │ │ │ - this._object.abort(); │ │ │ │ - │ │ │ │ - // BUGFIX: IE - memory leak │ │ │ │ - fCleanTransport(this); │ │ │ │ - │ │ │ │ - this.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - │ │ │ │ - delete this._data; │ │ │ │ - /* if (this._async) │ │ │ │ - fQueue_remove(this);*/ │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.getAllResponseHeaders = function() { │ │ │ │ - return this._object.getAllResponseHeaders(); │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.getResponseHeader = function(sName) { │ │ │ │ - return this._object.getResponseHeader(sName); │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) { │ │ │ │ - // BUGFIX: IE - cache issue │ │ │ │ - if (!this._headers) │ │ │ │ - this._headers = {}; │ │ │ │ - this._headers[sName] = sValue; │ │ │ │ - │ │ │ │ - return this._object.setRequestHeader(sName, sValue); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // EventTarget interface implementation │ │ │ │ - cXMLHttpRequest.prototype.addEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ - return; │ │ │ │ - // Add listener │ │ │ │ - this._listeners.push([sName, fHandler, bUseCapture]); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - cXMLHttpRequest.prototype.removeEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) │ │ │ │ - break; │ │ │ │ - // Remove listener │ │ │ │ - if (oListener) │ │ │ │ - this._listeners.splice(nIndex, 1); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) { │ │ │ │ - var oEventPseudo = { │ │ │ │ - 'type': oEvent.type, │ │ │ │ - 'target': this, │ │ │ │ - 'currentTarget': this, │ │ │ │ - 'eventPhase': 2, │ │ │ │ - 'bubbles': oEvent.bubbles, │ │ │ │ - 'cancelable': oEvent.cancelable, │ │ │ │ - 'timeStamp': oEvent.timeStamp, │ │ │ │ - 'stopPropagation': function() {}, // There is no flow │ │ │ │ - 'preventDefault': function() {}, // There is no default action │ │ │ │ - 'initEvent': function() {} // Original event object should be initialized │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Execute onreadystatechange │ │ │ │ - if (oEventPseudo.type == "readystatechange" && this.onreadystatechange) │ │ │ │ - (this.onreadystatechange.handleEvent || this.onreadystatechange).apply(this, [oEventPseudo]); │ │ │ │ - │ │ │ │ - // Execute listeners │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == oEventPseudo.type && !oListener[2]) │ │ │ │ - (oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // │ │ │ │ - cXMLHttpRequest.prototype.toString = function() { │ │ │ │ - return '[' + "object" + ' ' + "XMLHttpRequest" + ']'; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - cXMLHttpRequest.toString = function() { │ │ │ │ - return '[' + "XMLHttpRequest" + ']'; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - // Helper function │ │ │ │ - function fReadyStateChange(oRequest) { │ │ │ │ - // Sniffing code │ │ │ │ - if (cXMLHttpRequest.onreadystatechange) │ │ │ │ - cXMLHttpRequest.onreadystatechange.apply(oRequest); │ │ │ │ - │ │ │ │ - // Fake event │ │ │ │ - oRequest.dispatchEvent({ │ │ │ │ - 'type': "readystatechange", │ │ │ │ - 'bubbles': false, │ │ │ │ - 'cancelable': false, │ │ │ │ - 'timeStamp': new Date + 0 │ │ │ │ - }); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fGetDocument(oRequest) { │ │ │ │ - var oDocument = oRequest.responseXML, │ │ │ │ - sResponse = oRequest.responseText; │ │ │ │ - // Try parsing responseText │ │ │ │ - if (bIE && sResponse && oDocument && !oDocument.documentElement && oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)) { │ │ │ │ - oDocument = new window.ActiveXObject("Microsoft.XMLDOM"); │ │ │ │ - oDocument.async = false; │ │ │ │ - oDocument.validateOnParse = false; │ │ │ │ - oDocument.loadXML(sResponse); │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + */ │ │ │ │ + activate: function(evt) { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + //register mousewheel events specifically on the window and document │ │ │ │ + var wheelListener = this.wheelListener; │ │ │ │ + OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener); │ │ │ │ + OpenLayers.Event.observe(window, "mousewheel", wheelListener); │ │ │ │ + OpenLayers.Event.observe(document, "mousewheel", wheelListener); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - // Check if there is no error in document │ │ │ │ - if (oDocument) │ │ │ │ - if ((bIE && oDocument.parseError != 0) || !oDocument.documentElement || (oDocument.documentElement && oDocument.documentElement.tagName == "parsererror")) │ │ │ │ - return null; │ │ │ │ - return oDocument; │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fSynchronizeValues(oRequest) { │ │ │ │ - try { │ │ │ │ - oRequest.responseText = oRequest._object.responseText; │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.responseXML = fGetDocument(oRequest._object); │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.status = oRequest._object.status; │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.statusText = oRequest._object.statusText; │ │ │ │ - } catch (e) {} │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fCleanTransport(oRequest) { │ │ │ │ - // BUGFIX: IE - memory leak (on-page leak) │ │ │ │ - oRequest._object.onreadystatechange = new window.Function; │ │ │ │ - }; │ │ │ │ - /* │ │ │ │ - // Queue manager │ │ │ │ - var oQueuePending = {"CRITICAL":[],"HIGH":[],"NORMAL":[],"LOW":[],"LOWEST":[]}, │ │ │ │ - aQueueRunning = []; │ │ │ │ - function fQueue_add(oRequest) { │ │ │ │ - oQueuePending[oRequest.priority in oQueuePending ? oRequest.priority : "NORMAL"].push(oRequest); │ │ │ │ - // │ │ │ │ - setTimeout(fQueue_process); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fQueue_remove(oRequest) { │ │ │ │ - for (var nIndex = 0, bFound = false; nIndex < aQueueRunning.length; nIndex++) │ │ │ │ - if (bFound) │ │ │ │ - aQueueRunning[nIndex - 1] = aQueueRunning[nIndex]; │ │ │ │ - else │ │ │ │ - if (aQueueRunning[nIndex] == oRequest) │ │ │ │ - bFound = true; │ │ │ │ - if (bFound) │ │ │ │ - aQueueRunning.length--; │ │ │ │ - // │ │ │ │ - setTimeout(fQueue_process); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fQueue_process() { │ │ │ │ - if (aQueueRunning.length < 6) { │ │ │ │ - for (var sPriority in oQueuePending) { │ │ │ │ - if (oQueuePending[sPriority].length) { │ │ │ │ - var oRequest = oQueuePending[sPriority][0]; │ │ │ │ - oQueuePending[sPriority] = oQueuePending[sPriority].slice(1); │ │ │ │ - // │ │ │ │ - aQueueRunning.push(oRequest); │ │ │ │ - // Send request │ │ │ │ - fXMLHttpRequest_send(oRequest); │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - */ │ │ │ │ - // Internet Explorer 5.0 (missing apply) │ │ │ │ - if (!window.Function.prototype.apply) { │ │ │ │ - window.Function.prototype.apply = function(oRequest, oArguments) { │ │ │ │ - if (!oArguments) │ │ │ │ - oArguments = []; │ │ │ │ - oRequest.__func = this; │ │ │ │ - oRequest.__func(oArguments[0], oArguments[1], oArguments[2], oArguments[3], oArguments[4]); │ │ │ │ - delete oRequest.__func; │ │ │ │ - }; │ │ │ │ - }; │ │ │ │ + }, │ │ │ │ │ │ │ │ - // Register new object with window │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Request.XMLHttpRequest │ │ │ │ - * Standard-compliant (W3C) cross-browser implementation of the │ │ │ │ - * XMLHttpRequest object. From │ │ │ │ - * http://code.google.com/p/xmlhttprequest/. │ │ │ │ + * Method: deactivate │ │ │ │ */ │ │ │ │ - if (!OpenLayers.Request) { │ │ │ │ - /** │ │ │ │ - * This allows for OpenLayers/Request.js to be included │ │ │ │ - * before or after this script. │ │ │ │ - */ │ │ │ │ - OpenLayers.Request = {}; │ │ │ │ - } │ │ │ │ - OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest; │ │ │ │ -})(); │ │ │ │ + deactivate: function(evt) { │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + // unregister mousewheel events specifically on the window and document │ │ │ │ + var wheelListener = this.wheelListener; │ │ │ │ + OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener); │ │ │ │ + OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Protocol/HTTP.js │ │ │ │ + OpenLayers/Handler/Click.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Protocol.js │ │ │ │ - * @requires OpenLayers/Request/XMLHttpRequest.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * if application uses the query string, for example, for BBOX parameters, │ │ │ │ - * OpenLayers/Format/QueryStringFilter.js should be included in the build config file │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Protocol.HTTP │ │ │ │ - * A basic HTTP protocol for vector layers. Create a new instance with the │ │ │ │ - * <OpenLayers.Protocol.HTTP> constructor. │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Handler.Click │ │ │ │ + * A handler for mouse clicks. The intention of this handler is to give │ │ │ │ + * controls more flexibility with handling clicks. Browsers trigger │ │ │ │ + * click events twice for a double-click. In addition, the mousedown, │ │ │ │ + * mousemove, mouseup sequence fires a click event. With this handler, │ │ │ │ + * controls can decide whether to ignore clicks associated with a double │ │ │ │ + * click. By setting a <pixelTolerance>, controls can also ignore clicks │ │ │ │ + * that include a drag. Create a new instance with the │ │ │ │ + * <OpenLayers.Handler.Click> constructor. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Protocol> │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ */ │ │ │ │ -OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ +OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + /** │ │ │ │ + * APIProperty: delay │ │ │ │ + * {Number} Number of milliseconds between clicks before the event is │ │ │ │ + * considered a double-click. │ │ │ │ + */ │ │ │ │ + delay: 300, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: url │ │ │ │ - * {String} Service URL, read-only, set through the options │ │ │ │ - * passed to constructor. │ │ │ │ + * APIProperty: single │ │ │ │ + * {Boolean} Handle single clicks. Default is true. If false, clicks │ │ │ │ + * will not be reported. If true, single-clicks will be reported. │ │ │ │ */ │ │ │ │ - url: null, │ │ │ │ + single: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: headers │ │ │ │ - * {Object} HTTP request headers, read-only, set through the options │ │ │ │ - * passed to the constructor, │ │ │ │ - * Example: {'Content-Type': 'plain/text'} │ │ │ │ + * APIProperty: double │ │ │ │ + * {Boolean} Handle double-clicks. Default is false. │ │ │ │ */ │ │ │ │ - headers: null, │ │ │ │ + 'double': false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: params │ │ │ │ - * {Object} Parameters of GET requests, read-only, set through the options │ │ │ │ - * passed to the constructor, │ │ │ │ - * Example: {'bbox': '5,5,5,5'} │ │ │ │ + * APIProperty: pixelTolerance │ │ │ │ + * {Number} Maximum number of pixels between mouseup and mousedown for an │ │ │ │ + * event to be considered a click. Default is 0. If set to an │ │ │ │ + * integer value, clicks with a drag greater than the value will be │ │ │ │ + * ignored. This property can only be set when the handler is │ │ │ │ + * constructed. │ │ │ │ */ │ │ │ │ - params: null, │ │ │ │ + pixelTolerance: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: callback │ │ │ │ - * {Object} Function to be called when the <read>, <create>, │ │ │ │ - * <update>, <delete> or <commit> operation completes, read-only, │ │ │ │ - * set through the options passed to the constructor. │ │ │ │ + * APIProperty: dblclickTolerance │ │ │ │ + * {Number} Maximum distance in pixels between clicks for a sequence of │ │ │ │ + * events to be considered a double click. Default is 13. If the │ │ │ │ + * distance between two clicks is greater than this value, a double- │ │ │ │ + * click will not be fired. │ │ │ │ */ │ │ │ │ - callback: null, │ │ │ │ + dblclickTolerance: 13, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: scope │ │ │ │ - * {Object} Callback execution scope, read-only, set through the │ │ │ │ - * options passed to the constructor. │ │ │ │ + * APIProperty: stopSingle │ │ │ │ + * {Boolean} Stop other listeners from being notified of clicks. Default │ │ │ │ + * is false. If true, any listeners registered before this one for │ │ │ │ + * click or rightclick events will not be notified. │ │ │ │ */ │ │ │ │ - scope: null, │ │ │ │ + stopSingle: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: readWithPOST │ │ │ │ - * {Boolean} true if read operations are done with POST requests │ │ │ │ - * instead of GET, defaults to false. │ │ │ │ + * APIProperty: stopDouble │ │ │ │ + * {Boolean} Stop other listeners from being notified of double-clicks. │ │ │ │ + * Default is false. If true, any click listeners registered before │ │ │ │ + * this one will not be notified of *any* double-click events. │ │ │ │ + * │ │ │ │ + * The one caveat with stopDouble is that given a map with two click │ │ │ │ + * handlers, one with stopDouble true and the other with stopSingle │ │ │ │ + * true, the stopSingle handler should be activated last to get │ │ │ │ + * uniform cross-browser performance. Since IE triggers one click │ │ │ │ + * with a dblclick and FF triggers two, if a stopSingle handler is │ │ │ │ + * activated first, all it gets in IE is a single click when the │ │ │ │ + * second handler stops propagation on the dblclick. │ │ │ │ */ │ │ │ │ - readWithPOST: false, │ │ │ │ + stopDouble: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: updateWithPOST │ │ │ │ - * {Boolean} true if update operations are done with POST requests │ │ │ │ - * defaults to false. │ │ │ │ + * Property: timerId │ │ │ │ + * {Number} The id of the timeout waiting to clear the <delayedCall>. │ │ │ │ */ │ │ │ │ - updateWithPOST: false, │ │ │ │ + timerId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: deleteWithPOST │ │ │ │ - * {Boolean} true if delete operations are done with POST requests │ │ │ │ - * defaults to false. │ │ │ │ - * if true, POST data is set to output of format.write(). │ │ │ │ + * Property: down │ │ │ │ + * {Object} Object that store relevant information about the last │ │ │ │ + * mousedown or touchstart. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ + * the average location of the mouse/touch event. Its 'touches' │ │ │ │ + * property records clientX/clientY of each touches. │ │ │ │ */ │ │ │ │ - deleteWithPOST: false, │ │ │ │ + down: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: wildcarded. │ │ │ │ - * {Boolean} If true percent signs are added around values │ │ │ │ - * read from LIKE filters, for example if the protocol │ │ │ │ - * read method is passed a LIKE filter whose property │ │ │ │ - * is "foo" and whose value is "bar" the string │ │ │ │ - * "foo__ilike=%bar%" will be sent in the query string; │ │ │ │ - * defaults to false. │ │ │ │ + * Property: last │ │ │ │ + * {Object} Object that store relevant information about the last │ │ │ │ + * mousemove or touchmove. Its 'xy' OpenLayers.Pixel property gives │ │ │ │ + * the average location of the mouse/touch event. Its 'touches' │ │ │ │ + * property records clientX/clientY of each touches. │ │ │ │ */ │ │ │ │ - wildcarded: false, │ │ │ │ + last: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: first │ │ │ │ + * {Object} When waiting for double clicks, this object will store │ │ │ │ + * information about the first click in a two click sequence. │ │ │ │ + */ │ │ │ │ + first: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: srsInBBOX │ │ │ │ - * {Boolean} Include the SRS identifier in BBOX query string parameter. │ │ │ │ - * Default is false. If true and the layer has a projection object set, │ │ │ │ - * any BBOX filter will be serialized with a fifth item identifying the │ │ │ │ - * projection. E.g. bbox=-1000,-1000,1000,1000,EPSG:900913 │ │ │ │ + * Property: rightclickTimerId │ │ │ │ + * {Number} The id of the right mouse timeout waiting to clear the │ │ │ │ + * <delayedEvent>. │ │ │ │ */ │ │ │ │ - srsInBBOX: false, │ │ │ │ + rightclickTimerId: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Protocol.HTTP │ │ │ │ - * A class for giving layers generic HTTP protocol. │ │ │ │ - * │ │ │ │ + * Constructor: OpenLayers.Handler.Click │ │ │ │ + * Create a new click handler. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} The control that is making use of │ │ │ │ + * this handler. If a handler is being used without a control, the │ │ │ │ + * handler's setMap method must be overridden to deal properly with │ │ │ │ + * the map. │ │ │ │ + * callbacks - {Object} An object with keys corresponding to callbacks │ │ │ │ + * that will be called by the handler. The callbacks should │ │ │ │ + * expect to recieve a single argument, the click event. │ │ │ │ + * Callbacks for 'click' and 'dblclick' are supported. │ │ │ │ * options - {Object} Optional object whose properties will be set on the │ │ │ │ - * instance. │ │ │ │ - * │ │ │ │ - * Valid options include: │ │ │ │ - * url - {String} │ │ │ │ - * headers - {Object} │ │ │ │ - * params - {Object} URL parameters for GET requests │ │ │ │ - * format - {<OpenLayers.Format>} │ │ │ │ - * callback - {Function} │ │ │ │ - * scope - {Object} │ │ │ │ + * handler. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - this.params = {}; │ │ │ │ - this.headers = {}; │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ - │ │ │ │ - if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ - var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ - wildcarded: this.wildcarded, │ │ │ │ - srsInBBOX: this.srsInBBOX │ │ │ │ - }); │ │ │ │ - this.filterToParams = function(filter, params) { │ │ │ │ - return format.write(filter, params); │ │ │ │ - }; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Clean up the protocol. │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.params = null; │ │ │ │ - this.headers = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this); │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: filterToParams │ │ │ │ - * Optional method to translate an <OpenLayers.Filter> object into an object │ │ │ │ - * that can be serialized as request query string provided. If a custom │ │ │ │ - * method is not provided, the filter will be serialized using the │ │ │ │ - * <OpenLayers.Format.QueryStringFilter> class. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * filter - {<OpenLayers.Filter>} filter to convert. │ │ │ │ - * params - {Object} The parameters object. │ │ │ │ + * Method: touchmove │ │ │ │ + * Store position of last move, because touchend event can have │ │ │ │ + * an empty "touches" property. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} The resulting parameters object. │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ + touchmove: function(evt) { │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: read │ │ │ │ - * Construct a request for reading new features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * url - {String} Url for the request. │ │ │ │ - * params - {Object} Parameters to get serialized as a query string. │ │ │ │ - * headers - {Object} Headers to be set on the request. │ │ │ │ - * filter - {<OpenLayers.Filter>} Filter to get serialized as a │ │ │ │ - * query string. │ │ │ │ - * readWithPOST - {Boolean} If the request should be done with POST. │ │ │ │ + * Method: touchend │ │ │ │ + * Correctly set event xy property, and add lastTouches to have │ │ │ │ + * touches property from last touchstart or touchmove │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property │ │ │ │ - * references the HTTP request, this object is also passed to the │ │ │ │ - * callback function when the request completes, its "features" property │ │ │ │ - * is then populated with the features received from the server. │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ - options = options || {}; │ │ │ │ - options.params = OpenLayers.Util.applyDefaults( │ │ │ │ - options.params, this.options.params); │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - if (options.filter && this.filterToParams) { │ │ │ │ - options.params = this.filterToParams( │ │ │ │ - options.filter, options.params │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - var readWithPOST = (options.readWithPOST !== undefined) ? │ │ │ │ - options.readWithPOST : this.readWithPOST; │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - if (readWithPOST) { │ │ │ │ - var headers = options.headers || {}; │ │ │ │ - headers["Content-Type"] = "application/x-www-form-urlencoded"; │ │ │ │ - resp.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ - data: OpenLayers.Util.getParameterString(options.params), │ │ │ │ - headers: headers │ │ │ │ - }); │ │ │ │ - } else { │ │ │ │ - resp.priv = OpenLayers.Request.GET({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers │ │ │ │ - }); │ │ │ │ + touchend: function(evt) { │ │ │ │ + // touchstart may not have been allowed to propagate │ │ │ │ + if (this.down) { │ │ │ │ + evt.xy = this.last.xy; │ │ │ │ + evt.lastTouches = this.last.touches; │ │ │ │ + this.handleSingle(evt); │ │ │ │ + this.down = null; │ │ │ │ } │ │ │ │ - return resp; │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleRead │ │ │ │ - * Individual callbacks are created for read, create and update, should │ │ │ │ - * a subclass need to override each one separately. │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mousedown. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * the user callback. │ │ │ │ - * options - {Object} The user options passed to the read call. │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - handleRead: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + mousedown: function(evt) { │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: create │ │ │ │ - * Construct a request for writing newly created features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ - * │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouseup. Installed to support collection of right mouse events. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, whose "priv" property references the HTTP request, this │ │ │ │ - * object is also passed to the callback function when the request │ │ │ │ - * completes, its "features" property is then populated with the │ │ │ │ - * the features received from the server. │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - create: function(features, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + mouseup: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: features, │ │ │ │ - requestType: "create" │ │ │ │ - }); │ │ │ │ + // Collect right mouse clicks from the mouseup │ │ │ │ + // IE - ignores the second right click in mousedown so using │ │ │ │ + // mouseup instead │ │ │ │ + if (this.checkModifiers(evt) && this.control.handleRightClicks && │ │ │ │ + OpenLayers.Event.isRightClick(evt)) { │ │ │ │ + propagate = this.rightclick(evt); │ │ │ │ + } │ │ │ │ │ │ │ │ - resp.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleCreate, resp, options), │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(features) │ │ │ │ - }); │ │ │ │ + return propagate; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return resp; │ │ │ │ + /** │ │ │ │ + * Method: rightclick │ │ │ │ + * Handle rightclick. For a dblrightclick, we get two clicks so we need │ │ │ │ + * to always register for dblrightclick to properly handle single │ │ │ │ + * clicks. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ + */ │ │ │ │ + rightclick: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + //Second click received before timeout this must be │ │ │ │ + // a double click │ │ │ │ + this.clearTimer(); │ │ │ │ + this.callback('dblrightclick', [evt]); │ │ │ │ + return !this.stopDouble; │ │ │ │ + } else { │ │ │ │ + //Set the rightclickTimerId, send evt only if double is │ │ │ │ + // true else trigger single │ │ │ │ + var clickEvent = this['double'] ? │ │ │ │ + OpenLayers.Util.extend({}, evt) : │ │ │ │ + this.callback('rightclick', [evt]); │ │ │ │ + │ │ │ │ + var delayedRightCall = OpenLayers.Function.bind( │ │ │ │ + this.delayedRightCall, │ │ │ │ + this, │ │ │ │ + clickEvent │ │ │ │ + ); │ │ │ │ + this.rightclickTimerId = window.setTimeout( │ │ │ │ + delayedRightCall, this.delay │ │ │ │ + ); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return !this.stopSingle; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleCreate │ │ │ │ - * Called the the request issued by <create> is complete. May be overridden │ │ │ │ - * by subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the create call. │ │ │ │ + * Method: delayedRightCall │ │ │ │ + * Sets <rightclickTimerId> to null. And optionally triggers the │ │ │ │ + * rightclick callback if evt is set. │ │ │ │ */ │ │ │ │ - handleCreate: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + delayedRightCall: function(evt) { │ │ │ │ + this.rightclickTimerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback('rightclick', [evt]); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: update │ │ │ │ - * Construct a request updating modified feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ + * Method: click │ │ │ │ + * Handle click events from the browser. This is registered as a listener │ │ │ │ + * for click events and should not be called from other events in this │ │ │ │ + * handler. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, whose "priv" property references the HTTP request, this │ │ │ │ - * object is also passed to the callback function when the request │ │ │ │ - * completes, its "features" property is then populated with the │ │ │ │ - * the feature received from the server. │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ */ │ │ │ │ - update: function(feature, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var url = options.url || │ │ │ │ - feature.url || │ │ │ │ - this.options.url + "/" + feature.fid; │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + click: function(evt) { │ │ │ │ + if (!this.last) { │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + } │ │ │ │ + this.handleSingle(evt); │ │ │ │ + return !this.stopSingle; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: feature, │ │ │ │ - requestType: "update" │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: dblclick │ │ │ │ + * Handle dblclick. For a dblclick, we get two clicks in some browsers │ │ │ │ + * (FF) and one in others (IE). So we need to always register for │ │ │ │ + * dblclick to properly handle single clicks. This method is registered │ │ │ │ + * as a listener for the dblclick browser event. It should *not* be │ │ │ │ + * called by other methods in this handler. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Continue propagating this event. │ │ │ │ + */ │ │ │ │ + dblclick: function(evt) { │ │ │ │ + this.handleDouble(evt); │ │ │ │ + return !this.stopDouble; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var method = this.updateWithPOST ? "POST" : "PUT"; │ │ │ │ - resp.priv = OpenLayers.Request[method]({ │ │ │ │ - url: url, │ │ │ │ - callback: this.createCallback(this.handleUpdate, resp, options), │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(feature) │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: handleDouble │ │ │ │ + * Handle double-click sequence. │ │ │ │ + */ │ │ │ │ + handleDouble: function(evt) { │ │ │ │ + if (this.passesDblclickTolerance(evt)) { │ │ │ │ + if (this["double"]) { │ │ │ │ + this.callback("dblclick", [evt]); │ │ │ │ + } │ │ │ │ + // to prevent a dblclick from firing the click callback in IE │ │ │ │ + this.clearTimer(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - return resp; │ │ │ │ + /** │ │ │ │ + * Method: handleSingle │ │ │ │ + * Handle single click sequence. │ │ │ │ + */ │ │ │ │ + handleSingle: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + // already received a click │ │ │ │ + if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ + // touch device, no dblclick event - this may be a double │ │ │ │ + if (this["double"]) { │ │ │ │ + // on Android don't let the browser zoom on the page │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + } │ │ │ │ + this.handleDouble(evt); │ │ │ │ + } │ │ │ │ + // if we're not in a touch environment we clear the click timer │ │ │ │ + // if we've got a second touch, we'll get two touchend events │ │ │ │ + if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ + this.clearTimer(); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + // remember the first click info so we can compare to the second │ │ │ │ + this.first = this.getEventInfo(evt); │ │ │ │ + // set the timer, send evt only if single is true │ │ │ │ + //use a clone of the event object because it will no longer │ │ │ │ + //be a valid event object in IE in the timer callback │ │ │ │ + var clickEvent = this.single ? │ │ │ │ + OpenLayers.Util.extend({}, evt) : null; │ │ │ │ + this.queuePotentialClick(clickEvent); │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: handleUpdate │ │ │ │ - * Called the the request issued by <update> is complete. May be overridden │ │ │ │ - * by subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the update call. │ │ │ │ + /** │ │ │ │ + * Method: queuePotentialClick │ │ │ │ + * This method is separated out largely to make testing easier (so we │ │ │ │ + * don't have to override window.setTimeout) │ │ │ │ */ │ │ │ │ - handleUpdate: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + queuePotentialClick: function(evt) { │ │ │ │ + this.timerId = window.setTimeout( │ │ │ │ + OpenLayers.Function.bind(this.delayedCall, this, evt), │ │ │ │ + this.delay │ │ │ │ + ); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: delete │ │ │ │ - * Construct a request deleting a removed feature. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ - * options - {Object} Optional object for configuring the request. │ │ │ │ - * This object is modified and should not be reused. │ │ │ │ + * Method: passesTolerance │ │ │ │ + * Determine whether the event is within the optional pixel tolerance. Note │ │ │ │ + * that the pixel tolerance check only works if mousedown events get to │ │ │ │ + * the listeners registered here. If they are stopped by other elements, │ │ │ │ + * the <pixelTolerance> will have no effect here (this method will always │ │ │ │ + * return true). │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response> │ │ │ │ - * object, whose "priv" property references the HTTP request, this │ │ │ │ - * object is also passed to the callback function when the request │ │ │ │ - * completes. │ │ │ │ + * {Boolean} The click is within the pixel tolerance (if specified). │ │ │ │ */ │ │ │ │ - "delete": function(feature, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var url = options.url || │ │ │ │ - feature.url || │ │ │ │ - this.options.url + "/" + feature.fid; │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + passesTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ + passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ + // for touch environments, we also enforce that all touches │ │ │ │ + // start and end within the given tolerance to be considered a click │ │ │ │ + if (passes && this.touch && │ │ │ │ + this.down.touches.length === this.last.touches.length) { │ │ │ │ + // the touchend event doesn't come with touches, so we check │ │ │ │ + // down and last │ │ │ │ + for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ + if (this.getTouchDistance( │ │ │ │ + this.down.touches[i], │ │ │ │ + this.last.touches[i] │ │ │ │ + ) > this.pixelTolerance) { │ │ │ │ + passes = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return passes; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: feature, │ │ │ │ - requestType: "delete" │ │ │ │ - }); │ │ │ │ + /** │ │ │ │ + * Method: getTouchDistance │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The pixel displacement between two touches. │ │ │ │ + */ │ │ │ │ + getTouchDistance: function(from, to) { │ │ │ │ + return Math.sqrt( │ │ │ │ + Math.pow(from.clientX - to.clientX, 2) + │ │ │ │ + Math.pow(from.clientY - to.clientY, 2) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - var method = this.deleteWithPOST ? "POST" : "DELETE"; │ │ │ │ - var requestOptions = { │ │ │ │ - url: url, │ │ │ │ - callback: this.createCallback(this.handleDelete, resp, options), │ │ │ │ - headers: options.headers │ │ │ │ - }; │ │ │ │ - if (this.deleteWithPOST) { │ │ │ │ - requestOptions.data = this.format.write(feature); │ │ │ │ + /** │ │ │ │ + * Method: passesDblclickTolerance │ │ │ │ + * Determine whether the event is within the optional double-cick pixel │ │ │ │ + * tolerance. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The click is within the double-click pixel tolerance. │ │ │ │ + */ │ │ │ │ + passesDblclickTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.down && this.first) { │ │ │ │ + passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance; │ │ │ │ } │ │ │ │ - resp.priv = OpenLayers.Request[method](requestOptions); │ │ │ │ + return passes; │ │ │ │ + }, │ │ │ │ │ │ │ │ - return resp; │ │ │ │ + /** │ │ │ │ + * Method: clearTimer │ │ │ │ + * Clear the timer and set <timerId> to null. │ │ │ │ + */ │ │ │ │ + clearTimer: function() { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + } │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + window.clearTimeout(this.rightclickTimerId); │ │ │ │ + this.rightclickTimerId = null; │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleDelete │ │ │ │ - * Called the the request issued by <delete> is complete. May be overridden │ │ │ │ - * by subclasses. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the delete call. │ │ │ │ + * Method: delayedCall │ │ │ │ + * Sets <timerId> to null. And optionally triggers the click callback if │ │ │ │ + * evt is set. │ │ │ │ */ │ │ │ │ - handleDelete: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options); │ │ │ │ + delayedCall: function(evt) { │ │ │ │ + this.timerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback("click", [evt]); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: handleResponse │ │ │ │ - * Called by CRUD specific handlers. │ │ │ │ + * Method: getEventInfo │ │ │ │ + * This method allows us to store event information without storing the │ │ │ │ + * actual event. In touch devices (at least), the same event is │ │ │ │ + * modified between touchstart, touchmove, and touchend. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} The response object to pass to │ │ │ │ - * any user callback. │ │ │ │ - * options - {Object} The user options passed to the create, read, update, │ │ │ │ - * or delete call. │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with event related info. │ │ │ │ */ │ │ │ │ - handleResponse: function(resp, options) { │ │ │ │ - var request = resp.priv; │ │ │ │ - if (options.callback) { │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - // success │ │ │ │ - if (resp.requestType != "delete") { │ │ │ │ - resp.features = this.parseFeatures(request); │ │ │ │ - } │ │ │ │ - resp.code = OpenLayers.Protocol.Response.SUCCESS; │ │ │ │ - } else { │ │ │ │ - // failure │ │ │ │ - resp.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + getEventInfo: function(evt) { │ │ │ │ + var touches; │ │ │ │ + if (evt.touches) { │ │ │ │ + var len = evt.touches.length; │ │ │ │ + touches = new Array(len); │ │ │ │ + var touch; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + touch = evt.touches[i]; │ │ │ │ + touches[i] = { │ │ │ │ + clientX: touch.olClientX, │ │ │ │ + clientY: touch.olClientY │ │ │ │ + }; │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, resp); │ │ │ │ } │ │ │ │ + return { │ │ │ │ + xy: evt.xy, │ │ │ │ + touches: touches │ │ │ │ + }; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: parseFeatures │ │ │ │ - * Read HTTP response body and return features. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * request - {XMLHttpRequest} The request object │ │ │ │ + * APIMethod: deactivate │ │ │ │ + * Deactivate the handler. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Array({<OpenLayers.Feature.Vector>})} or │ │ │ │ - * {<OpenLayers.Feature.Vector>} Array of features or a single feature. │ │ │ │ + * {Boolean} The handler was successfully deactivated. │ │ │ │ */ │ │ │ │ - parseFeatures: function(request) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText; │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null; │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.down = null; │ │ │ │ + this.first = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ } │ │ │ │ - return this.format.read(doc); │ │ │ │ + return deactivated; │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/Navigation.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control/ZoomBox.js │ │ │ │ + * @requires OpenLayers/Control/DragPan.js │ │ │ │ + * @requires OpenLayers/Handler/MouseWheel.js │ │ │ │ + * @requires OpenLayers/Handler/Click.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.Navigation │ │ │ │ + * The navigation control handles map browsing with mouse events (dragging, │ │ │ │ + * double-clicking, and scrolling the wheel). Create a new navigation │ │ │ │ + * control with the <OpenLayers.Control.Navigation> control. │ │ │ │ + * │ │ │ │ + * Note that this control is added to the map by default (if no controls │ │ │ │ + * array is sent in the options object to the <OpenLayers.Map> │ │ │ │ + * constructor). │ │ │ │ + * │ │ │ │ + * Inherits: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: dragPan │ │ │ │ + * {<OpenLayers.Control.DragPan>} │ │ │ │ + */ │ │ │ │ + dragPan: null, │ │ │ │ + │ │ │ │ /** │ │ │ │ - * APIMethod: commit │ │ │ │ - * Iterate over each feature and take action based on the feature state. │ │ │ │ - * Possible actions are create, update and delete. │ │ │ │ - * │ │ │ │ + * APIProperty: dragPanOptions │ │ │ │ + * {Object} Options passed to the DragPan control. │ │ │ │ + */ │ │ │ │ + dragPanOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: pinchZoom │ │ │ │ + * {<OpenLayers.Control.PinchZoom>} │ │ │ │ + */ │ │ │ │ + pinchZoom: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: pinchZoomOptions │ │ │ │ + * {Object} Options passed to the PinchZoom control. │ │ │ │ + */ │ │ │ │ + pinchZoomOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: documentDrag │ │ │ │ + * {Boolean} Allow panning of the map by dragging outside map viewport. │ │ │ │ + * Default is false. │ │ │ │ + */ │ │ │ │ + documentDrag: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: zoomBox │ │ │ │ + * {<OpenLayers.Control.ZoomBox>} │ │ │ │ + */ │ │ │ │ + zoomBox: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomBoxEnabled │ │ │ │ + * {Boolean} Whether the user can draw a box to zoom │ │ │ │ + */ │ │ │ │ + zoomBoxEnabled: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomWheelEnabled │ │ │ │ + * {Boolean} Whether the mousewheel should zoom the map │ │ │ │ + */ │ │ │ │ + zoomWheelEnabled: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: mouseWheelOptions │ │ │ │ + * {Object} Options passed to the MouseWheel control (only useful if │ │ │ │ + * <zoomWheelEnabled> is set to true). Default is no options for maps │ │ │ │ + * with fractionalZoom set to true, otherwise │ │ │ │ + * {cumulative: false, interval: 50, maxDelta: 6} │ │ │ │ + */ │ │ │ │ + mouseWheelOptions: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: handleRightClicks │ │ │ │ + * {Boolean} Whether or not to handle right clicks. Default is false. │ │ │ │ + */ │ │ │ │ + handleRightClicks: false, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomBoxKeyMask │ │ │ │ + * {Integer} <OpenLayers.Handler> key code of the key, which has to be │ │ │ │ + * pressed, while drawing the zoom box with the mouse on the screen. │ │ │ │ + * You should probably set handleRightClicks to true if you use this │ │ │ │ + * with MOD_CTRL, to disable the context menu for machines which use │ │ │ │ + * CTRL-Click as a right click. │ │ │ │ + * Default: <OpenLayers.Handler.MOD_SHIFT> │ │ │ │ + */ │ │ │ │ + zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoActivate: true, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.Navigation │ │ │ │ + * Create a new navigation control │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * features - {Array({<OpenLayers.Feature.Vector>})} │ │ │ │ - * options - {Object} Optional object for setting up intermediate commit │ │ │ │ - * callbacks. │ │ │ │ - * │ │ │ │ - * Valid options: │ │ │ │ - * create - {Object} Optional object to be passed to the <create> method. │ │ │ │ - * update - {Object} Optional object to be passed to the <update> method. │ │ │ │ - * delete - {Object} Optional object to be passed to the <delete> method. │ │ │ │ - * callback - {Function} Optional function to be called when the commit │ │ │ │ - * is complete. │ │ │ │ - * scope - {Object} Optional object to be set as the scope of the callback. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Array(<OpenLayers.Protocol.Response>)} An array of response objects, │ │ │ │ - * one per request made to the server, each object's "priv" property │ │ │ │ - * references the corresponding HTTP request. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * the control │ │ │ │ */ │ │ │ │ - commit: function(features, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var resp = [], │ │ │ │ - nResponses = 0; │ │ │ │ + initialize: function(options) { │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // Divide up features before issuing any requests. This properly │ │ │ │ - // counts requests in the event that any responses come in before │ │ │ │ - // all requests have been issued. │ │ │ │ - var types = {}; │ │ │ │ - types[OpenLayers.State.INSERT] = []; │ │ │ │ - types[OpenLayers.State.UPDATE] = []; │ │ │ │ - types[OpenLayers.State.DELETE] = []; │ │ │ │ - var feature, list, requestFeatures = []; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - list = types[feature.state]; │ │ │ │ - if (list) { │ │ │ │ - list.push(feature); │ │ │ │ - requestFeatures.push(feature); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - // tally up number of requests │ │ │ │ - var nRequests = (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) + │ │ │ │ - types[OpenLayers.State.UPDATE].length + │ │ │ │ - types[OpenLayers.State.DELETE].length; │ │ │ │ + /** │ │ │ │ + * 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() { │ │ │ │ + this.deactivate(); │ │ │ │ │ │ │ │ - // This response will be sent to the final callback after all the others │ │ │ │ - // have been fired. │ │ │ │ - var success = true; │ │ │ │ - var finalResponse = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: requestFeatures │ │ │ │ - }); │ │ │ │ + if (this.dragPan) { │ │ │ │ + this.dragPan.destroy(); │ │ │ │ + } │ │ │ │ + this.dragPan = null; │ │ │ │ │ │ │ │ - function insertCallback(response) { │ │ │ │ - var len = response.features ? response.features.length : 0; │ │ │ │ - var fids = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - fids[i] = response.features[i].fid; │ │ │ │ - } │ │ │ │ - finalResponse.insertIds = fids; │ │ │ │ - callback.apply(this, [response]); │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.zoomBox.destroy(); │ │ │ │ } │ │ │ │ + this.zoomBox = null; │ │ │ │ │ │ │ │ - function callback(response) { │ │ │ │ - this.callUserCallback(response, options); │ │ │ │ - success = success && response.success(); │ │ │ │ - nResponses++; │ │ │ │ - if (nResponses >= nRequests) { │ │ │ │ - if (options.callback) { │ │ │ │ - finalResponse.code = success ? │ │ │ │ - OpenLayers.Protocol.Response.SUCCESS : │ │ │ │ - OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - options.callback.apply(options.scope, [finalResponse]); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.destroy(); │ │ │ │ } │ │ │ │ + this.pinchZoom = null; │ │ │ │ │ │ │ │ - // start issuing requests │ │ │ │ - var queue = types[OpenLayers.State.INSERT]; │ │ │ │ - if (queue.length > 0) { │ │ │ │ - resp.push(this.create( │ │ │ │ - queue, OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: insertCallback, │ │ │ │ - scope: this │ │ │ │ - }, options.create) │ │ │ │ - )); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + this.dragPan.activate(); │ │ │ │ + if (this.zoomWheelEnabled) { │ │ │ │ + this.handlers.wheel.activate(); │ │ │ │ } │ │ │ │ - queue = types[OpenLayers.State.UPDATE]; │ │ │ │ - for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ - resp.push(this.update( │ │ │ │ - queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: callback, │ │ │ │ - scope: this │ │ │ │ - }, options.update))); │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + if (this.zoomBoxEnabled) { │ │ │ │ + this.zoomBox.activate(); │ │ │ │ } │ │ │ │ - queue = types[OpenLayers.State.DELETE]; │ │ │ │ - for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ - resp.push(this["delete"]( │ │ │ │ - queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: callback, │ │ │ │ - scope: this │ │ │ │ - }, options["delete"]))); │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.activate(); │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.deactivate(); │ │ │ │ + } │ │ │ │ + this.zoomBox.deactivate(); │ │ │ │ + this.dragPan.deactivate(); │ │ │ │ + this.handlers.click.deactivate(); │ │ │ │ + this.handlers.wheel.deactivate(); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + // disable right mouse context menu for support of right click events │ │ │ │ + if (this.handleRightClicks) { │ │ │ │ + this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var clickCallbacks = { │ │ │ │ + 'click': this.defaultClick, │ │ │ │ + 'dblclick': this.defaultDblClick, │ │ │ │ + 'dblrightclick': this.defaultDblRightClick │ │ │ │ + }; │ │ │ │ + var clickOptions = { │ │ │ │ + 'double': true, │ │ │ │ + 'stopDouble': true │ │ │ │ + }; │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click( │ │ │ │ + this, clickCallbacks, clickOptions │ │ │ │ + ); │ │ │ │ + this.dragPan = new OpenLayers.Control.DragPan( │ │ │ │ + OpenLayers.Util.extend({ │ │ │ │ + map: this.map, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }, this.dragPanOptions) │ │ │ │ + ); │ │ │ │ + this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ + map: this.map, │ │ │ │ + keyMask: this.zoomBoxKeyMask │ │ │ │ + }); │ │ │ │ + this.dragPan.draw(); │ │ │ │ + this.zoomBox.draw(); │ │ │ │ + var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ + cumulative: false, │ │ │ │ + interval: 50, │ │ │ │ + maxDelta: 6 │ │ │ │ + }; │ │ │ │ + this.handlers.wheel = new OpenLayers.Handler.MouseWheel( │ │ │ │ + this, { │ │ │ │ + up: this.wheelUp, │ │ │ │ + down: this.wheelDown │ │ │ │ + }, │ │ │ │ + OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions) │ │ │ │ + ); │ │ │ │ + if (OpenLayers.Control.PinchZoom) { │ │ │ │ + this.pinchZoom = new OpenLayers.Control.PinchZoom( │ │ │ │ + OpenLayers.Util.extend({ │ │ │ │ + map: this.map │ │ │ │ + }, this.pinchZoomOptions)); │ │ │ │ } │ │ │ │ - return resp; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: abort │ │ │ │ - * Abort an ongoing request, the response object passed to │ │ │ │ - * this method must come from this HTTP protocol (as a result │ │ │ │ - * of a create, read, update, delete or commit operation). │ │ │ │ + * Method: defaultClick │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * response - {<OpenLayers.Protocol.Response>} │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - response.priv.abort(); │ │ │ │ + defaultClick: function(evt) { │ │ │ │ + if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ + this.map.zoomOut(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: callUserCallback │ │ │ │ - * This method is used from within the commit method each time an │ │ │ │ - * an HTTP response is received from the server, it is responsible │ │ │ │ - * for calling the user-supplied callbacks. │ │ │ │ - * │ │ │ │ + * Method: defaultDblClick │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * resp - {<OpenLayers.Protocol.Response>} │ │ │ │ - * options - {Object} The map of options passed to the commit call. │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - callUserCallback: function(resp, options) { │ │ │ │ - var opt = options[resp.requestType]; │ │ │ │ - if (opt && opt.callback) { │ │ │ │ - opt.callback.call(opt.scope, resp); │ │ │ │ - } │ │ │ │ + defaultDblClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom + 1, evt.xy); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Filter/Logical.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Filter.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Filter.Logical │ │ │ │ - * This class represents ogc:And, ogc:Or and ogc:Not rules. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Filter> │ │ │ │ - */ │ │ │ │ -OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ - │ │ │ │ /** │ │ │ │ - * APIProperty: filters │ │ │ │ - * {Array(<OpenLayers.Filter>)} Child filters for this filter. │ │ │ │ + * Method: defaultDblRightClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - filters: null, │ │ │ │ + defaultDblRightClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom - 1, evt.xy); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} type of logical operator. Available types are: │ │ │ │ - * - OpenLayers.Filter.Logical.AND = "&&"; │ │ │ │ - * - OpenLayers.Filter.Logical.OR = "||"; │ │ │ │ - * - OpenLayers.Filter.Logical.NOT = "!"; │ │ │ │ - */ │ │ │ │ - type: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Filter.Logical │ │ │ │ - * Creates a logical filter (And, Or, Not). │ │ │ │ + * Method: wheelChange │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * filter. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter.Logical>} │ │ │ │ + * evt - {Event} │ │ │ │ + * deltaZ - {Integer} │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - this.filters = []; │ │ │ │ - OpenLayers.Filter.prototype.initialize.apply(this, [options]); │ │ │ │ + wheelChange: function(evt, deltaZ) { │ │ │ │ + if (!this.map.fractionalZoom) { │ │ │ │ + deltaZ = Math.round(deltaZ); │ │ │ │ + } │ │ │ │ + var currentZoom = this.map.getZoom(), │ │ │ │ + newZoom = currentZoom + deltaZ; │ │ │ │ + newZoom = Math.max(newZoom, 0); │ │ │ │ + newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ + if (newZoom === currentZoom) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + this.map.zoomTo(newZoom, evt.xy); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - * Remove reference to child filters. │ │ │ │ + * Method: wheelUp │ │ │ │ + * User spun scroll wheel up │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * delta - {Integer} │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - this.filters = null; │ │ │ │ - OpenLayers.Filter.prototype.destroy.apply(this); │ │ │ │ + wheelUp: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || 1); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: evaluate │ │ │ │ - * Evaluates this filter in a specific context. │ │ │ │ + /** │ │ │ │ + * Method: wheelDown │ │ │ │ + * User spun scroll wheel down │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * context - {Object} Context to use in evaluating the filter. A vector │ │ │ │ - * feature may also be provided to evaluate feature attributes in │ │ │ │ - * comparison filters or geometries in spatial filters. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The filter applies. │ │ │ │ + * evt - {Event} │ │ │ │ + * delta - {Integer} │ │ │ │ */ │ │ │ │ - evaluate: function(context) { │ │ │ │ - var i, len; │ │ │ │ - switch (this.type) { │ │ │ │ - case OpenLayers.Filter.Logical.AND: │ │ │ │ - for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ - if (this.filters[i].evaluate(context) == false) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return true; │ │ │ │ + wheelDown: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || -1); │ │ │ │ + }, │ │ │ │ │ │ │ │ - case OpenLayers.Filter.Logical.OR: │ │ │ │ - for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ - if (this.filters[i].evaluate(context) == true) { │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ + /** │ │ │ │ + * Method: disableZoomBox │ │ │ │ + */ │ │ │ │ + disableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = false; │ │ │ │ + this.zoomBox.deactivate(); │ │ │ │ + }, │ │ │ │ │ │ │ │ - case OpenLayers.Filter.Logical.NOT: │ │ │ │ - return (!this.filters[0].evaluate(context)); │ │ │ │ + /** │ │ │ │ + * Method: enableZoomBox │ │ │ │ + */ │ │ │ │ + enableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.zoomBox.activate(); │ │ │ │ } │ │ │ │ - return undefined; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this filter. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter.Logical>} Clone of this filter. │ │ │ │ + * Method: disableZoomWheel │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - var filters = []; │ │ │ │ - for (var i = 0, len = this.filters.length; i < len; ++i) { │ │ │ │ - filters.push(this.filters[i].clone()); │ │ │ │ - } │ │ │ │ - return new OpenLayers.Filter.Logical({ │ │ │ │ - type: this.type, │ │ │ │ - filters: filters │ │ │ │ - }); │ │ │ │ + │ │ │ │ + disableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = false; │ │ │ │ + this.handlers.wheel.deactivate(); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Filter.Logical" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Method: enableZoomWheel │ │ │ │ + */ │ │ │ │ │ │ │ │ + enableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.wheel.activate(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ -OpenLayers.Filter.Logical.AND = "&&"; │ │ │ │ -OpenLayers.Filter.Logical.OR = "||"; │ │ │ │ -OpenLayers.Filter.Logical.NOT = "!"; │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Filter/Comparison.js │ │ │ │ + OpenLayers/Events/buttonclick.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Filter.js │ │ │ │ + * @requires OpenLayers/Events.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Filter.Comparison │ │ │ │ - * This class represents a comparison filter. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Filter> │ │ │ │ + * Class: OpenLayers.Events.buttonclick │ │ │ │ + * Extension event type for handling buttons on top of a dom element. This │ │ │ │ + * event type fires "buttonclick" on its <target> when a button was │ │ │ │ + * clicked. Buttons are detected by the "olButton" class. │ │ │ │ + * │ │ │ │ + * This event type makes sure that button clicks do not interfere with other │ │ │ │ + * events that are registered on the same <element>. │ │ │ │ + * │ │ │ │ + * Event types provided by this extension: │ │ │ │ + * - *buttonclick* Triggered when a button is clicked. Listeners receive an │ │ │ │ + * object with a *buttonElement* property referencing the dom element of │ │ │ │ + * the clicked button, and an *buttonXY* property with the click position │ │ │ │ + * relative to the button. │ │ │ │ */ │ │ │ │ -OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ +OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} type: type of the comparison. This is one of │ │ │ │ - * - OpenLayers.Filter.Comparison.EQUAL_TO = "=="; │ │ │ │ - * - OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!="; │ │ │ │ - * - OpenLayers.Filter.Comparison.LESS_THAN = "<"; │ │ │ │ - * - OpenLayers.Filter.Comparison.GREATER_THAN = ">"; │ │ │ │ - * - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; │ │ │ │ - * - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; │ │ │ │ - * - OpenLayers.Filter.Comparison.BETWEEN = ".."; │ │ │ │ - * - OpenLayers.Filter.Comparison.LIKE = "~"; │ │ │ │ - * - OpenLayers.Filter.Comparison.IS_NULL = "NULL"; │ │ │ │ + * Property: target │ │ │ │ + * {<OpenLayers.Events>} The events instance that the buttonclick event will │ │ │ │ + * be triggered on. │ │ │ │ */ │ │ │ │ - type: null, │ │ │ │ + target: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: property │ │ │ │ - * {String} │ │ │ │ - * name of the context property to compare │ │ │ │ + * Property: events │ │ │ │ + * {Array} Events to observe and conditionally stop from propagating when │ │ │ │ + * an element with the olButton class (or its olAlphaImg child) is │ │ │ │ + * clicked. │ │ │ │ */ │ │ │ │ - property: null, │ │ │ │ + events: [ │ │ │ │ + 'mousedown', 'mouseup', 'click', 'dblclick', │ │ │ │ + 'touchstart', 'touchmove', 'touchend', 'keydown' │ │ │ │ + ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: value │ │ │ │ - * {Number} or {String} │ │ │ │ - * comparison value for binary comparisons. In the case of a String, this │ │ │ │ - * can be a combination of text and propertyNames in the form │ │ │ │ - * "literal ${propertyName}" │ │ │ │ + * Property: startRegEx │ │ │ │ + * {RegExp} Regular expression to test Event.type for events that start │ │ │ │ + * a buttonclick sequence. │ │ │ │ */ │ │ │ │ - value: null, │ │ │ │ + startRegEx: /^mousedown|touchstart$/, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: matchCase │ │ │ │ - * {Boolean} Force case sensitive searches for EQUAL_TO and NOT_EQUAL_TO │ │ │ │ - * comparisons. The Filter Encoding 1.1 specification added a matchCase │ │ │ │ - * attribute to ogc:PropertyIsEqualTo and ogc:PropertyIsNotEqualTo │ │ │ │ - * elements. This property will be serialized with those elements only │ │ │ │ - * if using the v1.1.0 filter format. However, when evaluating filters │ │ │ │ - * here, the matchCase property will always be respected (for EQUAL_TO │ │ │ │ - * and NOT_EQUAL_TO). Default is true. │ │ │ │ + * Property: cancelRegEx │ │ │ │ + * {RegExp} Regular expression to test Event.type for events that cancel │ │ │ │ + * a buttonclick sequence. │ │ │ │ */ │ │ │ │ - matchCase: true, │ │ │ │ + cancelRegEx: /^touchmove$/, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: lowerBoundary │ │ │ │ - * {Number} or {String} │ │ │ │ - * lower boundary for between comparisons. In the case of a String, this │ │ │ │ - * can be a combination of text and propertyNames in the form │ │ │ │ - * "literal ${propertyName}" │ │ │ │ + * Property: completeRegEx │ │ │ │ + * {RegExp} Regular expression to test Event.type for events that complete │ │ │ │ + * a buttonclick sequence. │ │ │ │ */ │ │ │ │ - lowerBoundary: null, │ │ │ │ + completeRegEx: /^mouseup|touchend$/, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: upperBoundary │ │ │ │ - * {Number} or {String} │ │ │ │ - * upper boundary for between comparisons. In the case of a String, this │ │ │ │ - * can be a combination of text and propertyNames in the form │ │ │ │ - * "literal ${propertyName}" │ │ │ │ + * Property: startEvt │ │ │ │ + * {Event} The event that started the click sequence │ │ │ │ */ │ │ │ │ - upperBoundary: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Filter.Comparison │ │ │ │ - * Creates a comparison rule. │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Events.buttonclick │ │ │ │ + * Construct a buttonclick event type. Applications are not supposed to │ │ │ │ + * create instances of this class - they are created on demand by │ │ │ │ + * <OpenLayers.Events> instances. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object with properties to set on the │ │ │ │ - * rule │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter.Comparison>} │ │ │ │ + * target - {<OpenLayers.Events>} The events instance that the buttonclick │ │ │ │ + * event will be triggered on. │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Filter.prototype.initialize.apply(this, [options]); │ │ │ │ - // since matchCase on PropertyIsLike is not schema compliant, we only │ │ │ │ - // want to use this if explicitly asked for │ │ │ │ - if (this.type === OpenLayers.Filter.Comparison.LIKE && │ │ │ │ - options.matchCase === undefined) { │ │ │ │ - this.matchCase = null; │ │ │ │ + initialize: function(target) { │ │ │ │ + this.target = target; │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: evaluate │ │ │ │ - * Evaluates this filter in a specific context. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * context - {Object} Context to use in evaluating the filter. If a vector │ │ │ │ - * feature is provided, the feature.attributes will be used as context. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} The filter applies. │ │ │ │ + * Method: destroy │ │ │ │ */ │ │ │ │ - evaluate: function(context) { │ │ │ │ - if (context instanceof OpenLayers.Feature.Vector) { │ │ │ │ - context = context.attributes; │ │ │ │ - } │ │ │ │ - var result = false; │ │ │ │ - var got = context[this.property]; │ │ │ │ - var exp; │ │ │ │ - switch (this.type) { │ │ │ │ - case OpenLayers.Filter.Comparison.EQUAL_TO: │ │ │ │ - exp = this.value; │ │ │ │ - if (!this.matchCase && │ │ │ │ - typeof got == "string" && typeof exp == "string") { │ │ │ │ - result = (got.toUpperCase() == exp.toUpperCase()); │ │ │ │ - } else { │ │ │ │ - result = (got == exp); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.NOT_EQUAL_TO: │ │ │ │ - exp = this.value; │ │ │ │ - if (!this.matchCase && │ │ │ │ - typeof got == "string" && typeof exp == "string") { │ │ │ │ - result = (got.toUpperCase() != exp.toUpperCase()); │ │ │ │ - } else { │ │ │ │ - result = (got != exp); │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.LESS_THAN: │ │ │ │ - result = got < this.value; │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.GREATER_THAN: │ │ │ │ - result = got > this.value; │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO: │ │ │ │ - result = got <= this.value; │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO: │ │ │ │ - result = got >= this.value; │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.BETWEEN: │ │ │ │ - result = (got >= this.lowerBoundary) && │ │ │ │ - (got <= this.upperBoundary); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.LIKE: │ │ │ │ - var regexp = new RegExp(this.value, "gi"); │ │ │ │ - result = regexp.test(got); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Comparison.IS_NULL: │ │ │ │ - result = (got === null); │ │ │ │ - break; │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.unregister(this.events[i], this, this.buttonClick); │ │ │ │ } │ │ │ │ - return result; │ │ │ │ + delete this.target; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: value2regex │ │ │ │ - * Converts the value of this rule into a regular expression string, │ │ │ │ - * according to the wildcard characters specified. This method has to │ │ │ │ - * be called after instantiation of this class, if the value is not a │ │ │ │ - * regular expression already. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * wildCard - {Char} wildcard character in the above value, default │ │ │ │ - * is "*" │ │ │ │ - * singleChar - {Char} single-character wildcard in the above value │ │ │ │ - * default is "." │ │ │ │ - * escapeChar - {Char} escape character in the above value, default is │ │ │ │ - * "!" │ │ │ │ - * │ │ │ │ + * Method: getPressedButton │ │ │ │ + * Get the pressed button, if any. Returns undefined if no button │ │ │ │ + * was pressed. │ │ │ │ + * │ │ │ │ + * Arguments: │ │ │ │ + * element - {DOMElement} The event target. │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {String} regular expression string │ │ │ │ + * {DOMElement} The button element, or undefined. │ │ │ │ */ │ │ │ │ - value2regex: function(wildCard, singleChar, escapeChar) { │ │ │ │ - if (wildCard == ".") { │ │ │ │ - throw new Error("'.' is an unsupported wildCard character for " + │ │ │ │ - "OpenLayers.Filter.Comparison"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - │ │ │ │ - // set UMN MapServer defaults for unspecified parameters │ │ │ │ - wildCard = wildCard ? wildCard : "*"; │ │ │ │ - singleChar = singleChar ? singleChar : "."; │ │ │ │ - escapeChar = escapeChar ? escapeChar : "!"; │ │ │ │ - │ │ │ │ - this.value = this.value.replace( │ │ │ │ - new RegExp("\\" + escapeChar + "(.|$)", "g"), "\\$1"); │ │ │ │ - this.value = this.value.replace( │ │ │ │ - new RegExp("\\" + singleChar, "g"), "."); │ │ │ │ - this.value = this.value.replace( │ │ │ │ - new RegExp("\\" + wildCard, "g"), ".*"); │ │ │ │ - this.value = this.value.replace( │ │ │ │ - new RegExp("\\\\.\\*", "g"), "\\" + wildCard); │ │ │ │ - this.value = this.value.replace( │ │ │ │ - new RegExp("\\\\\\.", "g"), "\\" + singleChar); │ │ │ │ - │ │ │ │ - return this.value; │ │ │ │ + getPressedButton: function(element) { │ │ │ │ + var depth = 3, // limit the search depth │ │ │ │ + button; │ │ │ │ + do { │ │ │ │ + if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ + // hit! │ │ │ │ + button = element; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + element = element.parentNode; │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return button; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: regex2value │ │ │ │ - * Convert the value of this rule from a regular expression string into an │ │ │ │ - * ogc literal string using a wildCard of *, a singleChar of ., and an │ │ │ │ - * escape of !. Leaves the <value> property unmodified. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} A string value. │ │ │ │ + * Method: ignore │ │ │ │ + * Check for event target elements that should be ignored by OpenLayers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * element - {DOMElement} The event target. │ │ │ │ */ │ │ │ │ - regex2value: function() { │ │ │ │ - │ │ │ │ - var value = this.value; │ │ │ │ - │ │ │ │ - // replace ! with !! │ │ │ │ - value = value.replace(/!/g, "!!"); │ │ │ │ - │ │ │ │ - // replace \. with !. (watching out for \\.) │ │ │ │ - value = value.replace(/(\\)?\\\./g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "!."; │ │ │ │ - }); │ │ │ │ - │ │ │ │ - // replace \* with #* (watching out for \\*) │ │ │ │ - value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "!*"; │ │ │ │ - }); │ │ │ │ - │ │ │ │ - // replace \\ with \ │ │ │ │ - value = value.replace(/\\\\/g, "\\"); │ │ │ │ - │ │ │ │ - // convert .* to * (the sequence #.* is not allowed) │ │ │ │ - value = value.replace(/\.\*/g, "*"); │ │ │ │ - │ │ │ │ - return value; │ │ │ │ + ignore: function(element) { │ │ │ │ + var depth = 3, │ │ │ │ + ignore = false; │ │ │ │ + do { │ │ │ │ + if (element.nodeName.toLowerCase() === 'a') { │ │ │ │ + ignore = true; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + element = element.parentNode; │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return ignore; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * Clones this filter. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Filter.Comparison>} Clone of this filter. │ │ │ │ + * Method: buttonClick │ │ │ │ + * Check if a button was clicked, and fire the buttonclick event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - clone: function() { │ │ │ │ - return OpenLayers.Util.extend(new OpenLayers.Filter.Comparison(), this); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Filter.Comparison" │ │ │ │ -}); │ │ │ │ + buttonClick: function(evt) { │ │ │ │ + var propagate = true, │ │ │ │ + element = OpenLayers.Event.element(evt); │ │ │ │ + if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ + // was a button pressed? │ │ │ │ + var button = this.getPressedButton(element); │ │ │ │ + if (button) { │ │ │ │ + if (evt.type === "keydown") { │ │ │ │ + switch (evt.keyCode) { │ │ │ │ + case OpenLayers.Event.KEY_RETURN: │ │ │ │ + case OpenLayers.Event.KEY_SPACE: │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button │ │ │ │ + }); │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } else if (this.startEvt) { │ │ │ │ + if (this.completeRegEx.test(evt.type)) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ + var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ + var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ + var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ + pos[0] = pos[0] - scrollLeft; │ │ │ │ + pos[1] = pos[1] - scrollTop; │ │ │ │ │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button, │ │ │ │ + buttonXY: { │ │ │ │ + x: this.startEvt.clientX - pos[0], │ │ │ │ + y: this.startEvt.clientY - pos[1] │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + if (this.cancelRegEx.test(evt.type)) { │ │ │ │ + delete this.startEvt; │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + } │ │ │ │ + if (this.startRegEx.test(evt.type)) { │ │ │ │ + this.startEvt = evt; │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ + delete this.startEvt; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return propagate; │ │ │ │ + } │ │ │ │ │ │ │ │ -OpenLayers.Filter.Comparison.EQUAL_TO = "=="; │ │ │ │ -OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!="; │ │ │ │ -OpenLayers.Filter.Comparison.LESS_THAN = "<"; │ │ │ │ -OpenLayers.Filter.Comparison.GREATER_THAN = ">"; │ │ │ │ -OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; │ │ │ │ -OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; │ │ │ │ -OpenLayers.Filter.Comparison.BETWEEN = ".."; │ │ │ │ -OpenLayers.Filter.Comparison.LIKE = "~"; │ │ │ │ -OpenLayers.Filter.Comparison.IS_NULL = "NULL"; │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Popup.js │ │ │ │ + OpenLayers/Control/LayerSwitcher.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Lang.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * 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 <OpenLayers.Marker>. Popup's don't require their own │ │ │ │ - * layer and are added the the map using the <OpenLayers.Map.addPopup> │ │ │ │ - * method. │ │ │ │ + * Class: OpenLayers.Control.LayerSwitcher │ │ │ │ + * The LayerSwitcher control displays a table of contents for the map. This │ │ │ │ + * allows the user interface to switch between BaseLasyers and to show or hide │ │ │ │ + * Overlays. By default the switcher is shown minimized on the right edge of │ │ │ │ + * the map, the user may expand it by clicking on the handle. │ │ │ │ * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * popup = new OpenLayers.Popup("chicken", │ │ │ │ - * new OpenLayers.LonLat(5,40), │ │ │ │ - * new OpenLayers.Size(200,200), │ │ │ │ - * "example popup", │ │ │ │ - * true); │ │ │ │ - * │ │ │ │ - * map.addPopup(popup); │ │ │ │ - * (end) │ │ │ │ + * To create the LayerSwitcher outside of the map, pass the Id of a html div │ │ │ │ + * as the first argument to the constructor. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: events │ │ │ │ - * {<OpenLayers.Events>} custom event manager │ │ │ │ - */ │ │ │ │ - events: null, │ │ │ │ - │ │ │ │ - /** Property: id │ │ │ │ - * {String} the unique identifier assigned to this popup. │ │ │ │ - */ │ │ │ │ - id: "", │ │ │ │ +OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: lonlat │ │ │ │ - * {<OpenLayers.LonLat>} the position of this popup on the map │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - lonlat: null, │ │ │ │ + layerStates: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: div │ │ │ │ - * {DOMElement} the div that contains this popup. │ │ │ │ - */ │ │ │ │ - div: null, │ │ │ │ + // DOM Elements │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: contentSize │ │ │ │ - * {<OpenLayers.Size>} the width and height of the content. │ │ │ │ + /** │ │ │ │ + * Property: layersDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - contentSize: null, │ │ │ │ + layersDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: size │ │ │ │ - * {<OpenLayers.Size>} the width and height of the popup. │ │ │ │ + /** │ │ │ │ + * Property: baseLayersDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - size: null, │ │ │ │ + baseLayersDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: contentHTML │ │ │ │ - * {String} An HTML string for this popup to display. │ │ │ │ + /** │ │ │ │ + * Property: baseLayers │ │ │ │ + * {Array(Object)} │ │ │ │ */ │ │ │ │ - contentHTML: null, │ │ │ │ + baseLayers: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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) │ │ │ │ + /** │ │ │ │ + * Property: dataLbl │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - opacity: "", │ │ │ │ + dataLbl: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: border │ │ │ │ - * {String} the border size of the popup. (eg 2px) │ │ │ │ + /** │ │ │ │ + * Property: dataLayersDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - border: "", │ │ │ │ + dataLayersDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: contentDiv │ │ │ │ - * {DOMElement} a reference to the element that holds the content of │ │ │ │ - * the div. │ │ │ │ + /** │ │ │ │ + * Property: dataLayers │ │ │ │ + * {Array(Object)} │ │ │ │ */ │ │ │ │ - contentDiv: null, │ │ │ │ + dataLayers: 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 │ │ │ │ + /** │ │ │ │ + * Property: minimizeDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - closeDiv: null, │ │ │ │ + minimizeDiv: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: autoSize │ │ │ │ - * {Boolean} Resize the popup to auto-fit the contents. │ │ │ │ - * Default is false. │ │ │ │ + /** │ │ │ │ + * Property: maximizeDiv │ │ │ │ + * {DOMElement} │ │ │ │ */ │ │ │ │ - autoSize: false, │ │ │ │ + maximizeDiv: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: minSize │ │ │ │ - * {<OpenLayers.Size>} Minimum size allowed for the popup's contents. │ │ │ │ + * APIProperty: ascending │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - minSize: null, │ │ │ │ + ascending: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: maxSize │ │ │ │ - * {<OpenLayers.Size>} Maximum size allowed for the popup's contents. │ │ │ │ + * Constructor: OpenLayers.Control.LayerSwitcher │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} │ │ │ │ */ │ │ │ │ - maxSize: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + this.layerStates = []; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: displayClass │ │ │ │ - * {String} The CSS class of the popup. │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ */ │ │ │ │ - displayClass: "olPopup", │ │ │ │ + destroy: function() { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: contentDisplayClass │ │ │ │ - * {String} The CSS class of the popup content div. │ │ │ │ - */ │ │ │ │ - contentDisplayClass: "olPopupContent", │ │ │ │ + //clear out layers info and unregister their events │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: padding │ │ │ │ - * {int or <OpenLayers.Bounds>} 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, │ │ │ │ + this.map.events.un({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + addlayer: this.redraw, │ │ │ │ + changelayer: this.redraw, │ │ │ │ + removelayer: this.redraw, │ │ │ │ + changebaselayer: this.redraw, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: disableFirefoxOverflowHack │ │ │ │ - * {Boolean} The hack for overflow in Firefox causes all elements │ │ │ │ - * to be re-drawn, which causes Flash elements to be │ │ │ │ - * re-initialized, which is troublesome. │ │ │ │ - * With this property the hack can be disabled. │ │ │ │ - */ │ │ │ │ - disableFirefoxOverflowHack: false, │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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 <OpenLayers.Bounds> object. │ │ │ │ + * Method: setMap │ │ │ │ + * │ │ │ │ + * Properties: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ */ │ │ │ │ - fixPadding: function() { │ │ │ │ - if (typeof this.padding == "number") { │ │ │ │ - this.padding = new OpenLayers.Bounds( │ │ │ │ - this.padding, this.padding, this.padding, this.padding │ │ │ │ - ); │ │ │ │ + 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 │ │ │ │ + }); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: panMapIfOutOfView │ │ │ │ - * {Boolean} When drawn, pan map such that the entire popup is visible in │ │ │ │ - * the current viewport (if necessary). │ │ │ │ - * Default is false. │ │ │ │ + * Method: draw │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A reference to the DIV DOMElement containing the │ │ │ │ + * switcher tabs. │ │ │ │ */ │ │ │ │ - panMapIfOutOfView: false, │ │ │ │ + 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; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: keepInMap │ │ │ │ - * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ - * contrain the popup such that it always fits in the available map │ │ │ │ - * space. By default, this is not set on the base class. If you are │ │ │ │ - * creating popups that are near map edges and not allowing pannning, │ │ │ │ - * and especially if you have a popup which has a │ │ │ │ - * fixedRelativePosition, setting this to false may be a smart thing to │ │ │ │ - * do. Subclasses may want to override this setting. │ │ │ │ - * │ │ │ │ - * Default is false. │ │ │ │ + * Method: onButtonClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - keepInMap: false, │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.minimizeDiv) { │ │ │ │ + this.minimizeControl(); │ │ │ │ + } else if (button === this.maximizeDiv) { │ │ │ │ + this.maximizeControl(); │ │ │ │ + } else if (button._layerSwitcher === this.id) { │ │ │ │ + if (button["for"]) { │ │ │ │ + button = document.getElementById(button["for"]); │ │ │ │ + } │ │ │ │ + if (!button.disabled) { │ │ │ │ + if (button.type == "radio") { │ │ │ │ + button.checked = true; │ │ │ │ + this.map.setBaseLayer(this.map.getLayer(button._layer)); │ │ │ │ + } else { │ │ │ │ + button.checked = !button.checked; │ │ │ │ + this.updateMap(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: closeOnMove │ │ │ │ - * {Boolean} When map pans, close the popup. │ │ │ │ - * Default is false. │ │ │ │ + * 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} │ │ │ │ */ │ │ │ │ - closeOnMove: false, │ │ │ │ + clearLayersArray: function(layersType) { │ │ │ │ + this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ + this[layersType + "Layers"] = []; │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {<OpenLayers.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 - {<OpenLayers.LonLat>} The position on the map the popup will │ │ │ │ - * be shown. │ │ │ │ - * contentSize - {<OpenLayers.Size>} The size of the content. │ │ │ │ - * contentHTML - {String} An HTML string 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. │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ - if (id == null) { │ │ │ │ - id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - this.id = id; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - │ │ │ │ - this.contentSize = (contentSize != null) ? contentSize : │ │ │ │ - new OpenLayers.Size( │ │ │ │ - OpenLayers.Popup.WIDTH, │ │ │ │ - OpenLayers.Popup.HEIGHT); │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML; │ │ │ │ + checkRedraw: function() { │ │ │ │ + if (!this.layerStates.length || │ │ │ │ + (this.map.layers.length != this.layerStates.length)) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ - 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 = this.displayClass; │ │ │ │ - │ │ │ │ - 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.contentSize.clone(), │ │ │ │ - null, "relative"); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass; │ │ │ │ - this.groupDiv.appendChild(this.contentDiv); │ │ │ │ - this.div.appendChild(this.groupDiv); │ │ │ │ │ │ │ │ - if (closeBox) { │ │ │ │ - this.addCloseBox(closeBoxCallback); │ │ │ │ + for (var i = 0, len = this.layerStates.length; i < len; 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)) { │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ } │ │ │ │ │ │ │ │ - this.registerEvents(); │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - * nullify references to prevent circular references and memory leaks │ │ │ │ + /** │ │ │ │ + * 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 │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ + 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; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.size = null; │ │ │ │ - this.contentHTML = null; │ │ │ │ + //clear out previous layers │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ │ │ │ │ - this.backgroundColor = null; │ │ │ │ - this.opacity = null; │ │ │ │ - this.border = null; │ │ │ │ + var containsOverlays = false; │ │ │ │ + var containsBaseLayers = false; │ │ │ │ │ │ │ │ - if (this.closeOnMove && this.map) { │ │ │ │ - this.map.events.unregister("movestart", this, this.hide); │ │ │ │ + // 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. │ │ │ │ + var len = this.map.layers.length; │ │ │ │ + this.layerStates = new Array(len); │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + this.layerStates[i] = { │ │ │ │ + 'name': layer.name, │ │ │ │ + 'visibility': layer.visibility, │ │ │ │ + 'inRange': layer.inRange, │ │ │ │ + 'id': layer.id │ │ │ │ + }; │ │ │ │ } │ │ │ │ │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - │ │ │ │ - if (this.closeDiv) { │ │ │ │ - OpenLayers.Event.stopObservingElement(this.closeDiv); │ │ │ │ - this.groupDiv.removeChild(this.closeDiv); │ │ │ │ + var layers = this.map.layers.slice(); │ │ │ │ + if (!this.ascending) { │ │ │ │ + layers.reverse(); │ │ │ │ } │ │ │ │ - this.closeDiv = null; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + var baseLayer = layer.isBaseLayer; │ │ │ │ │ │ │ │ - this.div.removeChild(this.groupDiv); │ │ │ │ - this.groupDiv = null; │ │ │ │ + if (layer.displayInLayerSwitcher) { │ │ │ │ │ │ │ │ - if (this.map != null) { │ │ │ │ - this.map.removePopup(this); │ │ │ │ - } │ │ │ │ - this.map = null; │ │ │ │ - this.div = null; │ │ │ │ + if (baseLayer) { │ │ │ │ + containsBaseLayers = true; │ │ │ │ + } else { │ │ │ │ + containsOverlays = true; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.autoSize = null; │ │ │ │ - this.minSize = null; │ │ │ │ - this.maxSize = null; │ │ │ │ - this.padding = null; │ │ │ │ - this.panMapIfOutOfView = null; │ │ │ │ - }, │ │ │ │ + // 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(); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: draw │ │ │ │ - * Constructs the elements that make up the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} 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); │ │ │ │ - } │ │ │ │ - } │ │ │ │ + // create input element │ │ │ │ + var inputElem = document.createElement("input"), │ │ │ │ + // The input shall have an id attribute so we can use │ │ │ │ + // labels to interact with them. │ │ │ │ + inputId = OpenLayers.Util.createUniqueID( │ │ │ │ + this.id + "_input_" │ │ │ │ + ); │ │ │ │ │ │ │ │ - // this assumes that this.map already exists, which is okay because │ │ │ │ - // this.draw is only called once the popup has been added to the map. │ │ │ │ - if (this.closeOnMove) { │ │ │ │ - this.map.events.register("movestart", this, this.hide); │ │ │ │ - } │ │ │ │ + inputElem.id = inputId; │ │ │ │ + inputElem.name = (baseLayer) ? this.id + "_baseLayers" : layer.name; │ │ │ │ + inputElem.type = (baseLayer) ? "radio" : "checkbox"; │ │ │ │ + inputElem.value = layer.name; │ │ │ │ + inputElem.checked = checked; │ │ │ │ + inputElem.defaultChecked = checked; │ │ │ │ + inputElem.className = "olButton"; │ │ │ │ + inputElem._layer = layer.id; │ │ │ │ + inputElem._layerSwitcher = this.id; │ │ │ │ │ │ │ │ - //listen to movestart, moveend to disable overflow (FF bug) │ │ │ │ - if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == '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"; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + inputElem.disabled = true; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - this.map.events.register("moveend", this, function() { │ │ │ │ - var oldOverflow = this.contentDiv._oldOverflow; │ │ │ │ - if (oldOverflow) { │ │ │ │ - this.contentDiv.style.overflow = oldOverflow; │ │ │ │ - this.contentDiv._oldOverflow = null; │ │ │ │ + │ │ │ │ + // create span │ │ │ │ + var labelSpan = document.createElement("label"); │ │ │ │ + // this isn't the DOM attribute 'for', but an arbitrary name we │ │ │ │ + // use to find the appropriate input element in <onButtonClick> │ │ │ │ + labelSpan["for"] = inputElem.id; │ │ │ │ + OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ + labelSpan._layer = layer.id; │ │ │ │ + labelSpan._layerSwitcher = this.id; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + labelSpan.style.color = "gray"; │ │ │ │ } │ │ │ │ - }); │ │ │ │ - } │ │ │ │ + labelSpan.innerHTML = layer.name; │ │ │ │ + labelSpan.style.verticalAlign = (baseLayer) ? "bottom" : │ │ │ │ + "baseline"; │ │ │ │ + // create line break │ │ │ │ + var br = document.createElement("br"); │ │ │ │ │ │ │ │ - this.moveTo(px); │ │ │ │ - if (!this.autoSize && !this.size) { │ │ │ │ - this.setSize(this.contentSize); │ │ │ │ - } │ │ │ │ - this.setBackgroundColor(); │ │ │ │ - this.setOpacity(); │ │ │ │ - this.setBorder(); │ │ │ │ - this.setContentHTML(); │ │ │ │ │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView(); │ │ │ │ + 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: updatePosition │ │ │ │ - * if the popup has a lonlat and its map members set, │ │ │ │ - * then have it move itself to its proper position │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - updatePosition: function() { │ │ │ │ - if ((this.lonlat) && (this.map)) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - if (px) { │ │ │ │ - this.moveTo(px); │ │ │ │ + updateMap: function() { │ │ │ │ + │ │ │ │ + // set the newly selected base layer │ │ │ │ + for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.baseLayers[i]; │ │ │ │ + if (layerEntry.inputElem.checked) { │ │ │ │ + this.map.setBaseLayer(layerEntry.layer, false); │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: moveTo │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} 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"; │ │ │ │ + // set the correct visibilities for the overlays │ │ │ │ + for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.dataLayers[i]; │ │ │ │ + layerEntry.layer.setVisibility(layerEntry.inputElem.checked); │ │ │ │ } │ │ │ │ + │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: visible │ │ │ │ + * Method: maximizeControl │ │ │ │ + * Set up the labels and divs for the control │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} Boolean indicating whether or not the popup is visible │ │ │ │ + * Parameters: │ │ │ │ + * e - {Event} │ │ │ │ */ │ │ │ │ - visible: function() { │ │ │ │ - return OpenLayers.Element.visible(this.div); │ │ │ │ - }, │ │ │ │ + maximizeControl: function(e) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: toggle │ │ │ │ - * Toggles visibility of the popup. │ │ │ │ - */ │ │ │ │ - toggle: function() { │ │ │ │ - if (this.visible()) { │ │ │ │ - this.hide(); │ │ │ │ - } else { │ │ │ │ - this.show(); │ │ │ │ + // set the div's width and height to empty values, so │ │ │ │ + // the div dimensions can be controlled by CSS │ │ │ │ + this.div.style.width = ""; │ │ │ │ + this.div.style.height = ""; │ │ │ │ + │ │ │ │ + this.showControls(false); │ │ │ │ + │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: show │ │ │ │ - * Makes the popup visible. │ │ │ │ + * Method: minimizeControl │ │ │ │ + * Hide all the contents of the control, shrink the size, │ │ │ │ + * add the maximize icon │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * e - {Event} │ │ │ │ */ │ │ │ │ - show: function() { │ │ │ │ - this.div.style.display = ''; │ │ │ │ + minimizeControl: function(e) { │ │ │ │ │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView(); │ │ │ │ + // to minimize the control we set its div's width │ │ │ │ + // and height to 0px, we cannot just set "display" │ │ │ │ + // to "none" because it would hide the maximize │ │ │ │ + // div │ │ │ │ + this.div.style.width = "0px"; │ │ │ │ + this.div.style.height = "0px"; │ │ │ │ + │ │ │ │ + this.showControls(true); │ │ │ │ + │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: hide │ │ │ │ - * Makes the popup invisible. │ │ │ │ + * Method: showControls │ │ │ │ + * Hide/Show all LayerSwitcher controls depending on whether we are │ │ │ │ + * minimized or not │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * minimize - {Boolean} │ │ │ │ */ │ │ │ │ - hide: function() { │ │ │ │ - this.div.style.display = 'none'; │ │ │ │ + showControls: function(minimize) { │ │ │ │ + │ │ │ │ + this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ + this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ + │ │ │ │ + this.layersDiv.style.display = minimize ? "none" : ""; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setSize │ │ │ │ - * Used to adjust the size of the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ - * contents div (in pixels). │ │ │ │ + * Method: loadContents │ │ │ │ + * Set up the labels and divs for the control │ │ │ │ */ │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - this.size = contentSize.clone(); │ │ │ │ + loadContents: function() { │ │ │ │ │ │ │ │ - // 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; │ │ │ │ + // layers list div │ │ │ │ + this.layersDiv = document.createElement("div"); │ │ │ │ + this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ + OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ │ │ │ │ - // take into account the popup's 'padding' property │ │ │ │ - this.fixPadding(); │ │ │ │ - wPadding += this.padding.left + this.padding.right; │ │ │ │ - hPadding += this.padding.top + this.padding.bottom; │ │ │ │ + this.baseLbl = document.createElement("div"); │ │ │ │ + this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ │ │ │ │ - // make extra space for the close div │ │ │ │ - if (this.closeDiv) { │ │ │ │ - var closeDivWidth = parseInt(this.closeDiv.style.width); │ │ │ │ - wPadding += closeDivWidth + contentDivPadding.right; │ │ │ │ - } │ │ │ │ + this.baseLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ │ │ │ │ - //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; │ │ │ │ + this.dataLbl = document.createElement("div"); │ │ │ │ + this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ │ │ │ │ - //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.BROWSER_NAME == "msie") { │ │ │ │ - this.contentSize.w += │ │ │ │ - contentDivPadding.left + contentDivPadding.right; │ │ │ │ - this.contentSize.h += │ │ │ │ - contentDivPadding.bottom + contentDivPadding.top; │ │ │ │ - } │ │ │ │ + this.dataLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ │ │ │ │ - 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"; │ │ │ │ + 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); │ │ │ │ + │ │ │ │ + // maximize button div │ │ │ │ + var img = OpenLayers.Util.getImageLocation('layer-switcher-maximize.png'); │ │ │ │ + this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + "OpenLayers_Control_MaximizeDiv", │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + img, │ │ │ │ + "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ + this.maximizeDiv.style.display = "none"; │ │ │ │ + │ │ │ │ + this.div.appendChild(this.maximizeDiv); │ │ │ │ + │ │ │ │ + // minimize button div │ │ │ │ + var img = OpenLayers.Util.getImageLocation('layer-switcher-minimize.png'); │ │ │ │ + this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( │ │ │ │ + "OpenLayers_Control_MinimizeDiv", │ │ │ │ + null, │ │ │ │ + null, │ │ │ │ + img, │ │ │ │ + "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ + this.minimizeDiv.style.display = "none"; │ │ │ │ + │ │ │ │ + this.div.appendChild(this.minimizeDiv); │ │ │ │ }, │ │ │ │ │ │ │ │ + CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/Panel.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.Panel │ │ │ │ + * The Panel control is a container for other controls. With it toolbars │ │ │ │ + * may be composed. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ /** │ │ │ │ - * APIMethod: updateSize │ │ │ │ - * Auto size the popup so that it precisely fits its contents (as │ │ │ │ - * determined by this.contentDiv.innerHTML). Popup size will, of │ │ │ │ - * course, be limited by the available space on the current map │ │ │ │ + * Property: controls │ │ │ │ + * {Array(<OpenLayers.Control>)} │ │ │ │ */ │ │ │ │ - updateSize: function() { │ │ │ │ + controls: null, │ │ │ │ │ │ │ │ - // determine actual render dimensions of the contents by putting its │ │ │ │ - // contents into a fake contentDiv (for the CSS) and then measuring it │ │ │ │ - var preparedHTML = "<div class='" + this.contentDisplayClass + "'>" + │ │ │ │ - this.contentDiv.innerHTML + │ │ │ │ - "</div>"; │ │ │ │ + /** │ │ │ │ + * APIProperty: autoActivate │ │ │ │ + * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ + * true. │ │ │ │ + */ │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ - var containerElement = (this.map) ? this.map.div : document.body; │ │ │ │ - var realSize = OpenLayers.Util.getRenderedDimensions( │ │ │ │ - preparedHTML, null, { │ │ │ │ - displayClass: this.displayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - } │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * APIProperty: defaultControl │ │ │ │ + * {<OpenLayers.Control>} The control which is activated when the control is │ │ │ │ + * activated (turned on), which also happens at instantiation. │ │ │ │ + * If <saveState> is true, <defaultControl> will be nullified after the │ │ │ │ + * first activation of the panel. │ │ │ │ + */ │ │ │ │ + defaultControl: null, │ │ │ │ │ │ │ │ - // is the "real" size of the div is safe to display in our map? │ │ │ │ - var safeSize = this.getSafeContentSize(realSize); │ │ │ │ + /** │ │ │ │ + * APIProperty: saveState │ │ │ │ + * {Boolean} If set to true, the active state of this panel's controls will │ │ │ │ + * be stored on panel deactivation, and restored on reactivation. Default │ │ │ │ + * is false. │ │ │ │ + */ │ │ │ │ + saveState: false, │ │ │ │ │ │ │ │ - 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; │ │ │ │ + /** │ │ │ │ + * APIProperty: allowDepress │ │ │ │ + * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can │ │ │ │ + * be deactivated by clicking the icon that represents them. Default │ │ │ │ + * is false. │ │ │ │ + */ │ │ │ │ + allowDepress: false, │ │ │ │ │ │ │ │ - } else { │ │ │ │ + /** │ │ │ │ + * Property: activeState │ │ │ │ + * {Object} stores the active state of this panel's controls. │ │ │ │ + */ │ │ │ │ + activeState: null, │ │ │ │ │ │ │ │ - // make a new 'size' object with the clipped dimensions │ │ │ │ - // set or null if not clipped. │ │ │ │ - var fixedSize = { │ │ │ │ - w: (safeSize.w < realSize.w) ? safeSize.w : null, │ │ │ │ - h: (safeSize.h < realSize.h) ? safeSize.h : null │ │ │ │ - }; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.Panel │ │ │ │ + * Create a new control panel. │ │ │ │ + * │ │ │ │ + * Each control in the panel is represented by an icon. When clicking │ │ │ │ + * on an icon, the <activateControl> method is called. │ │ │ │ + * │ │ │ │ + * Specific properties for controls on a panel: │ │ │ │ + * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>, │ │ │ │ + * <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>. │ │ │ │ + * If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed. │ │ │ │ + * title - {string} Text displayed when mouse is over the icon that │ │ │ │ + * represents the control. │ │ │ │ + * │ │ │ │ + * The <OpenLayers.Control.type> of a control determines the behavior when │ │ │ │ + * clicking its icon: │ │ │ │ + * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other │ │ │ │ + * controls of this type in the same panel are deactivated. This is │ │ │ │ + * the default type. │ │ │ │ + * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is │ │ │ │ + * toggled. │ │ │ │ + * <OpenLayers.Control.TYPE_BUTTON> - The │ │ │ │ + * <OpenLayers.Control.Button.trigger> method of the control is called, │ │ │ │ + * but its active state is not changed. │ │ │ │ + * │ │ │ │ + * If a control is <OpenLayers.Control.active>, it will be drawn with the │ │ │ │ + * olControl[Name]ItemActive class, otherwise with the │ │ │ │ + * olControl[Name]ItemInactive class. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} An optional object whose properties will be used │ │ │ │ + * to extend the control. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.controls = []; │ │ │ │ + this.activeState = {}; │ │ │ │ + }, │ │ │ │ │ │ │ │ - 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( │ │ │ │ - preparedHTML, fixedSize, { │ │ │ │ - displayClass: this.contentDisplayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - } │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * APIMethod: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ + ctl = this.controls[i]; │ │ │ │ + if (ctl.events) { │ │ │ │ + ctl.events.un({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + ctl.panel_div = null; │ │ │ │ + } │ │ │ │ + this.activeState = null; │ │ │ │ + }, │ │ │ │ │ │ │ │ - //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; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIMethod: activate │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + if (control === this.defaultControl || │ │ │ │ + (this.saveState && this.activeState[control.id])) { │ │ │ │ + control.activate(); │ │ │ │ } │ │ │ │ - │ │ │ │ - newSize = this.getSafeContentSize(clippedSize); │ │ │ │ } │ │ │ │ + if (this.saveState === true) { │ │ │ │ + this.defaultControl = null; │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - this.setSize(newSize); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setBackgroundColor │ │ │ │ - * Sets the background color of the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * color - {String} the background color. eg "#FFBBBB" │ │ │ │ + * APIMethod: deactivate │ │ │ │ */ │ │ │ │ - setBackgroundColor: function(color) { │ │ │ │ - if (color != undefined) { │ │ │ │ - this.backgroundColor = color; │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + this.activeState[control.id] = control.deactivate(); │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true; │ │ │ │ + } else { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.backgroundColor = this.backgroundColor; │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick); │ │ │ │ } │ │ │ │ + this.addControlsToMap(this.controls); │ │ │ │ + return this.div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setOpacity │ │ │ │ - * Sets the opacity of the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ + * Method: redraw │ │ │ │ */ │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - if (opacity != undefined) { │ │ │ │ - this.opacity = opacity; │ │ │ │ + redraw: function() { │ │ │ │ + for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ + this.div.removeChild(this.div.childNodes[i]); │ │ │ │ } │ │ │ │ - │ │ │ │ - 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 + ')'; │ │ │ │ + this.div.innerHTML = ""; │ │ │ │ + if (this.active) { │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + this.div.appendChild(this.controls[i].panel_div); │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setBorder │ │ │ │ - * Sets the border style of the popup. │ │ │ │ + * APIMethod: activateControl │ │ │ │ + * This method is called when the user click on the icon representing a │ │ │ │ + * control in the panel. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * border - {String} The border style value. eg 2px │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ */ │ │ │ │ - setBorder: function(border) { │ │ │ │ - if (border != undefined) { │ │ │ │ - this.border = border; │ │ │ │ + activateControl: function(control) { │ │ │ │ + if (!this.active) { │ │ │ │ + return false; │ │ │ │ } │ │ │ │ - │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.border = this.border; │ │ │ │ + if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ + control.trigger(); │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ + if (control.active) { │ │ │ │ + control.deactivate(); │ │ │ │ + } else { │ │ │ │ + control.activate(); │ │ │ │ + } │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + if (this.allowDepress && control.active) { │ │ │ │ + control.deactivate(); │ │ │ │ + } else { │ │ │ │ + var c; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + c = this.controls[i]; │ │ │ │ + if (c != control && │ │ │ │ + (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ + c.deactivate(); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + control.activate(); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: setContentHTML │ │ │ │ - * Allows the user to set the HTML content of the popup. │ │ │ │ + * 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: │ │ │ │ - * contentHTML - {String} HTML for the div. │ │ │ │ + * controls - {<OpenLayers.Control>} Controls to add in the panel. │ │ │ │ */ │ │ │ │ - setContentHTML: function(contentHTML) { │ │ │ │ - │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML; │ │ │ │ + addControls: function(controls) { │ │ │ │ + if (!(OpenLayers.Util.isArray(controls))) { │ │ │ │ + controls = [controls]; │ │ │ │ } │ │ │ │ + this.controls = this.controls.concat(controls); │ │ │ │ │ │ │ │ - if ((this.contentDiv != null) && │ │ │ │ - (this.contentHTML != null) && │ │ │ │ - (this.contentHTML != this.contentDiv.innerHTML)) { │ │ │ │ - │ │ │ │ - this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ - │ │ │ │ - if (this.autoSize) { │ │ │ │ - │ │ │ │ - //if popup has images, listen for when they finish │ │ │ │ - // loading and resize accordingly │ │ │ │ - this.registerImageListeners(); │ │ │ │ - │ │ │ │ - //auto size the popup to its current contents │ │ │ │ - this.updateSize(); │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + var control = controls[i], │ │ │ │ + element = this.createControlMarkup(control); │ │ │ │ + OpenLayers.Element.addClass(element, │ │ │ │ + control.displayClass + "ItemInactive"); │ │ │ │ + OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ + if (control.title != "" && !element.title) { │ │ │ │ + element.title = control.title; │ │ │ │ } │ │ │ │ + control.panel_div = element; │ │ │ │ } │ │ │ │ │ │ │ │ + if (this.map) { // map.addControl() has already been called on the panel │ │ │ │ + this.addControlsToMap(controls); │ │ │ │ + this.redraw(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: registerImageListeners │ │ │ │ - * Called when an image contained by the popup loaded. this function │ │ │ │ - * updates the popup size, then unregisters the image load listener. │ │ │ │ + * APIMethod: createControlMarkup │ │ │ │ + * This function just creates a div for the control. If specific HTML │ │ │ │ + * markup is needed this function can be overridden in specific classes, │ │ │ │ + * or at panel instantiation time: │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var panel = new OpenLayers.Control.Panel({ │ │ │ │ + * defaultControl: control, │ │ │ │ + * // ovverride createControlMarkup to create actual buttons │ │ │ │ + * // including texts wrapped into span elements. │ │ │ │ + * createControlMarkup: function(control) { │ │ │ │ + * var button = document.createElement('button'), │ │ │ │ + * span = document.createElement('span'); │ │ │ │ + * if (control.text) { │ │ │ │ + * span.innerHTML = control.text; │ │ │ │ + * } │ │ │ │ + * return button; │ │ │ │ + * } │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} The control to create the HTML │ │ │ │ + * markup for. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} The markup. │ │ │ │ */ │ │ │ │ - registerImageListeners: function() { │ │ │ │ - │ │ │ │ - // As the images load, this function will call updateSize() to │ │ │ │ - // resize the popup to fit the content div (which presumably is now │ │ │ │ - // bigger than when the image was not loaded). │ │ │ │ - // │ │ │ │ - // If the 'panMapIfOutOfView' property is set, we will pan the newly │ │ │ │ - // resized popup back into view. │ │ │ │ - // │ │ │ │ - // Note that this function, when called, will have 'popup' and │ │ │ │ - // 'img' properties in the context. │ │ │ │ - // │ │ │ │ - var onImgLoad = function() { │ │ │ │ - if (this.popup.id === null) { // this.popup has been destroyed! │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - this.popup.updateSize(); │ │ │ │ + createControlMarkup: function(control) { │ │ │ │ + return document.createElement("div"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ - this.popup.panIntoView(); │ │ │ │ + /** │ │ │ │ + * Method: addControlsToMap │ │ │ │ + * Only for internal use in draw() and addControls() methods. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * controls - {Array(<OpenLayers.Control>)} Controls to add into map. │ │ │ │ + */ │ │ │ │ + addControlsToMap: function(controls) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + control = controls[i]; │ │ │ │ + if (control.autoActivate === true) { │ │ │ │ + control.autoActivate = false; │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.autoActivate = true; │ │ │ │ + } else { │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.deactivate(); │ │ │ │ } │ │ │ │ + control.events.on({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - OpenLayers.Event.stopObserving( │ │ │ │ - this.img, "load", this.img._onImgLoad │ │ │ │ - ); │ │ │ │ - │ │ │ │ - }; │ │ │ │ - │ │ │ │ - //cycle through the images and if their size is 0x0, that means that │ │ │ │ - // they haven't been loaded yet, so we attach the listener, which │ │ │ │ - // will fire when the images finish loading and will resize the │ │ │ │ - // popup accordingly to its new size. │ │ │ │ - var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ - for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ - var img = images[i]; │ │ │ │ - if (img.width == 0 || img.height == 0) { │ │ │ │ - │ │ │ │ - var context = { │ │ │ │ - 'popup': this, │ │ │ │ - 'img': img │ │ │ │ - }; │ │ │ │ + /** │ │ │ │ + * Method: iconOn │ │ │ │ + * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ + */ │ │ │ │ + iconOn: function() { │ │ │ │ + var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Active"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - //expando this function to the image itself before registering │ │ │ │ - // it. This way we can easily and properly unregister it. │ │ │ │ - img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ + /** │ │ │ │ + * Method: iconOff │ │ │ │ + * Internal use, for use only with "controls[i].events.on/un". │ │ │ │ + */ │ │ │ │ + iconOff: function() { │ │ │ │ + var d = this.panel_div; // "this" refers to a control on panel! │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Inactive"); │ │ │ │ + }, │ │ │ │ │ │ │ │ - OpenLayers.Event.observe(img, 'load', img._onImgLoad); │ │ │ │ + /** │ │ │ │ + * Method: onButtonClick │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var controls = this.controls, │ │ │ │ + button = evt.buttonElement; │ │ │ │ + for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ + if (controls[i].panel_div === button) { │ │ │ │ + this.activateControl(controls[i]); │ │ │ │ + break; │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: getSafeContentSize │ │ │ │ - * │ │ │ │ + * APIMethod: getControlsBy │ │ │ │ + * Get a list of controls with properties matching the given criteria. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * size - {<OpenLayers.Size>} Desired size to make the popup. │ │ │ │ - * │ │ │ │ + * 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: │ │ │ │ - * {<OpenLayers.Size>} 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). │ │ │ │ + * {Array(<OpenLayers.Control>)} A list of controls matching the given criteria. │ │ │ │ + * An empty array is returned if no matches are found. │ │ │ │ */ │ │ │ │ - getSafeContentSize: function(size) { │ │ │ │ + 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; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var safeContentSize = size.clone(); │ │ │ │ + /** │ │ │ │ + * APIMethod: getControlsByName │ │ │ │ + * Get a list of contorls with names matching the given name. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * match - {String | Object} A control name. The name can also be a regular │ │ │ │ + * expression literal or object. In addition, it can be any object │ │ │ │ + * with a method named test. For reqular expressions or other, if │ │ │ │ + * name.test(control.name) evaluates to true, the control will be included │ │ │ │ + * in the list of controls returned. If no controls are found, an empty │ │ │ │ + * array is returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Control>)} A list of controls matching the given name. │ │ │ │ + * An empty array is returned if no matches are found. │ │ │ │ + */ │ │ │ │ + getControlsByName: function(match) { │ │ │ │ + return this.getControlsBy("name", match); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // 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; │ │ │ │ + /** │ │ │ │ + * APIMethod: getControlsByClass │ │ │ │ + * Get a list of controls of a given type (CLASS_NAME). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * match - {String | Object} A control class name. The type can also be a │ │ │ │ + * regular expression literal or object. In addition, it can be any │ │ │ │ + * object with a method named test. For reqular expressions or other, │ │ │ │ + * if type.test(control.CLASS_NAME) evaluates to true, the control will │ │ │ │ + * be included in the list of controls returned. If no controls are │ │ │ │ + * found, an empty array is returned. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Array(<OpenLayers.Control>)} A list of controls matching the given type. │ │ │ │ + * An empty array is returned if no matches are found. │ │ │ │ + */ │ │ │ │ + getControlsByClass: function(match) { │ │ │ │ + return this.getControlsBy("CLASS_NAME", match); │ │ │ │ + }, │ │ │ │ │ │ │ │ - // take into account the popup's 'padding' property │ │ │ │ - this.fixPadding(); │ │ │ │ - wPadding += this.padding.left + this.padding.right; │ │ │ │ - hPadding += this.padding.top + this.padding.bottom; │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ +}); │ │ │ │ │ │ │ │ - if (this.closeDiv) { │ │ │ │ - var closeDivWidth = parseInt(this.closeDiv.style.width); │ │ │ │ - wPadding += closeDivWidth + contentDivPadding.right; │ │ │ │ - } │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Control/Zoom.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - // 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)); │ │ │ │ - } │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - // 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)); │ │ │ │ - } │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Events/buttonclick.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - //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) { │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Control.Zoom │ │ │ │ + * The Zoom control is a pair of +/- links for zooming in and out. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ + */ │ │ │ │ +OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - var extraX = 0, │ │ │ │ - extraY = 0; │ │ │ │ - if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ - var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ - switch (this.relativePosition) { │ │ │ │ - case "tr": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "tl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "bl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - case "br": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomInText │ │ │ │ + * {String} │ │ │ │ + * Text for zoom-in link. Default is "+". │ │ │ │ + */ │ │ │ │ + zoomInText: "+", │ │ │ │ │ │ │ │ - var maxY = this.map.size.h - │ │ │ │ - this.map.paddingForPopups.top - │ │ │ │ - this.map.paddingForPopups.bottom - │ │ │ │ - hPadding - extraY; │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomInId │ │ │ │ + * {String} │ │ │ │ + * Instead of having the control create a zoom in link, you can provide │ │ │ │ + * the identifier for an anchor element already added to the document. │ │ │ │ + * By default, an element with id "olZoomInLink" will be searched for │ │ │ │ + * and used if it exists. │ │ │ │ + */ │ │ │ │ + zoomInId: "olZoomInLink", │ │ │ │ │ │ │ │ - var maxX = this.map.size.w - │ │ │ │ - this.map.paddingForPopups.left - │ │ │ │ - this.map.paddingForPopups.right - │ │ │ │ - wPadding - extraX; │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomOutText │ │ │ │ + * {String} │ │ │ │ + * Text for zoom-out link. Default is "\u2212". │ │ │ │ + */ │ │ │ │ + zoomOutText: "\u2212", │ │ │ │ │ │ │ │ - safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ - safeContentSize.h = Math.min(safeContentSize.h, maxY); │ │ │ │ + /** │ │ │ │ + * APIProperty: zoomOutId │ │ │ │ + * {String} │ │ │ │ + * Instead of having the control create a zoom out link, you can provide │ │ │ │ + * the identifier for an anchor element already added to the document. │ │ │ │ + * By default, an element with id "olZoomOutLink" will be searched for │ │ │ │ + * and used if it exists. │ │ │ │ + */ │ │ │ │ + zoomOutId: "olZoomOutLink", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: draw │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {DOMElement} A reference to the DOMElement containing the zoom links. │ │ │ │ + */ │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ + links = this.getOrCreateLinks(div), │ │ │ │ + zoomIn = links.zoomIn, │ │ │ │ + zoomOut = links.zoomOut, │ │ │ │ + eventsInstance = this.map.events; │ │ │ │ + │ │ │ │ + if (zoomOut.parentNode !== div) { │ │ │ │ + eventsInstance = this.events; │ │ │ │ + eventsInstance.attachToElement(zoomOut.parentNode); │ │ │ │ } │ │ │ │ + eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ │ │ │ │ - return safeContentSize; │ │ │ │ + this.zoomInLink = zoomIn; │ │ │ │ + this.zoomOutLink = zoomOut; │ │ │ │ + return div; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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) │ │ │ │ + * Method: getOrCreateLinks │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * el - {DOMElement} │ │ │ │ * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Bounds>} │ │ │ │ + * Return: │ │ │ │ + * {Object} Object with zoomIn and zoomOut properties referencing links. │ │ │ │ */ │ │ │ │ - getContentDivPadding: function() { │ │ │ │ + getOrCreateLinks: function(el) { │ │ │ │ + var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ + zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ + if (!zoomIn) { │ │ │ │ + zoomIn = document.createElement("a"); │ │ │ │ + zoomIn.href = "#zoomIn"; │ │ │ │ + zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ + zoomIn.className = "olControlZoomIn"; │ │ │ │ + el.appendChild(zoomIn); │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ + if (!zoomOut) { │ │ │ │ + zoomOut = document.createElement("a"); │ │ │ │ + zoomOut.href = "#zoomOut"; │ │ │ │ + zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ + zoomOut.className = "olControlZoomOut"; │ │ │ │ + el.appendChild(zoomOut); │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ + return { │ │ │ │ + zoomIn: zoomIn, │ │ │ │ + zoomOut: zoomOut │ │ │ │ + }; │ │ │ │ + }, │ │ │ │ │ │ │ │ - //use cached value if we have it │ │ │ │ - var contentDivPadding = this._contentDivPadding; │ │ │ │ - if (!contentDivPadding) { │ │ │ │ + /** │ │ │ │ + * Method: onZoomClick │ │ │ │ + * Called when zoomin/out link is clicked. │ │ │ │ + */ │ │ │ │ + onZoomClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.zoomInLink) { │ │ │ │ + this.map.zoomIn(); │ │ │ │ + } else if (button === this.zoomOutLink) { │ │ │ │ + this.map.zoomOut(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.div.parentNode == null) { │ │ │ │ - //make the div invisible and add it to the page │ │ │ │ - this.div.style.display = "none"; │ │ │ │ - document.body.appendChild(this.div); │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + * Clean up. │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onZoomClick); │ │ │ │ + } │ │ │ │ + delete this.zoomInLink; │ │ │ │ + delete this.zoomOutLink; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ + }, │ │ │ │ │ │ │ │ - //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") │ │ │ │ - ); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Handler/Feature.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - //cache the value │ │ │ │ - this._contentDivPadding = contentDivPadding; │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - if (this.div.parentNode == document.body) { │ │ │ │ - //remove the div from the page and make it visible again │ │ │ │ - document.body.removeChild(this.div); │ │ │ │ - this.div.style.display = ""; │ │ │ │ - } │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Handler.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Handler.Feature │ │ │ │ + * Handler to respond to mouse events related to a drawn feature. Callbacks │ │ │ │ + * with the following keys will be notified of the following events │ │ │ │ + * associated with features: click, clickout, over, out, and dblclick. │ │ │ │ + * │ │ │ │ + * This handler stops event propagation for mousedown and mouseup if those │ │ │ │ + * browser events target features that can be selected. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Handler> │ │ │ │ + */ │ │ │ │ +OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: EVENTMAP │ │ │ │ + * {Object} A object mapping the browser events to objects with callback │ │ │ │ + * keys for in and out. │ │ │ │ + */ │ │ │ │ + EVENTMAP: { │ │ │ │ + 'click': { │ │ │ │ + 'in': 'click', │ │ │ │ + 'out': 'clickout' │ │ │ │ + }, │ │ │ │ + 'mousemove': { │ │ │ │ + 'in': 'over', │ │ │ │ + 'out': 'out' │ │ │ │ + }, │ │ │ │ + 'dblclick': { │ │ │ │ + 'in': 'dblclick', │ │ │ │ + 'out': null │ │ │ │ + }, │ │ │ │ + 'mousedown': { │ │ │ │ + 'in': null, │ │ │ │ + 'out': null │ │ │ │ + }, │ │ │ │ + 'mouseup': { │ │ │ │ + 'in': null, │ │ │ │ + 'out': null │ │ │ │ + }, │ │ │ │ + 'touchstart': { │ │ │ │ + 'in': 'click', │ │ │ │ + 'out': 'clickout' │ │ │ │ } │ │ │ │ - return contentDivPadding; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: addCloseBox │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The callback to be called when the close button │ │ │ │ - * is clicked. │ │ │ │ + * Property: feature │ │ │ │ + * {<OpenLayers.Feature.Vector>} The last feature that was hovered. │ │ │ │ */ │ │ │ │ - addCloseBox: function(callback) { │ │ │ │ - │ │ │ │ - this.closeDiv = OpenLayers.Util.createDiv( │ │ │ │ - this.id + "_close", null, { │ │ │ │ - w: 17, │ │ │ │ - h: 17 │ │ │ │ - } │ │ │ │ - ); │ │ │ │ - this.closeDiv.className = "olPopupCloseBox"; │ │ │ │ + feature: null, │ │ │ │ │ │ │ │ - // use the content div's css padding to determine if we should │ │ │ │ - // padd the close div │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + /** │ │ │ │ + * Property: lastFeature │ │ │ │ + * {<OpenLayers.Feature.Vector>} The last feature that was handled. │ │ │ │ + */ │ │ │ │ + lastFeature: null, │ │ │ │ │ │ │ │ - this.closeDiv.style.right = contentDivPadding.right + "px"; │ │ │ │ - this.closeDiv.style.top = contentDivPadding.top + "px"; │ │ │ │ - this.groupDiv.appendChild(this.closeDiv); │ │ │ │ + /** │ │ │ │ + * Property: down │ │ │ │ + * {<OpenLayers.Pixel>} The location of the last mousedown. │ │ │ │ + */ │ │ │ │ + down: null, │ │ │ │ │ │ │ │ - var closePopup = callback || function(e) { │ │ │ │ - this.hide(); │ │ │ │ - OpenLayers.Event.stop(e); │ │ │ │ - }; │ │ │ │ - OpenLayers.Event.observe(this.closeDiv, "touchend", │ │ │ │ - OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ - OpenLayers.Event.observe(this.closeDiv, "click", │ │ │ │ - OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: up │ │ │ │ + * {<OpenLayers.Pixel>} The location of the last mouseup. │ │ │ │ + */ │ │ │ │ + up: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: panIntoView │ │ │ │ - * Pans the map such that the popup is totaly viewable (if necessary) │ │ │ │ + * Property: clickTolerance │ │ │ │ + * {Number} The number of pixels the mouse can move between mousedown │ │ │ │ + * and mouseup for the event to still be considered a click. │ │ │ │ + * Dragging the map should not trigger the click and clickout callbacks │ │ │ │ + * unless the map is moved by less than this tolerance. Defaults to 4. │ │ │ │ */ │ │ │ │ - panIntoView: function() { │ │ │ │ + clickTolerance: 4, │ │ │ │ │ │ │ │ - var mapSize = this.map.getSize(); │ │ │ │ + /** │ │ │ │ + * Property: geometryTypes │ │ │ │ + * To restrict dragging to a limited set of geometry types, send a list │ │ │ │ + * of strings corresponding to the geometry class names. │ │ │ │ + * │ │ │ │ + * @type Array(String) │ │ │ │ + */ │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ - //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(); │ │ │ │ + /** │ │ │ │ + * Property: stopClick │ │ │ │ + * {Boolean} If stopClick is set to true, handled clicks do not │ │ │ │ + * propagate to other click listeners. Otherwise, handled clicks │ │ │ │ + * do propagate. Unhandled clicks always propagate, whatever the │ │ │ │ + * value of stopClick. Defaults to true. │ │ │ │ + */ │ │ │ │ + stopClick: true, │ │ │ │ │ │ │ │ - //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; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: stopDown │ │ │ │ + * {Boolean} If stopDown is set to true, handled mousedowns do not │ │ │ │ + * propagate to other mousedown listeners. Otherwise, handled │ │ │ │ + * mousedowns do propagate. Unhandled mousedowns always propagate, │ │ │ │ + * whatever the value of stopDown. Defaults to true. │ │ │ │ + */ │ │ │ │ + stopDown: true, │ │ │ │ │ │ │ │ - //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; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * Property: stopUp │ │ │ │ + * {Boolean} If stopUp is set to true, handled mouseups do not │ │ │ │ + * propagate to other mouseup listeners. Otherwise, handled mouseups │ │ │ │ + * do propagate. Unhandled mouseups always propagate, whatever the │ │ │ │ + * value of stopUp. Defaults to false. │ │ │ │ + */ │ │ │ │ + stopUp: false, │ │ │ │ │ │ │ │ - var dx = origTL.x - newTL.x; │ │ │ │ - var dy = origTL.y - newTL.y; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Handler.Feature │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * control - {<OpenLayers.Control>} │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ + * callbacks - {Object} An object with a 'over' property whos value is │ │ │ │ + * a function to be called when the mouse is over a feature. The │ │ │ │ + * callback should expect to recieve a single argument, the feature. │ │ │ │ + * options - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(control, layer, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ + this.layer = layer; │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.map.pan(dx, dy); │ │ │ │ + /** │ │ │ │ + * Method: touchstart │ │ │ │ + * Handle touchstart events │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Let the event propagate. │ │ │ │ + */ │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return OpenLayers.Event.isMultiTouch(evt) ? │ │ │ │ + true : this.mousedown(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: registerEvents │ │ │ │ - * Registers events on the popup. │ │ │ │ + /** │ │ │ │ + * Method: touchmove │ │ │ │ + * Handle touchmove events. We just prevent the browser default behavior, │ │ │ │ + * for Android Webkit not to select text when moving the finger after │ │ │ │ + * selecting a feature. │ │ │ │ * │ │ │ │ - * 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. The same procedure is needed for │ │ │ │ - * touchmove and touchend events. │ │ │ │ - * │ │ │ │ - * 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. │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ */ │ │ │ │ - registerEvents: function() { │ │ │ │ - this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ + touchmove: function(evt) { │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + }, │ │ │ │ │ │ │ │ - function onTouchstart(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + /** │ │ │ │ + * Method: mousedown │ │ │ │ + * Handle mouse down. Stop propagation if a feature is targeted by this │ │ │ │ + * event (stops map dragging during feature selection). │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + */ │ │ │ │ + mousedown: function(evt) { │ │ │ │ + // Feature selection is only done with a left click. Other handlers may stop the │ │ │ │ + // propagation of left-click mousedown events but not right-click mousedown events. │ │ │ │ + // This mismatch causes problems when comparing the location of the down and up │ │ │ │ + // events in the click function so it is important ignore right-clicks. │ │ │ │ + if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ + this.down = evt.xy; │ │ │ │ } │ │ │ │ - this.events.on({ │ │ │ │ - "mousedown": this.onmousedown, │ │ │ │ - "mousemove": this.onmousemove, │ │ │ │ - "mouseup": this.onmouseup, │ │ │ │ - "click": this.onclick, │ │ │ │ - "mouseout": this.onmouseout, │ │ │ │ - "dblclick": this.ondblclick, │ │ │ │ - "touchstart": onTouchstart, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - │ │ │ │ + return this.handle(evt) ? !this.stopDown : true; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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) │ │ │ │ + /** │ │ │ │ + * Method: mouseup │ │ │ │ + * Handle mouse up. Stop propagation if a feature is targeted by this │ │ │ │ + * event. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * evt - {Event} │ │ │ │ */ │ │ │ │ - onmousedown: function(evt) { │ │ │ │ - this.mousedown = true; │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + mouseup: function(evt) { │ │ │ │ + this.up = evt.xy; │ │ │ │ + return this.handle(evt) ? !this.stopUp : 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) │ │ │ │ + /** │ │ │ │ + * Method: click │ │ │ │ + * Handle click. Call the "click" callback if click on a feature, │ │ │ │ + * or the "clickout" callback if click outside any feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - onmousemove: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ - } │ │ │ │ + click: function(evt) { │ │ │ │ + return this.handle(evt) ? !this.stopClick : 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 │ │ │ │ + /** │ │ │ │ + * Method: mousemove │ │ │ │ + * Handle mouse moves. Call the "over" callback if moving in to a feature, │ │ │ │ + * or the "out" callback if moving out of a feature. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - onmouseup: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - this.mousedown = false; │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + mousemove: function(evt) { │ │ │ │ + if (!this.callbacks['over'] && !this.callbacks['out']) { │ │ │ │ + return true; │ │ │ │ } │ │ │ │ + this.handle(evt); │ │ │ │ + return true; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: onclick │ │ │ │ - * Ignore clicks, but allowing default browser handling │ │ │ │ - * │ │ │ │ + * Method: dblclick │ │ │ │ + * Handle dblclick. Call the "dblclick" callback if dblclick on a feature. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - onclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + dblclick: function(evt) { │ │ │ │ + return !this.handle(evt); │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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. │ │ │ │ - * │ │ │ │ + /** │ │ │ │ + * Method: geometryTypeMatches │ │ │ │ + * Return true if the geometry type of the passed feature matches │ │ │ │ + * one of the geometry types in the geometryTypes array. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - onmouseout: function(evt) { │ │ │ │ - this.mousedown = false; │ │ │ │ + geometryTypeMatches: function(feature) { │ │ │ │ + return this.geometryTypes == null || │ │ │ │ + OpenLayers.Util.indexOf(this.geometryTypes, │ │ │ │ + feature.geometry.CLASS_NAME) > -1; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: ondblclick │ │ │ │ - * Ignore double-clicks, but allowing default browser handling │ │ │ │ + /** │ │ │ │ + * Method: handle │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Event} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The event occurred over a relevant feature. │ │ │ │ + */ │ │ │ │ + handle: function(evt) { │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + // feature has been destroyed │ │ │ │ + this.feature = null; │ │ │ │ + } │ │ │ │ + var type = evt.type; │ │ │ │ + var handled = false; │ │ │ │ + var previouslyIn = !!(this.feature); // previously in a feature │ │ │ │ + var click = (type == "click" || type == "dblclick" || type == "touchstart"); │ │ │ │ + this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + // feature has been destroyed │ │ │ │ + this.feature = null; │ │ │ │ + } │ │ │ │ + if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ + // last feature has been destroyed │ │ │ │ + this.lastFeature = null; │ │ │ │ + } │ │ │ │ + if (this.feature) { │ │ │ │ + if (type === "touchstart") { │ │ │ │ + // stop the event to prevent Android Webkit from │ │ │ │ + // "flashing" the map div │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + } │ │ │ │ + var inNew = (this.feature != this.lastFeature); │ │ │ │ + if (this.geometryTypeMatches(this.feature)) { │ │ │ │ + // in to a feature │ │ │ │ + if (previouslyIn && inNew) { │ │ │ │ + // out of last feature and in to another │ │ │ │ + if (this.lastFeature) { │ │ │ │ + this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ + } │ │ │ │ + this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ + } else if (!previouslyIn || click) { │ │ │ │ + // in feature for the first time │ │ │ │ + this.triggerCallback(type, 'in', [this.feature]); │ │ │ │ + } │ │ │ │ + this.lastFeature = this.feature; │ │ │ │ + handled = true; │ │ │ │ + } else { │ │ │ │ + // not in to a feature │ │ │ │ + if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ + // out of last feature for the first time │ │ │ │ + this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ + } │ │ │ │ + // next time the mouse goes in a feature whose geometry type │ │ │ │ + // doesn't match we don't want to call the 'out' callback │ │ │ │ + // again, so let's set this.feature to null so that │ │ │ │ + // previouslyIn will evaluate to false the next time │ │ │ │ + // we enter handle. Yes, a bit hackish... │ │ │ │ + this.feature = null; │ │ │ │ + } │ │ │ │ + } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ + this.triggerCallback(type, 'out', [this.lastFeature]); │ │ │ │ + } │ │ │ │ + return handled; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: triggerCallback │ │ │ │ + * Call the callback keyed in the event map with the supplied arguments. │ │ │ │ + * For click and clickout, the <clickTolerance> is checked first. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * type - {String} │ │ │ │ + */ │ │ │ │ + triggerCallback: function(type, mode, args) { │ │ │ │ + var key = this.EVENTMAP[type][mode]; │ │ │ │ + if (key) { │ │ │ │ + if (type == 'click' && this.up && this.down) { │ │ │ │ + // for click/clickout, only trigger callback if tolerance is met │ │ │ │ + var dpx = Math.sqrt( │ │ │ │ + Math.pow(this.up.x - this.down.x, 2) + │ │ │ │ + Math.pow(this.up.y - this.down.y, 2) │ │ │ │ + ); │ │ │ │ + if (dpx <= this.clickTolerance) { │ │ │ │ + this.callback(key, args); │ │ │ │ + } │ │ │ │ + // we're done with this set of events now: clear the cached │ │ │ │ + // positions so we can't trip over them later (this can occur │ │ │ │ + // if one of the up/down events gets eaten before it gets to us │ │ │ │ + // but we still get the click) │ │ │ │ + this.up = this.down = null; │ │ │ │ + } else { │ │ │ │ + this.callback(key, args); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + * Turn on the handler. Returns false if the handler was already active. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + this.map.events.on({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + activated = true; │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + * Turn off the handler. Returns false if the handler was already active. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.moveLayerBack(); │ │ │ │ + this.feature = null; │ │ │ │ + this.lastFeature = null; │ │ │ │ + this.down = null; │ │ │ │ + this.up = null; │ │ │ │ + this.map.events.un({ │ │ │ │ + "removelayer": this.handleMapEvents, │ │ │ │ + "changelayer": this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + deactivated = true; │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: handleMapEvents │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ + * evt - {Object} │ │ │ │ */ │ │ │ │ - ondblclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true); │ │ │ │ + handleMapEvents: function(evt) { │ │ │ │ + if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + } │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Popup" │ │ │ │ -}); │ │ │ │ + /** │ │ │ │ + * Method: moveLayerToTop │ │ │ │ + * Moves the layer for this handler to the top, so mouse events can reach │ │ │ │ + * it. │ │ │ │ + */ │ │ │ │ + moveLayerToTop: function() { │ │ │ │ + var index = Math.max(this.map.Z_INDEX_BASE['Feature'] - 1, │ │ │ │ + this.layer.getZIndex()) + 1; │ │ │ │ + this.layer.setZIndex(index); │ │ │ │ │ │ │ │ -OpenLayers.Popup.WIDTH = 200; │ │ │ │ -OpenLayers.Popup.HEIGHT = 200; │ │ │ │ -OpenLayers.Popup.COLOR = "white"; │ │ │ │ -OpenLayers.Popup.OPACITY = 1; │ │ │ │ -OpenLayers.Popup.BORDER = "0px"; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: moveLayerBack │ │ │ │ + * Moves the layer back to the position determined by the map's layers │ │ │ │ + * array. │ │ │ │ + */ │ │ │ │ + moveLayerBack: function() { │ │ │ │ + var index = this.layer.getZIndex() - 1; │ │ │ │ + if (index >= this.map.Z_INDEX_BASE['Feature']) { │ │ │ │ + this.layer.setZIndex(index); │ │ │ │ + } else { │ │ │ │ + this.map.setLayerZIndex(this.layer, │ │ │ │ + this.map.getLayerIndex(this.layer)); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Popup/Anchored.js │ │ │ │ + OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ - │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Popup.js │ │ │ │ + * @requires OpenLayers/Layer/Vector.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Popup.Anchored │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Layer.Vector.RootContainer │ │ │ │ + * A special layer type to combine multiple vector layers inside a single │ │ │ │ + * renderer root container. This class is not supposed to be instantiated │ │ │ │ + * from user space, it is a helper class for controls that require event │ │ │ │ + * processing for multiple vector layers. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Popup> │ │ │ │ + * - <OpenLayers.Layer.Vector> │ │ │ │ */ │ │ │ │ -OpenLayers.Popup.Anchored = │ │ │ │ - OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: relativePosition │ │ │ │ - * {String} Relative position of the popup ("br", "tr", "tl" or "bl"). │ │ │ │ - */ │ │ │ │ - relativePosition: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: keepInMap │ │ │ │ - * {Boolean} If panMapIfOutOfView is false, and this property is true, │ │ │ │ - * contrain the popup such that it always fits in the available map │ │ │ │ - * space. By default, this is set. If you are creating popups that are │ │ │ │ - * near map edges and not allowing pannning, and especially if you have │ │ │ │ - * a popup which has a fixedRelativePosition, setting this to false may │ │ │ │ - * be a smart thing to do. │ │ │ │ - * │ │ │ │ - * For anchored popups, default is true, since subclasses will │ │ │ │ - * usually want this functionality. │ │ │ │ - */ │ │ │ │ - keepInMap: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: anchor │ │ │ │ - * {Object} Object to which we'll anchor the popup. Must expose a │ │ │ │ - * 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>). │ │ │ │ - */ │ │ │ │ - anchor: null, │ │ │ │ +OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Popup.Anchored │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} │ │ │ │ - * lonlat - {<OpenLayers.LonLat>} │ │ │ │ - * contentSize - {<OpenLayers.Size>} │ │ │ │ - * contentHTML - {String} │ │ │ │ - * anchor - {Object} Object which must expose a 'size' <OpenLayers.Size> │ │ │ │ - * and 'offset' <OpenLayers.Pixel> (generally an <OpenLayers.Icon>). │ │ │ │ - * closeBox - {Boolean} │ │ │ │ - * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ - */ │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ - closeBoxCallback) { │ │ │ │ - var newArguments = [ │ │ │ │ - id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback │ │ │ │ - ]; │ │ │ │ - OpenLayers.Popup.prototype.initialize.apply(this, newArguments); │ │ │ │ + /** │ │ │ │ + * Property: displayInLayerSwitcher │ │ │ │ + * Set to false for this layer type │ │ │ │ + */ │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ │ │ │ │ - this.anchor = (anchor != null) ? anchor : │ │ │ │ - { │ │ │ │ - size: new OpenLayers.Size(0, 0), │ │ │ │ - offset: new OpenLayers.Pixel(0, 0) │ │ │ │ - }; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: layers │ │ │ │ + * Layers that are attached to this container. Required config option. │ │ │ │ + */ │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.anchor = null; │ │ │ │ - this.relativePosition = null; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.Vector.RootContainer │ │ │ │ + * Create a new root container for multiple vector layer. This constructor │ │ │ │ + * is not supposed to be used from user space, it is only to be used by │ │ │ │ + * controls that need feature selection across multiple vector layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * name - {String} A name for the layer │ │ │ │ + * options - {Object} Optional object with non-default properties to set on │ │ │ │ + * the layer. │ │ │ │ + * │ │ │ │ + * Required options properties: │ │ │ │ + * layers - {Array(<OpenLayers.Layer.Vector>)} The layers managed by this │ │ │ │ + * container │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Vector.RootContainer>} A new vector layer root │ │ │ │ + * container │ │ │ │ + */ │ │ │ │ │ │ │ │ - OpenLayers.Popup.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: display │ │ │ │ + */ │ │ │ │ + display: function() {}, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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: getFeatureFromEvent │ │ │ │ + * walk through the layers to find the feature returned by the event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} event object with a feature property │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + getFeatureFromEvent: function(evt) { │ │ │ │ + var layers = this.layers; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0; i < layers.length; i++) { │ │ │ │ + feature = layers[i].getFeatureFromEvent(evt); │ │ │ │ + if (feature) { │ │ │ │ + return feature; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * 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 - {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - var oldRelativePosition = this.relativePosition; │ │ │ │ - this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ + this.collectRoots(); │ │ │ │ + map.events.register("changelayer", this, this.handleChangeLayer); │ │ │ │ + }, │ │ │ │ │ │ │ │ - OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ + /** │ │ │ │ + * Method: removeMap │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + removeMap: function(map) { │ │ │ │ + map.events.unregister("changelayer", this, this.handleChangeLayer); │ │ │ │ + this.resetRoots(); │ │ │ │ + OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - //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(); │ │ │ │ + /** │ │ │ │ + * Method: collectRoots │ │ │ │ + * Collects the root nodes of all layers this control is configured with │ │ │ │ + * and moveswien the nodes to this control's layer │ │ │ │ + */ │ │ │ │ + collectRoots: function() { │ │ │ │ + var layer; │ │ │ │ + // walk through all map layers, because we want to keep the order │ │ │ │ + for (var i = 0; i < this.map.layers.length; ++i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ + layer.renderer.moveRoot(this.renderer); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: setSize │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ - * contents div (in pixels). │ │ │ │ - */ │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - if ((this.lonlat) && (this.map)) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - this.moveTo(px); │ │ │ │ + /** │ │ │ │ + * Method: resetRoots │ │ │ │ + * Resets the root nodes back into the layers they belong to. │ │ │ │ + */ │ │ │ │ + resetRoots: function() { │ │ │ │ + var layer; │ │ │ │ + for (var i = 0; i < this.layers.length; ++i) { │ │ │ │ + layer = this.layers[i]; │ │ │ │ + if (this.renderer && layer.renderer.getRenderLayerId() == this.id) { │ │ │ │ + this.renderer.moveRoot(layer.renderer); │ │ │ │ } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: calculateRelativePosition │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - * │ │ │ │ - * 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 Framed, however, will want to do something │ │ │ │ - * special here. │ │ │ │ - */ │ │ │ │ - updateRelativePosition: function() { │ │ │ │ - //to be overridden by subclasses │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: calculateNewPx │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} 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); │ │ │ │ - │ │ │ │ - //use contentSize if size is not already set │ │ │ │ - var size = this.size || this.contentSize; │ │ │ │ - │ │ │ │ - var top = (this.relativePosition.charAt(0) == 't'); │ │ │ │ - newPx.y += (top) ? -size.h : this.anchor.size.h; │ │ │ │ - │ │ │ │ - var left = (this.relativePosition.charAt(1) == 'l'); │ │ │ │ - newPx.x += (left) ? -size.w : this.anchor.size.w; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - return newPx; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: handleChangeLayer │ │ │ │ + * Event handler for the map's changelayer event. We need to rebuild │ │ │ │ + * this container's layer dom if order of one of its layers changes. │ │ │ │ + * This handler is added with the setMap method, and removed with the │ │ │ │ + * removeMap method. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * evt - {Object} │ │ │ │ + */ │ │ │ │ + handleChangeLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (evt.property == "order" && │ │ │ │ + OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ + this.resetRoots(); │ │ │ │ + this.collectRoots(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer" │ │ │ │ +}); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Popup/Framed.js │ │ │ │ + OpenLayers/Control/SelectFeature.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ + │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Popup/Anchored.js │ │ │ │ + * @requires OpenLayers/Control.js │ │ │ │ + * @requires OpenLayers/Feature/Vector.js │ │ │ │ + * @requires OpenLayers/Handler/Feature.js │ │ │ │ + * @requires OpenLayers/Layer/Vector/RootContainer.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Popup.Framed │ │ │ │ - * │ │ │ │ + * Class: OpenLayers.Control.SelectFeature │ │ │ │ + * The SelectFeature control selects vector features from a given layer on │ │ │ │ + * click or hover. │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ - * - <OpenLayers.Popup.Anchored> │ │ │ │ + * - <OpenLayers.Control> │ │ │ │ */ │ │ │ │ -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 │ │ │ │ - * {<OpenLayers.Size>} 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, │ │ │ │ +OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Popup.Framed │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} │ │ │ │ - * lonlat - {<OpenLayers.LonLat>} │ │ │ │ - * contentSize - {<OpenLayers.Size>} │ │ │ │ - * contentHTML - {String} │ │ │ │ - * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ - * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ - * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ - * closeBox - {Boolean} │ │ │ │ - * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ - */ │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ - closeBoxCallback) { │ │ │ │ + /** │ │ │ │ + * APIProperty: events │ │ │ │ + * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ + * control specific events. │ │ │ │ + * │ │ │ │ + * Register a listener for a particular event with the following syntax: │ │ │ │ + * (code) │ │ │ │ + * control.events.register(type, obj, listener); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Supported event types (in addition to those from <OpenLayers.Control.events>): │ │ │ │ + * beforefeaturehighlighted - Triggered before a feature is highlighted │ │ │ │ + * featurehighlighted - Triggered when a feature is highlighted │ │ │ │ + * featureunhighlighted - Triggered when a feature is unhighlighted │ │ │ │ + * boxselectionstart - Triggered before box selection starts │ │ │ │ + * boxselectionend - Triggered after box selection ends │ │ │ │ + */ │ │ │ │ │ │ │ │ - OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ + /** │ │ │ │ + * Property: multipleKey │ │ │ │ + * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ + * the <multiple> property to true. Default is null. │ │ │ │ + */ │ │ │ │ + multipleKey: null, │ │ │ │ │ │ │ │ - if (this.fixedRelativePosition) { │ │ │ │ - //based on our decided relativePostion, set the current padding │ │ │ │ - // this keeps us from getting into trouble │ │ │ │ - this.updateRelativePosition(); │ │ │ │ + /** │ │ │ │ + * Property: toggleKey │ │ │ │ + * {String} An event modifier ('altKey' or 'shiftKey') that temporarily sets │ │ │ │ + * the <toggle> property to true. Default is null. │ │ │ │ + */ │ │ │ │ + toggleKey: null, │ │ │ │ │ │ │ │ - //make calculateRelativePosition always return the specified │ │ │ │ - // fixed position. │ │ │ │ - this.calculateRelativePosition = function(px) { │ │ │ │ - return this.relativePosition; │ │ │ │ - }; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: multiple │ │ │ │ + * {Boolean} Allow selection of multiple geometries. Default is false. │ │ │ │ + */ │ │ │ │ + multiple: false, │ │ │ │ │ │ │ │ - this.contentDiv.style.position = "absolute"; │ │ │ │ - this.contentDiv.style.zIndex = 1; │ │ │ │ + /** │ │ │ │ + * APIProperty: clickout │ │ │ │ + * {Boolean} Unselect features when clicking outside any feature. │ │ │ │ + * Default is true. │ │ │ │ + */ │ │ │ │ + clickout: true, │ │ │ │ │ │ │ │ - if (closeBox) { │ │ │ │ - this.closeDiv.style.zIndex = 1; │ │ │ │ - } │ │ │ │ + /** │ │ │ │ + * APIProperty: toggle │ │ │ │ + * {Boolean} Unselect a selected feature on click. Default is false. Only │ │ │ │ + * has meaning if hover is false. │ │ │ │ + */ │ │ │ │ + toggle: false, │ │ │ │ │ │ │ │ - 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%"; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: hover │ │ │ │ + * {Boolean} Select on mouse over and deselect on mouse out. If true, this │ │ │ │ + * ignores clicks and only listens to mouse moves. │ │ │ │ + */ │ │ │ │ + hover: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.imageSrc = null; │ │ │ │ - this.imageSize = null; │ │ │ │ - this.isAlphaImage = null; │ │ │ │ + /** │ │ │ │ + * APIProperty: highlightOnly │ │ │ │ + * {Boolean} If true do not actually select features (that is place them in │ │ │ │ + * the layer's selected features array), just highlight them. This property │ │ │ │ + * has no effect if hover is false. Defaults to false. │ │ │ │ + */ │ │ │ │ + highlightOnly: false, │ │ │ │ │ │ │ │ - this.fixedRelativePosition = false; │ │ │ │ - this.positionBlocks = null; │ │ │ │ + /** │ │ │ │ + * APIProperty: box │ │ │ │ + * {Boolean} Allow feature selection by drawing a box. │ │ │ │ + */ │ │ │ │ + box: false, │ │ │ │ │ │ │ │ - //remove our blocks │ │ │ │ - for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ - var block = this.blocks[i]; │ │ │ │ + /** │ │ │ │ + * Property: onBeforeSelect │ │ │ │ + * {Function} Optional function to be called before a feature is selected. │ │ │ │ + * The function should expect to be called with a feature. │ │ │ │ + */ │ │ │ │ + onBeforeSelect: function() {}, │ │ │ │ │ │ │ │ - if (block.image) { │ │ │ │ - block.div.removeChild(block.image); │ │ │ │ - } │ │ │ │ - block.image = null; │ │ │ │ + /** │ │ │ │ + * APIProperty: onSelect │ │ │ │ + * {Function} Optional function to be called when a feature is selected. │ │ │ │ + * The function should expect to be called with a feature. │ │ │ │ + */ │ │ │ │ + onSelect: function() {}, │ │ │ │ │ │ │ │ - if (block.div) { │ │ │ │ - this.groupDiv.removeChild(block.div); │ │ │ │ - } │ │ │ │ - block.div = null; │ │ │ │ - } │ │ │ │ - this.blocks = null; │ │ │ │ + /** │ │ │ │ + * APIProperty: onUnselect │ │ │ │ + * {Function} Optional function to be called when a feature is unselected. │ │ │ │ + * The function should expect to be called with a feature. │ │ │ │ + */ │ │ │ │ + onUnselect: function() {}, │ │ │ │ │ │ │ │ - OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: scope │ │ │ │ + * {Object} The scope to use with the onBeforeSelect, onSelect, onUnselect │ │ │ │ + * callbacks. If null the scope will be this control. │ │ │ │ + */ │ │ │ │ + scope: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setBackgroundColor │ │ │ │ - */ │ │ │ │ - setBackgroundColor: function(color) { │ │ │ │ - //does nothing since the framed popup's entire scheme is based on a │ │ │ │ - // an image -- changing the background color makes no sense. │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: geometryTypes │ │ │ │ + * {Array(String)} To restrict selecting to a limited set of geometry types, │ │ │ │ + * send a list of strings corresponding to the geometry class names. │ │ │ │ + */ │ │ │ │ + geometryTypes: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setBorder │ │ │ │ - */ │ │ │ │ - setBorder: function() { │ │ │ │ - //does nothing since the framed popup's entire scheme is based on a │ │ │ │ - // an image -- changing the popup's border makes no sense. │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The vector layer with a common renderer │ │ │ │ + * root for all layers this control is configured with (if an array of │ │ │ │ + * layers was passed to the constructor), or the vector layer the control │ │ │ │ + * was configured with (if a single layer was passed to the constructor). │ │ │ │ + */ │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: setOpacity │ │ │ │ - * Sets the opacity of the popup. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). │ │ │ │ - */ │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - //does nothing since we suppose that we'll never apply an opacity │ │ │ │ - // to a framed popup │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Property: layers │ │ │ │ + * {Array(<OpenLayers.Layer.Vector>)} The layers this control will work on, │ │ │ │ + * or null if the control was configured with a single layer │ │ │ │ + */ │ │ │ │ + layers: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIMethod: setSize │ │ │ │ - * Overridden here, because we need to update the blocks whenever the size │ │ │ │ - * of the popup has changed. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * contentSize - {<OpenLayers.Size>} the new size for the popup's │ │ │ │ - * contents div (in pixels). │ │ │ │ - */ │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ + /** │ │ │ │ + * APIProperty: callbacks │ │ │ │ + * {Object} The functions that are sent to the handlers.feature for callback │ │ │ │ + */ │ │ │ │ + callbacks: null, │ │ │ │ │ │ │ │ - this.updateBlocks(); │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIProperty: selectStyle │ │ │ │ + * {Object} Hash of styles │ │ │ │ + */ │ │ │ │ + selectStyle: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: updateRelativePosition │ │ │ │ - * When the relative position changes, we need to set the new padding │ │ │ │ - * BBOX on the popup, reposition the close div, and update the blocks. │ │ │ │ - */ │ │ │ │ - updateRelativePosition: function() { │ │ │ │ + /** │ │ │ │ + * Property: renderIntent │ │ │ │ + * {String} key used to retrieve the select style from the layer's │ │ │ │ + * style map. │ │ │ │ + */ │ │ │ │ + renderIntent: "select", │ │ │ │ │ │ │ │ - //update the padding │ │ │ │ - this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ + /** │ │ │ │ + * Property: handlers │ │ │ │ + * {Object} Object with references to multiple <OpenLayers.Handler> │ │ │ │ + * instances. │ │ │ │ + */ │ │ │ │ + handlers: null, │ │ │ │ │ │ │ │ - //update the position of our close box to new padding │ │ │ │ - if (this.closeDiv) { │ │ │ │ - // use the content div's css padding to determine if we should │ │ │ │ - // padd the close div │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Control.SelectFeature │ │ │ │ + * Create a new control for selecting features. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. The │ │ │ │ + * layer(s) this control will select features from. │ │ │ │ + * options - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(layers, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ │ │ │ │ - this.closeDiv.style.right = contentDivPadding.right + │ │ │ │ - this.padding.right + "px"; │ │ │ │ - this.closeDiv.style.top = contentDivPadding.top + │ │ │ │ - this.padding.top + "px"; │ │ │ │ - } │ │ │ │ + if (this.scope === null) { │ │ │ │ + this.scope = this; │ │ │ │ + } │ │ │ │ + this.initLayer(layers); │ │ │ │ + var callbacks = { │ │ │ │ + click: this.clickFeature, │ │ │ │ + clickout: this.clickoutFeature │ │ │ │ + }; │ │ │ │ + if (this.hover) { │ │ │ │ + callbacks.over = this.overFeature; │ │ │ │ + callbacks.out = this.outFeature; │ │ │ │ + } │ │ │ │ │ │ │ │ - this.updateBlocks(); │ │ │ │ - }, │ │ │ │ + this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ + this.handlers = { │ │ │ │ + feature: new OpenLayers.Handler.Feature( │ │ │ │ + this, this.layer, this.callbacks, { │ │ │ │ + geometryTypes: this.geometryTypes │ │ │ │ + } │ │ │ │ + ) │ │ │ │ + }; │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: calculateNewPx │ │ │ │ - * Besides the standard offset as determined by the Anchored class, our │ │ │ │ - * Framed popups have a special 'offset' property for each of their │ │ │ │ - * positions, which is used to offset the popup relative to its anchor. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Pixel>} The the new px position of the popup on the screen │ │ │ │ - * relative to the passed-in px. │ │ │ │ - */ │ │ │ │ - calculateNewPx: function(px) { │ │ │ │ - var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply( │ │ │ │ - this, arguments │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box = new OpenLayers.Handler.Box( │ │ │ │ + this, { │ │ │ │ + done: this.selectBox │ │ │ │ + }, { │ │ │ │ + boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ + } │ │ │ │ ); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ - │ │ │ │ - return newPx; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * Method: initLayer │ │ │ │ + * Assign the layer property. If layers is an array, we need to use │ │ │ │ + * a RootContainer. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layers - {<OpenLayers.Layer.Vector>}, or an array of vector layers. │ │ │ │ + */ │ │ │ │ + initLayer: function(layers) { │ │ │ │ + if (OpenLayers.Util.isArray(layers)) { │ │ │ │ + this.layers = layers; │ │ │ │ + this.layer = new OpenLayers.Layer.Vector.RootContainer( │ │ │ │ + this.id + "_container", { │ │ │ │ + layers: layers │ │ │ │ + } │ │ │ │ + ); │ │ │ │ + } else { │ │ │ │ + this.layer = layers; │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: createBlocks │ │ │ │ - */ │ │ │ │ - createBlocks: function() { │ │ │ │ - this.blocks = []; │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active && this.layers) { │ │ │ │ + this.map.removeLayer(this.layer); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - //since all positions contain the same number of blocks, we can │ │ │ │ - // just pick the first position and use its blocks array to create │ │ │ │ - // our blocks array │ │ │ │ - var firstPosition = null; │ │ │ │ - for (var key in this.positionBlocks) { │ │ │ │ - firstPosition = key; │ │ │ │ - break; │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + * Activates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively activated. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.addLayer(this.layer); │ │ │ │ } │ │ │ │ - │ │ │ │ - var position = this.positionBlocks[firstPosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - │ │ │ │ - var block = {}; │ │ │ │ - this.blocks.push(block); │ │ │ │ - │ │ │ │ - var divId = this.id + '_FrameDecorationDiv_' + i; │ │ │ │ - block.div = OpenLayers.Util.createDiv(divId, │ │ │ │ - null, null, null, "absolute", null, "hidden", null │ │ │ │ - ); │ │ │ │ - │ │ │ │ - var imgId = this.id + '_FrameDecorationImg_' + i; │ │ │ │ - var imageCreator = │ │ │ │ - (this.isAlphaImage) ? OpenLayers.Util.createAlphaImageDiv : │ │ │ │ - OpenLayers.Util.createImage; │ │ │ │ - │ │ │ │ - block.image = imageCreator(imgId, │ │ │ │ - null, this.imageSize, this.imageSrc, │ │ │ │ - "absolute", null, null, null │ │ │ │ - ); │ │ │ │ - │ │ │ │ - block.div.appendChild(block.image); │ │ │ │ - this.groupDiv.appendChild(block.div); │ │ │ │ + this.handlers.feature.activate(); │ │ │ │ + if (this.box && this.handlers.box) { │ │ │ │ + this.handlers.box.activate(); │ │ │ │ } │ │ │ │ - }, │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: updateBlocks │ │ │ │ - * Internal method, called on initialize and when the popup's relative │ │ │ │ - * position has changed. This function takes care of re-positioning │ │ │ │ - * the popup's blocks in their appropropriate places. │ │ │ │ - */ │ │ │ │ - updateBlocks: function() { │ │ │ │ - if (!this.blocks) { │ │ │ │ - this.createBlocks(); │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivates the control. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The control was effectively deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.feature.deactivate(); │ │ │ │ + if (this.handlers.box) { │ │ │ │ + this.handlers.box.deactivate(); │ │ │ │ } │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.removeLayer(this.layer); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply( │ │ │ │ + this, arguments │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ │ │ │ │ - if (this.size && this.relativePosition) { │ │ │ │ - var position = this.positionBlocks[this.relativePosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - │ │ │ │ - var positionBlock = position.blocks[i]; │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - │ │ │ │ - // adjust sizes │ │ │ │ - var l = positionBlock.anchor.left; │ │ │ │ - var b = positionBlock.anchor.bottom; │ │ │ │ - var r = positionBlock.anchor.right; │ │ │ │ - var t = positionBlock.anchor.top; │ │ │ │ - │ │ │ │ - //note that we use the isNaN() test here because if the │ │ │ │ - // size object is initialized with a "auto" parameter, the │ │ │ │ - // size constructor calls parseFloat() on the string, │ │ │ │ - // which will turn it into NaN │ │ │ │ - // │ │ │ │ - var w = (isNaN(positionBlock.size.w)) ? this.size.w - (r + l) : │ │ │ │ - positionBlock.size.w; │ │ │ │ - │ │ │ │ - var h = (isNaN(positionBlock.size.h)) ? this.size.h - (b + t) : │ │ │ │ - positionBlock.size.h; │ │ │ │ - │ │ │ │ - block.div.style.width = (w < 0 ? 0 : w) + 'px'; │ │ │ │ - block.div.style.height = (h < 0 ? 0 : h) + 'px'; │ │ │ │ - │ │ │ │ - block.div.style.left = (l != null) ? l + 'px' : ''; │ │ │ │ - block.div.style.bottom = (b != null) ? b + 'px' : ''; │ │ │ │ - block.div.style.right = (r != null) ? r + 'px' : ''; │ │ │ │ - block.div.style.top = (t != null) ? t + 'px' : ''; │ │ │ │ - │ │ │ │ - block.image.style.left = positionBlock.position.x + 'px'; │ │ │ │ - block.image.style.top = positionBlock.position.y + 'px'; │ │ │ │ + /** │ │ │ │ + * Method: unselectAll │ │ │ │ + * Unselect all selected features. To unselect all except for a single │ │ │ │ + * feature, set the options.except property to the feature. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional configuration object. │ │ │ │ + */ │ │ │ │ + unselectAll: function(options) { │ │ │ │ + // we'll want an option to supress notification here │ │ │ │ + var layers = this.layers || [this.layer], │ │ │ │ + layer, feature, l, numExcept; │ │ │ │ + for (l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + numExcept = 0; │ │ │ │ + //layer.selectedFeatures is null when layer is destroyed and │ │ │ │ + //one of it's preremovelayer listener calls setLayer │ │ │ │ + //with another layer on this control │ │ │ │ + if (layer.selectedFeatures != null) { │ │ │ │ + while (layer.selectedFeatures.length > numExcept) { │ │ │ │ + feature = layer.selectedFeatures[numExcept]; │ │ │ │ + if (!options || options.except != feature) { │ │ │ │ + this.unselect(feature); │ │ │ │ + } else { │ │ │ │ + ++numExcept; │ │ │ │ + } │ │ │ │ } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ - this.contentDiv.style.top = this.padding.top + "px"; │ │ │ │ + /** │ │ │ │ + * Method: clickFeature │ │ │ │ + * Called on click in a feature │ │ │ │ + * Only responds if this.hover is false. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + clickFeature: function(feature) { │ │ │ │ + if (!this.hover) { │ │ │ │ + var selected = (OpenLayers.Util.indexOf( │ │ │ │ + feature.layer.selectedFeatures, feature) > -1); │ │ │ │ + if (selected) { │ │ │ │ + if (this.toggleSelect()) { │ │ │ │ + this.unselect(feature); │ │ │ │ + } else if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + this.select(feature); │ │ │ │ } │ │ │ │ - }, │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ - }); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Popup/FramedCloud.js │ │ │ │ - ====================================================================== */ │ │ │ │ + /** │ │ │ │ + * Method: multipleSelect │ │ │ │ + * Allow for multiple selected features based on <multiple> property and │ │ │ │ + * <multipleKey> event modifier. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Allow for multiple selected features. │ │ │ │ + */ │ │ │ │ + multipleSelect: function() { │ │ │ │ + return this.multiple || (this.handlers.feature.evt && │ │ │ │ + this.handlers.feature.evt[this.multipleKey]); │ │ │ │ + }, │ │ │ │ │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ + /** │ │ │ │ + * Method: toggleSelect │ │ │ │ + * Event should toggle the selected state of a feature based on <toggle> │ │ │ │ + * property and <toggleKey> event modifier. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} Toggle the selected state of a feature. │ │ │ │ + */ │ │ │ │ + toggleSelect: function() { │ │ │ │ + return this.toggle || (this.handlers.feature.evt && │ │ │ │ + this.handlers.feature.evt[this.toggleKey]); │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Popup/Framed.js │ │ │ │ - * @requires OpenLayers/Util.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Bounds.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Pixel.js │ │ │ │ - * @requires OpenLayers/BaseTypes/Size.js │ │ │ │ - */ │ │ │ │ + /** │ │ │ │ + * Method: clickoutFeature │ │ │ │ + * Called on click outside a previously clicked (selected) feature. │ │ │ │ + * Only responds if this.hover is false. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Vector.Feature>} │ │ │ │ + */ │ │ │ │ + clickoutFeature: function(feature) { │ │ │ │ + if (!this.hover && this.clickout) { │ │ │ │ + this.unselectAll(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Popup.FramedCloud │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Popup.Framed> │ │ │ │ - */ │ │ │ │ -OpenLayers.Popup.FramedCloud = │ │ │ │ - OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ + /** │ │ │ │ + * Method: overFeature │ │ │ │ + * Called on over a feature. │ │ │ │ + * Only responds if this.hover is true. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + overFeature: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + this.highlight(feature); │ │ │ │ + } else if (OpenLayers.Util.indexOf( │ │ │ │ + layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: contentDisplayClass │ │ │ │ - * {String} The CSS class of the popup content div. │ │ │ │ - */ │ │ │ │ - contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ + /** │ │ │ │ + * Method: outFeature │ │ │ │ + * Called on out of a selected feature. │ │ │ │ + * Only responds if this.hover is true. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + outFeature: function(feature) { │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + // we do nothing if we're not the last highlighter of the │ │ │ │ + // feature │ │ │ │ + if (feature._lastHighlighter == this.id) { │ │ │ │ + // if another select control had highlighted the feature before │ │ │ │ + // we did it ourself then we use that control to highlight the │ │ │ │ + // feature as it was before we highlighted it, else we just │ │ │ │ + // unhighlight it │ │ │ │ + if (feature._prevHighlighter && │ │ │ │ + feature._prevHighlighter != this.id) { │ │ │ │ + delete feature._lastHighlighter; │ │ │ │ + var control = this.map.getControl( │ │ │ │ + feature._prevHighlighter); │ │ │ │ + if (control) { │ │ │ │ + control.highlight(feature); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unhighlight(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unselect(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: autoSize │ │ │ │ - * {Boolean} Framed Cloud is autosizing by default. │ │ │ │ - */ │ │ │ │ - autoSize: true, │ │ │ │ + /** │ │ │ │ + * Method: highlight │ │ │ │ + * Redraw feature with the select style. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + highlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ + feature._lastHighlighter = this.id; │ │ │ │ + var style = this.selectStyle || this.renderIntent; │ │ │ │ + layer.drawFeature(feature, style); │ │ │ │ + this.events.triggerEvent("featurehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: panMapIfOutOfView │ │ │ │ - * {Boolean} Framed Cloud does pan into view by default. │ │ │ │ - */ │ │ │ │ - panMapIfOutOfView: true, │ │ │ │ + /** │ │ │ │ + * Method: unhighlight │ │ │ │ + * Redraw feature with the "default" style │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + unhighlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + // three cases: │ │ │ │ + // 1. there's no other highlighter, in that case _prev is undefined, │ │ │ │ + // and we just need to undef _last │ │ │ │ + // 2. another control highlighted the feature after we did it, in │ │ │ │ + // that case _last references this other control, and we just │ │ │ │ + // need to undef _prev │ │ │ │ + // 3. another control highlighted the feature before we did it, in │ │ │ │ + // that case _prev references this other control, and we need to │ │ │ │ + // set _last to _prev and undef _prev │ │ │ │ + if (feature._prevHighlighter == undefined) { │ │ │ │ + delete feature._lastHighlighter; │ │ │ │ + } else if (feature._prevHighlighter == this.id) { │ │ │ │ + delete feature._prevHighlighter; │ │ │ │ + } else { │ │ │ │ + feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ + delete feature._prevHighlighter; │ │ │ │ + } │ │ │ │ + layer.drawFeature(feature, feature.style || feature.layer.style || │ │ │ │ + "default"); │ │ │ │ + this.events.triggerEvent("featureunhighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: imageSize │ │ │ │ - * {<OpenLayers.Size>} │ │ │ │ - */ │ │ │ │ - imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ + /** │ │ │ │ + * Method: select │ │ │ │ + * Add feature to the layer's selectedFeature array, render the feature as │ │ │ │ + * selected, and call the onSelect function. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + select: function(feature) { │ │ │ │ + var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (cont !== false) { │ │ │ │ + cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + layer.selectedFeatures.push(feature); │ │ │ │ + this.highlight(feature); │ │ │ │ + // if the feature handler isn't involved in the feature │ │ │ │ + // selection (because the box handler is used or the │ │ │ │ + // feature is selected programatically) we fake the │ │ │ │ + // feature handler to allow unselecting on click │ │ │ │ + if (!this.handlers.feature.lastFeature) { │ │ │ │ + this.handlers.feature.lastFeature = layer.selectedFeatures[0]; │ │ │ │ + } │ │ │ │ + layer.events.triggerEvent("featureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onSelect.call(this.scope, feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: isAlphaImage │ │ │ │ - * {Boolean} The FramedCloud does not use an alpha image (in honor of the │ │ │ │ - * good ie6 folk out there) │ │ │ │ - */ │ │ │ │ - isAlphaImage: false, │ │ │ │ + /** │ │ │ │ + * Method: unselect │ │ │ │ + * Remove feature from the layer's selectedFeature array, render the feature as │ │ │ │ + * normal, and call the onUnselect function. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * feature - {<OpenLayers.Feature.Vector>} │ │ │ │ + */ │ │ │ │ + unselect: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + // Store feature style for restoration later │ │ │ │ + this.unhighlight(feature); │ │ │ │ + OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ + layer.events.triggerEvent("featureunselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onUnselect.call(this.scope, feature); │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: fixedRelativePosition │ │ │ │ - * {Boolean} The Framed Cloud popup works in just one fixed position. │ │ │ │ - */ │ │ │ │ - fixedRelativePosition: false, │ │ │ │ + /** │ │ │ │ + * Method: selectBox │ │ │ │ + * Callback from the handlers.box set up when <box> selection is true │ │ │ │ + * on. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * position - {<OpenLayers.Bounds> || <OpenLayers.Pixel> } │ │ │ │ + */ │ │ │ │ + selectBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + var bounds = new OpenLayers.Bounds( │ │ │ │ + minXY.lon, minXY.lat, maxXY.lon, maxXY.lat │ │ │ │ + ); │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: positionBlocks │ │ │ │ - * {Object} Hash of differen position blocks, keyed by relativePosition │ │ │ │ - * two-character code string (ie "tl", "tr", "bl", "br") │ │ │ │ - */ │ │ │ │ - positionBlocks: { │ │ │ │ - "tl": { │ │ │ │ - 'offset': new OpenLayers.Pixel(44, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 18), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -688) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - "tr": { │ │ │ │ - 'offset': new OpenLayers.Pixel(-45, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 19), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ - position: new OpenLayers.Pixel(-215, -687) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - "bl": { │ │ │ │ - 'offset': new OpenLayers.Pixel(45, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-101, -674) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - "br": { │ │ │ │ - 'offset': new OpenLayers.Pixel(-44, 0), │ │ │ │ - 'padding': new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - 'blocks': [{ // top-left │ │ │ │ - size: new OpenLayers.Size('auto', 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { //top-right │ │ │ │ - size: new OpenLayers.Size(22, 'auto'), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { //bottom-left │ │ │ │ - size: new OpenLayers.Size('auto', 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { //bottom-right │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { // stem │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ - position: new OpenLayers.Pixel(-311, -674) │ │ │ │ - }] │ │ │ │ + // if multiple is false, first deselect currently selected features │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll(); │ │ │ │ } │ │ │ │ - }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: minSize │ │ │ │ - * {<OpenLayers.Size>} │ │ │ │ - */ │ │ │ │ - minSize: new OpenLayers.Size(105, 10), │ │ │ │ + // because we're using a box, we consider we want multiple selection │ │ │ │ + var prevMultiple = this.multiple; │ │ │ │ + this.multiple = true; │ │ │ │ + var layers = this.layers || [this.layer]; │ │ │ │ + this.events.triggerEvent("boxselectionstart", { │ │ │ │ + layers: layers │ │ │ │ + }); │ │ │ │ + var layer; │ │ │ │ + for (var l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ + var feature = layer.features[i]; │ │ │ │ + // check if the feature is displayed │ │ │ │ + if (!feature.getVisibility()) { │ │ │ │ + continue; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: maxSize │ │ │ │ - * {<OpenLayers.Size>} │ │ │ │ - */ │ │ │ │ - maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ + if (this.geometryTypes == null || OpenLayers.Util.indexOf( │ │ │ │ + this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ + if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ + if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.multiple = prevMultiple; │ │ │ │ + this.events.triggerEvent("boxselectionend", { │ │ │ │ + layers: layers │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Constructor: OpenLayers.Popup.FramedCloud │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {String} │ │ │ │ - * lonlat - {<OpenLayers.LonLat>} │ │ │ │ - * contentSize - {<OpenLayers.Size>} │ │ │ │ - * contentHTML - {String} │ │ │ │ - * anchor - {Object} Object to which we'll anchor the popup. Must expose │ │ │ │ - * a 'size' (<OpenLayers.Size>) and 'offset' (<OpenLayers.Pixel>) │ │ │ │ - * (Note that this is generally an <OpenLayers.Icon>). │ │ │ │ - * closeBox - {Boolean} │ │ │ │ - * closeBoxCallback - {Function} Function to be called on closeBox click. │ │ │ │ - */ │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, │ │ │ │ - closeBoxCallback) { │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + * Set the map property for the control. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * map - {<OpenLayers.Map>} │ │ │ │ + */ │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.feature.setMap(map); │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box.setMap(map); │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.imageSrc = OpenLayers.Util.getImageLocation('cloud-popup-relative.png'); │ │ │ │ - OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass; │ │ │ │ - }, │ │ │ │ + /** │ │ │ │ + * APIMethod: setLayer │ │ │ │ + * Attach a new layer to the control, overriding any existing layers. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * layers - Array of {<OpenLayers.Layer.Vector>} or a single │ │ │ │ + * {<OpenLayers.Layer.Vector>} │ │ │ │ + */ │ │ │ │ + setLayer: function(layers) { │ │ │ │ + var isActive = this.active; │ │ │ │ + this.unselectAll(); │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy(); │ │ │ │ + this.layers = null; │ │ │ │ + } │ │ │ │ + this.initLayer(layers); │ │ │ │ + this.handlers.feature.layer = this.layer; │ │ │ │ + if (isActive) { │ │ │ │ + this.activate(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ - }); │ │ │ │ + CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ +}); │ │ ├── ./usr/share/javascript/openlayers/OpenLayers.light.min.js │ │ │ ├── js-beautify {} │ │ │ │ @@ -62,14 +62,204 @@ │ │ │ │ var sourceIsEvt = typeof window.Event == "function" && source instanceof window.Event; │ │ │ │ if (!sourceIsEvt && source.hasOwnProperty && source.hasOwnProperty("toString")) { │ │ │ │ destination.toString = source.toString │ │ │ │ } │ │ │ │ } │ │ │ │ return destination │ │ │ │ }; │ │ │ │ +OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ +OpenLayers.Util.vendorPrefix = function() { │ │ │ │ + "use strict"; │ │ │ │ + var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ + divStyle = document.createElement("div").style, │ │ │ │ + cssCache = {}, │ │ │ │ + jsCache = {}; │ │ │ │ + │ │ │ │ + function domToCss(prefixedDom) { │ │ │ │ + if (!prefixedDom) { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ + return prefixedDom.replace(/([A-Z])/g, function(c) { │ │ │ │ + return "-" + c.toLowerCase() │ │ │ │ + }).replace(/^ms-/, "-ms-") │ │ │ │ + } │ │ │ │ + │ │ │ │ + function css(property) { │ │ │ │ + if (cssCache[property] === undefined) { │ │ │ │ + var domProperty = property.replace(/(-[\s\S])/g, function(c) { │ │ │ │ + return c.charAt(1).toUpperCase() │ │ │ │ + }); │ │ │ │ + var prefixedDom = style(domProperty); │ │ │ │ + cssCache[property] = domToCss(prefixedDom) │ │ │ │ + } │ │ │ │ + return cssCache[property] │ │ │ │ + } │ │ │ │ + │ │ │ │ + function js(obj, property) { │ │ │ │ + if (jsCache[property] === undefined) { │ │ │ │ + var tmpProp, i = 0, │ │ │ │ + l = VENDOR_PREFIXES.length, │ │ │ │ + prefix, isStyleObj = typeof obj.cssText !== "undefined"; │ │ │ │ + jsCache[property] = null; │ │ │ │ + for (; i < l; i++) { │ │ │ │ + prefix = VENDOR_PREFIXES[i]; │ │ │ │ + if (prefix) { │ │ │ │ + if (!isStyleObj) { │ │ │ │ + prefix = prefix.toLowerCase() │ │ │ │ + } │ │ │ │ + tmpProp = prefix + property.charAt(0).toUpperCase() + property.slice(1) │ │ │ │ + } else { │ │ │ │ + tmpProp = property │ │ │ │ + } │ │ │ │ + if (obj[tmpProp] !== undefined) { │ │ │ │ + jsCache[property] = tmpProp; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return jsCache[property] │ │ │ │ + } │ │ │ │ + │ │ │ │ + function style(property) { │ │ │ │ + return js(divStyle, property) │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + css: css, │ │ │ │ + js: js, │ │ │ │ + style: style, │ │ │ │ + cssCache: cssCache, │ │ │ │ + jsCache: jsCache │ │ │ │ + } │ │ │ │ +}(); │ │ │ │ +OpenLayers.Animation = function(window) { │ │ │ │ + var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ + var isNative = !!requestAnimationFrame; │ │ │ │ + var requestFrame = function() { │ │ │ │ + var request = window[requestAnimationFrame] || function(callback, element) { │ │ │ │ + window.setTimeout(callback, 16) │ │ │ │ + }; │ │ │ │ + return function(callback, element) { │ │ │ │ + request.apply(window, [callback, element]) │ │ │ │ + } │ │ │ │ + }(); │ │ │ │ + var counter = 0; │ │ │ │ + var loops = {}; │ │ │ │ + │ │ │ │ + function start(callback, duration, element) { │ │ │ │ + duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ + var id = ++counter; │ │ │ │ + var start = +new Date; │ │ │ │ + loops[id] = function() { │ │ │ │ + if (loops[id] && +new Date - start <= duration) { │ │ │ │ + callback(); │ │ │ │ + if (loops[id]) { │ │ │ │ + requestFrame(loops[id], element) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + delete loops[id] │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + return id │ │ │ │ + } │ │ │ │ + │ │ │ │ + function stop(id) { │ │ │ │ + delete loops[id] │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + isNative: isNative, │ │ │ │ + requestFrame: requestFrame, │ │ │ │ + start: start, │ │ │ │ + stop: stop │ │ │ │ + } │ │ │ │ +}(window); │ │ │ │ +OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ + threshold: 0, │ │ │ │ + deceleration: .0035, │ │ │ │ + nbPoints: 100, │ │ │ │ + delay: 200, │ │ │ │ + points: undefined, │ │ │ │ + timerId: undefined, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options) │ │ │ │ + }, │ │ │ │ + begin: function() { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = undefined; │ │ │ │ + this.points = [] │ │ │ │ + }, │ │ │ │ + update: function(xy) { │ │ │ │ + this.points.unshift({ │ │ │ │ + xy: xy, │ │ │ │ + tick: (new Date).getTime() │ │ │ │ + }); │ │ │ │ + if (this.points.length > this.nbPoints) { │ │ │ │ + this.points.pop() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + end: function(xy) { │ │ │ │ + var last, now = (new Date).getTime(); │ │ │ │ + for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ + point = this.points[i]; │ │ │ │ + if (now - point.tick > this.delay) { │ │ │ │ + break │ │ │ │ + } │ │ │ │ + last = point │ │ │ │ + } │ │ │ │ + if (!last) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var time = (new Date).getTime() - last.tick; │ │ │ │ + var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ + var speed = dist / time; │ │ │ │ + if (speed == 0 || speed < this.threshold) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ + if (last.xy.x <= xy.x) { │ │ │ │ + theta = Math.PI - theta │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + speed: speed, │ │ │ │ + theta: theta │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + move: function(info, callback) { │ │ │ │ + var v0 = info.speed; │ │ │ │ + var fx = Math.cos(info.theta); │ │ │ │ + var fy = -Math.sin(info.theta); │ │ │ │ + var initialTime = (new Date).getTime(); │ │ │ │ + var lastX = 0; │ │ │ │ + var lastY = 0; │ │ │ │ + var timerCallback = function() { │ │ │ │ + if (this.timerId == null) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var t = (new Date).getTime() - initialTime; │ │ │ │ + var p = -this.deceleration * Math.pow(t, 2) / 2 + v0 * t; │ │ │ │ + var x = p * fx; │ │ │ │ + var y = p * fy; │ │ │ │ + var args = {}; │ │ │ │ + args.end = false; │ │ │ │ + var v = -this.deceleration * t + v0; │ │ │ │ + if (v <= 0) { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + args.end = true │ │ │ │ + } │ │ │ │ + args.x = x - lastX; │ │ │ │ + args.y = y - lastY; │ │ │ │ + lastX = x; │ │ │ │ + lastY = y; │ │ │ │ + callback(args.x, args.y, args.end) │ │ │ │ + }; │ │ │ │ + this.timerId = OpenLayers.Animation.start(OpenLayers.Function.bind(timerCallback, this)) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ +}); │ │ │ │ OpenLayers.String = { │ │ │ │ startsWith: function(str, sub) { │ │ │ │ return str.indexOf(sub) == 0 │ │ │ │ }, │ │ │ │ contains: function(str, sub) { │ │ │ │ return str.indexOf(sub) != -1 │ │ │ │ }, │ │ │ │ @@ -1605,611 +1795,14 @@ │ │ │ │ if (axis == "lon") { │ │ │ │ str += coordinate < 0 ? OpenLayers.i18n("W") : OpenLayers.i18n("E") │ │ │ │ } else { │ │ │ │ str += coordinate < 0 ? OpenLayers.i18n("S") : OpenLayers.i18n("N") │ │ │ │ } │ │ │ │ return str │ │ │ │ }; │ │ │ │ -OpenLayers.Feature = OpenLayers.Class({ │ │ │ │ - layer: null, │ │ │ │ - id: null, │ │ │ │ - lonlat: null, │ │ │ │ - data: null, │ │ │ │ - marker: null, │ │ │ │ - popupClass: null, │ │ │ │ - popup: null, │ │ │ │ - initialize: function(layer, lonlat, data) { │ │ │ │ - this.layer = layer; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - this.data = data != null ? data : {}; │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layer != null && this.layer.map != null) { │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.layer.map.removePopup(this.popup) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.layer != null && this.marker != null) { │ │ │ │ - this.layer.removeMarker(this.marker) │ │ │ │ - } │ │ │ │ - this.layer = null; │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.data = null; │ │ │ │ - if (this.marker != null) { │ │ │ │ - this.destroyMarker(this.marker); │ │ │ │ - this.marker = null │ │ │ │ - } │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.destroyPopup(this.popup); │ │ │ │ - this.popup = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - onScreen: function() { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.layer != null && this.layer.map != null) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsLonLat(this.lonlat) │ │ │ │ - } │ │ │ │ - return onScreen │ │ │ │ - }, │ │ │ │ - createMarker: function() { │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon) │ │ │ │ - } │ │ │ │ - return this.marker │ │ │ │ - }, │ │ │ │ - destroyMarker: function() { │ │ │ │ - this.marker.destroy() │ │ │ │ - }, │ │ │ │ - createPopup: function(closeBox) { │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - if (!this.popup) { │ │ │ │ - var anchor = this.marker ? this.marker.icon : null; │ │ │ │ - var popupClass = this.popupClass ? this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ - this.popup = new popupClass(this.id + "_popup", this.lonlat, this.data.popupSize, this.data.popupContentHTML, anchor, closeBox) │ │ │ │ - } │ │ │ │ - if (this.data.overflow != null) { │ │ │ │ - this.popup.contentDiv.style.overflow = this.data.overflow │ │ │ │ - } │ │ │ │ - this.popup.feature = this │ │ │ │ - } │ │ │ │ - return this.popup │ │ │ │ - }, │ │ │ │ - destroyPopup: function() { │ │ │ │ - if (this.popup) { │ │ │ │ - this.popup.feature = null; │ │ │ │ - this.popup.destroy(); │ │ │ │ - this.popup = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Feature" │ │ │ │ -}); │ │ │ │ -OpenLayers.State = { │ │ │ │ - UNKNOWN: "Unknown", │ │ │ │ - INSERT: "Insert", │ │ │ │ - UPDATE: "Update", │ │ │ │ - DELETE: "Delete" │ │ │ │ -}; │ │ │ │ -OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ - fid: null, │ │ │ │ - geometry: null, │ │ │ │ - attributes: null, │ │ │ │ - bounds: null, │ │ │ │ - state: null, │ │ │ │ - style: null, │ │ │ │ - url: null, │ │ │ │ - renderIntent: "default", │ │ │ │ - modified: null, │ │ │ │ - initialize: function(geometry, attributes, style) { │ │ │ │ - OpenLayers.Feature.prototype.initialize.apply(this, [null, null, attributes]); │ │ │ │ - this.lonlat = null; │ │ │ │ - this.geometry = geometry ? geometry : null; │ │ │ │ - this.state = null; │ │ │ │ - this.attributes = {}; │ │ │ │ - if (attributes) { │ │ │ │ - this.attributes = OpenLayers.Util.extend(this.attributes, attributes) │ │ │ │ - } │ │ │ │ - this.style = style ? style : null │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layer) { │ │ │ │ - this.layer.removeFeatures(this); │ │ │ │ - this.layer = null │ │ │ │ - } │ │ │ │ - this.geometry = null; │ │ │ │ - this.modified = null; │ │ │ │ - OpenLayers.Feature.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Feature.Vector(this.geometry ? this.geometry.clone() : null, this.attributes, this.style) │ │ │ │ - }, │ │ │ │ - onScreen: function(boundsOnly) { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.layer && this.layer.map) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - if (boundsOnly) { │ │ │ │ - var featureBounds = this.geometry.getBounds(); │ │ │ │ - onScreen = screenBounds.intersectsBounds(featureBounds) │ │ │ │ - } else { │ │ │ │ - var screenPoly = screenBounds.toGeometry(); │ │ │ │ - onScreen = screenPoly.intersects(this.geometry) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return onScreen │ │ │ │ - }, │ │ │ │ - getVisibility: function() { │ │ │ │ - return !(this.style && this.style.display == "none" || !this.layer || this.layer && this.layer.styleMap && this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == "none" || this.layer && !this.layer.getVisibility()) │ │ │ │ - }, │ │ │ │ - createMarker: function() { │ │ │ │ - return null │ │ │ │ - }, │ │ │ │ - destroyMarker: function() {}, │ │ │ │ - createPopup: function() { │ │ │ │ - return null │ │ │ │ - }, │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - if (this.geometry) { │ │ │ │ - atPoint = this.geometry.atPoint(lonlat, toleranceLon, toleranceLat) │ │ │ │ - } │ │ │ │ - return atPoint │ │ │ │ - }, │ │ │ │ - destroyPopup: function() {}, │ │ │ │ - move: function(location) { │ │ │ │ - if (!this.layer || !this.geometry.move) { │ │ │ │ - return undefined │ │ │ │ - } │ │ │ │ - var pixel; │ │ │ │ - if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ - pixel = this.layer.getViewPortPxFromLonLat(location) │ │ │ │ - } else { │ │ │ │ - pixel = location │ │ │ │ - } │ │ │ │ - var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ - var res = this.layer.map.getResolution(); │ │ │ │ - this.geometry.move(res * (pixel.x - lastPixel.x), res * (lastPixel.y - pixel.y)); │ │ │ │ - this.layer.drawFeature(this); │ │ │ │ - return lastPixel │ │ │ │ - }, │ │ │ │ - toState: function(state) { │ │ │ │ - if (state == OpenLayers.State.UPDATE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.INSERT) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - this.state = state; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.DELETE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - this.state = state; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ - this.state = state │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ -}); │ │ │ │ -OpenLayers.Feature.Vector.style = { │ │ │ │ - default: { │ │ │ │ - fillColor: "#ee9900", │ │ │ │ - fillOpacity: .4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: .8, │ │ │ │ - strokeColor: "#ee9900", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: .2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - select: { │ │ │ │ - fillColor: "blue", │ │ │ │ - fillOpacity: .4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: .8, │ │ │ │ - strokeColor: "blue", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: .2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "pointer", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - temporary: { │ │ │ │ - fillColor: "#66cccc", │ │ │ │ - fillOpacity: .2, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: .8, │ │ │ │ - strokeColor: "#66cccc", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: .2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - delete: { │ │ │ │ - display: "none" │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -OpenLayers.Style = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - name: null, │ │ │ │ - title: null, │ │ │ │ - description: null, │ │ │ │ - layerName: null, │ │ │ │ - isDefault: false, │ │ │ │ - rules: null, │ │ │ │ - context: null, │ │ │ │ - defaultStyle: null, │ │ │ │ - defaultsPerSymbolizer: false, │ │ │ │ - propertyStyles: null, │ │ │ │ - initialize: function(style, options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.rules = []; │ │ │ │ - if (options && options.rules) { │ │ │ │ - this.addRules(options.rules) │ │ │ │ - } │ │ │ │ - this.setDefaultStyle(style || OpenLayers.Feature.Vector.style["default"]); │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ - this.rules[i].destroy(); │ │ │ │ - this.rules[i] = null │ │ │ │ - } │ │ │ │ - this.rules = null; │ │ │ │ - this.defaultStyle = null │ │ │ │ - }, │ │ │ │ - createSymbolizer: function(feature) { │ │ │ │ - var style = this.defaultsPerSymbolizer ? {} : this.createLiterals(OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ - var rules = this.rules; │ │ │ │ - var rule, context; │ │ │ │ - var elseRules = []; │ │ │ │ - var appliedRules = false; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - rule = rules[i]; │ │ │ │ - var applies = rule.evaluate(feature); │ │ │ │ - if (applies) { │ │ │ │ - if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ - elseRules.push(rule) │ │ │ │ - } else { │ │ │ │ - appliedRules = true; │ │ │ │ - this.applySymbolizer(rule, style, feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (appliedRules == false && elseRules.length > 0) { │ │ │ │ - appliedRules = true; │ │ │ │ - for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ - this.applySymbolizer(elseRules[i], style, feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (rules.length > 0 && appliedRules == false) { │ │ │ │ - style.display = "none" │ │ │ │ - } │ │ │ │ - if (style.label != null && typeof style.label !== "string") { │ │ │ │ - style.label = String(style.label) │ │ │ │ - } │ │ │ │ - return style │ │ │ │ - }, │ │ │ │ - applySymbolizer: function(rule, style, feature) { │ │ │ │ - var symbolizerPrefix = feature.geometry ? this.getSymbolizerPrefix(feature.geometry) : OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ - var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ - if (this.defaultsPerSymbolizer === true) { │ │ │ │ - var defaults = this.defaultStyle; │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: defaults.pointRadius │ │ │ │ - }); │ │ │ │ - if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - strokeWidth: defaults.strokeWidth, │ │ │ │ - strokeColor: defaults.strokeColor, │ │ │ │ - strokeOpacity: defaults.strokeOpacity, │ │ │ │ - strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ - strokeLinecap: defaults.strokeLinecap │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - fillColor: defaults.fillColor, │ │ │ │ - fillOpacity: defaults.fillOpacity │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: this.defaultStyle.pointRadius, │ │ │ │ - externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ - graphicName: this.defaultStyle.graphicName, │ │ │ │ - graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ - graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ - graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ - graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ - graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return this.createLiterals(OpenLayers.Util.extend(style, symbolizer), feature) │ │ │ │ - }, │ │ │ │ - createLiterals: function(style, feature) { │ │ │ │ - var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ - OpenLayers.Util.extend(context, this.context); │ │ │ │ - for (var i in this.propertyStyles) { │ │ │ │ - style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i) │ │ │ │ - } │ │ │ │ - return style │ │ │ │ - }, │ │ │ │ - findPropertyStyles: function() { │ │ │ │ - var propertyStyles = {}; │ │ │ │ - var style = this.defaultStyle; │ │ │ │ - this.addPropertyStyles(propertyStyles, style); │ │ │ │ - var rules = this.rules; │ │ │ │ - var symbolizer, value; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - symbolizer = rules[i].symbolizer; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - value = symbolizer[key]; │ │ │ │ - if (typeof value == "object") { │ │ │ │ - this.addPropertyStyles(propertyStyles, value) │ │ │ │ - } else { │ │ │ │ - this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return propertyStyles │ │ │ │ - }, │ │ │ │ - addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ - var property; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - property = symbolizer[key]; │ │ │ │ - if (typeof property == "string" && property.match(/\$\{\w+\}/)) { │ │ │ │ - propertyStyles[key] = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return propertyStyles │ │ │ │ - }, │ │ │ │ - addRules: function(rules) { │ │ │ │ - Array.prototype.push.apply(this.rules, rules); │ │ │ │ - this.propertyStyles = this.findPropertyStyles() │ │ │ │ - }, │ │ │ │ - setDefaultStyle: function(style) { │ │ │ │ - this.defaultStyle = style; │ │ │ │ - this.propertyStyles = this.findPropertyStyles() │ │ │ │ - }, │ │ │ │ - getSymbolizerPrefix: function(geometry) { │ │ │ │ - var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ - for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ - if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ - return prefixes[i] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.rules) { │ │ │ │ - options.rules = []; │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ - options.rules.push(this.rules[i].clone()) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ - return new OpenLayers.Style(defaultStyle, options) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Style" │ │ │ │ -}); │ │ │ │ -OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ - if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ - value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ - value = isNaN(value) || !value ? value : parseFloat(value) │ │ │ │ - } │ │ │ │ - return value │ │ │ │ -}; │ │ │ │ -OpenLayers.Style.SYMBOLIZER_PREFIXES = ["Point", "Line", "Polygon", "Text", "Raster"]; │ │ │ │ -OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - name: null, │ │ │ │ - title: null, │ │ │ │ - description: null, │ │ │ │ - context: null, │ │ │ │ - filter: null, │ │ │ │ - elseFilter: false, │ │ │ │ - symbolizer: null, │ │ │ │ - symbolizers: null, │ │ │ │ - minScaleDenominator: null, │ │ │ │ - maxScaleDenominator: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.symbolizer = {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - delete this.symbolizer │ │ │ │ - } │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i in this.symbolizer) { │ │ │ │ - this.symbolizer[i] = null │ │ │ │ - } │ │ │ │ - this.symbolizer = null; │ │ │ │ - delete this.symbolizers │ │ │ │ - }, │ │ │ │ - evaluate: function(feature) { │ │ │ │ - var context = this.getContext(feature); │ │ │ │ - var applies = true; │ │ │ │ - if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ - var scale = feature.layer.map.getScale() │ │ │ │ - } │ │ │ │ - if (this.minScaleDenominator) { │ │ │ │ - applies = scale >= OpenLayers.Style.createLiteral(this.minScaleDenominator, context) │ │ │ │ - } │ │ │ │ - if (applies && this.maxScaleDenominator) { │ │ │ │ - applies = scale < OpenLayers.Style.createLiteral(this.maxScaleDenominator, context) │ │ │ │ - } │ │ │ │ - if (applies && this.filter) { │ │ │ │ - if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ - applies = this.filter.evaluate(feature) │ │ │ │ - } else { │ │ │ │ - applies = this.filter.evaluate(context) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return applies │ │ │ │ - }, │ │ │ │ - getContext: function(feature) { │ │ │ │ - var context = this.context; │ │ │ │ - if (!context) { │ │ │ │ - context = feature.attributes || feature.data │ │ │ │ - } │ │ │ │ - if (typeof this.context == "function") { │ │ │ │ - context = this.context(feature) │ │ │ │ - } │ │ │ │ - return context │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - var len = this.symbolizers.length; │ │ │ │ - options.symbolizers = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - options.symbolizers[i] = this.symbolizers[i].clone() │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - options.symbolizer = {}; │ │ │ │ - var value, type; │ │ │ │ - for (var key in this.symbolizer) { │ │ │ │ - value = this.symbolizer[key]; │ │ │ │ - type = typeof value; │ │ │ │ - if (type === "object") { │ │ │ │ - options.symbolizer[key] = OpenLayers.Util.extend({}, value) │ │ │ │ - } else if (type === "string") { │ │ │ │ - options.symbolizer[key] = value │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - options.filter = this.filter && this.filter.clone(); │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - return new OpenLayers.Rule(options) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Rule" │ │ │ │ -}); │ │ │ │ -OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ -OpenLayers.Util.vendorPrefix = function() { │ │ │ │ - "use strict"; │ │ │ │ - var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ - divStyle = document.createElement("div").style, │ │ │ │ - cssCache = {}, │ │ │ │ - jsCache = {}; │ │ │ │ - │ │ │ │ - function domToCss(prefixedDom) { │ │ │ │ - if (!prefixedDom) { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ - return prefixedDom.replace(/([A-Z])/g, function(c) { │ │ │ │ - return "-" + c.toLowerCase() │ │ │ │ - }).replace(/^ms-/, "-ms-") │ │ │ │ - } │ │ │ │ - │ │ │ │ - function css(property) { │ │ │ │ - if (cssCache[property] === undefined) { │ │ │ │ - var domProperty = property.replace(/(-[\s\S])/g, function(c) { │ │ │ │ - return c.charAt(1).toUpperCase() │ │ │ │ - }); │ │ │ │ - var prefixedDom = style(domProperty); │ │ │ │ - cssCache[property] = domToCss(prefixedDom) │ │ │ │ - } │ │ │ │ - return cssCache[property] │ │ │ │ - } │ │ │ │ - │ │ │ │ - function js(obj, property) { │ │ │ │ - if (jsCache[property] === undefined) { │ │ │ │ - var tmpProp, i = 0, │ │ │ │ - l = VENDOR_PREFIXES.length, │ │ │ │ - prefix, isStyleObj = typeof obj.cssText !== "undefined"; │ │ │ │ - jsCache[property] = null; │ │ │ │ - for (; i < l; i++) { │ │ │ │ - prefix = VENDOR_PREFIXES[i]; │ │ │ │ - if (prefix) { │ │ │ │ - if (!isStyleObj) { │ │ │ │ - prefix = prefix.toLowerCase() │ │ │ │ - } │ │ │ │ - tmpProp = prefix + property.charAt(0).toUpperCase() + property.slice(1) │ │ │ │ - } else { │ │ │ │ - tmpProp = property │ │ │ │ - } │ │ │ │ - if (obj[tmpProp] !== undefined) { │ │ │ │ - jsCache[property] = tmpProp; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return jsCache[property] │ │ │ │ - } │ │ │ │ - │ │ │ │ - function style(property) { │ │ │ │ - return js(divStyle, property) │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - css: css, │ │ │ │ - js: js, │ │ │ │ - style: style, │ │ │ │ - cssCache: cssCache, │ │ │ │ - jsCache: jsCache │ │ │ │ - } │ │ │ │ -}(); │ │ │ │ OpenLayers.Event = { │ │ │ │ observers: false, │ │ │ │ KEY_SPACE: 32, │ │ │ │ KEY_BACKSPACE: 8, │ │ │ │ KEY_TAB: 9, │ │ │ │ KEY_RETURN: 13, │ │ │ │ KEY_ESC: 27, │ │ │ │ @@ -2660,56 +2253,14 @@ │ │ │ │ e.touches = touches.slice(); │ │ │ │ handler(e) │ │ │ │ }; │ │ │ │ OpenLayers.Event.observe(element, "MSPointerUp", cb) │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Events" │ │ │ │ }); │ │ │ │ -OpenLayers.Animation = function(window) { │ │ │ │ - var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ - var isNative = !!requestAnimationFrame; │ │ │ │ - var requestFrame = function() { │ │ │ │ - var request = window[requestAnimationFrame] || function(callback, element) { │ │ │ │ - window.setTimeout(callback, 16) │ │ │ │ - }; │ │ │ │ - return function(callback, element) { │ │ │ │ - request.apply(window, [callback, element]) │ │ │ │ - } │ │ │ │ - }(); │ │ │ │ - var counter = 0; │ │ │ │ - var loops = {}; │ │ │ │ - │ │ │ │ - function start(callback, duration, element) { │ │ │ │ - duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ - var id = ++counter; │ │ │ │ - var start = +new Date; │ │ │ │ - loops[id] = function() { │ │ │ │ - if (loops[id] && +new Date - start <= duration) { │ │ │ │ - callback(); │ │ │ │ - if (loops[id]) { │ │ │ │ - requestFrame(loops[id], element) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - delete loops[id] │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - return id │ │ │ │ - } │ │ │ │ - │ │ │ │ - function stop(id) { │ │ │ │ - delete loops[id] │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - isNative: isNative, │ │ │ │ - requestFrame: requestFrame, │ │ │ │ - start: start, │ │ │ │ - stop: stop │ │ │ │ - } │ │ │ │ -}(window); │ │ │ │ OpenLayers.Tween = OpenLayers.Class({ │ │ │ │ easing: null, │ │ │ │ begin: null, │ │ │ │ finish: null, │ │ │ │ duration: null, │ │ │ │ callbacks: null, │ │ │ │ time: null, │ │ │ │ @@ -4130,14 +3681,462 @@ │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Map" │ │ │ │ }); │ │ │ │ OpenLayers.Map.TILE_WIDTH = 256; │ │ │ │ OpenLayers.Map.TILE_HEIGHT = 256; │ │ │ │ +OpenLayers.Feature = OpenLayers.Class({ │ │ │ │ + layer: null, │ │ │ │ + id: null, │ │ │ │ + lonlat: null, │ │ │ │ + data: null, │ │ │ │ + marker: null, │ │ │ │ + popupClass: null, │ │ │ │ + popup: null, │ │ │ │ + initialize: function(layer, lonlat, data) { │ │ │ │ + this.layer = layer; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + this.data = data != null ? data : {}; │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layer != null && this.layer.map != null) { │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.layer.map.removePopup(this.popup) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.layer != null && this.marker != null) { │ │ │ │ + this.layer.removeMarker(this.marker) │ │ │ │ + } │ │ │ │ + this.layer = null; │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.data = null; │ │ │ │ + if (this.marker != null) { │ │ │ │ + this.destroyMarker(this.marker); │ │ │ │ + this.marker = null │ │ │ │ + } │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.destroyPopup(this.popup); │ │ │ │ + this.popup = null │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + onScreen: function() { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.layer != null && this.layer.map != null) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsLonLat(this.lonlat) │ │ │ │ + } │ │ │ │ + return onScreen │ │ │ │ + }, │ │ │ │ + createMarker: function() { │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon) │ │ │ │ + } │ │ │ │ + return this.marker │ │ │ │ + }, │ │ │ │ + destroyMarker: function() { │ │ │ │ + this.marker.destroy() │ │ │ │ + }, │ │ │ │ + createPopup: function(closeBox) { │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + if (!this.popup) { │ │ │ │ + var anchor = this.marker ? this.marker.icon : null; │ │ │ │ + var popupClass = this.popupClass ? this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ + this.popup = new popupClass(this.id + "_popup", this.lonlat, this.data.popupSize, this.data.popupContentHTML, anchor, closeBox) │ │ │ │ + } │ │ │ │ + if (this.data.overflow != null) { │ │ │ │ + this.popup.contentDiv.style.overflow = this.data.overflow │ │ │ │ + } │ │ │ │ + this.popup.feature = this │ │ │ │ + } │ │ │ │ + return this.popup │ │ │ │ + }, │ │ │ │ + destroyPopup: function() { │ │ │ │ + if (this.popup) { │ │ │ │ + this.popup.feature = null; │ │ │ │ + this.popup.destroy(); │ │ │ │ + this.popup = null │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Feature" │ │ │ │ +}); │ │ │ │ +OpenLayers.State = { │ │ │ │ + UNKNOWN: "Unknown", │ │ │ │ + INSERT: "Insert", │ │ │ │ + UPDATE: "Update", │ │ │ │ + DELETE: "Delete" │ │ │ │ +}; │ │ │ │ +OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ + fid: null, │ │ │ │ + geometry: null, │ │ │ │ + attributes: null, │ │ │ │ + bounds: null, │ │ │ │ + state: null, │ │ │ │ + style: null, │ │ │ │ + url: null, │ │ │ │ + renderIntent: "default", │ │ │ │ + modified: null, │ │ │ │ + initialize: function(geometry, attributes, style) { │ │ │ │ + OpenLayers.Feature.prototype.initialize.apply(this, [null, null, attributes]); │ │ │ │ + this.lonlat = null; │ │ │ │ + this.geometry = geometry ? geometry : null; │ │ │ │ + this.state = null; │ │ │ │ + this.attributes = {}; │ │ │ │ + if (attributes) { │ │ │ │ + this.attributes = OpenLayers.Util.extend(this.attributes, attributes) │ │ │ │ + } │ │ │ │ + this.style = style ? style : null │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layer) { │ │ │ │ + this.layer.removeFeatures(this); │ │ │ │ + this.layer = null │ │ │ │ + } │ │ │ │ + this.geometry = null; │ │ │ │ + this.modified = null; │ │ │ │ + OpenLayers.Feature.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Feature.Vector(this.geometry ? this.geometry.clone() : null, this.attributes, this.style) │ │ │ │ + }, │ │ │ │ + onScreen: function(boundsOnly) { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.layer && this.layer.map) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + if (boundsOnly) { │ │ │ │ + var featureBounds = this.geometry.getBounds(); │ │ │ │ + onScreen = screenBounds.intersectsBounds(featureBounds) │ │ │ │ + } else { │ │ │ │ + var screenPoly = screenBounds.toGeometry(); │ │ │ │ + onScreen = screenPoly.intersects(this.geometry) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return onScreen │ │ │ │ + }, │ │ │ │ + getVisibility: function() { │ │ │ │ + return !(this.style && this.style.display == "none" || !this.layer || this.layer && this.layer.styleMap && this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == "none" || this.layer && !this.layer.getVisibility()) │ │ │ │ + }, │ │ │ │ + createMarker: function() { │ │ │ │ + return null │ │ │ │ + }, │ │ │ │ + destroyMarker: function() {}, │ │ │ │ + createPopup: function() { │ │ │ │ + return null │ │ │ │ + }, │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + if (this.geometry) { │ │ │ │ + atPoint = this.geometry.atPoint(lonlat, toleranceLon, toleranceLat) │ │ │ │ + } │ │ │ │ + return atPoint │ │ │ │ + }, │ │ │ │ + destroyPopup: function() {}, │ │ │ │ + move: function(location) { │ │ │ │ + if (!this.layer || !this.geometry.move) { │ │ │ │ + return undefined │ │ │ │ + } │ │ │ │ + var pixel; │ │ │ │ + if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ + pixel = this.layer.getViewPortPxFromLonLat(location) │ │ │ │ + } else { │ │ │ │ + pixel = location │ │ │ │ + } │ │ │ │ + var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ + var res = this.layer.map.getResolution(); │ │ │ │ + this.geometry.move(res * (pixel.x - lastPixel.x), res * (lastPixel.y - pixel.y)); │ │ │ │ + this.layer.drawFeature(this); │ │ │ │ + return lastPixel │ │ │ │ + }, │ │ │ │ + toState: function(state) { │ │ │ │ + if (state == OpenLayers.State.UPDATE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.INSERT) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + this.state = state; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.DELETE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + this.state = state; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ + this.state = state │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ +}); │ │ │ │ +OpenLayers.Feature.Vector.style = { │ │ │ │ + default: { │ │ │ │ + fillColor: "#ee9900", │ │ │ │ + fillOpacity: .4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: .8, │ │ │ │ + strokeColor: "#ee9900", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: .2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + }, │ │ │ │ + select: { │ │ │ │ + fillColor: "blue", │ │ │ │ + fillOpacity: .4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: .8, │ │ │ │ + strokeColor: "blue", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: .2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "pointer", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + }, │ │ │ │ + temporary: { │ │ │ │ + fillColor: "#66cccc", │ │ │ │ + fillOpacity: .2, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: .8, │ │ │ │ + strokeColor: "#66cccc", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: .2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ + }, │ │ │ │ + delete: { │ │ │ │ + display: "none" │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +OpenLayers.Style = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + name: null, │ │ │ │ + title: null, │ │ │ │ + description: null, │ │ │ │ + layerName: null, │ │ │ │ + isDefault: false, │ │ │ │ + rules: null, │ │ │ │ + context: null, │ │ │ │ + defaultStyle: null, │ │ │ │ + defaultsPerSymbolizer: false, │ │ │ │ + propertyStyles: null, │ │ │ │ + initialize: function(style, options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.rules = []; │ │ │ │ + if (options && options.rules) { │ │ │ │ + this.addRules(options.rules) │ │ │ │ + } │ │ │ │ + this.setDefaultStyle(style || OpenLayers.Feature.Vector.style["default"]); │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ + this.rules[i].destroy(); │ │ │ │ + this.rules[i] = null │ │ │ │ + } │ │ │ │ + this.rules = null; │ │ │ │ + this.defaultStyle = null │ │ │ │ + }, │ │ │ │ + createSymbolizer: function(feature) { │ │ │ │ + var style = this.defaultsPerSymbolizer ? {} : this.createLiterals(OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ + var rules = this.rules; │ │ │ │ + var rule, context; │ │ │ │ + var elseRules = []; │ │ │ │ + var appliedRules = false; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + rule = rules[i]; │ │ │ │ + var applies = rule.evaluate(feature); │ │ │ │ + if (applies) { │ │ │ │ + if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ + elseRules.push(rule) │ │ │ │ + } else { │ │ │ │ + appliedRules = true; │ │ │ │ + this.applySymbolizer(rule, style, feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (appliedRules == false && elseRules.length > 0) { │ │ │ │ + appliedRules = true; │ │ │ │ + for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ + this.applySymbolizer(elseRules[i], style, feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (rules.length > 0 && appliedRules == false) { │ │ │ │ + style.display = "none" │ │ │ │ + } │ │ │ │ + if (style.label != null && typeof style.label !== "string") { │ │ │ │ + style.label = String(style.label) │ │ │ │ + } │ │ │ │ + return style │ │ │ │ + }, │ │ │ │ + applySymbolizer: function(rule, style, feature) { │ │ │ │ + var symbolizerPrefix = feature.geometry ? this.getSymbolizerPrefix(feature.geometry) : OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ + var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ + if (this.defaultsPerSymbolizer === true) { │ │ │ │ + var defaults = this.defaultStyle; │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: defaults.pointRadius │ │ │ │ + }); │ │ │ │ + if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + strokeWidth: defaults.strokeWidth, │ │ │ │ + strokeColor: defaults.strokeColor, │ │ │ │ + strokeOpacity: defaults.strokeOpacity, │ │ │ │ + strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ + strokeLinecap: defaults.strokeLinecap │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + fillColor: defaults.fillColor, │ │ │ │ + fillOpacity: defaults.fillOpacity │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: this.defaultStyle.pointRadius, │ │ │ │ + externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ + graphicName: this.defaultStyle.graphicName, │ │ │ │ + graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ + graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ + graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ + graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ + graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return this.createLiterals(OpenLayers.Util.extend(style, symbolizer), feature) │ │ │ │ + }, │ │ │ │ + createLiterals: function(style, feature) { │ │ │ │ + var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ + OpenLayers.Util.extend(context, this.context); │ │ │ │ + for (var i in this.propertyStyles) { │ │ │ │ + style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i) │ │ │ │ + } │ │ │ │ + return style │ │ │ │ + }, │ │ │ │ + findPropertyStyles: function() { │ │ │ │ + var propertyStyles = {}; │ │ │ │ + var style = this.defaultStyle; │ │ │ │ + this.addPropertyStyles(propertyStyles, style); │ │ │ │ + var rules = this.rules; │ │ │ │ + var symbolizer, value; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + symbolizer = rules[i].symbolizer; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + value = symbolizer[key]; │ │ │ │ + if (typeof value == "object") { │ │ │ │ + this.addPropertyStyles(propertyStyles, value) │ │ │ │ + } else { │ │ │ │ + this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return propertyStyles │ │ │ │ + }, │ │ │ │ + addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ + var property; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + property = symbolizer[key]; │ │ │ │ + if (typeof property == "string" && property.match(/\$\{\w+\}/)) { │ │ │ │ + propertyStyles[key] = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return propertyStyles │ │ │ │ + }, │ │ │ │ + addRules: function(rules) { │ │ │ │ + Array.prototype.push.apply(this.rules, rules); │ │ │ │ + this.propertyStyles = this.findPropertyStyles() │ │ │ │ + }, │ │ │ │ + setDefaultStyle: function(style) { │ │ │ │ + this.defaultStyle = style; │ │ │ │ + this.propertyStyles = this.findPropertyStyles() │ │ │ │ + }, │ │ │ │ + getSymbolizerPrefix: function(geometry) { │ │ │ │ + var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ + for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ + if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ + return prefixes[i] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.rules) { │ │ │ │ + options.rules = []; │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ + options.rules.push(this.rules[i].clone()) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ + return new OpenLayers.Style(defaultStyle, options) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Style" │ │ │ │ +}); │ │ │ │ +OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ + if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ + value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ + value = isNaN(value) || !value ? value : parseFloat(value) │ │ │ │ + } │ │ │ │ + return value │ │ │ │ +}; │ │ │ │ +OpenLayers.Style.SYMBOLIZER_PREFIXES = ["Point", "Line", "Polygon", "Text", "Raster"]; │ │ │ │ OpenLayers.StyleMap = OpenLayers.Class({ │ │ │ │ styles: null, │ │ │ │ extendDefault: true, │ │ │ │ initialize: function(style, options) { │ │ │ │ this.styles = { │ │ │ │ default: new OpenLayers.Style(OpenLayers.Feature.Vector.style["default"]), │ │ │ │ select: new OpenLayers.Style(OpenLayers.Feature.Vector.style["select"]), │ │ │ │ @@ -4199,97 +4198,390 @@ │ │ │ │ }) │ │ │ │ })) │ │ │ │ } │ │ │ │ this.styles[renderIntent].addRules(rules) │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.StyleMap" │ │ │ │ }); │ │ │ │ -OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ - threshold: 0, │ │ │ │ - deceleration: .0035, │ │ │ │ - nbPoints: 100, │ │ │ │ - delay: 200, │ │ │ │ - points: undefined, │ │ │ │ - timerId: undefined, │ │ │ │ +OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + name: null, │ │ │ │ + title: null, │ │ │ │ + description: null, │ │ │ │ + context: null, │ │ │ │ + filter: null, │ │ │ │ + elseFilter: false, │ │ │ │ + symbolizer: null, │ │ │ │ + symbolizers: null, │ │ │ │ + minScaleDenominator: null, │ │ │ │ + maxScaleDenominator: null, │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options) │ │ │ │ - }, │ │ │ │ - begin: function() { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = undefined; │ │ │ │ - this.points = [] │ │ │ │ + this.symbolizer = {}; │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + delete this.symbolizer │ │ │ │ + } │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ }, │ │ │ │ - update: function(xy) { │ │ │ │ - this.points.unshift({ │ │ │ │ - xy: xy, │ │ │ │ - tick: (new Date).getTime() │ │ │ │ - }); │ │ │ │ - if (this.points.length > this.nbPoints) { │ │ │ │ - this.points.pop() │ │ │ │ + destroy: function() { │ │ │ │ + for (var i in this.symbolizer) { │ │ │ │ + this.symbolizer[i] = null │ │ │ │ } │ │ │ │ + this.symbolizer = null; │ │ │ │ + delete this.symbolizers │ │ │ │ }, │ │ │ │ - end: function(xy) { │ │ │ │ - var last, now = (new Date).getTime(); │ │ │ │ - for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ - point = this.points[i]; │ │ │ │ - if (now - point.tick > this.delay) { │ │ │ │ - break │ │ │ │ + evaluate: function(feature) { │ │ │ │ + var context = this.getContext(feature); │ │ │ │ + var applies = true; │ │ │ │ + if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ + var scale = feature.layer.map.getScale() │ │ │ │ + } │ │ │ │ + if (this.minScaleDenominator) { │ │ │ │ + applies = scale >= OpenLayers.Style.createLiteral(this.minScaleDenominator, context) │ │ │ │ + } │ │ │ │ + if (applies && this.maxScaleDenominator) { │ │ │ │ + applies = scale < OpenLayers.Style.createLiteral(this.maxScaleDenominator, context) │ │ │ │ + } │ │ │ │ + if (applies && this.filter) { │ │ │ │ + if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ + applies = this.filter.evaluate(feature) │ │ │ │ + } else { │ │ │ │ + applies = this.filter.evaluate(context) │ │ │ │ } │ │ │ │ - last = point │ │ │ │ } │ │ │ │ - if (!last) { │ │ │ │ - return │ │ │ │ + return applies │ │ │ │ + }, │ │ │ │ + getContext: function(feature) { │ │ │ │ + var context = this.context; │ │ │ │ + if (!context) { │ │ │ │ + context = feature.attributes || feature.data │ │ │ │ } │ │ │ │ - var time = (new Date).getTime() - last.tick; │ │ │ │ - var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ - var speed = dist / time; │ │ │ │ - if (speed == 0 || speed < this.threshold) { │ │ │ │ - return │ │ │ │ + if (typeof this.context == "function") { │ │ │ │ + context = this.context(feature) │ │ │ │ } │ │ │ │ - var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ - if (last.xy.x <= xy.x) { │ │ │ │ - theta = Math.PI - theta │ │ │ │ + return context │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + var len = this.symbolizers.length; │ │ │ │ + options.symbolizers = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + options.symbolizers[i] = this.symbolizers[i].clone() │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + options.symbolizer = {}; │ │ │ │ + var value, type; │ │ │ │ + for (var key in this.symbolizer) { │ │ │ │ + value = this.symbolizer[key]; │ │ │ │ + type = typeof value; │ │ │ │ + if (type === "object") { │ │ │ │ + options.symbolizer[key] = OpenLayers.Util.extend({}, value) │ │ │ │ + } else if (type === "string") { │ │ │ │ + options.symbolizer[key] = value │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - return { │ │ │ │ - speed: speed, │ │ │ │ - theta: theta │ │ │ │ + options.filter = this.filter && this.filter.clone(); │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + return new OpenLayers.Rule(options) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Rule" │ │ │ │ +}); │ │ │ │ +OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ + layer: null, │ │ │ │ + options: null, │ │ │ │ + active: null, │ │ │ │ + autoActivate: true, │ │ │ │ + autoDestroy: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ + this.active = false │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = null; │ │ │ │ + this.options = null │ │ │ │ + }, │ │ │ │ + setLayer: function(layer) { │ │ │ │ + this.layer = layer │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + this.active = true; │ │ │ │ + return true │ │ │ │ } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - move: function(info, callback) { │ │ │ │ - var v0 = info.speed; │ │ │ │ - var fx = Math.cos(info.theta); │ │ │ │ - var fy = -Math.sin(info.theta); │ │ │ │ - var initialTime = (new Date).getTime(); │ │ │ │ - var lastX = 0; │ │ │ │ - var lastY = 0; │ │ │ │ - var timerCallback = function() { │ │ │ │ - if (this.timerId == null) { │ │ │ │ - return │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.active = false; │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ +}); │ │ │ │ +OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + preload: false, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + refresh: this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (this.layer.visibility == true || this.preload) { │ │ │ │ + this.load() │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + visibilitychanged: this.load, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - var t = (new Date).getTime() - initialTime; │ │ │ │ - var p = -this.deceleration * Math.pow(t, 2) / 2 + v0 * t; │ │ │ │ - var x = p * fx; │ │ │ │ - var y = p * fy; │ │ │ │ - var args = {}; │ │ │ │ - args.end = false; │ │ │ │ - var v = -this.deceleration * t + v0; │ │ │ │ - if (v <= 0) { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - args.end = true │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + refresh: this.load, │ │ │ │ + visibilitychanged: this.load, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + load: function(options) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.events.triggerEvent("loadstart", { │ │ │ │ + filter: layer.filter │ │ │ │ + }); │ │ │ │ + layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: this.merge, │ │ │ │ + filter: layer.filter, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ + layer.events.un({ │ │ │ │ + visibilitychanged: this.load, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + merge: function(resp) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.destroyFeatures(); │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = layer.projection; │ │ │ │ + var local = layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - args.x = x - lastX; │ │ │ │ - args.y = y - lastY; │ │ │ │ - lastX = x; │ │ │ │ - lastY = y; │ │ │ │ - callback(args.x, args.y, args.end) │ │ │ │ + layer.addFeatures(features) │ │ │ │ + } │ │ │ │ + layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ +}); │ │ │ │ +OpenLayers.Filter = OpenLayers.Class({ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options) │ │ │ │ + }, │ │ │ │ + destroy: function() {}, │ │ │ │ + evaluate: function(context) { │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + return null │ │ │ │ + }, │ │ │ │ + toString: function() { │ │ │ │ + var string; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.CQL) { │ │ │ │ + string = OpenLayers.Format.CQL.prototype.write(this) │ │ │ │ + } else { │ │ │ │ + string = Object.prototype.toString.call(this) │ │ │ │ + } │ │ │ │ + return string │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Filter" │ │ │ │ +}); │ │ │ │ +OpenLayers.Filter.Spatial = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ + type: null, │ │ │ │ + property: null, │ │ │ │ + value: null, │ │ │ │ + distance: null, │ │ │ │ + distanceUnits: null, │ │ │ │ + evaluate: function(feature) { │ │ │ │ + var intersect = false; │ │ │ │ + switch (this.type) { │ │ │ │ + case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ + case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ + if (feature.geometry) { │ │ │ │ + var geom = this.value; │ │ │ │ + if (this.value.CLASS_NAME == "OpenLayers.Bounds") { │ │ │ │ + geom = this.value.toGeometry() │ │ │ │ + } │ │ │ │ + if (feature.geometry.intersects(geom)) { │ │ │ │ + intersect = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + throw new Error("evaluate is not implemented for this filter type.") │ │ │ │ + } │ │ │ │ + return intersect │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.applyDefaults({ │ │ │ │ + value: this.value && this.value.clone && this.value.clone() │ │ │ │ + }, this); │ │ │ │ + return new OpenLayers.Filter.Spatial(options) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Filter.Spatial" │ │ │ │ +}); │ │ │ │ +OpenLayers.Filter.Spatial.BBOX = "BBOX"; │ │ │ │ +OpenLayers.Filter.Spatial.INTERSECTS = "INTERSECTS"; │ │ │ │ +OpenLayers.Filter.Spatial.DWITHIN = "DWITHIN"; │ │ │ │ +OpenLayers.Filter.Spatial.WITHIN = "WITHIN"; │ │ │ │ +OpenLayers.Filter.Spatial.CONTAINS = "CONTAINS"; │ │ │ │ +OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + bounds: null, │ │ │ │ + resolution: null, │ │ │ │ + ratio: 2, │ │ │ │ + resFactor: null, │ │ │ │ + response: null, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + moveend: this.update, │ │ │ │ + refresh: this.update, │ │ │ │ + visibilitychanged: this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.update() │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + moveend: this.update, │ │ │ │ + refresh: this.update, │ │ │ │ + visibilitychanged: this.update, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + update: function(options) { │ │ │ │ + var mapBounds = this.getMapBounds(); │ │ │ │ + if (mapBounds !== null && (options && options.force || this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds))) { │ │ │ │ + this.calculateBounds(mapBounds); │ │ │ │ + this.resolution = this.layer.map.getResolution(); │ │ │ │ + this.triggerRead(options) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getMapBounds: function() { │ │ │ │ + if (this.layer.map === null) { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ + var bounds = this.layer.map.getExtent(); │ │ │ │ + if (bounds && !this.layer.projection.equals(this.layer.map.getProjectionObject())) { │ │ │ │ + bounds = bounds.clone().transform(this.layer.map.getProjectionObject(), this.layer.projection) │ │ │ │ + } │ │ │ │ + return bounds │ │ │ │ + }, │ │ │ │ + invalidBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds() │ │ │ │ + } │ │ │ │ + var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ + if (!invalid && this.resFactor) { │ │ │ │ + var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ + invalid = ratio >= this.resFactor || ratio <= 1 / this.resFactor │ │ │ │ + } │ │ │ │ + return invalid │ │ │ │ + }, │ │ │ │ + calculateBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds() │ │ │ │ + } │ │ │ │ + var center = mapBounds.getCenterLonLat(); │ │ │ │ + var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ + var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ + this.bounds = new OpenLayers.Bounds(center.lon - dataWidth / 2, center.lat - dataHeight / 2, center.lon + dataWidth / 2, center.lat + dataHeight / 2) │ │ │ │ + }, │ │ │ │ + triggerRead: function(options) { │ │ │ │ + if (this.response && !(options && options.noAbort === true)) { │ │ │ │ + this.layer.protocol.abort(this.response); │ │ │ │ + this.layer.events.triggerEvent("loadend") │ │ │ │ + } │ │ │ │ + var evt = { │ │ │ │ + filter: this.createFilter() │ │ │ │ }; │ │ │ │ - this.timerId = OpenLayers.Animation.start(OpenLayers.Function.bind(timerCallback, this)) │ │ │ │ + this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ + this.response = this.layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + filter: evt.filter, │ │ │ │ + callback: this.merge, │ │ │ │ + scope: this │ │ │ │ + }, options)) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ + createFilter: function() { │ │ │ │ + var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + value: this.bounds, │ │ │ │ + projection: this.layer.projection │ │ │ │ + }); │ │ │ │ + if (this.layer.filter) { │ │ │ │ + filter = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.layer.filter, filter] │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return filter │ │ │ │ + }, │ │ │ │ + merge: function(resp) { │ │ │ │ + this.layer.destroyFeatures(); │ │ │ │ + if (resp.success()) { │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = this.layer.projection; │ │ │ │ + var local = this.layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.addFeatures(features) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.bounds = null │ │ │ │ + } │ │ │ │ + this.response = null; │ │ │ │ + this.layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ }); │ │ │ │ OpenLayers.Layer = OpenLayers.Class({ │ │ │ │ id: null, │ │ │ │ name: null, │ │ │ │ div: null, │ │ │ │ opacity: 1, │ │ │ │ alwaysInRange: null, │ │ │ │ @@ -5863,154 +6155,36 @@ │ │ │ │ OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ if (!this.tileOrigin) { │ │ │ │ this.tileOrigin = new OpenLayers.LonLat(this.maxExtent.left, this.maxExtent.bottom) │ │ │ │ } │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - key: null, │ │ │ │ - serverResolutions: [156543.03390625, 78271.516953125, 39135.7584765625, 19567.87923828125, 9783.939619140625, 4891.9698095703125, 2445.9849047851562, 1222.9924523925781, 611.4962261962891, 305.74811309814453, 152.87405654907226, 76.43702827453613, 38.218514137268066, 19.109257068634033, 9.554628534317017, 4.777314267158508, 2.388657133579254, 1.194328566789627, .5971642833948135, .29858214169740677, .14929107084870338, .07464553542435169], │ │ │ │ - attributionTemplate: '<span class="olBingAttribution ${type}">' + '<div><a target="_blank" href="http://www.bing.com/maps/">' + '<img src="${logo}" /></a></div>${copyrights}' + '<a style="white-space: nowrap" target="_blank" ' + 'href="http://www.microsoft.com/maps/product/terms.html">' + "Terms of Use</a></span>", │ │ │ │ - metadata: null, │ │ │ │ - protocolRegex: /^http:/i, │ │ │ │ - type: "Road", │ │ │ │ - culture: "en-US", │ │ │ │ - metadataParams: null, │ │ │ │ +OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + name: "OpenStreetMap", │ │ │ │ + url: ["http://a.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"], │ │ │ │ + attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ + sphericalMercator: true, │ │ │ │ + wrapDateLine: true, │ │ │ │ tileOptions: null, │ │ │ │ - protocol: ~window.location.href.indexOf("http") ? "" : "http:", │ │ │ │ - initialize: function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - sphericalMercator: true │ │ │ │ - }, options); │ │ │ │ - var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ - var newArgs = [name, null, options]; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ crossOriginKeyword: "anonymous" │ │ │ │ - }, this.options.tileOptions); │ │ │ │ - this.loadMetadata() │ │ │ │ - }, │ │ │ │ - loadMetadata: function() { │ │ │ │ - this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ - window[this._callbackId] = OpenLayers.Function.bind(OpenLayers.Layer.Bing.processMetadata, this); │ │ │ │ - var params = OpenLayers.Util.applyDefaults({ │ │ │ │ - key: this.key, │ │ │ │ - jsonp: this._callbackId, │ │ │ │ - include: "ImageryProviders" │ │ │ │ - }, this.metadataParams); │ │ │ │ - var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = this._callbackId; │ │ │ │ - document.getElementsByTagName("head")[0].appendChild(script) │ │ │ │ - }, │ │ │ │ - initLayer: function() { │ │ │ │ - var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ - var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ - url = url.replace("{culture}", this.culture); │ │ │ │ - url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.url = []; │ │ │ │ - for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ - this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])) │ │ │ │ - } │ │ │ │ - this.addOptions({ │ │ │ │ - maxResolution: Math.min(this.serverResolutions[res.zoomMin], this.maxResolution || Number.POSITIVE_INFINITY), │ │ │ │ - numZoomLevels: Math.min(res.zoomMax + 1 - res.zoomMin, this.numZoomLevels) │ │ │ │ - }, true); │ │ │ │ - if (!this.isBaseLayer) { │ │ │ │ - this.redraw() │ │ │ │ - } │ │ │ │ - this.updateAttribution() │ │ │ │ - }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - if (!this.url) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var xyz = this.getXYZ(bounds), │ │ │ │ - x = xyz.x, │ │ │ │ - y = xyz.y, │ │ │ │ - z = xyz.z; │ │ │ │ - var quadDigits = []; │ │ │ │ - for (var i = z; i > 0; --i) { │ │ │ │ - var digit = "0"; │ │ │ │ - var mask = 1 << i - 1; │ │ │ │ - if ((x & mask) != 0) { │ │ │ │ - digit++ │ │ │ │ - } │ │ │ │ - if ((y & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - digit++ │ │ │ │ - } │ │ │ │ - quadDigits.push(digit) │ │ │ │ - } │ │ │ │ - var quadKey = quadDigits.join(""); │ │ │ │ - var url = this.selectUrl("" + x + y + z, this.url); │ │ │ │ - return OpenLayers.String.format(url, { │ │ │ │ - quadkey: quadKey │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - updateAttribution: function() { │ │ │ │ - var metadata = this.metadata; │ │ │ │ - if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var res = metadata.resourceSets[0].resources[0]; │ │ │ │ - var extent = this.map.getExtent().transform(this.map.getProjectionObject(), new OpenLayers.Projection("EPSG:4326")); │ │ │ │ - var providers = res.imageryProviders || [], │ │ │ │ - zoom = OpenLayers.Util.indexOf(this.serverResolutions, this.getServerResolution()), │ │ │ │ - copyrights = "", │ │ │ │ - provider, i, ii, j, jj, bbox, coverage; │ │ │ │ - for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ - provider = providers[i]; │ │ │ │ - for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ - coverage = provider.coverageAreas[j]; │ │ │ │ - bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ - if (extent.intersectsBounds(bbox) && zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ - copyrights += provider.attribution + " " │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ - type: this.type.toLowerCase(), │ │ │ │ - logo: logo, │ │ │ │ - copyrights: copyrights │ │ │ │ - }); │ │ │ │ - this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "attribution" │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - setMap: function() { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("moveend", this, this.updateAttribution) │ │ │ │ + }, this.options && this.options.tileOptions) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Bing(this.options) │ │ │ │ + obj = new OpenLayers.Layer.OSM(this.name, this.url, this.getOptions()) │ │ │ │ } │ │ │ │ obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.map && this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ - OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ - this.metadata = metadata; │ │ │ │ - this.initLayer(); │ │ │ │ - var script = document.getElementById(this._callbackId); │ │ │ │ - script.parentNode.removeChild(script); │ │ │ │ - window[this._callbackId] = undefined; │ │ │ │ - delete this._callbackId │ │ │ │ -}; │ │ │ │ OpenLayers.Renderer = OpenLayers.Class({ │ │ │ │ container: null, │ │ │ │ root: null, │ │ │ │ extent: null, │ │ │ │ locked: false, │ │ │ │ size: null, │ │ │ │ resolution: null, │ │ │ │ @@ -6575,14 +6749,154 @@ │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return maxExtent │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.Vector" │ │ │ │ }); │ │ │ │ +OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + key: null, │ │ │ │ + serverResolutions: [156543.03390625, 78271.516953125, 39135.7584765625, 19567.87923828125, 9783.939619140625, 4891.9698095703125, 2445.9849047851562, 1222.9924523925781, 611.4962261962891, 305.74811309814453, 152.87405654907226, 76.43702827453613, 38.218514137268066, 19.109257068634033, 9.554628534317017, 4.777314267158508, 2.388657133579254, 1.194328566789627, .5971642833948135, .29858214169740677, .14929107084870338, .07464553542435169], │ │ │ │ + attributionTemplate: '<span class="olBingAttribution ${type}">' + '<div><a target="_blank" href="http://www.bing.com/maps/">' + '<img src="${logo}" /></a></div>${copyrights}' + '<a style="white-space: nowrap" target="_blank" ' + 'href="http://www.microsoft.com/maps/product/terms.html">' + "Terms of Use</a></span>", │ │ │ │ + metadata: null, │ │ │ │ + protocolRegex: /^http:/i, │ │ │ │ + type: "Road", │ │ │ │ + culture: "en-US", │ │ │ │ + metadataParams: null, │ │ │ │ + tileOptions: null, │ │ │ │ + protocol: ~window.location.href.indexOf("http") ? "" : "http:", │ │ │ │ + initialize: function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + sphericalMercator: true │ │ │ │ + }, options); │ │ │ │ + var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ + var newArgs = [name, null, options]; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: "anonymous" │ │ │ │ + }, this.options.tileOptions); │ │ │ │ + this.loadMetadata() │ │ │ │ + }, │ │ │ │ + loadMetadata: function() { │ │ │ │ + this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ + window[this._callbackId] = OpenLayers.Function.bind(OpenLayers.Layer.Bing.processMetadata, this); │ │ │ │ + var params = OpenLayers.Util.applyDefaults({ │ │ │ │ + key: this.key, │ │ │ │ + jsonp: this._callbackId, │ │ │ │ + include: "ImageryProviders" │ │ │ │ + }, this.metadataParams); │ │ │ │ + var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = this._callbackId; │ │ │ │ + document.getElementsByTagName("head")[0].appendChild(script) │ │ │ │ + }, │ │ │ │ + initLayer: function() { │ │ │ │ + var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ + var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ + url = url.replace("{culture}", this.culture); │ │ │ │ + url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.url = []; │ │ │ │ + for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ + this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])) │ │ │ │ + } │ │ │ │ + this.addOptions({ │ │ │ │ + maxResolution: Math.min(this.serverResolutions[res.zoomMin], this.maxResolution || Number.POSITIVE_INFINITY), │ │ │ │ + numZoomLevels: Math.min(res.zoomMax + 1 - res.zoomMin, this.numZoomLevels) │ │ │ │ + }, true); │ │ │ │ + if (!this.isBaseLayer) { │ │ │ │ + this.redraw() │ │ │ │ + } │ │ │ │ + this.updateAttribution() │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + if (!this.url) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var xyz = this.getXYZ(bounds), │ │ │ │ + x = xyz.x, │ │ │ │ + y = xyz.y, │ │ │ │ + z = xyz.z; │ │ │ │ + var quadDigits = []; │ │ │ │ + for (var i = z; i > 0; --i) { │ │ │ │ + var digit = "0"; │ │ │ │ + var mask = 1 << i - 1; │ │ │ │ + if ((x & mask) != 0) { │ │ │ │ + digit++ │ │ │ │ + } │ │ │ │ + if ((y & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + digit++ │ │ │ │ + } │ │ │ │ + quadDigits.push(digit) │ │ │ │ + } │ │ │ │ + var quadKey = quadDigits.join(""); │ │ │ │ + var url = this.selectUrl("" + x + y + z, this.url); │ │ │ │ + return OpenLayers.String.format(url, { │ │ │ │ + quadkey: quadKey │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + updateAttribution: function() { │ │ │ │ + var metadata = this.metadata; │ │ │ │ + if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var res = metadata.resourceSets[0].resources[0]; │ │ │ │ + var extent = this.map.getExtent().transform(this.map.getProjectionObject(), new OpenLayers.Projection("EPSG:4326")); │ │ │ │ + var providers = res.imageryProviders || [], │ │ │ │ + zoom = OpenLayers.Util.indexOf(this.serverResolutions, this.getServerResolution()), │ │ │ │ + copyrights = "", │ │ │ │ + provider, i, ii, j, jj, bbox, coverage; │ │ │ │ + for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ + provider = providers[i]; │ │ │ │ + for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ + coverage = provider.coverageAreas[j]; │ │ │ │ + bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ + if (extent.intersectsBounds(bbox) && zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ + copyrights += provider.attribution + " " │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ + type: this.type.toLowerCase(), │ │ │ │ + logo: logo, │ │ │ │ + copyrights: copyrights │ │ │ │ + }); │ │ │ │ + this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "attribution" │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + setMap: function() { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("moveend", this, this.updateAttribution) │ │ │ │ + }, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Bing(this.options) │ │ │ │ + } │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.map && this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ + OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ + this.metadata = metadata; │ │ │ │ + this.initLayer(); │ │ │ │ + var script = document.getElementById(this._callbackId); │ │ │ │ + script.parentNode.removeChild(script); │ │ │ │ + window[this._callbackId] = undefined; │ │ │ │ + delete this._callbackId │ │ │ │ +}; │ │ │ │ OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ DEFAULT_PARAMS: { │ │ │ │ service: "WMS", │ │ │ │ version: "1.1.1", │ │ │ │ request: "GetMap", │ │ │ │ styles: "", │ │ │ │ format: "image/jpeg" │ │ │ │ @@ -6648,36 +6962,14 @@ │ │ │ │ if (typeof this.params.TRANSPARENT == "boolean") { │ │ │ │ newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE" │ │ │ │ } │ │ │ │ return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, arguments) │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - name: "OpenStreetMap", │ │ │ │ - url: ["http://a.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"], │ │ │ │ - attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ - sphericalMercator: true, │ │ │ │ - wrapDateLine: true, │ │ │ │ - tileOptions: null, │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: "anonymous" │ │ │ │ - }, this.options && this.options.tileOptions) │ │ │ │ - }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.OSM(this.name, this.url, this.getOptions()) │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ -}); │ │ │ │ OpenLayers.Layer.SphericalMercator = { │ │ │ │ getExtent: function() { │ │ │ │ var extent = null; │ │ │ │ if (this.sphericalMercator) { │ │ │ │ extent = this.map.calculateBounds() │ │ │ │ } else { │ │ │ │ extent = OpenLayers.Layer.FixedZoomLevels.prototype.getExtent.apply(this) │ │ │ │ @@ -7410,4481 +7702,1398 @@ │ │ │ │ } │ │ │ │ return gLatLng │ │ │ │ }, │ │ │ │ getMapObjectPixelFromXY: function(x, y) { │ │ │ │ return new google.maps.Point(x, y) │ │ │ │ } │ │ │ │ }; │ │ │ │ -OpenLayers.Control = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - map: null, │ │ │ │ - div: null, │ │ │ │ +OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ type: null, │ │ │ │ - allowSelection: false, │ │ │ │ - displayClass: "", │ │ │ │ - title: "", │ │ │ │ - autoActivate: false, │ │ │ │ - active: null, │ │ │ │ - handlerOptions: null, │ │ │ │ - handler: null, │ │ │ │ - eventListeners: null, │ │ │ │ - events: null, │ │ │ │ + property: null, │ │ │ │ + value: null, │ │ │ │ + matchCase: true, │ │ │ │ + lowerBoundary: null, │ │ │ │ + upperBoundary: null, │ │ │ │ initialize: function(options) { │ │ │ │ - this.displayClass = this.CLASS_NAME.replace("OpenLayers.", "ol").replace(/\./g, ""); │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.events = new OpenLayers.Events(this); │ │ │ │ - if (this.eventListeners instanceof Object) { │ │ │ │ - this.events.on(this.eventListeners) │ │ │ │ + OpenLayers.Filter.prototype.initialize.apply(this, [options]); │ │ │ │ + if (this.type === OpenLayers.Filter.Comparison.LIKE && options.matchCase === undefined) { │ │ │ │ + this.matchCase = null │ │ │ │ } │ │ │ │ - if (this.id == null) { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + }, │ │ │ │ + evaluate: function(context) { │ │ │ │ + if (context instanceof OpenLayers.Feature.Vector) { │ │ │ │ + context = context.attributes │ │ │ │ + } │ │ │ │ + var result = false; │ │ │ │ + var got = context[this.property]; │ │ │ │ + var exp; │ │ │ │ + switch (this.type) { │ │ │ │ + case OpenLayers.Filter.Comparison.EQUAL_TO: │ │ │ │ + exp = this.value; │ │ │ │ + if (!this.matchCase && typeof got == "string" && typeof exp == "string") { │ │ │ │ + result = got.toUpperCase() == exp.toUpperCase() │ │ │ │ + } else { │ │ │ │ + result = got == exp │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.NOT_EQUAL_TO: │ │ │ │ + exp = this.value; │ │ │ │ + if (!this.matchCase && typeof got == "string" && typeof exp == "string") { │ │ │ │ + result = got.toUpperCase() != exp.toUpperCase() │ │ │ │ + } else { │ │ │ │ + result = got != exp │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.LESS_THAN: │ │ │ │ + result = got < this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.GREATER_THAN: │ │ │ │ + result = got > this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO: │ │ │ │ + result = got <= this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO: │ │ │ │ + result = got >= this.value; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.BETWEEN: │ │ │ │ + result = got >= this.lowerBoundary && got <= this.upperBoundary; │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.LIKE: │ │ │ │ + var regexp = new RegExp(this.value, "gi"); │ │ │ │ + result = regexp.test(got); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Comparison.IS_NULL: │ │ │ │ + result = got === null; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + return result │ │ │ │ + }, │ │ │ │ + value2regex: function(wildCard, singleChar, escapeChar) { │ │ │ │ + if (wildCard == ".") { │ │ │ │ + throw new Error("'.' is an unsupported wildCard character for " + "OpenLayers.Filter.Comparison") │ │ │ │ } │ │ │ │ + wildCard = wildCard ? wildCard : "*"; │ │ │ │ + singleChar = singleChar ? singleChar : "."; │ │ │ │ + escapeChar = escapeChar ? escapeChar : "!"; │ │ │ │ + this.value = this.value.replace(new RegExp("\\" + escapeChar + "(.|$)", "g"), "\\$1"); │ │ │ │ + this.value = this.value.replace(new RegExp("\\" + singleChar, "g"), "."); │ │ │ │ + this.value = this.value.replace(new RegExp("\\" + wildCard, "g"), ".*"); │ │ │ │ + this.value = this.value.replace(new RegExp("\\\\.\\*", "g"), "\\" + wildCard); │ │ │ │ + this.value = this.value.replace(new RegExp("\\\\\\.", "g"), "\\" + singleChar); │ │ │ │ + return this.value │ │ │ │ + }, │ │ │ │ + regex2value: function() { │ │ │ │ + var value = this.value; │ │ │ │ + value = value.replace(/!/g, "!!"); │ │ │ │ + value = value.replace(/(\\)?\\\./g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "!." │ │ │ │ + }); │ │ │ │ + value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "!*" │ │ │ │ + }); │ │ │ │ + value = value.replace(/\\\\/g, "\\"); │ │ │ │ + value = value.replace(/\.\*/g, "*"); │ │ │ │ + return value │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + return OpenLayers.Util.extend(new OpenLayers.Filter.Comparison, this) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Filter.Comparison" │ │ │ │ +}); │ │ │ │ +OpenLayers.Filter.Comparison.EQUAL_TO = "=="; │ │ │ │ +OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!="; │ │ │ │ +OpenLayers.Filter.Comparison.LESS_THAN = "<"; │ │ │ │ +OpenLayers.Filter.Comparison.GREATER_THAN = ">"; │ │ │ │ +OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; │ │ │ │ +OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; │ │ │ │ +OpenLayers.Filter.Comparison.BETWEEN = ".."; │ │ │ │ +OpenLayers.Filter.Comparison.LIKE = "~"; │ │ │ │ +OpenLayers.Filter.Comparison.IS_NULL = "NULL"; │ │ │ │ +OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ + filters: null, │ │ │ │ + type: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.filters = []; │ │ │ │ + OpenLayers.Filter.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - if (this.events) { │ │ │ │ - if (this.eventListeners) { │ │ │ │ - this.events.un(this.eventListeners) │ │ │ │ - } │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null │ │ │ │ + this.filters = null; │ │ │ │ + OpenLayers.Filter.prototype.destroy.apply(this) │ │ │ │ + }, │ │ │ │ + evaluate: function(context) { │ │ │ │ + var i, len; │ │ │ │ + switch (this.type) { │ │ │ │ + case OpenLayers.Filter.Logical.AND: │ │ │ │ + for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ + if (this.filters[i].evaluate(context) == false) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return true; │ │ │ │ + case OpenLayers.Filter.Logical.OR: │ │ │ │ + for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ + if (this.filters[i].evaluate(context) == true) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ + case OpenLayers.Filter.Logical.NOT: │ │ │ │ + return !this.filters[0].evaluate(context) │ │ │ │ } │ │ │ │ - this.eventListeners = null; │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.destroy(); │ │ │ │ - this.handler = null │ │ │ │ + return undefined │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var filters = []; │ │ │ │ + for (var i = 0, len = this.filters.length; i < len; ++i) { │ │ │ │ + filters.push(this.filters[i].clone()) │ │ │ │ } │ │ │ │ - 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 │ │ │ │ + return new OpenLayers.Filter.Logical({ │ │ │ │ + type: this.type, │ │ │ │ + filters: filters │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Filter.Logical" │ │ │ │ +}); │ │ │ │ +OpenLayers.Filter.Logical.AND = "&&"; │ │ │ │ +OpenLayers.Filter.Logical.OR = "||"; │ │ │ │ +OpenLayers.Filter.Logical.NOT = "!"; │ │ │ │ +OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ + events: null, │ │ │ │ + id: "", │ │ │ │ + lonlat: null, │ │ │ │ + div: null, │ │ │ │ + contentSize: null, │ │ │ │ + size: null, │ │ │ │ + contentHTML: null, │ │ │ │ + backgroundColor: "", │ │ │ │ + opacity: "", │ │ │ │ + border: "", │ │ │ │ + contentDiv: null, │ │ │ │ + groupDiv: null, │ │ │ │ + closeDiv: null, │ │ │ │ + autoSize: false, │ │ │ │ + minSize: null, │ │ │ │ + maxSize: null, │ │ │ │ + displayClass: "olPopup", │ │ │ │ + contentDisplayClass: "olPopupContent", │ │ │ │ + padding: 0, │ │ │ │ + disableFirefoxOverflowHack: false, │ │ │ │ + fixPadding: function() { │ │ │ │ + if (typeof this.padding == "number") { │ │ │ │ + this.padding = new OpenLayers.Bounds(this.padding, this.padding, this.padding, this.padding) │ │ │ │ } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.removeControl(this); │ │ │ │ - this.map = null │ │ │ │ + }, │ │ │ │ + panMapIfOutOfView: false, │ │ │ │ + keepInMap: false, │ │ │ │ + closeOnMove: false, │ │ │ │ + map: null, │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ + if (id == null) { │ │ │ │ + id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ } │ │ │ │ - this.div = null │ │ │ │ + this.id = id; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + this.contentSize = contentSize != null ? contentSize : 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 = this.displayClass; │ │ │ │ + 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.contentSize.clone(), null, "relative"); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass; │ │ │ │ + this.groupDiv.appendChild(this.contentDiv); │ │ │ │ + this.div.appendChild(this.groupDiv); │ │ │ │ + if (closeBox) { │ │ │ │ + this.addCloseBox(closeBoxCallback) │ │ │ │ + } │ │ │ │ + this.registerEvents() │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.setMap(map) │ │ │ │ + destroy: function() { │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.size = null; │ │ │ │ + this.contentHTML = null; │ │ │ │ + this.backgroundColor = null; │ │ │ │ + this.opacity = null; │ │ │ │ + this.border = null; │ │ │ │ + if (this.closeOnMove && this.map) { │ │ │ │ + this.map.events.unregister("movestart", this, this.hide) │ │ │ │ + } │ │ │ │ + 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 │ │ │ │ }, │ │ │ │ draw: function(px) { │ │ │ │ - if (this.div == null) { │ │ │ │ - this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ - this.div.className = this.displayClass; │ │ │ │ - if (!this.allowSelection) { │ │ │ │ - this.div.className += " olControlNoSelect"; │ │ │ │ - this.div.setAttribute("unselectable", "on", 0); │ │ │ │ - this.div.onselectstart = OpenLayers.Function.False │ │ │ │ - } │ │ │ │ - if (this.title != "") { │ │ │ │ - this.div.title = this.title │ │ │ │ + if (px == null) { │ │ │ │ + if (this.lonlat != null && this.map != null) { │ │ │ │ + px = this.map.getLayerPxFromLonLat(this.lonlat) │ │ │ │ } │ │ │ │ } │ │ │ │ - if (px != null) { │ │ │ │ - this.position = px.clone() │ │ │ │ + if (this.closeOnMove) { │ │ │ │ + this.map.events.register("movestart", this, this.hide) │ │ │ │ + } │ │ │ │ + if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == "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.size) { │ │ │ │ + this.setSize(this.contentSize) │ │ │ │ + } │ │ │ │ + this.setBackgroundColor(); │ │ │ │ + this.setOpacity(); │ │ │ │ + this.setBorder(); │ │ │ │ + this.setContentHTML(); │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView() │ │ │ │ } │ │ │ │ - this.moveTo(this.position); │ │ │ │ return this.div │ │ │ │ }, │ │ │ │ + updatePosition: function() { │ │ │ │ + if (this.lonlat && this.map) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + if (px) { │ │ │ │ + this.moveTo(px) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ moveTo: function(px) { │ │ │ │ if (px != null && this.div != null) { │ │ │ │ this.div.style.left = px.x + "px"; │ │ │ │ this.div.style.top = px.y + "px" │ │ │ │ } │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.activate() │ │ │ │ - } │ │ │ │ - this.active = true; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("activate"); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate() │ │ │ │ - } │ │ │ │ - this.active = false; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("deactivate"); │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ + visible: function() { │ │ │ │ + return OpenLayers.Element.visible(this.div) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ -OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ -OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ -OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ - target: null, │ │ │ │ - events: ["mousedown", "mouseup", "click", "dblclick", "touchstart", "touchmove", "touchend", "keydown"], │ │ │ │ - startRegEx: /^mousedown|touchstart$/, │ │ │ │ - cancelRegEx: /^touchmove$/, │ │ │ │ - completeRegEx: /^mouseup|touchend$/, │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ - extension: true │ │ │ │ - }) │ │ │ │ + toggle: function() { │ │ │ │ + if (this.visible()) { │ │ │ │ + this.hide() │ │ │ │ + } else { │ │ │ │ + this.show() │ │ │ │ } │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.unregister(this.events[i], this, this.buttonClick) │ │ │ │ + show: function() { │ │ │ │ + this.div.style.display = ""; │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView() │ │ │ │ } │ │ │ │ - delete this.target │ │ │ │ }, │ │ │ │ - getPressedButton: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - button; │ │ │ │ - do { │ │ │ │ - if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ - button = element; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - element = element.parentNode │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return button │ │ │ │ + hide: function() { │ │ │ │ + this.div.style.display = "none" │ │ │ │ }, │ │ │ │ - ignore: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - ignore = false; │ │ │ │ - do { │ │ │ │ - if (element.nodeName.toLowerCase() === "a") { │ │ │ │ - ignore = true; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - element = element.parentNode │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return ignore │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + this.size = contentSize.clone(); │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ + var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ + 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 │ │ │ │ + } │ │ │ │ + this.size.w += wPadding; │ │ │ │ + this.size.h += hPadding; │ │ │ │ + if (OpenLayers.BROWSER_NAME == "msie") { │ │ │ │ + this.contentSize.w += contentDivPadding.left + contentDivPadding.right; │ │ │ │ + this.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" │ │ │ │ + } │ │ │ │ }, │ │ │ │ - buttonClick: function(evt) { │ │ │ │ - var propagate = true, │ │ │ │ - element = OpenLayers.Event.element(evt); │ │ │ │ - if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ - var button = this.getPressedButton(element); │ │ │ │ - if (button) { │ │ │ │ - if (evt.type === "keydown") { │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_RETURN: │ │ │ │ - case OpenLayers.Event.KEY_SPACE: │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button │ │ │ │ - }); │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (this.startEvt) { │ │ │ │ - if (this.completeRegEx.test(evt.type)) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ - var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ - var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ - var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ - pos[0] = pos[0] - scrollLeft; │ │ │ │ - pos[1] = pos[1] - scrollTop; │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button, │ │ │ │ - buttonXY: { │ │ │ │ - x: this.startEvt.clientX - pos[0], │ │ │ │ - y: this.startEvt.clientY - pos[1] │ │ │ │ - } │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (this.cancelRegEx.test(evt.type)) { │ │ │ │ - delete this.startEvt │ │ │ │ + updateSize: function() { │ │ │ │ + var preparedHTML = "<div class='" + this.contentDisplayClass + "'>" + this.contentDiv.innerHTML + "</div>"; │ │ │ │ + var containerElement = this.map ? this.map.div : document.body; │ │ │ │ + var realSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, null, { │ │ │ │ + displayClass: this.displayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + }); │ │ │ │ + var safeSize = this.getSafeContentSize(realSize); │ │ │ │ + var newSize = null; │ │ │ │ + if (safeSize.equals(realSize)) { │ │ │ │ + newSize = realSize │ │ │ │ + } else { │ │ │ │ + var fixedSize = { │ │ │ │ + w: safeSize.w < realSize.w ? safeSize.w : null, │ │ │ │ + h: safeSize.h < realSize.h ? safeSize.h : null │ │ │ │ + }; │ │ │ │ + if (fixedSize.w && fixedSize.h) { │ │ │ │ + newSize = safeSize │ │ │ │ + } else { │ │ │ │ + var clippedSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, fixedSize, { │ │ │ │ + displayClass: this.contentDisplayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + }); │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false │ │ │ │ - } │ │ │ │ - if (this.startRegEx.test(evt.type)) { │ │ │ │ - this.startEvt = evt; │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ - delete this.startEvt │ │ │ │ + newSize = this.getSafeContentSize(clippedSize) │ │ │ │ } │ │ │ │ } │ │ │ │ - return propagate │ │ │ │ - } │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - controls: null, │ │ │ │ - autoActivate: true, │ │ │ │ - defaultControl: null, │ │ │ │ - saveState: false, │ │ │ │ - allowDepress: false, │ │ │ │ - activeState: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.controls = []; │ │ │ │ - this.activeState = {} │ │ │ │ + this.setSize(newSize) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick) │ │ │ │ + setBackgroundColor: function(color) { │ │ │ │ + if (color != undefined) { │ │ │ │ + this.backgroundColor = color │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ - ctl = this.controls[i]; │ │ │ │ - if (ctl.events) { │ │ │ │ - ctl.events.un({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - ctl.panel_div = null │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.backgroundColor = this.backgroundColor │ │ │ │ } │ │ │ │ - this.activeState = null │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - if (control === this.defaultControl || this.saveState && this.activeState[control.id]) { │ │ │ │ - control.activate() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.saveState === true) { │ │ │ │ - this.defaultControl = null │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + if (opacity != undefined) { │ │ │ │ + this.opacity = opacity │ │ │ │ } │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - this.activeState[control.id] = control.deactivate() │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.opacity = this.opacity; │ │ │ │ + this.div.style.filter = "alpha(opacity=" + this.opacity * 100 + ")" │ │ │ │ } │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + setBorder: function(border) { │ │ │ │ + if (border != undefined) { │ │ │ │ + this.border = border │ │ │ │ + } │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.border = this.border │ │ │ │ } │ │ │ │ - this.addControlsToMap(this.controls); │ │ │ │ - return this.div │ │ │ │ }, │ │ │ │ - redraw: function() { │ │ │ │ - for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ - this.div.removeChild(this.div.childNodes[i]) │ │ │ │ + setContentHTML: function(contentHTML) { │ │ │ │ + if (contentHTML != null) { │ │ │ │ + this.contentHTML = contentHTML │ │ │ │ } │ │ │ │ - this.div.innerHTML = ""; │ │ │ │ - if (this.active) { │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - this.div.appendChild(this.controls[i].panel_div) │ │ │ │ + if (this.contentDiv != null && this.contentHTML != null && this.contentHTML != this.contentDiv.innerHTML) { │ │ │ │ + this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ + if (this.autoSize) { │ │ │ │ + this.registerImageListeners(); │ │ │ │ + this.updateSize() │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - activateControl: function(control) { │ │ │ │ - if (!this.active) { │ │ │ │ - return false │ │ │ │ + registerImageListeners: function() { │ │ │ │ + var onImgLoad = function() { │ │ │ │ + if (this.popup.id === null) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + this.popup.updateSize(); │ │ │ │ + if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ + this.popup.panIntoView() │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stopObserving(this.img, "load", this.img._onImgLoad) │ │ │ │ + }; │ │ │ │ + var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ + for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ + var img = images[i]; │ │ │ │ + if (img.width == 0 || img.height == 0) { │ │ │ │ + var context = { │ │ │ │ + popup: this, │ │ │ │ + img: img │ │ │ │ + }; │ │ │ │ + img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ + OpenLayers.Event.observe(img, "load", img._onImgLoad) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ - control.trigger(); │ │ │ │ - return │ │ │ │ + }, │ │ │ │ + getSafeContentSize: function(size) { │ │ │ │ + var safeContentSize = size.clone(); │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ + var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ - if (control.active) { │ │ │ │ - control.deactivate() │ │ │ │ - } else { │ │ │ │ - control.activate() │ │ │ │ - } │ │ │ │ - return │ │ │ │ + if (this.minSize) { │ │ │ │ + safeContentSize.w = Math.max(safeContentSize.w, this.minSize.w - wPadding); │ │ │ │ + safeContentSize.h = Math.max(safeContentSize.h, this.minSize.h - hPadding) │ │ │ │ } │ │ │ │ - if (this.allowDepress && control.active) { │ │ │ │ - control.deactivate() │ │ │ │ - } else { │ │ │ │ - var c; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - c = this.controls[i]; │ │ │ │ - if (c != control && (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ - c.deactivate() │ │ │ │ + if (this.maxSize) { │ │ │ │ + safeContentSize.w = Math.min(safeContentSize.w, this.maxSize.w - wPadding); │ │ │ │ + safeContentSize.h = Math.min(safeContentSize.h, this.maxSize.h - hPadding) │ │ │ │ + } │ │ │ │ + if (this.map && this.map.size) { │ │ │ │ + var extraX = 0, │ │ │ │ + extraY = 0; │ │ │ │ + if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ + var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ + switch (this.relativePosition) { │ │ │ │ + case "tr": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "tl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "bl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + case "br": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - control.activate() │ │ │ │ + var maxY = this.map.size.h - this.map.paddingForPopups.top - this.map.paddingForPopups.bottom - hPadding - extraY; │ │ │ │ + var maxX = this.map.size.w - this.map.paddingForPopups.left - this.map.paddingForPopups.right - wPadding - extraX; │ │ │ │ + safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ + safeContentSize.h = Math.min(safeContentSize.h, maxY) │ │ │ │ } │ │ │ │ + return safeContentSize │ │ │ │ }, │ │ │ │ - addControls: function(controls) { │ │ │ │ - if (!OpenLayers.Util.isArray(controls)) { │ │ │ │ - controls = [controls] │ │ │ │ - } │ │ │ │ - this.controls = this.controls.concat(controls); │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - var control = controls[i], │ │ │ │ - element = this.createControlMarkup(control); │ │ │ │ - OpenLayers.Element.addClass(element, control.displayClass + "ItemInactive"); │ │ │ │ - OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ - if (control.title != "" && !element.title) { │ │ │ │ - element.title = control.title │ │ │ │ + getContentDivPadding: function() { │ │ │ │ + var contentDivPadding = this._contentDivPadding; │ │ │ │ + if (!contentDivPadding) { │ │ │ │ + if (this.div.parentNode == null) { │ │ │ │ + this.div.style.display = "none"; │ │ │ │ + document.body.appendChild(this.div) │ │ │ │ + } │ │ │ │ + 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")); │ │ │ │ + this._contentDivPadding = contentDivPadding; │ │ │ │ + if (this.div.parentNode == document.body) { │ │ │ │ + document.body.removeChild(this.div); │ │ │ │ + this.div.style.display = "" │ │ │ │ } │ │ │ │ - control.panel_div = element │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.addControlsToMap(controls); │ │ │ │ - this.redraw() │ │ │ │ } │ │ │ │ + return contentDivPadding │ │ │ │ }, │ │ │ │ - createControlMarkup: function(control) { │ │ │ │ - return document.createElement("div") │ │ │ │ + addCloseBox: function(callback) { │ │ │ │ + this.closeDiv = OpenLayers.Util.createDiv(this.id + "_close", null, { │ │ │ │ + w: 17, │ │ │ │ + h: 17 │ │ │ │ + }); │ │ │ │ + this.closeDiv.className = "olPopupCloseBox"; │ │ │ │ + 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, "touchend", OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ + OpenLayers.Event.observe(this.closeDiv, "click", OpenLayers.Function.bindAsEventListener(closePopup, this)) │ │ │ │ }, │ │ │ │ - addControlsToMap: function(controls) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - control = controls[i]; │ │ │ │ - if (control.autoActivate === true) { │ │ │ │ - control.autoActivate = false; │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.autoActivate = true │ │ │ │ - } else { │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.deactivate() │ │ │ │ - } │ │ │ │ - control.events.on({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }) │ │ │ │ + panIntoView: function() { │ │ │ │ + var mapSize = this.map.getSize(); │ │ │ │ + var origTL = this.map.getViewPortPxFromLayerPx(new OpenLayers.Pixel(parseInt(this.div.style.left), parseInt(this.div.style.top))); │ │ │ │ + var newTL = origTL.clone(); │ │ │ │ + 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 │ │ │ │ + } │ │ │ │ + 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) │ │ │ │ }, │ │ │ │ - iconOn: function() { │ │ │ │ - var d = this.panel_div; │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Active") │ │ │ │ + registerEvents: function() { │ │ │ │ + this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ + │ │ │ │ + function onTouchstart(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ + } │ │ │ │ + this.events.on({ │ │ │ │ + mousedown: this.onmousedown, │ │ │ │ + mousemove: this.onmousemove, │ │ │ │ + mouseup: this.onmouseup, │ │ │ │ + click: this.onclick, │ │ │ │ + mouseout: this.onmouseout, │ │ │ │ + dblclick: this.ondblclick, │ │ │ │ + touchstart: onTouchstart, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - iconOff: function() { │ │ │ │ - var d = this.panel_div; │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Inactive") │ │ │ │ + onmousedown: function(evt) { │ │ │ │ + this.mousedown = true; │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var controls = this.controls, │ │ │ │ - button = evt.buttonElement; │ │ │ │ - for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ - if (controls[i].panel_div === button) { │ │ │ │ - this.activateControl(controls[i]); │ │ │ │ - break │ │ │ │ - } │ │ │ │ + onmousemove: function(evt) { │ │ │ │ + if (this.mousedown) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ } │ │ │ │ }, │ │ │ │ - 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 │ │ │ │ + onmouseup: function(evt) { │ │ │ │ + if (this.mousedown) { │ │ │ │ + this.mousedown = false; │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - getControlsByName: function(match) { │ │ │ │ - return this.getControlsBy("name", match) │ │ │ │ + onclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ }, │ │ │ │ - getControlsByClass: function(match) { │ │ │ │ - return this.getControlsBy("CLASS_NAME", match) │ │ │ │ + onmouseout: function(evt) { │ │ │ │ + this.mousedown = false │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ + ondblclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Popup" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - zoomInText: "+", │ │ │ │ - zoomInId: "olZoomInLink", │ │ │ │ - zoomOutText: "−", │ │ │ │ - zoomOutId: "olZoomOutLink", │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ - links = this.getOrCreateLinks(div), │ │ │ │ - zoomIn = links.zoomIn, │ │ │ │ - zoomOut = links.zoomOut, │ │ │ │ - eventsInstance = this.map.events; │ │ │ │ - if (zoomOut.parentNode !== div) { │ │ │ │ - eventsInstance = this.events; │ │ │ │ - eventsInstance.attachToElement(zoomOut.parentNode) │ │ │ │ +OpenLayers.Popup.WIDTH = 200; │ │ │ │ +OpenLayers.Popup.HEIGHT = 200; │ │ │ │ +OpenLayers.Popup.COLOR = "white"; │ │ │ │ +OpenLayers.Popup.OPACITY = 1; │ │ │ │ +OpenLayers.Popup.BORDER = "0px"; │ │ │ │ +OpenLayers.Popup.Anchored = OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ + relativePosition: null, │ │ │ │ + keepInMap: true, │ │ │ │ + anchor: null, │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ + var newArguments = [id, lonlat, contentSize, 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) │ │ │ │ } │ │ │ │ - eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ - this.zoomInLink = zoomIn; │ │ │ │ - this.zoomOutLink = zoomOut; │ │ │ │ - return div │ │ │ │ }, │ │ │ │ - getOrCreateLinks: function(el) { │ │ │ │ - var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ - zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ - if (!zoomIn) { │ │ │ │ - zoomIn = document.createElement("a"); │ │ │ │ - zoomIn.href = "#zoomIn"; │ │ │ │ - zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ - zoomIn.className = "olControlZoomIn"; │ │ │ │ - el.appendChild(zoomIn) │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ - if (!zoomOut) { │ │ │ │ - zoomOut = document.createElement("a"); │ │ │ │ - zoomOut.href = "#zoomOut"; │ │ │ │ - zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ - zoomOut.className = "olControlZoomOut"; │ │ │ │ - el.appendChild(zoomOut) │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ - return { │ │ │ │ - zoomIn: zoomIn, │ │ │ │ - zoomOut: zoomOut │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + this.anchor = null; │ │ │ │ + this.relativePosition = null; │ │ │ │ + OpenLayers.Popup.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - onZoomClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.zoomInLink) { │ │ │ │ - this.map.zoomIn() │ │ │ │ - } else if (button === this.zoomOutLink) { │ │ │ │ - this.map.zoomOut() │ │ │ │ + show: function() { │ │ │ │ + this.updatePosition(); │ │ │ │ + OpenLayers.Popup.prototype.show.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + moveTo: function(px) { │ │ │ │ + var oldRelativePosition = this.relativePosition; │ │ │ │ + this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ + OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ + if (this.relativePosition != oldRelativePosition) { │ │ │ │ + this.updateRelativePosition() │ │ │ │ } │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onZoomClick) │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ + if (this.lonlat && this.map) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + this.moveTo(px) │ │ │ │ } │ │ │ │ - delete this.zoomInLink; │ │ │ │ - delete this.zoomOutLink; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - layerStates: null, │ │ │ │ - layersDiv: null, │ │ │ │ - baseLayersDiv: null, │ │ │ │ - baseLayers: null, │ │ │ │ - dataLbl: null, │ │ │ │ - dataLayersDiv: null, │ │ │ │ - dataLayers: null, │ │ │ │ - minimizeDiv: null, │ │ │ │ - maximizeDiv: null, │ │ │ │ - ascending: true, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - this.layerStates = [] │ │ │ │ + calculateRelativePosition: function(px) { │ │ │ │ + var lonlat = this.map.getLonLatFromLayerPx(px); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var quadrant = extent.determineQuadrant(lonlat); │ │ │ │ + return OpenLayers.Bounds.oppositeQuadrant(quadrant) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ - this.map.events.un({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - addlayer: this.redraw, │ │ │ │ - changelayer: this.redraw, │ │ │ │ - removelayer: this.redraw, │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + updateRelativePosition: function() {}, │ │ │ │ + calculateNewPx: function(px) { │ │ │ │ + var newPx = px.offset(this.anchor.offset); │ │ │ │ + var size = this.size || this.contentSize; │ │ │ │ + var top = this.relativePosition.charAt(0) == "t"; │ │ │ │ + newPx.y += top ? -size.h : this.anchor.size.h; │ │ │ │ + var left = this.relativePosition.charAt(1) == "l"; │ │ │ │ + newPx.x += left ? -size.w : this.anchor.size.w; │ │ │ │ + return newPx │ │ │ │ }, │ │ │ │ - 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 │ │ │ │ - }); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ +}); │ │ │ │ +OpenLayers.Popup.Framed = OpenLayers.Class(OpenLayers.Popup.Anchored, { │ │ │ │ + imageSrc: null, │ │ │ │ + imageSize: null, │ │ │ │ + isAlphaImage: false, │ │ │ │ + positionBlocks: null, │ │ │ │ + blocks: null, │ │ │ │ + fixedRelativePosition: false, │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ + OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.fixedRelativePosition) { │ │ │ │ + this.updateRelativePosition(); │ │ │ │ + this.calculateRelativePosition = function(px) { │ │ │ │ + return this.relativePosition │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ - this.loadContents(); │ │ │ │ - if (!this.outsideViewport) { │ │ │ │ - this.minimizeControl() │ │ │ │ + this.contentDiv.style.position = "absolute"; │ │ │ │ + this.contentDiv.style.zIndex = 1; │ │ │ │ + if (closeBox) { │ │ │ │ + this.closeDiv.style.zIndex = 1 │ │ │ │ } │ │ │ │ - this.redraw(); │ │ │ │ - return this.div │ │ │ │ + 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%" │ │ │ │ }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.minimizeDiv) { │ │ │ │ - this.minimizeControl() │ │ │ │ - } else if (button === this.maximizeDiv) { │ │ │ │ - this.maximizeControl() │ │ │ │ - } else if (button._layerSwitcher === this.id) { │ │ │ │ - if (button["for"]) { │ │ │ │ - button = document.getElementById(button["for"]) │ │ │ │ + destroy: function() { │ │ │ │ + this.imageSrc = null; │ │ │ │ + this.imageSize = null; │ │ │ │ + this.isAlphaImage = null; │ │ │ │ + this.fixedRelativePosition = false; │ │ │ │ + this.positionBlocks = null; │ │ │ │ + for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ + var block = this.blocks[i]; │ │ │ │ + if (block.image) { │ │ │ │ + block.div.removeChild(block.image) │ │ │ │ } │ │ │ │ - if (!button.disabled) { │ │ │ │ - if (button.type == "radio") { │ │ │ │ - button.checked = true; │ │ │ │ - this.map.setBaseLayer(this.map.getLayer(button._layer)) │ │ │ │ - } else { │ │ │ │ - button.checked = !button.checked; │ │ │ │ - this.updateMap() │ │ │ │ - } │ │ │ │ + block.image = null; │ │ │ │ + if (block.div) { │ │ │ │ + this.groupDiv.removeChild(block.div) │ │ │ │ } │ │ │ │ + block.div = null │ │ │ │ } │ │ │ │ + this.blocks = null; │ │ │ │ + OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - clearLayersArray: function(layersType) { │ │ │ │ - this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ - this[layersType + "Layers"] = [] │ │ │ │ + setBackgroundColor: function(color) {}, │ │ │ │ + setBorder: function() {}, │ │ │ │ + setOpacity: function(opacity) {}, │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ + this.updateBlocks() │ │ │ │ }, │ │ │ │ - checkRedraw: function() { │ │ │ │ - if (!this.layerStates.length || this.map.layers.length != this.layerStates.length) { │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - for (var i = 0, len = this.layerStates.length; i < len; 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) { │ │ │ │ - return true │ │ │ │ - } │ │ │ │ + updateRelativePosition: function() { │ │ │ │ + this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ + if (this.closeDiv) { │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + this.closeDiv.style.right = contentDivPadding.right + this.padding.right + "px"; │ │ │ │ + this.closeDiv.style.top = contentDivPadding.top + this.padding.top + "px" │ │ │ │ } │ │ │ │ - return false │ │ │ │ + this.updateBlocks() │ │ │ │ }, │ │ │ │ - redraw: function() { │ │ │ │ - if (!this.checkRedraw()) { │ │ │ │ - return this.div │ │ │ │ + calculateNewPx: function(px) { │ │ │ │ + var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply(this, arguments); │ │ │ │ + newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ + return newPx │ │ │ │ + }, │ │ │ │ + createBlocks: function() { │ │ │ │ + this.blocks = []; │ │ │ │ + var firstPosition = null; │ │ │ │ + for (var key in this.positionBlocks) { │ │ │ │ + firstPosition = key; │ │ │ │ + break │ │ │ │ } │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ - var containsOverlays = false; │ │ │ │ - var containsBaseLayers = false; │ │ │ │ - var len = this.map.layers.length; │ │ │ │ - this.layerStates = new Array(len); │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - this.layerStates[i] = { │ │ │ │ - name: layer.name, │ │ │ │ - visibility: layer.visibility, │ │ │ │ - inRange: layer.inRange, │ │ │ │ - id: layer.id │ │ │ │ - } │ │ │ │ + var position = this.positionBlocks[firstPosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ + var block = {}; │ │ │ │ + this.blocks.push(block); │ │ │ │ + var divId = this.id + "_FrameDecorationDiv_" + i; │ │ │ │ + block.div = OpenLayers.Util.createDiv(divId, null, null, null, "absolute", null, "hidden", null); │ │ │ │ + var imgId = this.id + "_FrameDecorationImg_" + i; │ │ │ │ + var imageCreator = this.isAlphaImage ? OpenLayers.Util.createAlphaImageDiv : OpenLayers.Util.createImage; │ │ │ │ + block.image = imageCreator(imgId, null, this.imageSize, this.imageSrc, "absolute", null, null, null); │ │ │ │ + block.div.appendChild(block.image); │ │ │ │ + this.groupDiv.appendChild(block.div) │ │ │ │ } │ │ │ │ - var layers = this.map.layers.slice(); │ │ │ │ - if (!this.ascending) { │ │ │ │ - layers.reverse() │ │ │ │ + }, │ │ │ │ + updateBlocks: function() { │ │ │ │ + if (!this.blocks) { │ │ │ │ + this.createBlocks() │ │ │ │ } │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - var baseLayer = layer.isBaseLayer; │ │ │ │ - if (layer.displayInLayerSwitcher) { │ │ │ │ - if (baseLayer) { │ │ │ │ - containsBaseLayers = true │ │ │ │ - } else { │ │ │ │ - containsOverlays = true │ │ │ │ - } │ │ │ │ - var checked = baseLayer ? layer == this.map.baseLayer : layer.getVisibility(); │ │ │ │ - var inputElem = document.createElement("input"), │ │ │ │ - inputId = OpenLayers.Util.createUniqueID(this.id + "_input_"); │ │ │ │ - inputElem.id = inputId; │ │ │ │ - inputElem.name = baseLayer ? this.id + "_baseLayers" : layer.name; │ │ │ │ - inputElem.type = baseLayer ? "radio" : "checkbox"; │ │ │ │ - inputElem.value = layer.name; │ │ │ │ - inputElem.checked = checked; │ │ │ │ - inputElem.defaultChecked = checked; │ │ │ │ - inputElem.className = "olButton"; │ │ │ │ - inputElem._layer = layer.id; │ │ │ │ - inputElem._layerSwitcher = this.id; │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - inputElem.disabled = true │ │ │ │ - } │ │ │ │ - var labelSpan = document.createElement("label"); │ │ │ │ - labelSpan["for"] = inputElem.id; │ │ │ │ - OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ - labelSpan._layer = layer.id; │ │ │ │ - labelSpan._layerSwitcher = this.id; │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - labelSpan.style.color = "gray" │ │ │ │ - } │ │ │ │ - labelSpan.innerHTML = layer.name; │ │ │ │ - labelSpan.style.verticalAlign = baseLayer ? "bottom" : "baseline"; │ │ │ │ - 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 (this.size && this.relativePosition) { │ │ │ │ + var position = this.positionBlocks[this.relativePosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ + var positionBlock = position.blocks[i]; │ │ │ │ + var block = this.blocks[i]; │ │ │ │ + var l = positionBlock.anchor.left; │ │ │ │ + var b = positionBlock.anchor.bottom; │ │ │ │ + var r = positionBlock.anchor.right; │ │ │ │ + var t = positionBlock.anchor.top; │ │ │ │ + var w = isNaN(positionBlock.size.w) ? this.size.w - (r + l) : positionBlock.size.w; │ │ │ │ + var h = isNaN(positionBlock.size.h) ? this.size.h - (b + t) : positionBlock.size.h; │ │ │ │ + block.div.style.width = (w < 0 ? 0 : w) + "px"; │ │ │ │ + block.div.style.height = (h < 0 ? 0 : h) + "px"; │ │ │ │ + block.div.style.left = l != null ? l + "px" : ""; │ │ │ │ + block.div.style.bottom = b != null ? b + "px" : ""; │ │ │ │ + block.div.style.right = r != null ? r + "px" : ""; │ │ │ │ + block.div.style.top = t != null ? t + "px" : ""; │ │ │ │ + block.image.style.left = positionBlock.position.x + "px"; │ │ │ │ + block.image.style.top = positionBlock.position.y + "px" │ │ │ │ } │ │ │ │ + this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ + this.contentDiv.style.top = this.padding.top + "px" │ │ │ │ } │ │ │ │ - this.dataLbl.style.display = containsOverlays ? "" : "none"; │ │ │ │ - this.baseLbl.style.display = containsBaseLayers ? "" : "none"; │ │ │ │ - return this.div │ │ │ │ }, │ │ │ │ - updateMap: function() { │ │ │ │ - for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.baseLayers[i]; │ │ │ │ - if (layerEntry.inputElem.checked) { │ │ │ │ - this.map.setBaseLayer(layerEntry.layer, false) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.dataLayers[i]; │ │ │ │ - layerEntry.layer.setVisibility(layerEntry.inputElem.checked) │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ +}); │ │ │ │ +OpenLayers.Popup.FramedCloud = OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ + contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ + autoSize: true, │ │ │ │ + panMapIfOutOfView: true, │ │ │ │ + imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ + isAlphaImage: false, │ │ │ │ + fixedRelativePosition: false, │ │ │ │ + positionBlocks: { │ │ │ │ + tl: { │ │ │ │ + offset: new OpenLayers.Pixel(44, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 18), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -688) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + tr: { │ │ │ │ + offset: new OpenLayers.Pixel(-45, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 19), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ + position: new OpenLayers.Pixel(-215, -687) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + bl: { │ │ │ │ + offset: new OpenLayers.Pixel(45, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-101, -674) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + br: { │ │ │ │ + offset: new OpenLayers.Pixel(-44, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ + position: new OpenLayers.Pixel(-311, -674) │ │ │ │ + }] │ │ │ │ } │ │ │ │ }, │ │ │ │ - maximizeControl: function(e) { │ │ │ │ - this.div.style.width = ""; │ │ │ │ - this.div.style.height = ""; │ │ │ │ - this.showControls(false); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ - } │ │ │ │ + minSize: new OpenLayers.Size(105, 10), │ │ │ │ + maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ + this.imageSrc = OpenLayers.Util.getImageLocation("cloud-popup-relative.png"); │ │ │ │ + OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass │ │ │ │ }, │ │ │ │ - minimizeControl: function(e) { │ │ │ │ - this.div.style.width = "0px"; │ │ │ │ - this.div.style.height = "0px"; │ │ │ │ - this.showControls(true); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format = OpenLayers.Class({ │ │ │ │ + options: null, │ │ │ │ + externalProjection: null, │ │ │ │ + internalProjection: null, │ │ │ │ + data: null, │ │ │ │ + keepData: false, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options │ │ │ │ + }, │ │ │ │ + destroy: function() {}, │ │ │ │ + read: function(data) { │ │ │ │ + throw new Error("Read not implemented.") │ │ │ │ + }, │ │ │ │ + write: function(object) { │ │ │ │ + throw new Error("Write not implemented.") │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + indent: " ", │ │ │ │ + space: " ", │ │ │ │ + newline: "\n", │ │ │ │ + level: 0, │ │ │ │ + pretty: false, │ │ │ │ + nativeJSON: function() { │ │ │ │ + return !!(window.JSON && typeof JSON.parse == "function" && typeof JSON.stringify == "function") │ │ │ │ + }(), │ │ │ │ + read: function(json, filter) { │ │ │ │ + var object; │ │ │ │ + if (this.nativeJSON) { │ │ │ │ + object = JSON.parse(json, filter) │ │ │ │ + } else try { │ │ │ │ + if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, ""))) { │ │ │ │ + object = eval("(" + json + ")"); │ │ │ │ + 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) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } catch (e) {} │ │ │ │ + if (this.keepData) { │ │ │ │ + this.data = object │ │ │ │ } │ │ │ │ + return object │ │ │ │ }, │ │ │ │ - showControls: function(minimize) { │ │ │ │ - this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ - this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ - this.layersDiv.style.display = minimize ? "none" : "" │ │ │ │ + write: function(value, pretty) { │ │ │ │ + this.pretty = !!pretty; │ │ │ │ + var json = null; │ │ │ │ + var type = typeof value; │ │ │ │ + if (this.serialize[type]) { │ │ │ │ + try { │ │ │ │ + json = !this.pretty && this.nativeJSON ? JSON.stringify(value) : this.serialize[type].apply(this, [value]) │ │ │ │ + } catch (err) { │ │ │ │ + OpenLayers.Console.error("Trouble serializing: " + err) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return json │ │ │ │ }, │ │ │ │ - loadContents: function() { │ │ │ │ - this.layersDiv = document.createElement("div"); │ │ │ │ - this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ - OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ - this.baseLbl = document.createElement("div"); │ │ │ │ - this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ - this.baseLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ - this.dataLbl = document.createElement("div"); │ │ │ │ - this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ - this.dataLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ - 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) │ │ │ │ + writeIndent: function() { │ │ │ │ + var pieces = []; │ │ │ │ + if (this.pretty) { │ │ │ │ + for (var i = 0; i < this.level; ++i) { │ │ │ │ + pieces.push(this.indent) │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.div.appendChild(this.layersDiv); │ │ │ │ - var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png"); │ │ │ │ - this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MaximizeDiv", null, null, img, "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ - this.maximizeDiv.style.display = "none"; │ │ │ │ - this.div.appendChild(this.maximizeDiv); │ │ │ │ - var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png"); │ │ │ │ - this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MinimizeDiv", null, null, img, "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ - this.minimizeDiv.style.display = "none"; │ │ │ │ - this.div.appendChild(this.minimizeDiv) │ │ │ │ + return pieces.join("") │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Attribution = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - separator: ", ", │ │ │ │ - template: "${layers}", │ │ │ │ - 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) │ │ │ │ + writeNewline: function() { │ │ │ │ + return this.pretty ? this.newline : "" │ │ │ │ }, │ │ │ │ - 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 │ │ │ │ + writeSpace: function() { │ │ │ │ + return this.pretty ? this.space : "" │ │ │ │ }, │ │ │ │ - updateAttribution: function() { │ │ │ │ - var attributions = []; │ │ │ │ - if (this.map && this.map.layers) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (layer.attribution && layer.getVisibility()) { │ │ │ │ - if (OpenLayers.Util.indexOf(attributions, layer.attribution) === -1) { │ │ │ │ - attributions.push(layer.attribution) │ │ │ │ + serialize: { │ │ │ │ + object: function(object) { │ │ │ │ + if (object == null) { │ │ │ │ + return "null" │ │ │ │ + } │ │ │ │ + if (object.constructor == Date) { │ │ │ │ + return this.serialize.date.apply(this, [object]) │ │ │ │ + } │ │ │ │ + if (object.constructor == Array) { │ │ │ │ + return this.serialize.array.apply(this, [object]) │ │ │ │ + } │ │ │ │ + var pieces = ["{"]; │ │ │ │ + this.level += 1; │ │ │ │ + var key, keyJSON, valueJSON; │ │ │ │ + var addComma = false; │ │ │ │ + for (key in object) { │ │ │ │ + if (object.hasOwnProperty(key)) { │ │ │ │ + keyJSON = OpenLayers.Format.JSON.prototype.write.apply(this, [key, this.pretty]); │ │ │ │ + valueJSON = OpenLayers.Format.JSON.prototype.write.apply(this, [object[key], this.pretty]); │ │ │ │ + if (keyJSON != null && valueJSON != null) { │ │ │ │ + if (addComma) { │ │ │ │ + pieces.push(",") │ │ │ │ + } │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), keyJSON, ":", this.writeSpace(), valueJSON); │ │ │ │ + addComma = true │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ - layers: attributions.join(this.separator) │ │ │ │ - }) │ │ │ │ + this.level -= 1; │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), "}"); │ │ │ │ + return pieces.join("") │ │ │ │ + }, │ │ │ │ + array: function(array) { │ │ │ │ + var json; │ │ │ │ + var pieces = ["["]; │ │ │ │ + this.level += 1; │ │ │ │ + for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ + json = OpenLayers.Format.JSON.prototype.write.apply(this, [array[i], this.pretty]); │ │ │ │ + if (json != null) { │ │ │ │ + if (i > 0) { │ │ │ │ + pieces.push(",") │ │ │ │ + } │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), json) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.level -= 1; │ │ │ │ + pieces.push(this.writeNewline(), this.writeIndent(), "]"); │ │ │ │ + return pieces.join("") │ │ │ │ + }, │ │ │ │ + string: function(string) { │ │ │ │ + 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 + '"' │ │ │ │ + }, │ │ │ │ + number: function(number) { │ │ │ │ + return isFinite(number) ? String(number) : "null" │ │ │ │ + }, │ │ │ │ + boolean: function(bool) { │ │ │ │ + return String(bool) │ │ │ │ + }, │ │ │ │ + date: function(date) { │ │ │ │ + function format(number) { │ │ │ │ + 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.Control.Attribution" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.JSON" │ │ │ │ }); │ │ │ │ -OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ +OpenLayers.Geometry = OpenLayers.Class({ │ │ │ │ id: null, │ │ │ │ - control: null, │ │ │ │ - map: null, │ │ │ │ - keyMask: null, │ │ │ │ - active: false, │ │ │ │ - evt: null, │ │ │ │ - touch: false, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.control = control; │ │ │ │ - this.callbacks = callbacks; │ │ │ │ - var map = this.map || control.map; │ │ │ │ - if (map) { │ │ │ │ - this.setMap(map) │ │ │ │ - } │ │ │ │ + parent: null, │ │ │ │ + bounds: null, │ │ │ │ + initialize: function() { │ │ │ │ this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map │ │ │ │ + destroy: function() { │ │ │ │ + this.id = null; │ │ │ │ + this.bounds = null │ │ │ │ }, │ │ │ │ - checkModifiers: function(evt) { │ │ │ │ - if (this.keyMask == null) { │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - var keyModifiers = (evt.shiftKey ? OpenLayers.Handler.MOD_SHIFT : 0) | (evt.ctrlKey ? OpenLayers.Handler.MOD_CTRL : 0) | (evt.altKey ? OpenLayers.Handler.MOD_ALT : 0) | (evt.metaKey ? OpenLayers.Handler.MOD_META : 0); │ │ │ │ - return keyModifiers == this.keyMask │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Geometry │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - var events = OpenLayers.Events.prototype.BROWSER_EVENTS; │ │ │ │ - for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.register(events[i], this[events[i]]) │ │ │ │ - } │ │ │ │ + setBounds: function(bounds) { │ │ │ │ + if (bounds) { │ │ │ │ + this.bounds = bounds.clone() │ │ │ │ } │ │ │ │ - this.active = true; │ │ │ │ - return true │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - return false │ │ │ │ + clearBounds: function() { │ │ │ │ + this.bounds = null; │ │ │ │ + if (this.parent) { │ │ │ │ + this.parent.clearBounds() │ │ │ │ } │ │ │ │ - var events = OpenLayers.Events.prototype.BROWSER_EVENTS; │ │ │ │ - for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.unregister(events[i], this[events[i]]) │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + extendBounds: function(newBounds) { │ │ │ │ + var bounds = this.getBounds(); │ │ │ │ + if (!bounds) { │ │ │ │ + this.setBounds(newBounds) │ │ │ │ + } else { │ │ │ │ + this.bounds.extend(newBounds) │ │ │ │ } │ │ │ │ - this.touch = false; │ │ │ │ - this.active = false; │ │ │ │ - return true │ │ │ │ }, │ │ │ │ - startTouch: function() { │ │ │ │ - if (!this.touch) { │ │ │ │ - this.touch = true; │ │ │ │ - var events = ["mousedown", "mouseup", "mousemove", "click", "dblclick", "mouseout"]; │ │ │ │ - for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ - if (this[events[i]]) { │ │ │ │ - this.unregister(events[i], this[events[i]]) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + getBounds: function() { │ │ │ │ + if (this.bounds == null) { │ │ │ │ + this.calculateBounds() │ │ │ │ } │ │ │ │ + return this.bounds │ │ │ │ }, │ │ │ │ - callback: function(name, args) { │ │ │ │ - if (name && this.callbacks[name]) { │ │ │ │ - this.callbacks[name].apply(this.control, args) │ │ │ │ + calculateBounds: function() {}, │ │ │ │ + distanceTo: function(geometry, options) {}, │ │ │ │ + getVertices: function(nodes) {}, │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + var bounds = this.getBounds(); │ │ │ │ + if (bounds != null && lonlat != null) { │ │ │ │ + var dX = toleranceLon != null ? toleranceLon : 0; │ │ │ │ + var dY = toleranceLat != null ? toleranceLat : 0; │ │ │ │ + var toleranceBounds = new OpenLayers.Bounds(this.bounds.left - dX, this.bounds.bottom - dY, this.bounds.right + dX, this.bounds.top + dY); │ │ │ │ + atPoint = toleranceBounds.containsLonLat(lonlat) │ │ │ │ } │ │ │ │ + return atPoint │ │ │ │ }, │ │ │ │ - register: function(name, method) { │ │ │ │ - this.map.events.registerPriority(name, this, method); │ │ │ │ - this.map.events.registerPriority(name, this, this.setEvent) │ │ │ │ + getLength: function() { │ │ │ │ + return 0 │ │ │ │ }, │ │ │ │ - unregister: function(name, method) { │ │ │ │ - this.map.events.unregister(name, this, method); │ │ │ │ - this.map.events.unregister(name, this, this.setEvent) │ │ │ │ + getArea: function() { │ │ │ │ + return 0 │ │ │ │ }, │ │ │ │ - setEvent: function(evt) { │ │ │ │ - this.evt = evt; │ │ │ │ - return true │ │ │ │ + getCentroid: function() { │ │ │ │ + return null │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.control = this.map = null │ │ │ │ + toString: function() { │ │ │ │ + var string; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ + string = OpenLayers.Format.WKT.prototype.write(new OpenLayers.Feature.Vector(this)) │ │ │ │ + } else { │ │ │ │ + string = Object.prototype.toString.call(this) │ │ │ │ + } │ │ │ │ + return string │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler" │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry" │ │ │ │ }); │ │ │ │ -OpenLayers.Handler.MOD_NONE = 0; │ │ │ │ -OpenLayers.Handler.MOD_SHIFT = 1; │ │ │ │ -OpenLayers.Handler.MOD_CTRL = 2; │ │ │ │ -OpenLayers.Handler.MOD_ALT = 4; │ │ │ │ -OpenLayers.Handler.MOD_META = 8; │ │ │ │ -OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - started: false, │ │ │ │ - stopDown: true, │ │ │ │ - dragging: false, │ │ │ │ - last: null, │ │ │ │ - start: null, │ │ │ │ - lastMoveEvt: null, │ │ │ │ - oldOnselectstart: null, │ │ │ │ - interval: 0, │ │ │ │ - timeoutId: null, │ │ │ │ - documentDrag: false, │ │ │ │ - documentEvents: null, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - var me = this; │ │ │ │ - this._docMove = function(evt) { │ │ │ │ - me.mousemove({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - }, │ │ │ │ - element: document │ │ │ │ - }) │ │ │ │ - }; │ │ │ │ - this._docUp = function(evt) { │ │ │ │ - me.mouseup({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - } │ │ │ │ - }) │ │ │ │ +OpenLayers.Geometry.fromWKT = function(wkt) { │ │ │ │ + var geom; │ │ │ │ + if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ + var format = OpenLayers.Geometry.fromWKT.format; │ │ │ │ + if (!format) { │ │ │ │ + format = new OpenLayers.Format.WKT; │ │ │ │ + OpenLayers.Geometry.fromWKT.format = format │ │ │ │ + } │ │ │ │ + var result = format.read(wkt); │ │ │ │ + if (result instanceof OpenLayers.Feature.Vector) { │ │ │ │ + geom = result.geometry │ │ │ │ + } else if (OpenLayers.Util.isArray(result)) { │ │ │ │ + var len = result.length; │ │ │ │ + var components = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + components[i] = result[i].geometry │ │ │ │ } │ │ │ │ + geom = new OpenLayers.Geometry.Collection(components) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - dragstart: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - this.dragging = false; │ │ │ │ - if (this.checkModifiers(evt) && (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ - this.started = true; │ │ │ │ - this.start = evt.xy; │ │ │ │ - this.last = evt.xy; │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ - this.down(evt); │ │ │ │ - this.callback("down", [evt.xy]); │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart ? document.onselectstart : OpenLayers.Function.True │ │ │ │ + } │ │ │ │ + return geom │ │ │ │ +}; │ │ │ │ +OpenLayers.Geometry.segmentsIntersect = function(seg1, seg2, options) { │ │ │ │ + var point = options && options.point; │ │ │ │ + var tolerance = options && options.tolerance; │ │ │ │ + var intersection = false; │ │ │ │ + var x11_21 = seg1.x1 - seg2.x1; │ │ │ │ + var y11_21 = seg1.y1 - seg2.y1; │ │ │ │ + var x12_11 = seg1.x2 - seg1.x1; │ │ │ │ + var y12_11 = seg1.y2 - seg1.y1; │ │ │ │ + var y22_21 = seg2.y2 - seg2.y1; │ │ │ │ + var x22_21 = seg2.x2 - seg2.x1; │ │ │ │ + var d = y22_21 * x12_11 - x22_21 * y12_11; │ │ │ │ + var n1 = x22_21 * y11_21 - y22_21 * x11_21; │ │ │ │ + var n2 = x12_11 * y11_21 - y12_11 * x11_21; │ │ │ │ + if (d == 0) { │ │ │ │ + if (n1 == 0 && n2 == 0) { │ │ │ │ + intersection = true │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + var along1 = n1 / d; │ │ │ │ + var along2 = n2 / d; │ │ │ │ + if (along1 >= 0 && along1 <= 1 && along2 >= 0 && along2 <= 1) { │ │ │ │ + if (!point) { │ │ │ │ + intersection = true │ │ │ │ + } else { │ │ │ │ + var x = seg1.x1 + along1 * x12_11; │ │ │ │ + var y = seg1.y1 + along1 * y12_11; │ │ │ │ + intersection = new OpenLayers.Geometry.Point(x, y) │ │ │ │ } │ │ │ │ - document.onselectstart = OpenLayers.Function.False; │ │ │ │ - propagate = !this.stopDown │ │ │ │ - } else { │ │ │ │ - this.started = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null │ │ │ │ } │ │ │ │ - return propagate │ │ │ │ - }, │ │ │ │ - dragmove: function(evt) { │ │ │ │ - this.lastMoveEvt = evt; │ │ │ │ - if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || evt.xy.y != this.last.y)) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - if (evt.element === document) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - this.setEvent(evt) │ │ │ │ - } else { │ │ │ │ - this.removeDocumentEvents() │ │ │ │ + } │ │ │ │ + if (tolerance) { │ │ │ │ + var dist; │ │ │ │ + if (intersection) { │ │ │ │ + if (point) { │ │ │ │ + var segs = [seg1, seg2]; │ │ │ │ + var seg, x, y; │ │ │ │ + outer: for (var i = 0; i < 2; ++i) { │ │ │ │ + seg = segs[i]; │ │ │ │ + for (var j = 1; j < 3; ++j) { │ │ │ │ + x = seg["x" + j]; │ │ │ │ + y = seg["y" + j]; │ │ │ │ + dist = Math.sqrt(Math.pow(x - intersection.x, 2) + Math.pow(y - intersection.y, 2)); │ │ │ │ + if (dist < tolerance) { │ │ │ │ + intersection.x = x; │ │ │ │ + intersection.y = y; │ │ │ │ + break outer │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - if (this.interval > 0) { │ │ │ │ - this.timeoutId = setTimeout(OpenLayers.Function.bind(this.removeTimeout, this), this.interval) │ │ │ │ - } │ │ │ │ - this.dragging = true; │ │ │ │ - this.move(evt); │ │ │ │ - this.callback("move", [evt.xy]); │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart; │ │ │ │ - document.onselectstart = OpenLayers.Function.False │ │ │ │ + } else { │ │ │ │ + var segs = [seg1, seg2]; │ │ │ │ + var source, target, x, y, p, result; │ │ │ │ + outer: for (var i = 0; i < 2; ++i) { │ │ │ │ + source = segs[i]; │ │ │ │ + target = segs[(i + 1) % 2]; │ │ │ │ + for (var j = 1; j < 3; ++j) { │ │ │ │ + p = { │ │ │ │ + x: source["x" + j], │ │ │ │ + y: source["y" + j] │ │ │ │ + }; │ │ │ │ + result = OpenLayers.Geometry.distanceToSegment(p, target); │ │ │ │ + if (result.distance < tolerance) { │ │ │ │ + if (point) { │ │ │ │ + intersection = new OpenLayers.Geometry.Point(p.x, p.y) │ │ │ │ + } else { │ │ │ │ + intersection = true │ │ │ │ + } │ │ │ │ + break outer │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.last = evt.xy │ │ │ │ } │ │ │ │ - return true │ │ │ │ + } │ │ │ │ + return intersection │ │ │ │ +}; │ │ │ │ +OpenLayers.Geometry.distanceToSegment = function(point, segment) { │ │ │ │ + var result = OpenLayers.Geometry.distanceSquaredToSegment(point, segment); │ │ │ │ + result.distance = Math.sqrt(result.distance); │ │ │ │ + return result │ │ │ │ +}; │ │ │ │ +OpenLayers.Geometry.distanceSquaredToSegment = function(point, segment) { │ │ │ │ + var x0 = point.x; │ │ │ │ + var y0 = point.y; │ │ │ │ + var x1 = segment.x1; │ │ │ │ + var y1 = segment.y1; │ │ │ │ + var x2 = segment.x2; │ │ │ │ + var y2 = segment.y2; │ │ │ │ + var dx = x2 - x1; │ │ │ │ + var dy = y2 - y1; │ │ │ │ + var along = (dx * (x0 - x1) + dy * (y0 - y1)) / (Math.pow(dx, 2) + Math.pow(dy, 2)); │ │ │ │ + var x, y; │ │ │ │ + if (along <= 0) { │ │ │ │ + x = x1; │ │ │ │ + y = y1 │ │ │ │ + } else if (along >= 1) { │ │ │ │ + x = x2; │ │ │ │ + y = y2 │ │ │ │ + } else { │ │ │ │ + x = x1 + along * dx; │ │ │ │ + y = y1 + along * dy │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + distance: Math.pow(x - x0, 2) + Math.pow(y - y0, 2), │ │ │ │ + x: x, │ │ │ │ + y: y, │ │ │ │ + along: along │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +OpenLayers.Geometry.Point = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ + x: null, │ │ │ │ + y: null, │ │ │ │ + initialize: function(x, y) { │ │ │ │ + OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ + this.x = parseFloat(x); │ │ │ │ + this.y = parseFloat(y) │ │ │ │ }, │ │ │ │ - dragend: function(evt) { │ │ │ │ - if (this.started) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - this.removeDocumentEvents() │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Geometry.Point(this.x, this.y) │ │ │ │ + } │ │ │ │ + OpenLayers.Util.applyDefaults(obj, this); │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + calculateBounds: function() { │ │ │ │ + this.bounds = new OpenLayers.Bounds(this.x, this.y, this.x, this.y) │ │ │ │ + }, │ │ │ │ + distanceTo: function(geometry, options) { │ │ │ │ + var edge = !(options && options.edge === false); │ │ │ │ + var details = edge && options && options.details; │ │ │ │ + var distance, x0, y0, x1, y1, result; │ │ │ │ + if (geometry instanceof OpenLayers.Geometry.Point) { │ │ │ │ + x0 = this.x; │ │ │ │ + y0 = this.y; │ │ │ │ + x1 = geometry.x; │ │ │ │ + y1 = geometry.y; │ │ │ │ + distance = Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2)); │ │ │ │ + result = !details ? distance : { │ │ │ │ + x0: x0, │ │ │ │ + y0: y0, │ │ │ │ + x1: x1, │ │ │ │ + y1: y1, │ │ │ │ + distance: distance │ │ │ │ } │ │ │ │ - var dragged = this.start != this.last; │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ - this.up(evt); │ │ │ │ - this.callback("up", [evt.xy]); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]) │ │ │ │ + } else { │ │ │ │ + result = geometry.distanceTo(this, options); │ │ │ │ + if (details) { │ │ │ │ + result = { │ │ │ │ + x0: result.x1, │ │ │ │ + y0: result.y1, │ │ │ │ + x1: result.x0, │ │ │ │ + y1: result.y0, │ │ │ │ + distance: result.distance │ │ │ │ + } │ │ │ │ } │ │ │ │ - document.onselectstart = this.oldOnselectstart │ │ │ │ } │ │ │ │ - return true │ │ │ │ + return result │ │ │ │ }, │ │ │ │ - down: function(evt) {}, │ │ │ │ - move: function(evt) {}, │ │ │ │ - up: function(evt) {}, │ │ │ │ - out: function(evt) {}, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - return this.dragstart(evt) │ │ │ │ + equals: function(geom) { │ │ │ │ + var equals = false; │ │ │ │ + if (geom != null) { │ │ │ │ + equals = this.x == geom.x && this.y == geom.y || isNaN(this.x) && isNaN(this.y) && isNaN(geom.x) && isNaN(geom.y) │ │ │ │ + } │ │ │ │ + return equals │ │ │ │ }, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return this.dragstart(evt) │ │ │ │ + toShortString: function() { │ │ │ │ + return this.x + ", " + this.y │ │ │ │ }, │ │ │ │ - mousemove: function(evt) { │ │ │ │ - return this.dragmove(evt) │ │ │ │ + move: function(x, y) { │ │ │ │ + this.x = this.x + x; │ │ │ │ + this.y = this.y + y; │ │ │ │ + this.clearBounds() │ │ │ │ }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - return this.dragmove(evt) │ │ │ │ + rotate: function(angle, origin) { │ │ │ │ + angle *= Math.PI / 180; │ │ │ │ + var radius = this.distanceTo(origin); │ │ │ │ + var theta = angle + Math.atan2(this.y - origin.y, this.x - origin.x); │ │ │ │ + this.x = origin.x + radius * Math.cos(theta); │ │ │ │ + this.y = origin.y + radius * Math.sin(theta); │ │ │ │ + this.clearBounds() │ │ │ │ }, │ │ │ │ - removeTimeout: function() { │ │ │ │ - this.timeoutId = null; │ │ │ │ - if (this.dragging) { │ │ │ │ - this.mousemove(this.lastMoveEvt) │ │ │ │ - } │ │ │ │ + getCentroid: function() { │ │ │ │ + return new OpenLayers.Geometry.Point(this.x, this.y) │ │ │ │ }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - return this.dragend(evt) │ │ │ │ + resize: function(scale, origin, ratio) { │ │ │ │ + ratio = ratio == undefined ? 1 : ratio; │ │ │ │ + this.x = origin.x + scale * ratio * (this.x - origin.x); │ │ │ │ + this.y = origin.y + scale * (this.y - origin.y); │ │ │ │ + this.clearBounds(); │ │ │ │ + return this │ │ │ │ }, │ │ │ │ - touchend: function(evt) { │ │ │ │ - evt.xy = this.last; │ │ │ │ - return this.dragend(evt) │ │ │ │ + intersects: function(geometry) { │ │ │ │ + var intersect = false; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + intersect = this.equals(geometry) │ │ │ │ + } else { │ │ │ │ + intersect = geometry.intersects(this) │ │ │ │ + } │ │ │ │ + return intersect │ │ │ │ }, │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - this.addDocumentEvents() │ │ │ │ - } else { │ │ │ │ - var dragged = this.start != this.last; │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ - this.out(evt); │ │ │ │ - this.callback("out", []); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]) │ │ │ │ - } │ │ │ │ - if (document.onselectstart) { │ │ │ │ - document.onselectstart = this.oldOnselectstart │ │ │ │ - } │ │ │ │ - } │ │ │ │ + transform: function(source, dest) { │ │ │ │ + if (source && dest) { │ │ │ │ + OpenLayers.Projection.transform(this, source, dest); │ │ │ │ + this.bounds = null │ │ │ │ } │ │ │ │ - return true │ │ │ │ + return this │ │ │ │ }, │ │ │ │ - click: function(evt) { │ │ │ │ - return this.start == this.last │ │ │ │ + getVertices: function(nodes) { │ │ │ │ + return [this] │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragging = false; │ │ │ │ - activated = true │ │ │ │ + CLASS_NAME: "OpenLayers.Geometry.Point" │ │ │ │ +}); │ │ │ │ +OpenLayers.Geometry.Collection = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ + components: null, │ │ │ │ + componentTypes: null, │ │ │ │ + initialize: function(components) { │ │ │ │ + OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ + this.components = []; │ │ │ │ + if (components != null) { │ │ │ │ + this.addComponents(components) │ │ │ │ } │ │ │ │ - return activated │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown") │ │ │ │ + destroy: function() { │ │ │ │ + this.components.length = 0; │ │ │ │ + this.components = null; │ │ │ │ + OpenLayers.Geometry.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var geometry = eval("new " + this.CLASS_NAME + "()"); │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + geometry.addComponent(this.components[i].clone()) │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ + OpenLayers.Util.applyDefaults(geometry, this); │ │ │ │ + return geometry │ │ │ │ }, │ │ │ │ - adjustXY: function(evt) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ - evt.xy.x -= pos[0]; │ │ │ │ - evt.xy.y -= pos[1] │ │ │ │ - }, │ │ │ │ - addDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = true; │ │ │ │ - OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.observe(document, "mouseup", this._docUp) │ │ │ │ - }, │ │ │ │ - removeDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = false; │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mouseup", this._docUp) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - dragHandler: null, │ │ │ │ - boxDivClassName: "olHandlerBoxZoomBox", │ │ │ │ - boxOffsets: null, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.dragHandler = new OpenLayers.Handler.Drag(this, { │ │ │ │ - down: this.startBox, │ │ │ │ - move: this.moveBox, │ │ │ │ - out: this.removeBox, │ │ │ │ - up: this.endBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.dragHandler) { │ │ │ │ - this.dragHandler.destroy(); │ │ │ │ - this.dragHandler = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Handler.prototype.setMap.apply(this, arguments); │ │ │ │ - if (this.dragHandler) { │ │ │ │ - this.dragHandler.setMap(map) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - startBox: function(xy) { │ │ │ │ - this.callback("start", []); │ │ │ │ - this.zoomBox = OpenLayers.Util.createDiv("zoomBox", { │ │ │ │ - x: -9999, │ │ │ │ - y: -9999 │ │ │ │ - }); │ │ │ │ - this.zoomBox.className = this.boxDivClassName; │ │ │ │ - this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; │ │ │ │ - this.map.viewPortDiv.appendChild(this.zoomBox); │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olDrawBox") │ │ │ │ - }, │ │ │ │ - moveBox: function(xy) { │ │ │ │ - var startX = this.dragHandler.start.x; │ │ │ │ - var startY = this.dragHandler.start.y; │ │ │ │ - var deltaX = Math.abs(startX - xy.x); │ │ │ │ - var deltaY = Math.abs(startY - xy.y); │ │ │ │ - var offset = this.getBoxOffsets(); │ │ │ │ - this.zoomBox.style.width = deltaX + offset.width + 1 + "px"; │ │ │ │ - this.zoomBox.style.height = deltaY + offset.height + 1 + "px"; │ │ │ │ - this.zoomBox.style.left = (xy.x < startX ? startX - deltaX - offset.left : startX - offset.left) + "px"; │ │ │ │ - this.zoomBox.style.top = (xy.y < startY ? startY - deltaY - offset.top : startY - offset.top) + "px" │ │ │ │ - }, │ │ │ │ - endBox: function(end) { │ │ │ │ - var result; │ │ │ │ - if (Math.abs(this.dragHandler.start.x - end.x) > 5 || Math.abs(this.dragHandler.start.y - end.y) > 5) { │ │ │ │ - var start = this.dragHandler.start; │ │ │ │ - var top = Math.min(start.y, end.y); │ │ │ │ - var bottom = Math.max(start.y, end.y); │ │ │ │ - var left = Math.min(start.x, end.x); │ │ │ │ - var right = Math.max(start.x, end.x); │ │ │ │ - result = new OpenLayers.Bounds(left, bottom, right, top) │ │ │ │ - } else { │ │ │ │ - result = this.dragHandler.start.clone() │ │ │ │ - } │ │ │ │ - this.removeBox(); │ │ │ │ - this.callback("done", [result]) │ │ │ │ - }, │ │ │ │ - removeBox: function() { │ │ │ │ - this.map.viewPortDiv.removeChild(this.zoomBox); │ │ │ │ - this.zoomBox = null; │ │ │ │ - this.boxOffsets = null; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDrawBox") │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragHandler.activate(); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - if (this.dragHandler.deactivate()) { │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.removeBox() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getBoxOffsets: function() { │ │ │ │ - if (!this.boxOffsets) { │ │ │ │ - var testDiv = document.createElement("div"); │ │ │ │ - testDiv.style.position = "absolute"; │ │ │ │ - testDiv.style.border = "1px solid black"; │ │ │ │ - testDiv.style.width = "3px"; │ │ │ │ - document.body.appendChild(testDiv); │ │ │ │ - var w3cBoxModel = testDiv.clientWidth == 3; │ │ │ │ - document.body.removeChild(testDiv); │ │ │ │ - var left = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-left-width")); │ │ │ │ - var right = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-right-width")); │ │ │ │ - var top = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-top-width")); │ │ │ │ - var bottom = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-bottom-width")); │ │ │ │ - this.boxOffsets = { │ │ │ │ - left: left, │ │ │ │ - right: right, │ │ │ │ - top: top, │ │ │ │ - bottom: bottom, │ │ │ │ - width: w3cBoxModel === false ? left + right : 0, │ │ │ │ - height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return this.boxOffsets │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - out: false, │ │ │ │ - keyMask: null, │ │ │ │ - alwaysZoom: false, │ │ │ │ - zoomOnClick: true, │ │ │ │ - draw: function() { │ │ │ │ - this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.zoomBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - zoomBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var bounds, targetCenterPx = position.getCenterPixel(); │ │ │ │ - if (!this.out) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat) │ │ │ │ - } else { │ │ │ │ - var pixWidth = position.right - position.left; │ │ │ │ - var pixHeight = position.bottom - position.top; │ │ │ │ - var zoomFactor = Math.min(this.map.size.h / pixHeight, this.map.size.w / pixWidth); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ - var xmin = center.lon - extent.getWidth() / 2 * zoomFactor; │ │ │ │ - var xmax = center.lon + extent.getWidth() / 2 * zoomFactor; │ │ │ │ - var ymin = center.lat - extent.getHeight() / 2 * zoomFactor; │ │ │ │ - var ymax = center.lat + extent.getHeight() / 2 * zoomFactor; │ │ │ │ - bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax) │ │ │ │ - } │ │ │ │ - var lastZoom = this.map.getZoom(), │ │ │ │ - size = this.map.getSize(), │ │ │ │ - centerPx = { │ │ │ │ - x: size.w / 2, │ │ │ │ - y: size.h / 2 │ │ │ │ - }, │ │ │ │ - zoom = this.map.getZoomForExtent(bounds), │ │ │ │ - oldRes = this.map.getResolution(), │ │ │ │ - newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ - if (oldRes == newRes) { │ │ │ │ - this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)) │ │ │ │ - } else { │ │ │ │ - var zoomOriginPx = { │ │ │ │ - x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / (oldRes - newRes), │ │ │ │ - y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / (oldRes - newRes) │ │ │ │ - }; │ │ │ │ - this.map.zoomTo(zoom, zoomOriginPx) │ │ │ │ - } │ │ │ │ - if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ - this.map.zoomTo(lastZoom + (this.out ? -1 : 1)) │ │ │ │ - } │ │ │ │ - } else if (this.zoomOnClick) { │ │ │ │ - if (!this.out) { │ │ │ │ - this.map.zoomTo(this.map.getZoom() + 1, position) │ │ │ │ - } else { │ │ │ │ - this.map.zoomTo(this.map.getZoom() - 1, position) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - panned: false, │ │ │ │ - interval: 0, │ │ │ │ - documentDrag: false, │ │ │ │ - kinetic: null, │ │ │ │ - enableKinetic: true, │ │ │ │ - kineticInterval: 10, │ │ │ │ - draw: function() { │ │ │ │ - if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ - var config = { │ │ │ │ - interval: this.kineticInterval │ │ │ │ - }; │ │ │ │ - if (typeof this.enableKinetic === "object") { │ │ │ │ - config = OpenLayers.Util.extend(config, this.enableKinetic) │ │ │ │ - } │ │ │ │ - this.kinetic = new OpenLayers.Kinetic(config) │ │ │ │ - } │ │ │ │ - this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ - move: this.panMap, │ │ │ │ - done: this.panMapDone, │ │ │ │ - down: this.panMapStart │ │ │ │ - }, { │ │ │ │ - interval: this.interval, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - panMapStart: function() { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.begin() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - panMap: function(xy) { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.update(xy) │ │ │ │ - } │ │ │ │ - this.panned = true; │ │ │ │ - this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ - dragging: true, │ │ │ │ - animate: false │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - panMapDone: function(xy) { │ │ │ │ - if (this.panned) { │ │ │ │ - var res = null; │ │ │ │ - if (this.kinetic) { │ │ │ │ - res = this.kinetic.end(xy) │ │ │ │ - } │ │ │ │ - this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ - dragging: !!res, │ │ │ │ - animate: false │ │ │ │ - }); │ │ │ │ - if (res) { │ │ │ │ - var self = this; │ │ │ │ - this.kinetic.move(res, function(x, y, end) { │ │ │ │ - self.map.pan(x, y, { │ │ │ │ - dragging: !end, │ │ │ │ - animate: false │ │ │ │ - }) │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.panned = false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - wheelListener: null, │ │ │ │ - interval: 0, │ │ │ │ - maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ - delta: 0, │ │ │ │ - cumulative: true, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.wheelListener = OpenLayers.Function.bindAsEventListener(this.onWheelEvent, this) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ - this.wheelListener = null │ │ │ │ - }, │ │ │ │ - onWheelEvent: function(e) { │ │ │ │ - if (!this.map || !this.checkModifiers(e)) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var overScrollableDiv = false; │ │ │ │ - var allowScroll = false; │ │ │ │ - var overMapDiv = false; │ │ │ │ - var elem = OpenLayers.Event.element(e); │ │ │ │ - while (elem != null && !overMapDiv && !overScrollableDiv) { │ │ │ │ - if (!overScrollableDiv) { │ │ │ │ - try { │ │ │ │ - var overflow; │ │ │ │ - if (elem.currentStyle) { │ │ │ │ - overflow = elem.currentStyle["overflow"] │ │ │ │ - } else { │ │ │ │ - var style = document.defaultView.getComputedStyle(elem, null); │ │ │ │ - overflow = style.getPropertyValue("overflow") │ │ │ │ - } │ │ │ │ - overScrollableDiv = overflow && overflow == "auto" || overflow == "scroll" │ │ │ │ - } catch (err) {} │ │ │ │ - } │ │ │ │ - if (!allowScroll) { │ │ │ │ - allowScroll = OpenLayers.Element.hasClass(elem, "olScrollable"); │ │ │ │ - if (!allowScroll) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (elem == layer.div || elem == layer.pane) { │ │ │ │ - allowScroll = true; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - overMapDiv = elem == this.map.div; │ │ │ │ - elem = elem.parentNode │ │ │ │ - } │ │ │ │ - if (!overScrollableDiv && overMapDiv) { │ │ │ │ - if (allowScroll) { │ │ │ │ - var delta = 0; │ │ │ │ - if (e.wheelDelta) { │ │ │ │ - delta = e.wheelDelta; │ │ │ │ - if (delta % 160 === 0) { │ │ │ │ - delta = delta * .75 │ │ │ │ - } │ │ │ │ - delta = delta / 120 │ │ │ │ - } else if (e.detail) { │ │ │ │ - delta = -(e.detail / Math.abs(e.detail)) │ │ │ │ - } │ │ │ │ - this.delta += delta; │ │ │ │ - window.clearTimeout(this._timeoutId); │ │ │ │ - if (this.interval && Math.abs(this.delta) < this.maxDelta) { │ │ │ │ - var evt = OpenLayers.Util.extend({}, e); │ │ │ │ - this._timeoutId = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ - this.wheelZoom(evt) │ │ │ │ - }, this), this.interval) │ │ │ │ - } else { │ │ │ │ - this.wheelZoom(e) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - wheelZoom: function(e) { │ │ │ │ - var delta = this.delta; │ │ │ │ - this.delta = 0; │ │ │ │ - if (delta) { │ │ │ │ - e.xy = this.map.events.getMousePosition(e); │ │ │ │ - if (delta < 0) { │ │ │ │ - this.callback("down", [e, this.cumulative ? Math.max(-this.maxDelta, delta) : -1]) │ │ │ │ - } else { │ │ │ │ - this.callback("up", [e, this.cumulative ? Math.min(this.maxDelta, delta) : 1]) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - activate: function(evt) { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - var wheelListener = this.wheelListener; │ │ │ │ - OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener); │ │ │ │ - OpenLayers.Event.observe(window, "mousewheel", wheelListener); │ │ │ │ - OpenLayers.Event.observe(document, "mousewheel", wheelListener); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - deactivate: function(evt) { │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - var wheelListener = this.wheelListener; │ │ │ │ - OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener); │ │ │ │ - OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - delay: 300, │ │ │ │ - single: true, │ │ │ │ - double: false, │ │ │ │ - pixelTolerance: 0, │ │ │ │ - dblclickTolerance: 13, │ │ │ │ - stopSingle: false, │ │ │ │ - stopDouble: false, │ │ │ │ - timerId: null, │ │ │ │ - down: null, │ │ │ │ - last: null, │ │ │ │ - first: null, │ │ │ │ - rightclickTimerId: null, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - touchend: function(evt) { │ │ │ │ - if (this.down) { │ │ │ │ - evt.xy = this.last.xy; │ │ │ │ - evt.lastTouches = this.last.touches; │ │ │ │ - this.handleSingle(evt); │ │ │ │ - this.down = null │ │ │ │ - } │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - if (this.checkModifiers(evt) && this.control.handleRightClicks && OpenLayers.Event.isRightClick(evt)) { │ │ │ │ - propagate = this.rightclick(evt) │ │ │ │ - } │ │ │ │ - return propagate │ │ │ │ - }, │ │ │ │ - rightclick: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.callback("dblrightclick", [evt]); │ │ │ │ - return !this.stopDouble │ │ │ │ - } else { │ │ │ │ - var clickEvent = this["double"] ? OpenLayers.Util.extend({}, evt) : this.callback("rightclick", [evt]); │ │ │ │ - var delayedRightCall = OpenLayers.Function.bind(this.delayedRightCall, this, clickEvent); │ │ │ │ - this.rightclickTimerId = window.setTimeout(delayedRightCall, this.delay) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return !this.stopSingle │ │ │ │ - }, │ │ │ │ - delayedRightCall: function(evt) { │ │ │ │ - this.rightclickTimerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback("rightclick", [evt]) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - click: function(evt) { │ │ │ │ - if (!this.last) { │ │ │ │ - this.last = this.getEventInfo(evt) │ │ │ │ - } │ │ │ │ - this.handleSingle(evt); │ │ │ │ - return !this.stopSingle │ │ │ │ - }, │ │ │ │ - dblclick: function(evt) { │ │ │ │ - this.handleDouble(evt); │ │ │ │ - return !this.stopDouble │ │ │ │ - }, │ │ │ │ - handleDouble: function(evt) { │ │ │ │ - if (this.passesDblclickTolerance(evt)) { │ │ │ │ - if (this["double"]) { │ │ │ │ - this.callback("dblclick", [evt]) │ │ │ │ - } │ │ │ │ - this.clearTimer() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - handleSingle: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ - if (this["double"]) { │ │ │ │ - OpenLayers.Event.preventDefault(evt) │ │ │ │ - } │ │ │ │ - this.handleDouble(evt) │ │ │ │ - } │ │ │ │ - if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ - this.clearTimer() │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.first = this.getEventInfo(evt); │ │ │ │ - var clickEvent = this.single ? OpenLayers.Util.extend({}, evt) : null; │ │ │ │ - this.queuePotentialClick(clickEvent) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - queuePotentialClick: function(evt) { │ │ │ │ - this.timerId = window.setTimeout(OpenLayers.Function.bind(this.delayedCall, this, evt), this.delay) │ │ │ │ - }, │ │ │ │ - passesTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ - passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ - if (passes && this.touch && this.down.touches.length === this.last.touches.length) { │ │ │ │ - for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ - if (this.getTouchDistance(this.down.touches[i], this.last.touches[i]) > this.pixelTolerance) { │ │ │ │ - passes = false; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return passes │ │ │ │ - }, │ │ │ │ - getTouchDistance: function(from, to) { │ │ │ │ - return Math.sqrt(Math.pow(from.clientX - to.clientX, 2) + Math.pow(from.clientY - to.clientY, 2)) │ │ │ │ - }, │ │ │ │ - passesDblclickTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.down && this.first) { │ │ │ │ - passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance │ │ │ │ - } │ │ │ │ - return passes │ │ │ │ - }, │ │ │ │ - clearTimer: function() { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null │ │ │ │ - } │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - window.clearTimeout(this.rightclickTimerId); │ │ │ │ - this.rightclickTimerId = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - delayedCall: function(evt) { │ │ │ │ - this.timerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback("click", [evt]) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getEventInfo: function(evt) { │ │ │ │ - var touches; │ │ │ │ - if (evt.touches) { │ │ │ │ - var len = evt.touches.length; │ │ │ │ - touches = new Array(len); │ │ │ │ - var touch; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - touch = evt.touches[i]; │ │ │ │ - touches[i] = { │ │ │ │ - clientX: touch.olClientX, │ │ │ │ - clientY: touch.olClientY │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - xy: evt.xy, │ │ │ │ - touches: touches │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.down = null; │ │ │ │ - this.first = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - dragPan: null, │ │ │ │ - dragPanOptions: null, │ │ │ │ - pinchZoom: null, │ │ │ │ - pinchZoomOptions: null, │ │ │ │ - documentDrag: false, │ │ │ │ - zoomBox: null, │ │ │ │ - zoomBoxEnabled: true, │ │ │ │ - zoomWheelEnabled: true, │ │ │ │ - mouseWheelOptions: null, │ │ │ │ - handleRightClicks: false, │ │ │ │ - zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ - autoActivate: true, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.dragPan) { │ │ │ │ - this.dragPan.destroy() │ │ │ │ - } │ │ │ │ - this.dragPan = null; │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.zoomBox.destroy() │ │ │ │ - } │ │ │ │ - this.zoomBox = null; │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.destroy() │ │ │ │ - } │ │ │ │ - this.pinchZoom = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - this.dragPan.activate(); │ │ │ │ - if (this.zoomWheelEnabled) { │ │ │ │ - this.handlers.wheel.activate() │ │ │ │ - } │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - if (this.zoomBoxEnabled) { │ │ │ │ - this.zoomBox.activate() │ │ │ │ - } │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.activate() │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.deactivate() │ │ │ │ - } │ │ │ │ - this.zoomBox.deactivate(); │ │ │ │ - this.dragPan.deactivate(); │ │ │ │ - this.handlers.click.deactivate(); │ │ │ │ - this.handlers.wheel.deactivate(); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - if (this.handleRightClicks) { │ │ │ │ - this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False │ │ │ │ - } │ │ │ │ - var clickCallbacks = { │ │ │ │ - click: this.defaultClick, │ │ │ │ - dblclick: this.defaultDblClick, │ │ │ │ - dblrightclick: this.defaultDblRightClick │ │ │ │ - }; │ │ │ │ - var clickOptions = { │ │ │ │ - double: true, │ │ │ │ - stopDouble: true │ │ │ │ - }; │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks, clickOptions); │ │ │ │ - this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend({ │ │ │ │ - map: this.map, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }, this.dragPanOptions)); │ │ │ │ - this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ - map: this.map, │ │ │ │ - keyMask: this.zoomBoxKeyMask │ │ │ │ - }); │ │ │ │ - this.dragPan.draw(); │ │ │ │ - this.zoomBox.draw(); │ │ │ │ - var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ - cumulative: false, │ │ │ │ - interval: 50, │ │ │ │ - maxDelta: 6 │ │ │ │ - }; │ │ │ │ - this.handlers.wheel = new OpenLayers.Handler.MouseWheel(this, { │ │ │ │ - up: this.wheelUp, │ │ │ │ - down: this.wheelDown │ │ │ │ - }, OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions)); │ │ │ │ - if (OpenLayers.Control.PinchZoom) { │ │ │ │ - this.pinchZoom = new OpenLayers.Control.PinchZoom(OpenLayers.Util.extend({ │ │ │ │ - map: this.map │ │ │ │ - }, this.pinchZoomOptions)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - defaultClick: function(evt) { │ │ │ │ - if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ - this.map.zoomOut() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - defaultDblClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom + 1, evt.xy) │ │ │ │ - }, │ │ │ │ - defaultDblRightClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom - 1, evt.xy) │ │ │ │ - }, │ │ │ │ - wheelChange: function(evt, deltaZ) { │ │ │ │ - if (!this.map.fractionalZoom) { │ │ │ │ - deltaZ = Math.round(deltaZ) │ │ │ │ - } │ │ │ │ - var currentZoom = this.map.getZoom(), │ │ │ │ - newZoom = currentZoom + deltaZ; │ │ │ │ - newZoom = Math.max(newZoom, 0); │ │ │ │ - newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ - if (newZoom === currentZoom) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - this.map.zoomTo(newZoom, evt.xy) │ │ │ │ - }, │ │ │ │ - wheelUp: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || 1) │ │ │ │ - }, │ │ │ │ - wheelDown: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || -1) │ │ │ │ - }, │ │ │ │ - disableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = false; │ │ │ │ - this.zoomBox.deactivate() │ │ │ │ - }, │ │ │ │ - enableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.zoomBox.activate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - disableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = false; │ │ │ │ - this.handlers.wheel.deactivate() │ │ │ │ - }, │ │ │ │ - enableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.wheel.activate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - EVENTMAP: { │ │ │ │ - click: { │ │ │ │ - in: "click", │ │ │ │ - out: "clickout" │ │ │ │ - }, │ │ │ │ - mousemove: { │ │ │ │ - in: "over", │ │ │ │ - out: "out" │ │ │ │ - }, │ │ │ │ - dblclick: { │ │ │ │ - in: "dblclick", │ │ │ │ - out: null │ │ │ │ - }, │ │ │ │ - mousedown: { │ │ │ │ - in: null, │ │ │ │ - out: null │ │ │ │ - }, │ │ │ │ - mouseup: { │ │ │ │ - in: null, │ │ │ │ - out: null │ │ │ │ - }, │ │ │ │ - touchstart: { │ │ │ │ - in: "click", │ │ │ │ - out: "clickout" │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - feature: null, │ │ │ │ - lastFeature: null, │ │ │ │ - down: null, │ │ │ │ - up: null, │ │ │ │ - clickTolerance: 4, │ │ │ │ - geometryTypes: null, │ │ │ │ - stopClick: true, │ │ │ │ - stopDown: true, │ │ │ │ - stopUp: false, │ │ │ │ - initialize: function(control, layer, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ - this.layer = layer │ │ │ │ - }, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return OpenLayers.Event.isMultiTouch(evt) ? true : this.mousedown(evt) │ │ │ │ - }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - OpenLayers.Event.preventDefault(evt) │ │ │ │ - }, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ - this.down = evt.xy │ │ │ │ - } │ │ │ │ - return this.handle(evt) ? !this.stopDown : true │ │ │ │ - }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - this.up = evt.xy; │ │ │ │ - return this.handle(evt) ? !this.stopUp : true │ │ │ │ - }, │ │ │ │ - click: function(evt) { │ │ │ │ - return this.handle(evt) ? !this.stopClick : true │ │ │ │ - }, │ │ │ │ - mousemove: function(evt) { │ │ │ │ - if (!this.callbacks["over"] && !this.callbacks["out"]) { │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - this.handle(evt); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - dblclick: function(evt) { │ │ │ │ - return !this.handle(evt) │ │ │ │ - }, │ │ │ │ - geometryTypeMatches: function(feature) { │ │ │ │ - return this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1 │ │ │ │ - }, │ │ │ │ - handle: function(evt) { │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - this.feature = null │ │ │ │ - } │ │ │ │ - var type = evt.type; │ │ │ │ - var handled = false; │ │ │ │ - var previouslyIn = !!this.feature; │ │ │ │ - var click = type == "click" || type == "dblclick" || type == "touchstart"; │ │ │ │ - this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - this.feature = null │ │ │ │ - } │ │ │ │ - if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ - this.lastFeature = null │ │ │ │ - } │ │ │ │ - if (this.feature) { │ │ │ │ - if (type === "touchstart") { │ │ │ │ - OpenLayers.Event.preventDefault(evt) │ │ │ │ - } │ │ │ │ - var inNew = this.feature != this.lastFeature; │ │ │ │ - if (this.geometryTypeMatches(this.feature)) { │ │ │ │ - if (previouslyIn && inNew) { │ │ │ │ - if (this.lastFeature) { │ │ │ │ - this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ - } │ │ │ │ - this.triggerCallback(type, "in", [this.feature]) │ │ │ │ - } else if (!previouslyIn || click) { │ │ │ │ - this.triggerCallback(type, "in", [this.feature]) │ │ │ │ - } │ │ │ │ - this.lastFeature = this.feature; │ │ │ │ - handled = true │ │ │ │ - } else { │ │ │ │ - if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ - this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ - } │ │ │ │ - this.feature = null │ │ │ │ - } │ │ │ │ - } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ - this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ - } │ │ │ │ - return handled │ │ │ │ - }, │ │ │ │ - triggerCallback: function(type, mode, args) { │ │ │ │ - var key = this.EVENTMAP[type][mode]; │ │ │ │ - if (key) { │ │ │ │ - if (type == "click" && this.up && this.down) { │ │ │ │ - var dpx = Math.sqrt(Math.pow(this.up.x - this.down.x, 2) + Math.pow(this.up.y - this.down.y, 2)); │ │ │ │ - if (dpx <= this.clickTolerance) { │ │ │ │ - this.callback(key, args) │ │ │ │ - } │ │ │ │ - this.up = this.down = null │ │ │ │ - } else { │ │ │ │ - this.callback(key, args) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - this.map.events.on({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - activated = true │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.moveLayerBack(); │ │ │ │ - this.feature = null; │ │ │ │ - this.lastFeature = null; │ │ │ │ - this.down = null; │ │ │ │ - this.up = null; │ │ │ │ - this.map.events.un({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - deactivated = true │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - handleMapEvents: function(evt) { │ │ │ │ - if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ - this.moveLayerToTop() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - moveLayerToTop: function() { │ │ │ │ - var index = Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) + 1; │ │ │ │ - this.layer.setZIndex(index) │ │ │ │ - }, │ │ │ │ - moveLayerBack: function() { │ │ │ │ - var index = this.layer.getZIndex() - 1; │ │ │ │ - if (index >= this.map.Z_INDEX_BASE["Feature"]) { │ │ │ │ - this.layer.setZIndex(index) │ │ │ │ - } else { │ │ │ │ - this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - layers: null, │ │ │ │ - display: function() {}, │ │ │ │ - getFeatureFromEvent: function(evt) { │ │ │ │ - var layers = this.layers; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0; i < layers.length; i++) { │ │ │ │ - feature = layers[i].getFeatureFromEvent(evt); │ │ │ │ - if (feature) { │ │ │ │ - return feature │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ - this.collectRoots(); │ │ │ │ - map.events.register("changelayer", this, this.handleChangeLayer) │ │ │ │ - }, │ │ │ │ - removeMap: function(map) { │ │ │ │ - map.events.unregister("changelayer", this, this.handleChangeLayer); │ │ │ │ - this.resetRoots(); │ │ │ │ - OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - collectRoots: function() { │ │ │ │ - var layer; │ │ │ │ - for (var i = 0; i < this.map.layers.length; ++i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ - layer.renderer.moveRoot(this.renderer) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - resetRoots: function() { │ │ │ │ - var layer; │ │ │ │ - for (var i = 0; i < this.layers.length; ++i) { │ │ │ │ - layer = this.layers[i]; │ │ │ │ - if (this.renderer && layer.renderer.getRenderLayerId() == this.id) { │ │ │ │ - this.renderer.moveRoot(layer.renderer) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - handleChangeLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (evt.property == "order" && OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ - this.resetRoots(); │ │ │ │ - this.collectRoots() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - multipleKey: null, │ │ │ │ - toggleKey: null, │ │ │ │ - multiple: false, │ │ │ │ - clickout: true, │ │ │ │ - toggle: false, │ │ │ │ - hover: false, │ │ │ │ - highlightOnly: false, │ │ │ │ - box: false, │ │ │ │ - onBeforeSelect: function() {}, │ │ │ │ - onSelect: function() {}, │ │ │ │ - onUnselect: function() {}, │ │ │ │ - scope: null, │ │ │ │ - geometryTypes: null, │ │ │ │ - layer: null, │ │ │ │ - layers: null, │ │ │ │ - callbacks: null, │ │ │ │ - selectStyle: null, │ │ │ │ - renderIntent: "select", │ │ │ │ - handlers: null, │ │ │ │ - initialize: function(layers, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (this.scope === null) { │ │ │ │ - this.scope = this │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - var callbacks = { │ │ │ │ - click: this.clickFeature, │ │ │ │ - clickout: this.clickoutFeature │ │ │ │ - }; │ │ │ │ - if (this.hover) { │ │ │ │ - callbacks.over = this.overFeature; │ │ │ │ - callbacks.out = this.outFeature │ │ │ │ - } │ │ │ │ - this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ - this.handlers = { │ │ │ │ - feature: new OpenLayers.Handler.Feature(this, this.layer, this.callbacks, { │ │ │ │ - geometryTypes: this.geometryTypes │ │ │ │ - }) │ │ │ │ - }; │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.selectBox │ │ │ │ - }, { │ │ │ │ - boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - initLayer: function(layers) { │ │ │ │ - if (OpenLayers.Util.isArray(layers)) { │ │ │ │ - this.layers = layers; │ │ │ │ - this.layer = new OpenLayers.Layer.Vector.RootContainer(this.id + "_container", { │ │ │ │ - layers: layers │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - this.layer = layers │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active && this.layers) { │ │ │ │ - this.map.removeLayer(this.layer) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.addLayer(this.layer) │ │ │ │ - } │ │ │ │ - this.handlers.feature.activate(); │ │ │ │ - if (this.box && this.handlers.box) { │ │ │ │ - this.handlers.box.activate() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.feature.deactivate(); │ │ │ │ - if (this.handlers.box) { │ │ │ │ - this.handlers.box.deactivate() │ │ │ │ - } │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.removeLayer(this.layer) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - unselectAll: function(options) { │ │ │ │ - var layers = this.layers || [this.layer], │ │ │ │ - layer, feature, l, numExcept; │ │ │ │ - for (l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - numExcept = 0; │ │ │ │ - if (layer.selectedFeatures != null) { │ │ │ │ - while (layer.selectedFeatures.length > numExcept) { │ │ │ │ - feature = layer.selectedFeatures[numExcept]; │ │ │ │ - if (!options || options.except != feature) { │ │ │ │ - this.unselect(feature) │ │ │ │ - } else { │ │ │ │ - ++numExcept │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clickFeature: function(feature) { │ │ │ │ - if (!this.hover) { │ │ │ │ - var selected = OpenLayers.Util.indexOf(feature.layer.selectedFeatures, feature) > -1; │ │ │ │ - if (selected) { │ │ │ │ - if (this.toggleSelect()) { │ │ │ │ - this.unselect(feature) │ │ │ │ - } else if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.select(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - multipleSelect: function() { │ │ │ │ - return this.multiple || this.handlers.feature.evt && this.handlers.feature.evt[this.multipleKey] │ │ │ │ - }, │ │ │ │ - toggleSelect: function() { │ │ │ │ - return this.toggle || this.handlers.feature.evt && this.handlers.feature.evt[this.toggleKey] │ │ │ │ - }, │ │ │ │ - clickoutFeature: function(feature) { │ │ │ │ - if (!this.hover && this.clickout) { │ │ │ │ - this.unselectAll() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - overFeature: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - this.highlight(feature) │ │ │ │ - } else if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - outFeature: function(feature) { │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - if (feature._lastHighlighter == this.id) { │ │ │ │ - if (feature._prevHighlighter && feature._prevHighlighter != this.id) { │ │ │ │ - delete feature._lastHighlighter; │ │ │ │ - var control = this.map.getControl(feature._prevHighlighter); │ │ │ │ - if (control) { │ │ │ │ - control.highlight(feature) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unhighlight(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unselect(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - highlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ - feature._lastHighlighter = this.id; │ │ │ │ - var style = this.selectStyle || this.renderIntent; │ │ │ │ - layer.drawFeature(feature, style); │ │ │ │ - this.events.triggerEvent("featurehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - unhighlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (feature._prevHighlighter == undefined) { │ │ │ │ - delete feature._lastHighlighter │ │ │ │ - } else if (feature._prevHighlighter == this.id) { │ │ │ │ - delete feature._prevHighlighter │ │ │ │ - } else { │ │ │ │ - feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ - delete feature._prevHighlighter │ │ │ │ - } │ │ │ │ - layer.drawFeature(feature, feature.style || feature.layer.style || "default"); │ │ │ │ - this.events.triggerEvent("featureunhighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - select: function(feature) { │ │ │ │ - var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (cont !== false) { │ │ │ │ - cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - layer.selectedFeatures.push(feature); │ │ │ │ - this.highlight(feature); │ │ │ │ - if (!this.handlers.feature.lastFeature) { │ │ │ │ - this.handlers.feature.lastFeature = layer.selectedFeatures[0] │ │ │ │ - } │ │ │ │ - layer.events.triggerEvent("featureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onSelect.call(this.scope, feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - unselect: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - this.unhighlight(feature); │ │ │ │ - OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ - layer.events.triggerEvent("featureunselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onUnselect.call(this.scope, feature) │ │ │ │ - }, │ │ │ │ - selectBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - var bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat); │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll() │ │ │ │ - } │ │ │ │ - var prevMultiple = this.multiple; │ │ │ │ - this.multiple = true; │ │ │ │ - var layers = this.layers || [this.layer]; │ │ │ │ - this.events.triggerEvent("boxselectionstart", { │ │ │ │ - layers: layers │ │ │ │ - }); │ │ │ │ - var layer; │ │ │ │ - for (var l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ - var feature = layer.features[i]; │ │ │ │ - if (!feature.getVisibility()) { │ │ │ │ - continue │ │ │ │ - } │ │ │ │ - if (this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ - if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ - if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.multiple = prevMultiple; │ │ │ │ - this.events.triggerEvent("boxselectionend", { │ │ │ │ - layers: layers │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.feature.setMap(map); │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box.setMap(map) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - setLayer: function(layers) { │ │ │ │ - var isActive = this.active; │ │ │ │ - this.unselectAll(); │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy(); │ │ │ │ - this.layers = null │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - this.handlers.feature.layer = this.layer; │ │ │ │ - if (isActive) { │ │ │ │ - this.activate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ - layer: null, │ │ │ │ - options: null, │ │ │ │ - active: null, │ │ │ │ - autoActivate: true, │ │ │ │ - autoDestroy: true, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options; │ │ │ │ - this.active = false │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layer = null; │ │ │ │ - this.options = null │ │ │ │ - }, │ │ │ │ - setLayer: function(layer) { │ │ │ │ - this.layer = layer │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - this.active = true; │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.active = false; │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ -}); │ │ │ │ -OpenLayers.Filter = OpenLayers.Class({ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options) │ │ │ │ - }, │ │ │ │ - destroy: function() {}, │ │ │ │ - evaluate: function(context) { │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - return null │ │ │ │ - }, │ │ │ │ - toString: function() { │ │ │ │ - var string; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.CQL) { │ │ │ │ - string = OpenLayers.Format.CQL.prototype.write(this) │ │ │ │ - } else { │ │ │ │ - string = Object.prototype.toString.call(this) │ │ │ │ - } │ │ │ │ - return string │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Filter" │ │ │ │ -}); │ │ │ │ -OpenLayers.Filter.Spatial = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ - type: null, │ │ │ │ - property: null, │ │ │ │ - value: null, │ │ │ │ - distance: null, │ │ │ │ - distanceUnits: null, │ │ │ │ - evaluate: function(feature) { │ │ │ │ - var intersect = false; │ │ │ │ - switch (this.type) { │ │ │ │ - case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ - case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ - if (feature.geometry) { │ │ │ │ - var geom = this.value; │ │ │ │ - if (this.value.CLASS_NAME == "OpenLayers.Bounds") { │ │ │ │ - geom = this.value.toGeometry() │ │ │ │ - } │ │ │ │ - if (feature.geometry.intersects(geom)) { │ │ │ │ - intersect = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - throw new Error("evaluate is not implemented for this filter type.") │ │ │ │ - } │ │ │ │ - return intersect │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.applyDefaults({ │ │ │ │ - value: this.value && this.value.clone && this.value.clone() │ │ │ │ - }, this); │ │ │ │ - return new OpenLayers.Filter.Spatial(options) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Filter.Spatial" │ │ │ │ -}); │ │ │ │ -OpenLayers.Filter.Spatial.BBOX = "BBOX"; │ │ │ │ -OpenLayers.Filter.Spatial.INTERSECTS = "INTERSECTS"; │ │ │ │ -OpenLayers.Filter.Spatial.DWITHIN = "DWITHIN"; │ │ │ │ -OpenLayers.Filter.Spatial.WITHIN = "WITHIN"; │ │ │ │ -OpenLayers.Filter.Spatial.CONTAINS = "CONTAINS"; │ │ │ │ -OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - bounds: null, │ │ │ │ - resolution: null, │ │ │ │ - ratio: 2, │ │ │ │ - resFactor: null, │ │ │ │ - response: null, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - moveend: this.update, │ │ │ │ - refresh: this.update, │ │ │ │ - visibilitychanged: this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.update() │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - moveend: this.update, │ │ │ │ - refresh: this.update, │ │ │ │ - visibilitychanged: this.update, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - update: function(options) { │ │ │ │ - var mapBounds = this.getMapBounds(); │ │ │ │ - if (mapBounds !== null && (options && options.force || this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds))) { │ │ │ │ - this.calculateBounds(mapBounds); │ │ │ │ - this.resolution = this.layer.map.getResolution(); │ │ │ │ - this.triggerRead(options) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getMapBounds: function() { │ │ │ │ - if (this.layer.map === null) { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ - var bounds = this.layer.map.getExtent(); │ │ │ │ - if (bounds && !this.layer.projection.equals(this.layer.map.getProjectionObject())) { │ │ │ │ - bounds = bounds.clone().transform(this.layer.map.getProjectionObject(), this.layer.projection) │ │ │ │ - } │ │ │ │ - return bounds │ │ │ │ - }, │ │ │ │ - invalidBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds() │ │ │ │ - } │ │ │ │ - var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ - if (!invalid && this.resFactor) { │ │ │ │ - var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ - invalid = ratio >= this.resFactor || ratio <= 1 / this.resFactor │ │ │ │ - } │ │ │ │ - return invalid │ │ │ │ - }, │ │ │ │ - calculateBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds() │ │ │ │ - } │ │ │ │ - var center = mapBounds.getCenterLonLat(); │ │ │ │ - var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ - var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ - this.bounds = new OpenLayers.Bounds(center.lon - dataWidth / 2, center.lat - dataHeight / 2, center.lon + dataWidth / 2, center.lat + dataHeight / 2) │ │ │ │ - }, │ │ │ │ - triggerRead: function(options) { │ │ │ │ - if (this.response && !(options && options.noAbort === true)) { │ │ │ │ - this.layer.protocol.abort(this.response); │ │ │ │ - this.layer.events.triggerEvent("loadend") │ │ │ │ - } │ │ │ │ - var evt = { │ │ │ │ - filter: this.createFilter() │ │ │ │ - }; │ │ │ │ - this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ - this.response = this.layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ - filter: evt.filter, │ │ │ │ - callback: this.merge, │ │ │ │ - scope: this │ │ │ │ - }, options)) │ │ │ │ - }, │ │ │ │ - createFilter: function() { │ │ │ │ - var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - value: this.bounds, │ │ │ │ - projection: this.layer.projection │ │ │ │ - }); │ │ │ │ - if (this.layer.filter) { │ │ │ │ - filter = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.layer.filter, filter] │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return filter │ │ │ │ - }, │ │ │ │ - merge: function(resp) { │ │ │ │ - this.layer.destroyFeatures(); │ │ │ │ - if (resp.success()) { │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = this.layer.projection; │ │ │ │ - var local = this.layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.layer.addFeatures(features) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.bounds = null │ │ │ │ - } │ │ │ │ - this.response = null; │ │ │ │ - this.layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - preload: false, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - refresh: this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (this.layer.visibility == true || this.preload) { │ │ │ │ - this.load() │ │ │ │ - } else { │ │ │ │ - this.layer.events.on({ │ │ │ │ - visibilitychanged: this.load, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - refresh: this.load, │ │ │ │ - visibilitychanged: this.load, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - load: function(options) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.events.triggerEvent("loadstart", { │ │ │ │ - filter: layer.filter │ │ │ │ - }); │ │ │ │ - layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: this.merge, │ │ │ │ - filter: layer.filter, │ │ │ │ - scope: this │ │ │ │ - }, options)); │ │ │ │ - layer.events.un({ │ │ │ │ - visibilitychanged: this.load, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - merge: function(resp) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.destroyFeatures(); │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = layer.projection; │ │ │ │ - var local = layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - layer.addFeatures(features) │ │ │ │ - } │ │ │ │ - layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ -}); │ │ │ │ -OpenLayers.ElementsIndexer = OpenLayers.Class({ │ │ │ │ - maxZIndex: null, │ │ │ │ - order: null, │ │ │ │ - indices: null, │ │ │ │ - compare: null, │ │ │ │ - initialize: function(yOrdering) { │ │ │ │ - this.compare = yOrdering ? OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER : OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER; │ │ │ │ - this.clear() │ │ │ │ - }, │ │ │ │ - insert: function(newNode) { │ │ │ │ - if (this.exists(newNode)) { │ │ │ │ - this.remove(newNode) │ │ │ │ - } │ │ │ │ - var nodeId = newNode.id; │ │ │ │ - this.determineZIndex(newNode); │ │ │ │ - var leftIndex = -1; │ │ │ │ - var rightIndex = this.order.length; │ │ │ │ - var middle; │ │ │ │ - while (rightIndex - leftIndex > 1) { │ │ │ │ - middle = parseInt((leftIndex + rightIndex) / 2); │ │ │ │ - var placement = this.compare(this, newNode, OpenLayers.Util.getElement(this.order[middle])); │ │ │ │ - if (placement > 0) { │ │ │ │ - leftIndex = middle │ │ │ │ - } else { │ │ │ │ - rightIndex = middle │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.order.splice(rightIndex, 0, nodeId); │ │ │ │ - this.indices[nodeId] = this.getZIndex(newNode); │ │ │ │ - return this.getNextElement(rightIndex) │ │ │ │ - }, │ │ │ │ - remove: function(node) { │ │ │ │ - var nodeId = node.id; │ │ │ │ - var arrayIndex = OpenLayers.Util.indexOf(this.order, nodeId); │ │ │ │ - if (arrayIndex >= 0) { │ │ │ │ - this.order.splice(arrayIndex, 1); │ │ │ │ - delete this.indices[nodeId]; │ │ │ │ - if (this.order.length > 0) { │ │ │ │ - var lastId = this.order[this.order.length - 1]; │ │ │ │ - this.maxZIndex = this.indices[lastId] │ │ │ │ - } else { │ │ │ │ - this.maxZIndex = 0 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clear: function() { │ │ │ │ - this.order = []; │ │ │ │ - this.indices = {}; │ │ │ │ - this.maxZIndex = 0 │ │ │ │ - }, │ │ │ │ - exists: function(node) { │ │ │ │ - return this.indices[node.id] != null │ │ │ │ - }, │ │ │ │ - getZIndex: function(node) { │ │ │ │ - return node._style.graphicZIndex │ │ │ │ - }, │ │ │ │ - determineZIndex: function(node) { │ │ │ │ - var zIndex = node._style.graphicZIndex; │ │ │ │ - if (zIndex == null) { │ │ │ │ - zIndex = this.maxZIndex; │ │ │ │ - node._style.graphicZIndex = zIndex │ │ │ │ - } else if (zIndex > this.maxZIndex) { │ │ │ │ - this.maxZIndex = zIndex │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getNextElement: function(index) { │ │ │ │ - var nextIndex = index + 1; │ │ │ │ - if (nextIndex < this.order.length) { │ │ │ │ - var nextElement = OpenLayers.Util.getElement(this.order[nextIndex]); │ │ │ │ - if (nextElement == undefined) { │ │ │ │ - nextElement = this.getNextElement(nextIndex) │ │ │ │ - } │ │ │ │ - return nextElement │ │ │ │ - } else { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.ElementsIndexer" │ │ │ │ -}); │ │ │ │ -OpenLayers.ElementsIndexer.IndexingMethods = { │ │ │ │ - Z_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ - var newZIndex = indexer.getZIndex(newNode); │ │ │ │ - var returnVal = 0; │ │ │ │ - if (nextNode) { │ │ │ │ - var nextZIndex = indexer.getZIndex(nextNode); │ │ │ │ - returnVal = newZIndex - nextZIndex │ │ │ │ - } │ │ │ │ - return returnVal │ │ │ │ - }, │ │ │ │ - Z_ORDER_DRAWING_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ - var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ - if (nextNode && returnVal == 0) { │ │ │ │ - returnVal = 1 │ │ │ │ - } │ │ │ │ - return returnVal │ │ │ │ - }, │ │ │ │ - Z_ORDER_Y_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ - var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ - if (nextNode && returnVal === 0) { │ │ │ │ - var result = nextNode._boundsBottom - newNode._boundsBottom; │ │ │ │ - returnVal = result === 0 ? 1 : result │ │ │ │ - } │ │ │ │ - return returnVal │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, { │ │ │ │ - rendererRoot: null, │ │ │ │ - root: null, │ │ │ │ - vectorRoot: null, │ │ │ │ - textRoot: null, │ │ │ │ - xmlns: null, │ │ │ │ - xOffset: 0, │ │ │ │ - indexer: null, │ │ │ │ - BACKGROUND_ID_SUFFIX: "_background", │ │ │ │ - LABEL_ID_SUFFIX: "_label", │ │ │ │ - LABEL_OUTLINE_SUFFIX: "_outline", │ │ │ │ - initialize: function(containerID, options) { │ │ │ │ - OpenLayers.Renderer.prototype.initialize.apply(this, arguments); │ │ │ │ - this.rendererRoot = this.createRenderRoot(); │ │ │ │ - this.root = this.createRoot("_root"); │ │ │ │ - this.vectorRoot = this.createRoot("_vroot"); │ │ │ │ - this.textRoot = this.createRoot("_troot"); │ │ │ │ - this.root.appendChild(this.vectorRoot); │ │ │ │ - this.root.appendChild(this.textRoot); │ │ │ │ - this.rendererRoot.appendChild(this.root); │ │ │ │ - this.container.appendChild(this.rendererRoot); │ │ │ │ - if (options && (options.zIndexing || options.yOrdering)) { │ │ │ │ - this.indexer = new OpenLayers.ElementsIndexer(options.yOrdering) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.clear(); │ │ │ │ - this.rendererRoot = null; │ │ │ │ - this.root = null; │ │ │ │ - this.xmlns = null; │ │ │ │ - OpenLayers.Renderer.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - clear: function() { │ │ │ │ - var child; │ │ │ │ - var root = this.vectorRoot; │ │ │ │ - if (root) { │ │ │ │ - while (child = root.firstChild) { │ │ │ │ - root.removeChild(child) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - root = this.textRoot; │ │ │ │ - if (root) { │ │ │ │ - while (child = root.firstChild) { │ │ │ │ - root.removeChild(child) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.indexer) { │ │ │ │ - this.indexer.clear() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setExtent: function(extent, resolutionChanged) { │ │ │ │ - var coordSysUnchanged = OpenLayers.Renderer.prototype.setExtent.apply(this, arguments); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) { │ │ │ │ - var rightOfDateLine, ratio = extent.getWidth() / this.map.getExtent().getWidth(), │ │ │ │ - extent = extent.scale(1 / ratio), │ │ │ │ - world = this.map.getMaxExtent(); │ │ │ │ - if (world.right > extent.left && world.right < extent.right) { │ │ │ │ - rightOfDateLine = true │ │ │ │ - } else if (world.left > extent.left && world.left < extent.right) { │ │ │ │ - rightOfDateLine = false │ │ │ │ - } │ │ │ │ - if (rightOfDateLine !== this.rightOfDateLine || resolutionChanged) { │ │ │ │ - coordSysUnchanged = false; │ │ │ │ - this.xOffset = rightOfDateLine === true ? world.getWidth() / resolution : 0 │ │ │ │ - } │ │ │ │ - this.rightOfDateLine = rightOfDateLine │ │ │ │ - } │ │ │ │ - return coordSysUnchanged │ │ │ │ - }, │ │ │ │ - getNodeType: function(geometry, style) {}, │ │ │ │ - drawGeometry: function(geometry, style, featureId) { │ │ │ │ - var className = geometry.CLASS_NAME; │ │ │ │ - var rendered = true; │ │ │ │ - if (className == "OpenLayers.Geometry.Collection" || className == "OpenLayers.Geometry.MultiPoint" || className == "OpenLayers.Geometry.MultiLineString" || className == "OpenLayers.Geometry.MultiPolygon") { │ │ │ │ - for (var i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ - rendered = this.drawGeometry(geometry.components[i], style, featureId) && rendered │ │ │ │ - } │ │ │ │ - return rendered │ │ │ │ - } │ │ │ │ - rendered = false; │ │ │ │ - var removeBackground = false; │ │ │ │ - if (style.display != "none") { │ │ │ │ - if (style.backgroundGraphic) { │ │ │ │ - this.redrawBackgroundNode(geometry.id, geometry, style, featureId) │ │ │ │ - } else { │ │ │ │ - removeBackground = true │ │ │ │ - } │ │ │ │ - rendered = this.redrawNode(geometry.id, geometry, style, featureId) │ │ │ │ - } │ │ │ │ - if (rendered == false) { │ │ │ │ - var node = document.getElementById(geometry.id); │ │ │ │ - if (node) { │ │ │ │ - if (node._style.backgroundGraphic) { │ │ │ │ - removeBackground = true │ │ │ │ - } │ │ │ │ - node.parentNode.removeChild(node) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (removeBackground) { │ │ │ │ - var node = document.getElementById(geometry.id + this.BACKGROUND_ID_SUFFIX); │ │ │ │ - if (node) { │ │ │ │ - node.parentNode.removeChild(node) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return rendered │ │ │ │ - }, │ │ │ │ - redrawNode: function(id, geometry, style, featureId) { │ │ │ │ - style = this.applyDefaultSymbolizer(style); │ │ │ │ - var node = this.nodeFactory(id, this.getNodeType(geometry, style)); │ │ │ │ - node._featureId = featureId; │ │ │ │ - node._boundsBottom = geometry.getBounds().bottom; │ │ │ │ - node._geometryClass = geometry.CLASS_NAME; │ │ │ │ - node._style = style; │ │ │ │ - var drawResult = this.drawGeometryNode(node, geometry, style); │ │ │ │ - if (drawResult === false) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - node = drawResult.node; │ │ │ │ - if (this.indexer) { │ │ │ │ - var insert = this.indexer.insert(node); │ │ │ │ - if (insert) { │ │ │ │ - this.vectorRoot.insertBefore(node, insert) │ │ │ │ - } else { │ │ │ │ - this.vectorRoot.appendChild(node) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (node.parentNode !== this.vectorRoot) { │ │ │ │ - this.vectorRoot.appendChild(node) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.postDraw(node); │ │ │ │ - return drawResult.complete │ │ │ │ - }, │ │ │ │ - redrawBackgroundNode: function(id, geometry, style, featureId) { │ │ │ │ - var backgroundStyle = OpenLayers.Util.extend({}, style); │ │ │ │ - backgroundStyle.externalGraphic = backgroundStyle.backgroundGraphic; │ │ │ │ - backgroundStyle.graphicXOffset = backgroundStyle.backgroundXOffset; │ │ │ │ - backgroundStyle.graphicYOffset = backgroundStyle.backgroundYOffset; │ │ │ │ - backgroundStyle.graphicZIndex = backgroundStyle.backgroundGraphicZIndex; │ │ │ │ - backgroundStyle.graphicWidth = backgroundStyle.backgroundWidth || backgroundStyle.graphicWidth; │ │ │ │ - backgroundStyle.graphicHeight = backgroundStyle.backgroundHeight || backgroundStyle.graphicHeight; │ │ │ │ - backgroundStyle.backgroundGraphic = null; │ │ │ │ - backgroundStyle.backgroundXOffset = null; │ │ │ │ - backgroundStyle.backgroundYOffset = null; │ │ │ │ - backgroundStyle.backgroundGraphicZIndex = null; │ │ │ │ - return this.redrawNode(id + this.BACKGROUND_ID_SUFFIX, geometry, backgroundStyle, null) │ │ │ │ - }, │ │ │ │ - drawGeometryNode: function(node, geometry, style) { │ │ │ │ - style = style || node._style; │ │ │ │ - var options = { │ │ │ │ - isFilled: style.fill === undefined ? true : style.fill, │ │ │ │ - isStroked: style.stroke === undefined ? !!style.strokeWidth : style.stroke │ │ │ │ - }; │ │ │ │ - var drawn; │ │ │ │ - switch (geometry.CLASS_NAME) { │ │ │ │ - case "OpenLayers.Geometry.Point": │ │ │ │ - if (style.graphic === false) { │ │ │ │ - options.isFilled = false; │ │ │ │ - options.isStroked = false │ │ │ │ - } │ │ │ │ - drawn = this.drawPoint(node, geometry); │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LineString": │ │ │ │ - options.isFilled = false; │ │ │ │ - drawn = this.drawLineString(node, geometry); │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LinearRing": │ │ │ │ - drawn = this.drawLinearRing(node, geometry); │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Polygon": │ │ │ │ - drawn = this.drawPolygon(node, geometry); │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Rectangle": │ │ │ │ - drawn = this.drawRectangle(node, geometry); │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - break │ │ │ │ - } │ │ │ │ - node._options = options; │ │ │ │ - if (drawn != false) { │ │ │ │ - return { │ │ │ │ - node: this.setStyle(node, style, options, geometry), │ │ │ │ - complete: drawn │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - postDraw: function(node) {}, │ │ │ │ - drawPoint: function(node, geometry) {}, │ │ │ │ - drawLineString: function(node, geometry) {}, │ │ │ │ - drawLinearRing: function(node, geometry) {}, │ │ │ │ - drawPolygon: function(node, geometry) {}, │ │ │ │ - drawRectangle: function(node, geometry) {}, │ │ │ │ - drawCircle: function(node, geometry) {}, │ │ │ │ - removeText: function(featureId) { │ │ │ │ - var label = document.getElementById(featureId + this.LABEL_ID_SUFFIX); │ │ │ │ - if (label) { │ │ │ │ - this.textRoot.removeChild(label) │ │ │ │ - } │ │ │ │ - var outline = document.getElementById(featureId + this.LABEL_OUTLINE_SUFFIX); │ │ │ │ - if (outline) { │ │ │ │ - this.textRoot.removeChild(outline) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getFeatureIdFromEvent: function(evt) { │ │ │ │ - var target = evt.target; │ │ │ │ - var useElement = target && target.correspondingUseElement; │ │ │ │ - var node = useElement ? useElement : target || evt.srcElement; │ │ │ │ - return node._featureId │ │ │ │ - }, │ │ │ │ - eraseGeometry: function(geometry, featureId) { │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint" || geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString" || geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon" || geometry.CLASS_NAME == "OpenLayers.Geometry.Collection") { │ │ │ │ - for (var i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ - this.eraseGeometry(geometry.components[i], featureId) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - var element = OpenLayers.Util.getElement(geometry.id); │ │ │ │ - if (element && element.parentNode) { │ │ │ │ - if (element.geometry) { │ │ │ │ - element.geometry.destroy(); │ │ │ │ - element.geometry = null │ │ │ │ - } │ │ │ │ - element.parentNode.removeChild(element); │ │ │ │ - if (this.indexer) { │ │ │ │ - this.indexer.remove(element) │ │ │ │ - } │ │ │ │ - if (element._style.backgroundGraphic) { │ │ │ │ - var backgroundId = geometry.id + this.BACKGROUND_ID_SUFFIX; │ │ │ │ - var bElem = OpenLayers.Util.getElement(backgroundId); │ │ │ │ - if (bElem && bElem.parentNode) { │ │ │ │ - bElem.parentNode.removeChild(bElem) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - 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 │ │ │ │ - }, │ │ │ │ - nodeTypeCompare: function(node, type) {}, │ │ │ │ - createNode: function(type, id) {}, │ │ │ │ - moveRoot: function(renderer) { │ │ │ │ - var root = this.root; │ │ │ │ - if (renderer.root.parentNode == this.rendererRoot) { │ │ │ │ - root = renderer.root │ │ │ │ - } │ │ │ │ - root.parentNode.removeChild(root); │ │ │ │ - renderer.rendererRoot.appendChild(root) │ │ │ │ - }, │ │ │ │ - getRenderLayerId: function() { │ │ │ │ - return this.root.parentNode.parentNode.id │ │ │ │ - }, │ │ │ │ - isComplexSymbol: function(graphicName) { │ │ │ │ - return graphicName != "circle" && !!graphicName │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.Elements" │ │ │ │ -}); │ │ │ │ -OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ - xmlns: "http://www.w3.org/2000/svg", │ │ │ │ - xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ - MAX_PIXEL: 15e3, │ │ │ │ - translationParameters: null, │ │ │ │ - symbolMetrics: null, │ │ │ │ - initialize: function(containerID) { │ │ │ │ - if (!this.supported()) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: 0, │ │ │ │ - y: 0 │ │ │ │ - }; │ │ │ │ - this.symbolMetrics = {} │ │ │ │ - }, │ │ │ │ - supported: function() { │ │ │ │ - var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ - return document.implementation && (document.implementation.hasFeature("org.w3c.svg", "1.0") || document.implementation.hasFeature(svgFeature + "SVG", "1.1") || document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1")) │ │ │ │ - }, │ │ │ │ - inValidRange: function(x, y, xyOnly) { │ │ │ │ - var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ - var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ - return left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL │ │ │ │ - }, │ │ │ │ - setExtent: function(extent, resolutionChanged) { │ │ │ │ - var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ - var resolution = this.getResolution(), │ │ │ │ - left = -extent.left / resolution, │ │ │ │ - top = extent.top / resolution; │ │ │ │ - if (resolutionChanged) { │ │ │ │ - this.left = left; │ │ │ │ - this.top = top; │ │ │ │ - var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ - this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ - this.translate(this.xOffset, 0); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ - if (!inRange) { │ │ │ │ - this.setExtent(extent, true) │ │ │ │ - } │ │ │ │ - return coordSysUnchanged && inRange │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - translate: function(x, y) { │ │ │ │ - if (!this.inValidRange(x, y, true)) { │ │ │ │ - return false │ │ │ │ - } else { │ │ │ │ - var transformString = ""; │ │ │ │ - if (x || y) { │ │ │ │ - transformString = "translate(" + x + "," + y + ")" │ │ │ │ - } │ │ │ │ - this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: x, │ │ │ │ - y: y │ │ │ │ - }; │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setSize: function(size) { │ │ │ │ - OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ - this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ - this.rendererRoot.setAttributeNS(null, "height", this.size.h) │ │ │ │ - }, │ │ │ │ - getNodeType: function(geometry, style) { │ │ │ │ - var nodeType = null; │ │ │ │ - switch (geometry.CLASS_NAME) { │ │ │ │ - case "OpenLayers.Geometry.Point": │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - nodeType = "image" │ │ │ │ - } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "svg" │ │ │ │ - } else { │ │ │ │ - nodeType = "circle" │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "rect"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LineString": │ │ │ │ - nodeType = "polyline"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LinearRing": │ │ │ │ - nodeType = "polygon"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Polygon": │ │ │ │ - case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "path"; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - break │ │ │ │ - } │ │ │ │ - return nodeType │ │ │ │ - }, │ │ │ │ - setStyle: function(node, style, options) { │ │ │ │ - style = style || node._style; │ │ │ │ - options = options || node._options; │ │ │ │ - var title = style.title || style.graphicTitle; │ │ │ │ - if (title) { │ │ │ │ - node.setAttributeNS(null, "title", title); │ │ │ │ - var titleNode = node.getElementsByTagName("title"); │ │ │ │ - if (titleNode.length > 0) { │ │ │ │ - titleNode[0].firstChild.textContent = title │ │ │ │ - } else { │ │ │ │ - var label = this.nodeFactory(null, "title"); │ │ │ │ - label.textContent = title; │ │ │ │ - node.appendChild(label) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ - var widthFactor = 1; │ │ │ │ - var pos; │ │ │ │ - if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ - node.style.visibility = ""; │ │ │ │ - if (style.graphic === false) { │ │ │ │ - node.style.visibility = "hidden" │ │ │ │ - } else if (style.externalGraphic) { │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - if (style.graphicWidth && style.graphicHeight) { │ │ │ │ - node.setAttributeNS(null, "preserveAspectRatio", "none") │ │ │ │ - } │ │ │ │ - var width = style.graphicWidth || style.graphicHeight; │ │ │ │ - var height = style.graphicHeight || style.graphicWidth; │ │ │ │ - width = width ? width : style.pointRadius * 2; │ │ │ │ - height = height ? height : style.pointRadius * 2; │ │ │ │ - var xOffset = style.graphicXOffset != undefined ? style.graphicXOffset : -(.5 * width); │ │ │ │ - var yOffset = style.graphicYOffset != undefined ? style.graphicYOffset : -(.5 * height); │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ - node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "width", width); │ │ │ │ - node.setAttributeNS(null, "height", height); │ │ │ │ - node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ - node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ - node.onclick = OpenLayers.Event.preventDefault │ │ │ │ - } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - var offset = style.pointRadius * 3; │ │ │ │ - var size = offset * 2; │ │ │ │ - var src = this.importSymbol(style.graphicName); │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ - var parent = node.parentNode; │ │ │ │ - var nextSibling = node.nextSibling; │ │ │ │ - if (parent) { │ │ │ │ - parent.removeChild(node) │ │ │ │ - } │ │ │ │ - node.firstChild && node.removeChild(node.firstChild); │ │ │ │ - node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ - node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ - node.setAttributeNS(null, "width", size); │ │ │ │ - node.setAttributeNS(null, "height", size); │ │ │ │ - node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ - node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ - if (nextSibling) { │ │ │ │ - parent.insertBefore(node, nextSibling) │ │ │ │ - } else if (parent) { │ │ │ │ - parent.appendChild(node) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "r", style.pointRadius) │ │ │ │ - } │ │ │ │ - var rotation = style.rotation; │ │ │ │ - if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - rotation |= 0; │ │ │ │ - if (node.nodeName !== "svg") { │ │ │ │ - node.setAttributeNS(null, "transform", "rotate(" + rotation + " " + pos.x + " " + pos.y + ")") │ │ │ │ - } else { │ │ │ │ - var metrics = this.symbolMetrics[src.id]; │ │ │ │ - node.firstChild.setAttributeNS(null, "transform", "rotate(" + rotation + " " + metrics[1] + " " + metrics[2] + ")") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (options.isFilled) { │ │ │ │ - node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ - node.setAttributeNS(null, "fill-opacity", style.fillOpacity) │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "fill", "none") │ │ │ │ - } │ │ │ │ - if (options.isStroked) { │ │ │ │ - node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ - node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ - node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ - node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ - node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ - style.strokeDashstyle && node.setAttributeNS(null, "stroke-dasharray", this.dashStyle(style, widthFactor)) │ │ │ │ - } else { │ │ │ │ - node.setAttributeNS(null, "stroke", "none") │ │ │ │ - } │ │ │ │ - if (style.pointerEvents) { │ │ │ │ - node.setAttributeNS(null, "pointer-events", style.pointerEvents) │ │ │ │ - } │ │ │ │ - if (style.cursor != null) { │ │ │ │ - node.setAttributeNS(null, "cursor", style.cursor) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - dashStyle: function(style, widthFactor) { │ │ │ │ - var w = style.strokeWidth * widthFactor; │ │ │ │ - var str = style.strokeDashstyle; │ │ │ │ - switch (str) { │ │ │ │ - case "solid": │ │ │ │ - return "none"; │ │ │ │ - case "dot": │ │ │ │ - return [1, 4 * w].join(); │ │ │ │ - case "dash": │ │ │ │ - return [4 * w, 4 * w].join(); │ │ │ │ - case "dashdot": │ │ │ │ - return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ - case "longdash": │ │ │ │ - return [8 * w, 4 * w].join(); │ │ │ │ - case "longdashdot": │ │ │ │ - return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ - default: │ │ │ │ - return OpenLayers.String.trim(str).replace(/\s+/g, ",") │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - createNode: function(type, id) { │ │ │ │ - var node = document.createElementNS(this.xmlns, type); │ │ │ │ - if (id) { │ │ │ │ - node.setAttributeNS(null, "id", id) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - nodeTypeCompare: function(node, type) { │ │ │ │ - return type == node.nodeName │ │ │ │ - }, │ │ │ │ - createRenderRoot: function() { │ │ │ │ - var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ - svg.style.display = "block"; │ │ │ │ - return svg │ │ │ │ - }, │ │ │ │ - createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "g") │ │ │ │ - }, │ │ │ │ - createDefs: function() { │ │ │ │ - var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ - this.rendererRoot.appendChild(defs); │ │ │ │ - return defs │ │ │ │ - }, │ │ │ │ - drawPoint: function(node, geometry) { │ │ │ │ - return this.drawCircle(node, geometry, 1) │ │ │ │ - }, │ │ │ │ - drawCircle: function(node, geometry, radius) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = this.top - geometry.y / resolution; │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "cx", x); │ │ │ │ - node.setAttributeNS(null, "cy", y); │ │ │ │ - node.setAttributeNS(null, "r", radius); │ │ │ │ - return node │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - drawLineString: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return componentsResult.complete ? node : null │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - drawLinearRing: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return componentsResult.complete ? node : null │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - drawPolygon: function(node, geometry) { │ │ │ │ - var d = ""; │ │ │ │ - var draw = true; │ │ │ │ - var complete = true; │ │ │ │ - var linearRingResult, path; │ │ │ │ - for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ - d += " M"; │ │ │ │ - linearRingResult = this.getComponentsString(geometry.components[j].components, " "); │ │ │ │ - path = linearRingResult.path; │ │ │ │ - if (path) { │ │ │ │ - d += " " + path; │ │ │ │ - complete = linearRingResult.complete && complete │ │ │ │ - } else { │ │ │ │ - draw = false │ │ │ │ - } │ │ │ │ - } │ │ │ │ - d += " z"; │ │ │ │ - if (draw) { │ │ │ │ - node.setAttributeNS(null, "d", d); │ │ │ │ - node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ - return complete ? node : null │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - drawRectangle: function(node, geometry) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = this.top - geometry.y / resolution; │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "x", x); │ │ │ │ - node.setAttributeNS(null, "y", y); │ │ │ │ - node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ - node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ - return node │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - drawText: function(featureId, style, location) { │ │ │ │ - var drawOutline = !!style.labelOutlineWidth; │ │ │ │ - if (drawOutline) { │ │ │ │ - var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ - outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ - if (style.labelOutlineOpacity) { │ │ │ │ - outlineStyle.fontOpacity = style.labelOutlineOpacity │ │ │ │ - } │ │ │ │ - delete outlineStyle.labelOutlineWidth; │ │ │ │ - this.drawText(featureId, outlineStyle, location) │ │ │ │ - } │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = (location.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = location.y / resolution - this.top; │ │ │ │ - var suffix = drawOutline ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ - var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ - label.setAttributeNS(null, "x", x); │ │ │ │ - label.setAttributeNS(null, "y", -y); │ │ │ │ - if (style.fontColor) { │ │ │ │ - label.setAttributeNS(null, "fill", style.fontColor) │ │ │ │ - } │ │ │ │ - if (style.fontStrokeColor) { │ │ │ │ - label.setAttributeNS(null, "stroke", style.fontStrokeColor) │ │ │ │ - } │ │ │ │ - if (style.fontStrokeWidth) { │ │ │ │ - label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth) │ │ │ │ - } │ │ │ │ - if (style.fontOpacity) { │ │ │ │ - label.setAttributeNS(null, "opacity", style.fontOpacity) │ │ │ │ - } │ │ │ │ - if (style.fontFamily) { │ │ │ │ - label.setAttributeNS(null, "font-family", style.fontFamily) │ │ │ │ - } │ │ │ │ - if (style.fontSize) { │ │ │ │ - label.setAttributeNS(null, "font-size", style.fontSize) │ │ │ │ - } │ │ │ │ - if (style.fontWeight) { │ │ │ │ - label.setAttributeNS(null, "font-weight", style.fontWeight) │ │ │ │ - } │ │ │ │ - if (style.fontStyle) { │ │ │ │ - label.setAttributeNS(null, "font-style", style.fontStyle) │ │ │ │ - } │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ - label._featureId = featureId │ │ │ │ - } else { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "none") │ │ │ │ - } │ │ │ │ - var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ - label.setAttributeNS(null, "text-anchor", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ - if (OpenLayers.IS_GECKO === true) { │ │ │ │ - label.setAttributeNS(null, "dominant-baseline", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central") │ │ │ │ - } │ │ │ │ - var labelRows = style.label.split("\n"); │ │ │ │ - var numRows = labelRows.length; │ │ │ │ - while (label.childNodes.length > numRows) { │ │ │ │ - label.removeChild(label.lastChild) │ │ │ │ - } │ │ │ │ - for (var i = 0; i < numRows; i++) { │ │ │ │ - var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - tspan._featureId = featureId; │ │ │ │ - tspan._geometry = location; │ │ │ │ - tspan._geometryClass = location.CLASS_NAME │ │ │ │ - } │ │ │ │ - if (OpenLayers.IS_GECKO === false) { │ │ │ │ - tspan.setAttributeNS(null, "baseline-shift", OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%") │ │ │ │ - } │ │ │ │ - tspan.setAttribute("x", x); │ │ │ │ - if (i == 0) { │ │ │ │ - var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ - if (vfactor == null) { │ │ │ │ - vfactor = -.5 │ │ │ │ - } │ │ │ │ - tspan.setAttribute("dy", vfactor * (numRows - 1) + "em") │ │ │ │ - } else { │ │ │ │ - tspan.setAttribute("dy", "1em") │ │ │ │ - } │ │ │ │ - tspan.textContent = labelRows[i] === "" ? " " : labelRows[i]; │ │ │ │ - if (!tspan.parentNode) { │ │ │ │ - label.appendChild(tspan) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!label.parentNode) { │ │ │ │ - this.textRoot.appendChild(label) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getComponentsString: function(components, separator) { │ │ │ │ - var renderCmp = []; │ │ │ │ - var complete = true; │ │ │ │ - var len = components.length; │ │ │ │ - var strings = []; │ │ │ │ - var str, component; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - component = components[i]; │ │ │ │ - renderCmp.push(component); │ │ │ │ - str = this.getShortString(component); │ │ │ │ - if (str) { │ │ │ │ - strings.push(str) │ │ │ │ - } else { │ │ │ │ - if (i > 0) { │ │ │ │ - if (this.getShortString(components[i - 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], components[i - 1])) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i < len - 1) { │ │ │ │ - if (this.getShortString(components[i + 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], components[i + 1])) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - complete = false │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - path: strings.join(separator || ","), │ │ │ │ - complete: complete │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clipLine: function(badComponent, goodComponent) { │ │ │ │ - if (goodComponent.equals(badComponent)) { │ │ │ │ - return "" │ │ │ │ - } │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ - var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ - var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y1 = this.top - goodComponent.y / resolution; │ │ │ │ - var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y2 = this.top - badComponent.y / resolution; │ │ │ │ - var k; │ │ │ │ - if (x2 < -maxX || x2 > maxX) { │ │ │ │ - k = (y2 - y1) / (x2 - x1); │ │ │ │ - x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ - y2 = y1 + (x2 - x1) * k │ │ │ │ - } │ │ │ │ - if (y2 < -maxY || y2 > maxY) { │ │ │ │ - k = (x2 - x1) / (y2 - y1); │ │ │ │ - y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ - x2 = x1 + (y2 - y1) * k │ │ │ │ - } │ │ │ │ - return x2 + "," + y2 │ │ │ │ - }, │ │ │ │ - getShortString: function(point) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = (point.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = this.top - point.y / resolution; │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - return x + "," + y │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getPosition: function(node) { │ │ │ │ - return { │ │ │ │ - x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ - y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - importSymbol: function(graphicName) { │ │ │ │ - if (!this.defs) { │ │ │ │ - this.defs = this.createDefs() │ │ │ │ - } │ │ │ │ - var id = this.container.id + "-" + graphicName; │ │ │ │ - var existing = document.getElementById(id); │ │ │ │ - if (existing != null) { │ │ │ │ - return existing │ │ │ │ - } │ │ │ │ - var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ - if (!symbol) { │ │ │ │ - throw new Error(graphicName + " is not a valid symbol name") │ │ │ │ - } │ │ │ │ - var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ - var node = this.nodeFactory(null, "polygon"); │ │ │ │ - symbolNode.appendChild(node); │ │ │ │ - var symbolExtent = new OpenLayers.Bounds(Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ - var points = []; │ │ │ │ - var x, y; │ │ │ │ - for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - x = symbol[i]; │ │ │ │ - y = symbol[i + 1]; │ │ │ │ - symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ - symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ - symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ - symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - points.push(x, ",", y) │ │ │ │ - } │ │ │ │ - node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ - var width = symbolExtent.getWidth(); │ │ │ │ - var height = symbolExtent.getHeight(); │ │ │ │ - var viewBox = [symbolExtent.left - width, symbolExtent.bottom - height, width * 3, height * 3]; │ │ │ │ - symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ - this.symbolMetrics[id] = [Math.max(width, height), symbolExtent.getCenterLonLat().lon, symbolExtent.getCenterLonLat().lat]; │ │ │ │ - this.defs.appendChild(symbolNode); │ │ │ │ - return symbolNode │ │ │ │ - }, │ │ │ │ - getFeatureIdFromEvent: function(evt) { │ │ │ │ - var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ - if (!featureId) { │ │ │ │ - var target = evt.target; │ │ │ │ - featureId = target.parentNode && target != this.rendererRoot ? target.parentNode._featureId : undefined │ │ │ │ - } │ │ │ │ - return featureId │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ -}); │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ - l: "start", │ │ │ │ - r: "end", │ │ │ │ - b: "bottom", │ │ │ │ - t: "hanging" │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ - t: "-70%", │ │ │ │ - b: "0" │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ - t: 0, │ │ │ │ - b: -1 │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ - OpenLayers.Event.preventDefault(e) │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ - xmlns: "urn:schemas-microsoft-com:vml", │ │ │ │ - symbolCache: {}, │ │ │ │ - offset: null, │ │ │ │ - initialize: function(containerID) { │ │ │ │ - if (!this.supported()) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (!document.namespaces.olv) { │ │ │ │ - document.namespaces.add("olv", this.xmlns); │ │ │ │ - var style = document.createStyleSheet(); │ │ │ │ - var shapes = ["shape", "rect", "oval", "fill", "stroke", "imagedata", "group", "textbox"]; │ │ │ │ - for (var i = 0, len = shapes.length; i < len; i++) { │ │ │ │ - style.addRule("olv\\:" + shapes[i], "behavior: url(#default#VML); " + "position: absolute; display: inline-block;") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - supported: function() { │ │ │ │ - return !!document.namespaces │ │ │ │ - }, │ │ │ │ - setExtent: function(extent, resolutionChanged) { │ │ │ │ - var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var left = extent.left / resolution | 0; │ │ │ │ - var top = extent.top / resolution - this.size.h | 0; │ │ │ │ - if (resolutionChanged || !this.offset) { │ │ │ │ - this.offset = { │ │ │ │ - x: left, │ │ │ │ - y: top │ │ │ │ - }; │ │ │ │ - left = 0; │ │ │ │ - top = 0 │ │ │ │ - } else { │ │ │ │ - left = left - this.offset.x; │ │ │ │ - top = top - this.offset.y │ │ │ │ - } │ │ │ │ - var org = left - this.xOffset + " " + top; │ │ │ │ - this.root.coordorigin = org; │ │ │ │ - var roots = [this.root, this.vectorRoot, this.textRoot]; │ │ │ │ - var root; │ │ │ │ - for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ - root = roots[i]; │ │ │ │ - var size = this.size.w + " " + this.size.h; │ │ │ │ - root.coordsize = size │ │ │ │ - } │ │ │ │ - this.root.style.flip = "y"; │ │ │ │ - return coordSysUnchanged │ │ │ │ - }, │ │ │ │ - setSize: function(size) { │ │ │ │ - OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ - var roots = [this.rendererRoot, this.root, this.vectorRoot, this.textRoot]; │ │ │ │ - var w = this.size.w + "px"; │ │ │ │ - var h = this.size.h + "px"; │ │ │ │ - var root; │ │ │ │ - for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ - root = roots[i]; │ │ │ │ - root.style.width = w; │ │ │ │ - root.style.height = h │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getNodeType: function(geometry, style) { │ │ │ │ - var nodeType = null; │ │ │ │ - switch (geometry.CLASS_NAME) { │ │ │ │ - case "OpenLayers.Geometry.Point": │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - nodeType = "olv:rect" │ │ │ │ - } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "olv:shape" │ │ │ │ - } else { │ │ │ │ - nodeType = "olv:oval" │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "olv:rect"; │ │ │ │ - break; │ │ │ │ - case "OpenLayers.Geometry.LineString": │ │ │ │ - case "OpenLayers.Geometry.LinearRing": │ │ │ │ - case "OpenLayers.Geometry.Polygon": │ │ │ │ - case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "olv:shape"; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - break │ │ │ │ - } │ │ │ │ - return nodeType │ │ │ │ - }, │ │ │ │ - setStyle: function(node, style, options, geometry) { │ │ │ │ - style = style || node._style; │ │ │ │ - options = options || node._options; │ │ │ │ - var fillColor = style.fillColor; │ │ │ │ - var title = style.title || style.graphicTitle; │ │ │ │ - if (title) { │ │ │ │ - node.title = title │ │ │ │ - } │ │ │ │ - if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - options.isFilled = true; │ │ │ │ - var width = style.graphicWidth || style.graphicHeight; │ │ │ │ - var height = style.graphicHeight || style.graphicWidth; │ │ │ │ - width = width ? width : style.pointRadius * 2; │ │ │ │ - height = height ? height : style.pointRadius * 2; │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var xOffset = style.graphicXOffset != undefined ? style.graphicXOffset : -(.5 * width); │ │ │ │ - var yOffset = style.graphicYOffset != undefined ? style.graphicYOffset : -(.5 * height); │ │ │ │ - node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x + xOffset | 0) + "px"; │ │ │ │ - node.style.top = (geometry.y / resolution - this.offset.y - (yOffset + height) | 0) + "px"; │ │ │ │ - node.style.width = width + "px"; │ │ │ │ - node.style.height = height + "px"; │ │ │ │ - node.style.flip = "y"; │ │ │ │ - fillColor = "none"; │ │ │ │ - options.isStroked = false │ │ │ │ - } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - var cache = this.importSymbol(style.graphicName); │ │ │ │ - node.path = cache.path; │ │ │ │ - node.coordorigin = cache.left + "," + cache.bottom; │ │ │ │ - var size = cache.size; │ │ │ │ - node.coordsize = size + "," + size; │ │ │ │ - this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ - node.style.flip = "y" │ │ │ │ - } else { │ │ │ │ - this.drawCircle(node, geometry, style.pointRadius) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (options.isFilled) { │ │ │ │ - node.fillcolor = fillColor │ │ │ │ - } else { │ │ │ │ - node.filled = "false" │ │ │ │ - } │ │ │ │ - var fills = node.getElementsByTagName("fill"); │ │ │ │ - var fill = fills.length == 0 ? null : fills[0]; │ │ │ │ - if (!options.isFilled) { │ │ │ │ - if (fill) { │ │ │ │ - node.removeChild(fill) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!fill) { │ │ │ │ - fill = this.createNode("olv:fill", node.id + "_fill") │ │ │ │ - } │ │ │ │ - fill.opacity = style.fillOpacity; │ │ │ │ - if (node._geometryClass === "OpenLayers.Geometry.Point" && style.externalGraphic) { │ │ │ │ - if (style.graphicOpacity) { │ │ │ │ - fill.opacity = style.graphicOpacity │ │ │ │ - } │ │ │ │ - fill.src = style.externalGraphic; │ │ │ │ - fill.type = "frame"; │ │ │ │ - if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ - fill.aspect = "atmost" │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (fill.parentNode != node) { │ │ │ │ - node.appendChild(fill) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var rotation = style.rotation; │ │ │ │ - if (rotation !== undefined || node._rotation !== undefined) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ - fill.opacity = 0 │ │ │ │ - } else if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ - node.style.rotation = rotation || 0 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var strokes = node.getElementsByTagName("stroke"); │ │ │ │ - var stroke = strokes.length == 0 ? null : strokes[0]; │ │ │ │ - if (!options.isStroked) { │ │ │ │ - node.stroked = false; │ │ │ │ - if (stroke) { │ │ │ │ - stroke.on = false │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!stroke) { │ │ │ │ - stroke = this.createNode("olv:stroke", node.id + "_stroke"); │ │ │ │ - node.appendChild(stroke) │ │ │ │ - } │ │ │ │ - stroke.on = true; │ │ │ │ - stroke.color = style.strokeColor; │ │ │ │ - stroke.weight = style.strokeWidth + "px"; │ │ │ │ - stroke.opacity = style.strokeOpacity; │ │ │ │ - stroke.endcap = style.strokeLinecap == "butt" ? "flat" : style.strokeLinecap || "round"; │ │ │ │ - if (style.strokeDashstyle) { │ │ │ │ - stroke.dashstyle = this.dashStyle(style) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ - node.style.cursor = style.cursor │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - graphicRotate: function(node, xOffset, yOffset, style) { │ │ │ │ - var style = style || node._style; │ │ │ │ - var rotation = style.rotation || 0; │ │ │ │ - var aspectRatio, size; │ │ │ │ - if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ - var img = new Image; │ │ │ │ - img.onreadystatechange = OpenLayers.Function.bind(function() { │ │ │ │ - if (img.readyState == "complete" || img.readyState == "interactive") { │ │ │ │ - aspectRatio = img.width / img.height; │ │ │ │ - size = Math.max(style.pointRadius * 2, style.graphicWidth || 0, style.graphicHeight || 0); │ │ │ │ - xOffset = xOffset * aspectRatio; │ │ │ │ - style.graphicWidth = size * aspectRatio; │ │ │ │ - style.graphicHeight = size; │ │ │ │ - this.graphicRotate(node, xOffset, yOffset, style) │ │ │ │ - } │ │ │ │ - }, this); │ │ │ │ - img.src = style.externalGraphic; │ │ │ │ - return │ │ │ │ - } else { │ │ │ │ - size = Math.max(style.graphicWidth, style.graphicHeight); │ │ │ │ - aspectRatio = style.graphicWidth / style.graphicHeight │ │ │ │ - } │ │ │ │ - var width = Math.round(style.graphicWidth || size * aspectRatio); │ │ │ │ - var height = Math.round(style.graphicHeight || size); │ │ │ │ - node.style.width = width + "px"; │ │ │ │ - node.style.height = height + "px"; │ │ │ │ - var image = document.getElementById(node.id + "_image"); │ │ │ │ - if (!image) { │ │ │ │ - image = this.createNode("olv:imagedata", node.id + "_image"); │ │ │ │ - node.appendChild(image) │ │ │ │ - } │ │ │ │ - image.style.width = width + "px"; │ │ │ │ - image.style.height = height + "px"; │ │ │ │ - image.src = style.externalGraphic; │ │ │ │ - image.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + "src='', sizingMethod='scale')"; │ │ │ │ - var rot = rotation * Math.PI / 180; │ │ │ │ - var sintheta = Math.sin(rot); │ │ │ │ - var costheta = Math.cos(rot); │ │ │ │ - var filter = "progid:DXImageTransform.Microsoft.Matrix(M11=" + costheta + ",M12=" + -sintheta + ",M21=" + sintheta + ",M22=" + costheta + ",SizingMethod='auto expand')\n"; │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ - if (opacity && opacity != 1) { │ │ │ │ - filter += "progid:DXImageTransform.Microsoft.BasicImage(opacity=" + opacity + ")\n" │ │ │ │ - } │ │ │ │ - node.style.filter = filter; │ │ │ │ - var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset); │ │ │ │ - var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry(); │ │ │ │ - imgBox.rotate(style.rotation, centerPoint); │ │ │ │ - var imgBounds = imgBox.getBounds(); │ │ │ │ - node.style.left = Math.round(parseInt(node.style.left) + imgBounds.left) + "px"; │ │ │ │ - node.style.top = Math.round(parseInt(node.style.top) - imgBounds.bottom) + "px" │ │ │ │ - }, │ │ │ │ - postDraw: function(node) { │ │ │ │ - node.style.visibility = "visible"; │ │ │ │ - var fillColor = node._style.fillColor; │ │ │ │ - var strokeColor = node._style.strokeColor; │ │ │ │ - if (fillColor == "none" && node.fillcolor != fillColor) { │ │ │ │ - node.fillcolor = fillColor │ │ │ │ - } │ │ │ │ - if (strokeColor == "none" && node.strokecolor != strokeColor) { │ │ │ │ - node.strokecolor = strokeColor │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setNodeDimension: function(node, geometry) { │ │ │ │ - var bbox = geometry.getBounds(); │ │ │ │ - if (bbox) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var scaledBox = new OpenLayers.Bounds((bbox.left - this.featureDx) / resolution - this.offset.x | 0, bbox.bottom / resolution - this.offset.y | 0, (bbox.right - this.featureDx) / resolution - this.offset.x | 0, bbox.top / resolution - this.offset.y | 0); │ │ │ │ - node.style.left = scaledBox.left + "px"; │ │ │ │ - node.style.top = scaledBox.top + "px"; │ │ │ │ - node.style.width = scaledBox.getWidth() + "px"; │ │ │ │ - node.style.height = scaledBox.getHeight() + "px"; │ │ │ │ - node.coordorigin = scaledBox.left + " " + scaledBox.top; │ │ │ │ - node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - dashStyle: function(style) { │ │ │ │ - var dash = style.strokeDashstyle; │ │ │ │ - switch (dash) { │ │ │ │ - case "solid": │ │ │ │ - case "dot": │ │ │ │ - case "dash": │ │ │ │ - case "dashdot": │ │ │ │ - case "longdash": │ │ │ │ - case "longdashdot": │ │ │ │ - return dash; │ │ │ │ - default: │ │ │ │ - var parts = dash.split(/[ ,]/); │ │ │ │ - if (parts.length == 2) { │ │ │ │ - if (1 * parts[0] >= 2 * parts[1]) { │ │ │ │ - return "longdash" │ │ │ │ - } │ │ │ │ - return parts[0] == 1 || parts[1] == 1 ? "dot" : "dash" │ │ │ │ - } else if (parts.length == 4) { │ │ │ │ - return 1 * parts[0] >= 2 * parts[1] ? "longdashdot" : "dashdot" │ │ │ │ - } │ │ │ │ - return "solid" │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - createNode: function(type, id) { │ │ │ │ - var node = document.createElement(type); │ │ │ │ - if (id) { │ │ │ │ - node.id = id │ │ │ │ - } │ │ │ │ - node.unselectable = "on"; │ │ │ │ - node.onselectstart = OpenLayers.Function.False; │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - nodeTypeCompare: function(node, type) { │ │ │ │ - var subType = type; │ │ │ │ - var splitIndex = subType.indexOf(":"); │ │ │ │ - if (splitIndex != -1) { │ │ │ │ - subType = subType.substr(splitIndex + 1) │ │ │ │ - } │ │ │ │ - var nodeName = node.nodeName; │ │ │ │ - splitIndex = nodeName.indexOf(":"); │ │ │ │ - if (splitIndex != -1) { │ │ │ │ - nodeName = nodeName.substr(splitIndex + 1) │ │ │ │ - } │ │ │ │ - return subType == nodeName │ │ │ │ - }, │ │ │ │ - createRenderRoot: function() { │ │ │ │ - return this.nodeFactory(this.container.id + "_vmlRoot", "div") │ │ │ │ - }, │ │ │ │ - createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "olv:group") │ │ │ │ - }, │ │ │ │ - drawPoint: function(node, geometry) { │ │ │ │ - return this.drawCircle(node, geometry, 1) │ │ │ │ - }, │ │ │ │ - drawCircle: function(node, geometry, radius) { │ │ │ │ - if (!isNaN(geometry.x) && !isNaN(geometry.y)) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) - radius + "px"; │ │ │ │ - node.style.top = (geometry.y / resolution - this.offset.y | 0) - radius + "px"; │ │ │ │ - var diameter = radius * 2; │ │ │ │ - node.style.width = diameter + "px"; │ │ │ │ - node.style.height = diameter + "px"; │ │ │ │ - return node │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - drawLineString: function(node, geometry) { │ │ │ │ - return this.drawLine(node, geometry, false) │ │ │ │ - }, │ │ │ │ - drawLinearRing: function(node, geometry) { │ │ │ │ - return this.drawLine(node, geometry, true) │ │ │ │ - }, │ │ │ │ - drawLine: function(node, geometry, closeLine) { │ │ │ │ - this.setNodeDimension(node, geometry); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var numComponents = geometry.components.length; │ │ │ │ - var parts = new Array(numComponents); │ │ │ │ - var comp, x, y; │ │ │ │ - for (var i = 0; i < numComponents; i++) { │ │ │ │ - comp = geometry.components[i]; │ │ │ │ - x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ - y = comp.y / resolution - this.offset.y | 0; │ │ │ │ - parts[i] = " " + x + "," + y + " l " │ │ │ │ - } │ │ │ │ - var end = closeLine ? " x e" : " e"; │ │ │ │ - node.path = "m" + parts.join("") + end; │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - drawPolygon: function(node, geometry) { │ │ │ │ - this.setNodeDimension(node, geometry); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var path = []; │ │ │ │ - var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y; │ │ │ │ - for (j = 0, jj = geometry.components.length; j < jj; j++) { │ │ │ │ - path.push("m"); │ │ │ │ - points = geometry.components[j].components; │ │ │ │ - area = j === 0; │ │ │ │ - first = null; │ │ │ │ - second = null; │ │ │ │ - for (i = 0, ii = points.length; i < ii; i++) { │ │ │ │ - comp = points[i]; │ │ │ │ - x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ - y = comp.y / resolution - this.offset.y | 0; │ │ │ │ - pathComp = " " + x + "," + y; │ │ │ │ - path.push(pathComp); │ │ │ │ - if (i == 0) { │ │ │ │ - path.push(" l") │ │ │ │ - } │ │ │ │ - if (!area) { │ │ │ │ - if (!first) { │ │ │ │ - first = pathComp │ │ │ │ - } else if (first != pathComp) { │ │ │ │ - if (!second) { │ │ │ │ - second = pathComp │ │ │ │ - } else if (second != pathComp) { │ │ │ │ - area = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - path.push(area ? " x " : " ") │ │ │ │ - } │ │ │ │ - path.push("e"); │ │ │ │ - node.path = path.join(""); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - drawRectangle: function(node, geometry) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ - node.style.top = (geometry.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ - node.style.width = (geometry.width / resolution | 0) + "px"; │ │ │ │ - node.style.height = (geometry.height / resolution | 0) + "px"; │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - drawText: function(featureId, style, location) { │ │ │ │ - var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect"); │ │ │ │ - var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox"); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - label.style.left = ((location.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ - label.style.top = (location.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ - label.style.flip = "y"; │ │ │ │ - textbox.innerText = style.label; │ │ │ │ - if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ - textbox.style.cursor = style.cursor │ │ │ │ - } │ │ │ │ - if (style.fontColor) { │ │ │ │ - textbox.style.color = style.fontColor │ │ │ │ - } │ │ │ │ - if (style.fontOpacity) { │ │ │ │ - textbox.style.filter = "alpha(opacity=" + style.fontOpacity * 100 + ")" │ │ │ │ - } │ │ │ │ - if (style.fontFamily) { │ │ │ │ - textbox.style.fontFamily = style.fontFamily │ │ │ │ - } │ │ │ │ - if (style.fontSize) { │ │ │ │ - textbox.style.fontSize = style.fontSize │ │ │ │ - } │ │ │ │ - if (style.fontWeight) { │ │ │ │ - textbox.style.fontWeight = style.fontWeight │ │ │ │ - } │ │ │ │ - if (style.fontStyle) { │ │ │ │ - textbox.style.fontStyle = style.fontStyle │ │ │ │ - } │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - label._featureId = featureId; │ │ │ │ - textbox._featureId = featureId; │ │ │ │ - textbox._geometry = location; │ │ │ │ - textbox._geometryClass = location.CLASS_NAME │ │ │ │ - } │ │ │ │ - textbox.style.whiteSpace = "nowrap"; │ │ │ │ - textbox.inset = "1px,0px,0px,0px"; │ │ │ │ - if (!label.parentNode) { │ │ │ │ - label.appendChild(textbox); │ │ │ │ - this.textRoot.appendChild(label) │ │ │ │ - } │ │ │ │ - var align = style.labelAlign || "cm"; │ │ │ │ - if (align.length == 1) { │ │ │ │ - align += "m" │ │ │ │ - } │ │ │ │ - var xshift = textbox.clientWidth * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)]; │ │ │ │ - var yshift = textbox.clientHeight * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)]; │ │ │ │ - label.style.left = parseInt(label.style.left) - xshift - 1 + "px"; │ │ │ │ - label.style.top = parseInt(label.style.top) + yshift + "px" │ │ │ │ - }, │ │ │ │ - moveRoot: function(renderer) { │ │ │ │ - var layer = this.map.getLayer(renderer.container.id); │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector.RootContainer) { │ │ │ │ - layer = this.map.getLayer(this.container.id) │ │ │ │ - } │ │ │ │ - layer && layer.renderer.clear(); │ │ │ │ - OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments); │ │ │ │ - layer && layer.redraw() │ │ │ │ - }, │ │ │ │ - importSymbol: function(graphicName) { │ │ │ │ - var id = this.container.id + "-" + graphicName; │ │ │ │ - var cache = this.symbolCache[id]; │ │ │ │ - if (cache) { │ │ │ │ - return cache │ │ │ │ - } │ │ │ │ - var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ - if (!symbol) { │ │ │ │ - throw new Error(graphicName + " is not a valid symbol name") │ │ │ │ - } │ │ │ │ - var symbolExtent = new OpenLayers.Bounds(Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ - var pathitems = ["m"]; │ │ │ │ - for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - var x = symbol[i]; │ │ │ │ - var y = symbol[i + 1]; │ │ │ │ - symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ - symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ - symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ - symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - pathitems.push(x); │ │ │ │ - pathitems.push(y); │ │ │ │ - if (i == 0) { │ │ │ │ - pathitems.push("l") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - pathitems.push("x e"); │ │ │ │ - var path = pathitems.join(" "); │ │ │ │ - var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2; │ │ │ │ - if (diff > 0) { │ │ │ │ - symbolExtent.bottom = symbolExtent.bottom - diff; │ │ │ │ - symbolExtent.top = symbolExtent.top + diff │ │ │ │ - } else { │ │ │ │ - symbolExtent.left = symbolExtent.left + diff; │ │ │ │ - symbolExtent.right = symbolExtent.right - diff │ │ │ │ - } │ │ │ │ - cache = { │ │ │ │ - path: path, │ │ │ │ - size: symbolExtent.getWidth(), │ │ │ │ - left: symbolExtent.left, │ │ │ │ - bottom: symbolExtent.bottom │ │ │ │ - }; │ │ │ │ - this.symbolCache[id] = cache; │ │ │ │ - return cache │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.VML" │ │ │ │ -}); │ │ │ │ -OpenLayers.Renderer.VML.LABEL_SHIFT = { │ │ │ │ - l: 0, │ │ │ │ - c: .5, │ │ │ │ - r: 1, │ │ │ │ - t: 0, │ │ │ │ - m: .5, │ │ │ │ - b: 1 │ │ │ │ -}; │ │ │ │ -OpenLayers.Format = OpenLayers.Class({ │ │ │ │ - options: null, │ │ │ │ - externalProjection: null, │ │ │ │ - internalProjection: null, │ │ │ │ - data: null, │ │ │ │ - keepData: false, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options │ │ │ │ - }, │ │ │ │ - destroy: function() {}, │ │ │ │ - read: function(data) { │ │ │ │ - throw new Error("Read not implemented.") │ │ │ │ - }, │ │ │ │ - write: function(object) { │ │ │ │ - throw new Error("Write not implemented.") │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - indent: " ", │ │ │ │ - space: " ", │ │ │ │ - newline: "\n", │ │ │ │ - level: 0, │ │ │ │ - pretty: false, │ │ │ │ - nativeJSON: function() { │ │ │ │ - return !!(window.JSON && typeof JSON.parse == "function" && typeof JSON.stringify == "function") │ │ │ │ - }(), │ │ │ │ - read: function(json, filter) { │ │ │ │ - var object; │ │ │ │ - if (this.nativeJSON) { │ │ │ │ - object = JSON.parse(json, filter) │ │ │ │ - } else try { │ │ │ │ - if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, ""))) { │ │ │ │ - object = eval("(" + json + ")"); │ │ │ │ - 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) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } catch (e) {} │ │ │ │ - if (this.keepData) { │ │ │ │ - this.data = object │ │ │ │ - } │ │ │ │ - return object │ │ │ │ - }, │ │ │ │ - write: function(value, pretty) { │ │ │ │ - this.pretty = !!pretty; │ │ │ │ - var json = null; │ │ │ │ - var type = typeof value; │ │ │ │ - if (this.serialize[type]) { │ │ │ │ - try { │ │ │ │ - json = !this.pretty && this.nativeJSON ? JSON.stringify(value) : this.serialize[type].apply(this, [value]) │ │ │ │ - } catch (err) { │ │ │ │ - OpenLayers.Console.error("Trouble serializing: " + err) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return json │ │ │ │ - }, │ │ │ │ - writeIndent: function() { │ │ │ │ - var pieces = []; │ │ │ │ - if (this.pretty) { │ │ │ │ - for (var i = 0; i < this.level; ++i) { │ │ │ │ - pieces.push(this.indent) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return pieces.join("") │ │ │ │ - }, │ │ │ │ - writeNewline: function() { │ │ │ │ - return this.pretty ? this.newline : "" │ │ │ │ - }, │ │ │ │ - writeSpace: function() { │ │ │ │ - return this.pretty ? this.space : "" │ │ │ │ - }, │ │ │ │ - serialize: { │ │ │ │ - object: function(object) { │ │ │ │ - if (object == null) { │ │ │ │ - return "null" │ │ │ │ - } │ │ │ │ - if (object.constructor == Date) { │ │ │ │ - return this.serialize.date.apply(this, [object]) │ │ │ │ - } │ │ │ │ - if (object.constructor == Array) { │ │ │ │ - return this.serialize.array.apply(this, [object]) │ │ │ │ - } │ │ │ │ - var pieces = ["{"]; │ │ │ │ - this.level += 1; │ │ │ │ - var key, keyJSON, valueJSON; │ │ │ │ - var addComma = false; │ │ │ │ - for (key in object) { │ │ │ │ - if (object.hasOwnProperty(key)) { │ │ │ │ - keyJSON = OpenLayers.Format.JSON.prototype.write.apply(this, [key, this.pretty]); │ │ │ │ - valueJSON = OpenLayers.Format.JSON.prototype.write.apply(this, [object[key], this.pretty]); │ │ │ │ - if (keyJSON != null && valueJSON != null) { │ │ │ │ - if (addComma) { │ │ │ │ - pieces.push(",") │ │ │ │ - } │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), keyJSON, ":", this.writeSpace(), valueJSON); │ │ │ │ - addComma = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.level -= 1; │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), "}"); │ │ │ │ - return pieces.join("") │ │ │ │ - }, │ │ │ │ - array: function(array) { │ │ │ │ - var json; │ │ │ │ - var pieces = ["["]; │ │ │ │ - this.level += 1; │ │ │ │ - for (var i = 0, len = array.length; i < len; ++i) { │ │ │ │ - json = OpenLayers.Format.JSON.prototype.write.apply(this, [array[i], this.pretty]); │ │ │ │ - if (json != null) { │ │ │ │ - if (i > 0) { │ │ │ │ - pieces.push(",") │ │ │ │ - } │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), json) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.level -= 1; │ │ │ │ - pieces.push(this.writeNewline(), this.writeIndent(), "]"); │ │ │ │ - return pieces.join("") │ │ │ │ - }, │ │ │ │ - string: function(string) { │ │ │ │ - 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 + '"' │ │ │ │ - }, │ │ │ │ - number: function(number) { │ │ │ │ - return isFinite(number) ? String(number) : "null" │ │ │ │ - }, │ │ │ │ - boolean: function(bool) { │ │ │ │ - return String(bool) │ │ │ │ - }, │ │ │ │ - date: function(date) { │ │ │ │ - function format(number) { │ │ │ │ - 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.Geometry = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - parent: null, │ │ │ │ - bounds: null, │ │ │ │ - initialize: function() { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.id = null; │ │ │ │ - this.bounds = null │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Geometry │ │ │ │ - }, │ │ │ │ - setBounds: function(bounds) { │ │ │ │ - if (bounds) { │ │ │ │ - this.bounds = bounds.clone() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clearBounds: function() { │ │ │ │ - this.bounds = null; │ │ │ │ - if (this.parent) { │ │ │ │ - this.parent.clearBounds() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - extendBounds: function(newBounds) { │ │ │ │ - var bounds = this.getBounds(); │ │ │ │ - if (!bounds) { │ │ │ │ - this.setBounds(newBounds) │ │ │ │ - } else { │ │ │ │ - this.bounds.extend(newBounds) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getBounds: function() { │ │ │ │ - if (this.bounds == null) { │ │ │ │ - this.calculateBounds() │ │ │ │ - } │ │ │ │ - return this.bounds │ │ │ │ - }, │ │ │ │ - calculateBounds: function() {}, │ │ │ │ - distanceTo: function(geometry, options) {}, │ │ │ │ - getVertices: function(nodes) {}, │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - var bounds = this.getBounds(); │ │ │ │ - if (bounds != null && lonlat != null) { │ │ │ │ - var dX = toleranceLon != null ? toleranceLon : 0; │ │ │ │ - var dY = toleranceLat != null ? toleranceLat : 0; │ │ │ │ - var toleranceBounds = new OpenLayers.Bounds(this.bounds.left - dX, this.bounds.bottom - dY, this.bounds.right + dX, this.bounds.top + dY); │ │ │ │ - atPoint = toleranceBounds.containsLonLat(lonlat) │ │ │ │ - } │ │ │ │ - return atPoint │ │ │ │ - }, │ │ │ │ - getLength: function() { │ │ │ │ - return 0 │ │ │ │ - }, │ │ │ │ - getArea: function() { │ │ │ │ - return 0 │ │ │ │ - }, │ │ │ │ - getCentroid: function() { │ │ │ │ - return null │ │ │ │ - }, │ │ │ │ - toString: function() { │ │ │ │ - var string; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ - string = OpenLayers.Format.WKT.prototype.write(new OpenLayers.Feature.Vector(this)) │ │ │ │ - } else { │ │ │ │ - string = Object.prototype.toString.call(this) │ │ │ │ - } │ │ │ │ - return string │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry" │ │ │ │ -}); │ │ │ │ -OpenLayers.Geometry.fromWKT = function(wkt) { │ │ │ │ - var geom; │ │ │ │ - if (OpenLayers.Format && OpenLayers.Format.WKT) { │ │ │ │ - var format = OpenLayers.Geometry.fromWKT.format; │ │ │ │ - if (!format) { │ │ │ │ - format = new OpenLayers.Format.WKT; │ │ │ │ - OpenLayers.Geometry.fromWKT.format = format │ │ │ │ - } │ │ │ │ - var result = format.read(wkt); │ │ │ │ - if (result instanceof OpenLayers.Feature.Vector) { │ │ │ │ - geom = result.geometry │ │ │ │ - } else if (OpenLayers.Util.isArray(result)) { │ │ │ │ - var len = result.length; │ │ │ │ - var components = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - components[i] = result[i].geometry │ │ │ │ - } │ │ │ │ - geom = new OpenLayers.Geometry.Collection(components) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return geom │ │ │ │ -}; │ │ │ │ -OpenLayers.Geometry.segmentsIntersect = function(seg1, seg2, options) { │ │ │ │ - var point = options && options.point; │ │ │ │ - var tolerance = options && options.tolerance; │ │ │ │ - var intersection = false; │ │ │ │ - var x11_21 = seg1.x1 - seg2.x1; │ │ │ │ - var y11_21 = seg1.y1 - seg2.y1; │ │ │ │ - var x12_11 = seg1.x2 - seg1.x1; │ │ │ │ - var y12_11 = seg1.y2 - seg1.y1; │ │ │ │ - var y22_21 = seg2.y2 - seg2.y1; │ │ │ │ - var x22_21 = seg2.x2 - seg2.x1; │ │ │ │ - var d = y22_21 * x12_11 - x22_21 * y12_11; │ │ │ │ - var n1 = x22_21 * y11_21 - y22_21 * x11_21; │ │ │ │ - var n2 = x12_11 * y11_21 - y12_11 * x11_21; │ │ │ │ - if (d == 0) { │ │ │ │ - if (n1 == 0 && n2 == 0) { │ │ │ │ - intersection = true │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - var along1 = n1 / d; │ │ │ │ - var along2 = n2 / d; │ │ │ │ - if (along1 >= 0 && along1 <= 1 && along2 >= 0 && along2 <= 1) { │ │ │ │ - if (!point) { │ │ │ │ - intersection = true │ │ │ │ - } else { │ │ │ │ - var x = seg1.x1 + along1 * x12_11; │ │ │ │ - var y = seg1.y1 + along1 * y12_11; │ │ │ │ - intersection = new OpenLayers.Geometry.Point(x, y) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (tolerance) { │ │ │ │ - var dist; │ │ │ │ - if (intersection) { │ │ │ │ - if (point) { │ │ │ │ - var segs = [seg1, seg2]; │ │ │ │ - var seg, x, y; │ │ │ │ - outer: for (var i = 0; i < 2; ++i) { │ │ │ │ - seg = segs[i]; │ │ │ │ - for (var j = 1; j < 3; ++j) { │ │ │ │ - x = seg["x" + j]; │ │ │ │ - y = seg["y" + j]; │ │ │ │ - dist = Math.sqrt(Math.pow(x - intersection.x, 2) + Math.pow(y - intersection.y, 2)); │ │ │ │ - if (dist < tolerance) { │ │ │ │ - intersection.x = x; │ │ │ │ - intersection.y = y; │ │ │ │ - break outer │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - var segs = [seg1, seg2]; │ │ │ │ - var source, target, x, y, p, result; │ │ │ │ - outer: for (var i = 0; i < 2; ++i) { │ │ │ │ - source = segs[i]; │ │ │ │ - target = segs[(i + 1) % 2]; │ │ │ │ - for (var j = 1; j < 3; ++j) { │ │ │ │ - p = { │ │ │ │ - x: source["x" + j], │ │ │ │ - y: source["y" + j] │ │ │ │ - }; │ │ │ │ - result = OpenLayers.Geometry.distanceToSegment(p, target); │ │ │ │ - if (result.distance < tolerance) { │ │ │ │ - if (point) { │ │ │ │ - intersection = new OpenLayers.Geometry.Point(p.x, p.y) │ │ │ │ - } else { │ │ │ │ - intersection = true │ │ │ │ - } │ │ │ │ - break outer │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return intersection │ │ │ │ -}; │ │ │ │ -OpenLayers.Geometry.distanceToSegment = function(point, segment) { │ │ │ │ - var result = OpenLayers.Geometry.distanceSquaredToSegment(point, segment); │ │ │ │ - result.distance = Math.sqrt(result.distance); │ │ │ │ - return result │ │ │ │ -}; │ │ │ │ -OpenLayers.Geometry.distanceSquaredToSegment = function(point, segment) { │ │ │ │ - var x0 = point.x; │ │ │ │ - var y0 = point.y; │ │ │ │ - var x1 = segment.x1; │ │ │ │ - var y1 = segment.y1; │ │ │ │ - var x2 = segment.x2; │ │ │ │ - var y2 = segment.y2; │ │ │ │ - var dx = x2 - x1; │ │ │ │ - var dy = y2 - y1; │ │ │ │ - var along = (dx * (x0 - x1) + dy * (y0 - y1)) / (Math.pow(dx, 2) + Math.pow(dy, 2)); │ │ │ │ - var x, y; │ │ │ │ - if (along <= 0) { │ │ │ │ - x = x1; │ │ │ │ - y = y1 │ │ │ │ - } else if (along >= 1) { │ │ │ │ - x = x2; │ │ │ │ - y = y2 │ │ │ │ - } else { │ │ │ │ - x = x1 + along * dx; │ │ │ │ - y = y1 + along * dy │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - distance: Math.pow(x - x0, 2) + Math.pow(y - y0, 2), │ │ │ │ - x: x, │ │ │ │ - y: y, │ │ │ │ - along: along │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -OpenLayers.Geometry.Point = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ - x: null, │ │ │ │ - y: null, │ │ │ │ - initialize: function(x, y) { │ │ │ │ - OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ - this.x = parseFloat(x); │ │ │ │ - this.y = parseFloat(y) │ │ │ │ - }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Geometry.Point(this.x, this.y) │ │ │ │ - } │ │ │ │ - OpenLayers.Util.applyDefaults(obj, this); │ │ │ │ - return obj │ │ │ │ - }, │ │ │ │ - calculateBounds: function() { │ │ │ │ - this.bounds = new OpenLayers.Bounds(this.x, this.y, this.x, this.y) │ │ │ │ - }, │ │ │ │ - distanceTo: function(geometry, options) { │ │ │ │ - var edge = !(options && options.edge === false); │ │ │ │ - var details = edge && options && options.details; │ │ │ │ - var distance, x0, y0, x1, y1, result; │ │ │ │ - if (geometry instanceof OpenLayers.Geometry.Point) { │ │ │ │ - x0 = this.x; │ │ │ │ - y0 = this.y; │ │ │ │ - x1 = geometry.x; │ │ │ │ - y1 = geometry.y; │ │ │ │ - distance = Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2)); │ │ │ │ - result = !details ? distance : { │ │ │ │ - x0: x0, │ │ │ │ - y0: y0, │ │ │ │ - x1: x1, │ │ │ │ - y1: y1, │ │ │ │ - distance: distance │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - result = geometry.distanceTo(this, options); │ │ │ │ - if (details) { │ │ │ │ - result = { │ │ │ │ - x0: result.x1, │ │ │ │ - y0: result.y1, │ │ │ │ - x1: result.x0, │ │ │ │ - y1: result.y0, │ │ │ │ - distance: result.distance │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return result │ │ │ │ - }, │ │ │ │ - equals: function(geom) { │ │ │ │ - var equals = false; │ │ │ │ - if (geom != null) { │ │ │ │ - equals = this.x == geom.x && this.y == geom.y || isNaN(this.x) && isNaN(this.y) && isNaN(geom.x) && isNaN(geom.y) │ │ │ │ - } │ │ │ │ - return equals │ │ │ │ - }, │ │ │ │ - toShortString: function() { │ │ │ │ - return this.x + ", " + this.y │ │ │ │ - }, │ │ │ │ - move: function(x, y) { │ │ │ │ - this.x = this.x + x; │ │ │ │ - this.y = this.y + y; │ │ │ │ - this.clearBounds() │ │ │ │ - }, │ │ │ │ - rotate: function(angle, origin) { │ │ │ │ - angle *= Math.PI / 180; │ │ │ │ - var radius = this.distanceTo(origin); │ │ │ │ - var theta = angle + Math.atan2(this.y - origin.y, this.x - origin.x); │ │ │ │ - this.x = origin.x + radius * Math.cos(theta); │ │ │ │ - this.y = origin.y + radius * Math.sin(theta); │ │ │ │ - this.clearBounds() │ │ │ │ - }, │ │ │ │ - getCentroid: function() { │ │ │ │ - return new OpenLayers.Geometry.Point(this.x, this.y) │ │ │ │ - }, │ │ │ │ - resize: function(scale, origin, ratio) { │ │ │ │ - ratio = ratio == undefined ? 1 : ratio; │ │ │ │ - this.x = origin.x + scale * ratio * (this.x - origin.x); │ │ │ │ - this.y = origin.y + scale * (this.y - origin.y); │ │ │ │ - this.clearBounds(); │ │ │ │ - return this │ │ │ │ - }, │ │ │ │ - intersects: function(geometry) { │ │ │ │ - var intersect = false; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - intersect = this.equals(geometry) │ │ │ │ - } else { │ │ │ │ - intersect = geometry.intersects(this) │ │ │ │ - } │ │ │ │ - return intersect │ │ │ │ - }, │ │ │ │ - transform: function(source, dest) { │ │ │ │ - if (source && dest) { │ │ │ │ - OpenLayers.Projection.transform(this, source, dest); │ │ │ │ - this.bounds = null │ │ │ │ - } │ │ │ │ - return this │ │ │ │ - }, │ │ │ │ - getVertices: function(nodes) { │ │ │ │ - return [this] │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Geometry.Point" │ │ │ │ -}); │ │ │ │ -OpenLayers.Geometry.Collection = OpenLayers.Class(OpenLayers.Geometry, { │ │ │ │ - components: null, │ │ │ │ - componentTypes: null, │ │ │ │ - initialize: function(components) { │ │ │ │ - OpenLayers.Geometry.prototype.initialize.apply(this, arguments); │ │ │ │ - this.components = []; │ │ │ │ - if (components != null) { │ │ │ │ - this.addComponents(components) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.components.length = 0; │ │ │ │ - this.components = null; │ │ │ │ - OpenLayers.Geometry.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var geometry = eval("new " + this.CLASS_NAME + "()"); │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - geometry.addComponent(this.components[i].clone()) │ │ │ │ - } │ │ │ │ - OpenLayers.Util.applyDefaults(geometry, this); │ │ │ │ - return geometry │ │ │ │ - }, │ │ │ │ - getComponentsString: function() { │ │ │ │ - var strings = []; │ │ │ │ - for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ - strings.push(this.components[i].toShortString()) │ │ │ │ - } │ │ │ │ - return strings.join(",") │ │ │ │ + getComponentsString: function() { │ │ │ │ + var strings = []; │ │ │ │ + for (var i = 0, len = this.components.length; i < len; i++) { │ │ │ │ + strings.push(this.components[i].toShortString()) │ │ │ │ + } │ │ │ │ + return strings.join(",") │ │ │ │ }, │ │ │ │ calculateBounds: function() { │ │ │ │ this.bounds = null; │ │ │ │ var bounds = new OpenLayers.Bounds; │ │ │ │ var components = this.components; │ │ │ │ if (components) { │ │ │ │ for (var i = 0, len = components.length; i < len; i++) { │ │ │ │ @@ -14002,886 +11211,3677 @@ │ │ │ │ var opt = options[resp.requestType]; │ │ │ │ if (opt && opt.callback) { │ │ │ │ opt.callback.call(opt.scope, resp) │ │ │ │ } │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ }); │ │ │ │ -OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ - filters: null, │ │ │ │ - type: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.filters = []; │ │ │ │ - OpenLayers.Filter.prototype.initialize.apply(this, [options]) │ │ │ │ +OpenLayers.ElementsIndexer = OpenLayers.Class({ │ │ │ │ + maxZIndex: null, │ │ │ │ + order: null, │ │ │ │ + indices: null, │ │ │ │ + compare: null, │ │ │ │ + initialize: function(yOrdering) { │ │ │ │ + this.compare = yOrdering ? OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER : OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER; │ │ │ │ + this.clear() │ │ │ │ + }, │ │ │ │ + insert: function(newNode) { │ │ │ │ + if (this.exists(newNode)) { │ │ │ │ + this.remove(newNode) │ │ │ │ + } │ │ │ │ + var nodeId = newNode.id; │ │ │ │ + this.determineZIndex(newNode); │ │ │ │ + var leftIndex = -1; │ │ │ │ + var rightIndex = this.order.length; │ │ │ │ + var middle; │ │ │ │ + while (rightIndex - leftIndex > 1) { │ │ │ │ + middle = parseInt((leftIndex + rightIndex) / 2); │ │ │ │ + var placement = this.compare(this, newNode, OpenLayers.Util.getElement(this.order[middle])); │ │ │ │ + if (placement > 0) { │ │ │ │ + leftIndex = middle │ │ │ │ + } else { │ │ │ │ + rightIndex = middle │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.order.splice(rightIndex, 0, nodeId); │ │ │ │ + this.indices[nodeId] = this.getZIndex(newNode); │ │ │ │ + return this.getNextElement(rightIndex) │ │ │ │ + }, │ │ │ │ + remove: function(node) { │ │ │ │ + var nodeId = node.id; │ │ │ │ + var arrayIndex = OpenLayers.Util.indexOf(this.order, nodeId); │ │ │ │ + if (arrayIndex >= 0) { │ │ │ │ + this.order.splice(arrayIndex, 1); │ │ │ │ + delete this.indices[nodeId]; │ │ │ │ + if (this.order.length > 0) { │ │ │ │ + var lastId = this.order[this.order.length - 1]; │ │ │ │ + this.maxZIndex = this.indices[lastId] │ │ │ │ + } else { │ │ │ │ + this.maxZIndex = 0 │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clear: function() { │ │ │ │ + this.order = []; │ │ │ │ + this.indices = {}; │ │ │ │ + this.maxZIndex = 0 │ │ │ │ + }, │ │ │ │ + exists: function(node) { │ │ │ │ + return this.indices[node.id] != null │ │ │ │ + }, │ │ │ │ + getZIndex: function(node) { │ │ │ │ + return node._style.graphicZIndex │ │ │ │ + }, │ │ │ │ + determineZIndex: function(node) { │ │ │ │ + var zIndex = node._style.graphicZIndex; │ │ │ │ + if (zIndex == null) { │ │ │ │ + zIndex = this.maxZIndex; │ │ │ │ + node._style.graphicZIndex = zIndex │ │ │ │ + } else if (zIndex > this.maxZIndex) { │ │ │ │ + this.maxZIndex = zIndex │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getNextElement: function(index) { │ │ │ │ + var nextIndex = index + 1; │ │ │ │ + if (nextIndex < this.order.length) { │ │ │ │ + var nextElement = OpenLayers.Util.getElement(this.order[nextIndex]); │ │ │ │ + if (nextElement == undefined) { │ │ │ │ + nextElement = this.getNextElement(nextIndex) │ │ │ │ + } │ │ │ │ + return nextElement │ │ │ │ + } else { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.ElementsIndexer" │ │ │ │ +}); │ │ │ │ +OpenLayers.ElementsIndexer.IndexingMethods = { │ │ │ │ + Z_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ + var newZIndex = indexer.getZIndex(newNode); │ │ │ │ + var returnVal = 0; │ │ │ │ + if (nextNode) { │ │ │ │ + var nextZIndex = indexer.getZIndex(nextNode); │ │ │ │ + returnVal = newZIndex - nextZIndex │ │ │ │ + } │ │ │ │ + return returnVal │ │ │ │ + }, │ │ │ │ + Z_ORDER_DRAWING_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ + var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ + if (nextNode && returnVal == 0) { │ │ │ │ + returnVal = 1 │ │ │ │ + } │ │ │ │ + return returnVal │ │ │ │ + }, │ │ │ │ + Z_ORDER_Y_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ + var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ + if (nextNode && returnVal === 0) { │ │ │ │ + var result = nextNode._boundsBottom - newNode._boundsBottom; │ │ │ │ + returnVal = result === 0 ? 1 : result │ │ │ │ + } │ │ │ │ + return returnVal │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, { │ │ │ │ + rendererRoot: null, │ │ │ │ + root: null, │ │ │ │ + vectorRoot: null, │ │ │ │ + textRoot: null, │ │ │ │ + xmlns: null, │ │ │ │ + xOffset: 0, │ │ │ │ + indexer: null, │ │ │ │ + BACKGROUND_ID_SUFFIX: "_background", │ │ │ │ + LABEL_ID_SUFFIX: "_label", │ │ │ │ + LABEL_OUTLINE_SUFFIX: "_outline", │ │ │ │ + initialize: function(containerID, options) { │ │ │ │ + OpenLayers.Renderer.prototype.initialize.apply(this, arguments); │ │ │ │ + this.rendererRoot = this.createRenderRoot(); │ │ │ │ + this.root = this.createRoot("_root"); │ │ │ │ + this.vectorRoot = this.createRoot("_vroot"); │ │ │ │ + this.textRoot = this.createRoot("_troot"); │ │ │ │ + this.root.appendChild(this.vectorRoot); │ │ │ │ + this.root.appendChild(this.textRoot); │ │ │ │ + this.rendererRoot.appendChild(this.root); │ │ │ │ + this.container.appendChild(this.rendererRoot); │ │ │ │ + if (options && (options.zIndexing || options.yOrdering)) { │ │ │ │ + this.indexer = new OpenLayers.ElementsIndexer(options.yOrdering) │ │ │ │ + } │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.filters = null; │ │ │ │ - OpenLayers.Filter.prototype.destroy.apply(this) │ │ │ │ + this.clear(); │ │ │ │ + this.rendererRoot = null; │ │ │ │ + this.root = null; │ │ │ │ + this.xmlns = null; │ │ │ │ + OpenLayers.Renderer.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - evaluate: function(context) { │ │ │ │ - var i, len; │ │ │ │ - switch (this.type) { │ │ │ │ - case OpenLayers.Filter.Logical.AND: │ │ │ │ - for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ - if (this.filters[i].evaluate(context) == false) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ + clear: function() { │ │ │ │ + var child; │ │ │ │ + var root = this.vectorRoot; │ │ │ │ + if (root) { │ │ │ │ + while (child = root.firstChild) { │ │ │ │ + root.removeChild(child) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + root = this.textRoot; │ │ │ │ + if (root) { │ │ │ │ + while (child = root.firstChild) { │ │ │ │ + root.removeChild(child) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.indexer) { │ │ │ │ + this.indexer.clear() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setExtent: function(extent, resolutionChanged) { │ │ │ │ + var coordSysUnchanged = OpenLayers.Renderer.prototype.setExtent.apply(this, arguments); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) { │ │ │ │ + var rightOfDateLine, ratio = extent.getWidth() / this.map.getExtent().getWidth(), │ │ │ │ + extent = extent.scale(1 / ratio), │ │ │ │ + world = this.map.getMaxExtent(); │ │ │ │ + if (world.right > extent.left && world.right < extent.right) { │ │ │ │ + rightOfDateLine = true │ │ │ │ + } else if (world.left > extent.left && world.left < extent.right) { │ │ │ │ + rightOfDateLine = false │ │ │ │ + } │ │ │ │ + if (rightOfDateLine !== this.rightOfDateLine || resolutionChanged) { │ │ │ │ + coordSysUnchanged = false; │ │ │ │ + this.xOffset = rightOfDateLine === true ? world.getWidth() / resolution : 0 │ │ │ │ + } │ │ │ │ + this.rightOfDateLine = rightOfDateLine │ │ │ │ + } │ │ │ │ + return coordSysUnchanged │ │ │ │ + }, │ │ │ │ + getNodeType: function(geometry, style) {}, │ │ │ │ + drawGeometry: function(geometry, style, featureId) { │ │ │ │ + var className = geometry.CLASS_NAME; │ │ │ │ + var rendered = true; │ │ │ │ + if (className == "OpenLayers.Geometry.Collection" || className == "OpenLayers.Geometry.MultiPoint" || className == "OpenLayers.Geometry.MultiLineString" || className == "OpenLayers.Geometry.MultiPolygon") { │ │ │ │ + for (var i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ + rendered = this.drawGeometry(geometry.components[i], style, featureId) && rendered │ │ │ │ + } │ │ │ │ + return rendered │ │ │ │ + } │ │ │ │ + rendered = false; │ │ │ │ + var removeBackground = false; │ │ │ │ + if (style.display != "none") { │ │ │ │ + if (style.backgroundGraphic) { │ │ │ │ + this.redrawBackgroundNode(geometry.id, geometry, style, featureId) │ │ │ │ + } else { │ │ │ │ + removeBackground = true │ │ │ │ + } │ │ │ │ + rendered = this.redrawNode(geometry.id, geometry, style, featureId) │ │ │ │ + } │ │ │ │ + if (rendered == false) { │ │ │ │ + var node = document.getElementById(geometry.id); │ │ │ │ + if (node) { │ │ │ │ + if (node._style.backgroundGraphic) { │ │ │ │ + removeBackground = true │ │ │ │ } │ │ │ │ - return true; │ │ │ │ - case OpenLayers.Filter.Logical.OR: │ │ │ │ - for (i = 0, len = this.filters.length; i < len; i++) { │ │ │ │ - if (this.filters[i].evaluate(context) == true) { │ │ │ │ - return true │ │ │ │ + node.parentNode.removeChild(node) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (removeBackground) { │ │ │ │ + var node = document.getElementById(geometry.id + this.BACKGROUND_ID_SUFFIX); │ │ │ │ + if (node) { │ │ │ │ + node.parentNode.removeChild(node) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return rendered │ │ │ │ + }, │ │ │ │ + redrawNode: function(id, geometry, style, featureId) { │ │ │ │ + style = this.applyDefaultSymbolizer(style); │ │ │ │ + var node = this.nodeFactory(id, this.getNodeType(geometry, style)); │ │ │ │ + node._featureId = featureId; │ │ │ │ + node._boundsBottom = geometry.getBounds().bottom; │ │ │ │ + node._geometryClass = geometry.CLASS_NAME; │ │ │ │ + node._style = style; │ │ │ │ + var drawResult = this.drawGeometryNode(node, geometry, style); │ │ │ │ + if (drawResult === false) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + node = drawResult.node; │ │ │ │ + if (this.indexer) { │ │ │ │ + var insert = this.indexer.insert(node); │ │ │ │ + if (insert) { │ │ │ │ + this.vectorRoot.insertBefore(node, insert) │ │ │ │ + } else { │ │ │ │ + this.vectorRoot.appendChild(node) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (node.parentNode !== this.vectorRoot) { │ │ │ │ + this.vectorRoot.appendChild(node) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.postDraw(node); │ │ │ │ + return drawResult.complete │ │ │ │ + }, │ │ │ │ + redrawBackgroundNode: function(id, geometry, style, featureId) { │ │ │ │ + var backgroundStyle = OpenLayers.Util.extend({}, style); │ │ │ │ + backgroundStyle.externalGraphic = backgroundStyle.backgroundGraphic; │ │ │ │ + backgroundStyle.graphicXOffset = backgroundStyle.backgroundXOffset; │ │ │ │ + backgroundStyle.graphicYOffset = backgroundStyle.backgroundYOffset; │ │ │ │ + backgroundStyle.graphicZIndex = backgroundStyle.backgroundGraphicZIndex; │ │ │ │ + backgroundStyle.graphicWidth = backgroundStyle.backgroundWidth || backgroundStyle.graphicWidth; │ │ │ │ + backgroundStyle.graphicHeight = backgroundStyle.backgroundHeight || backgroundStyle.graphicHeight; │ │ │ │ + backgroundStyle.backgroundGraphic = null; │ │ │ │ + backgroundStyle.backgroundXOffset = null; │ │ │ │ + backgroundStyle.backgroundYOffset = null; │ │ │ │ + backgroundStyle.backgroundGraphicZIndex = null; │ │ │ │ + return this.redrawNode(id + this.BACKGROUND_ID_SUFFIX, geometry, backgroundStyle, null) │ │ │ │ + }, │ │ │ │ + drawGeometryNode: function(node, geometry, style) { │ │ │ │ + style = style || node._style; │ │ │ │ + var options = { │ │ │ │ + isFilled: style.fill === undefined ? true : style.fill, │ │ │ │ + isStroked: style.stroke === undefined ? !!style.strokeWidth : style.stroke │ │ │ │ + }; │ │ │ │ + var drawn; │ │ │ │ + switch (geometry.CLASS_NAME) { │ │ │ │ + case "OpenLayers.Geometry.Point": │ │ │ │ + if (style.graphic === false) { │ │ │ │ + options.isFilled = false; │ │ │ │ + options.isStroked = false │ │ │ │ + } │ │ │ │ + drawn = this.drawPoint(node, geometry); │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.LineString": │ │ │ │ + options.isFilled = false; │ │ │ │ + drawn = this.drawLineString(node, geometry); │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.LinearRing": │ │ │ │ + drawn = this.drawLinearRing(node, geometry); │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.Polygon": │ │ │ │ + drawn = this.drawPolygon(node, geometry); │ │ │ │ + break; │ │ │ │ + case "OpenLayers.Geometry.Rectangle": │ │ │ │ + drawn = this.drawRectangle(node, geometry); │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + break │ │ │ │ + } │ │ │ │ + node._options = options; │ │ │ │ + if (drawn != false) { │ │ │ │ + return { │ │ │ │ + node: this.setStyle(node, style, options, geometry), │ │ │ │ + complete: drawn │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + postDraw: function(node) {}, │ │ │ │ + drawPoint: function(node, geometry) {}, │ │ │ │ + drawLineString: function(node, geometry) {}, │ │ │ │ + drawLinearRing: function(node, geometry) {}, │ │ │ │ + drawPolygon: function(node, geometry) {}, │ │ │ │ + drawRectangle: function(node, geometry) {}, │ │ │ │ + drawCircle: function(node, geometry) {}, │ │ │ │ + removeText: function(featureId) { │ │ │ │ + var label = document.getElementById(featureId + this.LABEL_ID_SUFFIX); │ │ │ │ + if (label) { │ │ │ │ + this.textRoot.removeChild(label) │ │ │ │ + } │ │ │ │ + var outline = document.getElementById(featureId + this.LABEL_OUTLINE_SUFFIX); │ │ │ │ + if (outline) { │ │ │ │ + this.textRoot.removeChild(outline) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getFeatureIdFromEvent: function(evt) { │ │ │ │ + var target = evt.target; │ │ │ │ + var useElement = target && target.correspondingUseElement; │ │ │ │ + var node = useElement ? useElement : target || evt.srcElement; │ │ │ │ + return node._featureId │ │ │ │ + }, │ │ │ │ + eraseGeometry: function(geometry, featureId) { │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint" || geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString" || geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon" || geometry.CLASS_NAME == "OpenLayers.Geometry.Collection") { │ │ │ │ + for (var i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ + this.eraseGeometry(geometry.components[i], featureId) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + var element = OpenLayers.Util.getElement(geometry.id); │ │ │ │ + if (element && element.parentNode) { │ │ │ │ + if (element.geometry) { │ │ │ │ + element.geometry.destroy(); │ │ │ │ + element.geometry = null │ │ │ │ + } │ │ │ │ + element.parentNode.removeChild(element); │ │ │ │ + if (this.indexer) { │ │ │ │ + this.indexer.remove(element) │ │ │ │ + } │ │ │ │ + if (element._style.backgroundGraphic) { │ │ │ │ + var backgroundId = geometry.id + this.BACKGROUND_ID_SUFFIX; │ │ │ │ + var bElem = OpenLayers.Util.getElement(backgroundId); │ │ │ │ + if (bElem && bElem.parentNode) { │ │ │ │ + bElem.parentNode.removeChild(bElem) │ │ │ │ } │ │ │ │ } │ │ │ │ - return false; │ │ │ │ - case OpenLayers.Filter.Logical.NOT: │ │ │ │ - return !this.filters[0].evaluate(context) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return undefined │ │ │ │ }, │ │ │ │ - clone: function() { │ │ │ │ - var filters = []; │ │ │ │ - for (var i = 0, len = this.filters.length; i < len; ++i) { │ │ │ │ - filters.push(this.filters[i].clone()) │ │ │ │ + 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 new OpenLayers.Filter.Logical({ │ │ │ │ - type: this.type, │ │ │ │ - filters: filters │ │ │ │ - }) │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Filter.Logical" │ │ │ │ + nodeTypeCompare: function(node, type) {}, │ │ │ │ + createNode: function(type, id) {}, │ │ │ │ + moveRoot: function(renderer) { │ │ │ │ + var root = this.root; │ │ │ │ + if (renderer.root.parentNode == this.rendererRoot) { │ │ │ │ + root = renderer.root │ │ │ │ + } │ │ │ │ + root.parentNode.removeChild(root); │ │ │ │ + renderer.rendererRoot.appendChild(root) │ │ │ │ + }, │ │ │ │ + getRenderLayerId: function() { │ │ │ │ + return this.root.parentNode.parentNode.id │ │ │ │ + }, │ │ │ │ + isComplexSymbol: function(graphicName) { │ │ │ │ + return graphicName != "circle" && !!graphicName │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.Elements" │ │ │ │ }); │ │ │ │ -OpenLayers.Filter.Logical.AND = "&&"; │ │ │ │ -OpenLayers.Filter.Logical.OR = "||"; │ │ │ │ -OpenLayers.Filter.Logical.NOT = "!"; │ │ │ │ -OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, { │ │ │ │ - type: null, │ │ │ │ - property: null, │ │ │ │ - value: null, │ │ │ │ - matchCase: true, │ │ │ │ - lowerBoundary: null, │ │ │ │ - upperBoundary: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Filter.prototype.initialize.apply(this, [options]); │ │ │ │ - if (this.type === OpenLayers.Filter.Comparison.LIKE && options.matchCase === undefined) { │ │ │ │ - this.matchCase = null │ │ │ │ +OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ + xmlns: "urn:schemas-microsoft-com:vml", │ │ │ │ + symbolCache: {}, │ │ │ │ + offset: null, │ │ │ │ + initialize: function(containerID) { │ │ │ │ + if (!this.supported()) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if (!document.namespaces.olv) { │ │ │ │ + document.namespaces.add("olv", this.xmlns); │ │ │ │ + var style = document.createStyleSheet(); │ │ │ │ + var shapes = ["shape", "rect", "oval", "fill", "stroke", "imagedata", "group", "textbox"]; │ │ │ │ + for (var i = 0, len = shapes.length; i < len; i++) { │ │ │ │ + style.addRule("olv\\:" + shapes[i], "behavior: url(#default#VML); " + "position: absolute; display: inline-block;") │ │ │ │ + } │ │ │ │ } │ │ │ │ + OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments) │ │ │ │ }, │ │ │ │ - evaluate: function(context) { │ │ │ │ - if (context instanceof OpenLayers.Feature.Vector) { │ │ │ │ - context = context.attributes │ │ │ │ + supported: function() { │ │ │ │ + return !!document.namespaces │ │ │ │ + }, │ │ │ │ + setExtent: function(extent, resolutionChanged) { │ │ │ │ + var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var left = extent.left / resolution | 0; │ │ │ │ + var top = extent.top / resolution - this.size.h | 0; │ │ │ │ + if (resolutionChanged || !this.offset) { │ │ │ │ + this.offset = { │ │ │ │ + x: left, │ │ │ │ + y: top │ │ │ │ + }; │ │ │ │ + left = 0; │ │ │ │ + top = 0 │ │ │ │ + } else { │ │ │ │ + left = left - this.offset.x; │ │ │ │ + top = top - this.offset.y │ │ │ │ } │ │ │ │ - var result = false; │ │ │ │ - var got = context[this.property]; │ │ │ │ - var exp; │ │ │ │ - switch (this.type) { │ │ │ │ - case OpenLayers.Filter.Comparison.EQUAL_TO: │ │ │ │ - exp = this.value; │ │ │ │ - if (!this.matchCase && typeof got == "string" && typeof exp == "string") { │ │ │ │ - result = got.toUpperCase() == exp.toUpperCase() │ │ │ │ + var org = left - this.xOffset + " " + top; │ │ │ │ + this.root.coordorigin = org; │ │ │ │ + var roots = [this.root, this.vectorRoot, this.textRoot]; │ │ │ │ + var root; │ │ │ │ + for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ + root = roots[i]; │ │ │ │ + var size = this.size.w + " " + this.size.h; │ │ │ │ + root.coordsize = size │ │ │ │ + } │ │ │ │ + this.root.style.flip = "y"; │ │ │ │ + return coordSysUnchanged │ │ │ │ + }, │ │ │ │ + setSize: function(size) { │ │ │ │ + OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ + var roots = [this.rendererRoot, this.root, this.vectorRoot, this.textRoot]; │ │ │ │ + var w = this.size.w + "px"; │ │ │ │ + var h = this.size.h + "px"; │ │ │ │ + var root; │ │ │ │ + for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ + root = roots[i]; │ │ │ │ + root.style.width = w; │ │ │ │ + root.style.height = h │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getNodeType: function(geometry, style) { │ │ │ │ + var nodeType = null; │ │ │ │ + switch (geometry.CLASS_NAME) { │ │ │ │ + case "OpenLayers.Geometry.Point": │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + nodeType = "olv:rect" │ │ │ │ + } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ + nodeType = "olv:shape" │ │ │ │ } else { │ │ │ │ - result = got == exp │ │ │ │ + nodeType = "olv:oval" │ │ │ │ } │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.NOT_EQUAL_TO: │ │ │ │ - exp = this.value; │ │ │ │ - if (!this.matchCase && typeof got == "string" && typeof exp == "string") { │ │ │ │ - result = got.toUpperCase() != exp.toUpperCase() │ │ │ │ - } else { │ │ │ │ - result = got != exp │ │ │ │ - } │ │ │ │ + case "OpenLayers.Geometry.Rectangle": │ │ │ │ + nodeType = "olv:rect"; │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.LESS_THAN: │ │ │ │ - result = got < this.value; │ │ │ │ + case "OpenLayers.Geometry.LineString": │ │ │ │ + case "OpenLayers.Geometry.LinearRing": │ │ │ │ + case "OpenLayers.Geometry.Polygon": │ │ │ │ + case "OpenLayers.Geometry.Curve": │ │ │ │ + nodeType = "olv:shape"; │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.GREATER_THAN: │ │ │ │ - result = got > this.value; │ │ │ │ + default: │ │ │ │ + break │ │ │ │ + } │ │ │ │ + return nodeType │ │ │ │ + }, │ │ │ │ + setStyle: function(node, style, options, geometry) { │ │ │ │ + style = style || node._style; │ │ │ │ + options = options || node._options; │ │ │ │ + var fillColor = style.fillColor; │ │ │ │ + var title = style.title || style.graphicTitle; │ │ │ │ + if (title) { │ │ │ │ + node.title = title │ │ │ │ + } │ │ │ │ + if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + options.isFilled = true; │ │ │ │ + var width = style.graphicWidth || style.graphicHeight; │ │ │ │ + var height = style.graphicHeight || style.graphicWidth; │ │ │ │ + width = width ? width : style.pointRadius * 2; │ │ │ │ + height = height ? height : style.pointRadius * 2; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var xOffset = style.graphicXOffset != undefined ? style.graphicXOffset : -(.5 * width); │ │ │ │ + var yOffset = style.graphicYOffset != undefined ? style.graphicYOffset : -(.5 * height); │ │ │ │ + node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x + xOffset | 0) + "px"; │ │ │ │ + node.style.top = (geometry.y / resolution - this.offset.y - (yOffset + height) | 0) + "px"; │ │ │ │ + node.style.width = width + "px"; │ │ │ │ + node.style.height = height + "px"; │ │ │ │ + node.style.flip = "y"; │ │ │ │ + fillColor = "none"; │ │ │ │ + options.isStroked = false │ │ │ │ + } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ + var cache = this.importSymbol(style.graphicName); │ │ │ │ + node.path = cache.path; │ │ │ │ + node.coordorigin = cache.left + "," + cache.bottom; │ │ │ │ + var size = cache.size; │ │ │ │ + node.coordsize = size + "," + size; │ │ │ │ + this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ + node.style.flip = "y" │ │ │ │ + } else { │ │ │ │ + this.drawCircle(node, geometry, style.pointRadius) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (options.isFilled) { │ │ │ │ + node.fillcolor = fillColor │ │ │ │ + } else { │ │ │ │ + node.filled = "false" │ │ │ │ + } │ │ │ │ + var fills = node.getElementsByTagName("fill"); │ │ │ │ + var fill = fills.length == 0 ? null : fills[0]; │ │ │ │ + if (!options.isFilled) { │ │ │ │ + if (fill) { │ │ │ │ + node.removeChild(fill) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!fill) { │ │ │ │ + fill = this.createNode("olv:fill", node.id + "_fill") │ │ │ │ + } │ │ │ │ + fill.opacity = style.fillOpacity; │ │ │ │ + if (node._geometryClass === "OpenLayers.Geometry.Point" && style.externalGraphic) { │ │ │ │ + if (style.graphicOpacity) { │ │ │ │ + fill.opacity = style.graphicOpacity │ │ │ │ + } │ │ │ │ + fill.src = style.externalGraphic; │ │ │ │ + fill.type = "frame"; │ │ │ │ + if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ + fill.aspect = "atmost" │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (fill.parentNode != node) { │ │ │ │ + node.appendChild(fill) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var rotation = style.rotation; │ │ │ │ + if (rotation !== undefined || node._rotation !== undefined) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ + fill.opacity = 0 │ │ │ │ + } else if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ + node.style.rotation = rotation || 0 │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var strokes = node.getElementsByTagName("stroke"); │ │ │ │ + var stroke = strokes.length == 0 ? null : strokes[0]; │ │ │ │ + if (!options.isStroked) { │ │ │ │ + node.stroked = false; │ │ │ │ + if (stroke) { │ │ │ │ + stroke.on = false │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!stroke) { │ │ │ │ + stroke = this.createNode("olv:stroke", node.id + "_stroke"); │ │ │ │ + node.appendChild(stroke) │ │ │ │ + } │ │ │ │ + stroke.on = true; │ │ │ │ + stroke.color = style.strokeColor; │ │ │ │ + stroke.weight = style.strokeWidth + "px"; │ │ │ │ + stroke.opacity = style.strokeOpacity; │ │ │ │ + stroke.endcap = style.strokeLinecap == "butt" ? "flat" : style.strokeLinecap || "round"; │ │ │ │ + if (style.strokeDashstyle) { │ │ │ │ + stroke.dashstyle = this.dashStyle(style) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ + node.style.cursor = style.cursor │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + graphicRotate: function(node, xOffset, yOffset, style) { │ │ │ │ + var style = style || node._style; │ │ │ │ + var rotation = style.rotation || 0; │ │ │ │ + var aspectRatio, size; │ │ │ │ + if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ + var img = new Image; │ │ │ │ + img.onreadystatechange = OpenLayers.Function.bind(function() { │ │ │ │ + if (img.readyState == "complete" || img.readyState == "interactive") { │ │ │ │ + aspectRatio = img.width / img.height; │ │ │ │ + size = Math.max(style.pointRadius * 2, style.graphicWidth || 0, style.graphicHeight || 0); │ │ │ │ + xOffset = xOffset * aspectRatio; │ │ │ │ + style.graphicWidth = size * aspectRatio; │ │ │ │ + style.graphicHeight = size; │ │ │ │ + this.graphicRotate(node, xOffset, yOffset, style) │ │ │ │ + } │ │ │ │ + }, this); │ │ │ │ + img.src = style.externalGraphic; │ │ │ │ + return │ │ │ │ + } else { │ │ │ │ + size = Math.max(style.graphicWidth, style.graphicHeight); │ │ │ │ + aspectRatio = style.graphicWidth / style.graphicHeight │ │ │ │ + } │ │ │ │ + var width = Math.round(style.graphicWidth || size * aspectRatio); │ │ │ │ + var height = Math.round(style.graphicHeight || size); │ │ │ │ + node.style.width = width + "px"; │ │ │ │ + node.style.height = height + "px"; │ │ │ │ + var image = document.getElementById(node.id + "_image"); │ │ │ │ + if (!image) { │ │ │ │ + image = this.createNode("olv:imagedata", node.id + "_image"); │ │ │ │ + node.appendChild(image) │ │ │ │ + } │ │ │ │ + image.style.width = width + "px"; │ │ │ │ + image.style.height = height + "px"; │ │ │ │ + image.src = style.externalGraphic; │ │ │ │ + image.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + "src='', sizingMethod='scale')"; │ │ │ │ + var rot = rotation * Math.PI / 180; │ │ │ │ + var sintheta = Math.sin(rot); │ │ │ │ + var costheta = Math.cos(rot); │ │ │ │ + var filter = "progid:DXImageTransform.Microsoft.Matrix(M11=" + costheta + ",M12=" + -sintheta + ",M21=" + sintheta + ",M22=" + costheta + ",SizingMethod='auto expand')\n"; │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ + if (opacity && opacity != 1) { │ │ │ │ + filter += "progid:DXImageTransform.Microsoft.BasicImage(opacity=" + opacity + ")\n" │ │ │ │ + } │ │ │ │ + node.style.filter = filter; │ │ │ │ + var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset); │ │ │ │ + var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry(); │ │ │ │ + imgBox.rotate(style.rotation, centerPoint); │ │ │ │ + var imgBounds = imgBox.getBounds(); │ │ │ │ + node.style.left = Math.round(parseInt(node.style.left) + imgBounds.left) + "px"; │ │ │ │ + node.style.top = Math.round(parseInt(node.style.top) - imgBounds.bottom) + "px" │ │ │ │ + }, │ │ │ │ + postDraw: function(node) { │ │ │ │ + node.style.visibility = "visible"; │ │ │ │ + var fillColor = node._style.fillColor; │ │ │ │ + var strokeColor = node._style.strokeColor; │ │ │ │ + if (fillColor == "none" && node.fillcolor != fillColor) { │ │ │ │ + node.fillcolor = fillColor │ │ │ │ + } │ │ │ │ + if (strokeColor == "none" && node.strokecolor != strokeColor) { │ │ │ │ + node.strokecolor = strokeColor │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setNodeDimension: function(node, geometry) { │ │ │ │ + var bbox = geometry.getBounds(); │ │ │ │ + if (bbox) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var scaledBox = new OpenLayers.Bounds((bbox.left - this.featureDx) / resolution - this.offset.x | 0, bbox.bottom / resolution - this.offset.y | 0, (bbox.right - this.featureDx) / resolution - this.offset.x | 0, bbox.top / resolution - this.offset.y | 0); │ │ │ │ + node.style.left = scaledBox.left + "px"; │ │ │ │ + node.style.top = scaledBox.top + "px"; │ │ │ │ + node.style.width = scaledBox.getWidth() + "px"; │ │ │ │ + node.style.height = scaledBox.getHeight() + "px"; │ │ │ │ + node.coordorigin = scaledBox.left + " " + scaledBox.top; │ │ │ │ + node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + dashStyle: function(style) { │ │ │ │ + var dash = style.strokeDashstyle; │ │ │ │ + switch (dash) { │ │ │ │ + case "solid": │ │ │ │ + case "dot": │ │ │ │ + case "dash": │ │ │ │ + case "dashdot": │ │ │ │ + case "longdash": │ │ │ │ + case "longdashdot": │ │ │ │ + return dash; │ │ │ │ + default: │ │ │ │ + var parts = dash.split(/[ ,]/); │ │ │ │ + if (parts.length == 2) { │ │ │ │ + if (1 * parts[0] >= 2 * parts[1]) { │ │ │ │ + return "longdash" │ │ │ │ + } │ │ │ │ + return parts[0] == 1 || parts[1] == 1 ? "dot" : "dash" │ │ │ │ + } else if (parts.length == 4) { │ │ │ │ + return 1 * parts[0] >= 2 * parts[1] ? "longdashdot" : "dashdot" │ │ │ │ + } │ │ │ │ + return "solid" │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + createNode: function(type, id) { │ │ │ │ + var node = document.createElement(type); │ │ │ │ + if (id) { │ │ │ │ + node.id = id │ │ │ │ + } │ │ │ │ + node.unselectable = "on"; │ │ │ │ + node.onselectstart = OpenLayers.Function.False; │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + nodeTypeCompare: function(node, type) { │ │ │ │ + var subType = type; │ │ │ │ + var splitIndex = subType.indexOf(":"); │ │ │ │ + if (splitIndex != -1) { │ │ │ │ + subType = subType.substr(splitIndex + 1) │ │ │ │ + } │ │ │ │ + var nodeName = node.nodeName; │ │ │ │ + splitIndex = nodeName.indexOf(":"); │ │ │ │ + if (splitIndex != -1) { │ │ │ │ + nodeName = nodeName.substr(splitIndex + 1) │ │ │ │ + } │ │ │ │ + return subType == nodeName │ │ │ │ + }, │ │ │ │ + createRenderRoot: function() { │ │ │ │ + return this.nodeFactory(this.container.id + "_vmlRoot", "div") │ │ │ │ + }, │ │ │ │ + createRoot: function(suffix) { │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "olv:group") │ │ │ │ + }, │ │ │ │ + drawPoint: function(node, geometry) { │ │ │ │ + return this.drawCircle(node, geometry, 1) │ │ │ │ + }, │ │ │ │ + drawCircle: function(node, geometry, radius) { │ │ │ │ + if (!isNaN(geometry.x) && !isNaN(geometry.y)) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) - radius + "px"; │ │ │ │ + node.style.top = (geometry.y / resolution - this.offset.y | 0) - radius + "px"; │ │ │ │ + var diameter = radius * 2; │ │ │ │ + node.style.width = diameter + "px"; │ │ │ │ + node.style.height = diameter + "px"; │ │ │ │ + return node │ │ │ │ + } │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + drawLineString: function(node, geometry) { │ │ │ │ + return this.drawLine(node, geometry, false) │ │ │ │ + }, │ │ │ │ + drawLinearRing: function(node, geometry) { │ │ │ │ + return this.drawLine(node, geometry, true) │ │ │ │ + }, │ │ │ │ + drawLine: function(node, geometry, closeLine) { │ │ │ │ + this.setNodeDimension(node, geometry); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var numComponents = geometry.components.length; │ │ │ │ + var parts = new Array(numComponents); │ │ │ │ + var comp, x, y; │ │ │ │ + for (var i = 0; i < numComponents; i++) { │ │ │ │ + comp = geometry.components[i]; │ │ │ │ + x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ + y = comp.y / resolution - this.offset.y | 0; │ │ │ │ + parts[i] = " " + x + "," + y + " l " │ │ │ │ + } │ │ │ │ + var end = closeLine ? " x e" : " e"; │ │ │ │ + node.path = "m" + parts.join("") + end; │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + drawPolygon: function(node, geometry) { │ │ │ │ + this.setNodeDimension(node, geometry); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var path = []; │ │ │ │ + var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y; │ │ │ │ + for (j = 0, jj = geometry.components.length; j < jj; j++) { │ │ │ │ + path.push("m"); │ │ │ │ + points = geometry.components[j].components; │ │ │ │ + area = j === 0; │ │ │ │ + first = null; │ │ │ │ + second = null; │ │ │ │ + for (i = 0, ii = points.length; i < ii; i++) { │ │ │ │ + comp = points[i]; │ │ │ │ + x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ + y = comp.y / resolution - this.offset.y | 0; │ │ │ │ + pathComp = " " + x + "," + y; │ │ │ │ + path.push(pathComp); │ │ │ │ + if (i == 0) { │ │ │ │ + path.push(" l") │ │ │ │ + } │ │ │ │ + if (!area) { │ │ │ │ + if (!first) { │ │ │ │ + first = pathComp │ │ │ │ + } else if (first != pathComp) { │ │ │ │ + if (!second) { │ │ │ │ + second = pathComp │ │ │ │ + } else if (second != pathComp) { │ │ │ │ + area = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + path.push(area ? " x " : " ") │ │ │ │ + } │ │ │ │ + path.push("e"); │ │ │ │ + node.path = path.join(""); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + drawRectangle: function(node, geometry) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ + node.style.top = (geometry.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ + node.style.width = (geometry.width / resolution | 0) + "px"; │ │ │ │ + node.style.height = (geometry.height / resolution | 0) + "px"; │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + drawText: function(featureId, style, location) { │ │ │ │ + var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect"); │ │ │ │ + var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox"); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + label.style.left = ((location.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ + label.style.top = (location.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ + label.style.flip = "y"; │ │ │ │ + textbox.innerText = style.label; │ │ │ │ + if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ + textbox.style.cursor = style.cursor │ │ │ │ + } │ │ │ │ + if (style.fontColor) { │ │ │ │ + textbox.style.color = style.fontColor │ │ │ │ + } │ │ │ │ + if (style.fontOpacity) { │ │ │ │ + textbox.style.filter = "alpha(opacity=" + style.fontOpacity * 100 + ")" │ │ │ │ + } │ │ │ │ + if (style.fontFamily) { │ │ │ │ + textbox.style.fontFamily = style.fontFamily │ │ │ │ + } │ │ │ │ + if (style.fontSize) { │ │ │ │ + textbox.style.fontSize = style.fontSize │ │ │ │ + } │ │ │ │ + if (style.fontWeight) { │ │ │ │ + textbox.style.fontWeight = style.fontWeight │ │ │ │ + } │ │ │ │ + if (style.fontStyle) { │ │ │ │ + textbox.style.fontStyle = style.fontStyle │ │ │ │ + } │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + label._featureId = featureId; │ │ │ │ + textbox._featureId = featureId; │ │ │ │ + textbox._geometry = location; │ │ │ │ + textbox._geometryClass = location.CLASS_NAME │ │ │ │ + } │ │ │ │ + textbox.style.whiteSpace = "nowrap"; │ │ │ │ + textbox.inset = "1px,0px,0px,0px"; │ │ │ │ + if (!label.parentNode) { │ │ │ │ + label.appendChild(textbox); │ │ │ │ + this.textRoot.appendChild(label) │ │ │ │ + } │ │ │ │ + var align = style.labelAlign || "cm"; │ │ │ │ + if (align.length == 1) { │ │ │ │ + align += "m" │ │ │ │ + } │ │ │ │ + var xshift = textbox.clientWidth * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)]; │ │ │ │ + var yshift = textbox.clientHeight * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)]; │ │ │ │ + label.style.left = parseInt(label.style.left) - xshift - 1 + "px"; │ │ │ │ + label.style.top = parseInt(label.style.top) + yshift + "px" │ │ │ │ + }, │ │ │ │ + moveRoot: function(renderer) { │ │ │ │ + var layer = this.map.getLayer(renderer.container.id); │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector.RootContainer) { │ │ │ │ + layer = this.map.getLayer(this.container.id) │ │ │ │ + } │ │ │ │ + layer && layer.renderer.clear(); │ │ │ │ + OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments); │ │ │ │ + layer && layer.redraw() │ │ │ │ + }, │ │ │ │ + importSymbol: function(graphicName) { │ │ │ │ + var id = this.container.id + "-" + graphicName; │ │ │ │ + var cache = this.symbolCache[id]; │ │ │ │ + if (cache) { │ │ │ │ + return cache │ │ │ │ + } │ │ │ │ + var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ + if (!symbol) { │ │ │ │ + throw new Error(graphicName + " is not a valid symbol name") │ │ │ │ + } │ │ │ │ + var symbolExtent = new OpenLayers.Bounds(Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ + var pathitems = ["m"]; │ │ │ │ + for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ + var x = symbol[i]; │ │ │ │ + var y = symbol[i + 1]; │ │ │ │ + symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ + symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ + symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ + symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ + pathitems.push(x); │ │ │ │ + pathitems.push(y); │ │ │ │ + if (i == 0) { │ │ │ │ + pathitems.push("l") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + pathitems.push("x e"); │ │ │ │ + var path = pathitems.join(" "); │ │ │ │ + var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2; │ │ │ │ + if (diff > 0) { │ │ │ │ + symbolExtent.bottom = symbolExtent.bottom - diff; │ │ │ │ + symbolExtent.top = symbolExtent.top + diff │ │ │ │ + } else { │ │ │ │ + symbolExtent.left = symbolExtent.left + diff; │ │ │ │ + symbolExtent.right = symbolExtent.right - diff │ │ │ │ + } │ │ │ │ + cache = { │ │ │ │ + path: path, │ │ │ │ + size: symbolExtent.getWidth(), │ │ │ │ + left: symbolExtent.left, │ │ │ │ + bottom: symbolExtent.bottom │ │ │ │ + }; │ │ │ │ + this.symbolCache[id] = cache; │ │ │ │ + return cache │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.VML" │ │ │ │ +}); │ │ │ │ +OpenLayers.Renderer.VML.LABEL_SHIFT = { │ │ │ │ + l: 0, │ │ │ │ + c: .5, │ │ │ │ + r: 1, │ │ │ │ + t: 0, │ │ │ │ + m: .5, │ │ │ │ + b: 1 │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ + xmlns: "http://www.w3.org/2000/svg", │ │ │ │ + xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ + MAX_PIXEL: 15e3, │ │ │ │ + translationParameters: null, │ │ │ │ + symbolMetrics: null, │ │ │ │ + initialize: function(containerID) { │ │ │ │ + if (!this.supported()) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: 0, │ │ │ │ + y: 0 │ │ │ │ + }; │ │ │ │ + this.symbolMetrics = {} │ │ │ │ + }, │ │ │ │ + supported: function() { │ │ │ │ + var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ + return document.implementation && (document.implementation.hasFeature("org.w3c.svg", "1.0") || document.implementation.hasFeature(svgFeature + "SVG", "1.1") || document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1")) │ │ │ │ + }, │ │ │ │ + inValidRange: function(x, y, xyOnly) { │ │ │ │ + var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ + var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ + return left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL │ │ │ │ + }, │ │ │ │ + setExtent: function(extent, resolutionChanged) { │ │ │ │ + var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ + var resolution = this.getResolution(), │ │ │ │ + left = -extent.left / resolution, │ │ │ │ + top = extent.top / resolution; │ │ │ │ + if (resolutionChanged) { │ │ │ │ + this.left = left; │ │ │ │ + this.top = top; │ │ │ │ + var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ + this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ + this.translate(this.xOffset, 0); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ + if (!inRange) { │ │ │ │ + this.setExtent(extent, true) │ │ │ │ + } │ │ │ │ + return coordSysUnchanged && inRange │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + translate: function(x, y) { │ │ │ │ + if (!this.inValidRange(x, y, true)) { │ │ │ │ + return false │ │ │ │ + } else { │ │ │ │ + var transformString = ""; │ │ │ │ + if (x || y) { │ │ │ │ + transformString = "translate(" + x + "," + y + ")" │ │ │ │ + } │ │ │ │ + this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: x, │ │ │ │ + y: y │ │ │ │ + }; │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setSize: function(size) { │ │ │ │ + OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ + this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ + this.rendererRoot.setAttributeNS(null, "height", this.size.h) │ │ │ │ + }, │ │ │ │ + getNodeType: function(geometry, style) { │ │ │ │ + var nodeType = null; │ │ │ │ + switch (geometry.CLASS_NAME) { │ │ │ │ + case "OpenLayers.Geometry.Point": │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + nodeType = "image" │ │ │ │ + } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ + nodeType = "svg" │ │ │ │ + } else { │ │ │ │ + nodeType = "circle" │ │ │ │ + } │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO: │ │ │ │ - result = got <= this.value; │ │ │ │ + case "OpenLayers.Geometry.Rectangle": │ │ │ │ + nodeType = "rect"; │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO: │ │ │ │ - result = got >= this.value; │ │ │ │ + case "OpenLayers.Geometry.LineString": │ │ │ │ + nodeType = "polyline"; │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.BETWEEN: │ │ │ │ - result = got >= this.lowerBoundary && got <= this.upperBoundary; │ │ │ │ + case "OpenLayers.Geometry.LinearRing": │ │ │ │ + nodeType = "polygon"; │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.LIKE: │ │ │ │ - var regexp = new RegExp(this.value, "gi"); │ │ │ │ - result = regexp.test(got); │ │ │ │ + case "OpenLayers.Geometry.Polygon": │ │ │ │ + case "OpenLayers.Geometry.Curve": │ │ │ │ + nodeType = "path"; │ │ │ │ break; │ │ │ │ - case OpenLayers.Filter.Comparison.IS_NULL: │ │ │ │ - result = got === null; │ │ │ │ + default: │ │ │ │ break │ │ │ │ } │ │ │ │ - return result │ │ │ │ + return nodeType │ │ │ │ }, │ │ │ │ - value2regex: function(wildCard, singleChar, escapeChar) { │ │ │ │ - if (wildCard == ".") { │ │ │ │ - throw new Error("'.' is an unsupported wildCard character for " + "OpenLayers.Filter.Comparison") │ │ │ │ + setStyle: function(node, style, options) { │ │ │ │ + style = style || node._style; │ │ │ │ + options = options || node._options; │ │ │ │ + var title = style.title || style.graphicTitle; │ │ │ │ + if (title) { │ │ │ │ + node.setAttributeNS(null, "title", title); │ │ │ │ + var titleNode = node.getElementsByTagName("title"); │ │ │ │ + if (titleNode.length > 0) { │ │ │ │ + titleNode[0].firstChild.textContent = title │ │ │ │ + } else { │ │ │ │ + var label = this.nodeFactory(null, "title"); │ │ │ │ + label.textContent = title; │ │ │ │ + node.appendChild(label) │ │ │ │ + } │ │ │ │ } │ │ │ │ - wildCard = wildCard ? wildCard : "*"; │ │ │ │ - singleChar = singleChar ? singleChar : "."; │ │ │ │ - escapeChar = escapeChar ? escapeChar : "!"; │ │ │ │ - this.value = this.value.replace(new RegExp("\\" + escapeChar + "(.|$)", "g"), "\\$1"); │ │ │ │ - this.value = this.value.replace(new RegExp("\\" + singleChar, "g"), "."); │ │ │ │ - this.value = this.value.replace(new RegExp("\\" + wildCard, "g"), ".*"); │ │ │ │ - this.value = this.value.replace(new RegExp("\\\\.\\*", "g"), "\\" + wildCard); │ │ │ │ - this.value = this.value.replace(new RegExp("\\\\\\.", "g"), "\\" + singleChar); │ │ │ │ - return this.value │ │ │ │ - }, │ │ │ │ - regex2value: function() { │ │ │ │ - var value = this.value; │ │ │ │ - value = value.replace(/!/g, "!!"); │ │ │ │ - value = value.replace(/(\\)?\\\./g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "!." │ │ │ │ - }); │ │ │ │ - value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "!*" │ │ │ │ - }); │ │ │ │ - value = value.replace(/\\\\/g, "\\"); │ │ │ │ - value = value.replace(/\.\*/g, "*"); │ │ │ │ - return value │ │ │ │ + var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ + var widthFactor = 1; │ │ │ │ + var pos; │ │ │ │ + if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ + node.style.visibility = ""; │ │ │ │ + if (style.graphic === false) { │ │ │ │ + node.style.visibility = "hidden" │ │ │ │ + } else if (style.externalGraphic) { │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + if (style.graphicWidth && style.graphicHeight) { │ │ │ │ + node.setAttributeNS(null, "preserveAspectRatio", "none") │ │ │ │ + } │ │ │ │ + var width = style.graphicWidth || style.graphicHeight; │ │ │ │ + var height = style.graphicHeight || style.graphicWidth; │ │ │ │ + width = width ? width : style.pointRadius * 2; │ │ │ │ + height = height ? height : style.pointRadius * 2; │ │ │ │ + var xOffset = style.graphicXOffset != undefined ? style.graphicXOffset : -(.5 * width); │ │ │ │ + var yOffset = style.graphicYOffset != undefined ? style.graphicYOffset : -(.5 * height); │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ + node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "width", width); │ │ │ │ + node.setAttributeNS(null, "height", height); │ │ │ │ + node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ + node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ + node.onclick = OpenLayers.Event.preventDefault │ │ │ │ + } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ + var offset = style.pointRadius * 3; │ │ │ │ + var size = offset * 2; │ │ │ │ + var src = this.importSymbol(style.graphicName); │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ + var parent = node.parentNode; │ │ │ │ + var nextSibling = node.nextSibling; │ │ │ │ + if (parent) { │ │ │ │ + parent.removeChild(node) │ │ │ │ + } │ │ │ │ + node.firstChild && node.removeChild(node.firstChild); │ │ │ │ + node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ + node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ + node.setAttributeNS(null, "width", size); │ │ │ │ + node.setAttributeNS(null, "height", size); │ │ │ │ + node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ + node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ + if (nextSibling) { │ │ │ │ + parent.insertBefore(node, nextSibling) │ │ │ │ + } else if (parent) { │ │ │ │ + parent.appendChild(node) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "r", style.pointRadius) │ │ │ │ + } │ │ │ │ + var rotation = style.rotation; │ │ │ │ + if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + rotation |= 0; │ │ │ │ + if (node.nodeName !== "svg") { │ │ │ │ + node.setAttributeNS(null, "transform", "rotate(" + rotation + " " + pos.x + " " + pos.y + ")") │ │ │ │ + } else { │ │ │ │ + var metrics = this.symbolMetrics[src.id]; │ │ │ │ + node.firstChild.setAttributeNS(null, "transform", "rotate(" + rotation + " " + metrics[1] + " " + metrics[2] + ")") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (options.isFilled) { │ │ │ │ + node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ + node.setAttributeNS(null, "fill-opacity", style.fillOpacity) │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "fill", "none") │ │ │ │ + } │ │ │ │ + if (options.isStroked) { │ │ │ │ + node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ + node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ + node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ + node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ + node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ + style.strokeDashstyle && node.setAttributeNS(null, "stroke-dasharray", this.dashStyle(style, widthFactor)) │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "stroke", "none") │ │ │ │ + } │ │ │ │ + if (style.pointerEvents) { │ │ │ │ + node.setAttributeNS(null, "pointer-events", style.pointerEvents) │ │ │ │ + } │ │ │ │ + if (style.cursor != null) { │ │ │ │ + node.setAttributeNS(null, "cursor", style.cursor) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - clone: function() { │ │ │ │ - return OpenLayers.Util.extend(new OpenLayers.Filter.Comparison, this) │ │ │ │ + dashStyle: function(style, widthFactor) { │ │ │ │ + var w = style.strokeWidth * widthFactor; │ │ │ │ + var str = style.strokeDashstyle; │ │ │ │ + switch (str) { │ │ │ │ + case "solid": │ │ │ │ + return "none"; │ │ │ │ + case "dot": │ │ │ │ + return [1, 4 * w].join(); │ │ │ │ + case "dash": │ │ │ │ + return [4 * w, 4 * w].join(); │ │ │ │ + case "dashdot": │ │ │ │ + return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ + case "longdash": │ │ │ │ + return [8 * w, 4 * w].join(); │ │ │ │ + case "longdashdot": │ │ │ │ + return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ + default: │ │ │ │ + return OpenLayers.String.trim(str).replace(/\s+/g, ",") │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Filter.Comparison" │ │ │ │ -}); │ │ │ │ -OpenLayers.Filter.Comparison.EQUAL_TO = "=="; │ │ │ │ -OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!="; │ │ │ │ -OpenLayers.Filter.Comparison.LESS_THAN = "<"; │ │ │ │ -OpenLayers.Filter.Comparison.GREATER_THAN = ">"; │ │ │ │ -OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; │ │ │ │ -OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; │ │ │ │ -OpenLayers.Filter.Comparison.BETWEEN = ".."; │ │ │ │ -OpenLayers.Filter.Comparison.LIKE = "~"; │ │ │ │ -OpenLayers.Filter.Comparison.IS_NULL = "NULL"; │ │ │ │ -OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ - events: null, │ │ │ │ - id: "", │ │ │ │ - lonlat: null, │ │ │ │ - div: null, │ │ │ │ - contentSize: null, │ │ │ │ - size: null, │ │ │ │ - contentHTML: null, │ │ │ │ - backgroundColor: "", │ │ │ │ - opacity: "", │ │ │ │ - border: "", │ │ │ │ - contentDiv: null, │ │ │ │ - groupDiv: null, │ │ │ │ - closeDiv: null, │ │ │ │ - autoSize: false, │ │ │ │ - minSize: null, │ │ │ │ - maxSize: null, │ │ │ │ - displayClass: "olPopup", │ │ │ │ - contentDisplayClass: "olPopupContent", │ │ │ │ - padding: 0, │ │ │ │ - disableFirefoxOverflowHack: false, │ │ │ │ - fixPadding: function() { │ │ │ │ - if (typeof this.padding == "number") { │ │ │ │ - this.padding = new OpenLayers.Bounds(this.padding, this.padding, this.padding, this.padding) │ │ │ │ + createNode: function(type, id) { │ │ │ │ + var node = document.createElementNS(this.xmlns, type); │ │ │ │ + if (id) { │ │ │ │ + node.setAttributeNS(null, "id", id) │ │ │ │ } │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - panMapIfOutOfView: false, │ │ │ │ - keepInMap: false, │ │ │ │ - closeOnMove: false, │ │ │ │ - map: null, │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ - if (id == null) { │ │ │ │ - id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + nodeTypeCompare: function(node, type) { │ │ │ │ + return type == node.nodeName │ │ │ │ + }, │ │ │ │ + createRenderRoot: function() { │ │ │ │ + var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ + svg.style.display = "block"; │ │ │ │ + return svg │ │ │ │ + }, │ │ │ │ + createRoot: function(suffix) { │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "g") │ │ │ │ + }, │ │ │ │ + createDefs: function() { │ │ │ │ + var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ + this.rendererRoot.appendChild(defs); │ │ │ │ + return defs │ │ │ │ + }, │ │ │ │ + drawPoint: function(node, geometry) { │ │ │ │ + return this.drawCircle(node, geometry, 1) │ │ │ │ + }, │ │ │ │ + drawCircle: function(node, geometry, radius) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = this.top - geometry.y / resolution; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "cx", x); │ │ │ │ + node.setAttributeNS(null, "cy", y); │ │ │ │ + node.setAttributeNS(null, "r", radius); │ │ │ │ + return node │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - this.id = id; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - this.contentSize = contentSize != null ? contentSize : new OpenLayers.Size(OpenLayers.Popup.WIDTH, OpenLayers.Popup.HEIGHT); │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML │ │ │ │ + }, │ │ │ │ + drawLineString: function(node, geometry) { │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return componentsResult.complete ? node : null │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - 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 = this.displayClass; │ │ │ │ - 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.contentSize.clone(), null, "relative"); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass; │ │ │ │ - this.groupDiv.appendChild(this.contentDiv); │ │ │ │ - this.div.appendChild(this.groupDiv); │ │ │ │ - if (closeBox) { │ │ │ │ - this.addCloseBox(closeBoxCallback) │ │ │ │ + }, │ │ │ │ + drawLinearRing: function(node, geometry) { │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return componentsResult.complete ? node : null │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - this.registerEvents() │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.size = null; │ │ │ │ - this.contentHTML = null; │ │ │ │ - this.backgroundColor = null; │ │ │ │ - this.opacity = null; │ │ │ │ - this.border = null; │ │ │ │ - if (this.closeOnMove && this.map) { │ │ │ │ - this.map.events.unregister("movestart", this, this.hide) │ │ │ │ + drawPolygon: function(node, geometry) { │ │ │ │ + var d = ""; │ │ │ │ + var draw = true; │ │ │ │ + var complete = true; │ │ │ │ + var linearRingResult, path; │ │ │ │ + for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ + d += " M"; │ │ │ │ + linearRingResult = this.getComponentsString(geometry.components[j].components, " "); │ │ │ │ + path = linearRingResult.path; │ │ │ │ + if (path) { │ │ │ │ + d += " " + path; │ │ │ │ + complete = linearRingResult.complete && complete │ │ │ │ + } else { │ │ │ │ + draw = false │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - if (this.closeDiv) { │ │ │ │ - OpenLayers.Event.stopObservingElement(this.closeDiv); │ │ │ │ - this.groupDiv.removeChild(this.closeDiv) │ │ │ │ + d += " z"; │ │ │ │ + if (draw) { │ │ │ │ + node.setAttributeNS(null, "d", d); │ │ │ │ + node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ + return complete ? node : null │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - this.closeDiv = null; │ │ │ │ - this.div.removeChild(this.groupDiv); │ │ │ │ - this.groupDiv = null; │ │ │ │ - if (this.map != null) { │ │ │ │ - this.map.removePopup(this) │ │ │ │ + }, │ │ │ │ + drawRectangle: function(node, geometry) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = this.top - geometry.y / resolution; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "x", x); │ │ │ │ + node.setAttributeNS(null, "y", y); │ │ │ │ + node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ + node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ + return node │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - this.map = null; │ │ │ │ - this.div = null; │ │ │ │ - this.autoSize = null; │ │ │ │ - this.minSize = null; │ │ │ │ - this.maxSize = null; │ │ │ │ - this.padding = null; │ │ │ │ - this.panMapIfOutOfView = null │ │ │ │ }, │ │ │ │ - draw: function(px) { │ │ │ │ - if (px == null) { │ │ │ │ - if (this.lonlat != null && this.map != null) { │ │ │ │ - px = this.map.getLayerPxFromLonLat(this.lonlat) │ │ │ │ + drawText: function(featureId, style, location) { │ │ │ │ + var drawOutline = !!style.labelOutlineWidth; │ │ │ │ + if (drawOutline) { │ │ │ │ + var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ + outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ + if (style.labelOutlineOpacity) { │ │ │ │ + outlineStyle.fontOpacity = style.labelOutlineOpacity │ │ │ │ } │ │ │ │ + delete outlineStyle.labelOutlineWidth; │ │ │ │ + this.drawText(featureId, outlineStyle, location) │ │ │ │ } │ │ │ │ - if (this.closeOnMove) { │ │ │ │ - this.map.events.register("movestart", this, this.hide) │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (location.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = location.y / resolution - this.top; │ │ │ │ + var suffix = drawOutline ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ + var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ + label.setAttributeNS(null, "x", x); │ │ │ │ + label.setAttributeNS(null, "y", -y); │ │ │ │ + if (style.fontColor) { │ │ │ │ + label.setAttributeNS(null, "fill", style.fontColor) │ │ │ │ } │ │ │ │ - if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == "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" │ │ │ │ + if (style.fontStrokeColor) { │ │ │ │ + label.setAttributeNS(null, "stroke", style.fontStrokeColor) │ │ │ │ + } │ │ │ │ + if (style.fontStrokeWidth) { │ │ │ │ + label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth) │ │ │ │ + } │ │ │ │ + if (style.fontOpacity) { │ │ │ │ + label.setAttributeNS(null, "opacity", style.fontOpacity) │ │ │ │ + } │ │ │ │ + if (style.fontFamily) { │ │ │ │ + label.setAttributeNS(null, "font-family", style.fontFamily) │ │ │ │ + } │ │ │ │ + if (style.fontSize) { │ │ │ │ + label.setAttributeNS(null, "font-size", style.fontSize) │ │ │ │ + } │ │ │ │ + if (style.fontWeight) { │ │ │ │ + label.setAttributeNS(null, "font-weight", style.fontWeight) │ │ │ │ + } │ │ │ │ + if (style.fontStyle) { │ │ │ │ + label.setAttributeNS(null, "font-style", style.fontStyle) │ │ │ │ + } │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ + label._featureId = featureId │ │ │ │ + } else { │ │ │ │ + label.setAttributeNS(null, "pointer-events", "none") │ │ │ │ + } │ │ │ │ + var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ + label.setAttributeNS(null, "text-anchor", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ + if (OpenLayers.IS_GECKO === true) { │ │ │ │ + label.setAttributeNS(null, "dominant-baseline", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central") │ │ │ │ + } │ │ │ │ + var labelRows = style.label.split("\n"); │ │ │ │ + var numRows = labelRows.length; │ │ │ │ + while (label.childNodes.length > numRows) { │ │ │ │ + label.removeChild(label.lastChild) │ │ │ │ + } │ │ │ │ + for (var i = 0; i < numRows; i++) { │ │ │ │ + var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + tspan._featureId = featureId; │ │ │ │ + tspan._geometry = location; │ │ │ │ + tspan._geometryClass = location.CLASS_NAME │ │ │ │ + } │ │ │ │ + if (OpenLayers.IS_GECKO === false) { │ │ │ │ + tspan.setAttributeNS(null, "baseline-shift", OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%") │ │ │ │ + } │ │ │ │ + tspan.setAttribute("x", x); │ │ │ │ + if (i == 0) { │ │ │ │ + var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ + if (vfactor == null) { │ │ │ │ + vfactor = -.5 │ │ │ │ } │ │ │ │ - }); │ │ │ │ - this.map.events.register("moveend", this, function() { │ │ │ │ - var oldOverflow = this.contentDiv._oldOverflow; │ │ │ │ - if (oldOverflow) { │ │ │ │ - this.contentDiv.style.overflow = oldOverflow; │ │ │ │ - this.contentDiv._oldOverflow = null │ │ │ │ + tspan.setAttribute("dy", vfactor * (numRows - 1) + "em") │ │ │ │ + } else { │ │ │ │ + tspan.setAttribute("dy", "1em") │ │ │ │ + } │ │ │ │ + tspan.textContent = labelRows[i] === "" ? " " : labelRows[i]; │ │ │ │ + if (!tspan.parentNode) { │ │ │ │ + label.appendChild(tspan) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!label.parentNode) { │ │ │ │ + this.textRoot.appendChild(label) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getComponentsString: function(components, separator) { │ │ │ │ + var renderCmp = []; │ │ │ │ + var complete = true; │ │ │ │ + var len = components.length; │ │ │ │ + var strings = []; │ │ │ │ + var str, component; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + component = components[i]; │ │ │ │ + renderCmp.push(component); │ │ │ │ + str = this.getShortString(component); │ │ │ │ + if (str) { │ │ │ │ + strings.push(str) │ │ │ │ + } else { │ │ │ │ + if (i > 0) { │ │ │ │ + if (this.getShortString(components[i - 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], components[i - 1])) │ │ │ │ + } │ │ │ │ } │ │ │ │ - }) │ │ │ │ + if (i < len - 1) { │ │ │ │ + if (this.getShortString(components[i + 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], components[i + 1])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + complete = false │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.moveTo(px); │ │ │ │ - if (!this.autoSize && !this.size) { │ │ │ │ - this.setSize(this.contentSize) │ │ │ │ + return { │ │ │ │ + path: strings.join(separator || ","), │ │ │ │ + complete: complete │ │ │ │ } │ │ │ │ - this.setBackgroundColor(); │ │ │ │ - this.setOpacity(); │ │ │ │ - this.setBorder(); │ │ │ │ - this.setContentHTML(); │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView() │ │ │ │ + }, │ │ │ │ + clipLine: function(badComponent, goodComponent) { │ │ │ │ + if (goodComponent.equals(badComponent)) { │ │ │ │ + return "" │ │ │ │ } │ │ │ │ - return this.div │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ + var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ + var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y1 = this.top - goodComponent.y / resolution; │ │ │ │ + var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y2 = this.top - badComponent.y / resolution; │ │ │ │ + var k; │ │ │ │ + if (x2 < -maxX || x2 > maxX) { │ │ │ │ + k = (y2 - y1) / (x2 - x1); │ │ │ │ + x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ + y2 = y1 + (x2 - x1) * k │ │ │ │ + } │ │ │ │ + if (y2 < -maxY || y2 > maxY) { │ │ │ │ + k = (x2 - x1) / (y2 - y1); │ │ │ │ + y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ + x2 = x1 + (y2 - y1) * k │ │ │ │ + } │ │ │ │ + return x2 + "," + y2 │ │ │ │ }, │ │ │ │ - updatePosition: function() { │ │ │ │ - if (this.lonlat && this.map) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - if (px) { │ │ │ │ - this.moveTo(px) │ │ │ │ + getShortString: function(point) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (point.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = this.top - point.y / resolution; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + return x + "," + y │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getPosition: function(node) { │ │ │ │ + return { │ │ │ │ + x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ + y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + importSymbol: function(graphicName) { │ │ │ │ + if (!this.defs) { │ │ │ │ + this.defs = this.createDefs() │ │ │ │ + } │ │ │ │ + var id = this.container.id + "-" + graphicName; │ │ │ │ + var existing = document.getElementById(id); │ │ │ │ + if (existing != null) { │ │ │ │ + return existing │ │ │ │ + } │ │ │ │ + var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ + if (!symbol) { │ │ │ │ + throw new Error(graphicName + " is not a valid symbol name") │ │ │ │ + } │ │ │ │ + var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ + var node = this.nodeFactory(null, "polygon"); │ │ │ │ + symbolNode.appendChild(node); │ │ │ │ + var symbolExtent = new OpenLayers.Bounds(Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ + var points = []; │ │ │ │ + var x, y; │ │ │ │ + for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ + x = symbol[i]; │ │ │ │ + y = symbol[i + 1]; │ │ │ │ + symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ + symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ + symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ + symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ + points.push(x, ",", y) │ │ │ │ + } │ │ │ │ + node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ + var width = symbolExtent.getWidth(); │ │ │ │ + var height = symbolExtent.getHeight(); │ │ │ │ + var viewBox = [symbolExtent.left - width, symbolExtent.bottom - height, width * 3, height * 3]; │ │ │ │ + symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ + this.symbolMetrics[id] = [Math.max(width, height), symbolExtent.getCenterLonLat().lon, symbolExtent.getCenterLonLat().lat]; │ │ │ │ + this.defs.appendChild(symbolNode); │ │ │ │ + return symbolNode │ │ │ │ + }, │ │ │ │ + getFeatureIdFromEvent: function(evt) { │ │ │ │ + var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ + if (!featureId) { │ │ │ │ + var target = evt.target; │ │ │ │ + featureId = target.parentNode && target != this.rendererRoot ? target.parentNode._featureId : undefined │ │ │ │ + } │ │ │ │ + return featureId │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ +}); │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ + l: "start", │ │ │ │ + r: "end", │ │ │ │ + b: "bottom", │ │ │ │ + t: "hanging" │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ + t: "-70%", │ │ │ │ + b: "0" │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ + t: 0, │ │ │ │ + b: -1 │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ + OpenLayers.Event.preventDefault(e) │ │ │ │ +}; │ │ │ │ +OpenLayers.Control = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + map: null, │ │ │ │ + div: null, │ │ │ │ + type: null, │ │ │ │ + allowSelection: false, │ │ │ │ + displayClass: "", │ │ │ │ + title: "", │ │ │ │ + autoActivate: false, │ │ │ │ + active: null, │ │ │ │ + handlerOptions: null, │ │ │ │ + handler: null, │ │ │ │ + eventListeners: null, │ │ │ │ + events: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.displayClass = this.CLASS_NAME.replace("OpenLayers.", "ol").replace(/\./g, ""); │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.events = new OpenLayers.Events(this); │ │ │ │ + if (this.eventListeners instanceof Object) { │ │ │ │ + this.events.on(this.eventListeners) │ │ │ │ + } │ │ │ │ + if (this.id == null) { │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.events) { │ │ │ │ + if (this.eventListeners) { │ │ │ │ + this.events.un(this.eventListeners) │ │ │ │ + } │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null │ │ │ │ + } │ │ │ │ + this.eventListeners = null; │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.destroy(); │ │ │ │ + this.handler = null │ │ │ │ + } │ │ │ │ + if (this.handlers) { │ │ │ │ + for (var key in this.handlers) { │ │ │ │ + if (this.handlers.hasOwnProperty(key) && typeof this.handlers[key].destroy == "function") { │ │ │ │ + this.handlers[key].destroy() │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.handlers = null │ │ │ │ + } │ │ │ │ + if (this.map) { │ │ │ │ + this.map.removeControl(this); │ │ │ │ + this.map = null │ │ │ │ + } │ │ │ │ + this.div = null │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.setMap(map) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + draw: function(px) { │ │ │ │ + if (this.div == null) { │ │ │ │ + this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ + this.div.className = this.displayClass; │ │ │ │ + if (!this.allowSelection) { │ │ │ │ + this.div.className += " olControlNoSelect"; │ │ │ │ + this.div.setAttribute("unselectable", "on", 0); │ │ │ │ + this.div.onselectstart = OpenLayers.Function.False │ │ │ │ + } │ │ │ │ + if (this.title != "") { │ │ │ │ + this.div.title = this.title │ │ │ │ } │ │ │ │ } │ │ │ │ + if (px != null) { │ │ │ │ + this.position = px.clone() │ │ │ │ + } │ │ │ │ + this.moveTo(this.position); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ moveTo: function(px) { │ │ │ │ if (px != null && this.div != null) { │ │ │ │ this.div.style.left = px.x + "px"; │ │ │ │ this.div.style.top = px.y + "px" │ │ │ │ } │ │ │ │ }, │ │ │ │ - visible: function() { │ │ │ │ - return OpenLayers.Element.visible(this.div) │ │ │ │ + activate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.activate() │ │ │ │ + } │ │ │ │ + this.active = true; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("activate"); │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - toggle: function() { │ │ │ │ - if (this.visible()) { │ │ │ │ - this.hide() │ │ │ │ - } else { │ │ │ │ - this.show() │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.deactivate() │ │ │ │ + } │ │ │ │ + this.active = false; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("deactivate"); │ │ │ │ + return true │ │ │ │ } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - show: function() { │ │ │ │ - this.div.style.display = ""; │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView() │ │ │ │ + CLASS_NAME: "OpenLayers.Control" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ +OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ +OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ +OpenLayers.Control.Attribution = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + separator: ", ", │ │ │ │ + template: "${layers}", │ │ │ │ + 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) │ │ │ │ + }, │ │ │ │ + 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 │ │ │ │ + }, │ │ │ │ + updateAttribution: function() { │ │ │ │ + var attributions = []; │ │ │ │ + if (this.map && this.map.layers) { │ │ │ │ + for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (layer.attribution && layer.getVisibility()) { │ │ │ │ + if (OpenLayers.Util.indexOf(attributions, layer.attribution) === -1) { │ │ │ │ + attributions.push(layer.attribution) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ + layers: attributions.join(this.separator) │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - hide: function() { │ │ │ │ - this.div.style.display = "none" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + control: null, │ │ │ │ + map: null, │ │ │ │ + keyMask: null, │ │ │ │ + active: false, │ │ │ │ + evt: null, │ │ │ │ + touch: false, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.control = control; │ │ │ │ + this.callbacks = callbacks; │ │ │ │ + var map = this.map || control.map; │ │ │ │ + if (map) { │ │ │ │ + this.setMap(map) │ │ │ │ + } │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ }, │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - this.size = contentSize.clone(); │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ - var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ - var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ - 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 │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map │ │ │ │ + }, │ │ │ │ + checkModifiers: function(evt) { │ │ │ │ + if (this.keyMask == null) { │ │ │ │ + return true │ │ │ │ } │ │ │ │ - this.size.w += wPadding; │ │ │ │ - this.size.h += hPadding; │ │ │ │ - if (OpenLayers.BROWSER_NAME == "msie") { │ │ │ │ - this.contentSize.w += contentDivPadding.left + contentDivPadding.right; │ │ │ │ - this.contentSize.h += contentDivPadding.bottom + contentDivPadding.top │ │ │ │ + var keyModifiers = (evt.shiftKey ? OpenLayers.Handler.MOD_SHIFT : 0) | (evt.ctrlKey ? OpenLayers.Handler.MOD_CTRL : 0) | (evt.altKey ? OpenLayers.Handler.MOD_ALT : 0) | (evt.metaKey ? OpenLayers.Handler.MOD_META : 0); │ │ │ │ + return keyModifiers == this.keyMask │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.width = this.size.w + "px"; │ │ │ │ - this.div.style.height = this.size.h + "px" │ │ │ │ + var events = OpenLayers.Events.prototype.BROWSER_EVENTS; │ │ │ │ + for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.register(events[i], this[events[i]]) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.contentDiv != null) { │ │ │ │ - this.contentDiv.style.width = contentSize.w + "px"; │ │ │ │ - this.contentDiv.style.height = contentSize.h + "px" │ │ │ │ + this.active = true; │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + var events = OpenLayers.Events.prototype.BROWSER_EVENTS; │ │ │ │ + for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.unregister(events[i], this[events[i]]) │ │ │ │ + } │ │ │ │ } │ │ │ │ + this.touch = false; │ │ │ │ + this.active = false; │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - updateSize: function() { │ │ │ │ - var preparedHTML = "<div class='" + this.contentDisplayClass + "'>" + this.contentDiv.innerHTML + "</div>"; │ │ │ │ - var containerElement = this.map ? this.map.div : document.body; │ │ │ │ - var realSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, null, { │ │ │ │ - displayClass: this.displayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - }); │ │ │ │ - var safeSize = this.getSafeContentSize(realSize); │ │ │ │ - var newSize = null; │ │ │ │ - if (safeSize.equals(realSize)) { │ │ │ │ - newSize = realSize │ │ │ │ - } else { │ │ │ │ - var fixedSize = { │ │ │ │ - w: safeSize.w < realSize.w ? safeSize.w : null, │ │ │ │ - h: safeSize.h < realSize.h ? safeSize.h : null │ │ │ │ + startTouch: function() { │ │ │ │ + if (!this.touch) { │ │ │ │ + this.touch = true; │ │ │ │ + var events = ["mousedown", "mouseup", "mousemove", "click", "dblclick", "mouseout"]; │ │ │ │ + for (var i = 0, len = events.length; i < len; i++) { │ │ │ │ + if (this[events[i]]) { │ │ │ │ + this.unregister(events[i], this[events[i]]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + callback: function(name, args) { │ │ │ │ + if (name && this.callbacks[name]) { │ │ │ │ + this.callbacks[name].apply(this.control, args) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + register: function(name, method) { │ │ │ │ + this.map.events.registerPriority(name, this, method); │ │ │ │ + this.map.events.registerPriority(name, this, this.setEvent) │ │ │ │ + }, │ │ │ │ + unregister: function(name, method) { │ │ │ │ + this.map.events.unregister(name, this, method); │ │ │ │ + this.map.events.unregister(name, this, this.setEvent) │ │ │ │ + }, │ │ │ │ + setEvent: function(evt) { │ │ │ │ + this.evt = evt; │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.control = this.map = null │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.MOD_NONE = 0; │ │ │ │ +OpenLayers.Handler.MOD_SHIFT = 1; │ │ │ │ +OpenLayers.Handler.MOD_CTRL = 2; │ │ │ │ +OpenLayers.Handler.MOD_ALT = 4; │ │ │ │ +OpenLayers.Handler.MOD_META = 8; │ │ │ │ +OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + started: false, │ │ │ │ + stopDown: true, │ │ │ │ + dragging: false, │ │ │ │ + last: null, │ │ │ │ + start: null, │ │ │ │ + lastMoveEvt: null, │ │ │ │ + oldOnselectstart: null, │ │ │ │ + interval: 0, │ │ │ │ + timeoutId: null, │ │ │ │ + documentDrag: false, │ │ │ │ + documentEvents: null, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + var me = this; │ │ │ │ + this._docMove = function(evt) { │ │ │ │ + me.mousemove({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + }, │ │ │ │ + element: document │ │ │ │ + }) │ │ │ │ }; │ │ │ │ - if (fixedSize.w && fixedSize.h) { │ │ │ │ - newSize = safeSize │ │ │ │ - } else { │ │ │ │ - var clippedSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, fixedSize, { │ │ │ │ - displayClass: this.contentDisplayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - }); │ │ │ │ - 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 │ │ │ │ + this._docUp = function(evt) { │ │ │ │ + me.mouseup({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ } │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + dragstart: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + this.dragging = false; │ │ │ │ + if (this.checkModifiers(evt) && (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ + this.started = true; │ │ │ │ + this.start = evt.xy; │ │ │ │ + this.last = evt.xy; │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ + this.down(evt); │ │ │ │ + this.callback("down", [evt.xy]); │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart ? document.onselectstart : OpenLayers.Function.True │ │ │ │ + } │ │ │ │ + document.onselectstart = OpenLayers.Function.False; │ │ │ │ + propagate = !this.stopDown │ │ │ │ + } else { │ │ │ │ + this.started = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null │ │ │ │ + } │ │ │ │ + return propagate │ │ │ │ + }, │ │ │ │ + dragmove: function(evt) { │ │ │ │ + this.lastMoveEvt = evt; │ │ │ │ + if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || evt.xy.y != this.last.y)) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + if (evt.element === document) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + this.setEvent(evt) │ │ │ │ + } else { │ │ │ │ + this.removeDocumentEvents() │ │ │ │ } │ │ │ │ - newSize = this.getSafeContentSize(clippedSize) │ │ │ │ } │ │ │ │ + if (this.interval > 0) { │ │ │ │ + this.timeoutId = setTimeout(OpenLayers.Function.bind(this.removeTimeout, this), this.interval) │ │ │ │ + } │ │ │ │ + this.dragging = true; │ │ │ │ + this.move(evt); │ │ │ │ + this.callback("move", [evt.xy]); │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart; │ │ │ │ + document.onselectstart = OpenLayers.Function.False │ │ │ │ + } │ │ │ │ + this.last = evt.xy │ │ │ │ } │ │ │ │ - this.setSize(newSize) │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - setBackgroundColor: function(color) { │ │ │ │ - if (color != undefined) { │ │ │ │ - this.backgroundColor = color │ │ │ │ + dragend: function(evt) { │ │ │ │ + if (this.started) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + this.removeDocumentEvents() │ │ │ │ + } │ │ │ │ + var dragged = this.start != this.last; │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ + this.up(evt); │ │ │ │ + this.callback("up", [evt.xy]); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]) │ │ │ │ + } │ │ │ │ + document.onselectstart = this.oldOnselectstart │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.backgroundColor = this.backgroundColor │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + down: function(evt) {}, │ │ │ │ + move: function(evt) {}, │ │ │ │ + up: function(evt) {}, │ │ │ │ + out: function(evt) {}, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + return this.dragstart(evt) │ │ │ │ + }, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return this.dragstart(evt) │ │ │ │ + }, │ │ │ │ + mousemove: function(evt) { │ │ │ │ + return this.dragmove(evt) │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + return this.dragmove(evt) │ │ │ │ + }, │ │ │ │ + removeTimeout: function() { │ │ │ │ + this.timeoutId = null; │ │ │ │ + if (this.dragging) { │ │ │ │ + this.mousemove(this.lastMoveEvt) │ │ │ │ } │ │ │ │ }, │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - if (opacity != undefined) { │ │ │ │ - this.opacity = opacity │ │ │ │ + mouseup: function(evt) { │ │ │ │ + return this.dragend(evt) │ │ │ │ + }, │ │ │ │ + touchend: function(evt) { │ │ │ │ + evt.xy = this.last; │ │ │ │ + return this.dragend(evt) │ │ │ │ + }, │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + this.addDocumentEvents() │ │ │ │ + } else { │ │ │ │ + var dragged = this.start != this.last; │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ + this.out(evt); │ │ │ │ + this.callback("out", []); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]) │ │ │ │ + } │ │ │ │ + if (document.onselectstart) { │ │ │ │ + document.onselectstart = this.oldOnselectstart │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.opacity = this.opacity; │ │ │ │ - this.div.style.filter = "alpha(opacity=" + this.opacity * 100 + ")" │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + click: function(evt) { │ │ │ │ + return this.start == this.last │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragging = false; │ │ │ │ + activated = true │ │ │ │ } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - setBorder: function(border) { │ │ │ │ - if (border != undefined) { │ │ │ │ - this.border = border │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown") │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.border = this.border │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + adjustXY: function(evt) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ + evt.xy.x -= pos[0]; │ │ │ │ + evt.xy.y -= pos[1] │ │ │ │ + }, │ │ │ │ + addDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = true; │ │ │ │ + OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.observe(document, "mouseup", this._docUp) │ │ │ │ + }, │ │ │ │ + removeDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = false; │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mouseup", this._docUp) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + dragHandler: null, │ │ │ │ + boxDivClassName: "olHandlerBoxZoomBox", │ │ │ │ + boxOffsets: null, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.dragHandler = new OpenLayers.Handler.Drag(this, { │ │ │ │ + down: this.startBox, │ │ │ │ + move: this.moveBox, │ │ │ │ + out: this.removeBox, │ │ │ │ + up: this.endBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.dragHandler) { │ │ │ │ + this.dragHandler.destroy(); │ │ │ │ + this.dragHandler = null │ │ │ │ } │ │ │ │ }, │ │ │ │ - setContentHTML: function(contentHTML) { │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Handler.prototype.setMap.apply(this, arguments); │ │ │ │ + if (this.dragHandler) { │ │ │ │ + this.dragHandler.setMap(map) │ │ │ │ } │ │ │ │ - if (this.contentDiv != null && this.contentHTML != null && this.contentHTML != this.contentDiv.innerHTML) { │ │ │ │ - this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ - if (this.autoSize) { │ │ │ │ - this.registerImageListeners(); │ │ │ │ - this.updateSize() │ │ │ │ + }, │ │ │ │ + startBox: function(xy) { │ │ │ │ + this.callback("start", []); │ │ │ │ + this.zoomBox = OpenLayers.Util.createDiv("zoomBox", { │ │ │ │ + x: -9999, │ │ │ │ + y: -9999 │ │ │ │ + }); │ │ │ │ + this.zoomBox.className = this.boxDivClassName; │ │ │ │ + this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; │ │ │ │ + this.map.viewPortDiv.appendChild(this.zoomBox); │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olDrawBox") │ │ │ │ + }, │ │ │ │ + moveBox: function(xy) { │ │ │ │ + var startX = this.dragHandler.start.x; │ │ │ │ + var startY = this.dragHandler.start.y; │ │ │ │ + var deltaX = Math.abs(startX - xy.x); │ │ │ │ + var deltaY = Math.abs(startY - xy.y); │ │ │ │ + var offset = this.getBoxOffsets(); │ │ │ │ + this.zoomBox.style.width = deltaX + offset.width + 1 + "px"; │ │ │ │ + this.zoomBox.style.height = deltaY + offset.height + 1 + "px"; │ │ │ │ + this.zoomBox.style.left = (xy.x < startX ? startX - deltaX - offset.left : startX - offset.left) + "px"; │ │ │ │ + this.zoomBox.style.top = (xy.y < startY ? startY - deltaY - offset.top : startY - offset.top) + "px" │ │ │ │ + }, │ │ │ │ + endBox: function(end) { │ │ │ │ + var result; │ │ │ │ + if (Math.abs(this.dragHandler.start.x - end.x) > 5 || Math.abs(this.dragHandler.start.y - end.y) > 5) { │ │ │ │ + var start = this.dragHandler.start; │ │ │ │ + var top = Math.min(start.y, end.y); │ │ │ │ + var bottom = Math.max(start.y, end.y); │ │ │ │ + var left = Math.min(start.x, end.x); │ │ │ │ + var right = Math.max(start.x, end.x); │ │ │ │ + result = new OpenLayers.Bounds(left, bottom, right, top) │ │ │ │ + } else { │ │ │ │ + result = this.dragHandler.start.clone() │ │ │ │ + } │ │ │ │ + this.removeBox(); │ │ │ │ + this.callback("done", [result]) │ │ │ │ + }, │ │ │ │ + removeBox: function() { │ │ │ │ + this.map.viewPortDiv.removeChild(this.zoomBox); │ │ │ │ + this.zoomBox = null; │ │ │ │ + this.boxOffsets = null; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDrawBox") │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragHandler.activate(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + if (this.dragHandler.deactivate()) { │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.removeBox() │ │ │ │ + } │ │ │ │ } │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ }, │ │ │ │ - registerImageListeners: function() { │ │ │ │ - var onImgLoad = function() { │ │ │ │ - if (this.popup.id === null) { │ │ │ │ - return │ │ │ │ + getBoxOffsets: function() { │ │ │ │ + if (!this.boxOffsets) { │ │ │ │ + var testDiv = document.createElement("div"); │ │ │ │ + testDiv.style.position = "absolute"; │ │ │ │ + testDiv.style.border = "1px solid black"; │ │ │ │ + testDiv.style.width = "3px"; │ │ │ │ + document.body.appendChild(testDiv); │ │ │ │ + var w3cBoxModel = testDiv.clientWidth == 3; │ │ │ │ + document.body.removeChild(testDiv); │ │ │ │ + var left = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-left-width")); │ │ │ │ + var right = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-right-width")); │ │ │ │ + var top = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-top-width")); │ │ │ │ + var bottom = parseInt(OpenLayers.Element.getStyle(this.zoomBox, "border-bottom-width")); │ │ │ │ + this.boxOffsets = { │ │ │ │ + left: left, │ │ │ │ + right: right, │ │ │ │ + top: top, │ │ │ │ + bottom: bottom, │ │ │ │ + width: w3cBoxModel === false ? left + right : 0, │ │ │ │ + height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ } │ │ │ │ - this.popup.updateSize(); │ │ │ │ - if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ - this.popup.panIntoView() │ │ │ │ + } │ │ │ │ + return this.boxOffsets │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + out: false, │ │ │ │ + keyMask: null, │ │ │ │ + alwaysZoom: false, │ │ │ │ + zoomOnClick: true, │ │ │ │ + draw: function() { │ │ │ │ + this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.zoomBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + zoomBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var bounds, targetCenterPx = position.getCenterPixel(); │ │ │ │ + if (!this.out) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat) │ │ │ │ + } else { │ │ │ │ + var pixWidth = position.right - position.left; │ │ │ │ + var pixHeight = position.bottom - position.top; │ │ │ │ + var zoomFactor = Math.min(this.map.size.h / pixHeight, this.map.size.w / pixWidth); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ + var xmin = center.lon - extent.getWidth() / 2 * zoomFactor; │ │ │ │ + var xmax = center.lon + extent.getWidth() / 2 * zoomFactor; │ │ │ │ + var ymin = center.lat - extent.getHeight() / 2 * zoomFactor; │ │ │ │ + var ymax = center.lat + extent.getHeight() / 2 * zoomFactor; │ │ │ │ + bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax) │ │ │ │ } │ │ │ │ - OpenLayers.Event.stopObserving(this.img, "load", this.img._onImgLoad) │ │ │ │ - }; │ │ │ │ - var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ - for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ - var img = images[i]; │ │ │ │ - if (img.width == 0 || img.height == 0) { │ │ │ │ - var context = { │ │ │ │ - popup: this, │ │ │ │ - img: img │ │ │ │ + var lastZoom = this.map.getZoom(), │ │ │ │ + size = this.map.getSize(), │ │ │ │ + centerPx = { │ │ │ │ + x: size.w / 2, │ │ │ │ + y: size.h / 2 │ │ │ │ + }, │ │ │ │ + zoom = this.map.getZoomForExtent(bounds), │ │ │ │ + oldRes = this.map.getResolution(), │ │ │ │ + newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ + if (oldRes == newRes) { │ │ │ │ + this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)) │ │ │ │ + } else { │ │ │ │ + var zoomOriginPx = { │ │ │ │ + x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / (oldRes - newRes), │ │ │ │ + y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / (oldRes - newRes) │ │ │ │ }; │ │ │ │ - img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ - OpenLayers.Event.observe(img, "load", img._onImgLoad) │ │ │ │ + this.map.zoomTo(zoom, zoomOriginPx) │ │ │ │ + } │ │ │ │ + if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ + this.map.zoomTo(lastZoom + (this.out ? -1 : 1)) │ │ │ │ + } │ │ │ │ + } else if (this.zoomOnClick) { │ │ │ │ + if (!this.out) { │ │ │ │ + this.map.zoomTo(this.map.getZoom() + 1, position) │ │ │ │ + } else { │ │ │ │ + this.map.zoomTo(this.map.getZoom() - 1, position) │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - getSafeContentSize: function(size) { │ │ │ │ - var safeContentSize = size.clone(); │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ - var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ - var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ - 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 │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + panned: false, │ │ │ │ + interval: 0, │ │ │ │ + documentDrag: false, │ │ │ │ + kinetic: null, │ │ │ │ + enableKinetic: true, │ │ │ │ + kineticInterval: 10, │ │ │ │ + draw: function() { │ │ │ │ + if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ + var config = { │ │ │ │ + interval: this.kineticInterval │ │ │ │ + }; │ │ │ │ + if (typeof this.enableKinetic === "object") { │ │ │ │ + config = OpenLayers.Util.extend(config, this.enableKinetic) │ │ │ │ + } │ │ │ │ + this.kinetic = new OpenLayers.Kinetic(config) │ │ │ │ } │ │ │ │ - if (this.minSize) { │ │ │ │ - safeContentSize.w = Math.max(safeContentSize.w, this.minSize.w - wPadding); │ │ │ │ - safeContentSize.h = Math.max(safeContentSize.h, this.minSize.h - hPadding) │ │ │ │ + this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ + move: this.panMap, │ │ │ │ + done: this.panMapDone, │ │ │ │ + down: this.panMapStart │ │ │ │ + }, { │ │ │ │ + interval: this.interval, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + panMapStart: function() { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.begin() │ │ │ │ } │ │ │ │ - if (this.maxSize) { │ │ │ │ - safeContentSize.w = Math.min(safeContentSize.w, this.maxSize.w - wPadding); │ │ │ │ - safeContentSize.h = Math.min(safeContentSize.h, this.maxSize.h - hPadding) │ │ │ │ + }, │ │ │ │ + panMap: function(xy) { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.update(xy) │ │ │ │ } │ │ │ │ - if (this.map && this.map.size) { │ │ │ │ - var extraX = 0, │ │ │ │ - extraY = 0; │ │ │ │ - if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ - var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ - switch (this.relativePosition) { │ │ │ │ - case "tr": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "tl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "bl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - case "br": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break │ │ │ │ + this.panned = true; │ │ │ │ + this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ + dragging: true, │ │ │ │ + animate: false │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + panMapDone: function(xy) { │ │ │ │ + if (this.panned) { │ │ │ │ + var res = null; │ │ │ │ + if (this.kinetic) { │ │ │ │ + res = this.kinetic.end(xy) │ │ │ │ + } │ │ │ │ + this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ + dragging: !!res, │ │ │ │ + animate: false │ │ │ │ + }); │ │ │ │ + if (res) { │ │ │ │ + var self = this; │ │ │ │ + this.kinetic.move(res, function(x, y, end) { │ │ │ │ + self.map.pan(x, y, { │ │ │ │ + dragging: !end, │ │ │ │ + animate: false │ │ │ │ + }) │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + this.panned = false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + wheelListener: null, │ │ │ │ + interval: 0, │ │ │ │ + maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ + delta: 0, │ │ │ │ + cumulative: true, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.wheelListener = OpenLayers.Function.bindAsEventListener(this.onWheelEvent, this) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments); │ │ │ │ + this.wheelListener = null │ │ │ │ + }, │ │ │ │ + onWheelEvent: function(e) { │ │ │ │ + if (!this.map || !this.checkModifiers(e)) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var overScrollableDiv = false; │ │ │ │ + var allowScroll = false; │ │ │ │ + var overMapDiv = false; │ │ │ │ + var elem = OpenLayers.Event.element(e); │ │ │ │ + while (elem != null && !overMapDiv && !overScrollableDiv) { │ │ │ │ + if (!overScrollableDiv) { │ │ │ │ + try { │ │ │ │ + var overflow; │ │ │ │ + if (elem.currentStyle) { │ │ │ │ + overflow = elem.currentStyle["overflow"] │ │ │ │ + } else { │ │ │ │ + var style = document.defaultView.getComputedStyle(elem, null); │ │ │ │ + overflow = style.getPropertyValue("overflow") │ │ │ │ + } │ │ │ │ + overScrollableDiv = overflow && overflow == "auto" || overflow == "scroll" │ │ │ │ + } catch (err) {} │ │ │ │ + } │ │ │ │ + if (!allowScroll) { │ │ │ │ + allowScroll = OpenLayers.Element.hasClass(elem, "olScrollable"); │ │ │ │ + if (!allowScroll) { │ │ │ │ + for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (elem == layer.div || elem == layer.pane) { │ │ │ │ + allowScroll = true; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - var maxY = this.map.size.h - this.map.paddingForPopups.top - this.map.paddingForPopups.bottom - hPadding - extraY; │ │ │ │ - var maxX = this.map.size.w - this.map.paddingForPopups.left - this.map.paddingForPopups.right - wPadding - extraX; │ │ │ │ - safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ - safeContentSize.h = Math.min(safeContentSize.h, maxY) │ │ │ │ + overMapDiv = elem == this.map.div; │ │ │ │ + elem = elem.parentNode │ │ │ │ + } │ │ │ │ + if (!overScrollableDiv && overMapDiv) { │ │ │ │ + if (allowScroll) { │ │ │ │ + var delta = 0; │ │ │ │ + if (e.wheelDelta) { │ │ │ │ + delta = e.wheelDelta; │ │ │ │ + if (delta % 160 === 0) { │ │ │ │ + delta = delta * .75 │ │ │ │ + } │ │ │ │ + delta = delta / 120 │ │ │ │ + } else if (e.detail) { │ │ │ │ + delta = -(e.detail / Math.abs(e.detail)) │ │ │ │ + } │ │ │ │ + this.delta += delta; │ │ │ │ + window.clearTimeout(this._timeoutId); │ │ │ │ + if (this.interval && Math.abs(this.delta) < this.maxDelta) { │ │ │ │ + var evt = OpenLayers.Util.extend({}, e); │ │ │ │ + this._timeoutId = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ + this.wheelZoom(evt) │ │ │ │ + }, this), this.interval) │ │ │ │ + } else { │ │ │ │ + this.wheelZoom(e) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ } │ │ │ │ - return safeContentSize │ │ │ │ }, │ │ │ │ - getContentDivPadding: function() { │ │ │ │ - var contentDivPadding = this._contentDivPadding; │ │ │ │ - if (!contentDivPadding) { │ │ │ │ - if (this.div.parentNode == null) { │ │ │ │ - this.div.style.display = "none"; │ │ │ │ - document.body.appendChild(this.div) │ │ │ │ + wheelZoom: function(e) { │ │ │ │ + var delta = this.delta; │ │ │ │ + this.delta = 0; │ │ │ │ + if (delta) { │ │ │ │ + e.xy = this.map.events.getMousePosition(e); │ │ │ │ + if (delta < 0) { │ │ │ │ + this.callback("down", [e, this.cumulative ? Math.max(-this.maxDelta, delta) : -1]) │ │ │ │ + } else { │ │ │ │ + this.callback("up", [e, this.cumulative ? Math.min(this.maxDelta, delta) : 1]) │ │ │ │ } │ │ │ │ - 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")); │ │ │ │ - this._contentDivPadding = contentDivPadding; │ │ │ │ - if (this.div.parentNode == document.body) { │ │ │ │ - document.body.removeChild(this.div); │ │ │ │ - this.div.style.display = "" │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + activate: function(evt) { │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + var wheelListener = this.wheelListener; │ │ │ │ + OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener); │ │ │ │ + OpenLayers.Event.observe(window, "mousewheel", wheelListener); │ │ │ │ + OpenLayers.Event.observe(document, "mousewheel", wheelListener); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + deactivate: function(evt) { │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + var wheelListener = this.wheelListener; │ │ │ │ + OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener); │ │ │ │ + OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + delay: 300, │ │ │ │ + single: true, │ │ │ │ + double: false, │ │ │ │ + pixelTolerance: 0, │ │ │ │ + dblclickTolerance: 13, │ │ │ │ + stopSingle: false, │ │ │ │ + stopDouble: false, │ │ │ │ + timerId: null, │ │ │ │ + down: null, │ │ │ │ + last: null, │ │ │ │ + first: null, │ │ │ │ + rightclickTimerId: null, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + touchend: function(evt) { │ │ │ │ + if (this.down) { │ │ │ │ + evt.xy = this.last.xy; │ │ │ │ + evt.lastTouches = this.last.touches; │ │ │ │ + this.handleSingle(evt); │ │ │ │ + this.down = null │ │ │ │ + } │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + mouseup: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + if (this.checkModifiers(evt) && this.control.handleRightClicks && OpenLayers.Event.isRightClick(evt)) { │ │ │ │ + propagate = this.rightclick(evt) │ │ │ │ + } │ │ │ │ + return propagate │ │ │ │ + }, │ │ │ │ + rightclick: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.callback("dblrightclick", [evt]); │ │ │ │ + return !this.stopDouble │ │ │ │ + } else { │ │ │ │ + var clickEvent = this["double"] ? OpenLayers.Util.extend({}, evt) : this.callback("rightclick", [evt]); │ │ │ │ + var delayedRightCall = OpenLayers.Function.bind(this.delayedRightCall, this, clickEvent); │ │ │ │ + this.rightclickTimerId = window.setTimeout(delayedRightCall, this.delay) │ │ │ │ } │ │ │ │ } │ │ │ │ - return contentDivPadding │ │ │ │ + return !this.stopSingle │ │ │ │ }, │ │ │ │ - addCloseBox: function(callback) { │ │ │ │ - this.closeDiv = OpenLayers.Util.createDiv(this.id + "_close", null, { │ │ │ │ - w: 17, │ │ │ │ - h: 17 │ │ │ │ + delayedRightCall: function(evt) { │ │ │ │ + this.rightclickTimerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback("rightclick", [evt]) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + click: function(evt) { │ │ │ │ + if (!this.last) { │ │ │ │ + this.last = this.getEventInfo(evt) │ │ │ │ + } │ │ │ │ + this.handleSingle(evt); │ │ │ │ + return !this.stopSingle │ │ │ │ + }, │ │ │ │ + dblclick: function(evt) { │ │ │ │ + this.handleDouble(evt); │ │ │ │ + return !this.stopDouble │ │ │ │ + }, │ │ │ │ + handleDouble: function(evt) { │ │ │ │ + if (this.passesDblclickTolerance(evt)) { │ │ │ │ + if (this["double"]) { │ │ │ │ + this.callback("dblclick", [evt]) │ │ │ │ + } │ │ │ │ + this.clearTimer() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + handleSingle: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ + if (this["double"]) { │ │ │ │ + OpenLayers.Event.preventDefault(evt) │ │ │ │ + } │ │ │ │ + this.handleDouble(evt) │ │ │ │ + } │ │ │ │ + if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ + this.clearTimer() │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.first = this.getEventInfo(evt); │ │ │ │ + var clickEvent = this.single ? OpenLayers.Util.extend({}, evt) : null; │ │ │ │ + this.queuePotentialClick(clickEvent) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + queuePotentialClick: function(evt) { │ │ │ │ + this.timerId = window.setTimeout(OpenLayers.Function.bind(this.delayedCall, this, evt), this.delay) │ │ │ │ + }, │ │ │ │ + passesTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ + passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ + if (passes && this.touch && this.down.touches.length === this.last.touches.length) { │ │ │ │ + for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ + if (this.getTouchDistance(this.down.touches[i], this.last.touches[i]) > this.pixelTolerance) { │ │ │ │ + passes = false; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return passes │ │ │ │ + }, │ │ │ │ + getTouchDistance: function(from, to) { │ │ │ │ + return Math.sqrt(Math.pow(from.clientX - to.clientX, 2) + Math.pow(from.clientY - to.clientY, 2)) │ │ │ │ + }, │ │ │ │ + passesDblclickTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.down && this.first) { │ │ │ │ + passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance │ │ │ │ + } │ │ │ │ + return passes │ │ │ │ + }, │ │ │ │ + clearTimer: function() { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null │ │ │ │ + } │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + window.clearTimeout(this.rightclickTimerId); │ │ │ │ + this.rightclickTimerId = null │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + delayedCall: function(evt) { │ │ │ │ + this.timerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback("click", [evt]) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getEventInfo: function(evt) { │ │ │ │ + var touches; │ │ │ │ + if (evt.touches) { │ │ │ │ + var len = evt.touches.length; │ │ │ │ + touches = new Array(len); │ │ │ │ + var touch; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + touch = evt.touches[i]; │ │ │ │ + touches[i] = { │ │ │ │ + clientX: touch.olClientX, │ │ │ │ + clientY: touch.olClientY │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + xy: evt.xy, │ │ │ │ + touches: touches │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.down = null; │ │ │ │ + this.first = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true │ │ │ │ + } │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + dragPan: null, │ │ │ │ + dragPanOptions: null, │ │ │ │ + pinchZoom: null, │ │ │ │ + pinchZoomOptions: null, │ │ │ │ + documentDrag: false, │ │ │ │ + zoomBox: null, │ │ │ │ + zoomBoxEnabled: true, │ │ │ │ + zoomWheelEnabled: true, │ │ │ │ + mouseWheelOptions: null, │ │ │ │ + handleRightClicks: false, │ │ │ │ + zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ + autoActivate: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.dragPan) { │ │ │ │ + this.dragPan.destroy() │ │ │ │ + } │ │ │ │ + this.dragPan = null; │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.zoomBox.destroy() │ │ │ │ + } │ │ │ │ + this.zoomBox = null; │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.destroy() │ │ │ │ + } │ │ │ │ + this.pinchZoom = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + this.dragPan.activate(); │ │ │ │ + if (this.zoomWheelEnabled) { │ │ │ │ + this.handlers.wheel.activate() │ │ │ │ + } │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + if (this.zoomBoxEnabled) { │ │ │ │ + this.zoomBox.activate() │ │ │ │ + } │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.activate() │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.deactivate() │ │ │ │ + } │ │ │ │ + this.zoomBox.deactivate(); │ │ │ │ + this.dragPan.deactivate(); │ │ │ │ + this.handlers.click.deactivate(); │ │ │ │ + this.handlers.wheel.deactivate(); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + if (this.handleRightClicks) { │ │ │ │ + this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False │ │ │ │ + } │ │ │ │ + var clickCallbacks = { │ │ │ │ + click: this.defaultClick, │ │ │ │ + dblclick: this.defaultDblClick, │ │ │ │ + dblrightclick: this.defaultDblRightClick │ │ │ │ + }; │ │ │ │ + var clickOptions = { │ │ │ │ + double: true, │ │ │ │ + stopDouble: true │ │ │ │ + }; │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks, clickOptions); │ │ │ │ + this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend({ │ │ │ │ + map: this.map, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }, this.dragPanOptions)); │ │ │ │ + this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ + map: this.map, │ │ │ │ + keyMask: this.zoomBoxKeyMask │ │ │ │ }); │ │ │ │ - this.closeDiv.className = "olPopupCloseBox"; │ │ │ │ - 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) │ │ │ │ + this.dragPan.draw(); │ │ │ │ + this.zoomBox.draw(); │ │ │ │ + var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ + cumulative: false, │ │ │ │ + interval: 50, │ │ │ │ + maxDelta: 6 │ │ │ │ }; │ │ │ │ - OpenLayers.Event.observe(this.closeDiv, "touchend", OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ - OpenLayers.Event.observe(this.closeDiv, "click", OpenLayers.Function.bindAsEventListener(closePopup, this)) │ │ │ │ + this.handlers.wheel = new OpenLayers.Handler.MouseWheel(this, { │ │ │ │ + up: this.wheelUp, │ │ │ │ + down: this.wheelDown │ │ │ │ + }, OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions)); │ │ │ │ + if (OpenLayers.Control.PinchZoom) { │ │ │ │ + this.pinchZoom = new OpenLayers.Control.PinchZoom(OpenLayers.Util.extend({ │ │ │ │ + map: this.map │ │ │ │ + }, this.pinchZoomOptions)) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - panIntoView: function() { │ │ │ │ - var mapSize = this.map.getSize(); │ │ │ │ - var origTL = this.map.getViewPortPxFromLayerPx(new OpenLayers.Pixel(parseInt(this.div.style.left), parseInt(this.div.style.top))); │ │ │ │ - var newTL = origTL.clone(); │ │ │ │ - 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 │ │ │ │ + defaultClick: function(evt) { │ │ │ │ + if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ + this.map.zoomOut() │ │ │ │ } │ │ │ │ - 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 │ │ │ │ + }, │ │ │ │ + defaultDblClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom + 1, evt.xy) │ │ │ │ + }, │ │ │ │ + defaultDblRightClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom - 1, evt.xy) │ │ │ │ + }, │ │ │ │ + wheelChange: function(evt, deltaZ) { │ │ │ │ + if (!this.map.fractionalZoom) { │ │ │ │ + deltaZ = Math.round(deltaZ) │ │ │ │ } │ │ │ │ - var dx = origTL.x - newTL.x; │ │ │ │ - var dy = origTL.y - newTL.y; │ │ │ │ - this.map.pan(dx, dy) │ │ │ │ + var currentZoom = this.map.getZoom(), │ │ │ │ + newZoom = currentZoom + deltaZ; │ │ │ │ + newZoom = Math.max(newZoom, 0); │ │ │ │ + newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ + if (newZoom === currentZoom) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + this.map.zoomTo(newZoom, evt.xy) │ │ │ │ }, │ │ │ │ - registerEvents: function() { │ │ │ │ - this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ - │ │ │ │ - function onTouchstart(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + wheelUp: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || 1) │ │ │ │ + }, │ │ │ │ + wheelDown: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || -1) │ │ │ │ + }, │ │ │ │ + disableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = false; │ │ │ │ + this.zoomBox.deactivate() │ │ │ │ + }, │ │ │ │ + enableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.zoomBox.activate() │ │ │ │ } │ │ │ │ - this.events.on({ │ │ │ │ - mousedown: this.onmousedown, │ │ │ │ - mousemove: this.onmousemove, │ │ │ │ - mouseup: this.onmouseup, │ │ │ │ - click: this.onclick, │ │ │ │ - mouseout: this.onmouseout, │ │ │ │ - dblclick: this.ondblclick, │ │ │ │ - touchstart: onTouchstart, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ }, │ │ │ │ - onmousedown: function(evt) { │ │ │ │ - this.mousedown = true; │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + disableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = false; │ │ │ │ + this.handlers.wheel.deactivate() │ │ │ │ }, │ │ │ │ - onmousemove: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + enableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.wheel.activate() │ │ │ │ } │ │ │ │ }, │ │ │ │ - onmouseup: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - this.mousedown = false; │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ +}); │ │ │ │ +OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ + target: null, │ │ │ │ + events: ["mousedown", "mouseup", "click", "dblclick", "touchstart", "touchmove", "touchend", "keydown"], │ │ │ │ + startRegEx: /^mousedown|touchstart$/, │ │ │ │ + cancelRegEx: /^touchmove$/, │ │ │ │ + completeRegEx: /^mouseup|touchend$/, │ │ │ │ + initialize: function(target) { │ │ │ │ + this.target = target; │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ + extension: true │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - onclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.unregister(this.events[i], this, this.buttonClick) │ │ │ │ + } │ │ │ │ + delete this.target │ │ │ │ }, │ │ │ │ - onmouseout: function(evt) { │ │ │ │ - this.mousedown = false │ │ │ │ + getPressedButton: function(element) { │ │ │ │ + var depth = 3, │ │ │ │ + button; │ │ │ │ + do { │ │ │ │ + if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ + button = element; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + element = element.parentNode │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return button │ │ │ │ }, │ │ │ │ - ondblclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + ignore: function(element) { │ │ │ │ + var depth = 3, │ │ │ │ + ignore = false; │ │ │ │ + do { │ │ │ │ + if (element.nodeName.toLowerCase() === "a") { │ │ │ │ + ignore = true; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + element = element.parentNode │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return ignore │ │ │ │ }, │ │ │ │ - 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.Popup.Anchored = OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ - relativePosition: null, │ │ │ │ - keepInMap: true, │ │ │ │ - anchor: null, │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ - var newArguments = [id, lonlat, contentSize, 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) │ │ │ │ + buttonClick: function(evt) { │ │ │ │ + var propagate = true, │ │ │ │ + element = OpenLayers.Event.element(evt); │ │ │ │ + if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ + var button = this.getPressedButton(element); │ │ │ │ + if (button) { │ │ │ │ + if (evt.type === "keydown") { │ │ │ │ + switch (evt.keyCode) { │ │ │ │ + case OpenLayers.Event.KEY_RETURN: │ │ │ │ + case OpenLayers.Event.KEY_SPACE: │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button │ │ │ │ + }); │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } else if (this.startEvt) { │ │ │ │ + if (this.completeRegEx.test(evt.type)) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ + var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ + var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ + var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ + pos[0] = pos[0] - scrollLeft; │ │ │ │ + pos[1] = pos[1] - scrollTop; │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button, │ │ │ │ + buttonXY: { │ │ │ │ + x: this.startEvt.clientX - pos[0], │ │ │ │ + y: this.startEvt.clientY - pos[1] │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (this.cancelRegEx.test(evt.type)) { │ │ │ │ + delete this.startEvt │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false │ │ │ │ + } │ │ │ │ + if (this.startRegEx.test(evt.type)) { │ │ │ │ + this.startEvt = evt; │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ + delete this.startEvt │ │ │ │ + } │ │ │ │ } │ │ │ │ + return propagate │ │ │ │ + } │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + layerStates: null, │ │ │ │ + layersDiv: null, │ │ │ │ + baseLayersDiv: null, │ │ │ │ + baseLayers: null, │ │ │ │ + dataLbl: null, │ │ │ │ + dataLayersDiv: null, │ │ │ │ + dataLayers: null, │ │ │ │ + minimizeDiv: null, │ │ │ │ + maximizeDiv: null, │ │ │ │ + ascending: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + this.layerStates = [] │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.anchor = null; │ │ │ │ - this.relativePosition = null; │ │ │ │ - OpenLayers.Popup.prototype.destroy.apply(this, arguments) │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ + this.map.events.un({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + addlayer: this.redraw, │ │ │ │ + changelayer: this.redraw, │ │ │ │ + removelayer: this.redraw, │ │ │ │ + changebaselayer: this.redraw, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - show: function() { │ │ │ │ - this.updatePosition(); │ │ │ │ - OpenLayers.Popup.prototype.show.apply(this, arguments) │ │ │ │ + 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 │ │ │ │ + }); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - moveTo: function(px) { │ │ │ │ - var oldRelativePosition = this.relativePosition; │ │ │ │ - this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ - OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ - if (this.relativePosition != oldRelativePosition) { │ │ │ │ - this.updateRelativePosition() │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ + this.loadContents(); │ │ │ │ + if (!this.outsideViewport) { │ │ │ │ + this.minimizeControl() │ │ │ │ } │ │ │ │ + this.redraw(); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ - if (this.lonlat && this.map) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - this.moveTo(px) │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.minimizeDiv) { │ │ │ │ + this.minimizeControl() │ │ │ │ + } else if (button === this.maximizeDiv) { │ │ │ │ + this.maximizeControl() │ │ │ │ + } else if (button._layerSwitcher === this.id) { │ │ │ │ + if (button["for"]) { │ │ │ │ + button = document.getElementById(button["for"]) │ │ │ │ + } │ │ │ │ + if (!button.disabled) { │ │ │ │ + if (button.type == "radio") { │ │ │ │ + button.checked = true; │ │ │ │ + this.map.setBaseLayer(this.map.getLayer(button._layer)) │ │ │ │ + } else { │ │ │ │ + button.checked = !button.checked; │ │ │ │ + this.updateMap() │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - calculateRelativePosition: function(px) { │ │ │ │ - var lonlat = this.map.getLonLatFromLayerPx(px); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - var quadrant = extent.determineQuadrant(lonlat); │ │ │ │ - return OpenLayers.Bounds.oppositeQuadrant(quadrant) │ │ │ │ + clearLayersArray: function(layersType) { │ │ │ │ + this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ + this[layersType + "Layers"] = [] │ │ │ │ }, │ │ │ │ - updateRelativePosition: function() {}, │ │ │ │ - calculateNewPx: function(px) { │ │ │ │ - var newPx = px.offset(this.anchor.offset); │ │ │ │ - var size = this.size || this.contentSize; │ │ │ │ - var top = this.relativePosition.charAt(0) == "t"; │ │ │ │ - newPx.y += top ? -size.h : this.anchor.size.h; │ │ │ │ - var left = this.relativePosition.charAt(1) == "l"; │ │ │ │ - newPx.x += left ? -size.w : this.anchor.size.w; │ │ │ │ - return newPx │ │ │ │ + checkRedraw: function() { │ │ │ │ + if (!this.layerStates.length || this.map.layers.length != this.layerStates.length) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + for (var i = 0, len = this.layerStates.length; i < len; 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) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ -}); │ │ │ │ -OpenLayers.Popup.Framed = OpenLayers.Class(OpenLayers.Popup.Anchored, { │ │ │ │ - imageSrc: null, │ │ │ │ - imageSize: null, │ │ │ │ - isAlphaImage: false, │ │ │ │ - positionBlocks: null, │ │ │ │ - blocks: null, │ │ │ │ - fixedRelativePosition: false, │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ - OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.fixedRelativePosition) { │ │ │ │ - this.updateRelativePosition(); │ │ │ │ - this.calculateRelativePosition = function(px) { │ │ │ │ - return this.relativePosition │ │ │ │ + redraw: function() { │ │ │ │ + if (!this.checkRedraw()) { │ │ │ │ + return this.div │ │ │ │ + } │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ + var containsOverlays = false; │ │ │ │ + var containsBaseLayers = false; │ │ │ │ + var len = this.map.layers.length; │ │ │ │ + this.layerStates = new Array(len); │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + this.layerStates[i] = { │ │ │ │ + name: layer.name, │ │ │ │ + visibility: layer.visibility, │ │ │ │ + inRange: layer.inRange, │ │ │ │ + id: layer.id │ │ │ │ } │ │ │ │ } │ │ │ │ - this.contentDiv.style.position = "absolute"; │ │ │ │ - this.contentDiv.style.zIndex = 1; │ │ │ │ - if (closeBox) { │ │ │ │ - this.closeDiv.style.zIndex = 1 │ │ │ │ + var layers = this.map.layers.slice(); │ │ │ │ + if (!this.ascending) { │ │ │ │ + layers.reverse() │ │ │ │ } │ │ │ │ - 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%" │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + var baseLayer = layer.isBaseLayer; │ │ │ │ + if (layer.displayInLayerSwitcher) { │ │ │ │ + if (baseLayer) { │ │ │ │ + containsBaseLayers = true │ │ │ │ + } else { │ │ │ │ + containsOverlays = true │ │ │ │ + } │ │ │ │ + var checked = baseLayer ? layer == this.map.baseLayer : layer.getVisibility(); │ │ │ │ + var inputElem = document.createElement("input"), │ │ │ │ + inputId = OpenLayers.Util.createUniqueID(this.id + "_input_"); │ │ │ │ + inputElem.id = inputId; │ │ │ │ + inputElem.name = baseLayer ? this.id + "_baseLayers" : layer.name; │ │ │ │ + inputElem.type = baseLayer ? "radio" : "checkbox"; │ │ │ │ + inputElem.value = layer.name; │ │ │ │ + inputElem.checked = checked; │ │ │ │ + inputElem.defaultChecked = checked; │ │ │ │ + inputElem.className = "olButton"; │ │ │ │ + inputElem._layer = layer.id; │ │ │ │ + inputElem._layerSwitcher = this.id; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + inputElem.disabled = true │ │ │ │ + } │ │ │ │ + var labelSpan = document.createElement("label"); │ │ │ │ + labelSpan["for"] = inputElem.id; │ │ │ │ + OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ + labelSpan._layer = layer.id; │ │ │ │ + labelSpan._layerSwitcher = this.id; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + labelSpan.style.color = "gray" │ │ │ │ + } │ │ │ │ + labelSpan.innerHTML = layer.name; │ │ │ │ + labelSpan.style.verticalAlign = baseLayer ? "bottom" : "baseline"; │ │ │ │ + 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) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.dataLbl.style.display = containsOverlays ? "" : "none"; │ │ │ │ + this.baseLbl.style.display = containsBaseLayers ? "" : "none"; │ │ │ │ + return this.div │ │ │ │ + }, │ │ │ │ + updateMap: function() { │ │ │ │ + for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.baseLayers[i]; │ │ │ │ + if (layerEntry.inputElem.checked) { │ │ │ │ + this.map.setBaseLayer(layerEntry.layer, false) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.dataLayers[i]; │ │ │ │ + layerEntry.layer.setVisibility(layerEntry.inputElem.checked) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + maximizeControl: function(e) { │ │ │ │ + this.div.style.width = ""; │ │ │ │ + this.div.style.height = ""; │ │ │ │ + this.showControls(false); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + minimizeControl: function(e) { │ │ │ │ + this.div.style.width = "0px"; │ │ │ │ + this.div.style.height = "0px"; │ │ │ │ + this.showControls(true); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + showControls: function(minimize) { │ │ │ │ + this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ + this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ + this.layersDiv.style.display = minimize ? "none" : "" │ │ │ │ + }, │ │ │ │ + loadContents: function() { │ │ │ │ + this.layersDiv = document.createElement("div"); │ │ │ │ + this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ + OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ + this.baseLbl = document.createElement("div"); │ │ │ │ + this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ + this.baseLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ + this.dataLbl = document.createElement("div"); │ │ │ │ + this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ + this.dataLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ + 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); │ │ │ │ + var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png"); │ │ │ │ + this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MaximizeDiv", null, null, img, "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ + this.maximizeDiv.style.display = "none"; │ │ │ │ + this.div.appendChild(this.maximizeDiv); │ │ │ │ + var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png"); │ │ │ │ + this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MinimizeDiv", null, null, img, "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ + this.minimizeDiv.style.display = "none"; │ │ │ │ + this.div.appendChild(this.minimizeDiv) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + controls: null, │ │ │ │ + autoActivate: true, │ │ │ │ + defaultControl: null, │ │ │ │ + saveState: false, │ │ │ │ + allowDepress: false, │ │ │ │ + activeState: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.controls = []; │ │ │ │ + this.activeState = {} │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.imageSrc = null; │ │ │ │ - this.imageSize = null; │ │ │ │ - this.isAlphaImage = null; │ │ │ │ - this.fixedRelativePosition = false; │ │ │ │ - this.positionBlocks = null; │ │ │ │ - for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - if (block.image) { │ │ │ │ - block.div.removeChild(block.image) │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onButtonClick) │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ + ctl = this.controls[i]; │ │ │ │ + if (ctl.events) { │ │ │ │ + ctl.events.un({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }) │ │ │ │ } │ │ │ │ - block.image = null; │ │ │ │ - if (block.div) { │ │ │ │ - this.groupDiv.removeChild(block.div) │ │ │ │ + ctl.panel_div = null │ │ │ │ + } │ │ │ │ + this.activeState = null │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + if (control === this.defaultControl || this.saveState && this.activeState[control.id]) { │ │ │ │ + control.activate() │ │ │ │ + } │ │ │ │ } │ │ │ │ - block.div = null │ │ │ │ + if (this.saveState === true) { │ │ │ │ + this.defaultControl = null │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - this.blocks = null; │ │ │ │ - OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - setBackgroundColor: function(color) {}, │ │ │ │ - setBorder: function() {}, │ │ │ │ - setOpacity: function(opacity) {}, │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ - this.updateBlocks() │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + this.activeState[control.id] = control.deactivate() │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ }, │ │ │ │ - updateRelativePosition: function() { │ │ │ │ - this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ - if (this.closeDiv) { │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ - this.closeDiv.style.right = contentDivPadding.right + this.padding.right + "px"; │ │ │ │ - this.closeDiv.style.top = contentDivPadding.top + this.padding.top + "px" │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ } │ │ │ │ - this.updateBlocks() │ │ │ │ + this.addControlsToMap(this.controls); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - calculateNewPx: function(px) { │ │ │ │ - var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply(this, arguments); │ │ │ │ - newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ - return newPx │ │ │ │ + redraw: function() { │ │ │ │ + for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ + this.div.removeChild(this.div.childNodes[i]) │ │ │ │ + } │ │ │ │ + this.div.innerHTML = ""; │ │ │ │ + if (this.active) { │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + this.div.appendChild(this.controls[i].panel_div) │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - createBlocks: function() { │ │ │ │ - this.blocks = []; │ │ │ │ - var firstPosition = null; │ │ │ │ - for (var key in this.positionBlocks) { │ │ │ │ - firstPosition = key; │ │ │ │ - break │ │ │ │ + activateControl: function(control) { │ │ │ │ + if (!this.active) { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - var position = this.positionBlocks[firstPosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - var block = {}; │ │ │ │ - this.blocks.push(block); │ │ │ │ - var divId = this.id + "_FrameDecorationDiv_" + i; │ │ │ │ - block.div = OpenLayers.Util.createDiv(divId, null, null, null, "absolute", null, "hidden", null); │ │ │ │ - var imgId = this.id + "_FrameDecorationImg_" + i; │ │ │ │ - var imageCreator = this.isAlphaImage ? OpenLayers.Util.createAlphaImageDiv : OpenLayers.Util.createImage; │ │ │ │ - block.image = imageCreator(imgId, null, this.imageSize, this.imageSrc, "absolute", null, null, null); │ │ │ │ - block.div.appendChild(block.image); │ │ │ │ - this.groupDiv.appendChild(block.div) │ │ │ │ + if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ + control.trigger(); │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ + if (control.active) { │ │ │ │ + control.deactivate() │ │ │ │ + } else { │ │ │ │ + control.activate() │ │ │ │ + } │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if (this.allowDepress && control.active) { │ │ │ │ + control.deactivate() │ │ │ │ + } else { │ │ │ │ + var c; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + c = this.controls[i]; │ │ │ │ + if (c != control && (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ + c.deactivate() │ │ │ │ + } │ │ │ │ + } │ │ │ │ + control.activate() │ │ │ │ } │ │ │ │ }, │ │ │ │ - updateBlocks: function() { │ │ │ │ - if (!this.blocks) { │ │ │ │ - this.createBlocks() │ │ │ │ + addControls: function(controls) { │ │ │ │ + if (!OpenLayers.Util.isArray(controls)) { │ │ │ │ + controls = [controls] │ │ │ │ } │ │ │ │ - if (this.size && this.relativePosition) { │ │ │ │ - var position = this.positionBlocks[this.relativePosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - var positionBlock = position.blocks[i]; │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - var l = positionBlock.anchor.left; │ │ │ │ - var b = positionBlock.anchor.bottom; │ │ │ │ - var r = positionBlock.anchor.right; │ │ │ │ - var t = positionBlock.anchor.top; │ │ │ │ - var w = isNaN(positionBlock.size.w) ? this.size.w - (r + l) : positionBlock.size.w; │ │ │ │ - var h = isNaN(positionBlock.size.h) ? this.size.h - (b + t) : positionBlock.size.h; │ │ │ │ - block.div.style.width = (w < 0 ? 0 : w) + "px"; │ │ │ │ - block.div.style.height = (h < 0 ? 0 : h) + "px"; │ │ │ │ - block.div.style.left = l != null ? l + "px" : ""; │ │ │ │ - block.div.style.bottom = b != null ? b + "px" : ""; │ │ │ │ - block.div.style.right = r != null ? r + "px" : ""; │ │ │ │ - block.div.style.top = t != null ? t + "px" : ""; │ │ │ │ - block.image.style.left = positionBlock.position.x + "px"; │ │ │ │ - block.image.style.top = positionBlock.position.y + "px" │ │ │ │ + this.controls = this.controls.concat(controls); │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + var control = controls[i], │ │ │ │ + element = this.createControlMarkup(control); │ │ │ │ + OpenLayers.Element.addClass(element, control.displayClass + "ItemInactive"); │ │ │ │ + OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ + if (control.title != "" && !element.title) { │ │ │ │ + element.title = control.title │ │ │ │ } │ │ │ │ - this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ - this.contentDiv.style.top = this.padding.top + "px" │ │ │ │ + control.panel_div = element │ │ │ │ + } │ │ │ │ + if (this.map) { │ │ │ │ + this.addControlsToMap(controls); │ │ │ │ + this.redraw() │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ + createControlMarkup: function(control) { │ │ │ │ + return document.createElement("div") │ │ │ │ + }, │ │ │ │ + addControlsToMap: function(controls) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + control = controls[i]; │ │ │ │ + if (control.autoActivate === true) { │ │ │ │ + control.autoActivate = false; │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.autoActivate = true │ │ │ │ + } else { │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.deactivate() │ │ │ │ + } │ │ │ │ + control.events.on({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + iconOn: function() { │ │ │ │ + var d = this.panel_div; │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Active") │ │ │ │ + }, │ │ │ │ + iconOff: function() { │ │ │ │ + var d = this.panel_div; │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Inactive") │ │ │ │ + }, │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var controls = this.controls, │ │ │ │ + button = evt.buttonElement; │ │ │ │ + for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ + if (controls[i].panel_div === button) { │ │ │ │ + this.activateControl(controls[i]); │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + 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 │ │ │ │ + }, │ │ │ │ + getControlsByName: function(match) { │ │ │ │ + return this.getControlsBy("name", match) │ │ │ │ + }, │ │ │ │ + getControlsByClass: function(match) { │ │ │ │ + return this.getControlsBy("CLASS_NAME", match) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ }); │ │ │ │ -OpenLayers.Popup.FramedCloud = OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ - contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ - autoSize: true, │ │ │ │ - panMapIfOutOfView: true, │ │ │ │ - imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ - isAlphaImage: false, │ │ │ │ - fixedRelativePosition: false, │ │ │ │ - positionBlocks: { │ │ │ │ - tl: { │ │ │ │ - offset: new OpenLayers.Pixel(44, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 18), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -688) │ │ │ │ - }] │ │ │ │ +OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + zoomInText: "+", │ │ │ │ + zoomInId: "olZoomInLink", │ │ │ │ + zoomOutText: "−", │ │ │ │ + zoomOutId: "olZoomOutLink", │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ + links = this.getOrCreateLinks(div), │ │ │ │ + zoomIn = links.zoomIn, │ │ │ │ + zoomOut = links.zoomOut, │ │ │ │ + eventsInstance = this.map.events; │ │ │ │ + if (zoomOut.parentNode !== div) { │ │ │ │ + eventsInstance = this.events; │ │ │ │ + eventsInstance.attachToElement(zoomOut.parentNode) │ │ │ │ + } │ │ │ │ + eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ + this.zoomInLink = zoomIn; │ │ │ │ + this.zoomOutLink = zoomOut; │ │ │ │ + return div │ │ │ │ + }, │ │ │ │ + getOrCreateLinks: function(el) { │ │ │ │ + var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ + zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ + if (!zoomIn) { │ │ │ │ + zoomIn = document.createElement("a"); │ │ │ │ + zoomIn.href = "#zoomIn"; │ │ │ │ + zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ + zoomIn.className = "olControlZoomIn"; │ │ │ │ + el.appendChild(zoomIn) │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ + if (!zoomOut) { │ │ │ │ + zoomOut = document.createElement("a"); │ │ │ │ + zoomOut.href = "#zoomOut"; │ │ │ │ + zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ + zoomOut.className = "olControlZoomOut"; │ │ │ │ + el.appendChild(zoomOut) │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ + return { │ │ │ │ + zoomIn: zoomIn, │ │ │ │ + zoomOut: zoomOut │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + onZoomClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.zoomInLink) { │ │ │ │ + this.map.zoomIn() │ │ │ │ + } else if (button === this.zoomOutLink) { │ │ │ │ + this.map.zoomOut() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onZoomClick) │ │ │ │ + } │ │ │ │ + delete this.zoomInLink; │ │ │ │ + delete this.zoomOutLink; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + EVENTMAP: { │ │ │ │ + click: { │ │ │ │ + in: "click", │ │ │ │ + out: "clickout" │ │ │ │ }, │ │ │ │ - tr: { │ │ │ │ - offset: new OpenLayers.Pixel(-45, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 19), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ - position: new OpenLayers.Pixel(-215, -687) │ │ │ │ - }] │ │ │ │ + mousemove: { │ │ │ │ + in: "over", │ │ │ │ + out: "out" │ │ │ │ }, │ │ │ │ - bl: { │ │ │ │ - offset: new OpenLayers.Pixel(45, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-101, -674) │ │ │ │ - }] │ │ │ │ + dblclick: { │ │ │ │ + in: "dblclick", │ │ │ │ + out: null │ │ │ │ }, │ │ │ │ - br: { │ │ │ │ - offset: new OpenLayers.Pixel(-44, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + mousedown: { │ │ │ │ + in: null, │ │ │ │ + out: null │ │ │ │ + }, │ │ │ │ + mouseup: { │ │ │ │ + in: null, │ │ │ │ + out: null │ │ │ │ + }, │ │ │ │ + touchstart: { │ │ │ │ + in: "click", │ │ │ │ + out: "clickout" │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + feature: null, │ │ │ │ + lastFeature: null, │ │ │ │ + down: null, │ │ │ │ + up: null, │ │ │ │ + clickTolerance: 4, │ │ │ │ + geometryTypes: null, │ │ │ │ + stopClick: true, │ │ │ │ + stopDown: true, │ │ │ │ + stopUp: false, │ │ │ │ + initialize: function(control, layer, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ + this.layer = layer │ │ │ │ + }, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return OpenLayers.Event.isMultiTouch(evt) ? true : this.mousedown(evt) │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + OpenLayers.Event.preventDefault(evt) │ │ │ │ + }, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ + this.down = evt.xy │ │ │ │ + } │ │ │ │ + return this.handle(evt) ? !this.stopDown : true │ │ │ │ + }, │ │ │ │ + mouseup: function(evt) { │ │ │ │ + this.up = evt.xy; │ │ │ │ + return this.handle(evt) ? !this.stopUp : true │ │ │ │ + }, │ │ │ │ + click: function(evt) { │ │ │ │ + return this.handle(evt) ? !this.stopClick : true │ │ │ │ + }, │ │ │ │ + mousemove: function(evt) { │ │ │ │ + if (!this.callbacks["over"] && !this.callbacks["out"]) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + this.handle(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + dblclick: function(evt) { │ │ │ │ + return !this.handle(evt) │ │ │ │ + }, │ │ │ │ + geometryTypeMatches: function(feature) { │ │ │ │ + return this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1 │ │ │ │ + }, │ │ │ │ + handle: function(evt) { │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + this.feature = null │ │ │ │ + } │ │ │ │ + var type = evt.type; │ │ │ │ + var handled = false; │ │ │ │ + var previouslyIn = !!this.feature; │ │ │ │ + var click = type == "click" || type == "dblclick" || type == "touchstart"; │ │ │ │ + this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + this.feature = null │ │ │ │ + } │ │ │ │ + if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ + this.lastFeature = null │ │ │ │ + } │ │ │ │ + if (this.feature) { │ │ │ │ + if (type === "touchstart") { │ │ │ │ + OpenLayers.Event.preventDefault(evt) │ │ │ │ + } │ │ │ │ + var inNew = this.feature != this.lastFeature; │ │ │ │ + if (this.geometryTypeMatches(this.feature)) { │ │ │ │ + if (previouslyIn && inNew) { │ │ │ │ + if (this.lastFeature) { │ │ │ │ + this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ + } │ │ │ │ + this.triggerCallback(type, "in", [this.feature]) │ │ │ │ + } else if (!previouslyIn || click) { │ │ │ │ + this.triggerCallback(type, "in", [this.feature]) │ │ │ │ + } │ │ │ │ + this.lastFeature = this.feature; │ │ │ │ + handled = true │ │ │ │ + } else { │ │ │ │ + if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ + this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ + } │ │ │ │ + this.feature = null │ │ │ │ + } │ │ │ │ + } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ + this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ + } │ │ │ │ + return handled │ │ │ │ + }, │ │ │ │ + triggerCallback: function(type, mode, args) { │ │ │ │ + var key = this.EVENTMAP[type][mode]; │ │ │ │ + if (key) { │ │ │ │ + if (type == "click" && this.up && this.down) { │ │ │ │ + var dpx = Math.sqrt(Math.pow(this.up.x - this.down.x, 2) + Math.pow(this.up.y - this.down.y, 2)); │ │ │ │ + if (dpx <= this.clickTolerance) { │ │ │ │ + this.callback(key, args) │ │ │ │ + } │ │ │ │ + this.up = this.down = null │ │ │ │ + } else { │ │ │ │ + this.callback(key, args) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + this.map.events.on({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + activated = true │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.moveLayerBack(); │ │ │ │ + this.feature = null; │ │ │ │ + this.lastFeature = null; │ │ │ │ + this.down = null; │ │ │ │ + this.up = null; │ │ │ │ + this.map.events.un({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + deactivated = true │ │ │ │ + } │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + handleMapEvents: function(evt) { │ │ │ │ + if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ + this.moveLayerToTop() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + moveLayerToTop: function() { │ │ │ │ + var index = Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) + 1; │ │ │ │ + this.layer.setZIndex(index) │ │ │ │ + }, │ │ │ │ + moveLayerBack: function() { │ │ │ │ + var index = this.layer.getZIndex() - 1; │ │ │ │ + if (index >= this.map.Z_INDEX_BASE["Feature"]) { │ │ │ │ + this.layer.setZIndex(index) │ │ │ │ + } else { │ │ │ │ + this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer)) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + layers: null, │ │ │ │ + display: function() {}, │ │ │ │ + getFeatureFromEvent: function(evt) { │ │ │ │ + var layers = this.layers; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0; i < layers.length; i++) { │ │ │ │ + feature = layers[i].getFeatureFromEvent(evt); │ │ │ │ + if (feature) { │ │ │ │ + return feature │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments); │ │ │ │ + this.collectRoots(); │ │ │ │ + map.events.register("changelayer", this, this.handleChangeLayer) │ │ │ │ + }, │ │ │ │ + removeMap: function(map) { │ │ │ │ + map.events.unregister("changelayer", this, this.handleChangeLayer); │ │ │ │ + this.resetRoots(); │ │ │ │ + OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + collectRoots: function() { │ │ │ │ + var layer; │ │ │ │ + for (var i = 0; i < this.map.layers.length; ++i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ + layer.renderer.moveRoot(this.renderer) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + resetRoots: function() { │ │ │ │ + var layer; │ │ │ │ + for (var i = 0; i < this.layers.length; ++i) { │ │ │ │ + layer = this.layers[i]; │ │ │ │ + if (this.renderer && layer.renderer.getRenderLayerId() == this.id) { │ │ │ │ + this.renderer.moveRoot(layer.renderer) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + handleChangeLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (evt.property == "order" && OpenLayers.Util.indexOf(this.layers, layer) != -1) { │ │ │ │ + this.resetRoots(); │ │ │ │ + this.collectRoots() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + multipleKey: null, │ │ │ │ + toggleKey: null, │ │ │ │ + multiple: false, │ │ │ │ + clickout: true, │ │ │ │ + toggle: false, │ │ │ │ + hover: false, │ │ │ │ + highlightOnly: false, │ │ │ │ + box: false, │ │ │ │ + onBeforeSelect: function() {}, │ │ │ │ + onSelect: function() {}, │ │ │ │ + onUnselect: function() {}, │ │ │ │ + scope: null, │ │ │ │ + geometryTypes: null, │ │ │ │ + layer: null, │ │ │ │ + layers: null, │ │ │ │ + callbacks: null, │ │ │ │ + selectStyle: null, │ │ │ │ + renderIntent: "select", │ │ │ │ + handlers: null, │ │ │ │ + initialize: function(layers, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (this.scope === null) { │ │ │ │ + this.scope = this │ │ │ │ + } │ │ │ │ + this.initLayer(layers); │ │ │ │ + var callbacks = { │ │ │ │ + click: this.clickFeature, │ │ │ │ + clickout: this.clickoutFeature │ │ │ │ + }; │ │ │ │ + if (this.hover) { │ │ │ │ + callbacks.over = this.overFeature; │ │ │ │ + callbacks.out = this.outFeature │ │ │ │ + } │ │ │ │ + this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ + this.handlers = { │ │ │ │ + feature: new OpenLayers.Handler.Feature(this, this.layer, this.callbacks, { │ │ │ │ + geometryTypes: this.geometryTypes │ │ │ │ + }) │ │ │ │ + }; │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.selectBox │ │ │ │ }, { │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ - position: new OpenLayers.Pixel(-311, -674) │ │ │ │ - }] │ │ │ │ + boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - minSize: new OpenLayers.Size(105, 10), │ │ │ │ - maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ - this.imageSrc = OpenLayers.Util.getImageLocation("cloud-popup-relative.png"); │ │ │ │ - OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass │ │ │ │ + initLayer: function(layers) { │ │ │ │ + if (OpenLayers.Util.isArray(layers)) { │ │ │ │ + this.layers = layers; │ │ │ │ + this.layer = new OpenLayers.Layer.Vector.RootContainer(this.id + "_container", { │ │ │ │ + layers: layers │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + this.layer = layers │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active && this.layers) { │ │ │ │ + this.map.removeLayer(this.layer) │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.addLayer(this.layer) │ │ │ │ + } │ │ │ │ + this.handlers.feature.activate(); │ │ │ │ + if (this.box && this.handlers.box) { │ │ │ │ + this.handlers.box.activate() │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.feature.deactivate(); │ │ │ │ + if (this.handlers.box) { │ │ │ │ + this.handlers.box.deactivate() │ │ │ │ + } │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.removeLayer(this.layer) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + unselectAll: function(options) { │ │ │ │ + var layers = this.layers || [this.layer], │ │ │ │ + layer, feature, l, numExcept; │ │ │ │ + for (l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + numExcept = 0; │ │ │ │ + if (layer.selectedFeatures != null) { │ │ │ │ + while (layer.selectedFeatures.length > numExcept) { │ │ │ │ + feature = layer.selectedFeatures[numExcept]; │ │ │ │ + if (!options || options.except != feature) { │ │ │ │ + this.unselect(feature) │ │ │ │ + } else { │ │ │ │ + ++numExcept │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clickFeature: function(feature) { │ │ │ │ + if (!this.hover) { │ │ │ │ + var selected = OpenLayers.Util.indexOf(feature.layer.selectedFeatures, feature) > -1; │ │ │ │ + if (selected) { │ │ │ │ + if (this.toggleSelect()) { │ │ │ │ + this.unselect(feature) │ │ │ │ + } else if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + this.select(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + multipleSelect: function() { │ │ │ │ + return this.multiple || this.handlers.feature.evt && this.handlers.feature.evt[this.multipleKey] │ │ │ │ + }, │ │ │ │ + toggleSelect: function() { │ │ │ │ + return this.toggle || this.handlers.feature.evt && this.handlers.feature.evt[this.toggleKey] │ │ │ │ + }, │ │ │ │ + clickoutFeature: function(feature) { │ │ │ │ + if (!this.hover && this.clickout) { │ │ │ │ + this.unselectAll() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + overFeature: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + this.highlight(feature) │ │ │ │ + } else if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + outFeature: function(feature) { │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + if (feature._lastHighlighter == this.id) { │ │ │ │ + if (feature._prevHighlighter && feature._prevHighlighter != this.id) { │ │ │ │ + delete feature._lastHighlighter; │ │ │ │ + var control = this.map.getControl(feature._prevHighlighter); │ │ │ │ + if (control) { │ │ │ │ + control.highlight(feature) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unhighlight(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unselect(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + highlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ + feature._lastHighlighter = this.id; │ │ │ │ + var style = this.selectStyle || this.renderIntent; │ │ │ │ + layer.drawFeature(feature, style); │ │ │ │ + this.events.triggerEvent("featurehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + unhighlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (feature._prevHighlighter == undefined) { │ │ │ │ + delete feature._lastHighlighter │ │ │ │ + } else if (feature._prevHighlighter == this.id) { │ │ │ │ + delete feature._prevHighlighter │ │ │ │ + } else { │ │ │ │ + feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ + delete feature._prevHighlighter │ │ │ │ + } │ │ │ │ + layer.drawFeature(feature, feature.style || feature.layer.style || "default"); │ │ │ │ + this.events.triggerEvent("featureunhighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + select: function(feature) { │ │ │ │ + var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (cont !== false) { │ │ │ │ + cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + layer.selectedFeatures.push(feature); │ │ │ │ + this.highlight(feature); │ │ │ │ + if (!this.handlers.feature.lastFeature) { │ │ │ │ + this.handlers.feature.lastFeature = layer.selectedFeatures[0] │ │ │ │ + } │ │ │ │ + layer.events.triggerEvent("featureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onSelect.call(this.scope, feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + unselect: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + this.unhighlight(feature); │ │ │ │ + OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ + layer.events.triggerEvent("featureunselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onUnselect.call(this.scope, feature) │ │ │ │ + }, │ │ │ │ + selectBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + var bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat); │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll() │ │ │ │ + } │ │ │ │ + var prevMultiple = this.multiple; │ │ │ │ + this.multiple = true; │ │ │ │ + var layers = this.layers || [this.layer]; │ │ │ │ + this.events.triggerEvent("boxselectionstart", { │ │ │ │ + layers: layers │ │ │ │ + }); │ │ │ │ + var layer; │ │ │ │ + for (var l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ + var feature = layer.features[i]; │ │ │ │ + if (!feature.getVisibility()) { │ │ │ │ + continue │ │ │ │ + } │ │ │ │ + if (this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ + if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ + if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.multiple = prevMultiple; │ │ │ │ + this.events.triggerEvent("boxselectionend", { │ │ │ │ + layers: layers │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.feature.setMap(map); │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box.setMap(map) │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + setLayer: function(layers) { │ │ │ │ + var isActive = this.active; │ │ │ │ + this.unselectAll(); │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy(); │ │ │ │ + this.layers = null │ │ │ │ + } │ │ │ │ + this.initLayer(layers); │ │ │ │ + this.handlers.feature.layer = this.layer; │ │ │ │ + if (isActive) { │ │ │ │ + this.activate() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ }); │ │ ├── ./usr/share/javascript/openlayers/OpenLayers.min.js │ │ │ ├── js-beautify {} │ │ │ │ @@ -2063,547 +2063,453 @@ │ │ │ │ _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.Feature = OpenLayers.Class({ │ │ │ │ - layer: null, │ │ │ │ - id: null, │ │ │ │ +OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ + events: null, │ │ │ │ + id: "", │ │ │ │ lonlat: null, │ │ │ │ - data: null, │ │ │ │ - marker: null, │ │ │ │ - popupClass: null, │ │ │ │ - popup: null, │ │ │ │ - initialize: function(layer, lonlat, data) { │ │ │ │ - this.layer = layer; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - this.data = data != null ? data : {}; │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + div: null, │ │ │ │ + contentSize: null, │ │ │ │ + size: null, │ │ │ │ + contentHTML: null, │ │ │ │ + backgroundColor: "", │ │ │ │ + opacity: "", │ │ │ │ + border: "", │ │ │ │ + contentDiv: null, │ │ │ │ + groupDiv: null, │ │ │ │ + closeDiv: null, │ │ │ │ + autoSize: false, │ │ │ │ + minSize: null, │ │ │ │ + maxSize: null, │ │ │ │ + displayClass: "olPopup", │ │ │ │ + contentDisplayClass: "olPopupContent", │ │ │ │ + padding: 0, │ │ │ │ + disableFirefoxOverflowHack: false, │ │ │ │ + fixPadding: function() { │ │ │ │ + if (typeof this.padding == "number") { │ │ │ │ + this.padding = new OpenLayers.Bounds(this.padding, this.padding, this.padding, this.padding) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layer != null && this.layer.map != null) { │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.layer.map.removePopup(this.popup) │ │ │ │ - } │ │ │ │ + panMapIfOutOfView: false, │ │ │ │ + keepInMap: false, │ │ │ │ + closeOnMove: false, │ │ │ │ + map: null, │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ + if (id == null) { │ │ │ │ + id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ } │ │ │ │ - if (this.layer != null && this.marker != null) { │ │ │ │ - this.layer.removeMarker(this.marker) │ │ │ │ + this.id = id; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + this.contentSize = contentSize != null ? contentSize : new OpenLayers.Size(OpenLayers.Popup.WIDTH, OpenLayers.Popup.HEIGHT); │ │ │ │ + if (contentHTML != null) { │ │ │ │ + this.contentHTML = contentHTML │ │ │ │ } │ │ │ │ - this.layer = null; │ │ │ │ + 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 = this.displayClass; │ │ │ │ + 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.contentSize.clone(), null, "relative"); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass; │ │ │ │ + this.groupDiv.appendChild(this.contentDiv); │ │ │ │ + this.div.appendChild(this.groupDiv); │ │ │ │ + if (closeBox) { │ │ │ │ + this.addCloseBox(closeBoxCallback) │ │ │ │ + } │ │ │ │ + this.registerEvents() │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ this.id = null; │ │ │ │ this.lonlat = null; │ │ │ │ - this.data = null; │ │ │ │ - if (this.marker != null) { │ │ │ │ - this.destroyMarker(this.marker); │ │ │ │ - this.marker = null │ │ │ │ - } │ │ │ │ - if (this.popup != null) { │ │ │ │ - this.destroyPopup(this.popup); │ │ │ │ - this.popup = null │ │ │ │ + this.size = null; │ │ │ │ + this.contentHTML = null; │ │ │ │ + this.backgroundColor = null; │ │ │ │ + this.opacity = null; │ │ │ │ + this.border = null; │ │ │ │ + if (this.closeOnMove && this.map) { │ │ │ │ + this.map.events.unregister("movestart", this, this.hide) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - onScreen: function() { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.layer != null && this.layer.map != null) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsLonLat(this.lonlat) │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ + if (this.closeDiv) { │ │ │ │ + OpenLayers.Event.stopObservingElement(this.closeDiv); │ │ │ │ + this.groupDiv.removeChild(this.closeDiv) │ │ │ │ } │ │ │ │ - return onScreen │ │ │ │ - }, │ │ │ │ - createMarker: function() { │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon) │ │ │ │ + this.closeDiv = null; │ │ │ │ + this.div.removeChild(this.groupDiv); │ │ │ │ + this.groupDiv = null; │ │ │ │ + if (this.map != null) { │ │ │ │ + this.map.removePopup(this) │ │ │ │ } │ │ │ │ - return this.marker │ │ │ │ - }, │ │ │ │ - destroyMarker: function() { │ │ │ │ - this.marker.destroy() │ │ │ │ + this.map = null; │ │ │ │ + this.div = null; │ │ │ │ + this.autoSize = null; │ │ │ │ + this.minSize = null; │ │ │ │ + this.maxSize = null; │ │ │ │ + this.padding = null; │ │ │ │ + this.panMapIfOutOfView = null │ │ │ │ }, │ │ │ │ - createPopup: function(closeBox) { │ │ │ │ - if (this.lonlat != null) { │ │ │ │ - if (!this.popup) { │ │ │ │ - var anchor = this.marker ? this.marker.icon : null; │ │ │ │ - var popupClass = this.popupClass ? this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ - this.popup = new popupClass(this.id + "_popup", this.lonlat, this.data.popupSize, this.data.popupContentHTML, anchor, closeBox) │ │ │ │ - } │ │ │ │ - if (this.data.overflow != null) { │ │ │ │ - this.popup.contentDiv.style.overflow = this.data.overflow │ │ │ │ + draw: function(px) { │ │ │ │ + if (px == null) { │ │ │ │ + if (this.lonlat != null && this.map != null) { │ │ │ │ + px = this.map.getLayerPxFromLonLat(this.lonlat) │ │ │ │ } │ │ │ │ - this.popup.feature = this │ │ │ │ } │ │ │ │ - return this.popup │ │ │ │ - }, │ │ │ │ - destroyPopup: function() { │ │ │ │ - if (this.popup) { │ │ │ │ - this.popup.feature = null; │ │ │ │ - this.popup.destroy(); │ │ │ │ - this.popup = null │ │ │ │ + if (this.closeOnMove) { │ │ │ │ + this.map.events.register("movestart", this, this.hide) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Feature" │ │ │ │ -}); │ │ │ │ -OpenLayers.State = { │ │ │ │ - UNKNOWN: "Unknown", │ │ │ │ - INSERT: "Insert", │ │ │ │ - UPDATE: "Update", │ │ │ │ - DELETE: "Delete" │ │ │ │ -}; │ │ │ │ -OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ - fid: null, │ │ │ │ - geometry: null, │ │ │ │ - attributes: null, │ │ │ │ - bounds: null, │ │ │ │ - state: null, │ │ │ │ - style: null, │ │ │ │ - url: null, │ │ │ │ - renderIntent: "default", │ │ │ │ - modified: null, │ │ │ │ - initialize: function(geometry, attributes, style) { │ │ │ │ - OpenLayers.Feature.prototype.initialize.apply(this, [null, null, attributes]); │ │ │ │ - this.lonlat = null; │ │ │ │ - this.geometry = geometry ? geometry : null; │ │ │ │ - this.state = null; │ │ │ │ - this.attributes = {}; │ │ │ │ - if (attributes) { │ │ │ │ - this.attributes = OpenLayers.Util.extend(this.attributes, attributes) │ │ │ │ + if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == "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.style = style ? style : null │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layer) { │ │ │ │ - this.layer.removeFeatures(this); │ │ │ │ - this.layer = null │ │ │ │ + this.moveTo(px); │ │ │ │ + if (!this.autoSize && !this.size) { │ │ │ │ + this.setSize(this.contentSize) │ │ │ │ } │ │ │ │ - this.geometry = null; │ │ │ │ - this.modified = null; │ │ │ │ - OpenLayers.Feature.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Feature.Vector(this.geometry ? this.geometry.clone() : null, this.attributes, this.style) │ │ │ │ + this.setBackgroundColor(); │ │ │ │ + this.setOpacity(); │ │ │ │ + this.setBorder(); │ │ │ │ + this.setContentHTML(); │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView() │ │ │ │ + } │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - onScreen: function(boundsOnly) { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.layer && this.layer.map) { │ │ │ │ - var screenBounds = this.layer.map.getExtent(); │ │ │ │ - if (boundsOnly) { │ │ │ │ - var featureBounds = this.geometry.getBounds(); │ │ │ │ - onScreen = screenBounds.intersectsBounds(featureBounds) │ │ │ │ - } else { │ │ │ │ - var screenPoly = screenBounds.toGeometry(); │ │ │ │ - onScreen = screenPoly.intersects(this.geometry) │ │ │ │ + updatePosition: function() { │ │ │ │ + if (this.lonlat && this.map) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + if (px) { │ │ │ │ + this.moveTo(px) │ │ │ │ } │ │ │ │ } │ │ │ │ - return onScreen │ │ │ │ }, │ │ │ │ - getVisibility: function() { │ │ │ │ - return !(this.style && this.style.display == "none" || !this.layer || this.layer && this.layer.styleMap && this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == "none" || this.layer && !this.layer.getVisibility()) │ │ │ │ + moveTo: function(px) { │ │ │ │ + if (px != null && this.div != null) { │ │ │ │ + this.div.style.left = px.x + "px"; │ │ │ │ + this.div.style.top = px.y + "px" │ │ │ │ + } │ │ │ │ }, │ │ │ │ - createMarker: function() { │ │ │ │ - return null │ │ │ │ + visible: function() { │ │ │ │ + return OpenLayers.Element.visible(this.div) │ │ │ │ }, │ │ │ │ - destroyMarker: function() {}, │ │ │ │ - createPopup: function() { │ │ │ │ - return null │ │ │ │ + toggle: function() { │ │ │ │ + if (this.visible()) { │ │ │ │ + this.hide() │ │ │ │ + } else { │ │ │ │ + this.show() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ - var atPoint = false; │ │ │ │ - if (this.geometry) { │ │ │ │ - atPoint = this.geometry.atPoint(lonlat, toleranceLon, toleranceLat) │ │ │ │ + show: function() { │ │ │ │ + this.div.style.display = ""; │ │ │ │ + if (this.panMapIfOutOfView) { │ │ │ │ + this.panIntoView() │ │ │ │ } │ │ │ │ - return atPoint │ │ │ │ }, │ │ │ │ - destroyPopup: function() {}, │ │ │ │ - move: function(location) { │ │ │ │ - if (!this.layer || !this.geometry.move) { │ │ │ │ - return undefined │ │ │ │ + hide: function() { │ │ │ │ + this.div.style.display = "none" │ │ │ │ + }, │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + this.size = contentSize.clone(); │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ + var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - var pixel; │ │ │ │ - if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ - pixel = this.layer.getViewPortPxFromLonLat(location) │ │ │ │ - } else { │ │ │ │ - pixel = location │ │ │ │ + this.size.w += wPadding; │ │ │ │ + this.size.h += hPadding; │ │ │ │ + if (OpenLayers.BROWSER_NAME == "msie") { │ │ │ │ + this.contentSize.w += contentDivPadding.left + contentDivPadding.right; │ │ │ │ + this.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" │ │ │ │ } │ │ │ │ - var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ - var res = this.layer.map.getResolution(); │ │ │ │ - this.geometry.move(res * (pixel.x - lastPixel.x), res * (lastPixel.y - pixel.y)); │ │ │ │ - this.layer.drawFeature(this); │ │ │ │ - return lastPixel │ │ │ │ }, │ │ │ │ - toState: function(state) { │ │ │ │ - if (state == OpenLayers.State.UPDATE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - this.state = state; │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.INSERT) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - this.state = state; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (state == OpenLayers.State.DELETE) { │ │ │ │ - switch (this.state) { │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UNKNOWN: │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - this.state = state; │ │ │ │ - break │ │ │ │ + updateSize: function() { │ │ │ │ + var preparedHTML = "<div class='" + this.contentDisplayClass + "'>" + this.contentDiv.innerHTML + "</div>"; │ │ │ │ + var containerElement = this.map ? this.map.div : document.body; │ │ │ │ + var realSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, null, { │ │ │ │ + displayClass: this.displayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + }); │ │ │ │ + var safeSize = this.getSafeContentSize(realSize); │ │ │ │ + var newSize = null; │ │ │ │ + if (safeSize.equals(realSize)) { │ │ │ │ + newSize = realSize │ │ │ │ + } else { │ │ │ │ + var fixedSize = { │ │ │ │ + w: safeSize.w < realSize.w ? safeSize.w : null, │ │ │ │ + h: safeSize.h < realSize.h ? safeSize.h : null │ │ │ │ + }; │ │ │ │ + if (fixedSize.w && fixedSize.h) { │ │ │ │ + newSize = safeSize │ │ │ │ + } else { │ │ │ │ + var clippedSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, fixedSize, { │ │ │ │ + displayClass: this.contentDisplayClass, │ │ │ │ + containerElement: containerElement │ │ │ │ + }); │ │ │ │ + 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) │ │ │ │ } │ │ │ │ - } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ - this.state = state │ │ │ │ } │ │ │ │ + this.setSize(newSize) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ -}); │ │ │ │ -OpenLayers.Feature.Vector.style = { │ │ │ │ - default: { │ │ │ │ - fillColor: "#ee9900", │ │ │ │ - fillOpacity: .4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: .8, │ │ │ │ - strokeColor: "#ee9900", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: .2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - select: { │ │ │ │ - fillColor: "blue", │ │ │ │ - fillOpacity: .4, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: .8, │ │ │ │ - strokeColor: "blue", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: .2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "pointer", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - temporary: { │ │ │ │ - fillColor: "#66cccc", │ │ │ │ - fillOpacity: .2, │ │ │ │ - hoverFillColor: "white", │ │ │ │ - hoverFillOpacity: .8, │ │ │ │ - strokeColor: "#66cccc", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeLinecap: "round", │ │ │ │ - strokeWidth: 2, │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - hoverStrokeColor: "red", │ │ │ │ - hoverStrokeOpacity: 1, │ │ │ │ - hoverStrokeWidth: .2, │ │ │ │ - pointRadius: 6, │ │ │ │ - hoverPointRadius: 1, │ │ │ │ - hoverPointUnit: "%", │ │ │ │ - pointerEvents: "visiblePainted", │ │ │ │ - cursor: "inherit", │ │ │ │ - fontColor: "#000000", │ │ │ │ - labelAlign: "cm", │ │ │ │ - labelOutlineColor: "white", │ │ │ │ - labelOutlineWidth: 3 │ │ │ │ - }, │ │ │ │ - delete: { │ │ │ │ - display: "none" │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -OpenLayers.Style = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - name: null, │ │ │ │ - title: null, │ │ │ │ - description: null, │ │ │ │ - layerName: null, │ │ │ │ - isDefault: false, │ │ │ │ - rules: null, │ │ │ │ - context: null, │ │ │ │ - defaultStyle: null, │ │ │ │ - defaultsPerSymbolizer: false, │ │ │ │ - propertyStyles: null, │ │ │ │ - initialize: function(style, options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.rules = []; │ │ │ │ - if (options && options.rules) { │ │ │ │ - this.addRules(options.rules) │ │ │ │ + setBackgroundColor: function(color) { │ │ │ │ + if (color != undefined) { │ │ │ │ + this.backgroundColor = color │ │ │ │ + } │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.backgroundColor = this.backgroundColor │ │ │ │ } │ │ │ │ - this.setDefaultStyle(style || OpenLayers.Feature.Vector.style["default"]); │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ - this.rules[i].destroy(); │ │ │ │ - this.rules[i] = null │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + if (opacity != undefined) { │ │ │ │ + this.opacity = opacity │ │ │ │ + } │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.opacity = this.opacity; │ │ │ │ + this.div.style.filter = "alpha(opacity=" + this.opacity * 100 + ")" │ │ │ │ } │ │ │ │ - this.rules = null; │ │ │ │ - this.defaultStyle = null │ │ │ │ }, │ │ │ │ - createSymbolizer: function(feature) { │ │ │ │ - var style = this.defaultsPerSymbolizer ? {} : this.createLiterals(OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ - var rules = this.rules; │ │ │ │ - var rule, context; │ │ │ │ - var elseRules = []; │ │ │ │ - var appliedRules = false; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - rule = rules[i]; │ │ │ │ - var applies = rule.evaluate(feature); │ │ │ │ - if (applies) { │ │ │ │ - if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ - elseRules.push(rule) │ │ │ │ - } else { │ │ │ │ - appliedRules = true; │ │ │ │ - this.applySymbolizer(rule, style, feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + setBorder: function(border) { │ │ │ │ + if (border != undefined) { │ │ │ │ + this.border = border │ │ │ │ } │ │ │ │ - if (appliedRules == false && elseRules.length > 0) { │ │ │ │ - appliedRules = true; │ │ │ │ - for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ - this.applySymbolizer(elseRules[i], style, feature) │ │ │ │ - } │ │ │ │ + if (this.div != null) { │ │ │ │ + this.div.style.border = this.border │ │ │ │ } │ │ │ │ - if (rules.length > 0 && appliedRules == false) { │ │ │ │ - style.display = "none" │ │ │ │ + }, │ │ │ │ + setContentHTML: function(contentHTML) { │ │ │ │ + if (contentHTML != null) { │ │ │ │ + this.contentHTML = contentHTML │ │ │ │ } │ │ │ │ - if (style.label != null && typeof style.label !== "string") { │ │ │ │ - style.label = String(style.label) │ │ │ │ + if (this.contentDiv != null && this.contentHTML != null && this.contentHTML != this.contentDiv.innerHTML) { │ │ │ │ + this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ + if (this.autoSize) { │ │ │ │ + this.registerImageListeners(); │ │ │ │ + this.updateSize() │ │ │ │ + } │ │ │ │ } │ │ │ │ - return style │ │ │ │ }, │ │ │ │ - applySymbolizer: function(rule, style, feature) { │ │ │ │ - var symbolizerPrefix = feature.geometry ? this.getSymbolizerPrefix(feature.geometry) : OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ - var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ - if (this.defaultsPerSymbolizer === true) { │ │ │ │ - var defaults = this.defaultStyle; │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: defaults.pointRadius │ │ │ │ - }); │ │ │ │ - if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - strokeWidth: defaults.strokeWidth, │ │ │ │ - strokeColor: defaults.strokeColor, │ │ │ │ - strokeOpacity: defaults.strokeOpacity, │ │ │ │ - strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ - strokeLinecap: defaults.strokeLinecap │ │ │ │ - }) │ │ │ │ + registerImageListeners: function() { │ │ │ │ + var onImgLoad = function() { │ │ │ │ + if (this.popup.id === null) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - fillColor: defaults.fillColor, │ │ │ │ - fillOpacity: defaults.fillOpacity │ │ │ │ - }) │ │ │ │ + this.popup.updateSize(); │ │ │ │ + if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ + this.popup.panIntoView() │ │ │ │ } │ │ │ │ - if (symbolizer.graphic === true) { │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ - pointRadius: this.defaultStyle.pointRadius, │ │ │ │ - externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ - graphicName: this.defaultStyle.graphicName, │ │ │ │ - graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ - graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ - graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ - graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ - graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ - }) │ │ │ │ + OpenLayers.Event.stopObserving(this.img, "load", this.img._onImgLoad) │ │ │ │ + }; │ │ │ │ + var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ + for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ + var img = images[i]; │ │ │ │ + if (img.width == 0 || img.height == 0) { │ │ │ │ + var context = { │ │ │ │ + popup: this, │ │ │ │ + img: img │ │ │ │ + }; │ │ │ │ + img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ + OpenLayers.Event.observe(img, "load", img._onImgLoad) │ │ │ │ } │ │ │ │ } │ │ │ │ - return this.createLiterals(OpenLayers.Util.extend(style, symbolizer), feature) │ │ │ │ }, │ │ │ │ - createLiterals: function(style, feature) { │ │ │ │ - var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ - OpenLayers.Util.extend(context, this.context); │ │ │ │ - for (var i in this.propertyStyles) { │ │ │ │ - style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i) │ │ │ │ + getSafeContentSize: function(size) { │ │ │ │ + var safeContentSize = size.clone(); │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ + var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - return style │ │ │ │ - }, │ │ │ │ - findPropertyStyles: function() { │ │ │ │ - var propertyStyles = {}; │ │ │ │ - var style = this.defaultStyle; │ │ │ │ - this.addPropertyStyles(propertyStyles, style); │ │ │ │ - var rules = this.rules; │ │ │ │ - var symbolizer, value; │ │ │ │ - for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ - symbolizer = rules[i].symbolizer; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - value = symbolizer[key]; │ │ │ │ - if (typeof value == "object") { │ │ │ │ - this.addPropertyStyles(propertyStyles, value) │ │ │ │ - } else { │ │ │ │ - this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ - break │ │ │ │ + if (this.minSize) { │ │ │ │ + safeContentSize.w = Math.max(safeContentSize.w, this.minSize.w - wPadding); │ │ │ │ + safeContentSize.h = Math.max(safeContentSize.h, this.minSize.h - hPadding) │ │ │ │ + } │ │ │ │ + if (this.maxSize) { │ │ │ │ + safeContentSize.w = Math.min(safeContentSize.w, this.maxSize.w - wPadding); │ │ │ │ + safeContentSize.h = Math.min(safeContentSize.h, this.maxSize.h - hPadding) │ │ │ │ + } │ │ │ │ + if (this.map && this.map.size) { │ │ │ │ + var extraX = 0, │ │ │ │ + extraY = 0; │ │ │ │ + if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ + var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ + switch (this.relativePosition) { │ │ │ │ + case "tr": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "tl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break; │ │ │ │ + case "bl": │ │ │ │ + extraX = this.map.size.w - px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + case "br": │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = px.y; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + extraX = px.x; │ │ │ │ + extraY = this.map.size.h - px.y; │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ + var maxY = this.map.size.h - this.map.paddingForPopups.top - this.map.paddingForPopups.bottom - hPadding - extraY; │ │ │ │ + var maxX = this.map.size.w - this.map.paddingForPopups.left - this.map.paddingForPopups.right - wPadding - extraX; │ │ │ │ + safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ + safeContentSize.h = Math.min(safeContentSize.h, maxY) │ │ │ │ } │ │ │ │ - return propertyStyles │ │ │ │ + return safeContentSize │ │ │ │ }, │ │ │ │ - addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ - var property; │ │ │ │ - for (var key in symbolizer) { │ │ │ │ - property = symbolizer[key]; │ │ │ │ - if (typeof property == "string" && property.match(/\$\{\w+\}/)) { │ │ │ │ - propertyStyles[key] = true │ │ │ │ + getContentDivPadding: function() { │ │ │ │ + var contentDivPadding = this._contentDivPadding; │ │ │ │ + if (!contentDivPadding) { │ │ │ │ + if (this.div.parentNode == null) { │ │ │ │ + this.div.style.display = "none"; │ │ │ │ + document.body.appendChild(this.div) │ │ │ │ + } │ │ │ │ + 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")); │ │ │ │ + this._contentDivPadding = contentDivPadding; │ │ │ │ + if (this.div.parentNode == document.body) { │ │ │ │ + document.body.removeChild(this.div); │ │ │ │ + this.div.style.display = "" │ │ │ │ } │ │ │ │ } │ │ │ │ - return propertyStyles │ │ │ │ - }, │ │ │ │ - addRules: function(rules) { │ │ │ │ - Array.prototype.push.apply(this.rules, rules); │ │ │ │ - this.propertyStyles = this.findPropertyStyles() │ │ │ │ + return contentDivPadding │ │ │ │ }, │ │ │ │ - setDefaultStyle: function(style) { │ │ │ │ - this.defaultStyle = style; │ │ │ │ - this.propertyStyles = this.findPropertyStyles() │ │ │ │ + addCloseBox: function(callback) { │ │ │ │ + this.closeDiv = OpenLayers.Util.createDiv(this.id + "_close", null, { │ │ │ │ + w: 17, │ │ │ │ + h: 17 │ │ │ │ + }); │ │ │ │ + this.closeDiv.className = "olPopupCloseBox"; │ │ │ │ + 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, "touchend", OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ + OpenLayers.Event.observe(this.closeDiv, "click", OpenLayers.Function.bindAsEventListener(closePopup, this)) │ │ │ │ }, │ │ │ │ - getSymbolizerPrefix: function(geometry) { │ │ │ │ - var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ - for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ - if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ - return prefixes[i] │ │ │ │ - } │ │ │ │ + panIntoView: function() { │ │ │ │ + var mapSize = this.map.getSize(); │ │ │ │ + var origTL = this.map.getViewPortPxFromLayerPx(new OpenLayers.Pixel(parseInt(this.div.style.left), parseInt(this.div.style.top))); │ │ │ │ + var newTL = origTL.clone(); │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.rules) { │ │ │ │ - options.rules = []; │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ - options.rules.push(this.rules[i].clone()) │ │ │ │ - } │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ - return new OpenLayers.Style(defaultStyle, options) │ │ │ │ + var dx = origTL.x - newTL.x; │ │ │ │ + var dy = origTL.y - newTL.y; │ │ │ │ + this.map.pan(dx, dy) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Style" │ │ │ │ -}); │ │ │ │ -OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ - if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ - value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ - value = isNaN(value) || !value ? value : parseFloat(value) │ │ │ │ - } │ │ │ │ - return value │ │ │ │ -}; │ │ │ │ -OpenLayers.Style.SYMBOLIZER_PREFIXES = ["Point", "Line", "Polygon", "Text", "Raster"]; │ │ │ │ -OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - name: null, │ │ │ │ - title: null, │ │ │ │ - description: null, │ │ │ │ - context: null, │ │ │ │ - filter: null, │ │ │ │ - elseFilter: false, │ │ │ │ - symbolizer: null, │ │ │ │ - symbolizers: null, │ │ │ │ - minScaleDenominator: null, │ │ │ │ - maxScaleDenominator: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.symbolizer = {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - delete this.symbolizer │ │ │ │ + registerEvents: function() { │ │ │ │ + this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ + │ │ │ │ + function onTouchstart(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ } │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + this.events.on({ │ │ │ │ + mousedown: this.onmousedown, │ │ │ │ + mousemove: this.onmousemove, │ │ │ │ + mouseup: this.onmouseup, │ │ │ │ + click: this.onclick, │ │ │ │ + mouseout: this.onmouseout, │ │ │ │ + dblclick: this.ondblclick, │ │ │ │ + touchstart: onTouchstart, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i in this.symbolizer) { │ │ │ │ - this.symbolizer[i] = null │ │ │ │ - } │ │ │ │ - this.symbolizer = null; │ │ │ │ - delete this.symbolizers │ │ │ │ + onmousedown: function(evt) { │ │ │ │ + this.mousedown = true; │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ }, │ │ │ │ - evaluate: function(feature) { │ │ │ │ - var context = this.getContext(feature); │ │ │ │ - var applies = true; │ │ │ │ - if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ - var scale = feature.layer.map.getScale() │ │ │ │ - } │ │ │ │ - if (this.minScaleDenominator) { │ │ │ │ - applies = scale >= OpenLayers.Style.createLiteral(this.minScaleDenominator, context) │ │ │ │ - } │ │ │ │ - if (applies && this.maxScaleDenominator) { │ │ │ │ - applies = scale < OpenLayers.Style.createLiteral(this.maxScaleDenominator, context) │ │ │ │ - } │ │ │ │ - if (applies && this.filter) { │ │ │ │ - if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ - applies = this.filter.evaluate(feature) │ │ │ │ - } else { │ │ │ │ - applies = this.filter.evaluate(context) │ │ │ │ - } │ │ │ │ + onmousemove: function(evt) { │ │ │ │ + if (this.mousedown) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ } │ │ │ │ - return applies │ │ │ │ }, │ │ │ │ - getContext: function(feature) { │ │ │ │ - var context = this.context; │ │ │ │ - if (!context) { │ │ │ │ - context = feature.attributes || feature.data │ │ │ │ - } │ │ │ │ - if (typeof this.context == "function") { │ │ │ │ - context = this.context(feature) │ │ │ │ + onmouseup: function(evt) { │ │ │ │ + if (this.mousedown) { │ │ │ │ + this.mousedown = false; │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ } │ │ │ │ - return context │ │ │ │ }, │ │ │ │ - clone: function() { │ │ │ │ - var options = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.symbolizers) { │ │ │ │ - var len = this.symbolizers.length; │ │ │ │ - options.symbolizers = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - options.symbolizers[i] = this.symbolizers[i].clone() │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - options.symbolizer = {}; │ │ │ │ - var value, type; │ │ │ │ - for (var key in this.symbolizer) { │ │ │ │ - value = this.symbolizer[key]; │ │ │ │ - type = typeof value; │ │ │ │ - if (type === "object") { │ │ │ │ - options.symbolizer[key] = OpenLayers.Util.extend({}, value) │ │ │ │ - } else if (type === "string") { │ │ │ │ - options.symbolizer[key] = value │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - options.filter = this.filter && this.filter.clone(); │ │ │ │ - options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ - return new OpenLayers.Rule(options) │ │ │ │ + onclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt, true) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Rule" │ │ │ │ + onmouseout: function(evt) { │ │ │ │ + this.mousedown = false │ │ │ │ + }, │ │ │ │ + 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.Util = OpenLayers.Util || {}; │ │ │ │ OpenLayers.Util.vendorPrefix = function() { │ │ │ │ "use strict"; │ │ │ │ var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ divStyle = document.createElement("div").style, │ │ │ │ cssCache = {}, │ │ │ │ jsCache = {}; │ │ │ │ @@ -2660,163 +2566,14 @@ │ │ │ │ css: css, │ │ │ │ js: js, │ │ │ │ style: style, │ │ │ │ cssCache: cssCache, │ │ │ │ jsCache: jsCache │ │ │ │ } │ │ │ │ }(); │ │ │ │ -OpenLayers.Animation = function(window) { │ │ │ │ - var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ - var isNative = !!requestAnimationFrame; │ │ │ │ - var requestFrame = function() { │ │ │ │ - var request = window[requestAnimationFrame] || function(callback, element) { │ │ │ │ - window.setTimeout(callback, 16) │ │ │ │ - }; │ │ │ │ - return function(callback, element) { │ │ │ │ - request.apply(window, [callback, element]) │ │ │ │ - } │ │ │ │ - }(); │ │ │ │ - var counter = 0; │ │ │ │ - var loops = {}; │ │ │ │ - │ │ │ │ - function start(callback, duration, element) { │ │ │ │ - duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ - var id = ++counter; │ │ │ │ - var start = +new Date; │ │ │ │ - loops[id] = function() { │ │ │ │ - if (loops[id] && +new Date - start <= duration) { │ │ │ │ - callback(); │ │ │ │ - if (loops[id]) { │ │ │ │ - requestFrame(loops[id], element) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - delete loops[id] │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - return id │ │ │ │ - } │ │ │ │ - │ │ │ │ - function stop(id) { │ │ │ │ - delete loops[id] │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - isNative: isNative, │ │ │ │ - requestFrame: requestFrame, │ │ │ │ - start: start, │ │ │ │ - stop: stop │ │ │ │ - } │ │ │ │ -}(window); │ │ │ │ -OpenLayers.Tween = OpenLayers.Class({ │ │ │ │ - easing: null, │ │ │ │ - begin: null, │ │ │ │ - finish: null, │ │ │ │ - duration: null, │ │ │ │ - callbacks: null, │ │ │ │ - time: null, │ │ │ │ - minFrameRate: null, │ │ │ │ - startTime: null, │ │ │ │ - animationId: null, │ │ │ │ - playing: false, │ │ │ │ - initialize: function(easing) { │ │ │ │ - this.easing = easing ? easing : OpenLayers.Easing.Expo.easeOut │ │ │ │ - }, │ │ │ │ - start: function(begin, finish, duration, options) { │ │ │ │ - this.playing = true; │ │ │ │ - this.begin = begin; │ │ │ │ - this.finish = finish; │ │ │ │ - this.duration = duration; │ │ │ │ - this.callbacks = options.callbacks; │ │ │ │ - this.minFrameRate = options.minFrameRate || 30; │ │ │ │ - this.time = 0; │ │ │ │ - this.startTime = (new Date).getTime(); │ │ │ │ - OpenLayers.Animation.stop(this.animationId); │ │ │ │ - this.animationId = null; │ │ │ │ - if (this.callbacks && this.callbacks.start) { │ │ │ │ - this.callbacks.start.call(this, this.begin) │ │ │ │ - } │ │ │ │ - this.animationId = OpenLayers.Animation.start(OpenLayers.Function.bind(this.play, this)) │ │ │ │ - }, │ │ │ │ - stop: function() { │ │ │ │ - if (!this.playing) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (this.callbacks && this.callbacks.done) { │ │ │ │ - this.callbacks.done.call(this, this.finish) │ │ │ │ - } │ │ │ │ - OpenLayers.Animation.stop(this.animationId); │ │ │ │ - this.animationId = null; │ │ │ │ - this.playing = false │ │ │ │ - }, │ │ │ │ - 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)) { │ │ │ │ - throw new TypeError("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) { │ │ │ │ - if (((new Date).getTime() - this.startTime) / this.time <= 1e3 / this.minFrameRate) { │ │ │ │ - this.callbacks.eachStep.call(this, value) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.time > this.duration) { │ │ │ │ - this.stop() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Tween" │ │ │ │ -}); │ │ │ │ -OpenLayers.Easing = { │ │ │ │ - CLASS_NAME: "OpenLayers.Easing" │ │ │ │ -}; │ │ │ │ -OpenLayers.Easing.Linear = { │ │ │ │ - easeIn: function(t, b, c, d) { │ │ │ │ - return c * t / d + b │ │ │ │ - }, │ │ │ │ - easeOut: function(t, b, c, d) { │ │ │ │ - return c * t / d + b │ │ │ │ - }, │ │ │ │ - easeInOut: function(t, b, c, d) { │ │ │ │ - return c * t / d + b │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Easing.Linear" │ │ │ │ -}; │ │ │ │ -OpenLayers.Easing.Expo = { │ │ │ │ - easeIn: function(t, b, c, d) { │ │ │ │ - return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b │ │ │ │ - }, │ │ │ │ - easeOut: function(t, b, c, d) { │ │ │ │ - return t == d ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b │ │ │ │ - }, │ │ │ │ - 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" │ │ │ │ -}; │ │ │ │ -OpenLayers.Easing.Quad = { │ │ │ │ - easeIn: function(t, b, c, d) { │ │ │ │ - return c * (t /= d) * t + b │ │ │ │ - }, │ │ │ │ - easeOut: function(t, b, c, d) { │ │ │ │ - return -c * (t /= d) * (t - 2) + b │ │ │ │ - }, │ │ │ │ - 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" │ │ │ │ -}; │ │ │ │ OpenLayers.Event = { │ │ │ │ observers: false, │ │ │ │ KEY_SPACE: 32, │ │ │ │ KEY_BACKSPACE: 8, │ │ │ │ KEY_TAB: 9, │ │ │ │ KEY_RETURN: 13, │ │ │ │ KEY_ESC: 27, │ │ │ │ @@ -3267,14 +3024,163 @@ │ │ │ │ e.touches = touches.slice(); │ │ │ │ handler(e) │ │ │ │ }; │ │ │ │ OpenLayers.Event.observe(element, "MSPointerUp", cb) │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Events" │ │ │ │ }); │ │ │ │ +OpenLayers.Animation = function(window) { │ │ │ │ + var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ + var isNative = !!requestAnimationFrame; │ │ │ │ + var requestFrame = function() { │ │ │ │ + var request = window[requestAnimationFrame] || function(callback, element) { │ │ │ │ + window.setTimeout(callback, 16) │ │ │ │ + }; │ │ │ │ + return function(callback, element) { │ │ │ │ + request.apply(window, [callback, element]) │ │ │ │ + } │ │ │ │ + }(); │ │ │ │ + var counter = 0; │ │ │ │ + var loops = {}; │ │ │ │ + │ │ │ │ + function start(callback, duration, element) { │ │ │ │ + duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ + var id = ++counter; │ │ │ │ + var start = +new Date; │ │ │ │ + loops[id] = function() { │ │ │ │ + if (loops[id] && +new Date - start <= duration) { │ │ │ │ + callback(); │ │ │ │ + if (loops[id]) { │ │ │ │ + requestFrame(loops[id], element) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + delete loops[id] │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + return id │ │ │ │ + } │ │ │ │ + │ │ │ │ + function stop(id) { │ │ │ │ + delete loops[id] │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + isNative: isNative, │ │ │ │ + requestFrame: requestFrame, │ │ │ │ + start: start, │ │ │ │ + stop: stop │ │ │ │ + } │ │ │ │ +}(window); │ │ │ │ +OpenLayers.Tween = OpenLayers.Class({ │ │ │ │ + easing: null, │ │ │ │ + begin: null, │ │ │ │ + finish: null, │ │ │ │ + duration: null, │ │ │ │ + callbacks: null, │ │ │ │ + time: null, │ │ │ │ + minFrameRate: null, │ │ │ │ + startTime: null, │ │ │ │ + animationId: null, │ │ │ │ + playing: false, │ │ │ │ + initialize: function(easing) { │ │ │ │ + this.easing = easing ? easing : OpenLayers.Easing.Expo.easeOut │ │ │ │ + }, │ │ │ │ + start: function(begin, finish, duration, options) { │ │ │ │ + this.playing = true; │ │ │ │ + this.begin = begin; │ │ │ │ + this.finish = finish; │ │ │ │ + this.duration = duration; │ │ │ │ + this.callbacks = options.callbacks; │ │ │ │ + this.minFrameRate = options.minFrameRate || 30; │ │ │ │ + this.time = 0; │ │ │ │ + this.startTime = (new Date).getTime(); │ │ │ │ + OpenLayers.Animation.stop(this.animationId); │ │ │ │ + this.animationId = null; │ │ │ │ + if (this.callbacks && this.callbacks.start) { │ │ │ │ + this.callbacks.start.call(this, this.begin) │ │ │ │ + } │ │ │ │ + this.animationId = OpenLayers.Animation.start(OpenLayers.Function.bind(this.play, this)) │ │ │ │ + }, │ │ │ │ + stop: function() { │ │ │ │ + if (!this.playing) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if (this.callbacks && this.callbacks.done) { │ │ │ │ + this.callbacks.done.call(this, this.finish) │ │ │ │ + } │ │ │ │ + OpenLayers.Animation.stop(this.animationId); │ │ │ │ + this.animationId = null; │ │ │ │ + this.playing = false │ │ │ │ + }, │ │ │ │ + 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)) { │ │ │ │ + throw new TypeError("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) { │ │ │ │ + if (((new Date).getTime() - this.startTime) / this.time <= 1e3 / this.minFrameRate) { │ │ │ │ + this.callbacks.eachStep.call(this, value) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.time > this.duration) { │ │ │ │ + this.stop() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Tween" │ │ │ │ +}); │ │ │ │ +OpenLayers.Easing = { │ │ │ │ + CLASS_NAME: "OpenLayers.Easing" │ │ │ │ +}; │ │ │ │ +OpenLayers.Easing.Linear = { │ │ │ │ + easeIn: function(t, b, c, d) { │ │ │ │ + return c * t / d + b │ │ │ │ + }, │ │ │ │ + easeOut: function(t, b, c, d) { │ │ │ │ + return c * t / d + b │ │ │ │ + }, │ │ │ │ + easeInOut: function(t, b, c, d) { │ │ │ │ + return c * t / d + b │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Easing.Linear" │ │ │ │ +}; │ │ │ │ +OpenLayers.Easing.Expo = { │ │ │ │ + easeIn: function(t, b, c, d) { │ │ │ │ + return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b │ │ │ │ + }, │ │ │ │ + easeOut: function(t, b, c, d) { │ │ │ │ + return t == d ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b │ │ │ │ + }, │ │ │ │ + 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" │ │ │ │ +}; │ │ │ │ +OpenLayers.Easing.Quad = { │ │ │ │ + easeIn: function(t, b, c, d) { │ │ │ │ + return c * (t /= d) * t + b │ │ │ │ + }, │ │ │ │ + easeOut: function(t, b, c, d) { │ │ │ │ + return -c * (t /= d) * (t - 2) + b │ │ │ │ + }, │ │ │ │ + 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" │ │ │ │ +}; │ │ │ │ OpenLayers.Projection = OpenLayers.Class({ │ │ │ │ proj: null, │ │ │ │ projCode: null, │ │ │ │ titleRegEx: /\+title=[^\+]*/, │ │ │ │ initialize: function(projCode, options) { │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ this.projCode = projCode; │ │ │ │ @@ -5107,87 +5013,95 @@ │ │ │ │ }; │ │ │ │ bounds = bounds.wrapDateLine(this.maxExtent, wrappingOptions) │ │ │ │ } │ │ │ │ return bounds │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.HTTPRequest = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ - URL_HASH_FACTOR: (Math.sqrt(5) - 1) / 2, │ │ │ │ +OpenLayers.Icon = OpenLayers.Class({ │ │ │ │ url: null, │ │ │ │ - params: null, │ │ │ │ - reproject: false, │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.prototype.initialize.apply(this, [name, options]); │ │ │ │ + size: null, │ │ │ │ + offset: null, │ │ │ │ + calculateOffset: null, │ │ │ │ + imageDiv: null, │ │ │ │ + px: null, │ │ │ │ + initialize: function(url, size, offset, calculateOffset) { │ │ │ │ this.url = url; │ │ │ │ - if (!this.params) { │ │ │ │ - this.params = OpenLayers.Util.extend({}, params) │ │ │ │ - } │ │ │ │ + this.size = size || { │ │ │ │ + w: 20, │ │ │ │ + h: 20 │ │ │ │ + }; │ │ │ │ + this.offset = offset || { │ │ │ │ + x: -(this.size.w / 2), │ │ │ │ + y: -(this.size.h / 2) │ │ │ │ + }; │ │ │ │ + this.calculateOffset = calculateOffset; │ │ │ │ + var id = OpenLayers.Util.createUniqueID("OL_Icon_"); │ │ │ │ + this.imageDiv = OpenLayers.Util.createAlphaImageDiv(id) │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.url = null; │ │ │ │ - this.params = null; │ │ │ │ - OpenLayers.Layer.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.HTTPRequest(this.name, this.url, this.params, this.getOptions()) │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ + this.erase(); │ │ │ │ + OpenLayers.Event.stopObservingElement(this.imageDiv.firstChild); │ │ │ │ + this.imageDiv.innerHTML = ""; │ │ │ │ + this.imageDiv = null │ │ │ │ }, │ │ │ │ - setUrl: function(newUrl) { │ │ │ │ - this.url = newUrl │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Icon(this.url, this.size, this.offset, this.calculateOffset) │ │ │ │ }, │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - this.params = OpenLayers.Util.extend(this.params, newParams); │ │ │ │ - var ret = this.redraw(); │ │ │ │ - if (this.map != null) { │ │ │ │ - this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "params" │ │ │ │ - }) │ │ │ │ + setSize: function(size) { │ │ │ │ + if (size != null) { │ │ │ │ + this.size = size │ │ │ │ } │ │ │ │ - return ret │ │ │ │ + this.draw() │ │ │ │ }, │ │ │ │ - redraw: function(force) { │ │ │ │ - if (force) { │ │ │ │ - return this.mergeNewParams({ │ │ │ │ - _olSalt: Math.random() │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - return OpenLayers.Layer.prototype.redraw.apply(this, []) │ │ │ │ + setUrl: function(url) { │ │ │ │ + if (url != null) { │ │ │ │ + this.url = url │ │ │ │ } │ │ │ │ + this.draw() │ │ │ │ }, │ │ │ │ - selectUrl: function(paramString, urls) { │ │ │ │ - var product = 1; │ │ │ │ - for (var i = 0, len = paramString.length; i < len; i++) { │ │ │ │ - product *= paramString.charCodeAt(i) * this.URL_HASH_FACTOR; │ │ │ │ - product -= Math.floor(product) │ │ │ │ + draw: function(px) { │ │ │ │ + OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, this.size, this.url, "absolute"); │ │ │ │ + this.moveTo(px); │ │ │ │ + return this.imageDiv │ │ │ │ + }, │ │ │ │ + erase: function() { │ │ │ │ + if (this.imageDiv != null && this.imageDiv.parentNode != null) { │ │ │ │ + OpenLayers.Element.remove(this.imageDiv) │ │ │ │ } │ │ │ │ - return urls[Math.floor(product * urls.length)] │ │ │ │ }, │ │ │ │ - getFullRequestString: function(newParams, altUrl) { │ │ │ │ - var url = altUrl || this.url; │ │ │ │ - var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ - allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ - var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(paramsString, url) │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, null, null, null, null, null, opacity) │ │ │ │ + }, │ │ │ │ + moveTo: function(px) { │ │ │ │ + if (px != null) { │ │ │ │ + this.px = px │ │ │ │ } │ │ │ │ - var urlParams = OpenLayers.Util.upperCaseObject(OpenLayers.Util.getParameters(url)); │ │ │ │ - for (var key in allParams) { │ │ │ │ - if (key.toUpperCase() in urlParams) { │ │ │ │ - delete allParams[key] │ │ │ │ + if (this.imageDiv != null) { │ │ │ │ + if (this.px == null) { │ │ │ │ + this.display(false) │ │ │ │ + } else { │ │ │ │ + if (this.calculateOffset) { │ │ │ │ + this.offset = this.calculateOffset(this.size) │ │ │ │ + } │ │ │ │ + OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, { │ │ │ │ + x: this.px.x + this.offset.x, │ │ │ │ + y: this.px.y + this.offset.y │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ - paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ - return OpenLayers.Util.urlAppend(url, paramsString) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.HTTPRequest" │ │ │ │ + display: function(display) { │ │ │ │ + this.imageDiv.style.display = display ? "" : "none" │ │ │ │ + }, │ │ │ │ + isDrawn: function() { │ │ │ │ + var isDrawn = this.imageDiv && this.imageDiv.parentNode && this.imageDiv.parentNode.nodeType != 11; │ │ │ │ + return isDrawn │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Icon" │ │ │ │ }); │ │ │ │ OpenLayers.Tile = OpenLayers.Class({ │ │ │ │ events: null, │ │ │ │ eventListeners: null, │ │ │ │ id: null, │ │ │ │ layer: null, │ │ │ │ url: null, │ │ │ │ @@ -5274,1134 +5188,1223 @@ │ │ │ │ if (redraw) { │ │ │ │ this.draw() │ │ │ │ } │ │ │ │ }, │ │ │ │ clear: function(draw) {}, │ │ │ │ CLASS_NAME: "OpenLayers.Tile" │ │ │ │ }); │ │ │ │ -OpenLayers.Tile.Image = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ - url: null, │ │ │ │ - imgDiv: null, │ │ │ │ - frame: null, │ │ │ │ - imageReloadAttempts: null, │ │ │ │ - layerAlphaHack: null, │ │ │ │ - asyncRequestId: null, │ │ │ │ - maxGetUrlLength: null, │ │ │ │ - canvasContext: null, │ │ │ │ - crossOriginKeyword: null, │ │ │ │ - initialize: function(layer, position, bounds, url, size, options) { │ │ │ │ - OpenLayers.Tile.prototype.initialize.apply(this, arguments); │ │ │ │ - this.url = url; │ │ │ │ - this.layerAlphaHack = this.layer.alpha && OpenLayers.Util.alphaHack(); │ │ │ │ - if (this.maxGetUrlLength != null || this.layer.gutter || this.layerAlphaHack) { │ │ │ │ - this.frame = document.createElement("div"); │ │ │ │ - this.frame.style.position = "absolute"; │ │ │ │ - this.frame.style.overflow = "hidden" │ │ │ │ - } │ │ │ │ - if (this.maxGetUrlLength != null) { │ │ │ │ - OpenLayers.Util.extend(this, OpenLayers.Tile.Image.IFrame) │ │ │ │ - } │ │ │ │ +OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ + threshold: 0, │ │ │ │ + deceleration: .0035, │ │ │ │ + nbPoints: 100, │ │ │ │ + delay: 200, │ │ │ │ + points: undefined, │ │ │ │ + timerId: undefined, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.imgDiv) { │ │ │ │ - this.clear(); │ │ │ │ - this.imgDiv = null; │ │ │ │ - this.frame = null │ │ │ │ + begin: function() { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = undefined; │ │ │ │ + this.points = [] │ │ │ │ + }, │ │ │ │ + update: function(xy) { │ │ │ │ + this.points.unshift({ │ │ │ │ + xy: xy, │ │ │ │ + tick: (new Date).getTime() │ │ │ │ + }); │ │ │ │ + if (this.points.length > this.nbPoints) { │ │ │ │ + this.points.pop() │ │ │ │ } │ │ │ │ - this.asyncRequestId = null; │ │ │ │ - OpenLayers.Tile.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - var shouldDraw = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ - if (shouldDraw) { │ │ │ │ - if (this.layer != this.layer.map.baseLayer && this.layer.reproject) { │ │ │ │ - this.bounds = this.getBoundsFromBaseLayer(this.position) │ │ │ │ - } │ │ │ │ - if (this.isLoading) { │ │ │ │ - this._loadEvent = "reload" │ │ │ │ - } else { │ │ │ │ - this.isLoading = true; │ │ │ │ - this._loadEvent = "loadstart" │ │ │ │ + end: function(xy) { │ │ │ │ + var last, now = (new Date).getTime(); │ │ │ │ + for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ + point = this.points[i]; │ │ │ │ + if (now - point.tick > this.delay) { │ │ │ │ + break │ │ │ │ } │ │ │ │ - this.renderTile(); │ │ │ │ - this.positionTile() │ │ │ │ - } else if (shouldDraw === false) { │ │ │ │ - this.unload() │ │ │ │ + last = point │ │ │ │ } │ │ │ │ - return shouldDraw │ │ │ │ - }, │ │ │ │ - renderTile: function() { │ │ │ │ - if (this.layer.async) { │ │ │ │ - var id = this.asyncRequestId = (this.asyncRequestId || 0) + 1; │ │ │ │ - this.layer.getURLasync(this.bounds, function(url) { │ │ │ │ - if (id == this.asyncRequestId) { │ │ │ │ - this.url = url; │ │ │ │ - this.initImage() │ │ │ │ - } │ │ │ │ - }, this) │ │ │ │ - } else { │ │ │ │ - this.url = this.layer.getURL(this.bounds); │ │ │ │ - this.initImage() │ │ │ │ + if (!last) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - }, │ │ │ │ - positionTile: function() { │ │ │ │ - var style = this.getTile().style, │ │ │ │ - size = this.frame ? this.size : this.layer.getImageSize(this.bounds), │ │ │ │ - ratio = 1; │ │ │ │ - if (this.layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ - ratio = this.layer.getServerResolution() / this.layer.map.getResolution() │ │ │ │ + var time = (new Date).getTime() - last.tick; │ │ │ │ + var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ + var speed = dist / time; │ │ │ │ + if (speed == 0 || speed < this.threshold) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - style.left = this.position.x + "px"; │ │ │ │ - style.top = this.position.y + "px"; │ │ │ │ - style.width = Math.round(ratio * size.w) + "px"; │ │ │ │ - style.height = Math.round(ratio * size.h) + "px" │ │ │ │ - }, │ │ │ │ - clear: function() { │ │ │ │ - OpenLayers.Tile.prototype.clear.apply(this, arguments); │ │ │ │ - var img = this.imgDiv; │ │ │ │ - if (img) { │ │ │ │ - var tile = this.getTile(); │ │ │ │ - if (tile.parentNode === this.layer.div) { │ │ │ │ - this.layer.div.removeChild(tile) │ │ │ │ - } │ │ │ │ - this.setImgSrc(); │ │ │ │ - if (this.layerAlphaHack === true) { │ │ │ │ - img.style.filter = "" │ │ │ │ - } │ │ │ │ - OpenLayers.Element.removeClass(img, "olImageLoadError") │ │ │ │ + var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ + if (last.xy.x <= xy.x) { │ │ │ │ + theta = Math.PI - theta │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + speed: speed, │ │ │ │ + theta: theta │ │ │ │ } │ │ │ │ - this.canvasContext = null │ │ │ │ }, │ │ │ │ - getImage: function() { │ │ │ │ - if (!this.imgDiv) { │ │ │ │ - this.imgDiv = OpenLayers.Tile.Image.IMAGE.cloneNode(false); │ │ │ │ - var style = this.imgDiv.style; │ │ │ │ - if (this.frame) { │ │ │ │ - var left = 0, │ │ │ │ - top = 0; │ │ │ │ - if (this.layer.gutter) { │ │ │ │ - left = this.layer.gutter / this.layer.tileSize.w * 100; │ │ │ │ - top = this.layer.gutter / this.layer.tileSize.h * 100 │ │ │ │ - } │ │ │ │ - style.left = -left + "%"; │ │ │ │ - style.top = -top + "%"; │ │ │ │ - style.width = 2 * left + 100 + "%"; │ │ │ │ - style.height = 2 * top + 100 + "%" │ │ │ │ - } │ │ │ │ - style.visibility = "hidden"; │ │ │ │ - style.opacity = 0; │ │ │ │ - if (this.layer.opacity < 1) { │ │ │ │ - style.filter = "alpha(opacity=" + this.layer.opacity * 100 + ")" │ │ │ │ - } │ │ │ │ - style.position = "absolute"; │ │ │ │ - if (this.layerAlphaHack) { │ │ │ │ - style.paddingTop = style.height; │ │ │ │ - style.height = "0"; │ │ │ │ - style.width = "100%" │ │ │ │ + move: function(info, callback) { │ │ │ │ + var v0 = info.speed; │ │ │ │ + var fx = Math.cos(info.theta); │ │ │ │ + var fy = -Math.sin(info.theta); │ │ │ │ + var initialTime = (new Date).getTime(); │ │ │ │ + var lastX = 0; │ │ │ │ + var lastY = 0; │ │ │ │ + var timerCallback = function() { │ │ │ │ + if (this.timerId == null) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - if (this.frame) { │ │ │ │ - this.frame.appendChild(this.imgDiv) │ │ │ │ + var t = (new Date).getTime() - initialTime; │ │ │ │ + var p = -this.deceleration * Math.pow(t, 2) / 2 + v0 * t; │ │ │ │ + var x = p * fx; │ │ │ │ + var y = p * fy; │ │ │ │ + var args = {}; │ │ │ │ + args.end = false; │ │ │ │ + var v = -this.deceleration * t + v0; │ │ │ │ + if (v <= 0) { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + args.end = true │ │ │ │ } │ │ │ │ - } │ │ │ │ - return this.imgDiv │ │ │ │ + args.x = x - lastX; │ │ │ │ + args.y = y - lastY; │ │ │ │ + lastX = x; │ │ │ │ + lastY = y; │ │ │ │ + callback(args.x, args.y, args.end) │ │ │ │ + }; │ │ │ │ + this.timerId = OpenLayers.Animation.start(OpenLayers.Function.bind(timerCallback, this)) │ │ │ │ }, │ │ │ │ - setImage: function(img) { │ │ │ │ - this.imgDiv = img │ │ │ │ + CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ +}); │ │ │ │ +OpenLayers.Feature = OpenLayers.Class({ │ │ │ │ + layer: null, │ │ │ │ + id: null, │ │ │ │ + lonlat: null, │ │ │ │ + data: null, │ │ │ │ + marker: null, │ │ │ │ + popupClass: null, │ │ │ │ + popup: null, │ │ │ │ + initialize: function(layer, lonlat, data) { │ │ │ │ + this.layer = layer; │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + this.data = data != null ? data : {}; │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ }, │ │ │ │ - initImage: function() { │ │ │ │ - if (!this.url && !this.imgDiv) { │ │ │ │ - this.isLoading = false; │ │ │ │ - return │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("beforeload"); │ │ │ │ - this.layer.div.appendChild(this.getTile()); │ │ │ │ - this.events.triggerEvent(this._loadEvent); │ │ │ │ - var img = this.getImage(); │ │ │ │ - var src = img.getAttribute("src") || ""; │ │ │ │ - if (this.url && OpenLayers.Util.isEquivalentUrl(src, this.url)) { │ │ │ │ - this._loadTimeout = window.setTimeout(OpenLayers.Function.bind(this.onImageLoad, this), 0) │ │ │ │ - } else { │ │ │ │ - this.stopLoading(); │ │ │ │ - if (this.crossOriginKeyword) { │ │ │ │ - img.removeAttribute("crossorigin") │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layer != null && this.layer.map != null) { │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.layer.map.removePopup(this.popup) │ │ │ │ } │ │ │ │ - OpenLayers.Event.observe(img, "load", OpenLayers.Function.bind(this.onImageLoad, this)); │ │ │ │ - OpenLayers.Event.observe(img, "error", OpenLayers.Function.bind(this.onImageError, this)); │ │ │ │ - this.imageReloadAttempts = 0; │ │ │ │ - this.setImgSrc(this.url) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - setImgSrc: function(url) { │ │ │ │ - var img = this.imgDiv; │ │ │ │ - if (url) { │ │ │ │ - img.style.visibility = "hidden"; │ │ │ │ - img.style.opacity = 0; │ │ │ │ - if (this.crossOriginKeyword) { │ │ │ │ - if (url.substr(0, 5) !== "data:") { │ │ │ │ - img.setAttribute("crossorigin", this.crossOriginKeyword) │ │ │ │ - } else { │ │ │ │ - img.removeAttribute("crossorigin") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - img.src = url │ │ │ │ - } else { │ │ │ │ - this.stopLoading(); │ │ │ │ - this.imgDiv = null; │ │ │ │ - if (img.parentNode) { │ │ │ │ - img.parentNode.removeChild(img) │ │ │ │ - } │ │ │ │ + if (this.layer != null && this.marker != null) { │ │ │ │ + this.layer.removeMarker(this.marker) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - getTile: function() { │ │ │ │ - return this.frame ? this.frame : this.getImage() │ │ │ │ - }, │ │ │ │ - createBackBuffer: function() { │ │ │ │ - if (!this.imgDiv || this.isLoading) { │ │ │ │ - return │ │ │ │ + this.layer = null; │ │ │ │ + this.id = null; │ │ │ │ + this.lonlat = null; │ │ │ │ + this.data = null; │ │ │ │ + if (this.marker != null) { │ │ │ │ + this.destroyMarker(this.marker); │ │ │ │ + this.marker = null │ │ │ │ } │ │ │ │ - var backBuffer; │ │ │ │ - if (this.frame) { │ │ │ │ - backBuffer = this.frame.cloneNode(false); │ │ │ │ - backBuffer.appendChild(this.imgDiv) │ │ │ │ - } else { │ │ │ │ - backBuffer = this.imgDiv │ │ │ │ + if (this.popup != null) { │ │ │ │ + this.destroyPopup(this.popup); │ │ │ │ + this.popup = null │ │ │ │ } │ │ │ │ - this.imgDiv = null; │ │ │ │ - return backBuffer │ │ │ │ }, │ │ │ │ - onImageLoad: function() { │ │ │ │ - var img = this.imgDiv; │ │ │ │ - this.stopLoading(); │ │ │ │ - img.style.visibility = "inherit"; │ │ │ │ - img.style.opacity = this.layer.opacity; │ │ │ │ - this.isLoading = false; │ │ │ │ - this.canvasContext = null; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - if (this.layerAlphaHack === true) { │ │ │ │ - img.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + img.src + "', sizingMethod='scale')" │ │ │ │ + onScreen: function() { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.layer != null && this.layer.map != null) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsLonLat(this.lonlat) │ │ │ │ } │ │ │ │ + return onScreen │ │ │ │ }, │ │ │ │ - onImageError: function() { │ │ │ │ - var img = this.imgDiv; │ │ │ │ - if (img.src != null) { │ │ │ │ - this.imageReloadAttempts++; │ │ │ │ - if (this.imageReloadAttempts <= OpenLayers.IMAGE_RELOAD_ATTEMPTS) { │ │ │ │ - this.setImgSrc(this.layer.getURL(this.bounds)) │ │ │ │ - } else { │ │ │ │ - OpenLayers.Element.addClass(img, "olImageLoadError"); │ │ │ │ - this.events.triggerEvent("loaderror"); │ │ │ │ - this.onImageLoad() │ │ │ │ - } │ │ │ │ + createMarker: function() { │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon) │ │ │ │ } │ │ │ │ + return this.marker │ │ │ │ }, │ │ │ │ - stopLoading: function() { │ │ │ │ - OpenLayers.Event.stopObservingElement(this.imgDiv); │ │ │ │ - window.clearTimeout(this._loadTimeout); │ │ │ │ - delete this._loadTimeout │ │ │ │ + destroyMarker: function() { │ │ │ │ + this.marker.destroy() │ │ │ │ }, │ │ │ │ - getCanvasContext: function() { │ │ │ │ - if (OpenLayers.CANVAS_SUPPORTED && this.imgDiv && !this.isLoading) { │ │ │ │ - if (!this.canvasContext) { │ │ │ │ - var canvas = document.createElement("canvas"); │ │ │ │ - canvas.width = this.size.w; │ │ │ │ - canvas.height = this.size.h; │ │ │ │ - this.canvasContext = canvas.getContext("2d"); │ │ │ │ - this.canvasContext.drawImage(this.imgDiv, 0, 0) │ │ │ │ + createPopup: function(closeBox) { │ │ │ │ + if (this.lonlat != null) { │ │ │ │ + if (!this.popup) { │ │ │ │ + var anchor = this.marker ? this.marker.icon : null; │ │ │ │ + var popupClass = this.popupClass ? this.popupClass : OpenLayers.Popup.Anchored; │ │ │ │ + this.popup = new popupClass(this.id + "_popup", this.lonlat, this.data.popupSize, this.data.popupContentHTML, anchor, closeBox) │ │ │ │ } │ │ │ │ - return this.canvasContext │ │ │ │ + if (this.data.overflow != null) { │ │ │ │ + this.popup.contentDiv.style.overflow = this.data.overflow │ │ │ │ + } │ │ │ │ + this.popup.feature = this │ │ │ │ } │ │ │ │ + return this.popup │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Tile.Image" │ │ │ │ -}); │ │ │ │ -OpenLayers.Tile.Image.IMAGE = function() { │ │ │ │ - var img = new Image; │ │ │ │ - img.className = "olTileImage"; │ │ │ │ - img.galleryImg = "no"; │ │ │ │ - return img │ │ │ │ -}(); │ │ │ │ -OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, { │ │ │ │ - tileSize: null, │ │ │ │ - tileOriginCorner: "bl", │ │ │ │ - tileOrigin: null, │ │ │ │ - tileOptions: null, │ │ │ │ - tileClass: OpenLayers.Tile.Image, │ │ │ │ - grid: null, │ │ │ │ - singleTile: false, │ │ │ │ - ratio: 1.5, │ │ │ │ - buffer: 0, │ │ │ │ - transitionEffect: "resize", │ │ │ │ - numLoadingTiles: 0, │ │ │ │ - serverResolutions: null, │ │ │ │ - loading: false, │ │ │ │ - backBuffer: null, │ │ │ │ - gridResolution: null, │ │ │ │ - backBufferResolution: null, │ │ │ │ - backBufferLonLat: null, │ │ │ │ - backBufferTimerId: null, │ │ │ │ - removeBackBufferDelay: null, │ │ │ │ - className: null, │ │ │ │ - gridLayout: null, │ │ │ │ - rowSign: null, │ │ │ │ - transitionendEvents: ["transitionend", "webkitTransitionEnd", "otransitionend", "oTransitionEnd"], │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.initialize.apply(this, arguments); │ │ │ │ - this.grid = []; │ │ │ │ - this._removeBackBuffer = OpenLayers.Function.bind(this.removeBackBuffer, this); │ │ │ │ - this.initProperties(); │ │ │ │ - this.rowSign = this.tileOriginCorner.substr(0, 1) === "t" ? 1 : -1 │ │ │ │ - }, │ │ │ │ - initProperties: function() { │ │ │ │ - if (this.options.removeBackBufferDelay === undefined) { │ │ │ │ - this.removeBackBufferDelay = this.singleTile ? 0 : 2500 │ │ │ │ - } │ │ │ │ - if (this.options.className === undefined) { │ │ │ │ - this.className = this.singleTile ? "olLayerGridSingleTile" : "olLayerGrid" │ │ │ │ + destroyPopup: function() { │ │ │ │ + if (this.popup) { │ │ │ │ + this.popup.feature = null; │ │ │ │ + this.popup.destroy(); │ │ │ │ + this.popup = null │ │ │ │ } │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.setMap.call(this, map); │ │ │ │ - OpenLayers.Element.addClass(this.div, this.className) │ │ │ │ - }, │ │ │ │ - removeMap: function(map) { │ │ │ │ - this.removeBackBuffer() │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.removeBackBuffer(); │ │ │ │ - this.clearGrid(); │ │ │ │ - this.grid = null; │ │ │ │ - this.tileSize = null; │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - clearGrid: function() { │ │ │ │ - if (this.grid) { │ │ │ │ - for (var iRow = 0, len = this.grid.length; iRow < len; iRow++) { │ │ │ │ - var row = this.grid[iRow]; │ │ │ │ - for (var iCol = 0, clen = row.length; iCol < clen; iCol++) { │ │ │ │ - var tile = row[iCol]; │ │ │ │ - this.destroyTile(tile) │ │ │ │ + CLASS_NAME: "OpenLayers.Feature" │ │ │ │ +}); │ │ │ │ +(function() { │ │ │ │ + var oXMLHttpRequest = window.XMLHttpRequest; │ │ │ │ + var bGecko = !!window.controllers, │ │ │ │ + bIE = window.document.all && !window.opera, │ │ │ │ + bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/); │ │ │ │ + │ │ │ │ + function fXMLHttpRequest() { │ │ │ │ + this._object = oXMLHttpRequest && !bIE7 ? new oXMLHttpRequest : new window.ActiveXObject("Microsoft.XMLHTTP"); │ │ │ │ + this._listeners = [] │ │ │ │ + } │ │ │ │ + │ │ │ │ + function cXMLHttpRequest() { │ │ │ │ + return new fXMLHttpRequest │ │ │ │ + } │ │ │ │ + cXMLHttpRequest.prototype = fXMLHttpRequest.prototype; │ │ │ │ + if (bGecko && oXMLHttpRequest.wrapped) cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped; │ │ │ │ + cXMLHttpRequest.UNSENT = 0; │ │ │ │ + cXMLHttpRequest.OPENED = 1; │ │ │ │ + cXMLHttpRequest.HEADERS_RECEIVED = 2; │ │ │ │ + cXMLHttpRequest.LOADING = 3; │ │ │ │ + cXMLHttpRequest.DONE = 4; │ │ │ │ + cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + cXMLHttpRequest.prototype.responseText = ""; │ │ │ │ + cXMLHttpRequest.prototype.responseXML = null; │ │ │ │ + cXMLHttpRequest.prototype.status = 0; │ │ │ │ + cXMLHttpRequest.prototype.statusText = ""; │ │ │ │ + cXMLHttpRequest.prototype.priority = "NORMAL"; │ │ │ │ + cXMLHttpRequest.prototype.onreadystatechange = null; │ │ │ │ + cXMLHttpRequest.onreadystatechange = null; │ │ │ │ + cXMLHttpRequest.onopen = null; │ │ │ │ + cXMLHttpRequest.onsend = null; │ │ │ │ + cXMLHttpRequest.onabort = null; │ │ │ │ + cXMLHttpRequest.prototype.open = function(sMethod, sUrl, bAsync, sUser, sPassword) { │ │ │ │ + delete this._headers; │ │ │ │ + if (arguments.length < 3) bAsync = true; │ │ │ │ + this._async = bAsync; │ │ │ │ + var oRequest = this, │ │ │ │ + nState = this.readyState, │ │ │ │ + fOnUnload; │ │ │ │ + if (bIE && bAsync) { │ │ │ │ + fOnUnload = function() { │ │ │ │ + if (nState != cXMLHttpRequest.DONE) { │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + oRequest.abort() │ │ │ │ } │ │ │ │ + }; │ │ │ │ + window.attachEvent("onunload", fOnUnload) │ │ │ │ + } │ │ │ │ + if (cXMLHttpRequest.onopen) cXMLHttpRequest.onopen.apply(this, arguments); │ │ │ │ + if (arguments.length > 4) this._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ + else if (arguments.length > 3) this._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ + else this._object.open(sMethod, sUrl, bAsync); │ │ │ │ + this.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + fReadyStateChange(this); │ │ │ │ + this._object.onreadystatechange = function() { │ │ │ │ + if (bGecko && !bAsync) return; │ │ │ │ + oRequest.readyState = oRequest._object.readyState; │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + if (oRequest._aborted) { │ │ │ │ + oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + return │ │ │ │ } │ │ │ │ - this.grid = []; │ │ │ │ - this.gridResolution = null; │ │ │ │ - this.gridLayout = null │ │ │ │ + if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ + delete oRequest._data; │ │ │ │ + fCleanTransport(oRequest); │ │ │ │ + if (bIE && bAsync) window.detachEvent("onunload", fOnUnload) │ │ │ │ + } │ │ │ │ + if (nState != oRequest.readyState) fReadyStateChange(oRequest); │ │ │ │ + nState = oRequest.readyState │ │ │ │ } │ │ │ │ - }, │ │ │ │ - addOptions: function(newOptions, reinitialize) { │ │ │ │ - var singleTileChanged = newOptions.singleTile !== undefined && newOptions.singleTile !== this.singleTile; │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.addOptions.apply(this, arguments); │ │ │ │ - if (this.map && singleTileChanged) { │ │ │ │ - this.initProperties(); │ │ │ │ - this.clearGrid(); │ │ │ │ - this.tileSize = this.options.tileSize; │ │ │ │ - this.setTileSize(); │ │ │ │ - this.moveTo(null, true) │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fXMLHttpRequest_send(oRequest) { │ │ │ │ + oRequest._object.send(oRequest._data); │ │ │ │ + if (bGecko && !oRequest._async) { │ │ │ │ + oRequest.readyState = cXMLHttpRequest.OPENED; │ │ │ │ + fSynchronizeValues(oRequest); │ │ │ │ + while (oRequest.readyState < cXMLHttpRequest.DONE) { │ │ │ │ + oRequest.readyState++; │ │ │ │ + fReadyStateChange(oRequest); │ │ │ │ + if (oRequest._aborted) return │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Grid(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + } │ │ │ │ + cXMLHttpRequest.prototype.send = function(vData) { │ │ │ │ + if (cXMLHttpRequest.onsend) cXMLHttpRequest.onsend.apply(this, arguments); │ │ │ │ + if (!arguments.length) vData = null; │ │ │ │ + if (vData && vData.nodeType) { │ │ │ │ + vData = window.XMLSerializer ? (new window.XMLSerializer).serializeToString(vData) : vData.xml; │ │ │ │ + if (!this._headers["Content-Type"]) this._object.setRequestHeader("Content-Type", "application/xml") │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.HTTPRequest.prototype.clone.apply(this, [obj]); │ │ │ │ - if (this.tileSize != null) { │ │ │ │ - obj.tileSize = this.tileSize.clone() │ │ │ │ + this._data = vData; │ │ │ │ + fXMLHttpRequest_send(this) │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.abort = function() { │ │ │ │ + if (cXMLHttpRequest.onabort) cXMLHttpRequest.onabort.apply(this, arguments); │ │ │ │ + if (this.readyState > cXMLHttpRequest.UNSENT) this._aborted = true; │ │ │ │ + this._object.abort(); │ │ │ │ + fCleanTransport(this); │ │ │ │ + this.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ + delete this._data │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.getAllResponseHeaders = function() { │ │ │ │ + return this._object.getAllResponseHeaders() │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.getResponseHeader = function(sName) { │ │ │ │ + return this._object.getResponseHeader(sName) │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) { │ │ │ │ + if (!this._headers) this._headers = {}; │ │ │ │ + this._headers[sName] = sValue; │ │ │ │ + return this._object.setRequestHeader(sName, sValue) │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.addEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) return; │ │ │ │ + this._listeners.push([sName, fHandler, bUseCapture]) │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.removeEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) break; │ │ │ │ + if (oListener) this._listeners.splice(nIndex, 1) │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) { │ │ │ │ + var oEventPseudo = { │ │ │ │ + type: oEvent.type, │ │ │ │ + target: this, │ │ │ │ + currentTarget: this, │ │ │ │ + eventPhase: 2, │ │ │ │ + bubbles: oEvent.bubbles, │ │ │ │ + cancelable: oEvent.cancelable, │ │ │ │ + timeStamp: oEvent.timeStamp, │ │ │ │ + stopPropagation: function() {}, │ │ │ │ + preventDefault: function() {}, │ │ │ │ + initEvent: function() {} │ │ │ │ + }; │ │ │ │ + if (oEventPseudo.type == "readystatechange" && this.onreadystatechange)(this.onreadystatechange.handleEvent || this.onreadystatechange).apply(this, [oEventPseudo]); │ │ │ │ + for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ + if (oListener[0] == oEventPseudo.type && !oListener[2])(oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]) │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.prototype.toString = function() { │ │ │ │ + return "[" + "object" + " " + "XMLHttpRequest" + "]" │ │ │ │ + }; │ │ │ │ + cXMLHttpRequest.toString = function() { │ │ │ │ + return "[" + "XMLHttpRequest" + "]" │ │ │ │ + }; │ │ │ │ + │ │ │ │ + function fReadyStateChange(oRequest) { │ │ │ │ + if (cXMLHttpRequest.onreadystatechange) cXMLHttpRequest.onreadystatechange.apply(oRequest); │ │ │ │ + oRequest.dispatchEvent({ │ │ │ │ + type: "readystatechange", │ │ │ │ + bubbles: false, │ │ │ │ + cancelable: false, │ │ │ │ + timeStamp: new Date + 0 │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + │ │ │ │ + function fGetDocument(oRequest) { │ │ │ │ + var oDocument = oRequest.responseXML, │ │ │ │ + sResponse = oRequest.responseText; │ │ │ │ + if (bIE && sResponse && oDocument && !oDocument.documentElement && oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)) { │ │ │ │ + oDocument = new window.ActiveXObject("Microsoft.XMLDOM"); │ │ │ │ + oDocument.async = false; │ │ │ │ + oDocument.validateOnParse = false; │ │ │ │ + oDocument.loadXML(sResponse) │ │ │ │ } │ │ │ │ - obj.grid = []; │ │ │ │ - obj.gridResolution = null; │ │ │ │ - obj.backBuffer = null; │ │ │ │ - obj.backBufferTimerId = null; │ │ │ │ - obj.loading = false; │ │ │ │ - obj.numLoadingTiles = 0; │ │ │ │ - return obj │ │ │ │ - }, │ │ │ │ - moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments); │ │ │ │ - bounds = bounds || this.map.getExtent(); │ │ │ │ - if (bounds != null) { │ │ │ │ - var forceReTile = !this.grid.length || zoomChanged; │ │ │ │ - var tilesBounds = this.getTilesBounds(); │ │ │ │ - var resolution = this.map.getResolution(); │ │ │ │ - var serverResolution = this.getServerResolution(resolution); │ │ │ │ - if (this.singleTile) { │ │ │ │ - if (forceReTile || !dragging && !tilesBounds.containsBounds(bounds)) { │ │ │ │ - if (zoomChanged && this.transitionEffect !== "resize") { │ │ │ │ - this.removeBackBuffer() │ │ │ │ - } │ │ │ │ - if (!zoomChanged || this.transitionEffect === "resize") { │ │ │ │ - this.applyBackBuffer(resolution) │ │ │ │ - } │ │ │ │ - this.initSingleTile(bounds) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - forceReTile = forceReTile || !tilesBounds.intersectsBounds(bounds, { │ │ │ │ - worldBounds: this.map.baseLayer.wrapDateLine && this.map.getMaxExtent() │ │ │ │ - }); │ │ │ │ - if (forceReTile) { │ │ │ │ - if (zoomChanged && (this.transitionEffect === "resize" || this.gridResolution === resolution)) { │ │ │ │ - this.applyBackBuffer(resolution) │ │ │ │ - } │ │ │ │ - this.initGriddedTiles(bounds) │ │ │ │ - } else { │ │ │ │ - this.moveGriddedTiles() │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (oDocument) │ │ │ │ + if (bIE && oDocument.parseError != 0 || !oDocument.documentElement || oDocument.documentElement && oDocument.documentElement.tagName == "parsererror") return null; │ │ │ │ + return oDocument │ │ │ │ + } │ │ │ │ + │ │ │ │ + function fSynchronizeValues(oRequest) { │ │ │ │ + try { │ │ │ │ + oRequest.responseText = oRequest._object.responseText │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.responseXML = fGetDocument(oRequest._object) │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.status = oRequest._object.status │ │ │ │ + } catch (e) {} │ │ │ │ + try { │ │ │ │ + oRequest.statusText = oRequest._object.statusText │ │ │ │ + } catch (e) {} │ │ │ │ + } │ │ │ │ + │ │ │ │ + function fCleanTransport(oRequest) { │ │ │ │ + oRequest._object.onreadystatechange = new window.Function │ │ │ │ + } │ │ │ │ + if (!window.Function.prototype.apply) { │ │ │ │ + window.Function.prototype.apply = function(oRequest, oArguments) { │ │ │ │ + if (!oArguments) oArguments = []; │ │ │ │ + oRequest.__func = this; │ │ │ │ + oRequest.__func(oArguments[0], oArguments[1], oArguments[2], oArguments[3], oArguments[4]); │ │ │ │ + delete oRequest.__func │ │ │ │ } │ │ │ │ + } │ │ │ │ + if (!OpenLayers.Request) { │ │ │ │ + OpenLayers.Request = {} │ │ │ │ + } │ │ │ │ + OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest │ │ │ │ +})(); │ │ │ │ +OpenLayers.ProxyHost = ""; │ │ │ │ +if (!OpenLayers.Request) { │ │ │ │ + OpenLayers.Request = {} │ │ │ │ +} │ │ │ │ +OpenLayers.Util.extend(OpenLayers.Request, { │ │ │ │ + DEFAULT_CONFIG: { │ │ │ │ + method: "GET", │ │ │ │ + url: window.location.href, │ │ │ │ + async: true, │ │ │ │ + user: undefined, │ │ │ │ + password: undefined, │ │ │ │ + params: null, │ │ │ │ + proxy: OpenLayers.ProxyHost, │ │ │ │ + headers: {}, │ │ │ │ + data: null, │ │ │ │ + callback: function() {}, │ │ │ │ + success: null, │ │ │ │ + failure: null, │ │ │ │ + scope: null │ │ │ │ }, │ │ │ │ - getTileData: function(loc) { │ │ │ │ - var data = null, │ │ │ │ - x = loc.lon, │ │ │ │ - y = loc.lat, │ │ │ │ - numRows = this.grid.length; │ │ │ │ - if (this.map && numRows) { │ │ │ │ - var res = this.map.getResolution(), │ │ │ │ - tileWidth = this.tileSize.w, │ │ │ │ - tileHeight = this.tileSize.h, │ │ │ │ - bounds = this.grid[0][0].bounds, │ │ │ │ - left = bounds.left, │ │ │ │ - top = bounds.top; │ │ │ │ - if (x < left) { │ │ │ │ - if (this.map.baseLayer.wrapDateLine) { │ │ │ │ - var worldWidth = this.map.getMaxExtent().getWidth(); │ │ │ │ - var worldsAway = Math.ceil((left - x) / worldWidth); │ │ │ │ - x += worldWidth * worldsAway │ │ │ │ - } │ │ │ │ + URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/, │ │ │ │ + events: new OpenLayers.Events(this), │ │ │ │ + makeSameOrigin: function(url, proxy) { │ │ │ │ + var sameOrigin = url.indexOf("http") !== 0; │ │ │ │ + var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX); │ │ │ │ + if (urlParts) { │ │ │ │ + var location = window.location; │ │ │ │ + sameOrigin = urlParts[1] == location.protocol && urlParts[3] == location.hostname; │ │ │ │ + var uPort = urlParts[4], │ │ │ │ + lPort = location.port; │ │ │ │ + if (uPort != 80 && uPort != "" || lPort != "80" && lPort != "") { │ │ │ │ + sameOrigin = sameOrigin && uPort == lPort │ │ │ │ } │ │ │ │ - var dtx = (x - left) / (res * tileWidth); │ │ │ │ - var dty = (top - y) / (res * tileHeight); │ │ │ │ - var col = Math.floor(dtx); │ │ │ │ - var row = Math.floor(dty); │ │ │ │ - if (row >= 0 && row < numRows) { │ │ │ │ - var tile = this.grid[row][col]; │ │ │ │ - if (tile) { │ │ │ │ - data = { │ │ │ │ - tile: tile, │ │ │ │ - i: Math.floor((dtx - col) * tileWidth), │ │ │ │ - j: Math.floor((dty - row) * tileHeight) │ │ │ │ - } │ │ │ │ + } │ │ │ │ + if (!sameOrigin) { │ │ │ │ + if (proxy) { │ │ │ │ + if (typeof proxy == "function") { │ │ │ │ + url = proxy(url) │ │ │ │ + } else { │ │ │ │ + url = proxy + encodeURIComponent(url) │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - return data │ │ │ │ - }, │ │ │ │ - destroyTile: function(tile) { │ │ │ │ - this.removeTileMonitoringHooks(tile); │ │ │ │ - tile.destroy() │ │ │ │ + return url │ │ │ │ }, │ │ │ │ - getServerResolution: function(resolution) { │ │ │ │ - var distance = Number.POSITIVE_INFINITY; │ │ │ │ - resolution = resolution || this.map.getResolution(); │ │ │ │ - if (this.serverResolutions && OpenLayers.Util.indexOf(this.serverResolutions, resolution) === -1) { │ │ │ │ - var i, newDistance, newResolution, serverResolution; │ │ │ │ - for (i = this.serverResolutions.length - 1; i >= 0; i--) { │ │ │ │ - newResolution = this.serverResolutions[i]; │ │ │ │ - newDistance = Math.abs(newResolution - resolution); │ │ │ │ - if (newDistance > distance) { │ │ │ │ - break │ │ │ │ + issue: function(config) { │ │ │ │ + var defaultConfig = OpenLayers.Util.extend(this.DEFAULT_CONFIG, { │ │ │ │ + proxy: OpenLayers.ProxyHost │ │ │ │ + }); │ │ │ │ + config = config || {}; │ │ │ │ + config.headers = config.headers || {}; │ │ │ │ + config = OpenLayers.Util.applyDefaults(config, defaultConfig); │ │ │ │ + config.headers = OpenLayers.Util.applyDefaults(config.headers, defaultConfig.headers); │ │ │ │ + var customRequestedWithHeader = false, │ │ │ │ + headerKey; │ │ │ │ + for (headerKey in config.headers) { │ │ │ │ + if (config.headers.hasOwnProperty(headerKey)) { │ │ │ │ + if (headerKey.toLowerCase() === "x-requested-with") { │ │ │ │ + customRequestedWithHeader = true │ │ │ │ } │ │ │ │ - distance = newDistance; │ │ │ │ - serverResolution = newResolution │ │ │ │ } │ │ │ │ - resolution = serverResolution │ │ │ │ - } │ │ │ │ - return resolution │ │ │ │ - }, │ │ │ │ - getServerZoom: function() { │ │ │ │ - var resolution = this.getServerResolution(); │ │ │ │ - return this.serverResolutions ? OpenLayers.Util.indexOf(this.serverResolutions, resolution) : this.map.getZoomForResolution(resolution) + (this.zoomOffset || 0) │ │ │ │ - }, │ │ │ │ - applyBackBuffer: function(resolution) { │ │ │ │ - if (this.backBufferTimerId !== null) { │ │ │ │ - this.removeBackBuffer() │ │ │ │ } │ │ │ │ - var backBuffer = this.backBuffer; │ │ │ │ - if (!backBuffer) { │ │ │ │ - backBuffer = this.createBackBuffer(); │ │ │ │ - if (!backBuffer) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (resolution === this.gridResolution) { │ │ │ │ - this.div.insertBefore(backBuffer, this.div.firstChild) │ │ │ │ - } else { │ │ │ │ - this.map.baseLayer.div.parentNode.insertBefore(backBuffer, this.map.baseLayer.div) │ │ │ │ - } │ │ │ │ - this.backBuffer = backBuffer; │ │ │ │ - var topLeftTileBounds = this.grid[0][0].bounds; │ │ │ │ - this.backBufferLonLat = { │ │ │ │ - lon: topLeftTileBounds.left, │ │ │ │ - lat: topLeftTileBounds.top │ │ │ │ - }; │ │ │ │ - this.backBufferResolution = this.gridResolution │ │ │ │ + if (customRequestedWithHeader === false) { │ │ │ │ + config.headers["X-Requested-With"] = "XMLHttpRequest" │ │ │ │ } │ │ │ │ - var ratio = this.backBufferResolution / resolution; │ │ │ │ - var tiles = backBuffer.childNodes, │ │ │ │ - tile; │ │ │ │ - for (var i = tiles.length - 1; i >= 0; --i) { │ │ │ │ - tile = tiles[i]; │ │ │ │ - tile.style.top = (ratio * tile._i * tile._h | 0) + "px"; │ │ │ │ - tile.style.left = (ratio * tile._j * tile._w | 0) + "px"; │ │ │ │ - tile.style.width = Math.round(ratio * tile._w) + "px"; │ │ │ │ - tile.style.height = Math.round(ratio * tile._h) + "px" │ │ │ │ + var request = new OpenLayers.Request.XMLHttpRequest; │ │ │ │ + var url = OpenLayers.Util.urlAppend(config.url, OpenLayers.Util.getParameterString(config.params || {})); │ │ │ │ + url = OpenLayers.Request.makeSameOrigin(url, config.proxy); │ │ │ │ + request.open(config.method, url, config.async, config.user, config.password); │ │ │ │ + for (var header in config.headers) { │ │ │ │ + request.setRequestHeader(header, config.headers[header]) │ │ │ │ } │ │ │ │ - var position = this.getViewPortPxFromLonLat(this.backBufferLonLat, resolution); │ │ │ │ - var leftOffset = this.map.layerContainerOriginPx.x; │ │ │ │ - var topOffset = this.map.layerContainerOriginPx.y; │ │ │ │ - backBuffer.style.left = Math.round(position.x - leftOffset) + "px"; │ │ │ │ - backBuffer.style.top = Math.round(position.y - topOffset) + "px" │ │ │ │ - }, │ │ │ │ - createBackBuffer: function() { │ │ │ │ - var backBuffer; │ │ │ │ - if (this.grid.length > 0) { │ │ │ │ - backBuffer = document.createElement("div"); │ │ │ │ - backBuffer.id = this.div.id + "_bb"; │ │ │ │ - backBuffer.className = "olBackBuffer"; │ │ │ │ - backBuffer.style.position = "absolute"; │ │ │ │ - var map = this.map; │ │ │ │ - backBuffer.style.zIndex = this.transitionEffect === "resize" ? this.getZIndex() - 1 : map.Z_INDEX_BASE.BaseLayer - (map.getNumLayers() - map.getLayerIndex(this)); │ │ │ │ - for (var i = 0, lenI = this.grid.length; i < lenI; i++) { │ │ │ │ - for (var j = 0, lenJ = this.grid[i].length; j < lenJ; j++) { │ │ │ │ - var tile = this.grid[i][j], │ │ │ │ - markup = this.grid[i][j].createBackBuffer(); │ │ │ │ - if (markup) { │ │ │ │ - markup._i = i; │ │ │ │ - markup._j = j; │ │ │ │ - markup._w = tile.size.w; │ │ │ │ - markup._h = tile.size.h; │ │ │ │ - markup.id = tile.id + "_bb"; │ │ │ │ - backBuffer.appendChild(markup) │ │ │ │ - } │ │ │ │ + var events = this.events; │ │ │ │ + var self = this; │ │ │ │ + request.onreadystatechange = function() { │ │ │ │ + if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) { │ │ │ │ + var proceed = events.triggerEvent("complete", { │ │ │ │ + request: request, │ │ │ │ + config: config, │ │ │ │ + requestUrl: url │ │ │ │ + }); │ │ │ │ + if (proceed !== false) { │ │ │ │ + self.runCallbacks({ │ │ │ │ + request: request, │ │ │ │ + config: config, │ │ │ │ + requestUrl: url │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ + }; │ │ │ │ + if (config.async === false) { │ │ │ │ + request.send(config.data) │ │ │ │ + } else { │ │ │ │ + window.setTimeout(function() { │ │ │ │ + if (request.readyState !== 0) { │ │ │ │ + request.send(config.data) │ │ │ │ + } │ │ │ │ + }, 0) │ │ │ │ } │ │ │ │ - return backBuffer │ │ │ │ + return request │ │ │ │ }, │ │ │ │ - removeBackBuffer: function() { │ │ │ │ - if (this._transitionElement) { │ │ │ │ - for (var i = this.transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ - OpenLayers.Event.stopObserving(this._transitionElement, this.transitionendEvents[i], this._removeBackBuffer) │ │ │ │ - } │ │ │ │ - delete this._transitionElement │ │ │ │ + runCallbacks: function(options) { │ │ │ │ + var request = options.request; │ │ │ │ + var config = options.config; │ │ │ │ + var complete = config.scope ? OpenLayers.Function.bind(config.callback, config.scope) : config.callback; │ │ │ │ + var success; │ │ │ │ + if (config.success) { │ │ │ │ + success = config.scope ? OpenLayers.Function.bind(config.success, config.scope) : config.success │ │ │ │ } │ │ │ │ - if (this.backBuffer) { │ │ │ │ - if (this.backBuffer.parentNode) { │ │ │ │ - this.backBuffer.parentNode.removeChild(this.backBuffer) │ │ │ │ + var failure; │ │ │ │ + if (config.failure) { │ │ │ │ + failure = config.scope ? OpenLayers.Function.bind(config.failure, config.scope) : config.failure │ │ │ │ + } │ │ │ │ + if (OpenLayers.Util.createUrlObject(config.url).protocol == "file:" && request.responseText) { │ │ │ │ + request.status = 200 │ │ │ │ + } │ │ │ │ + complete(request); │ │ │ │ + if (!request.status || request.status >= 200 && request.status < 300) { │ │ │ │ + this.events.triggerEvent("success", options); │ │ │ │ + if (success) { │ │ │ │ + success(request) │ │ │ │ } │ │ │ │ - this.backBuffer = null; │ │ │ │ - this.backBufferResolution = null; │ │ │ │ - if (this.backBufferTimerId !== null) { │ │ │ │ - window.clearTimeout(this.backBufferTimerId); │ │ │ │ - this.backBufferTimerId = null │ │ │ │ + } │ │ │ │ + if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ + this.events.triggerEvent("failure", options); │ │ │ │ + if (failure) { │ │ │ │ + failure(request) │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - moveByPx: function(dx, dy) { │ │ │ │ - if (!this.singleTile) { │ │ │ │ - this.moveGriddedTiles() │ │ │ │ - } │ │ │ │ + GET: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "GET" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config) │ │ │ │ }, │ │ │ │ - setTileSize: function(size) { │ │ │ │ - if (this.singleTile) { │ │ │ │ - size = this.map.getSize(); │ │ │ │ - size.h = parseInt(size.h * this.ratio, 10); │ │ │ │ - size.w = parseInt(size.w * this.ratio, 10) │ │ │ │ + POST: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "POST" │ │ │ │ + }); │ │ │ │ + config.headers = config.headers ? config.headers : {}; │ │ │ │ + if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ + config.headers["Content-Type"] = "application/xml" │ │ │ │ } │ │ │ │ - OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]) │ │ │ │ + return OpenLayers.Request.issue(config) │ │ │ │ }, │ │ │ │ - getTilesBounds: function() { │ │ │ │ - var bounds = null; │ │ │ │ - var length = this.grid.length; │ │ │ │ - if (length) { │ │ │ │ - var bottomLeftTileBounds = this.grid[length - 1][0].bounds, │ │ │ │ - width = this.grid[0].length * bottomLeftTileBounds.getWidth(), │ │ │ │ - height = this.grid.length * bottomLeftTileBounds.getHeight(); │ │ │ │ - bounds = new OpenLayers.Bounds(bottomLeftTileBounds.left, bottomLeftTileBounds.bottom, bottomLeftTileBounds.left + width, bottomLeftTileBounds.bottom + height) │ │ │ │ + PUT: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "PUT" │ │ │ │ + }); │ │ │ │ + config.headers = config.headers ? config.headers : {}; │ │ │ │ + if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ + config.headers["Content-Type"] = "application/xml" │ │ │ │ } │ │ │ │ - return bounds │ │ │ │ + return OpenLayers.Request.issue(config) │ │ │ │ }, │ │ │ │ - initSingleTile: function(bounds) { │ │ │ │ - this.events.triggerEvent("retile"); │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var tileWidth = bounds.getWidth() * this.ratio; │ │ │ │ - var tileHeight = bounds.getHeight() * this.ratio; │ │ │ │ - var tileBounds = new OpenLayers.Bounds(center.lon - tileWidth / 2, center.lat - tileHeight / 2, center.lon + tileWidth / 2, center.lat + tileHeight / 2); │ │ │ │ - var px = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: tileBounds.left, │ │ │ │ - lat: tileBounds.top │ │ │ │ + DELETE: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "DELETE" │ │ │ │ }); │ │ │ │ - if (!this.grid.length) { │ │ │ │ - this.grid[0] = [] │ │ │ │ - } │ │ │ │ - var tile = this.grid[0][0]; │ │ │ │ - if (!tile) { │ │ │ │ - tile = this.addTile(tileBounds, px); │ │ │ │ - this.addTileMonitoringHooks(tile); │ │ │ │ - tile.draw(); │ │ │ │ - this.grid[0][0] = tile │ │ │ │ - } else { │ │ │ │ - tile.moveTo(tileBounds, px) │ │ │ │ - } │ │ │ │ - this.removeExcessTiles(1, 1); │ │ │ │ - this.gridResolution = this.getServerResolution() │ │ │ │ + return OpenLayers.Request.issue(config) │ │ │ │ }, │ │ │ │ - calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ - var tilelon = resolution * this.tileSize.w; │ │ │ │ - var tilelat = resolution * this.tileSize.h; │ │ │ │ - var offsetlon = bounds.left - origin.lon; │ │ │ │ - var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ - var rowSign = this.rowSign; │ │ │ │ - var offsetlat = rowSign * (origin.lat - bounds.top + tilelat); │ │ │ │ - var tilerow = Math[~rowSign ? "floor" : "ceil"](offsetlat / tilelat) - this.buffer * rowSign; │ │ │ │ - return { │ │ │ │ - tilelon: tilelon, │ │ │ │ - tilelat: tilelat, │ │ │ │ - startcol: tilecol, │ │ │ │ - startrow: tilerow │ │ │ │ + HEAD: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "HEAD" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config) │ │ │ │ + }, │ │ │ │ + OPTIONS: function(config) { │ │ │ │ + config = OpenLayers.Util.extend(config, { │ │ │ │ + method: "OPTIONS" │ │ │ │ + }); │ │ │ │ + return OpenLayers.Request.issue(config) │ │ │ │ + } │ │ │ │ +}); │ │ │ │ +OpenLayers.State = { │ │ │ │ + UNKNOWN: "Unknown", │ │ │ │ + INSERT: "Insert", │ │ │ │ + UPDATE: "Update", │ │ │ │ + DELETE: "Delete" │ │ │ │ +}; │ │ │ │ +OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, { │ │ │ │ + fid: null, │ │ │ │ + geometry: null, │ │ │ │ + attributes: null, │ │ │ │ + bounds: null, │ │ │ │ + state: null, │ │ │ │ + style: null, │ │ │ │ + url: null, │ │ │ │ + renderIntent: "default", │ │ │ │ + modified: null, │ │ │ │ + initialize: function(geometry, attributes, style) { │ │ │ │ + OpenLayers.Feature.prototype.initialize.apply(this, [null, null, attributes]); │ │ │ │ + this.lonlat = null; │ │ │ │ + this.geometry = geometry ? geometry : null; │ │ │ │ + this.state = null; │ │ │ │ + this.attributes = {}; │ │ │ │ + if (attributes) { │ │ │ │ + this.attributes = OpenLayers.Util.extend(this.attributes, attributes) │ │ │ │ } │ │ │ │ + this.style = style ? style : null │ │ │ │ }, │ │ │ │ - getTileOrigin: function() { │ │ │ │ - var origin = this.tileOrigin; │ │ │ │ - if (!origin) { │ │ │ │ - var extent = this.getMaxExtent(); │ │ │ │ - var edges = { │ │ │ │ - tl: ["left", "top"], │ │ │ │ - tr: ["right", "top"], │ │ │ │ - bl: ["left", "bottom"], │ │ │ │ - br: ["right", "bottom"] │ │ │ │ - } [this.tileOriginCorner]; │ │ │ │ - origin = new OpenLayers.LonLat(extent[edges[0]], extent[edges[1]]) │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layer) { │ │ │ │ + this.layer.removeFeatures(this); │ │ │ │ + this.layer = null │ │ │ │ } │ │ │ │ - return origin │ │ │ │ + this.geometry = null; │ │ │ │ + this.modified = null; │ │ │ │ + OpenLayers.Feature.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - getTileBoundsForGridIndex: function(row, col) { │ │ │ │ - var origin = this.getTileOrigin(); │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - var tilelon = tileLayout.tilelon; │ │ │ │ - var tilelat = tileLayout.tilelat; │ │ │ │ - var startcol = tileLayout.startcol; │ │ │ │ - var startrow = tileLayout.startrow; │ │ │ │ - var rowSign = this.rowSign; │ │ │ │ - return new OpenLayers.Bounds(origin.lon + (startcol + col) * tilelon, origin.lat - (startrow + row * rowSign) * tilelat * rowSign, origin.lon + (startcol + col + 1) * tilelon, origin.lat - (startrow + (row - 1) * rowSign) * tilelat * rowSign) │ │ │ │ + clone: function() { │ │ │ │ + return new OpenLayers.Feature.Vector(this.geometry ? this.geometry.clone() : null, this.attributes, this.style) │ │ │ │ }, │ │ │ │ - initGriddedTiles: function(bounds) { │ │ │ │ - this.events.triggerEvent("retile"); │ │ │ │ - var viewSize = this.map.getSize(); │ │ │ │ - var origin = this.getTileOrigin(); │ │ │ │ - var resolution = this.map.getResolution(), │ │ │ │ - serverResolution = this.getServerResolution(), │ │ │ │ - ratio = resolution / serverResolution, │ │ │ │ - tileSize = { │ │ │ │ - w: this.tileSize.w / ratio, │ │ │ │ - h: this.tileSize.h / ratio │ │ │ │ - }; │ │ │ │ - var minRows = Math.ceil(viewSize.h / tileSize.h) + 2 * this.buffer + 1; │ │ │ │ - var minCols = Math.ceil(viewSize.w / tileSize.w) + 2 * this.buffer + 1; │ │ │ │ - var tileLayout = this.calculateGridLayout(bounds, origin, serverResolution); │ │ │ │ - this.gridLayout = tileLayout; │ │ │ │ - var tilelon = tileLayout.tilelon; │ │ │ │ - var tilelat = tileLayout.tilelat; │ │ │ │ - var layerContainerDivLeft = this.map.layerContainerOriginPx.x; │ │ │ │ - var layerContainerDivTop = this.map.layerContainerOriginPx.y; │ │ │ │ - var tileBounds = this.getTileBoundsForGridIndex(0, 0); │ │ │ │ - var startPx = this.map.getViewPortPxFromLonLat(new OpenLayers.LonLat(tileBounds.left, tileBounds.top)); │ │ │ │ - startPx.x = Math.round(startPx.x) - layerContainerDivLeft; │ │ │ │ - startPx.y = Math.round(startPx.y) - layerContainerDivTop; │ │ │ │ - var tileData = [], │ │ │ │ - center = this.map.getCenter(); │ │ │ │ - var rowidx = 0; │ │ │ │ - do { │ │ │ │ - var row = this.grid[rowidx]; │ │ │ │ - if (!row) { │ │ │ │ - row = []; │ │ │ │ - this.grid.push(row) │ │ │ │ + onScreen: function(boundsOnly) { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.layer && this.layer.map) { │ │ │ │ + var screenBounds = this.layer.map.getExtent(); │ │ │ │ + if (boundsOnly) { │ │ │ │ + var featureBounds = this.geometry.getBounds(); │ │ │ │ + onScreen = screenBounds.intersectsBounds(featureBounds) │ │ │ │ + } else { │ │ │ │ + var screenPoly = screenBounds.toGeometry(); │ │ │ │ + onScreen = screenPoly.intersects(this.geometry) │ │ │ │ } │ │ │ │ - var colidx = 0; │ │ │ │ - do { │ │ │ │ - tileBounds = this.getTileBoundsForGridIndex(rowidx, colidx); │ │ │ │ - var px = startPx.clone(); │ │ │ │ - px.x = px.x + colidx * Math.round(tileSize.w); │ │ │ │ - px.y = px.y + rowidx * Math.round(tileSize.h); │ │ │ │ - var tile = row[colidx]; │ │ │ │ - if (!tile) { │ │ │ │ - tile = this.addTile(tileBounds, px); │ │ │ │ - this.addTileMonitoringHooks(tile); │ │ │ │ - row.push(tile) │ │ │ │ - } else { │ │ │ │ - tile.moveTo(tileBounds, px, false) │ │ │ │ - } │ │ │ │ - var tileCenter = tileBounds.getCenterLonLat(); │ │ │ │ - tileData.push({ │ │ │ │ - tile: tile, │ │ │ │ - distance: Math.pow(tileCenter.lon - center.lon, 2) + Math.pow(tileCenter.lat - center.lat, 2) │ │ │ │ - }); │ │ │ │ - colidx += 1 │ │ │ │ - } while (tileBounds.right <= bounds.right + tilelon * this.buffer || colidx < minCols); │ │ │ │ - rowidx += 1 │ │ │ │ - } while (tileBounds.bottom >= bounds.bottom - tilelat * this.buffer || rowidx < minRows); │ │ │ │ - this.removeExcessTiles(rowidx, colidx); │ │ │ │ - var resolution = this.getServerResolution(); │ │ │ │ - this.gridResolution = resolution; │ │ │ │ - tileData.sort(function(a, b) { │ │ │ │ - return a.distance - b.distance │ │ │ │ - }); │ │ │ │ - for (var i = 0, ii = tileData.length; i < ii; ++i) { │ │ │ │ - tileData[i].tile.draw() │ │ │ │ } │ │ │ │ + return onScreen │ │ │ │ }, │ │ │ │ - getMaxExtent: function() { │ │ │ │ - return this.maxExtent │ │ │ │ - }, │ │ │ │ - addTile: function(bounds, position) { │ │ │ │ - var tile = new this.tileClass(this, position, bounds, null, this.tileSize, this.tileOptions); │ │ │ │ - this.events.triggerEvent("addtile", { │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - return tile │ │ │ │ + getVisibility: function() { │ │ │ │ + return !(this.style && this.style.display == "none" || !this.layer || this.layer && this.layer.styleMap && this.layer.styleMap.createSymbolizer(this, this.renderIntent).display == "none" || this.layer && !this.layer.getVisibility()) │ │ │ │ }, │ │ │ │ - addTileMonitoringHooks: function(tile) { │ │ │ │ - var replacingCls = "olTileReplacing"; │ │ │ │ - tile.onLoadStart = function() { │ │ │ │ - if (this.loading === false) { │ │ │ │ - this.loading = true; │ │ │ │ - this.events.triggerEvent("loadstart") │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("tileloadstart", { │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - this.numLoadingTiles++; │ │ │ │ - if (!this.singleTile && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ - OpenLayers.Element.addClass(tile.getTile(), replacingCls) │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - tile.onLoadEnd = function(evt) { │ │ │ │ - this.numLoadingTiles--; │ │ │ │ - var aborted = evt.type === "unload"; │ │ │ │ - this.events.triggerEvent("tileloaded", { │ │ │ │ - tile: tile, │ │ │ │ - aborted: aborted │ │ │ │ - }); │ │ │ │ - if (!this.singleTile && !aborted && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ - var tileDiv = tile.getTile(); │ │ │ │ - if (OpenLayers.Element.getStyle(tileDiv, "display") === "none") { │ │ │ │ - var bufferTile = document.getElementById(tile.id + "_bb"); │ │ │ │ - if (bufferTile) { │ │ │ │ - bufferTile.parentNode.removeChild(bufferTile) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Element.removeClass(tileDiv, replacingCls) │ │ │ │ - } │ │ │ │ - if (this.numLoadingTiles === 0) { │ │ │ │ - if (this.backBuffer) { │ │ │ │ - if (this.backBuffer.childNodes.length === 0) { │ │ │ │ - this.removeBackBuffer() │ │ │ │ - } else { │ │ │ │ - this._transitionElement = aborted ? this.div.lastChild : tile.imgDiv; │ │ │ │ - var transitionendEvents = this.transitionendEvents; │ │ │ │ - for (var i = transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ - OpenLayers.Event.observe(this._transitionElement, transitionendEvents[i], this._removeBackBuffer) │ │ │ │ - } │ │ │ │ - this.backBufferTimerId = window.setTimeout(this._removeBackBuffer, this.removeBackBufferDelay) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.loading = false; │ │ │ │ - this.events.triggerEvent("loadend") │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - tile.onLoadError = function() { │ │ │ │ - this.events.triggerEvent("tileerror", { │ │ │ │ - tile: tile │ │ │ │ - }) │ │ │ │ - }; │ │ │ │ - tile.events.on({ │ │ │ │ - loadstart: tile.onLoadStart, │ │ │ │ - loadend: tile.onLoadEnd, │ │ │ │ - unload: tile.onLoadEnd, │ │ │ │ - loaderror: tile.onLoadError, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + createMarker: function() { │ │ │ │ + return null │ │ │ │ }, │ │ │ │ - removeTileMonitoringHooks: function(tile) { │ │ │ │ - tile.unload(); │ │ │ │ - tile.events.un({ │ │ │ │ - loadstart: tile.onLoadStart, │ │ │ │ - loadend: tile.onLoadEnd, │ │ │ │ - unload: tile.onLoadEnd, │ │ │ │ - loaderror: tile.onLoadError, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + destroyMarker: function() {}, │ │ │ │ + createPopup: function() { │ │ │ │ + return null │ │ │ │ }, │ │ │ │ - moveGriddedTiles: function() { │ │ │ │ - var buffer = this.buffer + 1; │ │ │ │ - while (true) { │ │ │ │ - var tlTile = this.grid[0][0]; │ │ │ │ - var tlViewPort = { │ │ │ │ - x: tlTile.position.x + this.map.layerContainerOriginPx.x, │ │ │ │ - y: tlTile.position.y + this.map.layerContainerOriginPx.y │ │ │ │ - }; │ │ │ │ - var ratio = this.getServerResolution() / this.map.getResolution(); │ │ │ │ - var tileSize = { │ │ │ │ - w: Math.round(this.tileSize.w * ratio), │ │ │ │ - h: Math.round(this.tileSize.h * ratio) │ │ │ │ - }; │ │ │ │ - if (tlViewPort.x > -tileSize.w * (buffer - 1)) { │ │ │ │ - this.shiftColumn(true, tileSize) │ │ │ │ - } else if (tlViewPort.x < -tileSize.w * buffer) { │ │ │ │ - this.shiftColumn(false, tileSize) │ │ │ │ - } else if (tlViewPort.y > -tileSize.h * (buffer - 1)) { │ │ │ │ - this.shiftRow(true, tileSize) │ │ │ │ - } else if (tlViewPort.y < -tileSize.h * buffer) { │ │ │ │ - this.shiftRow(false, tileSize) │ │ │ │ - } else { │ │ │ │ - break │ │ │ │ - } │ │ │ │ + atPoint: function(lonlat, toleranceLon, toleranceLat) { │ │ │ │ + var atPoint = false; │ │ │ │ + if (this.geometry) { │ │ │ │ + atPoint = this.geometry.atPoint(lonlat, toleranceLon, toleranceLat) │ │ │ │ } │ │ │ │ + return atPoint │ │ │ │ }, │ │ │ │ - shiftRow: function(prepend, tileSize) { │ │ │ │ - var grid = this.grid; │ │ │ │ - var rowIndex = prepend ? 0 : grid.length - 1; │ │ │ │ - var sign = prepend ? -1 : 1; │ │ │ │ - var rowSign = this.rowSign; │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - tileLayout.startrow += sign * rowSign; │ │ │ │ - var modelRow = grid[rowIndex]; │ │ │ │ - var row = grid[prepend ? "pop" : "shift"](); │ │ │ │ - for (var i = 0, len = row.length; i < len; i++) { │ │ │ │ - var tile = row[i]; │ │ │ │ - var position = modelRow[i].position.clone(); │ │ │ │ - position.y += tileSize.h * sign; │ │ │ │ - tile.moveTo(this.getTileBoundsForGridIndex(rowIndex, i), position) │ │ │ │ + destroyPopup: function() {}, │ │ │ │ + move: function(location) { │ │ │ │ + if (!this.layer || !this.geometry.move) { │ │ │ │ + return undefined │ │ │ │ } │ │ │ │ - grid[prepend ? "unshift" : "push"](row) │ │ │ │ - }, │ │ │ │ - shiftColumn: function(prepend, tileSize) { │ │ │ │ - var grid = this.grid; │ │ │ │ - var colIndex = prepend ? 0 : grid[0].length - 1; │ │ │ │ - var sign = prepend ? -1 : 1; │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - tileLayout.startcol += sign; │ │ │ │ - for (var i = 0, len = grid.length; i < len; i++) { │ │ │ │ - var row = grid[i]; │ │ │ │ - var position = row[colIndex].position.clone(); │ │ │ │ - var tile = row[prepend ? "pop" : "shift"](); │ │ │ │ - position.x += tileSize.w * sign; │ │ │ │ - tile.moveTo(this.getTileBoundsForGridIndex(i, colIndex), position); │ │ │ │ - row[prepend ? "unshift" : "push"](tile) │ │ │ │ + var pixel; │ │ │ │ + if (location.CLASS_NAME == "OpenLayers.LonLat") { │ │ │ │ + pixel = this.layer.getViewPortPxFromLonLat(location) │ │ │ │ + } else { │ │ │ │ + pixel = location │ │ │ │ } │ │ │ │ + var lastPixel = this.layer.getViewPortPxFromLonLat(this.geometry.getBounds().getCenterLonLat()); │ │ │ │ + var res = this.layer.map.getResolution(); │ │ │ │ + this.geometry.move(res * (pixel.x - lastPixel.x), res * (lastPixel.y - pixel.y)); │ │ │ │ + this.layer.drawFeature(this); │ │ │ │ + return lastPixel │ │ │ │ }, │ │ │ │ - removeExcessTiles: function(rows, columns) { │ │ │ │ - var i, l; │ │ │ │ - while (this.grid.length > rows) { │ │ │ │ - var row = this.grid.pop(); │ │ │ │ - for (i = 0, l = row.length; i < l; i++) { │ │ │ │ - var tile = row[i]; │ │ │ │ - this.destroyTile(tile) │ │ │ │ + toState: function(state) { │ │ │ │ + if (state == OpenLayers.State.UPDATE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + this.state = state; │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + break │ │ │ │ } │ │ │ │ - } │ │ │ │ - for (i = 0, l = this.grid.length; i < l; i++) { │ │ │ │ - while (this.grid[i].length > columns) { │ │ │ │ - var row = this.grid[i]; │ │ │ │ - var tile = row.pop(); │ │ │ │ - this.destroyTile(tile) │ │ │ │ + } else if (state == OpenLayers.State.INSERT) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + this.state = state; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } else if (state == OpenLayers.State.DELETE) { │ │ │ │ + switch (this.state) { │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UNKNOWN: │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + this.state = state; │ │ │ │ + break │ │ │ │ } │ │ │ │ + } else if (state == OpenLayers.State.UNKNOWN) { │ │ │ │ + this.state = state │ │ │ │ } │ │ │ │ }, │ │ │ │ - onMapResize: function() { │ │ │ │ - if (this.singleTile) { │ │ │ │ - this.clearGrid(); │ │ │ │ - this.setTileSize() │ │ │ │ - } │ │ │ │ + CLASS_NAME: "OpenLayers.Feature.Vector" │ │ │ │ +}); │ │ │ │ +OpenLayers.Feature.Vector.style = { │ │ │ │ + default: { │ │ │ │ + fillColor: "#ee9900", │ │ │ │ + fillOpacity: .4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: .8, │ │ │ │ + strokeColor: "#ee9900", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: .2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ }, │ │ │ │ - getTileBounds: function(viewPortPx) { │ │ │ │ - var maxExtent = this.maxExtent; │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ - var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ - var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ - var tileLeft = maxExtent.left + tileMapWidth * Math.floor((mapPoint.lon - maxExtent.left) / tileMapWidth); │ │ │ │ - var tileBottom = maxExtent.bottom + tileMapHeight * Math.floor((mapPoint.lat - maxExtent.bottom) / tileMapHeight); │ │ │ │ - return new OpenLayers.Bounds(tileLeft, tileBottom, tileLeft + tileMapWidth, tileBottom + tileMapHeight) │ │ │ │ + select: { │ │ │ │ + fillColor: "blue", │ │ │ │ + fillOpacity: .4, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: .8, │ │ │ │ + strokeColor: "blue", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: .2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "pointer", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Grid" │ │ │ │ -}); │ │ │ │ -OpenLayers.TileManager = OpenLayers.Class({ │ │ │ │ - cacheSize: 256, │ │ │ │ - tilesPerFrame: 2, │ │ │ │ - frameDelay: 16, │ │ │ │ - moveDelay: 100, │ │ │ │ - zoomDelay: 200, │ │ │ │ - maps: null, │ │ │ │ - tileQueueId: null, │ │ │ │ - tileQueue: null, │ │ │ │ - tileCache: null, │ │ │ │ - tileCacheIndex: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.maps = []; │ │ │ │ - this.tileQueueId = {}; │ │ │ │ - this.tileQueue = {}; │ │ │ │ - this.tileCache = {}; │ │ │ │ - this.tileCacheIndex = [] │ │ │ │ + temporary: { │ │ │ │ + fillColor: "#66cccc", │ │ │ │ + fillOpacity: .2, │ │ │ │ + hoverFillColor: "white", │ │ │ │ + hoverFillOpacity: .8, │ │ │ │ + strokeColor: "#66cccc", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeLinecap: "round", │ │ │ │ + strokeWidth: 2, │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + hoverStrokeColor: "red", │ │ │ │ + hoverStrokeOpacity: 1, │ │ │ │ + hoverStrokeWidth: .2, │ │ │ │ + pointRadius: 6, │ │ │ │ + hoverPointRadius: 1, │ │ │ │ + hoverPointUnit: "%", │ │ │ │ + pointerEvents: "visiblePainted", │ │ │ │ + cursor: "inherit", │ │ │ │ + fontColor: "#000000", │ │ │ │ + labelAlign: "cm", │ │ │ │ + labelOutlineColor: "white", │ │ │ │ + labelOutlineWidth: 3 │ │ │ │ }, │ │ │ │ - addMap: function(map) { │ │ │ │ - if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ - return │ │ │ │ + delete: { │ │ │ │ + display: "none" │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +OpenLayers.Style = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + name: null, │ │ │ │ + title: null, │ │ │ │ + description: null, │ │ │ │ + layerName: null, │ │ │ │ + isDefault: false, │ │ │ │ + rules: null, │ │ │ │ + context: null, │ │ │ │ + defaultStyle: null, │ │ │ │ + defaultsPerSymbolizer: false, │ │ │ │ + propertyStyles: null, │ │ │ │ + initialize: function(style, options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.rules = []; │ │ │ │ + if (options && options.rules) { │ │ │ │ + this.addRules(options.rules) │ │ │ │ } │ │ │ │ - this.maps.push(map); │ │ │ │ - this.tileQueue[map.id] = []; │ │ │ │ - for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ - this.addLayer({ │ │ │ │ - layer: map.layers[i] │ │ │ │ - }) │ │ │ │ + this.setDefaultStyle(style || OpenLayers.Feature.Vector.style["default"]); │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ + this.rules[i].destroy(); │ │ │ │ + this.rules[i] = null │ │ │ │ } │ │ │ │ - map.events.on({ │ │ │ │ - move: this.move, │ │ │ │ - zoomend: this.zoomEnd, │ │ │ │ - changelayer: this.changeLayer, │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - preremovelayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + this.rules = null; │ │ │ │ + this.defaultStyle = null │ │ │ │ }, │ │ │ │ - removeMap: function(map) { │ │ │ │ - if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ - return │ │ │ │ + createSymbolizer: function(feature) { │ │ │ │ + var style = this.defaultsPerSymbolizer ? {} : this.createLiterals(OpenLayers.Util.extend({}, this.defaultStyle), feature); │ │ │ │ + var rules = this.rules; │ │ │ │ + var rule, context; │ │ │ │ + var elseRules = []; │ │ │ │ + var appliedRules = false; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + rule = rules[i]; │ │ │ │ + var applies = rule.evaluate(feature); │ │ │ │ + if (applies) { │ │ │ │ + if (rule instanceof OpenLayers.Rule && rule.elseFilter) { │ │ │ │ + elseRules.push(rule) │ │ │ │ + } else { │ │ │ │ + appliedRules = true; │ │ │ │ + this.applySymbolizer(rule, style, feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ - if (map.layers) { │ │ │ │ - for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: map.layers[i] │ │ │ │ - }) │ │ │ │ + if (appliedRules == false && elseRules.length > 0) { │ │ │ │ + appliedRules = true; │ │ │ │ + for (var i = 0, len = elseRules.length; i < len; i++) { │ │ │ │ + this.applySymbolizer(elseRules[i], style, feature) │ │ │ │ } │ │ │ │ } │ │ │ │ - if (map.events) { │ │ │ │ - map.events.un({ │ │ │ │ - move: this.move, │ │ │ │ - zoomend: this.zoomEnd, │ │ │ │ - changelayer: this.changeLayer, │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - preremovelayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + if (rules.length > 0 && appliedRules == false) { │ │ │ │ + style.display = "none" │ │ │ │ } │ │ │ │ - delete this.tileQueue[map.id]; │ │ │ │ - delete this.tileQueueId[map.id]; │ │ │ │ - OpenLayers.Util.removeItem(this.maps, map) │ │ │ │ - }, │ │ │ │ - move: function(evt) { │ │ │ │ - this.updateTimeout(evt.object, this.moveDelay, true) │ │ │ │ + if (style.label != null && typeof style.label !== "string") { │ │ │ │ + style.label = String(style.label) │ │ │ │ + } │ │ │ │ + return style │ │ │ │ }, │ │ │ │ - zoomEnd: function(evt) { │ │ │ │ - this.updateTimeout(evt.object, this.zoomDelay) │ │ │ │ + applySymbolizer: function(rule, style, feature) { │ │ │ │ + var symbolizerPrefix = feature.geometry ? this.getSymbolizerPrefix(feature.geometry) : OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; │ │ │ │ + var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer; │ │ │ │ + if (this.defaultsPerSymbolizer === true) { │ │ │ │ + var defaults = this.defaultStyle; │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: defaults.pointRadius │ │ │ │ + }); │ │ │ │ + if (symbolizer.stroke === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + strokeWidth: defaults.strokeWidth, │ │ │ │ + strokeColor: defaults.strokeColor, │ │ │ │ + strokeOpacity: defaults.strokeOpacity, │ │ │ │ + strokeDashstyle: defaults.strokeDashstyle, │ │ │ │ + strokeLinecap: defaults.strokeLinecap │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (symbolizer.fill === true || symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + fillColor: defaults.fillColor, │ │ │ │ + fillOpacity: defaults.fillOpacity │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (symbolizer.graphic === true) { │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, { │ │ │ │ + pointRadius: this.defaultStyle.pointRadius, │ │ │ │ + externalGraphic: this.defaultStyle.externalGraphic, │ │ │ │ + graphicName: this.defaultStyle.graphicName, │ │ │ │ + graphicOpacity: this.defaultStyle.graphicOpacity, │ │ │ │ + graphicWidth: this.defaultStyle.graphicWidth, │ │ │ │ + graphicHeight: this.defaultStyle.graphicHeight, │ │ │ │ + graphicXOffset: this.defaultStyle.graphicXOffset, │ │ │ │ + graphicYOffset: this.defaultStyle.graphicYOffset │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return this.createLiterals(OpenLayers.Util.extend(style, symbolizer), feature) │ │ │ │ }, │ │ │ │ - changeLayer: function(evt) { │ │ │ │ - if (evt.property === "visibility" || evt.property === "params") { │ │ │ │ - this.updateTimeout(evt.object, 0) │ │ │ │ + createLiterals: function(style, feature) { │ │ │ │ + var context = OpenLayers.Util.extend({}, feature.attributes || feature.data); │ │ │ │ + OpenLayers.Util.extend(context, this.context); │ │ │ │ + for (var i in this.propertyStyles) { │ │ │ │ + style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i) │ │ │ │ } │ │ │ │ + return style │ │ │ │ }, │ │ │ │ - addLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ - layer.events.on({ │ │ │ │ - addtile: this.addTile, │ │ │ │ - retile: this.clearTileQueue, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - var i, j, tile; │ │ │ │ - for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ - for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ - tile = layer.grid[i][j]; │ │ │ │ - this.addTile({ │ │ │ │ - tile: tile │ │ │ │ - }); │ │ │ │ - if (tile.url && !tile.imgDiv) { │ │ │ │ - this.manageTileCache({ │ │ │ │ - object: tile │ │ │ │ - }) │ │ │ │ - } │ │ │ │ + findPropertyStyles: function() { │ │ │ │ + var propertyStyles = {}; │ │ │ │ + var style = this.defaultStyle; │ │ │ │ + this.addPropertyStyles(propertyStyles, style); │ │ │ │ + var rules = this.rules; │ │ │ │ + var symbolizer, value; │ │ │ │ + for (var i = 0, len = rules.length; i < len; i++) { │ │ │ │ + symbolizer = rules[i].symbolizer; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + value = symbolizer[key]; │ │ │ │ + if (typeof value == "object") { │ │ │ │ + this.addPropertyStyles(propertyStyles, value) │ │ │ │ + } else { │ │ │ │ + this.addPropertyStyles(propertyStyles, symbolizer); │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ + return propertyStyles │ │ │ │ }, │ │ │ │ - removeLayer: function(evt) { │ │ │ │ - var layer = evt.layer; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ - this.clearTileQueue({ │ │ │ │ - object: layer │ │ │ │ - }); │ │ │ │ - if (layer.events) { │ │ │ │ - layer.events.un({ │ │ │ │ - addtile: this.addTile, │ │ │ │ - retile: this.clearTileQueue, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + addPropertyStyles: function(propertyStyles, symbolizer) { │ │ │ │ + var property; │ │ │ │ + for (var key in symbolizer) { │ │ │ │ + property = symbolizer[key]; │ │ │ │ + if (typeof property == "string" && property.match(/\$\{\w+\}/)) { │ │ │ │ + propertyStyles[key] = true │ │ │ │ } │ │ │ │ - if (layer.grid) { │ │ │ │ - var i, j, tile; │ │ │ │ - for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ - for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ - tile = layer.grid[i][j]; │ │ │ │ - this.unloadTile({ │ │ │ │ - object: tile │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + } │ │ │ │ + return propertyStyles │ │ │ │ + }, │ │ │ │ + addRules: function(rules) { │ │ │ │ + Array.prototype.push.apply(this.rules, rules); │ │ │ │ + this.propertyStyles = this.findPropertyStyles() │ │ │ │ + }, │ │ │ │ + setDefaultStyle: function(style) { │ │ │ │ + this.defaultStyle = style; │ │ │ │ + this.propertyStyles = this.findPropertyStyles() │ │ │ │ + }, │ │ │ │ + getSymbolizerPrefix: function(geometry) { │ │ │ │ + var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES; │ │ │ │ + for (var i = 0, len = prefixes.length; i < len; i++) { │ │ │ │ + if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) { │ │ │ │ + return prefixes[i] │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - updateTimeout: function(map, delay, nice) { │ │ │ │ - window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ - var tileQueue = this.tileQueue[map.id]; │ │ │ │ - if (!nice || tileQueue.length) { │ │ │ │ - this.tileQueueId[map.id] = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ - this.drawTilesFromQueue(map); │ │ │ │ - if (tileQueue.length) { │ │ │ │ - this.updateTimeout(map, this.frameDelay) │ │ │ │ - } │ │ │ │ - }, this), delay) │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.rules) { │ │ │ │ + options.rules = []; │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ + options.rules.push(this.rules[i].clone()) │ │ │ │ + } │ │ │ │ } │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle); │ │ │ │ + return new OpenLayers.Style(defaultStyle, options) │ │ │ │ }, │ │ │ │ - addTile: function(evt) { │ │ │ │ - if (evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ - evt.tile.events.on({ │ │ │ │ - beforedraw: this.queueTileDraw, │ │ │ │ - beforeload: this.manageTileCache, │ │ │ │ - loadend: this.addToCache, │ │ │ │ - unload: this.unloadTile, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: evt.tile.layer │ │ │ │ - }) │ │ │ │ + CLASS_NAME: "OpenLayers.Style" │ │ │ │ +}); │ │ │ │ +OpenLayers.Style.createLiteral = function(value, context, feature, property) { │ │ │ │ + if (typeof value == "string" && value.indexOf("${") != -1) { │ │ │ │ + value = OpenLayers.String.format(value, context, [feature, property]); │ │ │ │ + value = isNaN(value) || !value ? value : parseFloat(value) │ │ │ │ + } │ │ │ │ + return value │ │ │ │ +}; │ │ │ │ +OpenLayers.Style.SYMBOLIZER_PREFIXES = ["Point", "Line", "Polygon", "Text", "Raster"]; │ │ │ │ +OpenLayers.Rule = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + name: null, │ │ │ │ + title: null, │ │ │ │ + description: null, │ │ │ │ + context: null, │ │ │ │ + filter: null, │ │ │ │ + elseFilter: false, │ │ │ │ + symbolizer: null, │ │ │ │ + symbolizers: null, │ │ │ │ + minScaleDenominator: null, │ │ │ │ + maxScaleDenominator: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.symbolizer = {}; │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + delete this.symbolizer │ │ │ │ } │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ }, │ │ │ │ - unloadTile: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - tile.events.un({ │ │ │ │ - beforedraw: this.queueTileDraw, │ │ │ │ - beforeload: this.manageTileCache, │ │ │ │ - loadend: this.addToCache, │ │ │ │ - unload: this.unloadTile, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - OpenLayers.Util.removeItem(this.tileQueue[tile.layer.map.id], tile) │ │ │ │ + destroy: function() { │ │ │ │ + for (var i in this.symbolizer) { │ │ │ │ + this.symbolizer[i] = null │ │ │ │ + } │ │ │ │ + this.symbolizer = null; │ │ │ │ + delete this.symbolizers │ │ │ │ }, │ │ │ │ - queueTileDraw: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - var queued = false; │ │ │ │ - var layer = tile.layer; │ │ │ │ - var url = layer.getURL(tile.bounds); │ │ │ │ - var img = this.tileCache[url]; │ │ │ │ - if (img && img.className !== "olTileImage") { │ │ │ │ - delete this.tileCache[url]; │ │ │ │ - OpenLayers.Util.removeItem(this.tileCacheIndex, url); │ │ │ │ - img = null │ │ │ │ + evaluate: function(feature) { │ │ │ │ + var context = this.getContext(feature); │ │ │ │ + var applies = true; │ │ │ │ + if (this.minScaleDenominator || this.maxScaleDenominator) { │ │ │ │ + var scale = feature.layer.map.getScale() │ │ │ │ } │ │ │ │ - if (layer.url && (layer.async || !img)) { │ │ │ │ - var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ - if (!~OpenLayers.Util.indexOf(tileQueue, tile)) { │ │ │ │ - tileQueue.push(tile) │ │ │ │ + if (this.minScaleDenominator) { │ │ │ │ + applies = scale >= OpenLayers.Style.createLiteral(this.minScaleDenominator, context) │ │ │ │ + } │ │ │ │ + if (applies && this.maxScaleDenominator) { │ │ │ │ + applies = scale < OpenLayers.Style.createLiteral(this.maxScaleDenominator, context) │ │ │ │ + } │ │ │ │ + if (applies && this.filter) { │ │ │ │ + if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") { │ │ │ │ + applies = this.filter.evaluate(feature) │ │ │ │ + } else { │ │ │ │ + applies = this.filter.evaluate(context) │ │ │ │ } │ │ │ │ - queued = true │ │ │ │ } │ │ │ │ - return !queued │ │ │ │ + return applies │ │ │ │ }, │ │ │ │ - drawTilesFromQueue: function(map) { │ │ │ │ - var tileQueue = this.tileQueue[map.id]; │ │ │ │ - var limit = this.tilesPerFrame; │ │ │ │ - var animating = map.zoomTween && map.zoomTween.playing; │ │ │ │ - while (!animating && tileQueue.length && limit) { │ │ │ │ - tileQueue.shift().draw(true); │ │ │ │ - --limit │ │ │ │ + getContext: function(feature) { │ │ │ │ + var context = this.context; │ │ │ │ + if (!context) { │ │ │ │ + context = feature.attributes || feature.data │ │ │ │ + } │ │ │ │ + if (typeof this.context == "function") { │ │ │ │ + context = this.context(feature) │ │ │ │ } │ │ │ │ + return context │ │ │ │ }, │ │ │ │ - manageTileCache: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - var img = this.tileCache[tile.url]; │ │ │ │ - if (img) { │ │ │ │ - if (img.parentNode && OpenLayers.Element.hasClass(img.parentNode, "olBackBuffer")) { │ │ │ │ - img.parentNode.removeChild(img); │ │ │ │ - img.id = null │ │ │ │ + clone: function() { │ │ │ │ + var options = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.symbolizers) { │ │ │ │ + var len = this.symbolizers.length; │ │ │ │ + options.symbolizers = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + options.symbolizers[i] = this.symbolizers[i].clone() │ │ │ │ } │ │ │ │ - if (!img.parentNode) { │ │ │ │ - img.style.visibility = "hidden"; │ │ │ │ - img.style.opacity = 0; │ │ │ │ - tile.setImage(img); │ │ │ │ - OpenLayers.Util.removeItem(this.tileCacheIndex, tile.url); │ │ │ │ - this.tileCacheIndex.push(tile.url) │ │ │ │ + } else { │ │ │ │ + options.symbolizer = {}; │ │ │ │ + var value, type; │ │ │ │ + for (var key in this.symbolizer) { │ │ │ │ + value = this.symbolizer[key]; │ │ │ │ + type = typeof value; │ │ │ │ + if (type === "object") { │ │ │ │ + options.symbolizer[key] = OpenLayers.Util.extend({}, value) │ │ │ │ + } else if (type === "string") { │ │ │ │ + options.symbolizer[key] = value │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + options.filter = this.filter && this.filter.clone(); │ │ │ │ + options.context = this.context && OpenLayers.Util.extend({}, this.context); │ │ │ │ + return new OpenLayers.Rule(options) │ │ │ │ }, │ │ │ │ - addToCache: function(evt) { │ │ │ │ - var tile = evt.object; │ │ │ │ - if (!this.tileCache[tile.url]) { │ │ │ │ - if (!OpenLayers.Element.hasClass(tile.imgDiv, "olImageLoadError")) { │ │ │ │ - if (this.tileCacheIndex.length >= this.cacheSize) { │ │ │ │ - delete this.tileCache[this.tileCacheIndex[0]]; │ │ │ │ - this.tileCacheIndex.shift() │ │ │ │ - } │ │ │ │ - this.tileCache[tile.url] = tile.imgDiv; │ │ │ │ - this.tileCacheIndex.push(tile.url) │ │ │ │ + CLASS_NAME: "OpenLayers.Rule" │ │ │ │ +}); │ │ │ │ +OpenLayers.Symbolizer = OpenLayers.Class({ │ │ │ │ + zIndex: 0, │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Util.extend(this, config) │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var Type = eval(this.CLASS_NAME); │ │ │ │ + return new Type(OpenLayers.Util.extend({}, this)) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer" │ │ │ │ +}); │ │ │ │ +OpenLayers.Symbolizer.Point = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Point" │ │ │ │ +}); │ │ │ │ +OpenLayers.Symbolizer.Line = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Line" │ │ │ │ +}); │ │ │ │ +OpenLayers.Symbolizer.Polygon = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Polygon" │ │ │ │ +}); │ │ │ │ +OpenLayers.Symbolizer.Text = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Text" │ │ │ │ +}); │ │ │ │ +OpenLayers.Symbolizer.Raster = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Symbolizer.Raster" │ │ │ │ +}); │ │ │ │ +OpenLayers.Style2 = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + name: null, │ │ │ │ + title: null, │ │ │ │ + description: null, │ │ │ │ + layerName: null, │ │ │ │ + isDefault: false, │ │ │ │ + rules: null, │ │ │ │ + initialize: function(config) { │ │ │ │ + OpenLayers.Util.extend(this, config); │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ + this.rules[i].destroy() │ │ │ │ + } │ │ │ │ + delete this.rules │ │ │ │ + }, │ │ │ │ + clone: function() { │ │ │ │ + var config = OpenLayers.Util.extend({}, this); │ │ │ │ + if (this.rules) { │ │ │ │ + config.rules = []; │ │ │ │ + for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ + config.rules.push(this.rules[i].clone()) │ │ │ │ } │ │ │ │ } │ │ │ │ + return new OpenLayers.Style2(config) │ │ │ │ }, │ │ │ │ - clearTileQueue: function(evt) { │ │ │ │ - var layer = evt.object; │ │ │ │ - var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ - for (var i = tileQueue.length - 1; i >= 0; --i) { │ │ │ │ - if (tileQueue[i].layer === layer) { │ │ │ │ - tileQueue.splice(i, 1) │ │ │ │ + CLASS_NAME: "OpenLayers.Style2" │ │ │ │ +}); │ │ │ │ +OpenLayers.StyleMap = OpenLayers.Class({ │ │ │ │ + styles: null, │ │ │ │ + extendDefault: true, │ │ │ │ + initialize: function(style, options) { │ │ │ │ + this.styles = { │ │ │ │ + default: new OpenLayers.Style(OpenLayers.Feature.Vector.style["default"]), │ │ │ │ + select: new OpenLayers.Style(OpenLayers.Feature.Vector.style["select"]), │ │ │ │ + temporary: new OpenLayers.Style(OpenLayers.Feature.Vector.style["temporary"]), │ │ │ │ + delete: new OpenLayers.Style(OpenLayers.Feature.Vector.style["delete"]) │ │ │ │ + }; │ │ │ │ + if (style instanceof OpenLayers.Style) { │ │ │ │ + this.styles["default"] = style; │ │ │ │ + this.styles["select"] = style; │ │ │ │ + this.styles["temporary"] = style; │ │ │ │ + this.styles["delete"] = style │ │ │ │ + } else if (typeof style == "object") { │ │ │ │ + for (var key in style) { │ │ │ │ + if (style[key] instanceof OpenLayers.Style) { │ │ │ │ + this.styles[key] = style[key] │ │ │ │ + } else if (typeof style[key] == "object") { │ │ │ │ + this.styles[key] = new OpenLayers.Style(style[key]) │ │ │ │ + } else { │ │ │ │ + this.styles["default"] = new OpenLayers.Style(style); │ │ │ │ + this.styles["select"] = new OpenLayers.Style(style); │ │ │ │ + this.styles["temporary"] = new OpenLayers.Style(style); │ │ │ │ + this.styles["delete"] = new OpenLayers.Style(style); │ │ │ │ + break │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + OpenLayers.Util.extend(this, options) │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - for (var i = this.maps.length - 1; i >= 0; --i) { │ │ │ │ - this.removeMap(this.maps[i]) │ │ │ │ + for (var key in this.styles) { │ │ │ │ + this.styles[key].destroy() │ │ │ │ } │ │ │ │ - this.maps = null; │ │ │ │ - this.tileQueue = null; │ │ │ │ - this.tileQueueId = null; │ │ │ │ - this.tileCache = null; │ │ │ │ - this.tileCacheIndex = null; │ │ │ │ - this._destroyed = true │ │ │ │ - } │ │ │ │ + this.styles = null │ │ │ │ + }, │ │ │ │ + createSymbolizer: function(feature, intent) { │ │ │ │ + if (!feature) { │ │ │ │ + feature = new OpenLayers.Feature.Vector │ │ │ │ + } │ │ │ │ + if (!this.styles[intent]) { │ │ │ │ + intent = "default" │ │ │ │ + } │ │ │ │ + feature.renderIntent = intent; │ │ │ │ + var defaultSymbolizer = {}; │ │ │ │ + if (this.extendDefault && intent != "default") { │ │ │ │ + defaultSymbolizer = this.styles["default"].createSymbolizer(feature) │ │ │ │ + } │ │ │ │ + return OpenLayers.Util.extend(defaultSymbolizer, this.styles[intent].createSymbolizer(feature)) │ │ │ │ + }, │ │ │ │ + addUniqueValueRules: function(renderIntent, property, symbolizers, context) { │ │ │ │ + var rules = []; │ │ │ │ + for (var value in symbolizers) { │ │ │ │ + rules.push(new OpenLayers.Rule({ │ │ │ │ + symbolizer: symbolizers[value], │ │ │ │ + context: context, │ │ │ │ + filter: new OpenLayers.Filter.Comparison({ │ │ │ │ + type: OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }) │ │ │ │ + })) │ │ │ │ + } │ │ │ │ + this.styles[renderIntent].addRules(rules) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.StyleMap" │ │ │ │ }); │ │ │ │ -OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ - layer: null, │ │ │ │ +OpenLayers.Spherical = OpenLayers.Spherical || {}; │ │ │ │ +OpenLayers.Spherical.DEFAULT_RADIUS = 6378137; │ │ │ │ +OpenLayers.Spherical.computeDistanceBetween = function(from, to, radius) { │ │ │ │ + var R = radius || OpenLayers.Spherical.DEFAULT_RADIUS; │ │ │ │ + var sinHalfDeltaLon = Math.sin(Math.PI * (to.lon - from.lon) / 360); │ │ │ │ + var sinHalfDeltaLat = Math.sin(Math.PI * (to.lat - from.lat) / 360); │ │ │ │ + var a = sinHalfDeltaLat * sinHalfDeltaLat + sinHalfDeltaLon * sinHalfDeltaLon * Math.cos(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ + return 2 * R * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)) │ │ │ │ +}; │ │ │ │ +OpenLayers.Spherical.computeHeading = function(from, to) { │ │ │ │ + var y = Math.sin(Math.PI * (from.lon - to.lon) / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ + var x = Math.cos(Math.PI * from.lat / 180) * Math.sin(Math.PI * to.lat / 180) - Math.sin(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180) * Math.cos(Math.PI * (from.lon - to.lon) / 180); │ │ │ │ + return 180 * Math.atan2(y, x) / Math.PI │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol = OpenLayers.Class({ │ │ │ │ + format: null, │ │ │ │ options: null, │ │ │ │ - active: null, │ │ │ │ - autoActivate: true, │ │ │ │ autoDestroy: true, │ │ │ │ + defaultFilter: null, │ │ │ │ initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options; │ │ │ │ - this.active = false │ │ │ │ + this.options = options │ │ │ │ + }, │ │ │ │ + mergeWithDefaultFilter: function(filter) { │ │ │ │ + var merged; │ │ │ │ + if (filter && this.defaultFilter) { │ │ │ │ + merged = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.defaultFilter, filter] │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + merged = filter || this.defaultFilter || undefined │ │ │ │ + } │ │ │ │ + return merged │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layer = null; │ │ │ │ - this.options = null │ │ │ │ + this.options = null; │ │ │ │ + this.format = null │ │ │ │ }, │ │ │ │ - setLayer: function(layer) { │ │ │ │ - this.layer = layer │ │ │ │ + read: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.filter = this.mergeWithDefaultFilter(options.filter) │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - this.active = true; │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ + create: function() {}, │ │ │ │ + update: function() {}, │ │ │ │ + delete: function() {}, │ │ │ │ + commit: function() {}, │ │ │ │ + abort: function(response) {}, │ │ │ │ + createCallback: function(method, response, options) { │ │ │ │ + return OpenLayers.Function.bind(function() { │ │ │ │ + method.apply(this, [response, options]) │ │ │ │ + }, this) │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.active = false; │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol" │ │ │ │ +}); │ │ │ │ +OpenLayers.Protocol.Response = OpenLayers.Class({ │ │ │ │ + code: null, │ │ │ │ + requestType: null, │ │ │ │ + last: true, │ │ │ │ + features: null, │ │ │ │ + data: null, │ │ │ │ + reqFeatures: null, │ │ │ │ + priv: null, │ │ │ │ + error: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ + success: function() { │ │ │ │ + return this.code > 0 │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.Response" │ │ │ │ }); │ │ │ │ +OpenLayers.Protocol.Response.SUCCESS = 1; │ │ │ │ +OpenLayers.Protocol.Response.FAILURE = 0; │ │ │ │ OpenLayers.Handler = OpenLayers.Class({ │ │ │ │ id: null, │ │ │ │ control: null, │ │ │ │ map: null, │ │ │ │ keyMask: null, │ │ │ │ active: false, │ │ │ │ evt: null, │ │ │ │ @@ -6692,212 +6695,14 @@ │ │ │ │ return { │ │ │ │ distance: Math.pow(x - x0, 2) + Math.pow(y - y0, 2), │ │ │ │ x: x, │ │ │ │ y: y, │ │ │ │ along: along │ │ │ │ } │ │ │ │ }; │ │ │ │ -OpenLayers.Icon = OpenLayers.Class({ │ │ │ │ - url: null, │ │ │ │ - size: null, │ │ │ │ - offset: null, │ │ │ │ - calculateOffset: null, │ │ │ │ - imageDiv: null, │ │ │ │ - px: null, │ │ │ │ - initialize: function(url, size, offset, calculateOffset) { │ │ │ │ - this.url = url; │ │ │ │ - this.size = size || { │ │ │ │ - w: 20, │ │ │ │ - h: 20 │ │ │ │ - }; │ │ │ │ - this.offset = offset || { │ │ │ │ - x: -(this.size.w / 2), │ │ │ │ - y: -(this.size.h / 2) │ │ │ │ - }; │ │ │ │ - this.calculateOffset = calculateOffset; │ │ │ │ - var id = OpenLayers.Util.createUniqueID("OL_Icon_"); │ │ │ │ - this.imageDiv = OpenLayers.Util.createAlphaImageDiv(id) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.erase(); │ │ │ │ - OpenLayers.Event.stopObservingElement(this.imageDiv.firstChild); │ │ │ │ - this.imageDiv.innerHTML = ""; │ │ │ │ - this.imageDiv = null │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - return new OpenLayers.Icon(this.url, this.size, this.offset, this.calculateOffset) │ │ │ │ - }, │ │ │ │ - setSize: function(size) { │ │ │ │ - if (size != null) { │ │ │ │ - this.size = size │ │ │ │ - } │ │ │ │ - this.draw() │ │ │ │ - }, │ │ │ │ - setUrl: function(url) { │ │ │ │ - if (url != null) { │ │ │ │ - this.url = url │ │ │ │ - } │ │ │ │ - this.draw() │ │ │ │ - }, │ │ │ │ - draw: function(px) { │ │ │ │ - OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, this.size, this.url, "absolute"); │ │ │ │ - this.moveTo(px); │ │ │ │ - return this.imageDiv │ │ │ │ - }, │ │ │ │ - erase: function() { │ │ │ │ - if (this.imageDiv != null && this.imageDiv.parentNode != null) { │ │ │ │ - OpenLayers.Element.remove(this.imageDiv) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, null, null, null, null, null, opacity) │ │ │ │ - }, │ │ │ │ - moveTo: function(px) { │ │ │ │ - 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) │ │ │ │ - } │ │ │ │ - OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, { │ │ │ │ - x: this.px.x + this.offset.x, │ │ │ │ - y: this.px.y + this.offset.y │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - display: function(display) { │ │ │ │ - this.imageDiv.style.display = display ? "" : "none" │ │ │ │ - }, │ │ │ │ - isDrawn: function() { │ │ │ │ - var isDrawn = this.imageDiv && this.imageDiv.parentNode && this.imageDiv.parentNode.nodeType != 11; │ │ │ │ - return isDrawn │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Icon" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - map: null, │ │ │ │ - div: null, │ │ │ │ - type: null, │ │ │ │ - allowSelection: false, │ │ │ │ - displayClass: "", │ │ │ │ - title: "", │ │ │ │ - autoActivate: false, │ │ │ │ - active: null, │ │ │ │ - handlerOptions: null, │ │ │ │ - handler: null, │ │ │ │ - eventListeners: null, │ │ │ │ - events: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.displayClass = this.CLASS_NAME.replace("OpenLayers.", "ol").replace(/\./g, ""); │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.events = new OpenLayers.Events(this); │ │ │ │ - if (this.eventListeners instanceof Object) { │ │ │ │ - this.events.on(this.eventListeners) │ │ │ │ - } │ │ │ │ - if (this.id == null) { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.events) { │ │ │ │ - if (this.eventListeners) { │ │ │ │ - this.events.un(this.eventListeners) │ │ │ │ - } │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null │ │ │ │ - } │ │ │ │ - this.eventListeners = null; │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.destroy(); │ │ │ │ - this.handler = null │ │ │ │ - } │ │ │ │ - if (this.handlers) { │ │ │ │ - for (var key in this.handlers) { │ │ │ │ - if (this.handlers.hasOwnProperty(key) && typeof this.handlers[key].destroy == "function") { │ │ │ │ - this.handlers[key].destroy() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.handlers = null │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.removeControl(this); │ │ │ │ - this.map = null │ │ │ │ - } │ │ │ │ - this.div = null │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.setMap(map) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - draw: function(px) { │ │ │ │ - if (this.div == null) { │ │ │ │ - this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ - this.div.className = this.displayClass; │ │ │ │ - if (!this.allowSelection) { │ │ │ │ - this.div.className += " olControlNoSelect"; │ │ │ │ - this.div.setAttribute("unselectable", "on", 0); │ │ │ │ - this.div.onselectstart = OpenLayers.Function.False │ │ │ │ - } │ │ │ │ - if (this.title != "") { │ │ │ │ - this.div.title = this.title │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (px != null) { │ │ │ │ - this.position = px.clone() │ │ │ │ - } │ │ │ │ - this.moveTo(this.position); │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - moveTo: function(px) { │ │ │ │ - if (px != null && this.div != null) { │ │ │ │ - this.div.style.left = px.x + "px"; │ │ │ │ - this.div.style.top = px.y + "px" │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.activate() │ │ │ │ - } │ │ │ │ - this.active = true; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("activate"); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate() │ │ │ │ - } │ │ │ │ - this.active = false; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("deactivate"); │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ -OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ -OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ OpenLayers.Format = OpenLayers.Class({ │ │ │ │ options: null, │ │ │ │ externalProjection: null, │ │ │ │ internalProjection: null, │ │ │ │ data: null, │ │ │ │ keepData: false, │ │ │ │ initialize: function(options) { │ │ │ │ @@ -12548,391 +12353,14 @@ │ │ │ │ this.readChildNodes(node, output.boundingBoxData) │ │ │ │ } │ │ │ │ }, │ │ │ │ ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Format.WPSExecute" │ │ │ │ }); │ │ │ │ -(function() { │ │ │ │ - var oXMLHttpRequest = window.XMLHttpRequest; │ │ │ │ - var bGecko = !!window.controllers, │ │ │ │ - bIE = window.document.all && !window.opera, │ │ │ │ - bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/); │ │ │ │ - │ │ │ │ - function fXMLHttpRequest() { │ │ │ │ - this._object = oXMLHttpRequest && !bIE7 ? new oXMLHttpRequest : new window.ActiveXObject("Microsoft.XMLHTTP"); │ │ │ │ - this._listeners = [] │ │ │ │ - } │ │ │ │ - │ │ │ │ - function cXMLHttpRequest() { │ │ │ │ - return new fXMLHttpRequest │ │ │ │ - } │ │ │ │ - cXMLHttpRequest.prototype = fXMLHttpRequest.prototype; │ │ │ │ - if (bGecko && oXMLHttpRequest.wrapped) cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped; │ │ │ │ - cXMLHttpRequest.UNSENT = 0; │ │ │ │ - cXMLHttpRequest.OPENED = 1; │ │ │ │ - cXMLHttpRequest.HEADERS_RECEIVED = 2; │ │ │ │ - cXMLHttpRequest.LOADING = 3; │ │ │ │ - cXMLHttpRequest.DONE = 4; │ │ │ │ - cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - cXMLHttpRequest.prototype.responseText = ""; │ │ │ │ - cXMLHttpRequest.prototype.responseXML = null; │ │ │ │ - cXMLHttpRequest.prototype.status = 0; │ │ │ │ - cXMLHttpRequest.prototype.statusText = ""; │ │ │ │ - cXMLHttpRequest.prototype.priority = "NORMAL"; │ │ │ │ - cXMLHttpRequest.prototype.onreadystatechange = null; │ │ │ │ - cXMLHttpRequest.onreadystatechange = null; │ │ │ │ - cXMLHttpRequest.onopen = null; │ │ │ │ - cXMLHttpRequest.onsend = null; │ │ │ │ - cXMLHttpRequest.onabort = null; │ │ │ │ - cXMLHttpRequest.prototype.open = function(sMethod, sUrl, bAsync, sUser, sPassword) { │ │ │ │ - delete this._headers; │ │ │ │ - if (arguments.length < 3) bAsync = true; │ │ │ │ - this._async = bAsync; │ │ │ │ - var oRequest = this, │ │ │ │ - nState = this.readyState, │ │ │ │ - fOnUnload; │ │ │ │ - if (bIE && bAsync) { │ │ │ │ - fOnUnload = function() { │ │ │ │ - if (nState != cXMLHttpRequest.DONE) { │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - oRequest.abort() │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - window.attachEvent("onunload", fOnUnload) │ │ │ │ - } │ │ │ │ - if (cXMLHttpRequest.onopen) cXMLHttpRequest.onopen.apply(this, arguments); │ │ │ │ - if (arguments.length > 4) this._object.open(sMethod, sUrl, bAsync, sUser, sPassword); │ │ │ │ - else if (arguments.length > 3) this._object.open(sMethod, sUrl, bAsync, sUser); │ │ │ │ - else this._object.open(sMethod, sUrl, bAsync); │ │ │ │ - this.readyState = cXMLHttpRequest.OPENED; │ │ │ │ - fReadyStateChange(this); │ │ │ │ - this._object.onreadystatechange = function() { │ │ │ │ - if (bGecko && !bAsync) return; │ │ │ │ - oRequest.readyState = oRequest._object.readyState; │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ - if (oRequest._aborted) { │ │ │ │ - oRequest.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (oRequest.readyState == cXMLHttpRequest.DONE) { │ │ │ │ - delete oRequest._data; │ │ │ │ - fCleanTransport(oRequest); │ │ │ │ - if (bIE && bAsync) window.detachEvent("onunload", fOnUnload) │ │ │ │ - } │ │ │ │ - if (nState != oRequest.readyState) fReadyStateChange(oRequest); │ │ │ │ - nState = oRequest.readyState │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fXMLHttpRequest_send(oRequest) { │ │ │ │ - oRequest._object.send(oRequest._data); │ │ │ │ - if (bGecko && !oRequest._async) { │ │ │ │ - oRequest.readyState = cXMLHttpRequest.OPENED; │ │ │ │ - fSynchronizeValues(oRequest); │ │ │ │ - while (oRequest.readyState < cXMLHttpRequest.DONE) { │ │ │ │ - oRequest.readyState++; │ │ │ │ - fReadyStateChange(oRequest); │ │ │ │ - if (oRequest._aborted) return │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - cXMLHttpRequest.prototype.send = function(vData) { │ │ │ │ - if (cXMLHttpRequest.onsend) cXMLHttpRequest.onsend.apply(this, arguments); │ │ │ │ - if (!arguments.length) vData = null; │ │ │ │ - if (vData && vData.nodeType) { │ │ │ │ - vData = window.XMLSerializer ? (new window.XMLSerializer).serializeToString(vData) : vData.xml; │ │ │ │ - if (!this._headers["Content-Type"]) this._object.setRequestHeader("Content-Type", "application/xml") │ │ │ │ - } │ │ │ │ - this._data = vData; │ │ │ │ - fXMLHttpRequest_send(this) │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.abort = function() { │ │ │ │ - if (cXMLHttpRequest.onabort) cXMLHttpRequest.onabort.apply(this, arguments); │ │ │ │ - if (this.readyState > cXMLHttpRequest.UNSENT) this._aborted = true; │ │ │ │ - this._object.abort(); │ │ │ │ - fCleanTransport(this); │ │ │ │ - this.readyState = cXMLHttpRequest.UNSENT; │ │ │ │ - delete this._data │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.getAllResponseHeaders = function() { │ │ │ │ - return this._object.getAllResponseHeaders() │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.getResponseHeader = function(sName) { │ │ │ │ - return this._object.getResponseHeader(sName) │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) { │ │ │ │ - if (!this._headers) this._headers = {}; │ │ │ │ - this._headers[sName] = sValue; │ │ │ │ - return this._object.setRequestHeader(sName, sValue) │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.addEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) return; │ │ │ │ - this._listeners.push([sName, fHandler, bUseCapture]) │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.removeEventListener = function(sName, fHandler, bUseCapture) { │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == sName && oListener[1] == fHandler && oListener[2] == bUseCapture) break; │ │ │ │ - if (oListener) this._listeners.splice(nIndex, 1) │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) { │ │ │ │ - var oEventPseudo = { │ │ │ │ - type: oEvent.type, │ │ │ │ - target: this, │ │ │ │ - currentTarget: this, │ │ │ │ - eventPhase: 2, │ │ │ │ - bubbles: oEvent.bubbles, │ │ │ │ - cancelable: oEvent.cancelable, │ │ │ │ - timeStamp: oEvent.timeStamp, │ │ │ │ - stopPropagation: function() {}, │ │ │ │ - preventDefault: function() {}, │ │ │ │ - initEvent: function() {} │ │ │ │ - }; │ │ │ │ - if (oEventPseudo.type == "readystatechange" && this.onreadystatechange)(this.onreadystatechange.handleEvent || this.onreadystatechange).apply(this, [oEventPseudo]); │ │ │ │ - for (var nIndex = 0, oListener; oListener = this._listeners[nIndex]; nIndex++) │ │ │ │ - if (oListener[0] == oEventPseudo.type && !oListener[2])(oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]) │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.prototype.toString = function() { │ │ │ │ - return "[" + "object" + " " + "XMLHttpRequest" + "]" │ │ │ │ - }; │ │ │ │ - cXMLHttpRequest.toString = function() { │ │ │ │ - return "[" + "XMLHttpRequest" + "]" │ │ │ │ - }; │ │ │ │ - │ │ │ │ - function fReadyStateChange(oRequest) { │ │ │ │ - if (cXMLHttpRequest.onreadystatechange) cXMLHttpRequest.onreadystatechange.apply(oRequest); │ │ │ │ - oRequest.dispatchEvent({ │ │ │ │ - type: "readystatechange", │ │ │ │ - bubbles: false, │ │ │ │ - cancelable: false, │ │ │ │ - timeStamp: new Date + 0 │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - │ │ │ │ - function fGetDocument(oRequest) { │ │ │ │ - var oDocument = oRequest.responseXML, │ │ │ │ - sResponse = oRequest.responseText; │ │ │ │ - if (bIE && sResponse && oDocument && !oDocument.documentElement && oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)) { │ │ │ │ - oDocument = new window.ActiveXObject("Microsoft.XMLDOM"); │ │ │ │ - oDocument.async = false; │ │ │ │ - oDocument.validateOnParse = false; │ │ │ │ - oDocument.loadXML(sResponse) │ │ │ │ - } │ │ │ │ - if (oDocument) │ │ │ │ - if (bIE && oDocument.parseError != 0 || !oDocument.documentElement || oDocument.documentElement && oDocument.documentElement.tagName == "parsererror") return null; │ │ │ │ - return oDocument │ │ │ │ - } │ │ │ │ - │ │ │ │ - function fSynchronizeValues(oRequest) { │ │ │ │ - try { │ │ │ │ - oRequest.responseText = oRequest._object.responseText │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.responseXML = fGetDocument(oRequest._object) │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.status = oRequest._object.status │ │ │ │ - } catch (e) {} │ │ │ │ - try { │ │ │ │ - oRequest.statusText = oRequest._object.statusText │ │ │ │ - } catch (e) {} │ │ │ │ - } │ │ │ │ - │ │ │ │ - function fCleanTransport(oRequest) { │ │ │ │ - oRequest._object.onreadystatechange = new window.Function │ │ │ │ - } │ │ │ │ - if (!window.Function.prototype.apply) { │ │ │ │ - window.Function.prototype.apply = function(oRequest, oArguments) { │ │ │ │ - if (!oArguments) oArguments = []; │ │ │ │ - oRequest.__func = this; │ │ │ │ - oRequest.__func(oArguments[0], oArguments[1], oArguments[2], oArguments[3], oArguments[4]); │ │ │ │ - delete oRequest.__func │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!OpenLayers.Request) { │ │ │ │ - OpenLayers.Request = {} │ │ │ │ - } │ │ │ │ - OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest │ │ │ │ -})(); │ │ │ │ -OpenLayers.ProxyHost = ""; │ │ │ │ -if (!OpenLayers.Request) { │ │ │ │ - OpenLayers.Request = {} │ │ │ │ -} │ │ │ │ -OpenLayers.Util.extend(OpenLayers.Request, { │ │ │ │ - DEFAULT_CONFIG: { │ │ │ │ - method: "GET", │ │ │ │ - url: window.location.href, │ │ │ │ - async: true, │ │ │ │ - user: undefined, │ │ │ │ - password: undefined, │ │ │ │ - params: null, │ │ │ │ - proxy: OpenLayers.ProxyHost, │ │ │ │ - headers: {}, │ │ │ │ - data: null, │ │ │ │ - callback: function() {}, │ │ │ │ - success: null, │ │ │ │ - failure: null, │ │ │ │ - scope: null │ │ │ │ - }, │ │ │ │ - URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/, │ │ │ │ - events: new OpenLayers.Events(this), │ │ │ │ - makeSameOrigin: function(url, proxy) { │ │ │ │ - var sameOrigin = url.indexOf("http") !== 0; │ │ │ │ - var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX); │ │ │ │ - if (urlParts) { │ │ │ │ - var location = window.location; │ │ │ │ - sameOrigin = urlParts[1] == location.protocol && urlParts[3] == location.hostname; │ │ │ │ - var uPort = urlParts[4], │ │ │ │ - lPort = location.port; │ │ │ │ - if (uPort != 80 && uPort != "" || lPort != "80" && lPort != "") { │ │ │ │ - sameOrigin = sameOrigin && uPort == lPort │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!sameOrigin) { │ │ │ │ - if (proxy) { │ │ │ │ - if (typeof proxy == "function") { │ │ │ │ - url = proxy(url) │ │ │ │ - } else { │ │ │ │ - url = proxy + encodeURIComponent(url) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return url │ │ │ │ - }, │ │ │ │ - issue: function(config) { │ │ │ │ - var defaultConfig = OpenLayers.Util.extend(this.DEFAULT_CONFIG, { │ │ │ │ - proxy: OpenLayers.ProxyHost │ │ │ │ - }); │ │ │ │ - config = config || {}; │ │ │ │ - config.headers = config.headers || {}; │ │ │ │ - config = OpenLayers.Util.applyDefaults(config, defaultConfig); │ │ │ │ - config.headers = OpenLayers.Util.applyDefaults(config.headers, defaultConfig.headers); │ │ │ │ - var customRequestedWithHeader = false, │ │ │ │ - headerKey; │ │ │ │ - for (headerKey in config.headers) { │ │ │ │ - if (config.headers.hasOwnProperty(headerKey)) { │ │ │ │ - if (headerKey.toLowerCase() === "x-requested-with") { │ │ │ │ - customRequestedWithHeader = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (customRequestedWithHeader === false) { │ │ │ │ - config.headers["X-Requested-With"] = "XMLHttpRequest" │ │ │ │ - } │ │ │ │ - var request = new OpenLayers.Request.XMLHttpRequest; │ │ │ │ - var url = OpenLayers.Util.urlAppend(config.url, OpenLayers.Util.getParameterString(config.params || {})); │ │ │ │ - url = OpenLayers.Request.makeSameOrigin(url, config.proxy); │ │ │ │ - request.open(config.method, url, config.async, config.user, config.password); │ │ │ │ - for (var header in config.headers) { │ │ │ │ - request.setRequestHeader(header, config.headers[header]) │ │ │ │ - } │ │ │ │ - var events = this.events; │ │ │ │ - var self = this; │ │ │ │ - request.onreadystatechange = function() { │ │ │ │ - if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) { │ │ │ │ - var proceed = events.triggerEvent("complete", { │ │ │ │ - request: request, │ │ │ │ - config: config, │ │ │ │ - requestUrl: url │ │ │ │ - }); │ │ │ │ - if (proceed !== false) { │ │ │ │ - self.runCallbacks({ │ │ │ │ - request: request, │ │ │ │ - config: config, │ │ │ │ - requestUrl: url │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - if (config.async === false) { │ │ │ │ - request.send(config.data) │ │ │ │ - } else { │ │ │ │ - window.setTimeout(function() { │ │ │ │ - if (request.readyState !== 0) { │ │ │ │ - request.send(config.data) │ │ │ │ - } │ │ │ │ - }, 0) │ │ │ │ - } │ │ │ │ - return request │ │ │ │ - }, │ │ │ │ - runCallbacks: function(options) { │ │ │ │ - var request = options.request; │ │ │ │ - var config = options.config; │ │ │ │ - var complete = config.scope ? OpenLayers.Function.bind(config.callback, config.scope) : config.callback; │ │ │ │ - var success; │ │ │ │ - if (config.success) { │ │ │ │ - success = config.scope ? OpenLayers.Function.bind(config.success, config.scope) : config.success │ │ │ │ - } │ │ │ │ - var failure; │ │ │ │ - if (config.failure) { │ │ │ │ - failure = config.scope ? OpenLayers.Function.bind(config.failure, config.scope) : config.failure │ │ │ │ - } │ │ │ │ - if (OpenLayers.Util.createUrlObject(config.url).protocol == "file:" && request.responseText) { │ │ │ │ - request.status = 200 │ │ │ │ - } │ │ │ │ - complete(request); │ │ │ │ - if (!request.status || request.status >= 200 && request.status < 300) { │ │ │ │ - this.events.triggerEvent("success", options); │ │ │ │ - if (success) { │ │ │ │ - success(request) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ - this.events.triggerEvent("failure", options); │ │ │ │ - if (failure) { │ │ │ │ - failure(request) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - GET: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "GET" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config) │ │ │ │ - }, │ │ │ │ - POST: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "POST" │ │ │ │ - }); │ │ │ │ - config.headers = config.headers ? config.headers : {}; │ │ │ │ - if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ - config.headers["Content-Type"] = "application/xml" │ │ │ │ - } │ │ │ │ - return OpenLayers.Request.issue(config) │ │ │ │ - }, │ │ │ │ - PUT: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "PUT" │ │ │ │ - }); │ │ │ │ - config.headers = config.headers ? config.headers : {}; │ │ │ │ - if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) { │ │ │ │ - config.headers["Content-Type"] = "application/xml" │ │ │ │ - } │ │ │ │ - return OpenLayers.Request.issue(config) │ │ │ │ - }, │ │ │ │ - DELETE: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "DELETE" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config) │ │ │ │ - }, │ │ │ │ - HEAD: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "HEAD" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config) │ │ │ │ - }, │ │ │ │ - OPTIONS: function(config) { │ │ │ │ - config = OpenLayers.Util.extend(config, { │ │ │ │ - method: "OPTIONS" │ │ │ │ - }); │ │ │ │ - return OpenLayers.Request.issue(config) │ │ │ │ - } │ │ │ │ -}); │ │ │ │ OpenLayers.WPSProcess = OpenLayers.Class({ │ │ │ │ client: null, │ │ │ │ server: null, │ │ │ │ identifier: null, │ │ │ │ description: null, │ │ │ │ localWPS: "http://geoserver/wps", │ │ │ │ formats: null, │ │ │ │ @@ -13127,141 +12555,299 @@ │ │ │ │ process: null, │ │ │ │ output: null, │ │ │ │ initialize: function(options) { │ │ │ │ OpenLayers.Util.extend(this, options) │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.WPSProcess.ChainLink" │ │ │ │ }); │ │ │ │ -OpenLayers.Spherical = OpenLayers.Spherical || {}; │ │ │ │ -OpenLayers.Spherical.DEFAULT_RADIUS = 6378137; │ │ │ │ -OpenLayers.Spherical.computeDistanceBetween = function(from, to, radius) { │ │ │ │ - var R = radius || OpenLayers.Spherical.DEFAULT_RADIUS; │ │ │ │ - var sinHalfDeltaLon = Math.sin(Math.PI * (to.lon - from.lon) / 360); │ │ │ │ - var sinHalfDeltaLat = Math.sin(Math.PI * (to.lat - from.lat) / 360); │ │ │ │ - var a = sinHalfDeltaLat * sinHalfDeltaLat + sinHalfDeltaLon * sinHalfDeltaLon * Math.cos(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ - return 2 * R * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)) │ │ │ │ -}; │ │ │ │ -OpenLayers.Spherical.computeHeading = function(from, to) { │ │ │ │ - var y = Math.sin(Math.PI * (from.lon - to.lon) / 180) * Math.cos(Math.PI * to.lat / 180); │ │ │ │ - var x = Math.cos(Math.PI * from.lat / 180) * Math.sin(Math.PI * to.lat / 180) - Math.sin(Math.PI * from.lat / 180) * Math.cos(Math.PI * to.lat / 180) * Math.cos(Math.PI * (from.lon - to.lon) / 180); │ │ │ │ - return 180 * Math.atan2(y, x) / Math.PI │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol = OpenLayers.Class({ │ │ │ │ - format: null, │ │ │ │ - options: null, │ │ │ │ - autoDestroy: true, │ │ │ │ - defaultFilter: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - OpenLayers.Util.extend(this, options); │ │ │ │ - this.options = options │ │ │ │ - }, │ │ │ │ - mergeWithDefaultFilter: function(filter) { │ │ │ │ - var merged; │ │ │ │ - if (filter && this.defaultFilter) { │ │ │ │ - merged = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.defaultFilter, filter] │ │ │ │ - }) │ │ │ │ +OpenLayers.Marker = OpenLayers.Class({ │ │ │ │ + icon: null, │ │ │ │ + lonlat: null, │ │ │ │ + events: null, │ │ │ │ + map: null, │ │ │ │ + initialize: function(lonlat, icon) { │ │ │ │ + this.lonlat = lonlat; │ │ │ │ + var newIcon = icon ? icon : OpenLayers.Marker.defaultIcon(); │ │ │ │ + if (this.icon == null) { │ │ │ │ + this.icon = newIcon │ │ │ │ } else { │ │ │ │ - merged = filter || this.defaultFilter || undefined │ │ │ │ + this.icon.url = newIcon.url; │ │ │ │ + this.icon.size = newIcon.size; │ │ │ │ + this.icon.offset = newIcon.offset; │ │ │ │ + this.icon.calculateOffset = newIcon.calculateOffset │ │ │ │ } │ │ │ │ - return merged │ │ │ │ + this.events = new OpenLayers.Events(this, this.icon.imageDiv) │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.options = null; │ │ │ │ - this.format = null │ │ │ │ + this.erase(); │ │ │ │ + this.map = null; │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null; │ │ │ │ + if (this.icon != null) { │ │ │ │ + this.icon.destroy(); │ │ │ │ + this.icon = null │ │ │ │ + } │ │ │ │ }, │ │ │ │ - read: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.filter = this.mergeWithDefaultFilter(options.filter) │ │ │ │ + draw: function(px) { │ │ │ │ + return this.icon.draw(px) │ │ │ │ }, │ │ │ │ - create: function() {}, │ │ │ │ - update: function() {}, │ │ │ │ - delete: function() {}, │ │ │ │ - commit: function() {}, │ │ │ │ - abort: function(response) {}, │ │ │ │ - createCallback: function(method, response, options) { │ │ │ │ - return OpenLayers.Function.bind(function() { │ │ │ │ - method.apply(this, [response, options]) │ │ │ │ - }, this) │ │ │ │ + erase: function() { │ │ │ │ + if (this.icon != null) { │ │ │ │ + this.icon.erase() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol" │ │ │ │ -}); │ │ │ │ -OpenLayers.Protocol.Response = OpenLayers.Class({ │ │ │ │ - code: null, │ │ │ │ - requestType: null, │ │ │ │ - last: true, │ │ │ │ - features: null, │ │ │ │ - data: null, │ │ │ │ - reqFeatures: null, │ │ │ │ - priv: null, │ │ │ │ - error: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options) │ │ │ │ + moveTo: function(px) { │ │ │ │ + if (px != null && this.icon != null) { │ │ │ │ + this.icon.moveTo(px) │ │ │ │ + } │ │ │ │ + this.lonlat = this.map.getLonLatFromLayerPx(px) │ │ │ │ }, │ │ │ │ - success: function() { │ │ │ │ - return this.code > 0 │ │ │ │ + isDrawn: function() { │ │ │ │ + var isDrawn = this.icon && this.icon.isDrawn(); │ │ │ │ + return isDrawn │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.Response" │ │ │ │ -}); │ │ │ │ -OpenLayers.Protocol.Response.SUCCESS = 1; │ │ │ │ -OpenLayers.Protocol.Response.FAILURE = 0; │ │ │ │ -OpenLayers.Renderer = OpenLayers.Class({ │ │ │ │ - container: null, │ │ │ │ - root: null, │ │ │ │ - extent: null, │ │ │ │ - locked: false, │ │ │ │ - size: null, │ │ │ │ - resolution: null, │ │ │ │ - map: null, │ │ │ │ - featureDx: 0, │ │ │ │ - initialize: function(containerID, options) { │ │ │ │ - this.container = OpenLayers.Util.getElement(containerID); │ │ │ │ - OpenLayers.Util.extend(this, options) │ │ │ │ + onScreen: function() { │ │ │ │ + var onScreen = false; │ │ │ │ + if (this.map) { │ │ │ │ + var screenBounds = this.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsLonLat(this.lonlat) │ │ │ │ + } │ │ │ │ + return onScreen │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.container = null; │ │ │ │ - this.extent = null; │ │ │ │ - this.size = null; │ │ │ │ - this.resolution = null; │ │ │ │ - this.map = null │ │ │ │ + inflate: function(inflate) { │ │ │ │ + if (this.icon) { │ │ │ │ + this.icon.setSize({ │ │ │ │ + w: this.icon.size.w * inflate, │ │ │ │ + h: this.icon.size.h * inflate │ │ │ │ + }) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - supported: function() { │ │ │ │ - return false │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + this.icon.setOpacity(opacity) │ │ │ │ }, │ │ │ │ - setExtent: function(extent, resolutionChanged) { │ │ │ │ - this.extent = extent.clone(); │ │ │ │ - if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) { │ │ │ │ - var ratio = extent.getWidth() / this.map.getExtent().getWidth(), │ │ │ │ - extent = extent.scale(1 / ratio); │ │ │ │ - this.extent = extent.wrapDateLine(this.map.getMaxExtent()).scale(ratio) │ │ │ │ - } │ │ │ │ - if (resolutionChanged) { │ │ │ │ - this.resolution = null │ │ │ │ - } │ │ │ │ - return true │ │ │ │ + setUrl: function(url) { │ │ │ │ + this.icon.setUrl(url) │ │ │ │ }, │ │ │ │ - setSize: function(size) { │ │ │ │ - this.size = size.clone(); │ │ │ │ - this.resolution = null │ │ │ │ + display: function(display) { │ │ │ │ + this.icon.display(display) │ │ │ │ }, │ │ │ │ - getResolution: function() { │ │ │ │ - this.resolution = this.resolution || this.map.getResolution(); │ │ │ │ - return this.resolution │ │ │ │ + CLASS_NAME: "OpenLayers.Marker" │ │ │ │ +}); │ │ │ │ +OpenLayers.Marker.defaultIcon = function() { │ │ │ │ + return new OpenLayers.Icon(OpenLayers.Util.getImageLocation("marker.png"), { │ │ │ │ + w: 21, │ │ │ │ + h: 25 │ │ │ │ + }, { │ │ │ │ + x: -10.5, │ │ │ │ + y: -25 │ │ │ │ + }) │ │ │ │ +}; │ │ │ │ +OpenLayers.Control = OpenLayers.Class({ │ │ │ │ + id: null, │ │ │ │ + map: null, │ │ │ │ + div: null, │ │ │ │ + type: null, │ │ │ │ + allowSelection: false, │ │ │ │ + displayClass: "", │ │ │ │ + title: "", │ │ │ │ + autoActivate: false, │ │ │ │ + active: null, │ │ │ │ + handlerOptions: null, │ │ │ │ + handler: null, │ │ │ │ + eventListeners: null, │ │ │ │ + events: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.displayClass = this.CLASS_NAME.replace("OpenLayers.", "ol").replace(/\./g, ""); │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.events = new OpenLayers.Events(this); │ │ │ │ + if (this.eventListeners instanceof Object) { │ │ │ │ + this.events.on(this.eventListeners) │ │ │ │ + } │ │ │ │ + if (this.id == null) { │ │ │ │ + this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + } │ │ │ │ }, │ │ │ │ - drawFeature: function(feature, style) { │ │ │ │ - if (style == null) { │ │ │ │ - style = feature.style │ │ │ │ + destroy: function() { │ │ │ │ + if (this.events) { │ │ │ │ + if (this.eventListeners) { │ │ │ │ + this.events.un(this.eventListeners) │ │ │ │ + } │ │ │ │ + this.events.destroy(); │ │ │ │ + this.events = null │ │ │ │ } │ │ │ │ - if (feature.geometry) { │ │ │ │ - var bounds = feature.geometry.getBounds(); │ │ │ │ - if (bounds) { │ │ │ │ - var worldBounds; │ │ │ │ - if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) { │ │ │ │ + this.eventListeners = null; │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.destroy(); │ │ │ │ + this.handler = null │ │ │ │ + } │ │ │ │ + if (this.handlers) { │ │ │ │ + for (var key in this.handlers) { │ │ │ │ + if (this.handlers.hasOwnProperty(key) && typeof this.handlers[key].destroy == "function") { │ │ │ │ + this.handlers[key].destroy() │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.handlers = null │ │ │ │ + } │ │ │ │ + if (this.map) { │ │ │ │ + this.map.removeControl(this); │ │ │ │ + this.map = null │ │ │ │ + } │ │ │ │ + this.div = null │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.setMap(map) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + draw: function(px) { │ │ │ │ + if (this.div == null) { │ │ │ │ + this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ + this.div.className = this.displayClass; │ │ │ │ + if (!this.allowSelection) { │ │ │ │ + this.div.className += " olControlNoSelect"; │ │ │ │ + this.div.setAttribute("unselectable", "on", 0); │ │ │ │ + this.div.onselectstart = OpenLayers.Function.False │ │ │ │ + } │ │ │ │ + if (this.title != "") { │ │ │ │ + this.div.title = this.title │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (px != null) { │ │ │ │ + this.position = px.clone() │ │ │ │ + } │ │ │ │ + this.moveTo(this.position); │ │ │ │ + return this.div │ │ │ │ + }, │ │ │ │ + moveTo: function(px) { │ │ │ │ + if (px != null && this.div != null) { │ │ │ │ + this.div.style.left = px.x + "px"; │ │ │ │ + this.div.style.top = px.y + "px" │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.activate() │ │ │ │ + } │ │ │ │ + this.active = true; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("activate"); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.deactivate() │ │ │ │ + } │ │ │ │ + this.active = false; │ │ │ │ + if (this.map) { │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass.replace(/ /g, "") + "Active") │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("deactivate"); │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ +OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ +OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ +OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ + layer: null, │ │ │ │ + options: null, │ │ │ │ + active: null, │ │ │ │ + autoActivate: true, │ │ │ │ + autoDestroy: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ + this.active = false │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = null; │ │ │ │ + this.options = null │ │ │ │ + }, │ │ │ │ + setLayer: function(layer) { │ │ │ │ + this.layer = layer │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + this.active = true; │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.active = false; │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ +}); │ │ │ │ +OpenLayers.Renderer = OpenLayers.Class({ │ │ │ │ + container: null, │ │ │ │ + root: null, │ │ │ │ + extent: null, │ │ │ │ + locked: false, │ │ │ │ + size: null, │ │ │ │ + resolution: null, │ │ │ │ + map: null, │ │ │ │ + featureDx: 0, │ │ │ │ + initialize: function(containerID, options) { │ │ │ │ + this.container = OpenLayers.Util.getElement(containerID); │ │ │ │ + OpenLayers.Util.extend(this, options) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.container = null; │ │ │ │ + this.extent = null; │ │ │ │ + this.size = null; │ │ │ │ + this.resolution = null; │ │ │ │ + this.map = null │ │ │ │ + }, │ │ │ │ + supported: function() { │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + setExtent: function(extent, resolutionChanged) { │ │ │ │ + this.extent = extent.clone(); │ │ │ │ + if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) { │ │ │ │ + var ratio = extent.getWidth() / this.map.getExtent().getWidth(), │ │ │ │ + extent = extent.scale(1 / ratio); │ │ │ │ + this.extent = extent.wrapDateLine(this.map.getMaxExtent()).scale(ratio) │ │ │ │ + } │ │ │ │ + if (resolutionChanged) { │ │ │ │ + this.resolution = null │ │ │ │ + } │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + setSize: function(size) { │ │ │ │ + this.size = size.clone(); │ │ │ │ + this.resolution = null │ │ │ │ + }, │ │ │ │ + getResolution: function() { │ │ │ │ + this.resolution = this.resolution || this.map.getResolution(); │ │ │ │ + return this.resolution │ │ │ │ + }, │ │ │ │ + drawFeature: function(feature, style) { │ │ │ │ + if (style == null) { │ │ │ │ + style = feature.style │ │ │ │ + } │ │ │ │ + if (feature.geometry) { │ │ │ │ + var bounds = feature.geometry.getBounds(); │ │ │ │ + if (bounds) { │ │ │ │ + var worldBounds; │ │ │ │ + if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) { │ │ │ │ worldBounds = this.map.getMaxExtent() │ │ │ │ } │ │ │ │ if (!bounds.intersectsBounds(this.extent, { │ │ │ │ worldBounds: worldBounds │ │ │ │ })) { │ │ │ │ style = { │ │ │ │ display: "none" │ │ │ │ @@ -13342,236 +12928,14 @@ │ │ │ │ OpenLayers.Renderer.symbol = { │ │ │ │ star: [350, 75, 379, 161, 469, 161, 397, 215, 423, 301, 350, 250, 277, 301, 303, 215, 231, 161, 321, 161, 350, 75], │ │ │ │ cross: [4, 0, 6, 0, 6, 4, 10, 4, 10, 6, 6, 6, 6, 10, 4, 10, 4, 6, 0, 6, 0, 4, 4, 4, 4, 0], │ │ │ │ x: [0, 0, 25, 0, 50, 35, 75, 0, 100, 0, 65, 50, 100, 100, 75, 100, 50, 65, 25, 100, 0, 100, 35, 50, 0, 0], │ │ │ │ square: [0, 0, 0, 1, 1, 1, 1, 0, 0, 0], │ │ │ │ triangle: [0, 10, 10, 10, 5, 0, 0, 10] │ │ │ │ }; │ │ │ │ -OpenLayers.Symbolizer = OpenLayers.Class({ │ │ │ │ - zIndex: 0, │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Util.extend(this, config) │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var Type = eval(this.CLASS_NAME); │ │ │ │ - return new Type(OpenLayers.Util.extend({}, this)) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer" │ │ │ │ -}); │ │ │ │ -OpenLayers.StyleMap = OpenLayers.Class({ │ │ │ │ - styles: null, │ │ │ │ - extendDefault: true, │ │ │ │ - initialize: function(style, options) { │ │ │ │ - this.styles = { │ │ │ │ - default: new OpenLayers.Style(OpenLayers.Feature.Vector.style["default"]), │ │ │ │ - select: new OpenLayers.Style(OpenLayers.Feature.Vector.style["select"]), │ │ │ │ - temporary: new OpenLayers.Style(OpenLayers.Feature.Vector.style["temporary"]), │ │ │ │ - delete: new OpenLayers.Style(OpenLayers.Feature.Vector.style["delete"]) │ │ │ │ - }; │ │ │ │ - if (style instanceof OpenLayers.Style) { │ │ │ │ - this.styles["default"] = style; │ │ │ │ - this.styles["select"] = style; │ │ │ │ - this.styles["temporary"] = style; │ │ │ │ - this.styles["delete"] = style │ │ │ │ - } else if (typeof style == "object") { │ │ │ │ - for (var key in style) { │ │ │ │ - if (style[key] instanceof OpenLayers.Style) { │ │ │ │ - this.styles[key] = style[key] │ │ │ │ - } else if (typeof style[key] == "object") { │ │ │ │ - this.styles[key] = new OpenLayers.Style(style[key]) │ │ │ │ - } else { │ │ │ │ - this.styles["default"] = new OpenLayers.Style(style); │ │ │ │ - this.styles["select"] = new OpenLayers.Style(style); │ │ │ │ - this.styles["temporary"] = new OpenLayers.Style(style); │ │ │ │ - this.styles["delete"] = new OpenLayers.Style(style); │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Util.extend(this, options) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var key in this.styles) { │ │ │ │ - this.styles[key].destroy() │ │ │ │ - } │ │ │ │ - this.styles = null │ │ │ │ - }, │ │ │ │ - createSymbolizer: function(feature, intent) { │ │ │ │ - if (!feature) { │ │ │ │ - feature = new OpenLayers.Feature.Vector │ │ │ │ - } │ │ │ │ - if (!this.styles[intent]) { │ │ │ │ - intent = "default" │ │ │ │ - } │ │ │ │ - feature.renderIntent = intent; │ │ │ │ - var defaultSymbolizer = {}; │ │ │ │ - if (this.extendDefault && intent != "default") { │ │ │ │ - defaultSymbolizer = this.styles["default"].createSymbolizer(feature) │ │ │ │ - } │ │ │ │ - return OpenLayers.Util.extend(defaultSymbolizer, this.styles[intent].createSymbolizer(feature)) │ │ │ │ - }, │ │ │ │ - addUniqueValueRules: function(renderIntent, property, symbolizers, context) { │ │ │ │ - var rules = []; │ │ │ │ - for (var value in symbolizers) { │ │ │ │ - rules.push(new OpenLayers.Rule({ │ │ │ │ - symbolizer: symbolizers[value], │ │ │ │ - context: context, │ │ │ │ - filter: new OpenLayers.Filter.Comparison({ │ │ │ │ - type: OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }) │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - this.styles[renderIntent].addRules(rules) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.StyleMap" │ │ │ │ -}); │ │ │ │ -OpenLayers.Marker = OpenLayers.Class({ │ │ │ │ - icon: null, │ │ │ │ - lonlat: null, │ │ │ │ - events: null, │ │ │ │ - map: null, │ │ │ │ - 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) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.erase(); │ │ │ │ - this.map = null; │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - if (this.icon != null) { │ │ │ │ - this.icon.destroy(); │ │ │ │ - this.icon = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - draw: function(px) { │ │ │ │ - return this.icon.draw(px) │ │ │ │ - }, │ │ │ │ - erase: function() { │ │ │ │ - if (this.icon != null) { │ │ │ │ - this.icon.erase() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - moveTo: function(px) { │ │ │ │ - if (px != null && this.icon != null) { │ │ │ │ - this.icon.moveTo(px) │ │ │ │ - } │ │ │ │ - this.lonlat = this.map.getLonLatFromLayerPx(px) │ │ │ │ - }, │ │ │ │ - isDrawn: function() { │ │ │ │ - var isDrawn = this.icon && this.icon.isDrawn(); │ │ │ │ - return isDrawn │ │ │ │ - }, │ │ │ │ - onScreen: function() { │ │ │ │ - var onScreen = false; │ │ │ │ - if (this.map) { │ │ │ │ - var screenBounds = this.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsLonLat(this.lonlat) │ │ │ │ - } │ │ │ │ - return onScreen │ │ │ │ - }, │ │ │ │ - inflate: function(inflate) { │ │ │ │ - if (this.icon) { │ │ │ │ - this.icon.setSize({ │ │ │ │ - w: this.icon.size.w * inflate, │ │ │ │ - h: this.icon.size.h * inflate │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - this.icon.setOpacity(opacity) │ │ │ │ - }, │ │ │ │ - setUrl: function(url) { │ │ │ │ - this.icon.setUrl(url) │ │ │ │ - }, │ │ │ │ - display: function(display) { │ │ │ │ - this.icon.display(display) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Marker" │ │ │ │ -}); │ │ │ │ -OpenLayers.Marker.defaultIcon = function() { │ │ │ │ - return new OpenLayers.Icon(OpenLayers.Util.getImageLocation("marker.png"), { │ │ │ │ - w: 21, │ │ │ │ - h: 25 │ │ │ │ - }, { │ │ │ │ - x: -10.5, │ │ │ │ - y: -25 │ │ │ │ - }) │ │ │ │ -}; │ │ │ │ -OpenLayers.Symbolizer.Point = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Point" │ │ │ │ -}); │ │ │ │ -OpenLayers.Symbolizer.Line = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Line" │ │ │ │ -}); │ │ │ │ -OpenLayers.Symbolizer.Polygon = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Polygon" │ │ │ │ -}); │ │ │ │ -OpenLayers.Symbolizer.Text = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Text" │ │ │ │ -}); │ │ │ │ -OpenLayers.Symbolizer.Raster = OpenLayers.Class(OpenLayers.Symbolizer, { │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Symbolizer.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Symbolizer.Raster" │ │ │ │ -}); │ │ │ │ -OpenLayers.Style2 = OpenLayers.Class({ │ │ │ │ - id: null, │ │ │ │ - name: null, │ │ │ │ - title: null, │ │ │ │ - description: null, │ │ │ │ - layerName: null, │ │ │ │ - isDefault: false, │ │ │ │ - rules: null, │ │ │ │ - initialize: function(config) { │ │ │ │ - OpenLayers.Util.extend(this, config); │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; i++) { │ │ │ │ - this.rules[i].destroy() │ │ │ │ - } │ │ │ │ - delete this.rules │ │ │ │ - }, │ │ │ │ - clone: function() { │ │ │ │ - var config = OpenLayers.Util.extend({}, this); │ │ │ │ - if (this.rules) { │ │ │ │ - config.rules = []; │ │ │ │ - for (var i = 0, len = this.rules.length; i < len; ++i) { │ │ │ │ - config.rules.push(this.rules[i].clone()) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return new OpenLayers.Style2(config) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Style2" │ │ │ │ -}); │ │ │ │ OpenLayers.Format.WPSDescribeProcess = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ VERSION: "1.0.0", │ │ │ │ namespaces: { │ │ │ │ wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ ows: "http://www.opengis.net/ows/1.1", │ │ │ │ xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ }, │ │ │ │ @@ -13756,1104 +13120,1841 @@ │ │ │ │ destroy: function() { │ │ │ │ this.events.destroy(); │ │ │ │ this.events = null; │ │ │ │ this.servers = null │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.WPSClient" │ │ │ │ }); │ │ │ │ -OpenLayers.Popup = OpenLayers.Class({ │ │ │ │ - events: null, │ │ │ │ - id: "", │ │ │ │ - lonlat: null, │ │ │ │ - div: null, │ │ │ │ - contentSize: null, │ │ │ │ - size: null, │ │ │ │ - contentHTML: null, │ │ │ │ - backgroundColor: "", │ │ │ │ - opacity: "", │ │ │ │ - border: "", │ │ │ │ - contentDiv: null, │ │ │ │ - groupDiv: null, │ │ │ │ - closeDiv: null, │ │ │ │ - autoSize: false, │ │ │ │ - minSize: null, │ │ │ │ - maxSize: null, │ │ │ │ - displayClass: "olPopup", │ │ │ │ - contentDisplayClass: "olPopupContent", │ │ │ │ - padding: 0, │ │ │ │ - disableFirefoxOverflowHack: false, │ │ │ │ - fixPadding: function() { │ │ │ │ - if (typeof this.padding == "number") { │ │ │ │ - this.padding = new OpenLayers.Bounds(this.padding, this.padding, this.padding, this.padding) │ │ │ │ +OpenLayers.Layer.HTTPRequest = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ + URL_HASH_FACTOR: (Math.sqrt(5) - 1) / 2, │ │ │ │ + url: null, │ │ │ │ + params: null, │ │ │ │ + reproject: false, │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.prototype.initialize.apply(this, [name, options]); │ │ │ │ + this.url = url; │ │ │ │ + if (!this.params) { │ │ │ │ + this.params = OpenLayers.Util.extend({}, params) │ │ │ │ } │ │ │ │ }, │ │ │ │ - panMapIfOutOfView: false, │ │ │ │ - keepInMap: false, │ │ │ │ - closeOnMove: false, │ │ │ │ - map: null, │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, closeBox, closeBoxCallback) { │ │ │ │ - if (id == null) { │ │ │ │ - id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_") │ │ │ │ + destroy: function() { │ │ │ │ + this.url = null; │ │ │ │ + this.params = null; │ │ │ │ + OpenLayers.Layer.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.HTTPRequest(this.name, this.url, this.params, this.getOptions()) │ │ │ │ } │ │ │ │ - this.id = id; │ │ │ │ - this.lonlat = lonlat; │ │ │ │ - this.contentSize = contentSize != null ? contentSize : new OpenLayers.Size(OpenLayers.Popup.WIDTH, OpenLayers.Popup.HEIGHT); │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML │ │ │ │ + obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + setUrl: function(newUrl) { │ │ │ │ + this.url = newUrl │ │ │ │ + }, │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + this.params = OpenLayers.Util.extend(this.params, newParams); │ │ │ │ + var ret = this.redraw(); │ │ │ │ + if (this.map != null) { │ │ │ │ + this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "params" │ │ │ │ + }) │ │ │ │ } │ │ │ │ - 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 = this.displayClass; │ │ │ │ - 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.contentSize.clone(), null, "relative"); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass; │ │ │ │ - this.groupDiv.appendChild(this.contentDiv); │ │ │ │ - this.div.appendChild(this.groupDiv); │ │ │ │ - if (closeBox) { │ │ │ │ - this.addCloseBox(closeBoxCallback) │ │ │ │ + return ret │ │ │ │ + }, │ │ │ │ + redraw: function(force) { │ │ │ │ + if (force) { │ │ │ │ + return this.mergeNewParams({ │ │ │ │ + _olSalt: Math.random() │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + return OpenLayers.Layer.prototype.redraw.apply(this, []) │ │ │ │ } │ │ │ │ - this.registerEvents() │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.id = null; │ │ │ │ - this.lonlat = null; │ │ │ │ - this.size = null; │ │ │ │ - this.contentHTML = null; │ │ │ │ - this.backgroundColor = null; │ │ │ │ - this.opacity = null; │ │ │ │ - this.border = null; │ │ │ │ - if (this.closeOnMove && this.map) { │ │ │ │ - this.map.events.unregister("movestart", this, this.hide) │ │ │ │ + selectUrl: function(paramString, urls) { │ │ │ │ + var product = 1; │ │ │ │ + for (var i = 0, len = paramString.length; i < len; i++) { │ │ │ │ + product *= paramString.charCodeAt(i) * this.URL_HASH_FACTOR; │ │ │ │ + product -= Math.floor(product) │ │ │ │ } │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - if (this.closeDiv) { │ │ │ │ - OpenLayers.Event.stopObservingElement(this.closeDiv); │ │ │ │ - this.groupDiv.removeChild(this.closeDiv) │ │ │ │ + return urls[Math.floor(product * urls.length)] │ │ │ │ + }, │ │ │ │ + getFullRequestString: function(newParams, altUrl) { │ │ │ │ + var url = altUrl || this.url; │ │ │ │ + var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ + allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ + var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(paramsString, url) │ │ │ │ } │ │ │ │ - this.closeDiv = null; │ │ │ │ - this.div.removeChild(this.groupDiv); │ │ │ │ - this.groupDiv = null; │ │ │ │ - if (this.map != null) { │ │ │ │ - this.map.removePopup(this) │ │ │ │ + var urlParams = OpenLayers.Util.upperCaseObject(OpenLayers.Util.getParameters(url)); │ │ │ │ + for (var key in allParams) { │ │ │ │ + if (key.toUpperCase() in urlParams) { │ │ │ │ + delete allParams[key] │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.map = null; │ │ │ │ - this.div = null; │ │ │ │ - this.autoSize = null; │ │ │ │ - this.minSize = null; │ │ │ │ - this.maxSize = null; │ │ │ │ - this.padding = null; │ │ │ │ - this.panMapIfOutOfView = null │ │ │ │ + paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + return OpenLayers.Util.urlAppend(url, paramsString) │ │ │ │ }, │ │ │ │ - draw: function(px) { │ │ │ │ - if (px == null) { │ │ │ │ - if (this.lonlat != null && this.map != null) { │ │ │ │ - px = this.map.getLayerPxFromLonLat(this.lonlat) │ │ │ │ - } │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.HTTPRequest" │ │ │ │ +}); │ │ │ │ +OpenLayers.Tile.Image = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ + url: null, │ │ │ │ + imgDiv: null, │ │ │ │ + frame: null, │ │ │ │ + imageReloadAttempts: null, │ │ │ │ + layerAlphaHack: null, │ │ │ │ + asyncRequestId: null, │ │ │ │ + maxGetUrlLength: null, │ │ │ │ + canvasContext: null, │ │ │ │ + crossOriginKeyword: null, │ │ │ │ + initialize: function(layer, position, bounds, url, size, options) { │ │ │ │ + OpenLayers.Tile.prototype.initialize.apply(this, arguments); │ │ │ │ + this.url = url; │ │ │ │ + this.layerAlphaHack = this.layer.alpha && OpenLayers.Util.alphaHack(); │ │ │ │ + if (this.maxGetUrlLength != null || this.layer.gutter || this.layerAlphaHack) { │ │ │ │ + this.frame = document.createElement("div"); │ │ │ │ + this.frame.style.position = "absolute"; │ │ │ │ + this.frame.style.overflow = "hidden" │ │ │ │ } │ │ │ │ - if (this.closeOnMove) { │ │ │ │ - this.map.events.register("movestart", this, this.hide) │ │ │ │ + if (this.maxGetUrlLength != null) { │ │ │ │ + OpenLayers.Util.extend(this, OpenLayers.Tile.Image.IFrame) │ │ │ │ } │ │ │ │ - if (!this.disableFirefoxOverflowHack && OpenLayers.BROWSER_NAME == "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 │ │ │ │ - } │ │ │ │ - }) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.imgDiv) { │ │ │ │ + this.clear(); │ │ │ │ + this.imgDiv = null; │ │ │ │ + this.frame = null │ │ │ │ } │ │ │ │ - this.moveTo(px); │ │ │ │ - if (!this.autoSize && !this.size) { │ │ │ │ - this.setSize(this.contentSize) │ │ │ │ + this.asyncRequestId = null; │ │ │ │ + OpenLayers.Tile.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + var shouldDraw = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ + if (shouldDraw) { │ │ │ │ + if (this.layer != this.layer.map.baseLayer && this.layer.reproject) { │ │ │ │ + this.bounds = this.getBoundsFromBaseLayer(this.position) │ │ │ │ + } │ │ │ │ + if (this.isLoading) { │ │ │ │ + this._loadEvent = "reload" │ │ │ │ + } else { │ │ │ │ + this.isLoading = true; │ │ │ │ + this._loadEvent = "loadstart" │ │ │ │ + } │ │ │ │ + this.renderTile(); │ │ │ │ + this.positionTile() │ │ │ │ + } else if (shouldDraw === false) { │ │ │ │ + this.unload() │ │ │ │ } │ │ │ │ - this.setBackgroundColor(); │ │ │ │ - this.setOpacity(); │ │ │ │ - this.setBorder(); │ │ │ │ - this.setContentHTML(); │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView() │ │ │ │ + return shouldDraw │ │ │ │ + }, │ │ │ │ + renderTile: function() { │ │ │ │ + if (this.layer.async) { │ │ │ │ + var id = this.asyncRequestId = (this.asyncRequestId || 0) + 1; │ │ │ │ + this.layer.getURLasync(this.bounds, function(url) { │ │ │ │ + if (id == this.asyncRequestId) { │ │ │ │ + this.url = url; │ │ │ │ + this.initImage() │ │ │ │ + } │ │ │ │ + }, this) │ │ │ │ + } else { │ │ │ │ + this.url = this.layer.getURL(this.bounds); │ │ │ │ + this.initImage() │ │ │ │ } │ │ │ │ - return this.div │ │ │ │ }, │ │ │ │ - updatePosition: function() { │ │ │ │ - if (this.lonlat && this.map) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - if (px) { │ │ │ │ - this.moveTo(px) │ │ │ │ + positionTile: function() { │ │ │ │ + var style = this.getTile().style, │ │ │ │ + size = this.frame ? this.size : this.layer.getImageSize(this.bounds), │ │ │ │ + ratio = 1; │ │ │ │ + if (this.layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ + ratio = this.layer.getServerResolution() / this.layer.map.getResolution() │ │ │ │ + } │ │ │ │ + style.left = this.position.x + "px"; │ │ │ │ + style.top = this.position.y + "px"; │ │ │ │ + style.width = Math.round(ratio * size.w) + "px"; │ │ │ │ + style.height = Math.round(ratio * size.h) + "px" │ │ │ │ + }, │ │ │ │ + clear: function() { │ │ │ │ + OpenLayers.Tile.prototype.clear.apply(this, arguments); │ │ │ │ + var img = this.imgDiv; │ │ │ │ + if (img) { │ │ │ │ + var tile = this.getTile(); │ │ │ │ + if (tile.parentNode === this.layer.div) { │ │ │ │ + this.layer.div.removeChild(tile) │ │ │ │ + } │ │ │ │ + this.setImgSrc(); │ │ │ │ + if (this.layerAlphaHack === true) { │ │ │ │ + img.style.filter = "" │ │ │ │ } │ │ │ │ + OpenLayers.Element.removeClass(img, "olImageLoadError") │ │ │ │ } │ │ │ │ + this.canvasContext = null │ │ │ │ }, │ │ │ │ - moveTo: function(px) { │ │ │ │ - if (px != null && this.div != null) { │ │ │ │ - this.div.style.left = px.x + "px"; │ │ │ │ - this.div.style.top = px.y + "px" │ │ │ │ + getImage: function() { │ │ │ │ + if (!this.imgDiv) { │ │ │ │ + this.imgDiv = OpenLayers.Tile.Image.IMAGE.cloneNode(false); │ │ │ │ + var style = this.imgDiv.style; │ │ │ │ + if (this.frame) { │ │ │ │ + var left = 0, │ │ │ │ + top = 0; │ │ │ │ + if (this.layer.gutter) { │ │ │ │ + left = this.layer.gutter / this.layer.tileSize.w * 100; │ │ │ │ + top = this.layer.gutter / this.layer.tileSize.h * 100 │ │ │ │ + } │ │ │ │ + style.left = -left + "%"; │ │ │ │ + style.top = -top + "%"; │ │ │ │ + style.width = 2 * left + 100 + "%"; │ │ │ │ + style.height = 2 * top + 100 + "%" │ │ │ │ + } │ │ │ │ + style.visibility = "hidden"; │ │ │ │ + style.opacity = 0; │ │ │ │ + if (this.layer.opacity < 1) { │ │ │ │ + style.filter = "alpha(opacity=" + this.layer.opacity * 100 + ")" │ │ │ │ + } │ │ │ │ + style.position = "absolute"; │ │ │ │ + if (this.layerAlphaHack) { │ │ │ │ + style.paddingTop = style.height; │ │ │ │ + style.height = "0"; │ │ │ │ + style.width = "100%" │ │ │ │ + } │ │ │ │ + if (this.frame) { │ │ │ │ + this.frame.appendChild(this.imgDiv) │ │ │ │ + } │ │ │ │ } │ │ │ │ + return this.imgDiv │ │ │ │ }, │ │ │ │ - visible: function() { │ │ │ │ - return OpenLayers.Element.visible(this.div) │ │ │ │ + setImage: function(img) { │ │ │ │ + this.imgDiv = img │ │ │ │ }, │ │ │ │ - toggle: function() { │ │ │ │ - if (this.visible()) { │ │ │ │ - this.hide() │ │ │ │ + initImage: function() { │ │ │ │ + if (!this.url && !this.imgDiv) { │ │ │ │ + this.isLoading = false; │ │ │ │ + return │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("beforeload"); │ │ │ │ + this.layer.div.appendChild(this.getTile()); │ │ │ │ + this.events.triggerEvent(this._loadEvent); │ │ │ │ + var img = this.getImage(); │ │ │ │ + var src = img.getAttribute("src") || ""; │ │ │ │ + if (this.url && OpenLayers.Util.isEquivalentUrl(src, this.url)) { │ │ │ │ + this._loadTimeout = window.setTimeout(OpenLayers.Function.bind(this.onImageLoad, this), 0) │ │ │ │ } else { │ │ │ │ - this.show() │ │ │ │ + this.stopLoading(); │ │ │ │ + if (this.crossOriginKeyword) { │ │ │ │ + img.removeAttribute("crossorigin") │ │ │ │ + } │ │ │ │ + OpenLayers.Event.observe(img, "load", OpenLayers.Function.bind(this.onImageLoad, this)); │ │ │ │ + OpenLayers.Event.observe(img, "error", OpenLayers.Function.bind(this.onImageError, this)); │ │ │ │ + this.imageReloadAttempts = 0; │ │ │ │ + this.setImgSrc(this.url) │ │ │ │ } │ │ │ │ }, │ │ │ │ - show: function() { │ │ │ │ - this.div.style.display = ""; │ │ │ │ - if (this.panMapIfOutOfView) { │ │ │ │ - this.panIntoView() │ │ │ │ + setImgSrc: function(url) { │ │ │ │ + var img = this.imgDiv; │ │ │ │ + if (url) { │ │ │ │ + img.style.visibility = "hidden"; │ │ │ │ + img.style.opacity = 0; │ │ │ │ + if (this.crossOriginKeyword) { │ │ │ │ + if (url.substr(0, 5) !== "data:") { │ │ │ │ + img.setAttribute("crossorigin", this.crossOriginKeyword) │ │ │ │ + } else { │ │ │ │ + img.removeAttribute("crossorigin") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + img.src = url │ │ │ │ + } else { │ │ │ │ + this.stopLoading(); │ │ │ │ + this.imgDiv = null; │ │ │ │ + if (img.parentNode) { │ │ │ │ + img.parentNode.removeChild(img) │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - hide: function() { │ │ │ │ - this.div.style.display = "none" │ │ │ │ + getTile: function() { │ │ │ │ + return this.frame ? this.frame : this.getImage() │ │ │ │ }, │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - this.size = contentSize.clone(); │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ - var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ - var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ - 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 │ │ │ │ - } │ │ │ │ - this.size.w += wPadding; │ │ │ │ - this.size.h += hPadding; │ │ │ │ - if (OpenLayers.BROWSER_NAME == "msie") { │ │ │ │ - this.contentSize.w += contentDivPadding.left + contentDivPadding.right; │ │ │ │ - this.contentSize.h += contentDivPadding.bottom + contentDivPadding.top │ │ │ │ + createBackBuffer: function() { │ │ │ │ + if (!this.imgDiv || this.isLoading) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.width = this.size.w + "px"; │ │ │ │ - this.div.style.height = this.size.h + "px" │ │ │ │ + var backBuffer; │ │ │ │ + if (this.frame) { │ │ │ │ + backBuffer = this.frame.cloneNode(false); │ │ │ │ + backBuffer.appendChild(this.imgDiv) │ │ │ │ + } else { │ │ │ │ + backBuffer = this.imgDiv │ │ │ │ } │ │ │ │ - if (this.contentDiv != null) { │ │ │ │ - this.contentDiv.style.width = contentSize.w + "px"; │ │ │ │ - this.contentDiv.style.height = contentSize.h + "px" │ │ │ │ + this.imgDiv = null; │ │ │ │ + return backBuffer │ │ │ │ + }, │ │ │ │ + onImageLoad: function() { │ │ │ │ + var img = this.imgDiv; │ │ │ │ + this.stopLoading(); │ │ │ │ + img.style.visibility = "inherit"; │ │ │ │ + img.style.opacity = this.layer.opacity; │ │ │ │ + this.isLoading = false; │ │ │ │ + this.canvasContext = null; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + if (this.layerAlphaHack === true) { │ │ │ │ + img.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + img.src + "', sizingMethod='scale')" │ │ │ │ } │ │ │ │ }, │ │ │ │ - updateSize: function() { │ │ │ │ - var preparedHTML = "<div class='" + this.contentDisplayClass + "'>" + this.contentDiv.innerHTML + "</div>"; │ │ │ │ - var containerElement = this.map ? this.map.div : document.body; │ │ │ │ - var realSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, null, { │ │ │ │ - displayClass: this.displayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - }); │ │ │ │ - var safeSize = this.getSafeContentSize(realSize); │ │ │ │ - var newSize = null; │ │ │ │ - if (safeSize.equals(realSize)) { │ │ │ │ - newSize = realSize │ │ │ │ - } else { │ │ │ │ - var fixedSize = { │ │ │ │ - w: safeSize.w < realSize.w ? safeSize.w : null, │ │ │ │ - h: safeSize.h < realSize.h ? safeSize.h : null │ │ │ │ - }; │ │ │ │ - if (fixedSize.w && fixedSize.h) { │ │ │ │ - newSize = safeSize │ │ │ │ + onImageError: function() { │ │ │ │ + var img = this.imgDiv; │ │ │ │ + if (img.src != null) { │ │ │ │ + this.imageReloadAttempts++; │ │ │ │ + if (this.imageReloadAttempts <= OpenLayers.IMAGE_RELOAD_ATTEMPTS) { │ │ │ │ + this.setImgSrc(this.layer.getURL(this.bounds)) │ │ │ │ } else { │ │ │ │ - var clippedSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, fixedSize, { │ │ │ │ - displayClass: this.contentDisplayClass, │ │ │ │ - containerElement: containerElement │ │ │ │ - }); │ │ │ │ - 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) │ │ │ │ + OpenLayers.Element.addClass(img, "olImageLoadError"); │ │ │ │ + this.events.triggerEvent("loaderror"); │ │ │ │ + this.onImageLoad() │ │ │ │ } │ │ │ │ } │ │ │ │ - this.setSize(newSize) │ │ │ │ }, │ │ │ │ - setBackgroundColor: function(color) { │ │ │ │ - if (color != undefined) { │ │ │ │ - this.backgroundColor = color │ │ │ │ - } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.backgroundColor = this.backgroundColor │ │ │ │ + stopLoading: function() { │ │ │ │ + OpenLayers.Event.stopObservingElement(this.imgDiv); │ │ │ │ + window.clearTimeout(this._loadTimeout); │ │ │ │ + delete this._loadTimeout │ │ │ │ + }, │ │ │ │ + getCanvasContext: function() { │ │ │ │ + if (OpenLayers.CANVAS_SUPPORTED && this.imgDiv && !this.isLoading) { │ │ │ │ + if (!this.canvasContext) { │ │ │ │ + var canvas = document.createElement("canvas"); │ │ │ │ + canvas.width = this.size.w; │ │ │ │ + canvas.height = this.size.h; │ │ │ │ + this.canvasContext = canvas.getContext("2d"); │ │ │ │ + this.canvasContext.drawImage(this.imgDiv, 0, 0) │ │ │ │ + } │ │ │ │ + return this.canvasContext │ │ │ │ } │ │ │ │ }, │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - if (opacity != undefined) { │ │ │ │ - this.opacity = opacity │ │ │ │ + CLASS_NAME: "OpenLayers.Tile.Image" │ │ │ │ +}); │ │ │ │ +OpenLayers.Tile.Image.IMAGE = function() { │ │ │ │ + var img = new Image; │ │ │ │ + img.className = "olTileImage"; │ │ │ │ + img.galleryImg = "no"; │ │ │ │ + return img │ │ │ │ +}(); │ │ │ │ +OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, { │ │ │ │ + tileSize: null, │ │ │ │ + tileOriginCorner: "bl", │ │ │ │ + tileOrigin: null, │ │ │ │ + tileOptions: null, │ │ │ │ + tileClass: OpenLayers.Tile.Image, │ │ │ │ + grid: null, │ │ │ │ + singleTile: false, │ │ │ │ + ratio: 1.5, │ │ │ │ + buffer: 0, │ │ │ │ + transitionEffect: "resize", │ │ │ │ + numLoadingTiles: 0, │ │ │ │ + serverResolutions: null, │ │ │ │ + loading: false, │ │ │ │ + backBuffer: null, │ │ │ │ + gridResolution: null, │ │ │ │ + backBufferResolution: null, │ │ │ │ + backBufferLonLat: null, │ │ │ │ + backBufferTimerId: null, │ │ │ │ + removeBackBufferDelay: null, │ │ │ │ + className: null, │ │ │ │ + gridLayout: null, │ │ │ │ + rowSign: null, │ │ │ │ + transitionendEvents: ["transitionend", "webkitTransitionEnd", "otransitionend", "oTransitionEnd"], │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.initialize.apply(this, arguments); │ │ │ │ + this.grid = []; │ │ │ │ + this._removeBackBuffer = OpenLayers.Function.bind(this.removeBackBuffer, this); │ │ │ │ + this.initProperties(); │ │ │ │ + this.rowSign = this.tileOriginCorner.substr(0, 1) === "t" ? 1 : -1 │ │ │ │ + }, │ │ │ │ + initProperties: function() { │ │ │ │ + if (this.options.removeBackBufferDelay === undefined) { │ │ │ │ + this.removeBackBufferDelay = this.singleTile ? 0 : 2500 │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.opacity = this.opacity; │ │ │ │ - this.div.style.filter = "alpha(opacity=" + this.opacity * 100 + ")" │ │ │ │ + if (this.options.className === undefined) { │ │ │ │ + this.className = this.singleTile ? "olLayerGridSingleTile" : "olLayerGrid" │ │ │ │ } │ │ │ │ }, │ │ │ │ - setBorder: function(border) { │ │ │ │ - if (border != undefined) { │ │ │ │ - this.border = border │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.setMap.call(this, map); │ │ │ │ + OpenLayers.Element.addClass(this.div, this.className) │ │ │ │ + }, │ │ │ │ + removeMap: function(map) { │ │ │ │ + this.removeBackBuffer() │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.removeBackBuffer(); │ │ │ │ + this.clearGrid(); │ │ │ │ + this.grid = null; │ │ │ │ + this.tileSize = null; │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + clearGrid: function() { │ │ │ │ + if (this.grid) { │ │ │ │ + for (var iRow = 0, len = this.grid.length; iRow < len; iRow++) { │ │ │ │ + var row = this.grid[iRow]; │ │ │ │ + for (var iCol = 0, clen = row.length; iCol < clen; iCol++) { │ │ │ │ + var tile = row[iCol]; │ │ │ │ + this.destroyTile(tile) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.grid = []; │ │ │ │ + this.gridResolution = null; │ │ │ │ + this.gridLayout = null │ │ │ │ } │ │ │ │ - if (this.div != null) { │ │ │ │ - this.div.style.border = this.border │ │ │ │ + }, │ │ │ │ + addOptions: function(newOptions, reinitialize) { │ │ │ │ + var singleTileChanged = newOptions.singleTile !== undefined && newOptions.singleTile !== this.singleTile; │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.addOptions.apply(this, arguments); │ │ │ │ + if (this.map && singleTileChanged) { │ │ │ │ + this.initProperties(); │ │ │ │ + this.clearGrid(); │ │ │ │ + this.tileSize = this.options.tileSize; │ │ │ │ + this.setTileSize(); │ │ │ │ + this.moveTo(null, true) │ │ │ │ } │ │ │ │ }, │ │ │ │ - setContentHTML: function(contentHTML) { │ │ │ │ - if (contentHTML != null) { │ │ │ │ - this.contentHTML = contentHTML │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Grid(this.name, this.url, this.params, this.getOptions()) │ │ │ │ } │ │ │ │ - if (this.contentDiv != null && this.contentHTML != null && this.contentHTML != this.contentDiv.innerHTML) { │ │ │ │ - this.contentDiv.innerHTML = this.contentHTML; │ │ │ │ - if (this.autoSize) { │ │ │ │ - this.registerImageListeners(); │ │ │ │ - this.updateSize() │ │ │ │ + obj = OpenLayers.Layer.HTTPRequest.prototype.clone.apply(this, [obj]); │ │ │ │ + if (this.tileSize != null) { │ │ │ │ + obj.tileSize = this.tileSize.clone() │ │ │ │ + } │ │ │ │ + obj.grid = []; │ │ │ │ + obj.gridResolution = null; │ │ │ │ + obj.backBuffer = null; │ │ │ │ + obj.backBufferTimerId = null; │ │ │ │ + obj.loading = false; │ │ │ │ + obj.numLoadingTiles = 0; │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments); │ │ │ │ + bounds = bounds || this.map.getExtent(); │ │ │ │ + if (bounds != null) { │ │ │ │ + var forceReTile = !this.grid.length || zoomChanged; │ │ │ │ + var tilesBounds = this.getTilesBounds(); │ │ │ │ + var resolution = this.map.getResolution(); │ │ │ │ + var serverResolution = this.getServerResolution(resolution); │ │ │ │ + if (this.singleTile) { │ │ │ │ + if (forceReTile || !dragging && !tilesBounds.containsBounds(bounds)) { │ │ │ │ + if (zoomChanged && this.transitionEffect !== "resize") { │ │ │ │ + this.removeBackBuffer() │ │ │ │ + } │ │ │ │ + if (!zoomChanged || this.transitionEffect === "resize") { │ │ │ │ + this.applyBackBuffer(resolution) │ │ │ │ + } │ │ │ │ + this.initSingleTile(bounds) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + forceReTile = forceReTile || !tilesBounds.intersectsBounds(bounds, { │ │ │ │ + worldBounds: this.map.baseLayer.wrapDateLine && this.map.getMaxExtent() │ │ │ │ + }); │ │ │ │ + if (forceReTile) { │ │ │ │ + if (zoomChanged && (this.transitionEffect === "resize" || this.gridResolution === resolution)) { │ │ │ │ + this.applyBackBuffer(resolution) │ │ │ │ + } │ │ │ │ + this.initGriddedTiles(bounds) │ │ │ │ + } else { │ │ │ │ + this.moveGriddedTiles() │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - registerImageListeners: function() { │ │ │ │ - var onImgLoad = function() { │ │ │ │ - if (this.popup.id === null) { │ │ │ │ - return │ │ │ │ + getTileData: function(loc) { │ │ │ │ + var data = null, │ │ │ │ + x = loc.lon, │ │ │ │ + y = loc.lat, │ │ │ │ + numRows = this.grid.length; │ │ │ │ + if (this.map && numRows) { │ │ │ │ + var res = this.map.getResolution(), │ │ │ │ + tileWidth = this.tileSize.w, │ │ │ │ + tileHeight = this.tileSize.h, │ │ │ │ + bounds = this.grid[0][0].bounds, │ │ │ │ + left = bounds.left, │ │ │ │ + top = bounds.top; │ │ │ │ + if (x < left) { │ │ │ │ + if (this.map.baseLayer.wrapDateLine) { │ │ │ │ + var worldWidth = this.map.getMaxExtent().getWidth(); │ │ │ │ + var worldsAway = Math.ceil((left - x) / worldWidth); │ │ │ │ + x += worldWidth * worldsAway │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.popup.updateSize(); │ │ │ │ - if (this.popup.visible() && this.popup.panMapIfOutOfView) { │ │ │ │ - this.popup.panIntoView() │ │ │ │ + var dtx = (x - left) / (res * tileWidth); │ │ │ │ + var dty = (top - y) / (res * tileHeight); │ │ │ │ + var col = Math.floor(dtx); │ │ │ │ + var row = Math.floor(dty); │ │ │ │ + if (row >= 0 && row < numRows) { │ │ │ │ + var tile = this.grid[row][col]; │ │ │ │ + if (tile) { │ │ │ │ + data = { │ │ │ │ + tile: tile, │ │ │ │ + i: Math.floor((dtx - col) * tileWidth), │ │ │ │ + j: Math.floor((dty - row) * tileHeight) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - OpenLayers.Event.stopObserving(this.img, "load", this.img._onImgLoad) │ │ │ │ - }; │ │ │ │ - var images = this.contentDiv.getElementsByTagName("img"); │ │ │ │ - for (var i = 0, len = images.length; i < len; i++) { │ │ │ │ - var img = images[i]; │ │ │ │ - if (img.width == 0 || img.height == 0) { │ │ │ │ - var context = { │ │ │ │ - popup: this, │ │ │ │ - img: img │ │ │ │ - }; │ │ │ │ - img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context); │ │ │ │ - OpenLayers.Event.observe(img, "load", img._onImgLoad) │ │ │ │ + } │ │ │ │ + return data │ │ │ │ + }, │ │ │ │ + destroyTile: function(tile) { │ │ │ │ + this.removeTileMonitoringHooks(tile); │ │ │ │ + tile.destroy() │ │ │ │ + }, │ │ │ │ + getServerResolution: function(resolution) { │ │ │ │ + var distance = Number.POSITIVE_INFINITY; │ │ │ │ + resolution = resolution || this.map.getResolution(); │ │ │ │ + if (this.serverResolutions && OpenLayers.Util.indexOf(this.serverResolutions, resolution) === -1) { │ │ │ │ + var i, newDistance, newResolution, serverResolution; │ │ │ │ + for (i = this.serverResolutions.length - 1; i >= 0; i--) { │ │ │ │ + newResolution = this.serverResolutions[i]; │ │ │ │ + newDistance = Math.abs(newResolution - resolution); │ │ │ │ + if (newDistance > distance) { │ │ │ │ + break │ │ │ │ + } │ │ │ │ + distance = newDistance; │ │ │ │ + serverResolution = newResolution │ │ │ │ } │ │ │ │ + resolution = serverResolution │ │ │ │ } │ │ │ │ + return resolution │ │ │ │ }, │ │ │ │ - getSafeContentSize: function(size) { │ │ │ │ - var safeContentSize = size.clone(); │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ - var wPadding = contentDivPadding.left + contentDivPadding.right; │ │ │ │ - var hPadding = contentDivPadding.top + contentDivPadding.bottom; │ │ │ │ - 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 │ │ │ │ + getServerZoom: function() { │ │ │ │ + var resolution = this.getServerResolution(); │ │ │ │ + return this.serverResolutions ? OpenLayers.Util.indexOf(this.serverResolutions, resolution) : this.map.getZoomForResolution(resolution) + (this.zoomOffset || 0) │ │ │ │ + }, │ │ │ │ + applyBackBuffer: function(resolution) { │ │ │ │ + if (this.backBufferTimerId !== null) { │ │ │ │ + this.removeBackBuffer() │ │ │ │ } │ │ │ │ - if (this.minSize) { │ │ │ │ - safeContentSize.w = Math.max(safeContentSize.w, this.minSize.w - wPadding); │ │ │ │ - safeContentSize.h = Math.max(safeContentSize.h, this.minSize.h - hPadding) │ │ │ │ + var backBuffer = this.backBuffer; │ │ │ │ + if (!backBuffer) { │ │ │ │ + backBuffer = this.createBackBuffer(); │ │ │ │ + if (!backBuffer) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if (resolution === this.gridResolution) { │ │ │ │ + this.div.insertBefore(backBuffer, this.div.firstChild) │ │ │ │ + } else { │ │ │ │ + this.map.baseLayer.div.parentNode.insertBefore(backBuffer, this.map.baseLayer.div) │ │ │ │ + } │ │ │ │ + this.backBuffer = backBuffer; │ │ │ │ + var topLeftTileBounds = this.grid[0][0].bounds; │ │ │ │ + this.backBufferLonLat = { │ │ │ │ + lon: topLeftTileBounds.left, │ │ │ │ + lat: topLeftTileBounds.top │ │ │ │ + }; │ │ │ │ + this.backBufferResolution = this.gridResolution │ │ │ │ } │ │ │ │ - if (this.maxSize) { │ │ │ │ - safeContentSize.w = Math.min(safeContentSize.w, this.maxSize.w - wPadding); │ │ │ │ - safeContentSize.h = Math.min(safeContentSize.h, this.maxSize.h - hPadding) │ │ │ │ + var ratio = this.backBufferResolution / resolution; │ │ │ │ + var tiles = backBuffer.childNodes, │ │ │ │ + tile; │ │ │ │ + for (var i = tiles.length - 1; i >= 0; --i) { │ │ │ │ + tile = tiles[i]; │ │ │ │ + tile.style.top = (ratio * tile._i * tile._h | 0) + "px"; │ │ │ │ + tile.style.left = (ratio * tile._j * tile._w | 0) + "px"; │ │ │ │ + tile.style.width = Math.round(ratio * tile._w) + "px"; │ │ │ │ + tile.style.height = Math.round(ratio * tile._h) + "px" │ │ │ │ } │ │ │ │ - if (this.map && this.map.size) { │ │ │ │ - var extraX = 0, │ │ │ │ - extraY = 0; │ │ │ │ - if (this.keepInMap && !this.panMapIfOutOfView) { │ │ │ │ - var px = this.map.getPixelFromLonLat(this.lonlat); │ │ │ │ - switch (this.relativePosition) { │ │ │ │ - case "tr": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "tl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break; │ │ │ │ - case "bl": │ │ │ │ - extraX = this.map.size.w - px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - case "br": │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = px.y; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - extraX = px.x; │ │ │ │ - extraY = this.map.size.h - px.y; │ │ │ │ - break │ │ │ │ + var position = this.getViewPortPxFromLonLat(this.backBufferLonLat, resolution); │ │ │ │ + var leftOffset = this.map.layerContainerOriginPx.x; │ │ │ │ + var topOffset = this.map.layerContainerOriginPx.y; │ │ │ │ + backBuffer.style.left = Math.round(position.x - leftOffset) + "px"; │ │ │ │ + backBuffer.style.top = Math.round(position.y - topOffset) + "px" │ │ │ │ + }, │ │ │ │ + createBackBuffer: function() { │ │ │ │ + var backBuffer; │ │ │ │ + if (this.grid.length > 0) { │ │ │ │ + backBuffer = document.createElement("div"); │ │ │ │ + backBuffer.id = this.div.id + "_bb"; │ │ │ │ + backBuffer.className = "olBackBuffer"; │ │ │ │ + backBuffer.style.position = "absolute"; │ │ │ │ + var map = this.map; │ │ │ │ + backBuffer.style.zIndex = this.transitionEffect === "resize" ? this.getZIndex() - 1 : map.Z_INDEX_BASE.BaseLayer - (map.getNumLayers() - map.getLayerIndex(this)); │ │ │ │ + for (var i = 0, lenI = this.grid.length; i < lenI; i++) { │ │ │ │ + for (var j = 0, lenJ = this.grid[i].length; j < lenJ; j++) { │ │ │ │ + var tile = this.grid[i][j], │ │ │ │ + markup = this.grid[i][j].createBackBuffer(); │ │ │ │ + if (markup) { │ │ │ │ + markup._i = i; │ │ │ │ + markup._j = j; │ │ │ │ + markup._w = tile.size.w; │ │ │ │ + markup._h = tile.size.h; │ │ │ │ + markup.id = tile.id + "_bb"; │ │ │ │ + backBuffer.appendChild(markup) │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - var maxY = this.map.size.h - this.map.paddingForPopups.top - this.map.paddingForPopups.bottom - hPadding - extraY; │ │ │ │ - var maxX = this.map.size.w - this.map.paddingForPopups.left - this.map.paddingForPopups.right - wPadding - extraX; │ │ │ │ - safeContentSize.w = Math.min(safeContentSize.w, maxX); │ │ │ │ - safeContentSize.h = Math.min(safeContentSize.h, maxY) │ │ │ │ } │ │ │ │ - return safeContentSize │ │ │ │ + return backBuffer │ │ │ │ }, │ │ │ │ - getContentDivPadding: function() { │ │ │ │ - var contentDivPadding = this._contentDivPadding; │ │ │ │ - if (!contentDivPadding) { │ │ │ │ - if (this.div.parentNode == null) { │ │ │ │ - this.div.style.display = "none"; │ │ │ │ - document.body.appendChild(this.div) │ │ │ │ + removeBackBuffer: function() { │ │ │ │ + if (this._transitionElement) { │ │ │ │ + for (var i = this.transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ + OpenLayers.Event.stopObserving(this._transitionElement, this.transitionendEvents[i], this._removeBackBuffer) │ │ │ │ } │ │ │ │ - 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")); │ │ │ │ - this._contentDivPadding = contentDivPadding; │ │ │ │ - if (this.div.parentNode == document.body) { │ │ │ │ - document.body.removeChild(this.div); │ │ │ │ - this.div.style.display = "" │ │ │ │ + delete this._transitionElement │ │ │ │ + } │ │ │ │ + if (this.backBuffer) { │ │ │ │ + if (this.backBuffer.parentNode) { │ │ │ │ + this.backBuffer.parentNode.removeChild(this.backBuffer) │ │ │ │ + } │ │ │ │ + this.backBuffer = null; │ │ │ │ + this.backBufferResolution = null; │ │ │ │ + if (this.backBufferTimerId !== null) { │ │ │ │ + window.clearTimeout(this.backBufferTimerId); │ │ │ │ + this.backBufferTimerId = null │ │ │ │ } │ │ │ │ } │ │ │ │ - return contentDivPadding │ │ │ │ }, │ │ │ │ - addCloseBox: function(callback) { │ │ │ │ - this.closeDiv = OpenLayers.Util.createDiv(this.id + "_close", null, { │ │ │ │ - w: 17, │ │ │ │ - h: 17 │ │ │ │ - }); │ │ │ │ - this.closeDiv.className = "olPopupCloseBox"; │ │ │ │ - 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, "touchend", OpenLayers.Function.bindAsEventListener(closePopup, this)); │ │ │ │ - OpenLayers.Event.observe(this.closeDiv, "click", OpenLayers.Function.bindAsEventListener(closePopup, this)) │ │ │ │ + moveByPx: function(dx, dy) { │ │ │ │ + if (!this.singleTile) { │ │ │ │ + this.moveGriddedTiles() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - panIntoView: function() { │ │ │ │ - var mapSize = this.map.getSize(); │ │ │ │ - var origTL = this.map.getViewPortPxFromLayerPx(new OpenLayers.Pixel(parseInt(this.div.style.left), parseInt(this.div.style.top))); │ │ │ │ - var newTL = origTL.clone(); │ │ │ │ - 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 │ │ │ │ + setTileSize: function(size) { │ │ │ │ + if (this.singleTile) { │ │ │ │ + size = this.map.getSize(); │ │ │ │ + size.h = parseInt(size.h * this.ratio, 10); │ │ │ │ + size.w = parseInt(size.w * this.ratio, 10) │ │ │ │ } │ │ │ │ - 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 │ │ │ │ + OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]) │ │ │ │ + }, │ │ │ │ + getTilesBounds: function() { │ │ │ │ + var bounds = null; │ │ │ │ + var length = this.grid.length; │ │ │ │ + if (length) { │ │ │ │ + var bottomLeftTileBounds = this.grid[length - 1][0].bounds, │ │ │ │ + width = this.grid[0].length * bottomLeftTileBounds.getWidth(), │ │ │ │ + height = this.grid.length * bottomLeftTileBounds.getHeight(); │ │ │ │ + bounds = new OpenLayers.Bounds(bottomLeftTileBounds.left, bottomLeftTileBounds.bottom, bottomLeftTileBounds.left + width, bottomLeftTileBounds.bottom + height) │ │ │ │ } │ │ │ │ - var dx = origTL.x - newTL.x; │ │ │ │ - var dy = origTL.y - newTL.y; │ │ │ │ - this.map.pan(dx, dy) │ │ │ │ + return bounds │ │ │ │ }, │ │ │ │ - registerEvents: function() { │ │ │ │ - this.events = new OpenLayers.Events(this, this.div, null, true); │ │ │ │ - │ │ │ │ - function onTouchstart(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + initSingleTile: function(bounds) { │ │ │ │ + this.events.triggerEvent("retile"); │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var tileWidth = bounds.getWidth() * this.ratio; │ │ │ │ + var tileHeight = bounds.getHeight() * this.ratio; │ │ │ │ + var tileBounds = new OpenLayers.Bounds(center.lon - tileWidth / 2, center.lat - tileHeight / 2, center.lon + tileWidth / 2, center.lat + tileHeight / 2); │ │ │ │ + var px = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: tileBounds.left, │ │ │ │ + lat: tileBounds.top │ │ │ │ + }); │ │ │ │ + if (!this.grid.length) { │ │ │ │ + this.grid[0] = [] │ │ │ │ } │ │ │ │ - this.events.on({ │ │ │ │ - mousedown: this.onmousedown, │ │ │ │ - mousemove: this.onmousemove, │ │ │ │ - mouseup: this.onmouseup, │ │ │ │ - click: this.onclick, │ │ │ │ - mouseout: this.onmouseout, │ │ │ │ - dblclick: this.ondblclick, │ │ │ │ - touchstart: onTouchstart, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + var tile = this.grid[0][0]; │ │ │ │ + if (!tile) { │ │ │ │ + tile = this.addTile(tileBounds, px); │ │ │ │ + this.addTileMonitoringHooks(tile); │ │ │ │ + tile.draw(); │ │ │ │ + this.grid[0][0] = tile │ │ │ │ + } else { │ │ │ │ + tile.moveTo(tileBounds, px) │ │ │ │ + } │ │ │ │ + this.removeExcessTiles(1, 1); │ │ │ │ + this.gridResolution = this.getServerResolution() │ │ │ │ }, │ │ │ │ - onmousedown: function(evt) { │ │ │ │ - this.mousedown = true; │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ + var tilelon = resolution * this.tileSize.w; │ │ │ │ + var tilelat = resolution * this.tileSize.h; │ │ │ │ + var offsetlon = bounds.left - origin.lon; │ │ │ │ + var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ + var rowSign = this.rowSign; │ │ │ │ + var offsetlat = rowSign * (origin.lat - bounds.top + tilelat); │ │ │ │ + var tilerow = Math[~rowSign ? "floor" : "ceil"](offsetlat / tilelat) - this.buffer * rowSign; │ │ │ │ + return { │ │ │ │ + tilelon: tilelon, │ │ │ │ + tilelat: tilelat, │ │ │ │ + startcol: tilecol, │ │ │ │ + startrow: tilerow │ │ │ │ + } │ │ │ │ }, │ │ │ │ - onmousemove: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + getTileOrigin: function() { │ │ │ │ + var origin = this.tileOrigin; │ │ │ │ + if (!origin) { │ │ │ │ + var extent = this.getMaxExtent(); │ │ │ │ + var edges = { │ │ │ │ + tl: ["left", "top"], │ │ │ │ + tr: ["right", "top"], │ │ │ │ + bl: ["left", "bottom"], │ │ │ │ + br: ["right", "bottom"] │ │ │ │ + } [this.tileOriginCorner]; │ │ │ │ + origin = new OpenLayers.LonLat(extent[edges[0]], extent[edges[1]]) │ │ │ │ } │ │ │ │ + return origin │ │ │ │ }, │ │ │ │ - onmouseup: function(evt) { │ │ │ │ - if (this.mousedown) { │ │ │ │ - this.mousedown = false; │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + getTileBoundsForGridIndex: function(row, col) { │ │ │ │ + var origin = this.getTileOrigin(); │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + var tilelon = tileLayout.tilelon; │ │ │ │ + var tilelat = tileLayout.tilelat; │ │ │ │ + var startcol = tileLayout.startcol; │ │ │ │ + var startrow = tileLayout.startrow; │ │ │ │ + var rowSign = this.rowSign; │ │ │ │ + return new OpenLayers.Bounds(origin.lon + (startcol + col) * tilelon, origin.lat - (startrow + row * rowSign) * tilelat * rowSign, origin.lon + (startcol + col + 1) * tilelon, origin.lat - (startrow + (row - 1) * rowSign) * tilelat * rowSign) │ │ │ │ + }, │ │ │ │ + initGriddedTiles: function(bounds) { │ │ │ │ + this.events.triggerEvent("retile"); │ │ │ │ + var viewSize = this.map.getSize(); │ │ │ │ + var origin = this.getTileOrigin(); │ │ │ │ + var resolution = this.map.getResolution(), │ │ │ │ + serverResolution = this.getServerResolution(), │ │ │ │ + ratio = resolution / serverResolution, │ │ │ │ + tileSize = { │ │ │ │ + w: this.tileSize.w / ratio, │ │ │ │ + h: this.tileSize.h / ratio │ │ │ │ + }; │ │ │ │ + var minRows = Math.ceil(viewSize.h / tileSize.h) + 2 * this.buffer + 1; │ │ │ │ + var minCols = Math.ceil(viewSize.w / tileSize.w) + 2 * this.buffer + 1; │ │ │ │ + var tileLayout = this.calculateGridLayout(bounds, origin, serverResolution); │ │ │ │ + this.gridLayout = tileLayout; │ │ │ │ + var tilelon = tileLayout.tilelon; │ │ │ │ + var tilelat = tileLayout.tilelat; │ │ │ │ + var layerContainerDivLeft = this.map.layerContainerOriginPx.x; │ │ │ │ + var layerContainerDivTop = this.map.layerContainerOriginPx.y; │ │ │ │ + var tileBounds = this.getTileBoundsForGridIndex(0, 0); │ │ │ │ + var startPx = this.map.getViewPortPxFromLonLat(new OpenLayers.LonLat(tileBounds.left, tileBounds.top)); │ │ │ │ + startPx.x = Math.round(startPx.x) - layerContainerDivLeft; │ │ │ │ + startPx.y = Math.round(startPx.y) - layerContainerDivTop; │ │ │ │ + var tileData = [], │ │ │ │ + center = this.map.getCenter(); │ │ │ │ + var rowidx = 0; │ │ │ │ + do { │ │ │ │ + var row = this.grid[rowidx]; │ │ │ │ + if (!row) { │ │ │ │ + row = []; │ │ │ │ + this.grid.push(row) │ │ │ │ + } │ │ │ │ + var colidx = 0; │ │ │ │ + do { │ │ │ │ + tileBounds = this.getTileBoundsForGridIndex(rowidx, colidx); │ │ │ │ + var px = startPx.clone(); │ │ │ │ + px.x = px.x + colidx * Math.round(tileSize.w); │ │ │ │ + px.y = px.y + rowidx * Math.round(tileSize.h); │ │ │ │ + var tile = row[colidx]; │ │ │ │ + if (!tile) { │ │ │ │ + tile = this.addTile(tileBounds, px); │ │ │ │ + this.addTileMonitoringHooks(tile); │ │ │ │ + row.push(tile) │ │ │ │ + } else { │ │ │ │ + tile.moveTo(tileBounds, px, false) │ │ │ │ + } │ │ │ │ + var tileCenter = tileBounds.getCenterLonLat(); │ │ │ │ + tileData.push({ │ │ │ │ + tile: tile, │ │ │ │ + distance: Math.pow(tileCenter.lon - center.lon, 2) + Math.pow(tileCenter.lat - center.lat, 2) │ │ │ │ + }); │ │ │ │ + colidx += 1 │ │ │ │ + } while (tileBounds.right <= bounds.right + tilelon * this.buffer || colidx < minCols); │ │ │ │ + rowidx += 1 │ │ │ │ + } while (tileBounds.bottom >= bounds.bottom - tilelat * this.buffer || rowidx < minRows); │ │ │ │ + this.removeExcessTiles(rowidx, colidx); │ │ │ │ + var resolution = this.getServerResolution(); │ │ │ │ + this.gridResolution = resolution; │ │ │ │ + tileData.sort(function(a, b) { │ │ │ │ + return a.distance - b.distance │ │ │ │ + }); │ │ │ │ + for (var i = 0, ii = tileData.length; i < ii; ++i) { │ │ │ │ + tileData[i].tile.draw() │ │ │ │ } │ │ │ │ }, │ │ │ │ - onclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + getMaxExtent: function() { │ │ │ │ + return this.maxExtent │ │ │ │ }, │ │ │ │ - onmouseout: function(evt) { │ │ │ │ - this.mousedown = false │ │ │ │ + addTile: function(bounds, position) { │ │ │ │ + var tile = new this.tileClass(this, position, bounds, null, this.tileSize, this.tileOptions); │ │ │ │ + this.events.triggerEvent("addtile", { │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + return tile │ │ │ │ }, │ │ │ │ - ondblclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt, true) │ │ │ │ + addTileMonitoringHooks: function(tile) { │ │ │ │ + var replacingCls = "olTileReplacing"; │ │ │ │ + tile.onLoadStart = function() { │ │ │ │ + if (this.loading === false) { │ │ │ │ + this.loading = true; │ │ │ │ + this.events.triggerEvent("loadstart") │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("tileloadstart", { │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + this.numLoadingTiles++; │ │ │ │ + if (!this.singleTile && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ + OpenLayers.Element.addClass(tile.getTile(), replacingCls) │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + tile.onLoadEnd = function(evt) { │ │ │ │ + this.numLoadingTiles--; │ │ │ │ + var aborted = evt.type === "unload"; │ │ │ │ + this.events.triggerEvent("tileloaded", { │ │ │ │ + tile: tile, │ │ │ │ + aborted: aborted │ │ │ │ + }); │ │ │ │ + if (!this.singleTile && !aborted && this.backBuffer && this.gridResolution === this.backBufferResolution) { │ │ │ │ + var tileDiv = tile.getTile(); │ │ │ │ + if (OpenLayers.Element.getStyle(tileDiv, "display") === "none") { │ │ │ │ + var bufferTile = document.getElementById(tile.id + "_bb"); │ │ │ │ + if (bufferTile) { │ │ │ │ + bufferTile.parentNode.removeChild(bufferTile) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Element.removeClass(tileDiv, replacingCls) │ │ │ │ + } │ │ │ │ + if (this.numLoadingTiles === 0) { │ │ │ │ + if (this.backBuffer) { │ │ │ │ + if (this.backBuffer.childNodes.length === 0) { │ │ │ │ + this.removeBackBuffer() │ │ │ │ + } else { │ │ │ │ + this._transitionElement = aborted ? this.div.lastChild : tile.imgDiv; │ │ │ │ + var transitionendEvents = this.transitionendEvents; │ │ │ │ + for (var i = transitionendEvents.length - 1; i >= 0; --i) { │ │ │ │ + OpenLayers.Event.observe(this._transitionElement, transitionendEvents[i], this._removeBackBuffer) │ │ │ │ + } │ │ │ │ + this.backBufferTimerId = window.setTimeout(this._removeBackBuffer, this.removeBackBufferDelay) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.loading = false; │ │ │ │ + this.events.triggerEvent("loadend") │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + tile.onLoadError = function() { │ │ │ │ + this.events.triggerEvent("tileerror", { │ │ │ │ + tile: tile │ │ │ │ + }) │ │ │ │ + }; │ │ │ │ + tile.events.on({ │ │ │ │ + loadstart: tile.onLoadStart, │ │ │ │ + loadend: tile.onLoadEnd, │ │ │ │ + unload: tile.onLoadEnd, │ │ │ │ + loaderror: tile.onLoadError, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - 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.Kinetic = OpenLayers.Class({ │ │ │ │ - threshold: 0, │ │ │ │ - deceleration: .0035, │ │ │ │ - nbPoints: 100, │ │ │ │ - delay: 200, │ │ │ │ - points: undefined, │ │ │ │ - timerId: undefined, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Util.extend(this, options) │ │ │ │ + removeTileMonitoringHooks: function(tile) { │ │ │ │ + tile.unload(); │ │ │ │ + tile.events.un({ │ │ │ │ + loadstart: tile.onLoadStart, │ │ │ │ + loadend: tile.onLoadEnd, │ │ │ │ + unload: tile.onLoadEnd, │ │ │ │ + loaderror: tile.onLoadError, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - begin: function() { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = undefined; │ │ │ │ - this.points = [] │ │ │ │ + moveGriddedTiles: function() { │ │ │ │ + var buffer = this.buffer + 1; │ │ │ │ + while (true) { │ │ │ │ + var tlTile = this.grid[0][0]; │ │ │ │ + var tlViewPort = { │ │ │ │ + x: tlTile.position.x + this.map.layerContainerOriginPx.x, │ │ │ │ + y: tlTile.position.y + this.map.layerContainerOriginPx.y │ │ │ │ + }; │ │ │ │ + var ratio = this.getServerResolution() / this.map.getResolution(); │ │ │ │ + var tileSize = { │ │ │ │ + w: Math.round(this.tileSize.w * ratio), │ │ │ │ + h: Math.round(this.tileSize.h * ratio) │ │ │ │ + }; │ │ │ │ + if (tlViewPort.x > -tileSize.w * (buffer - 1)) { │ │ │ │ + this.shiftColumn(true, tileSize) │ │ │ │ + } else if (tlViewPort.x < -tileSize.w * buffer) { │ │ │ │ + this.shiftColumn(false, tileSize) │ │ │ │ + } else if (tlViewPort.y > -tileSize.h * (buffer - 1)) { │ │ │ │ + this.shiftRow(true, tileSize) │ │ │ │ + } else if (tlViewPort.y < -tileSize.h * buffer) { │ │ │ │ + this.shiftRow(false, tileSize) │ │ │ │ + } else { │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - update: function(xy) { │ │ │ │ - this.points.unshift({ │ │ │ │ - xy: xy, │ │ │ │ - tick: (new Date).getTime() │ │ │ │ - }); │ │ │ │ - if (this.points.length > this.nbPoints) { │ │ │ │ - this.points.pop() │ │ │ │ + shiftRow: function(prepend, tileSize) { │ │ │ │ + var grid = this.grid; │ │ │ │ + var rowIndex = prepend ? 0 : grid.length - 1; │ │ │ │ + var sign = prepend ? -1 : 1; │ │ │ │ + var rowSign = this.rowSign; │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + tileLayout.startrow += sign * rowSign; │ │ │ │ + var modelRow = grid[rowIndex]; │ │ │ │ + var row = grid[prepend ? "pop" : "shift"](); │ │ │ │ + for (var i = 0, len = row.length; i < len; i++) { │ │ │ │ + var tile = row[i]; │ │ │ │ + var position = modelRow[i].position.clone(); │ │ │ │ + position.y += tileSize.h * sign; │ │ │ │ + tile.moveTo(this.getTileBoundsForGridIndex(rowIndex, i), position) │ │ │ │ } │ │ │ │ + grid[prepend ? "unshift" : "push"](row) │ │ │ │ }, │ │ │ │ - end: function(xy) { │ │ │ │ - var last, now = (new Date).getTime(); │ │ │ │ - for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ - point = this.points[i]; │ │ │ │ - if (now - point.tick > this.delay) { │ │ │ │ - break │ │ │ │ + shiftColumn: function(prepend, tileSize) { │ │ │ │ + var grid = this.grid; │ │ │ │ + var colIndex = prepend ? 0 : grid[0].length - 1; │ │ │ │ + var sign = prepend ? -1 : 1; │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + tileLayout.startcol += sign; │ │ │ │ + for (var i = 0, len = grid.length; i < len; i++) { │ │ │ │ + var row = grid[i]; │ │ │ │ + var position = row[colIndex].position.clone(); │ │ │ │ + var tile = row[prepend ? "pop" : "shift"](); │ │ │ │ + position.x += tileSize.w * sign; │ │ │ │ + tile.moveTo(this.getTileBoundsForGridIndex(i, colIndex), position); │ │ │ │ + row[prepend ? "unshift" : "push"](tile) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + removeExcessTiles: function(rows, columns) { │ │ │ │ + var i, l; │ │ │ │ + while (this.grid.length > rows) { │ │ │ │ + var row = this.grid.pop(); │ │ │ │ + for (i = 0, l = row.length; i < l; i++) { │ │ │ │ + var tile = row[i]; │ │ │ │ + this.destroyTile(tile) │ │ │ │ } │ │ │ │ - last = point │ │ │ │ } │ │ │ │ - if (!last) { │ │ │ │ + for (i = 0, l = this.grid.length; i < l; i++) { │ │ │ │ + while (this.grid[i].length > columns) { │ │ │ │ + var row = this.grid[i]; │ │ │ │ + var tile = row.pop(); │ │ │ │ + this.destroyTile(tile) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + onMapResize: function() { │ │ │ │ + if (this.singleTile) { │ │ │ │ + this.clearGrid(); │ │ │ │ + this.setTileSize() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getTileBounds: function(viewPortPx) { │ │ │ │ + var maxExtent = this.maxExtent; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ + var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ + var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ + var tileLeft = maxExtent.left + tileMapWidth * Math.floor((mapPoint.lon - maxExtent.left) / tileMapWidth); │ │ │ │ + var tileBottom = maxExtent.bottom + tileMapHeight * Math.floor((mapPoint.lat - maxExtent.bottom) / tileMapHeight); │ │ │ │ + return new OpenLayers.Bounds(tileLeft, tileBottom, tileLeft + tileMapWidth, tileBottom + tileMapHeight) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Grid" │ │ │ │ +}); │ │ │ │ +OpenLayers.TileManager = OpenLayers.Class({ │ │ │ │ + cacheSize: 256, │ │ │ │ + tilesPerFrame: 2, │ │ │ │ + frameDelay: 16, │ │ │ │ + moveDelay: 100, │ │ │ │ + zoomDelay: 200, │ │ │ │ + maps: null, │ │ │ │ + tileQueueId: null, │ │ │ │ + tileQueue: null, │ │ │ │ + tileCache: null, │ │ │ │ + tileCacheIndex: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + this.maps = []; │ │ │ │ + this.tileQueueId = {}; │ │ │ │ + this.tileQueue = {}; │ │ │ │ + this.tileCache = {}; │ │ │ │ + this.tileCacheIndex = [] │ │ │ │ + }, │ │ │ │ + addMap: function(map) { │ │ │ │ + if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ return │ │ │ │ } │ │ │ │ - var time = (new Date).getTime() - last.tick; │ │ │ │ - var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ - var speed = dist / time; │ │ │ │ - if (speed == 0 || speed < this.threshold) { │ │ │ │ + this.maps.push(map); │ │ │ │ + this.tileQueue[map.id] = []; │ │ │ │ + for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ + this.addLayer({ │ │ │ │ + layer: map.layers[i] │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + map.events.on({ │ │ │ │ + move: this.move, │ │ │ │ + zoomend: this.zoomEnd, │ │ │ │ + changelayer: this.changeLayer, │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + preremovelayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + removeMap: function(map) { │ │ │ │ + if (this._destroyed || !OpenLayers.Layer.Grid) { │ │ │ │ return │ │ │ │ } │ │ │ │ - var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ - if (last.xy.x <= xy.x) { │ │ │ │ - theta = Math.PI - theta │ │ │ │ + window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ + if (map.layers) { │ │ │ │ + for (var i = 0, ii = map.layers.length; i < ii; ++i) { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: map.layers[i] │ │ │ │ + }) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return { │ │ │ │ - speed: speed, │ │ │ │ - theta: theta │ │ │ │ + if (map.events) { │ │ │ │ + map.events.un({ │ │ │ │ + move: this.move, │ │ │ │ + zoomend: this.zoomEnd, │ │ │ │ + changelayer: this.changeLayer, │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + preremovelayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ + delete this.tileQueue[map.id]; │ │ │ │ + delete this.tileQueueId[map.id]; │ │ │ │ + OpenLayers.Util.removeItem(this.maps, map) │ │ │ │ }, │ │ │ │ - move: function(info, callback) { │ │ │ │ - var v0 = info.speed; │ │ │ │ - var fx = Math.cos(info.theta); │ │ │ │ - var fy = -Math.sin(info.theta); │ │ │ │ - var initialTime = (new Date).getTime(); │ │ │ │ - var lastX = 0; │ │ │ │ - var lastY = 0; │ │ │ │ - var timerCallback = function() { │ │ │ │ - if (this.timerId == null) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var t = (new Date).getTime() - initialTime; │ │ │ │ - var p = -this.deceleration * Math.pow(t, 2) / 2 + v0 * t; │ │ │ │ - var x = p * fx; │ │ │ │ - var y = p * fy; │ │ │ │ - var args = {}; │ │ │ │ - args.end = false; │ │ │ │ - var v = -this.deceleration * t + v0; │ │ │ │ - if (v <= 0) { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - args.end = true │ │ │ │ - } │ │ │ │ - args.x = x - lastX; │ │ │ │ - args.y = y - lastY; │ │ │ │ - lastX = x; │ │ │ │ - lastY = y; │ │ │ │ - callback(args.x, args.y, args.end) │ │ │ │ - }; │ │ │ │ - this.timerId = OpenLayers.Animation.start(OpenLayers.Function.bind(timerCallback, this)) │ │ │ │ + move: function(evt) { │ │ │ │ + this.updateTimeout(evt.object, this.moveDelay, true) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.Markers = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ - isBaseLayer: false, │ │ │ │ - markers: null, │ │ │ │ - drawn: false, │ │ │ │ - initialize: function(name, options) { │ │ │ │ - OpenLayers.Layer.prototype.initialize.apply(this, arguments); │ │ │ │ - this.markers = [] │ │ │ │ + zoomEnd: function(evt) { │ │ │ │ + this.updateTimeout(evt.object, this.zoomDelay) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.clearMarkers(); │ │ │ │ - this.markers = null; │ │ │ │ - OpenLayers.Layer.prototype.destroy.apply(this, arguments) │ │ │ │ + changeLayer: function(evt) { │ │ │ │ + if (evt.property === "visibility" || evt.property === "params") { │ │ │ │ + this.updateTimeout(evt.object, 0) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - setOpacity: function(opacity) { │ │ │ │ - if (opacity != this.opacity) { │ │ │ │ - this.opacity = opacity; │ │ │ │ - for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ - this.markers[i].setOpacity(this.opacity) │ │ │ │ + addLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ + layer.events.on({ │ │ │ │ + addtile: this.addTile, │ │ │ │ + retile: this.clearTileQueue, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + var i, j, tile; │ │ │ │ + for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ + for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ + tile = layer.grid[i][j]; │ │ │ │ + this.addTile({ │ │ │ │ + tile: tile │ │ │ │ + }); │ │ │ │ + if (tile.url && !tile.imgDiv) { │ │ │ │ + this.manageTileCache({ │ │ │ │ + object: tile │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ - OpenLayers.Layer.prototype.moveTo.apply(this, arguments); │ │ │ │ - if (zoomChanged || !this.drawn) { │ │ │ │ - for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ - this.drawMarker(this.markers[i]) │ │ │ │ + removeLayer: function(evt) { │ │ │ │ + var layer = evt.layer; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Grid) { │ │ │ │ + this.clearTileQueue({ │ │ │ │ + object: layer │ │ │ │ + }); │ │ │ │ + if (layer.events) { │ │ │ │ + layer.events.un({ │ │ │ │ + addtile: this.addTile, │ │ │ │ + retile: this.clearTileQueue, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (layer.grid) { │ │ │ │ + var i, j, tile; │ │ │ │ + for (i = layer.grid.length - 1; i >= 0; --i) { │ │ │ │ + for (j = layer.grid[i].length - 1; j >= 0; --j) { │ │ │ │ + tile = layer.grid[i][j]; │ │ │ │ + this.unloadTile({ │ │ │ │ + object: tile │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.drawn = true │ │ │ │ } │ │ │ │ }, │ │ │ │ - addMarker: function(marker) { │ │ │ │ - this.markers.push(marker); │ │ │ │ - if (this.opacity < 1) { │ │ │ │ - marker.setOpacity(this.opacity) │ │ │ │ + updateTimeout: function(map, delay, nice) { │ │ │ │ + window.clearTimeout(this.tileQueueId[map.id]); │ │ │ │ + var tileQueue = this.tileQueue[map.id]; │ │ │ │ + if (!nice || tileQueue.length) { │ │ │ │ + this.tileQueueId[map.id] = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ + this.drawTilesFromQueue(map); │ │ │ │ + if (tileQueue.length) { │ │ │ │ + this.updateTimeout(map, this.frameDelay) │ │ │ │ + } │ │ │ │ + }, this), delay) │ │ │ │ } │ │ │ │ - if (this.map && this.map.getExtent()) { │ │ │ │ - marker.map = this.map; │ │ │ │ - this.drawMarker(marker) │ │ │ │ + }, │ │ │ │ + addTile: function(evt) { │ │ │ │ + if (evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ + evt.tile.events.on({ │ │ │ │ + beforedraw: this.queueTileDraw, │ │ │ │ + beforeload: this.manageTileCache, │ │ │ │ + loadend: this.addToCache, │ │ │ │ + unload: this.unloadTile, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: evt.tile.layer │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - removeMarker: function(marker) { │ │ │ │ - if (this.markers && this.markers.length) { │ │ │ │ - OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ - marker.erase() │ │ │ │ + unloadTile: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + tile.events.un({ │ │ │ │ + beforedraw: this.queueTileDraw, │ │ │ │ + beforeload: this.manageTileCache, │ │ │ │ + loadend: this.addToCache, │ │ │ │ + unload: this.unloadTile, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + OpenLayers.Util.removeItem(this.tileQueue[tile.layer.map.id], tile) │ │ │ │ + }, │ │ │ │ + queueTileDraw: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + var queued = false; │ │ │ │ + var layer = tile.layer; │ │ │ │ + var url = layer.getURL(tile.bounds); │ │ │ │ + var img = this.tileCache[url]; │ │ │ │ + if (img && img.className !== "olTileImage") { │ │ │ │ + delete this.tileCache[url]; │ │ │ │ + OpenLayers.Util.removeItem(this.tileCacheIndex, url); │ │ │ │ + img = null │ │ │ │ + } │ │ │ │ + if (layer.url && (layer.async || !img)) { │ │ │ │ + var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ + if (!~OpenLayers.Util.indexOf(tileQueue, tile)) { │ │ │ │ + tileQueue.push(tile) │ │ │ │ + } │ │ │ │ + queued = true │ │ │ │ } │ │ │ │ + return !queued │ │ │ │ }, │ │ │ │ - clearMarkers: function() { │ │ │ │ - if (this.markers != null) { │ │ │ │ - while (this.markers.length > 0) { │ │ │ │ - this.removeMarker(this.markers[0]) │ │ │ │ + drawTilesFromQueue: function(map) { │ │ │ │ + var tileQueue = this.tileQueue[map.id]; │ │ │ │ + var limit = this.tilesPerFrame; │ │ │ │ + var animating = map.zoomTween && map.zoomTween.playing; │ │ │ │ + while (!animating && tileQueue.length && limit) { │ │ │ │ + tileQueue.shift().draw(true); │ │ │ │ + --limit │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + manageTileCache: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + var img = this.tileCache[tile.url]; │ │ │ │ + if (img) { │ │ │ │ + if (img.parentNode && OpenLayers.Element.hasClass(img.parentNode, "olBackBuffer")) { │ │ │ │ + img.parentNode.removeChild(img); │ │ │ │ + img.id = null │ │ │ │ + } │ │ │ │ + if (!img.parentNode) { │ │ │ │ + img.style.visibility = "hidden"; │ │ │ │ + img.style.opacity = 0; │ │ │ │ + tile.setImage(img); │ │ │ │ + OpenLayers.Util.removeItem(this.tileCacheIndex, tile.url); │ │ │ │ + this.tileCacheIndex.push(tile.url) │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - drawMarker: function(marker) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(marker.lonlat); │ │ │ │ - if (px == null) { │ │ │ │ - marker.display(false) │ │ │ │ - } else { │ │ │ │ - if (!marker.isDrawn()) { │ │ │ │ - var markerImg = marker.draw(px); │ │ │ │ - this.div.appendChild(markerImg) │ │ │ │ - } else if (marker.icon) { │ │ │ │ - marker.icon.moveTo(px) │ │ │ │ + addToCache: function(evt) { │ │ │ │ + var tile = evt.object; │ │ │ │ + if (!this.tileCache[tile.url]) { │ │ │ │ + if (!OpenLayers.Element.hasClass(tile.imgDiv, "olImageLoadError")) { │ │ │ │ + if (this.tileCacheIndex.length >= this.cacheSize) { │ │ │ │ + delete this.tileCache[this.tileCacheIndex[0]]; │ │ │ │ + this.tileCacheIndex.shift() │ │ │ │ + } │ │ │ │ + this.tileCache[tile.url] = tile.imgDiv; │ │ │ │ + this.tileCacheIndex.push(tile.url) │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - getDataExtent: function() { │ │ │ │ - var maxExtent = null; │ │ │ │ - if (this.markers && this.markers.length > 0) { │ │ │ │ - var maxExtent = new OpenLayers.Bounds; │ │ │ │ - for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ - var marker = this.markers[i]; │ │ │ │ - maxExtent.extend(marker.lonlat) │ │ │ │ + clearTileQueue: function(evt) { │ │ │ │ + var layer = evt.object; │ │ │ │ + var tileQueue = this.tileQueue[layer.map.id]; │ │ │ │ + for (var i = tileQueue.length - 1; i >= 0; --i) { │ │ │ │ + if (tileQueue[i].layer === layer) { │ │ │ │ + tileQueue.splice(i, 1) │ │ │ │ } │ │ │ │ } │ │ │ │ - return maxExtent │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Markers" │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.maps.length - 1; i >= 0; --i) { │ │ │ │ + this.removeMap(this.maps[i]) │ │ │ │ + } │ │ │ │ + this.maps = null; │ │ │ │ + this.tileQueue = null; │ │ │ │ + this.tileQueueId = null; │ │ │ │ + this.tileCache = null; │ │ │ │ + this.tileCacheIndex = null; │ │ │ │ + this._destroyed = true │ │ │ │ + } │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.GeoRSS = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ - location: null, │ │ │ │ +OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ features: null, │ │ │ │ - formatOptions: null, │ │ │ │ - selectedFeature: null, │ │ │ │ - icon: null, │ │ │ │ - popupSize: null, │ │ │ │ - useFeedTitle: true, │ │ │ │ - initialize: function(name, location, options) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.initialize.apply(this, [name, options]); │ │ │ │ - this.location = location; │ │ │ │ - this.features = [] │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ - this.clearFeatures(); │ │ │ │ - this.features = null │ │ │ │ - }, │ │ │ │ - loadRSS: function() { │ │ │ │ - if (!this.loaded) { │ │ │ │ - this.events.triggerEvent("loadstart"); │ │ │ │ - OpenLayers.Request.GET({ │ │ │ │ - url: this.location, │ │ │ │ - success: this.parseData, │ │ │ │ + length: 10, │ │ │ │ + num: null, │ │ │ │ + paging: false, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + beforefeaturesadded: this.cacheFeatures, │ │ │ │ scope: this │ │ │ │ - }); │ │ │ │ - this.loaded = true │ │ │ │ + }) │ │ │ │ } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ - if (this.visibility && !this.loaded) { │ │ │ │ - this.loadRSS() │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.layer.events.un({ │ │ │ │ + beforefeaturesadded: this.cacheFeatures, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - parseData: function(ajaxRequest) { │ │ │ │ - var doc = ajaxRequest.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read(ajaxRequest.responseText) │ │ │ │ + cacheFeatures: function(event) { │ │ │ │ + if (!this.paging) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.features = event.features; │ │ │ │ + this.pageNext(event) │ │ │ │ } │ │ │ │ - if (this.useFeedTitle) { │ │ │ │ - var name = null; │ │ │ │ - try { │ │ │ │ - name = doc.getElementsByTagNameNS("*", "title")[0].firstChild.nodeValue │ │ │ │ - } catch (e) { │ │ │ │ - try { │ │ │ │ - name = doc.getElementsByTagName("title")[0].firstChild.nodeValue │ │ │ │ - } catch (e) {} │ │ │ │ - } │ │ │ │ - if (name) { │ │ │ │ - this.setName(name) │ │ │ │ + }, │ │ │ │ + clearCache: function() { │ │ │ │ + if (this.features) { │ │ │ │ + for (var i = 0; i < this.features.length; ++i) { │ │ │ │ + this.features[i].destroy() │ │ │ │ } │ │ │ │ } │ │ │ │ - var options = {}; │ │ │ │ - OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ - if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ - options.externalProjection = this.projection; │ │ │ │ - options.internalProjection = this.map.getProjectionObject() │ │ │ │ + this.features = null; │ │ │ │ + this.num = null │ │ │ │ + }, │ │ │ │ + pageCount: function() { │ │ │ │ + var numFeatures = this.features ? this.features.length : 0; │ │ │ │ + return Math.ceil(numFeatures / this.length) │ │ │ │ + }, │ │ │ │ + pageNum: function() { │ │ │ │ + return this.num │ │ │ │ + }, │ │ │ │ + pageLength: function(newLength) { │ │ │ │ + if (newLength && newLength > 0) { │ │ │ │ + this.length = newLength │ │ │ │ } │ │ │ │ - var format = new OpenLayers.Format.GeoRSS(options); │ │ │ │ - var features = format.read(doc); │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - var data = {}; │ │ │ │ - var feature = features[i]; │ │ │ │ - if (!feature.geometry) { │ │ │ │ - continue │ │ │ │ - } │ │ │ │ - var title = feature.attributes.title ? feature.attributes.title : "Untitled"; │ │ │ │ - var description = feature.attributes.description ? feature.attributes.description : "No description."; │ │ │ │ - var link = feature.attributes.link ? feature.attributes.link : ""; │ │ │ │ - var location = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ - data.icon = this.icon == null ? OpenLayers.Marker.defaultIcon() : this.icon.clone(); │ │ │ │ - data.popupSize = this.popupSize ? this.popupSize.clone() : new OpenLayers.Size(250, 120); │ │ │ │ - if (title || description) { │ │ │ │ - data.title = title; │ │ │ │ - data.description = description; │ │ │ │ - var contentHTML = '<div class="olLayerGeoRSSClose">[x]</div>'; │ │ │ │ - contentHTML += '<div class="olLayerGeoRSSTitle">'; │ │ │ │ - if (link) { │ │ │ │ - contentHTML += '<a class="link" href="' + link + '" target="_blank">' │ │ │ │ - } │ │ │ │ - contentHTML += title; │ │ │ │ - if (link) { │ │ │ │ - contentHTML += "</a>" │ │ │ │ - } │ │ │ │ - contentHTML += "</div>"; │ │ │ │ - contentHTML += '<div style="" class="olLayerGeoRSSDescription">'; │ │ │ │ - contentHTML += description; │ │ │ │ - contentHTML += "</div>"; │ │ │ │ - data["popupContentHTML"] = contentHTML │ │ │ │ + return this.length │ │ │ │ + }, │ │ │ │ + pageNext: function(event) { │ │ │ │ + var changed = false; │ │ │ │ + if (this.features) { │ │ │ │ + if (this.num === null) { │ │ │ │ + this.num = -1 │ │ │ │ } │ │ │ │ - var feature = new OpenLayers.Feature(this, location, data); │ │ │ │ - this.features.push(feature); │ │ │ │ - var marker = feature.createMarker(); │ │ │ │ - marker.events.register("click", feature, this.markerClick); │ │ │ │ - this.addMarker(marker) │ │ │ │ + var start = (this.num + 1) * this.length; │ │ │ │ + changed = this.page(start, event) │ │ │ │ } │ │ │ │ - this.events.triggerEvent("loadend") │ │ │ │ + return changed │ │ │ │ }, │ │ │ │ - markerClick: function(evt) { │ │ │ │ - var sameMarkerClicked = this == this.layer.selectedFeature; │ │ │ │ - this.layer.selectedFeature = !sameMarkerClicked ? this : null; │ │ │ │ - for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ - this.layer.map.removePopup(this.layer.map.popups[i]) │ │ │ │ - } │ │ │ │ - if (!sameMarkerClicked) { │ │ │ │ - var popup = this.createPopup(); │ │ │ │ - OpenLayers.Event.observe(popup.div, "click", OpenLayers.Function.bind(function() { │ │ │ │ - for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ - this.layer.map.removePopup(this.layer.map.popups[i]) │ │ │ │ - } │ │ │ │ - }, this)); │ │ │ │ - this.layer.map.addPopup(popup) │ │ │ │ + pagePrevious: function() { │ │ │ │ + var changed = false; │ │ │ │ + if (this.features) { │ │ │ │ + if (this.num === null) { │ │ │ │ + this.num = this.pageCount() │ │ │ │ + } │ │ │ │ + var start = (this.num - 1) * this.length; │ │ │ │ + changed = this.page(start) │ │ │ │ } │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ + return changed │ │ │ │ }, │ │ │ │ - clearFeatures: function() { │ │ │ │ - if (this.features != null) { │ │ │ │ - while (this.features.length > 0) { │ │ │ │ - var feature = this.features[0]; │ │ │ │ - OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ - feature.destroy() │ │ │ │ + page: function(start, event) { │ │ │ │ + var changed = false; │ │ │ │ + if (this.features) { │ │ │ │ + if (start >= 0 && start < this.features.length) { │ │ │ │ + var num = Math.floor(start / this.length); │ │ │ │ + if (num != this.num) { │ │ │ │ + this.paging = true; │ │ │ │ + var features = this.features.slice(start, start + this.length); │ │ │ │ + this.layer.removeFeatures(this.layer.features); │ │ │ │ + this.num = num; │ │ │ │ + if (event && event.features) { │ │ │ │ + event.features = features │ │ │ │ + } else { │ │ │ │ + this.layer.addFeatures(features) │ │ │ │ + } │ │ │ │ + this.paging = false; │ │ │ │ + changed = true │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + return changed │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.GeoRSS" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Paging" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.XYZ = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - isBaseLayer: true, │ │ │ │ - sphericalMercator: false, │ │ │ │ - zoomOffset: 0, │ │ │ │ - serverResolutions: null, │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - if (options && options.sphericalMercator || this.sphericalMercator) { │ │ │ │ - options = OpenLayers.Util.extend({ │ │ │ │ - projection: "EPSG:900913", │ │ │ │ - numZoomLevels: 19 │ │ │ │ - }, options) │ │ │ │ +OpenLayers.Strategy.Refresh = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + force: false, │ │ │ │ + interval: 0, │ │ │ │ + timer: null, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (this.layer.visibility === true) { │ │ │ │ + this.start() │ │ │ │ + } │ │ │ │ + this.layer.events.on({ │ │ │ │ + visibilitychanged: this.reset, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name || this.name, url || this.url, {}, options]) │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.XYZ(this.name, this.url, this.getOptions()) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.stop(); │ │ │ │ + this.layer.events.un({ │ │ │ │ + visibilitychanged: this.reset, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - var xyz = this.getXYZ(bounds); │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - var s = "" + xyz.x + xyz.y + xyz.z; │ │ │ │ - url = this.selectUrl(s, url) │ │ │ │ + reset: function() { │ │ │ │ + if (this.layer.visibility === true) { │ │ │ │ + this.start() │ │ │ │ + } else { │ │ │ │ + this.stop() │ │ │ │ } │ │ │ │ - return OpenLayers.String.format(url, xyz) │ │ │ │ }, │ │ │ │ - getXYZ: function(bounds) { │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getServerZoom(); │ │ │ │ - if (this.wrapDateLine) { │ │ │ │ - var limit = Math.pow(2, z); │ │ │ │ - x = (x % limit + limit) % limit │ │ │ │ + start: function() { │ │ │ │ + if (this.interval && typeof this.interval === "number" && this.interval > 0) { │ │ │ │ + this.timer = window.setInterval(OpenLayers.Function.bind(this.refresh, this), this.interval) │ │ │ │ } │ │ │ │ - return { │ │ │ │ - x: x, │ │ │ │ - y: y, │ │ │ │ - z: z │ │ │ │ + }, │ │ │ │ + refresh: function() { │ │ │ │ + if (this.layer && this.layer.refresh && typeof this.layer.refresh == "function") { │ │ │ │ + this.layer.refresh({ │ │ │ │ + force: this.force │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ - if (!this.tileOrigin) { │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(this.maxExtent.left, this.maxExtent.bottom) │ │ │ │ + stop: function() { │ │ │ │ + if (this.timer !== null) { │ │ │ │ + window.clearInterval(this.timer); │ │ │ │ + this.timer = null │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Refresh" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - url: null, │ │ │ │ - tileOrigin: null, │ │ │ │ - tileSize: new OpenLayers.Size(256, 256), │ │ │ │ - useArcGISServer: true, │ │ │ │ - type: "png", │ │ │ │ - useScales: false, │ │ │ │ - overrideDPI: false, │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.resolutions) { │ │ │ │ - this.serverResolutions = this.resolutions; │ │ │ │ - this.maxExtent = this.getMaxExtentForResolution(this.resolutions[0]) │ │ │ │ +OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + preload: false, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + refresh: this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (this.layer.visibility == true || this.preload) { │ │ │ │ + this.load() │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + visibilitychanged: this.load, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.layerInfo) { │ │ │ │ - var info = this.layerInfo; │ │ │ │ - var startingTileExtent = new OpenLayers.Bounds(info.fullExtent.xmin, info.fullExtent.ymin, info.fullExtent.xmax, info.fullExtent.ymax); │ │ │ │ - this.projection = "EPSG:" + info.spatialReference.wkid; │ │ │ │ - this.sphericalMercator = info.spatialReference.wkid == 102100; │ │ │ │ - this.units = info.units == "esriFeet" ? "ft" : "m"; │ │ │ │ - if (!!info.tileInfo) { │ │ │ │ - this.tileSize = new OpenLayers.Size(info.tileInfo.width || info.tileInfo.cols, info.tileInfo.height || info.tileInfo.rows); │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(info.tileInfo.origin.x, info.tileInfo.origin.y); │ │ │ │ - var upperLeft = new OpenLayers.Geometry.Point(startingTileExtent.left, startingTileExtent.top); │ │ │ │ - var bottomRight = new OpenLayers.Geometry.Point(startingTileExtent.right, startingTileExtent.bottom); │ │ │ │ - if (this.useScales) { │ │ │ │ - this.scales = [] │ │ │ │ - } else { │ │ │ │ - this.resolutions = [] │ │ │ │ - } │ │ │ │ - this.lods = []; │ │ │ │ - for (var key in info.tileInfo.lods) { │ │ │ │ - if (info.tileInfo.lods.hasOwnProperty(key)) { │ │ │ │ - var lod = info.tileInfo.lods[key]; │ │ │ │ - if (this.useScales) { │ │ │ │ - this.scales.push(lod.scale) │ │ │ │ - } else { │ │ │ │ - this.resolutions.push(lod.resolution) │ │ │ │ - } │ │ │ │ - var start = this.getContainingTileCoords(upperLeft, lod.resolution); │ │ │ │ - lod.startTileCol = start.x; │ │ │ │ - lod.startTileRow = start.y; │ │ │ │ - var end = this.getContainingTileCoords(bottomRight, lod.resolution); │ │ │ │ - lod.endTileCol = end.x; │ │ │ │ - lod.endTileRow = end.y; │ │ │ │ - this.lods.push(lod) │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + refresh: this.load, │ │ │ │ + visibilitychanged: this.load, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + load: function(options) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.events.triggerEvent("loadstart", { │ │ │ │ + filter: layer.filter │ │ │ │ + }); │ │ │ │ + layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: this.merge, │ │ │ │ + filter: layer.filter, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ + layer.events.un({ │ │ │ │ + visibilitychanged: this.load, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + merge: function(resp) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.destroyFeatures(); │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = layer.projection; │ │ │ │ + var local = layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local) │ │ │ │ } │ │ │ │ } │ │ │ │ - this.maxExtent = this.calculateMaxExtentWithLOD(this.lods[0]); │ │ │ │ - this.serverResolutions = this.resolutions; │ │ │ │ - if (this.overrideDPI && info.tileInfo.dpi) { │ │ │ │ - OpenLayers.DOTS_PER_INCH = info.tileInfo.dpi │ │ │ │ - } │ │ │ │ } │ │ │ │ + layer.addFeatures(features) │ │ │ │ } │ │ │ │ + layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - getContainingTileCoords: function(point, res) { │ │ │ │ - return new OpenLayers.Pixel(Math.max(Math.floor((point.x - this.tileOrigin.lon) / (this.tileSize.w * res)), 0), Math.max(Math.floor((this.tileOrigin.lat - point.y) / (this.tileSize.h * res)), 0)) │ │ │ │ - }, │ │ │ │ - calculateMaxExtentWithLOD: function(lod) { │ │ │ │ - var numTileCols = lod.endTileCol - lod.startTileCol + 1; │ │ │ │ - var numTileRows = lod.endTileRow - lod.startTileRow + 1; │ │ │ │ - var minX = this.tileOrigin.lon + lod.startTileCol * this.tileSize.w * lod.resolution; │ │ │ │ - var maxX = minX + numTileCols * this.tileSize.w * lod.resolution; │ │ │ │ - var maxY = this.tileOrigin.lat - lod.startTileRow * this.tileSize.h * lod.resolution; │ │ │ │ - var minY = maxY - numTileRows * this.tileSize.h * lod.resolution; │ │ │ │ - return new OpenLayers.Bounds(minX, minY, maxX, maxY) │ │ │ │ - }, │ │ │ │ - calculateMaxExtentWithExtent: function(extent, res) { │ │ │ │ - var upperLeft = new OpenLayers.Geometry.Point(extent.left, extent.top); │ │ │ │ - var bottomRight = new OpenLayers.Geometry.Point(extent.right, extent.bottom); │ │ │ │ - var start = this.getContainingTileCoords(upperLeft, res); │ │ │ │ - var end = this.getContainingTileCoords(bottomRight, res); │ │ │ │ - var lod = { │ │ │ │ - resolution: res, │ │ │ │ - startTileCol: start.x, │ │ │ │ - startTileRow: start.y, │ │ │ │ - endTileCol: end.x, │ │ │ │ - endTileRow: end.y │ │ │ │ - }; │ │ │ │ - return this.calculateMaxExtentWithLOD(lod) │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ +}); │ │ │ │ +OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + bounds: null, │ │ │ │ + resolution: null, │ │ │ │ + ratio: 2, │ │ │ │ + resFactor: null, │ │ │ │ + response: null, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + moveend: this.update, │ │ │ │ + refresh: this.update, │ │ │ │ + visibilitychanged: this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.update() │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - getUpperLeftTileCoord: function(res) { │ │ │ │ - var upperLeft = new OpenLayers.Geometry.Point(this.maxExtent.left, this.maxExtent.top); │ │ │ │ - return this.getContainingTileCoords(upperLeft, res) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + moveend: this.update, │ │ │ │ + refresh: this.update, │ │ │ │ + visibilitychanged: this.update, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - getLowerRightTileCoord: function(res) { │ │ │ │ - var bottomRight = new OpenLayers.Geometry.Point(this.maxExtent.right, this.maxExtent.bottom); │ │ │ │ - return this.getContainingTileCoords(bottomRight, res) │ │ │ │ + update: function(options) { │ │ │ │ + var mapBounds = this.getMapBounds(); │ │ │ │ + if (mapBounds !== null && (options && options.force || this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds))) { │ │ │ │ + this.calculateBounds(mapBounds); │ │ │ │ + this.resolution = this.layer.map.getResolution(); │ │ │ │ + this.triggerRead(options) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - getMaxExtentForResolution: function(res) { │ │ │ │ - var start = this.getUpperLeftTileCoord(res); │ │ │ │ - var end = this.getLowerRightTileCoord(res); │ │ │ │ - var numTileCols = end.x - start.x + 1; │ │ │ │ - var numTileRows = end.y - start.y + 1; │ │ │ │ - var minX = this.tileOrigin.lon + start.x * this.tileSize.w * res; │ │ │ │ - var maxX = minX + numTileCols * this.tileSize.w * res; │ │ │ │ - var maxY = this.tileOrigin.lat - start.y * this.tileSize.h * res; │ │ │ │ - var minY = maxY - numTileRows * this.tileSize.h * res; │ │ │ │ - return new OpenLayers.Bounds(minX, minY, maxX, maxY) │ │ │ │ + getMapBounds: function() { │ │ │ │ + if (this.layer.map === null) { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ + var bounds = this.layer.map.getExtent(); │ │ │ │ + if (bounds && !this.layer.projection.equals(this.layer.map.getProjectionObject())) { │ │ │ │ + bounds = bounds.clone().transform(this.layer.map.getProjectionObject(), this.layer.projection) │ │ │ │ + } │ │ │ │ + return bounds │ │ │ │ }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.ArcGISCache(this.name, this.url, this.options) │ │ │ │ + invalidBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds() │ │ │ │ } │ │ │ │ - return OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]) │ │ │ │ + var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ + if (!invalid && this.resFactor) { │ │ │ │ + var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ + invalid = ratio >= this.resFactor || ratio <= 1 / this.resFactor │ │ │ │ + } │ │ │ │ + return invalid │ │ │ │ }, │ │ │ │ - initGriddedTiles: function(bounds) { │ │ │ │ - delete this._tileOrigin; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initGriddedTiles.apply(this, arguments) │ │ │ │ + calculateBounds: function(mapBounds) { │ │ │ │ + if (!mapBounds) { │ │ │ │ + mapBounds = this.getMapBounds() │ │ │ │ + } │ │ │ │ + var center = mapBounds.getCenterLonLat(); │ │ │ │ + var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ + var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ + this.bounds = new OpenLayers.Bounds(center.lon - dataWidth / 2, center.lat - dataHeight / 2, center.lon + dataWidth / 2, center.lat + dataHeight / 2) │ │ │ │ }, │ │ │ │ - getMaxExtent: function() { │ │ │ │ - var resolution = this.map.getResolution(); │ │ │ │ - return this.maxExtent = this.getMaxExtentForResolution(resolution) │ │ │ │ + triggerRead: function(options) { │ │ │ │ + if (this.response && !(options && options.noAbort === true)) { │ │ │ │ + this.layer.protocol.abort(this.response); │ │ │ │ + this.layer.events.triggerEvent("loadend") │ │ │ │ + } │ │ │ │ + var evt = { │ │ │ │ + filter: this.createFilter() │ │ │ │ + }; │ │ │ │ + this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ + this.response = this.layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + filter: evt.filter, │ │ │ │ + callback: this.merge, │ │ │ │ + scope: this │ │ │ │ + }, options)) │ │ │ │ }, │ │ │ │ - getTileOrigin: function() { │ │ │ │ - if (!this._tileOrigin) { │ │ │ │ - var extent = this.getMaxExtent(); │ │ │ │ - this._tileOrigin = new OpenLayers.LonLat(extent.left, extent.bottom) │ │ │ │ + createFilter: function() { │ │ │ │ + var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + value: this.bounds, │ │ │ │ + projection: this.layer.projection │ │ │ │ + }); │ │ │ │ + if (this.layer.filter) { │ │ │ │ + filter = new OpenLayers.Filter.Logical({ │ │ │ │ + type: OpenLayers.Filter.Logical.AND, │ │ │ │ + filters: [this.layer.filter, filter] │ │ │ │ + }) │ │ │ │ } │ │ │ │ - return this._tileOrigin │ │ │ │ + return filter │ │ │ │ }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - var res = this.getResolution(); │ │ │ │ - var originTileX = this.tileOrigin.lon + res * this.tileSize.w / 2; │ │ │ │ - var originTileY = this.tileOrigin.lat - res * this.tileSize.h / 2; │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var point = { │ │ │ │ - x: center.lon, │ │ │ │ - y: center.lat │ │ │ │ - }; │ │ │ │ - var x = Math.round(Math.abs((center.lon - originTileX) / (res * this.tileSize.w))); │ │ │ │ - var y = Math.round(Math.abs((originTileY - center.lat) / (res * this.tileSize.h))); │ │ │ │ - var z = this.map.getZoom(); │ │ │ │ - if (this.lods) { │ │ │ │ - var lod = this.lods[this.map.getZoom()]; │ │ │ │ - if (x < lod.startTileCol || x > lod.endTileCol || (y < lod.startTileRow || y > lod.endTileRow)) { │ │ │ │ - return null │ │ │ │ + merge: function(resp) { │ │ │ │ + this.layer.destroyFeatures(); │ │ │ │ + if (resp.success()) { │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = this.layer.projection; │ │ │ │ + var local = this.layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.addFeatures(features) │ │ │ │ } │ │ │ │ } else { │ │ │ │ - var start = this.getUpperLeftTileCoord(res); │ │ │ │ - var end = this.getLowerRightTileCoord(res); │ │ │ │ - if (x < start.x || x >= end.x || (y < start.y || y >= end.y)) { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ + this.bounds = null │ │ │ │ } │ │ │ │ - var url = this.url; │ │ │ │ - var s = "" + x + y + z; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(s, url) │ │ │ │ + this.response = null; │ │ │ │ + this.layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ +}); │ │ │ │ +OpenLayers.Strategy.Filter = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + filter: null, │ │ │ │ + cache: null, │ │ │ │ + caching: false, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.cache = []; │ │ │ │ + this.layer.events.on({ │ │ │ │ + beforefeaturesadded: this.handleAdd, │ │ │ │ + beforefeaturesremoved: this.handleRemove, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - if (this.useArcGISServer) { │ │ │ │ - url = url + "/tile/${z}/${y}/${x}" │ │ │ │ - } else { │ │ │ │ - x = "C" + OpenLayers.Number.zeroPad(x, 8, 16); │ │ │ │ - y = "R" + OpenLayers.Number.zeroPad(y, 8, 16); │ │ │ │ - z = "L" + OpenLayers.Number.zeroPad(z, 2, 10); │ │ │ │ - url = url + "/${z}/${y}/${x}." + this.type │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + this.cache = null; │ │ │ │ + if (this.layer && this.layer.events) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + beforefeaturesadded: this.handleAdd, │ │ │ │ + beforefeaturesremoved: this.handleRemove, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - url = OpenLayers.String.format(url, { │ │ │ │ - x: x, │ │ │ │ - y: y, │ │ │ │ - z: z │ │ │ │ + return OpenLayers.Strategy.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + handleAdd: function(event) { │ │ │ │ + if (!this.caching && this.filter) { │ │ │ │ + var features = event.features; │ │ │ │ + event.features = []; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0, ii = features.length; i < ii; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (this.filter.evaluate(feature)) { │ │ │ │ + event.features.push(feature) │ │ │ │ + } else { │ │ │ │ + this.cache.push(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + handleRemove: function(event) { │ │ │ │ + if (!this.caching) { │ │ │ │ + this.cache = [] │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setFilter: function(filter) { │ │ │ │ + this.filter = filter; │ │ │ │ + var previousCache = this.cache; │ │ │ │ + this.cache = []; │ │ │ │ + this.handleAdd({ │ │ │ │ + features: this.layer.features │ │ │ │ }); │ │ │ │ - return OpenLayers.Util.urlAppend(url, OpenLayers.Util.getParameterString(this.params)) │ │ │ │ + if (this.cache.length > 0) { │ │ │ │ + this.caching = true; │ │ │ │ + this.layer.removeFeatures(this.cache.slice()); │ │ │ │ + this.caching = false │ │ │ │ + } │ │ │ │ + if (previousCache.length > 0) { │ │ │ │ + var event = { │ │ │ │ + features: previousCache │ │ │ │ + }; │ │ │ │ + this.handleAdd(event); │ │ │ │ + if (event.features.length > 0) { │ │ │ │ + this.caching = true; │ │ │ │ + this.layer.addFeatures(event.features); │ │ │ │ + this.caching = false │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.ArcGISCache" │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Filter" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - key: null, │ │ │ │ - serverResolutions: [156543.03390625, 78271.516953125, 39135.7584765625, 19567.87923828125, 9783.939619140625, 4891.9698095703125, 2445.9849047851562, 1222.9924523925781, 611.4962261962891, 305.74811309814453, 152.87405654907226, 76.43702827453613, 38.218514137268066, 19.109257068634033, 9.554628534317017, 4.777314267158508, 2.388657133579254, 1.194328566789627, .5971642833948135, .29858214169740677, .14929107084870338, .07464553542435169], │ │ │ │ - attributionTemplate: '<span class="olBingAttribution ${type}">' + '<div><a target="_blank" href="http://www.bing.com/maps/">' + '<img src="${logo}" /></a></div>${copyrights}' + '<a style="white-space: nowrap" target="_blank" ' + 'href="http://www.microsoft.com/maps/product/terms.html">' + "Terms of Use</a></span>", │ │ │ │ - metadata: null, │ │ │ │ - protocolRegex: /^http:/i, │ │ │ │ - type: "Road", │ │ │ │ - culture: "en-US", │ │ │ │ - metadataParams: null, │ │ │ │ - tileOptions: null, │ │ │ │ - protocol: ~window.location.href.indexOf("http") ? "" : "http:", │ │ │ │ +OpenLayers.Strategy.Save = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + events: null, │ │ │ │ + auto: false, │ │ │ │ + timer: null, │ │ │ │ initialize: function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - sphericalMercator: true │ │ │ │ - }, options); │ │ │ │ - var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ - var newArgs = [name, null, options]; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: "anonymous" │ │ │ │ - }, this.options.tileOptions); │ │ │ │ - this.loadMetadata() │ │ │ │ + OpenLayers.Strategy.prototype.initialize.apply(this, [options]); │ │ │ │ + this.events = new OpenLayers.Events(this) │ │ │ │ }, │ │ │ │ - loadMetadata: function() { │ │ │ │ - this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ - window[this._callbackId] = OpenLayers.Function.bind(OpenLayers.Layer.Bing.processMetadata, this); │ │ │ │ - var params = OpenLayers.Util.applyDefaults({ │ │ │ │ - key: this.key, │ │ │ │ - jsonp: this._callbackId, │ │ │ │ - include: "ImageryProviders" │ │ │ │ - }, this.metadataParams); │ │ │ │ - var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = this._callbackId; │ │ │ │ - document.getElementsByTagName("head")[0].appendChild(script) │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (this.auto) { │ │ │ │ + if (typeof this.auto === "number") { │ │ │ │ + this.timer = window.setInterval(OpenLayers.Function.bind(this.save, this), this.auto * 1e3) │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + featureadded: this.triggerSave, │ │ │ │ + afterfeaturemodified: this.triggerSave, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - initLayer: function() { │ │ │ │ - var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ - var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ - url = url.replace("{culture}", this.culture); │ │ │ │ - url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.url = []; │ │ │ │ - for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ - this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + if (this.auto) { │ │ │ │ + if (typeof this.auto === "number") { │ │ │ │ + window.clearInterval(this.timer) │ │ │ │ + } else { │ │ │ │ + this.layer.events.un({ │ │ │ │ + featureadded: this.triggerSave, │ │ │ │ + afterfeaturemodified: this.triggerSave, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.addOptions({ │ │ │ │ - maxResolution: Math.min(this.serverResolutions[res.zoomMin], this.maxResolution || Number.POSITIVE_INFINITY), │ │ │ │ - numZoomLevels: Math.min(res.zoomMax + 1 - res.zoomMin, this.numZoomLevels) │ │ │ │ - }, true); │ │ │ │ - if (!this.isBaseLayer) { │ │ │ │ - this.redraw() │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + triggerSave: function(event) { │ │ │ │ + var feature = event.feature; │ │ │ │ + if (feature.state === OpenLayers.State.INSERT || feature.state === OpenLayers.State.UPDATE || feature.state === OpenLayers.State.DELETE) { │ │ │ │ + this.save([event.feature]) │ │ │ │ } │ │ │ │ - this.updateAttribution() │ │ │ │ }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - if (!this.url) { │ │ │ │ - return │ │ │ │ + save: function(features) { │ │ │ │ + if (!features) { │ │ │ │ + features = this.layer.features │ │ │ │ } │ │ │ │ - var xyz = this.getXYZ(bounds), │ │ │ │ - x = xyz.x, │ │ │ │ - y = xyz.y, │ │ │ │ - z = xyz.z; │ │ │ │ - var quadDigits = []; │ │ │ │ - for (var i = z; i > 0; --i) { │ │ │ │ - var digit = "0"; │ │ │ │ - var mask = 1 << i - 1; │ │ │ │ - if ((x & mask) != 0) { │ │ │ │ - digit++ │ │ │ │ - } │ │ │ │ - if ((y & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - digit++ │ │ │ │ + this.events.triggerEvent("start", { │ │ │ │ + features: features │ │ │ │ + }); │ │ │ │ + var remote = this.layer.projection; │ │ │ │ + var local = this.layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var len = features.length; │ │ │ │ + var clones = new Array(len); │ │ │ │ + var orig, clone; │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + orig = features[i]; │ │ │ │ + clone = orig.clone(); │ │ │ │ + clone.fid = orig.fid; │ │ │ │ + clone.state = orig.state; │ │ │ │ + if (orig.url) { │ │ │ │ + clone.url = orig.url │ │ │ │ + } │ │ │ │ + clone._original = orig; │ │ │ │ + clone.geometry.transform(local, remote); │ │ │ │ + clones[i] = clone │ │ │ │ } │ │ │ │ - quadDigits.push(digit) │ │ │ │ + features = clones │ │ │ │ } │ │ │ │ - var quadKey = quadDigits.join(""); │ │ │ │ - var url = this.selectUrl("" + x + y + z, this.url); │ │ │ │ - return OpenLayers.String.format(url, { │ │ │ │ - quadkey: quadKey │ │ │ │ + this.layer.protocol.commit(features, { │ │ │ │ + callback: this.onCommit, │ │ │ │ + scope: this │ │ │ │ }) │ │ │ │ }, │ │ │ │ - updateAttribution: function() { │ │ │ │ - var metadata = this.metadata; │ │ │ │ - if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var res = metadata.resourceSets[0].resources[0]; │ │ │ │ - var extent = this.map.getExtent().transform(this.map.getProjectionObject(), new OpenLayers.Projection("EPSG:4326")); │ │ │ │ - var providers = res.imageryProviders || [], │ │ │ │ - zoom = OpenLayers.Util.indexOf(this.serverResolutions, this.getServerResolution()), │ │ │ │ - copyrights = "", │ │ │ │ - provider, i, ii, j, jj, bbox, coverage; │ │ │ │ - for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ - provider = providers[i]; │ │ │ │ - for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ - coverage = provider.coverageAreas[j]; │ │ │ │ - bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ - if (extent.intersectsBounds(bbox) && zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ - copyrights += provider.attribution + " " │ │ │ │ + onCommit: function(response) { │ │ │ │ + var evt = { │ │ │ │ + response: response │ │ │ │ + }; │ │ │ │ + if (response.success()) { │ │ │ │ + var features = response.reqFeatures; │ │ │ │ + var state, feature; │ │ │ │ + var destroys = []; │ │ │ │ + var insertIds = response.insertIds || []; │ │ │ │ + var j = 0; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + feature = feature._original || feature; │ │ │ │ + state = feature.state; │ │ │ │ + if (state) { │ │ │ │ + if (state == OpenLayers.State.DELETE) { │ │ │ │ + destroys.push(feature) │ │ │ │ + } else if (state == OpenLayers.State.INSERT) { │ │ │ │ + feature.fid = insertIds[j]; │ │ │ │ + ++j │ │ │ │ + } │ │ │ │ + feature.state = null │ │ │ │ } │ │ │ │ } │ │ │ │ + if (destroys.length > 0) { │ │ │ │ + this.layer.destroyFeatures(destroys) │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("success", evt) │ │ │ │ + } else { │ │ │ │ + this.events.triggerEvent("fail", evt) │ │ │ │ } │ │ │ │ - var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ - type: this.type.toLowerCase(), │ │ │ │ - logo: logo, │ │ │ │ - copyrights: copyrights │ │ │ │ - }); │ │ │ │ - this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "attribution" │ │ │ │ - }) │ │ │ │ }, │ │ │ │ - setMap: function() { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("moveend", this, this.updateAttribution) │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Save" │ │ │ │ +}); │ │ │ │ +OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ + distance: 20, │ │ │ │ + threshold: null, │ │ │ │ + features: null, │ │ │ │ + clusters: null, │ │ │ │ + clustering: false, │ │ │ │ + resolution: null, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + beforefeaturesadded: this.cacheFeatures, │ │ │ │ + featuresremoved: this.clearCache, │ │ │ │ + moveend: this.cluster, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Bing(this.options) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.layer.events.un({ │ │ │ │ + beforefeaturesadded: this.cacheFeatures, │ │ │ │ + featuresremoved: this.clearCache, │ │ │ │ + moveend: this.cluster, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.map && this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ - OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments) │ │ │ │ + cacheFeatures: function(event) { │ │ │ │ + var propagate = true; │ │ │ │ + if (!this.clustering) { │ │ │ │ + this.clearCache(); │ │ │ │ + this.features = event.features; │ │ │ │ + this.cluster(); │ │ │ │ + propagate = false │ │ │ │ + } │ │ │ │ + return propagate │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ + clearCache: function() { │ │ │ │ + if (!this.clustering) { │ │ │ │ + this.features = null │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + cluster: function(event) { │ │ │ │ + if ((!event || event.zoomChanged) && this.features) { │ │ │ │ + var resolution = this.layer.map.getResolution(); │ │ │ │ + if (resolution != this.resolution || !this.clustersExist()) { │ │ │ │ + this.resolution = resolution; │ │ │ │ + var clusters = []; │ │ │ │ + var feature, clustered, cluster; │ │ │ │ + for (var i = 0; i < this.features.length; ++i) { │ │ │ │ + feature = this.features[i]; │ │ │ │ + if (feature.geometry) { │ │ │ │ + clustered = false; │ │ │ │ + for (var j = clusters.length - 1; j >= 0; --j) { │ │ │ │ + cluster = clusters[j]; │ │ │ │ + if (this.shouldCluster(cluster, feature)) { │ │ │ │ + this.addToCluster(cluster, feature); │ │ │ │ + clustered = true; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (!clustered) { │ │ │ │ + clusters.push(this.createCluster(this.features[i])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.clustering = true; │ │ │ │ + this.layer.removeAllFeatures(); │ │ │ │ + this.clustering = false; │ │ │ │ + if (clusters.length > 0) { │ │ │ │ + if (this.threshold > 1) { │ │ │ │ + var clone = clusters.slice(); │ │ │ │ + clusters = []; │ │ │ │ + var candidate; │ │ │ │ + for (var i = 0, len = clone.length; i < len; ++i) { │ │ │ │ + candidate = clone[i]; │ │ │ │ + if (candidate.attributes.count < this.threshold) { │ │ │ │ + Array.prototype.push.apply(clusters, candidate.cluster) │ │ │ │ + } else { │ │ │ │ + clusters.push(candidate) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.clustering = true; │ │ │ │ + this.layer.addFeatures(clusters); │ │ │ │ + this.clustering = false │ │ │ │ + } │ │ │ │ + this.clusters = clusters │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clustersExist: function() { │ │ │ │ + var exist = false; │ │ │ │ + if (this.clusters && this.clusters.length > 0 && this.clusters.length == this.layer.features.length) { │ │ │ │ + exist = true; │ │ │ │ + for (var i = 0; i < this.clusters.length; ++i) { │ │ │ │ + if (this.clusters[i] != this.layer.features[i]) { │ │ │ │ + exist = false; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return exist │ │ │ │ + }, │ │ │ │ + shouldCluster: function(cluster, feature) { │ │ │ │ + var cc = cluster.geometry.getBounds().getCenterLonLat(); │ │ │ │ + var fc = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + var distance = Math.sqrt(Math.pow(cc.lon - fc.lon, 2) + Math.pow(cc.lat - fc.lat, 2)) / this.resolution; │ │ │ │ + return distance <= this.distance │ │ │ │ + }, │ │ │ │ + addToCluster: function(cluster, feature) { │ │ │ │ + cluster.cluster.push(feature); │ │ │ │ + cluster.attributes.count += 1 │ │ │ │ + }, │ │ │ │ + createCluster: function(feature) { │ │ │ │ + var center = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + var cluster = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(center.lon, center.lat), { │ │ │ │ + count: 1 │ │ │ │ + }); │ │ │ │ + cluster.cluster = [feature]; │ │ │ │ + return cluster │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Cluster" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ - this.metadata = metadata; │ │ │ │ - this.initLayer(); │ │ │ │ - var script = document.getElementById(this._callbackId); │ │ │ │ - script.parentNode.removeChild(script); │ │ │ │ - window[this._callbackId] = undefined; │ │ │ │ - delete this._callbackId │ │ │ │ -}; │ │ │ │ OpenLayers.Layer.SphericalMercator = { │ │ │ │ getExtent: function() { │ │ │ │ var extent = null; │ │ │ │ if (this.sphericalMercator) { │ │ │ │ extent = this.map.calculateBounds() │ │ │ │ } else { │ │ │ │ extent = OpenLayers.Layer.FixedZoomLevels.prototype.getExtent.apply(this) │ │ │ │ @@ -15435,299 +15536,397 @@ │ │ │ │ } │ │ │ │ return gLatLng │ │ │ │ }, │ │ │ │ getMapObjectPixelFromXY: function(x, y) { │ │ │ │ return new GPoint(x, y) │ │ │ │ } │ │ │ │ }; │ │ │ │ -OpenLayers.Layer.WorldWind = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - DEFAULT_PARAMS: {}, │ │ │ │ - isBaseLayer: true, │ │ │ │ - lzd: null, │ │ │ │ - zoomLevels: null, │ │ │ │ - initialize: function(name, url, lzd, zoomLevels, params, options) { │ │ │ │ - this.lzd = lzd; │ │ │ │ - this.zoomLevels = zoomLevels; │ │ │ │ - var newArguments = []; │ │ │ │ - newArguments.push(name, url, params, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ - this.params = OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS) │ │ │ │ - }, │ │ │ │ - getZoom: function() { │ │ │ │ - var zoom = this.map.getZoom(); │ │ │ │ - var extent = this.map.getMaxExtent(); │ │ │ │ - zoom = zoom - Math.log(this.maxResolution / (this.lzd / 512)) / Math.log(2); │ │ │ │ - return zoom │ │ │ │ - }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var zoom = this.getZoom(); │ │ │ │ - var extent = this.map.getMaxExtent(); │ │ │ │ - var deg = this.lzd / Math.pow(2, this.getZoom()); │ │ │ │ - var x = Math.floor((bounds.left - extent.left) / deg); │ │ │ │ - var y = Math.floor((bounds.bottom - extent.bottom) / deg); │ │ │ │ - if (this.map.getResolution() <= this.lzd / 512 && this.getZoom() <= this.zoomLevels) { │ │ │ │ - return this.getFullRequestString({ │ │ │ │ - L: zoom, │ │ │ │ - X: x, │ │ │ │ - Y: y │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - return OpenLayers.Util.getImageLocation("blank.gif") │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.WorldWind" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.TileCache = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ +OpenLayers.Layer.XYZ = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ isBaseLayer: true, │ │ │ │ - format: "image/png", │ │ │ │ + sphericalMercator: false, │ │ │ │ + zoomOffset: 0, │ │ │ │ serverResolutions: null, │ │ │ │ - initialize: function(name, url, layername, options) { │ │ │ │ - this.layername = layername; │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name, url, {}, options]); │ │ │ │ - this.extension = this.format.split("/")[1].toLowerCase(); │ │ │ │ - this.extension = this.extension == "jpg" ? "jpeg" : this.extension │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + if (options && options.sphericalMercator || this.sphericalMercator) { │ │ │ │ + options = OpenLayers.Util.extend({ │ │ │ │ + projection: "EPSG:900913", │ │ │ │ + numZoomLevels: 19 │ │ │ │ + }, options) │ │ │ │ + } │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name || this.name, url || this.url, {}, options]) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.TileCache(this.name, this.url, this.layername, this.getOptions()) │ │ │ │ + obj = new OpenLayers.Layer.XYZ(this.name, this.url, this.getOptions()) │ │ │ │ } │ │ │ │ obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ getURL: function(bounds) { │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var bbox = this.maxExtent; │ │ │ │ - var size = this.tileSize; │ │ │ │ - var tileX = Math.round((bounds.left - bbox.left) / (res * size.w)); │ │ │ │ - var tileY = Math.round((bounds.bottom - bbox.bottom) / (res * size.h)); │ │ │ │ - var tileZ = this.serverResolutions != null ? OpenLayers.Util.indexOf(this.serverResolutions, res) : this.map.getZoom(); │ │ │ │ - var components = [this.layername, OpenLayers.Number.zeroPad(tileZ, 2), OpenLayers.Number.zeroPad(parseInt(tileX / 1e6), 3), OpenLayers.Number.zeroPad(parseInt(tileX / 1e3) % 1e3, 3), OpenLayers.Number.zeroPad(parseInt(tileX) % 1e3, 3), OpenLayers.Number.zeroPad(parseInt(tileY / 1e6), 3), OpenLayers.Number.zeroPad(parseInt(tileY / 1e3) % 1e3, 3), OpenLayers.Number.zeroPad(parseInt(tileY) % 1e3, 3) + "." + this.extension]; │ │ │ │ - var path = components.join("/"); │ │ │ │ + var xyz = this.getXYZ(bounds); │ │ │ │ var url = this.url; │ │ │ │ if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(path, url) │ │ │ │ + var s = "" + xyz.x + xyz.y + xyz.z; │ │ │ │ + url = this.selectUrl(s, url) │ │ │ │ } │ │ │ │ - url = url.charAt(url.length - 1) == "/" ? url : url + "/"; │ │ │ │ - return url + path │ │ │ │ + return OpenLayers.String.format(url, xyz) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.TileCache" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.Text = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - defaultStyle: null, │ │ │ │ - extractStyles: true, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - if (options.extractStyles !== false) { │ │ │ │ - options.defaultStyle = { │ │ │ │ - externalGraphic: OpenLayers.Util.getImageLocation("marker.png"), │ │ │ │ - graphicWidth: 21, │ │ │ │ - graphicHeight: 25, │ │ │ │ - graphicXOffset: -10.5, │ │ │ │ - graphicYOffset: -12.5 │ │ │ │ - } │ │ │ │ + getXYZ: function(bounds) { │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getServerZoom(); │ │ │ │ + if (this.wrapDateLine) { │ │ │ │ + var limit = Math.pow(2, z); │ │ │ │ + x = (x % limit + limit) % limit │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + x: x, │ │ │ │ + y: y, │ │ │ │ + z: z │ │ │ │ } │ │ │ │ - OpenLayers.Format.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - read: function(text) { │ │ │ │ - var lines = text.split("\n"); │ │ │ │ - var columns; │ │ │ │ - var features = []; │ │ │ │ - for (var lcv = 0; lcv < lines.length - 1; lcv++) { │ │ │ │ - var currLine = lines[lcv].replace(/^\s*/, "").replace(/\s*$/, ""); │ │ │ │ - if (currLine.charAt(0) != "#") { │ │ │ │ - if (!columns) { │ │ │ │ - columns = currLine.split("\t") │ │ │ │ - } else { │ │ │ │ - var vals = currLine.split("\t"); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ - var attributes = {}; │ │ │ │ - var style = this.defaultStyle ? OpenLayers.Util.applyDefaults({}, this.defaultStyle) : null; │ │ │ │ - var icon, iconSize, iconOffset, overflow; │ │ │ │ - var set = false; │ │ │ │ - for (var valIndex = 0; valIndex < vals.length; valIndex++) { │ │ │ │ - if (vals[valIndex]) { │ │ │ │ - if (columns[valIndex] == "point") { │ │ │ │ - var coords = vals[valIndex].split(","); │ │ │ │ - geometry.y = parseFloat(coords[0]); │ │ │ │ - geometry.x = parseFloat(coords[1]); │ │ │ │ - set = true │ │ │ │ - } else if (columns[valIndex] == "lat") { │ │ │ │ - geometry.y = parseFloat(vals[valIndex]); │ │ │ │ - set = true │ │ │ │ - } else if (columns[valIndex] == "lon") { │ │ │ │ - geometry.x = parseFloat(vals[valIndex]); │ │ │ │ - set = true │ │ │ │ - } else if (columns[valIndex] == "title") attributes["title"] = vals[valIndex]; │ │ │ │ - else if (columns[valIndex] == "image" || columns[valIndex] == "icon" && style) { │ │ │ │ - style["externalGraphic"] = vals[valIndex] │ │ │ │ - } else if (columns[valIndex] == "iconSize" && style) { │ │ │ │ - var size = vals[valIndex].split(","); │ │ │ │ - style["graphicWidth"] = parseFloat(size[0]); │ │ │ │ - style["graphicHeight"] = parseFloat(size[1]) │ │ │ │ - } else if (columns[valIndex] == "iconOffset" && style) { │ │ │ │ - var offset = vals[valIndex].split(","); │ │ │ │ - style["graphicXOffset"] = parseFloat(offset[0]); │ │ │ │ - style["graphicYOffset"] = parseFloat(offset[1]) │ │ │ │ - } else if (columns[valIndex] == "description") { │ │ │ │ - attributes["description"] = vals[valIndex] │ │ │ │ - } else if (columns[valIndex] == "overflow") { │ │ │ │ - attributes["overflow"] = vals[valIndex] │ │ │ │ - } else { │ │ │ │ - attributes[columns[valIndex]] = vals[valIndex] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (set) { │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, attributes, style); │ │ │ │ - features.push(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + if (!this.tileOrigin) { │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(this.maxExtent.left, this.maxExtent.bottom) │ │ │ │ } │ │ │ │ - return features │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Text" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Text = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ - location: null, │ │ │ │ - features: null, │ │ │ │ - formatOptions: null, │ │ │ │ - selectedFeature: null, │ │ │ │ - initialize: function(name, options) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.initialize.apply(this, arguments); │ │ │ │ - this.features = [] │ │ │ │ - }, │ │ │ │ +OpenLayers.Tile.UTFGrid = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ + url: null, │ │ │ │ + utfgridResolution: 2, │ │ │ │ + json: null, │ │ │ │ + format: null, │ │ │ │ destroy: function() { │ │ │ │ - OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ - this.clearFeatures(); │ │ │ │ - this.features = null │ │ │ │ + this.clear(); │ │ │ │ + OpenLayers.Tile.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - loadText: function() { │ │ │ │ - if (!this.loaded) { │ │ │ │ - if (this.location != null) { │ │ │ │ - var onFail = function(e) { │ │ │ │ - this.events.triggerEvent("loadend") │ │ │ │ - }; │ │ │ │ - this.events.triggerEvent("loadstart"); │ │ │ │ - OpenLayers.Request.GET({ │ │ │ │ - url: this.location, │ │ │ │ - success: this.parseData, │ │ │ │ - failure: onFail, │ │ │ │ + draw: function() { │ │ │ │ + var drawn = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ + if (drawn) { │ │ │ │ + if (this.isLoading) { │ │ │ │ + this.abortLoading(); │ │ │ │ + this.events.triggerEvent("reload") │ │ │ │ + } else { │ │ │ │ + this.isLoading = true; │ │ │ │ + this.events.triggerEvent("loadstart") │ │ │ │ + } │ │ │ │ + this.url = this.layer.getURL(this.bounds); │ │ │ │ + if (this.layer.useJSONP) { │ │ │ │ + var ols = new OpenLayers.Protocol.Script({ │ │ │ │ + url: this.url, │ │ │ │ + callback: function(response) { │ │ │ │ + this.isLoading = false; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + this.json = response.data │ │ │ │ + }, │ │ │ │ scope: this │ │ │ │ }); │ │ │ │ - this.loaded = true │ │ │ │ + ols.read(); │ │ │ │ + this.request = ols │ │ │ │ + } else { │ │ │ │ + this.request = OpenLayers.Request.GET({ │ │ │ │ + url: this.url, │ │ │ │ + callback: function(response) { │ │ │ │ + this.isLoading = false; │ │ │ │ + this.events.triggerEvent("loadend"); │ │ │ │ + if (response.status === 200) { │ │ │ │ + this.parseData(response.responseText) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + this.unload() │ │ │ │ } │ │ │ │ + return drawn │ │ │ │ }, │ │ │ │ - moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ - OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ - if (this.visibility && !this.loaded) { │ │ │ │ - this.loadText() │ │ │ │ + abortLoading: function() { │ │ │ │ + if (this.request) { │ │ │ │ + this.request.abort(); │ │ │ │ + delete this.request │ │ │ │ } │ │ │ │ + this.isLoading = false │ │ │ │ }, │ │ │ │ - parseData: function(ajaxRequest) { │ │ │ │ - var text = ajaxRequest.responseText; │ │ │ │ - var options = {}; │ │ │ │ - OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ - if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ - options.externalProjection = this.projection; │ │ │ │ - options.internalProjection = this.map.getProjectionObject() │ │ │ │ - } │ │ │ │ - var parser = new OpenLayers.Format.Text(options); │ │ │ │ - var features = parser.read(text); │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - var data = {}; │ │ │ │ - var feature = features[i]; │ │ │ │ - var location; │ │ │ │ - var iconSize, iconOffset; │ │ │ │ - location = new OpenLayers.LonLat(feature.geometry.x, feature.geometry.y); │ │ │ │ - if (feature.style.graphicWidth && feature.style.graphicHeight) { │ │ │ │ - iconSize = new OpenLayers.Size(feature.style.graphicWidth, feature.style.graphicHeight) │ │ │ │ - } │ │ │ │ - if (feature.style.graphicXOffset !== undefined && feature.style.graphicYOffset !== undefined) { │ │ │ │ - iconOffset = new OpenLayers.Pixel(feature.style.graphicXOffset, feature.style.graphicYOffset) │ │ │ │ - } │ │ │ │ - if (feature.style.externalGraphic != null) { │ │ │ │ - data.icon = new OpenLayers.Icon(feature.style.externalGraphic, iconSize, iconOffset) │ │ │ │ - } else { │ │ │ │ - data.icon = OpenLayers.Marker.defaultIcon(); │ │ │ │ - if (iconSize != null) { │ │ │ │ - data.icon.setSize(iconSize) │ │ │ │ + getFeatureInfo: function(i, j) { │ │ │ │ + var info = null; │ │ │ │ + if (this.json) { │ │ │ │ + var id = this.getFeatureId(i, j); │ │ │ │ + if (id !== null) { │ │ │ │ + info = { │ │ │ │ + id: id, │ │ │ │ + data: this.json.data[id] │ │ │ │ } │ │ │ │ } │ │ │ │ - if (feature.attributes.title != null && feature.attributes.description != null) { │ │ │ │ - data["popupContentHTML"] = "<h2>" + feature.attributes.title + "</h2>" + "<p>" + feature.attributes.description + "</p>" │ │ │ │ - } │ │ │ │ - data["overflow"] = feature.attributes.overflow || "auto"; │ │ │ │ - var markerFeature = new OpenLayers.Feature(this, location, data); │ │ │ │ - this.features.push(markerFeature); │ │ │ │ - var marker = markerFeature.createMarker(); │ │ │ │ - if (feature.attributes.title != null && feature.attributes.description != null) { │ │ │ │ - marker.events.register("click", markerFeature, this.markerClick) │ │ │ │ + } │ │ │ │ + return info │ │ │ │ + }, │ │ │ │ + getFeatureId: function(i, j) { │ │ │ │ + var id = null; │ │ │ │ + if (this.json) { │ │ │ │ + var resolution = this.utfgridResolution; │ │ │ │ + var row = Math.floor(j / resolution); │ │ │ │ + var col = Math.floor(i / resolution); │ │ │ │ + var charCode = this.json.grid[row].charCodeAt(col); │ │ │ │ + var index = this.indexFromCharCode(charCode); │ │ │ │ + var keys = this.json.keys; │ │ │ │ + if (!isNaN(index) && index in keys) { │ │ │ │ + id = keys[index] │ │ │ │ } │ │ │ │ - this.addMarker(marker) │ │ │ │ } │ │ │ │ - this.events.triggerEvent("loadend") │ │ │ │ + return id │ │ │ │ }, │ │ │ │ - markerClick: function(evt) { │ │ │ │ - var sameMarkerClicked = this == this.layer.selectedFeature; │ │ │ │ - this.layer.selectedFeature = !sameMarkerClicked ? this : null; │ │ │ │ - for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ - this.layer.map.removePopup(this.layer.map.popups[i]) │ │ │ │ + indexFromCharCode: function(charCode) { │ │ │ │ + if (charCode >= 93) { │ │ │ │ + charCode-- │ │ │ │ } │ │ │ │ - if (!sameMarkerClicked) { │ │ │ │ - this.layer.map.addPopup(this.createPopup()) │ │ │ │ + if (charCode >= 35) { │ │ │ │ + charCode-- │ │ │ │ } │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ + return charCode - 32 │ │ │ │ }, │ │ │ │ - clearFeatures: function() { │ │ │ │ - if (this.features != null) { │ │ │ │ - while (this.features.length > 0) { │ │ │ │ - var feature = this.features[0]; │ │ │ │ - OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ - feature.destroy() │ │ │ │ - } │ │ │ │ + parseData: function(str) { │ │ │ │ + if (!this.format) { │ │ │ │ + this.format = new OpenLayers.Format.JSON │ │ │ │ } │ │ │ │ + this.json = this.format.read(str) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Text" │ │ │ │ + clear: function() { │ │ │ │ + this.json = null │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Tile.UTFGrid" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Boxes = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ - drawMarker: function(marker) { │ │ │ │ - var topleft = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: marker.bounds.left, │ │ │ │ - lat: marker.bounds.top │ │ │ │ - }); │ │ │ │ - var botright = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: marker.bounds.right, │ │ │ │ - lat: marker.bounds.bottom │ │ │ │ - }); │ │ │ │ - if (botright == null || topleft == null) { │ │ │ │ - marker.display(false) │ │ │ │ - } else { │ │ │ │ - var markerDiv = marker.draw(topleft, { │ │ │ │ - w: Math.max(1, botright.x - topleft.x), │ │ │ │ - h: Math.max(1, botright.y - topleft.y) │ │ │ │ - }); │ │ │ │ - if (!marker.drawn) { │ │ │ │ - this.div.appendChild(markerDiv); │ │ │ │ - marker.drawn = true │ │ │ │ - } │ │ │ │ +OpenLayers.Layer.UTFGrid = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + isBaseLayer: false, │ │ │ │ + projection: new OpenLayers.Projection("EPSG:900913"), │ │ │ │ + useJSONP: false, │ │ │ │ + tileClass: OpenLayers.Tile.UTFGrid, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, [options.name, options.url, {}, options]); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + utfgridResolution: this.utfgridResolution │ │ │ │ + }, this.tileOptions) │ │ │ │ + }, │ │ │ │ + createBackBuffer: function() {}, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.UTFGrid(this.getOptions()) │ │ │ │ } │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ }, │ │ │ │ - removeMarker: function(marker) { │ │ │ │ - OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ - if (marker.div != null && marker.div.parentNode == this.div) { │ │ │ │ - this.div.removeChild(marker.div) │ │ │ │ + getFeatureInfo: function(location) { │ │ │ │ + var info = null; │ │ │ │ + var tileInfo = this.getTileData(location); │ │ │ │ + if (tileInfo && tileInfo.tile) { │ │ │ │ + info = tileInfo.tile.getFeatureInfo(tileInfo.i, tileInfo.j) │ │ │ │ + } │ │ │ │ + return info │ │ │ │ + }, │ │ │ │ + getFeatureId: function(location) { │ │ │ │ + var id = null; │ │ │ │ + var info = this.getTileData(location); │ │ │ │ + if (info.tile) { │ │ │ │ + id = info.tile.getFeatureId(info.i, info.j) │ │ │ │ } │ │ │ │ + return id │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Boxes" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.UTFGrid" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.KaMap = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + isBaseLayer: true, │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + i: "jpeg", │ │ │ │ + map: "" │ │ │ │ + }, │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ + this.params = OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS) │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + var scale = Math.round(this.map.getScale() * 1e4) / 1e4; │ │ │ │ + var pX = Math.round(bounds.left / mapRes); │ │ │ │ + var pY = -Math.round(bounds.top / mapRes); │ │ │ │ + return this.getFullRequestString({ │ │ │ │ + t: pY, │ │ │ │ + l: pX, │ │ │ │ + s: scale │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ + var tilelon = resolution * this.tileSize.w; │ │ │ │ + var tilelat = resolution * this.tileSize.h; │ │ │ │ + var offsetlon = bounds.left; │ │ │ │ + var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ + var offsetlat = bounds.top; │ │ │ │ + var tilerow = Math.floor(offsetlat / tilelat) + this.buffer; │ │ │ │ + return { │ │ │ │ + tilelon: tilelon, │ │ │ │ + tilelat: tilelat, │ │ │ │ + startcol: tilecol, │ │ │ │ + startrow: tilerow │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getTileBoundsForGridIndex: function(row, col) { │ │ │ │ + var origin = this.getTileOrigin(); │ │ │ │ + var tileLayout = this.gridLayout; │ │ │ │ + var tilelon = tileLayout.tilelon; │ │ │ │ + var tilelat = tileLayout.tilelat; │ │ │ │ + var minX = (tileLayout.startcol + col) * tilelon; │ │ │ │ + var minY = (tileLayout.startrow - row) * tilelat; │ │ │ │ + return new OpenLayers.Bounds(minX, minY, minX + tilelon, minY + tilelat) │ │ │ │ + }, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.KaMap(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + } │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + if (this.tileSize != null) { │ │ │ │ + obj.tileSize = this.tileSize.clone() │ │ │ │ + } │ │ │ │ + obj.grid = []; │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + getTileBounds: function(viewPortPx) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ + var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ + var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ + var tileLeft = tileMapWidth * Math.floor(mapPoint.lon / tileMapWidth); │ │ │ │ + var tileBottom = tileMapHeight * Math.floor(mapPoint.lat / tileMapHeight); │ │ │ │ + return new OpenLayers.Bounds(tileLeft, tileBottom, tileLeft + tileMapWidth, tileBottom + tileMapHeight) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.KaMap" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.KaMapCache = OpenLayers.Class(OpenLayers.Layer.KaMap, { │ │ │ │ + IMAGE_EXTENSIONS: { │ │ │ │ + jpeg: "jpg", │ │ │ │ + gif: "gif", │ │ │ │ + png: "png", │ │ │ │ + png8: "png", │ │ │ │ + png24: "png", │ │ │ │ + dithered: "png" │ │ │ │ + }, │ │ │ │ + DEFAULT_FORMAT: "jpeg", │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + OpenLayers.Layer.KaMap.prototype.initialize.apply(this, arguments); │ │ │ │ + this.extension = this.IMAGE_EXTENSIONS[this.params.i.toLowerCase() || this.DEFAULT_FORMAT] │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + var scale = Math.round(this.map.getScale() * 1e4) / 1e4; │ │ │ │ + var pX = Math.round(bounds.left / mapRes); │ │ │ │ + var pY = -Math.round(bounds.top / mapRes); │ │ │ │ + var metaX = Math.floor(pX / this.tileSize.w / this.params.metaTileSize.w) * this.tileSize.w * this.params.metaTileSize.w; │ │ │ │ + var metaY = Math.floor(pY / this.tileSize.h / this.params.metaTileSize.h) * this.tileSize.h * this.params.metaTileSize.h; │ │ │ │ + var components = ["/", this.params.map, "/", scale, "/", this.params.g.replace(/\s/g, "_"), "/def/t", metaY, "/l", metaX, "/t", pY, "l", pX, ".", this.extension]; │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(components.join(""), url) │ │ │ │ + } │ │ │ │ + return url + components.join("") │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.KaMapCache" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Zoomify = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + size: null, │ │ │ │ + isBaseLayer: true, │ │ │ │ + standardTileSize: 256, │ │ │ │ + tileOriginCorner: "tl", │ │ │ │ + numberOfTiers: 0, │ │ │ │ + tileCountUpToTier: null, │ │ │ │ + tierSizeInTiles: null, │ │ │ │ + tierImageSize: null, │ │ │ │ + initialize: function(name, url, size, options) { │ │ │ │ + this.initializeZoomify(size); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name, url, size, {}, options]) │ │ │ │ + }, │ │ │ │ + initializeZoomify: function(size) { │ │ │ │ + var imageSize = size.clone(); │ │ │ │ + this.size = size.clone(); │ │ │ │ + var tiles = new OpenLayers.Size(Math.ceil(imageSize.w / this.standardTileSize), Math.ceil(imageSize.h / this.standardTileSize)); │ │ │ │ + this.tierSizeInTiles = [tiles]; │ │ │ │ + this.tierImageSize = [imageSize]; │ │ │ │ + while (imageSize.w > this.standardTileSize || imageSize.h > this.standardTileSize) { │ │ │ │ + imageSize = new OpenLayers.Size(Math.floor(imageSize.w / 2), Math.floor(imageSize.h / 2)); │ │ │ │ + tiles = new OpenLayers.Size(Math.ceil(imageSize.w / this.standardTileSize), Math.ceil(imageSize.h / this.standardTileSize)); │ │ │ │ + this.tierSizeInTiles.push(tiles); │ │ │ │ + this.tierImageSize.push(imageSize) │ │ │ │ + } │ │ │ │ + this.tierSizeInTiles.reverse(); │ │ │ │ + this.tierImageSize.reverse(); │ │ │ │ + this.numberOfTiers = this.tierSizeInTiles.length; │ │ │ │ + var resolutions = [1]; │ │ │ │ + this.tileCountUpToTier = [0]; │ │ │ │ + for (var i = 1; i < this.numberOfTiers; i++) { │ │ │ │ + resolutions.unshift(Math.pow(2, i)); │ │ │ │ + this.tileCountUpToTier.push(this.tierSizeInTiles[i - 1].w * this.tierSizeInTiles[i - 1].h + this.tileCountUpToTier[i - 1]) │ │ │ │ + } │ │ │ │ + if (!this.serverResolutions) { │ │ │ │ + this.serverResolutions = resolutions │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments); │ │ │ │ + this.tileCountUpToTier.length = 0; │ │ │ │ + this.tierSizeInTiles.length = 0; │ │ │ │ + this.tierImageSize.length = 0 │ │ │ │ + }, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Zoomify(this.name, this.url, this.size, this.options) │ │ │ │ + } │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getZoomForResolution(res); │ │ │ │ + var tileIndex = x + y * this.tierSizeInTiles[z].w + this.tileCountUpToTier[z]; │ │ │ │ + var path = "TileGroup" + Math.floor(tileIndex / 256) + "/" + z + "-" + x + "-" + y + ".jpg"; │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(path, url) │ │ │ │ + } │ │ │ │ + return url + path │ │ │ │ + }, │ │ │ │ + getImageSize: function() { │ │ │ │ + if (arguments.length > 0) { │ │ │ │ + var bounds = this.adjustBounds(arguments[0]); │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getZoomForResolution(res); │ │ │ │ + var w = this.standardTileSize; │ │ │ │ + var h = this.standardTileSize; │ │ │ │ + if (x == this.tierSizeInTiles[z].w - 1) { │ │ │ │ + var w = this.tierImageSize[z].w % this.standardTileSize │ │ │ │ + } │ │ │ │ + if (y == this.tierSizeInTiles[z].h - 1) { │ │ │ │ + var h = this.tierImageSize[z].h % this.standardTileSize │ │ │ │ + } │ │ │ │ + return new OpenLayers.Size(w, h) │ │ │ │ + } else { │ │ │ │ + return this.tileSize │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, this.map.maxExtent.top) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Zoomify" │ │ │ │ }); │ │ │ │ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ isBaseLayer: false, │ │ │ │ isFixed: false, │ │ │ │ features: null, │ │ │ │ filter: null, │ │ │ │ selectedFeatures: null, │ │ │ │ @@ -16153,192 +16352,14 @@ │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return maxExtent │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.Vector" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.PointTrack = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ - dataFrom: null, │ │ │ │ - styleFrom: null, │ │ │ │ - addNodes: function(pointFeatures, options) { │ │ │ │ - if (pointFeatures.length < 2) { │ │ │ │ - throw new Error("At least two point features have to be added to " + "create a line from") │ │ │ │ - } │ │ │ │ - var lines = new Array(pointFeatures.length - 1); │ │ │ │ - var pointFeature, startPoint, endPoint; │ │ │ │ - for (var i = 0, len = pointFeatures.length; i < len; i++) { │ │ │ │ - pointFeature = pointFeatures[i]; │ │ │ │ - endPoint = pointFeature.geometry; │ │ │ │ - if (!endPoint) { │ │ │ │ - var lonlat = pointFeature.lonlat; │ │ │ │ - endPoint = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat) │ │ │ │ - } else if (endPoint.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ - throw new TypeError("Only features with point geometries are supported.") │ │ │ │ - } │ │ │ │ - if (i > 0) { │ │ │ │ - var attributes = this.dataFrom != null ? pointFeatures[i + this.dataFrom].data || pointFeatures[i + this.dataFrom].attributes : null; │ │ │ │ - var style = this.styleFrom != null ? pointFeatures[i + this.styleFrom].style : null; │ │ │ │ - var line = new OpenLayers.Geometry.LineString([startPoint, endPoint]); │ │ │ │ - lines[i - 1] = new OpenLayers.Feature.Vector(line, attributes, style) │ │ │ │ - } │ │ │ │ - startPoint = endPoint │ │ │ │ - } │ │ │ │ - this.addFeatures(lines, options) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.PointTrack" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.PointTrack.SOURCE_NODE = -1; │ │ │ │ -OpenLayers.Layer.PointTrack.TARGET_NODE = 0; │ │ │ │ -OpenLayers.Layer.PointTrack.dataFrom = { │ │ │ │ - SOURCE_NODE: -1, │ │ │ │ - TARGET_NODE: 0 │ │ │ │ -}; │ │ │ │ -OpenLayers.Tile.UTFGrid = OpenLayers.Class(OpenLayers.Tile, { │ │ │ │ - url: null, │ │ │ │ - utfgridResolution: 2, │ │ │ │ - json: null, │ │ │ │ - format: null, │ │ │ │ - destroy: function() { │ │ │ │ - this.clear(); │ │ │ │ - OpenLayers.Tile.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - var drawn = OpenLayers.Tile.prototype.draw.apply(this, arguments); │ │ │ │ - if (drawn) { │ │ │ │ - if (this.isLoading) { │ │ │ │ - this.abortLoading(); │ │ │ │ - this.events.triggerEvent("reload") │ │ │ │ - } else { │ │ │ │ - this.isLoading = true; │ │ │ │ - this.events.triggerEvent("loadstart") │ │ │ │ - } │ │ │ │ - this.url = this.layer.getURL(this.bounds); │ │ │ │ - if (this.layer.useJSONP) { │ │ │ │ - var ols = new OpenLayers.Protocol.Script({ │ │ │ │ - url: this.url, │ │ │ │ - callback: function(response) { │ │ │ │ - this.isLoading = false; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - this.json = response.data │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - ols.read(); │ │ │ │ - this.request = ols │ │ │ │ - } else { │ │ │ │ - this.request = OpenLayers.Request.GET({ │ │ │ │ - url: this.url, │ │ │ │ - callback: function(response) { │ │ │ │ - this.isLoading = false; │ │ │ │ - this.events.triggerEvent("loadend"); │ │ │ │ - if (response.status === 200) { │ │ │ │ - this.parseData(response.responseText) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unload() │ │ │ │ - } │ │ │ │ - return drawn │ │ │ │ - }, │ │ │ │ - abortLoading: function() { │ │ │ │ - if (this.request) { │ │ │ │ - this.request.abort(); │ │ │ │ - delete this.request │ │ │ │ - } │ │ │ │ - this.isLoading = false │ │ │ │ - }, │ │ │ │ - getFeatureInfo: function(i, j) { │ │ │ │ - var info = null; │ │ │ │ - if (this.json) { │ │ │ │ - var id = this.getFeatureId(i, j); │ │ │ │ - if (id !== null) { │ │ │ │ - info = { │ │ │ │ - id: id, │ │ │ │ - data: this.json.data[id] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return info │ │ │ │ - }, │ │ │ │ - getFeatureId: function(i, j) { │ │ │ │ - var id = null; │ │ │ │ - if (this.json) { │ │ │ │ - var resolution = this.utfgridResolution; │ │ │ │ - var row = Math.floor(j / resolution); │ │ │ │ - var col = Math.floor(i / resolution); │ │ │ │ - var charCode = this.json.grid[row].charCodeAt(col); │ │ │ │ - var index = this.indexFromCharCode(charCode); │ │ │ │ - var keys = this.json.keys; │ │ │ │ - if (!isNaN(index) && index in keys) { │ │ │ │ - id = keys[index] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return id │ │ │ │ - }, │ │ │ │ - indexFromCharCode: function(charCode) { │ │ │ │ - if (charCode >= 93) { │ │ │ │ - charCode-- │ │ │ │ - } │ │ │ │ - if (charCode >= 35) { │ │ │ │ - charCode-- │ │ │ │ - } │ │ │ │ - return charCode - 32 │ │ │ │ - }, │ │ │ │ - parseData: function(str) { │ │ │ │ - if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.JSON │ │ │ │ - } │ │ │ │ - this.json = this.format.read(str) │ │ │ │ - }, │ │ │ │ - clear: function() { │ │ │ │ - this.json = null │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Tile.UTFGrid" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.UTFGrid = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - isBaseLayer: false, │ │ │ │ - projection: new OpenLayers.Projection("EPSG:900913"), │ │ │ │ - useJSONP: false, │ │ │ │ - tileClass: OpenLayers.Tile.UTFGrid, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, [options.name, options.url, {}, options]); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - utfgridResolution: this.utfgridResolution │ │ │ │ - }, this.tileOptions) │ │ │ │ - }, │ │ │ │ - createBackBuffer: function() {}, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.UTFGrid(this.getOptions()) │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ - }, │ │ │ │ - getFeatureInfo: function(location) { │ │ │ │ - var info = null; │ │ │ │ - var tileInfo = this.getTileData(location); │ │ │ │ - if (tileInfo && tileInfo.tile) { │ │ │ │ - info = tileInfo.tile.getFeatureInfo(tileInfo.i, tileInfo.j) │ │ │ │ - } │ │ │ │ - return info │ │ │ │ - }, │ │ │ │ - getFeatureId: function(location) { │ │ │ │ - var id = null; │ │ │ │ - var info = this.getTileData(location); │ │ │ │ - if (info.tile) { │ │ │ │ - id = info.tile.getFeatureId(info.i, info.j) │ │ │ │ - } │ │ │ │ - return id │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.UTFGrid" │ │ │ │ -}); │ │ │ │ OpenLayers.Layer.PointGrid = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ dx: null, │ │ │ │ dy: null, │ │ │ │ ratio: 1.5, │ │ │ │ maxFeatures: 250, │ │ │ │ rotation: 0, │ │ │ │ origin: null, │ │ │ │ @@ -16436,218 +16457,181 @@ │ │ │ │ } │ │ │ │ }, │ │ │ │ invalidBounds: function() { │ │ │ │ return !this.gridBounds || !this.gridBounds.containsBounds(this.getViewBounds()) │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.PointGrid" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Zoomify = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - size: null, │ │ │ │ - isBaseLayer: true, │ │ │ │ - standardTileSize: 256, │ │ │ │ - tileOriginCorner: "tl", │ │ │ │ - numberOfTiers: 0, │ │ │ │ - tileCountUpToTier: null, │ │ │ │ - tierSizeInTiles: null, │ │ │ │ - tierImageSize: null, │ │ │ │ - initialize: function(name, url, size, options) { │ │ │ │ - this.initializeZoomify(size); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name, url, size, {}, options]) │ │ │ │ - }, │ │ │ │ - initializeZoomify: function(size) { │ │ │ │ - var imageSize = size.clone(); │ │ │ │ - this.size = size.clone(); │ │ │ │ - var tiles = new OpenLayers.Size(Math.ceil(imageSize.w / this.standardTileSize), Math.ceil(imageSize.h / this.standardTileSize)); │ │ │ │ - this.tierSizeInTiles = [tiles]; │ │ │ │ - this.tierImageSize = [imageSize]; │ │ │ │ - while (imageSize.w > this.standardTileSize || imageSize.h > this.standardTileSize) { │ │ │ │ - imageSize = new OpenLayers.Size(Math.floor(imageSize.w / 2), Math.floor(imageSize.h / 2)); │ │ │ │ - tiles = new OpenLayers.Size(Math.ceil(imageSize.w / this.standardTileSize), Math.ceil(imageSize.h / this.standardTileSize)); │ │ │ │ - this.tierSizeInTiles.push(tiles); │ │ │ │ - this.tierImageSize.push(imageSize) │ │ │ │ - } │ │ │ │ - this.tierSizeInTiles.reverse(); │ │ │ │ - this.tierImageSize.reverse(); │ │ │ │ - this.numberOfTiers = this.tierSizeInTiles.length; │ │ │ │ - var resolutions = [1]; │ │ │ │ - this.tileCountUpToTier = [0]; │ │ │ │ - for (var i = 1; i < this.numberOfTiers; i++) { │ │ │ │ - resolutions.unshift(Math.pow(2, i)); │ │ │ │ - this.tileCountUpToTier.push(this.tierSizeInTiles[i - 1].w * this.tierSizeInTiles[i - 1].h + this.tileCountUpToTier[i - 1]) │ │ │ │ +OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + url: null, │ │ │ │ + tileOrigin: null, │ │ │ │ + tileSize: new OpenLayers.Size(256, 256), │ │ │ │ + useArcGISServer: true, │ │ │ │ + type: "png", │ │ │ │ + useScales: false, │ │ │ │ + overrideDPI: false, │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.resolutions) { │ │ │ │ + this.serverResolutions = this.resolutions; │ │ │ │ + this.maxExtent = this.getMaxExtentForResolution(this.resolutions[0]) │ │ │ │ } │ │ │ │ - if (!this.serverResolutions) { │ │ │ │ - this.serverResolutions = resolutions │ │ │ │ + if (this.layerInfo) { │ │ │ │ + var info = this.layerInfo; │ │ │ │ + var startingTileExtent = new OpenLayers.Bounds(info.fullExtent.xmin, info.fullExtent.ymin, info.fullExtent.xmax, info.fullExtent.ymax); │ │ │ │ + this.projection = "EPSG:" + info.spatialReference.wkid; │ │ │ │ + this.sphericalMercator = info.spatialReference.wkid == 102100; │ │ │ │ + this.units = info.units == "esriFeet" ? "ft" : "m"; │ │ │ │ + if (!!info.tileInfo) { │ │ │ │ + this.tileSize = new OpenLayers.Size(info.tileInfo.width || info.tileInfo.cols, info.tileInfo.height || info.tileInfo.rows); │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(info.tileInfo.origin.x, info.tileInfo.origin.y); │ │ │ │ + var upperLeft = new OpenLayers.Geometry.Point(startingTileExtent.left, startingTileExtent.top); │ │ │ │ + var bottomRight = new OpenLayers.Geometry.Point(startingTileExtent.right, startingTileExtent.bottom); │ │ │ │ + if (this.useScales) { │ │ │ │ + this.scales = [] │ │ │ │ + } else { │ │ │ │ + this.resolutions = [] │ │ │ │ + } │ │ │ │ + this.lods = []; │ │ │ │ + for (var key in info.tileInfo.lods) { │ │ │ │ + if (info.tileInfo.lods.hasOwnProperty(key)) { │ │ │ │ + var lod = info.tileInfo.lods[key]; │ │ │ │ + if (this.useScales) { │ │ │ │ + this.scales.push(lod.scale) │ │ │ │ + } else { │ │ │ │ + this.resolutions.push(lod.resolution) │ │ │ │ + } │ │ │ │ + var start = this.getContainingTileCoords(upperLeft, lod.resolution); │ │ │ │ + lod.startTileCol = start.x; │ │ │ │ + lod.startTileRow = start.y; │ │ │ │ + var end = this.getContainingTileCoords(bottomRight, lod.resolution); │ │ │ │ + lod.endTileCol = end.x; │ │ │ │ + lod.endTileRow = end.y; │ │ │ │ + this.lods.push(lod) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.maxExtent = this.calculateMaxExtentWithLOD(this.lods[0]); │ │ │ │ + this.serverResolutions = this.resolutions; │ │ │ │ + if (this.overrideDPI && info.tileInfo.dpi) { │ │ │ │ + OpenLayers.DOTS_PER_INCH = info.tileInfo.dpi │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments); │ │ │ │ - this.tileCountUpToTier.length = 0; │ │ │ │ - this.tierSizeInTiles.length = 0; │ │ │ │ - this.tierImageSize.length = 0 │ │ │ │ + getContainingTileCoords: function(point, res) { │ │ │ │ + return new OpenLayers.Pixel(Math.max(Math.floor((point.x - this.tileOrigin.lon) / (this.tileSize.w * res)), 0), Math.max(Math.floor((this.tileOrigin.lat - point.y) / (this.tileSize.h * res)), 0)) │ │ │ │ }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Zoomify(this.name, this.url, this.size, this.options) │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ + calculateMaxExtentWithLOD: function(lod) { │ │ │ │ + var numTileCols = lod.endTileCol - lod.startTileCol + 1; │ │ │ │ + var numTileRows = lod.endTileRow - lod.startTileRow + 1; │ │ │ │ + var minX = this.tileOrigin.lon + lod.startTileCol * this.tileSize.w * lod.resolution; │ │ │ │ + var maxX = minX + numTileCols * this.tileSize.w * lod.resolution; │ │ │ │ + var maxY = this.tileOrigin.lat - lod.startTileRow * this.tileSize.h * lod.resolution; │ │ │ │ + var minY = maxY - numTileRows * this.tileSize.h * lod.resolution; │ │ │ │ + return new OpenLayers.Bounds(minX, minY, maxX, maxY) │ │ │ │ }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getZoomForResolution(res); │ │ │ │ - var tileIndex = x + y * this.tierSizeInTiles[z].w + this.tileCountUpToTier[z]; │ │ │ │ - var path = "TileGroup" + Math.floor(tileIndex / 256) + "/" + z + "-" + x + "-" + y + ".jpg"; │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(path, url) │ │ │ │ - } │ │ │ │ - return url + path │ │ │ │ + calculateMaxExtentWithExtent: function(extent, res) { │ │ │ │ + var upperLeft = new OpenLayers.Geometry.Point(extent.left, extent.top); │ │ │ │ + var bottomRight = new OpenLayers.Geometry.Point(extent.right, extent.bottom); │ │ │ │ + var start = this.getContainingTileCoords(upperLeft, res); │ │ │ │ + var end = this.getContainingTileCoords(bottomRight, res); │ │ │ │ + var lod = { │ │ │ │ + resolution: res, │ │ │ │ + startTileCol: start.x, │ │ │ │ + startTileRow: start.y, │ │ │ │ + endTileCol: end.x, │ │ │ │ + endTileRow: end.y │ │ │ │ + }; │ │ │ │ + return this.calculateMaxExtentWithLOD(lod) │ │ │ │ }, │ │ │ │ - getImageSize: function() { │ │ │ │ - if (arguments.length > 0) { │ │ │ │ - var bounds = this.adjustBounds(arguments[0]); │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getZoomForResolution(res); │ │ │ │ - var w = this.standardTileSize; │ │ │ │ - var h = this.standardTileSize; │ │ │ │ - if (x == this.tierSizeInTiles[z].w - 1) { │ │ │ │ - var w = this.tierImageSize[z].w % this.standardTileSize │ │ │ │ - } │ │ │ │ - if (y == this.tierSizeInTiles[z].h - 1) { │ │ │ │ - var h = this.tierImageSize[z].h % this.standardTileSize │ │ │ │ - } │ │ │ │ - return new OpenLayers.Size(w, h) │ │ │ │ - } else { │ │ │ │ - return this.tileSize │ │ │ │ - } │ │ │ │ + getUpperLeftTileCoord: function(res) { │ │ │ │ + var upperLeft = new OpenLayers.Geometry.Point(this.maxExtent.left, this.maxExtent.top); │ │ │ │ + return this.getContainingTileCoords(upperLeft, res) │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, this.map.maxExtent.top) │ │ │ │ + getLowerRightTileCoord: function(res) { │ │ │ │ + var bottomRight = new OpenLayers.Geometry.Point(this.maxExtent.right, this.maxExtent.bottom); │ │ │ │ + return this.getContainingTileCoords(bottomRight, res) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Zoomify" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.TMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - serviceVersion: "1.0.0", │ │ │ │ - layername: null, │ │ │ │ - type: null, │ │ │ │ - isBaseLayer: true, │ │ │ │ - tileOrigin: null, │ │ │ │ - serverResolutions: null, │ │ │ │ - zoomOffset: 0, │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - var newArguments = []; │ │ │ │ - newArguments.push(name, url, {}, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments) │ │ │ │ + getMaxExtentForResolution: function(res) { │ │ │ │ + var start = this.getUpperLeftTileCoord(res); │ │ │ │ + var end = this.getLowerRightTileCoord(res); │ │ │ │ + var numTileCols = end.x - start.x + 1; │ │ │ │ + var numTileRows = end.y - start.y + 1; │ │ │ │ + var minX = this.tileOrigin.lon + start.x * this.tileSize.w * res; │ │ │ │ + var maxX = minX + numTileCols * this.tileSize.w * res; │ │ │ │ + var maxY = this.tileOrigin.lat - start.y * this.tileSize.h * res; │ │ │ │ + var minY = maxY - numTileRows * this.tileSize.h * res; │ │ │ │ + return new OpenLayers.Bounds(minX, minY, maxX, maxY) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.TMS(this.name, this.url, this.getOptions()) │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ - }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var res = this.getServerResolution(); │ │ │ │ - var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ - var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h)); │ │ │ │ - var z = this.getServerZoom(); │ │ │ │ - var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type; │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(path, url) │ │ │ │ + obj = new OpenLayers.Layer.ArcGISCache(this.name, this.url, this.options) │ │ │ │ } │ │ │ │ - return url + path │ │ │ │ + return OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]) │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ - if (!this.tileOrigin) { │ │ │ │ - this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, this.map.maxExtent.bottom) │ │ │ │ - } │ │ │ │ + initGriddedTiles: function(bounds) { │ │ │ │ + delete this._tileOrigin; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initGriddedTiles.apply(this, arguments) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.TMS" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - service: "WMS", │ │ │ │ - version: "1.1.1", │ │ │ │ - request: "GetMap", │ │ │ │ - styles: "", │ │ │ │ - format: "image/jpeg" │ │ │ │ + getMaxExtent: function() { │ │ │ │ + var resolution = this.map.getResolution(); │ │ │ │ + return this.maxExtent = this.getMaxExtentForResolution(resolution) │ │ │ │ }, │ │ │ │ - isBaseLayer: true, │ │ │ │ - encodeBBOX: false, │ │ │ │ - noMagic: false, │ │ │ │ - yx: {}, │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - var newArguments = []; │ │ │ │ - params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ - if (parseFloat(params.VERSION) >= 1.3 && !params.EXCEPTIONS) { │ │ │ │ - params.EXCEPTIONS = "INIMAGE" │ │ │ │ + getTileOrigin: function() { │ │ │ │ + if (!this._tileOrigin) { │ │ │ │ + var extent = this.getMaxExtent(); │ │ │ │ + this._tileOrigin = new OpenLayers.LonLat(extent.left, extent.bottom) │ │ │ │ } │ │ │ │ - newArguments.push(name, url, params, options); │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ - OpenLayers.Util.applyDefaults(this.params, OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)); │ │ │ │ - if (!this.noMagic && this.params.TRANSPARENT && this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ - if (options == null || !options.isBaseLayer) { │ │ │ │ - this.isBaseLayer = false │ │ │ │ + return this._tileOrigin │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + var res = this.getResolution(); │ │ │ │ + var originTileX = this.tileOrigin.lon + res * this.tileSize.w / 2; │ │ │ │ + var originTileY = this.tileOrigin.lat - res * this.tileSize.h / 2; │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var point = { │ │ │ │ + x: center.lon, │ │ │ │ + y: center.lat │ │ │ │ + }; │ │ │ │ + var x = Math.round(Math.abs((center.lon - originTileX) / (res * this.tileSize.w))); │ │ │ │ + var y = Math.round(Math.abs((originTileY - center.lat) / (res * this.tileSize.h))); │ │ │ │ + var z = this.map.getZoom(); │ │ │ │ + if (this.lods) { │ │ │ │ + var lod = this.lods[this.map.getZoom()]; │ │ │ │ + if (x < lod.startTileCol || x > lod.endTileCol || (y < lod.startTileRow || y > lod.endTileRow)) { │ │ │ │ + return null │ │ │ │ } │ │ │ │ - if (this.params.FORMAT == "image/jpeg") { │ │ │ │ - this.params.FORMAT = OpenLayers.Util.alphaHack() ? "image/gif" : "image/png" │ │ │ │ + } else { │ │ │ │ + var start = this.getUpperLeftTileCoord(res); │ │ │ │ + var end = this.getLowerRightTileCoord(res); │ │ │ │ + if (x < start.x || x >= end.x || (y < start.y || y >= end.y)) { │ │ │ │ + return null │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.WMS(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + var url = this.url; │ │ │ │ + var s = "" + x + y + z; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(s, url) │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj │ │ │ │ - }, │ │ │ │ - reverseAxisOrder: function() { │ │ │ │ - var projCode = this.projection.getCode(); │ │ │ │ - return parseFloat(this.params.VERSION) >= 1.3 && !!(this.yx[projCode] || OpenLayers.Projection.defaults[projCode] && OpenLayers.Projection.defaults[projCode].yx) │ │ │ │ - }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var imageSize = this.getImageSize(); │ │ │ │ - var newParams = {}; │ │ │ │ - var reverseAxisOrder = this.reverseAxisOrder(); │ │ │ │ - newParams.BBOX = this.encodeBBOX ? bounds.toBBOX(null, reverseAxisOrder) : bounds.toArray(reverseAxisOrder); │ │ │ │ - newParams.WIDTH = imageSize.w; │ │ │ │ - newParams.HEIGHT = imageSize.h; │ │ │ │ - var requestString = this.getFullRequestString(newParams); │ │ │ │ - return requestString │ │ │ │ - }, │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ - var newArguments = [upperParams]; │ │ │ │ - return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, newArguments) │ │ │ │ - }, │ │ │ │ - getFullRequestString: function(newParams, altUrl) { │ │ │ │ - var mapProjection = this.map.getProjectionObject(); │ │ │ │ - var projectionCode = this.projection && this.projection.equals(mapProjection) ? this.projection.getCode() : mapProjection.getCode(); │ │ │ │ - var value = projectionCode == "none" ? null : projectionCode; │ │ │ │ - if (parseFloat(this.params.VERSION) >= 1.3) { │ │ │ │ - this.params.CRS = value │ │ │ │ + if (this.useArcGISServer) { │ │ │ │ + url = url + "/tile/${z}/${y}/${x}" │ │ │ │ } else { │ │ │ │ - this.params.SRS = value │ │ │ │ - } │ │ │ │ - if (typeof this.params.TRANSPARENT == "boolean") { │ │ │ │ - newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE" │ │ │ │ + x = "C" + OpenLayers.Number.zeroPad(x, 8, 16); │ │ │ │ + y = "R" + OpenLayers.Number.zeroPad(y, 8, 16); │ │ │ │ + z = "L" + OpenLayers.Number.zeroPad(z, 2, 10); │ │ │ │ + url = url + "/${z}/${y}/${x}." + this.type │ │ │ │ } │ │ │ │ - return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, arguments) │ │ │ │ + url = OpenLayers.String.format(url, { │ │ │ │ + x: x, │ │ │ │ + y: y, │ │ │ │ + z: z │ │ │ │ + }); │ │ │ │ + return OpenLayers.Util.urlAppend(url, OpenLayers.Util.getParameterString(this.params)) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.ArcGISCache" │ │ │ │ }); │ │ │ │ OpenLayers.Format.ArcXML = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ fontStyleKeys: ["antialiasing", "blockout", "font", "fontcolor", "fontsize", "fontstyle", "glowing", "interval", "outline", "printmode", "shadow", "transparency"], │ │ │ │ request: null, │ │ │ │ response: null, │ │ │ │ initialize: function(options) { │ │ │ │ this.request = new OpenLayers.Format.ArcXML.Request; │ │ │ │ @@ -17508,168 +17492,735 @@ │ │ │ │ obj = new OpenLayers.Layer.ArcIMS(this.name, this.url, this.getOptions()) │ │ │ │ } │ │ │ │ obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.ArcIMS" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.ArcGIS93Rest = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - format: "png" │ │ │ │ - }, │ │ │ │ +OpenLayers.Layer.WorldWind = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + DEFAULT_PARAMS: {}, │ │ │ │ isBaseLayer: true, │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ + lzd: null, │ │ │ │ + zoomLevels: null, │ │ │ │ + initialize: function(name, url, lzd, zoomLevels, params, options) { │ │ │ │ + this.lzd = lzd; │ │ │ │ + this.zoomLevels = zoomLevels; │ │ │ │ var newArguments = []; │ │ │ │ - params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ newArguments.push(name, url, params, options); │ │ │ │ OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ - OpenLayers.Util.applyDefaults(this.params, OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)); │ │ │ │ - if (this.params.TRANSPARENT && this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ - if (options == null || !options.isBaseLayer) { │ │ │ │ - this.isBaseLayer = false │ │ │ │ - } │ │ │ │ - if (this.params.FORMAT == "jpg") { │ │ │ │ - this.params.FORMAT = OpenLayers.Util.alphaHack() ? "gif" : "png" │ │ │ │ - } │ │ │ │ + this.params = OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS) │ │ │ │ + }, │ │ │ │ + getZoom: function() { │ │ │ │ + var zoom = this.map.getZoom(); │ │ │ │ + var extent = this.map.getMaxExtent(); │ │ │ │ + zoom = zoom - Math.log(this.maxResolution / (this.lzd / 512)) / Math.log(2); │ │ │ │ + return zoom │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var zoom = this.getZoom(); │ │ │ │ + var extent = this.map.getMaxExtent(); │ │ │ │ + var deg = this.lzd / Math.pow(2, this.getZoom()); │ │ │ │ + var x = Math.floor((bounds.left - extent.left) / deg); │ │ │ │ + var y = Math.floor((bounds.bottom - extent.bottom) / deg); │ │ │ │ + if (this.map.getResolution() <= this.lzd / 512 && this.getZoom() <= this.zoomLevels) { │ │ │ │ + return this.getFullRequestString({ │ │ │ │ + L: zoom, │ │ │ │ + X: x, │ │ │ │ + Y: y │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + return OpenLayers.Util.getImageLocation("blank.gif") │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.WorldWind" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Image = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ + isBaseLayer: true, │ │ │ │ + url: null, │ │ │ │ + extent: null, │ │ │ │ + size: null, │ │ │ │ + tile: null, │ │ │ │ + aspectRatio: null, │ │ │ │ + initialize: function(name, url, extent, size, options) { │ │ │ │ + this.url = url; │ │ │ │ + this.extent = extent; │ │ │ │ + this.maxExtent = extent; │ │ │ │ + this.size = size; │ │ │ │ + OpenLayers.Layer.prototype.initialize.apply(this, [name, options]); │ │ │ │ + this.aspectRatio = this.extent.getHeight() / this.size.h / (this.extent.getWidth() / this.size.w) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.tile) { │ │ │ │ + this.removeTileMonitoringHooks(this.tile); │ │ │ │ + this.tile.destroy(); │ │ │ │ + this.tile = null │ │ │ │ } │ │ │ │ + OpenLayers.Layer.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.ArcGIS93Rest(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + obj = new OpenLayers.Layer.Image(this.name, this.url, this.extent, this.size, this.getOptions()) │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var projWords = this.projection.getCode().split(":"); │ │ │ │ - var srid = projWords[projWords.length - 1]; │ │ │ │ - var imageSize = this.getImageSize(); │ │ │ │ - var newParams = { │ │ │ │ - BBOX: bounds.toBBOX(), │ │ │ │ - SIZE: imageSize.w + "," + imageSize.h, │ │ │ │ - F: "image", │ │ │ │ - BBOXSR: srid, │ │ │ │ - IMAGESR: srid │ │ │ │ + setMap: function(map) { │ │ │ │ + if (this.options.maxResolution == null) { │ │ │ │ + this.options.maxResolution = this.aspectRatio * this.extent.getWidth() / this.size.w │ │ │ │ + } │ │ │ │ + OpenLayers.Layer.prototype.setMap.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ + OpenLayers.Layer.prototype.moveTo.apply(this, arguments); │ │ │ │ + var firstRendering = this.tile == null; │ │ │ │ + if (zoomChanged || firstRendering) { │ │ │ │ + this.setTileSize(); │ │ │ │ + var ulPx = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: this.extent.left, │ │ │ │ + lat: this.extent.top │ │ │ │ + }); │ │ │ │ + if (firstRendering) { │ │ │ │ + this.tile = new OpenLayers.Tile.Image(this, ulPx, this.extent, null, this.tileSize); │ │ │ │ + this.addTileMonitoringHooks(this.tile) │ │ │ │ + } else { │ │ │ │ + this.tile.size = this.tileSize.clone(); │ │ │ │ + this.tile.position = ulPx.clone() │ │ │ │ + } │ │ │ │ + this.tile.draw() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setTileSize: function() { │ │ │ │ + var tileWidth = this.extent.getWidth() / this.map.getResolution(); │ │ │ │ + var tileHeight = this.extent.getHeight() / this.map.getResolution(); │ │ │ │ + this.tileSize = new OpenLayers.Size(tileWidth, tileHeight) │ │ │ │ + }, │ │ │ │ + addTileMonitoringHooks: function(tile) { │ │ │ │ + tile.onLoadStart = function() { │ │ │ │ + this.events.triggerEvent("loadstart") │ │ │ │ }; │ │ │ │ - if (this.layerDefs) { │ │ │ │ - var layerDefStrList = []; │ │ │ │ - var layerID; │ │ │ │ - for (layerID in this.layerDefs) { │ │ │ │ - if (this.layerDefs.hasOwnProperty(layerID)) { │ │ │ │ - if (this.layerDefs[layerID]) { │ │ │ │ - layerDefStrList.push(layerID); │ │ │ │ - layerDefStrList.push(":"); │ │ │ │ - layerDefStrList.push(this.layerDefs[layerID]); │ │ │ │ - layerDefStrList.push(";") │ │ │ │ + tile.events.register("loadstart", this, tile.onLoadStart); │ │ │ │ + tile.onLoadEnd = function() { │ │ │ │ + this.events.triggerEvent("loadend") │ │ │ │ + }; │ │ │ │ + tile.events.register("loadend", this, tile.onLoadEnd); │ │ │ │ + tile.events.register("unload", this, tile.onLoadEnd) │ │ │ │ + }, │ │ │ │ + removeTileMonitoringHooks: function(tile) { │ │ │ │ + tile.unload(); │ │ │ │ + tile.events.un({ │ │ │ │ + loadstart: tile.onLoadStart, │ │ │ │ + loadend: tile.onLoadEnd, │ │ │ │ + unload: tile.onLoadEnd, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + setUrl: function(newUrl) { │ │ │ │ + this.url = newUrl; │ │ │ │ + this.tile.draw() │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + return this.url │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Image" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Markers = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ + isBaseLayer: false, │ │ │ │ + markers: null, │ │ │ │ + drawn: false, │ │ │ │ + initialize: function(name, options) { │ │ │ │ + OpenLayers.Layer.prototype.initialize.apply(this, arguments); │ │ │ │ + this.markers = [] │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.clearMarkers(); │ │ │ │ + this.markers = null; │ │ │ │ + OpenLayers.Layer.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + setOpacity: function(opacity) { │ │ │ │ + if (opacity != this.opacity) { │ │ │ │ + this.opacity = opacity; │ │ │ │ + for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ + this.markers[i].setOpacity(this.opacity) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ + OpenLayers.Layer.prototype.moveTo.apply(this, arguments); │ │ │ │ + if (zoomChanged || !this.drawn) { │ │ │ │ + for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ + this.drawMarker(this.markers[i]) │ │ │ │ + } │ │ │ │ + this.drawn = true │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + addMarker: function(marker) { │ │ │ │ + this.markers.push(marker); │ │ │ │ + if (this.opacity < 1) { │ │ │ │ + marker.setOpacity(this.opacity) │ │ │ │ + } │ │ │ │ + if (this.map && this.map.getExtent()) { │ │ │ │ + marker.map = this.map; │ │ │ │ + this.drawMarker(marker) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + removeMarker: function(marker) { │ │ │ │ + if (this.markers && this.markers.length) { │ │ │ │ + OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ + marker.erase() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clearMarkers: function() { │ │ │ │ + if (this.markers != null) { │ │ │ │ + while (this.markers.length > 0) { │ │ │ │ + this.removeMarker(this.markers[0]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + drawMarker: function(marker) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(marker.lonlat); │ │ │ │ + if (px == null) { │ │ │ │ + marker.display(false) │ │ │ │ + } else { │ │ │ │ + if (!marker.isDrawn()) { │ │ │ │ + var markerImg = marker.draw(px); │ │ │ │ + this.div.appendChild(markerImg) │ │ │ │ + } else if (marker.icon) { │ │ │ │ + marker.icon.moveTo(px) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getDataExtent: function() { │ │ │ │ + var maxExtent = null; │ │ │ │ + if (this.markers && this.markers.length > 0) { │ │ │ │ + var maxExtent = new OpenLayers.Bounds; │ │ │ │ + for (var i = 0, len = this.markers.length; i < len; i++) { │ │ │ │ + var marker = this.markers[i]; │ │ │ │ + maxExtent.extend(marker.lonlat) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return maxExtent │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Markers" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.Text = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + defaultStyle: null, │ │ │ │ + extractStyles: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + if (options.extractStyles !== false) { │ │ │ │ + options.defaultStyle = { │ │ │ │ + externalGraphic: OpenLayers.Util.getImageLocation("marker.png"), │ │ │ │ + graphicWidth: 21, │ │ │ │ + graphicHeight: 25, │ │ │ │ + graphicXOffset: -10.5, │ │ │ │ + graphicYOffset: -12.5 │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Format.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + read: function(text) { │ │ │ │ + var lines = text.split("\n"); │ │ │ │ + var columns; │ │ │ │ + var features = []; │ │ │ │ + for (var lcv = 0; lcv < lines.length - 1; lcv++) { │ │ │ │ + var currLine = lines[lcv].replace(/^\s*/, "").replace(/\s*$/, ""); │ │ │ │ + if (currLine.charAt(0) != "#") { │ │ │ │ + if (!columns) { │ │ │ │ + columns = currLine.split("\t") │ │ │ │ + } else { │ │ │ │ + var vals = currLine.split("\t"); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ + var attributes = {}; │ │ │ │ + var style = this.defaultStyle ? OpenLayers.Util.applyDefaults({}, this.defaultStyle) : null; │ │ │ │ + var icon, iconSize, iconOffset, overflow; │ │ │ │ + var set = false; │ │ │ │ + for (var valIndex = 0; valIndex < vals.length; valIndex++) { │ │ │ │ + if (vals[valIndex]) { │ │ │ │ + if (columns[valIndex] == "point") { │ │ │ │ + var coords = vals[valIndex].split(","); │ │ │ │ + geometry.y = parseFloat(coords[0]); │ │ │ │ + geometry.x = parseFloat(coords[1]); │ │ │ │ + set = true │ │ │ │ + } else if (columns[valIndex] == "lat") { │ │ │ │ + geometry.y = parseFloat(vals[valIndex]); │ │ │ │ + set = true │ │ │ │ + } else if (columns[valIndex] == "lon") { │ │ │ │ + geometry.x = parseFloat(vals[valIndex]); │ │ │ │ + set = true │ │ │ │ + } else if (columns[valIndex] == "title") attributes["title"] = vals[valIndex]; │ │ │ │ + else if (columns[valIndex] == "image" || columns[valIndex] == "icon" && style) { │ │ │ │ + style["externalGraphic"] = vals[valIndex] │ │ │ │ + } else if (columns[valIndex] == "iconSize" && style) { │ │ │ │ + var size = vals[valIndex].split(","); │ │ │ │ + style["graphicWidth"] = parseFloat(size[0]); │ │ │ │ + style["graphicHeight"] = parseFloat(size[1]) │ │ │ │ + } else if (columns[valIndex] == "iconOffset" && style) { │ │ │ │ + var offset = vals[valIndex].split(","); │ │ │ │ + style["graphicXOffset"] = parseFloat(offset[0]); │ │ │ │ + style["graphicYOffset"] = parseFloat(offset[1]) │ │ │ │ + } else if (columns[valIndex] == "description") { │ │ │ │ + attributes["description"] = vals[valIndex] │ │ │ │ + } else if (columns[valIndex] == "overflow") { │ │ │ │ + attributes["overflow"] = vals[valIndex] │ │ │ │ + } else { │ │ │ │ + attributes[columns[valIndex]] = vals[valIndex] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (set) { │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, attributes, style); │ │ │ │ + features.push(feature) │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - if (layerDefStrList.length > 0) { │ │ │ │ - newParams["LAYERDEFS"] = layerDefStrList.join("") │ │ │ │ + } │ │ │ │ + return features │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Text" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Text = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ + location: null, │ │ │ │ + features: null, │ │ │ │ + formatOptions: null, │ │ │ │ + selectedFeature: null, │ │ │ │ + initialize: function(name, options) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.initialize.apply(this, arguments); │ │ │ │ + this.features = [] │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ + this.clearFeatures(); │ │ │ │ + this.features = null │ │ │ │ + }, │ │ │ │ + loadText: function() { │ │ │ │ + if (!this.loaded) { │ │ │ │ + if (this.location != null) { │ │ │ │ + var onFail = function(e) { │ │ │ │ + this.events.triggerEvent("loadend") │ │ │ │ + }; │ │ │ │ + this.events.triggerEvent("loadstart"); │ │ │ │ + OpenLayers.Request.GET({ │ │ │ │ + url: this.location, │ │ │ │ + success: this.parseData, │ │ │ │ + failure: onFail, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.loaded = true │ │ │ │ } │ │ │ │ } │ │ │ │ - var requestString = this.getFullRequestString(newParams); │ │ │ │ - return requestString │ │ │ │ }, │ │ │ │ - setLayerFilter: function(id, queryDef) { │ │ │ │ - if (!this.layerDefs) { │ │ │ │ - this.layerDefs = {} │ │ │ │ + moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ + if (this.visibility && !this.loaded) { │ │ │ │ + this.loadText() │ │ │ │ } │ │ │ │ - if (queryDef) { │ │ │ │ - this.layerDefs[id] = queryDef │ │ │ │ - } else { │ │ │ │ - delete this.layerDefs[id] │ │ │ │ + }, │ │ │ │ + parseData: function(ajaxRequest) { │ │ │ │ + var text = ajaxRequest.responseText; │ │ │ │ + var options = {}; │ │ │ │ + OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ + if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ + options.externalProjection = this.projection; │ │ │ │ + options.internalProjection = this.map.getProjectionObject() │ │ │ │ + } │ │ │ │ + var parser = new OpenLayers.Format.Text(options); │ │ │ │ + var features = parser.read(text); │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + var data = {}; │ │ │ │ + var feature = features[i]; │ │ │ │ + var location; │ │ │ │ + var iconSize, iconOffset; │ │ │ │ + location = new OpenLayers.LonLat(feature.geometry.x, feature.geometry.y); │ │ │ │ + if (feature.style.graphicWidth && feature.style.graphicHeight) { │ │ │ │ + iconSize = new OpenLayers.Size(feature.style.graphicWidth, feature.style.graphicHeight) │ │ │ │ + } │ │ │ │ + if (feature.style.graphicXOffset !== undefined && feature.style.graphicYOffset !== undefined) { │ │ │ │ + iconOffset = new OpenLayers.Pixel(feature.style.graphicXOffset, feature.style.graphicYOffset) │ │ │ │ + } │ │ │ │ + if (feature.style.externalGraphic != null) { │ │ │ │ + data.icon = new OpenLayers.Icon(feature.style.externalGraphic, iconSize, iconOffset) │ │ │ │ + } else { │ │ │ │ + data.icon = OpenLayers.Marker.defaultIcon(); │ │ │ │ + if (iconSize != null) { │ │ │ │ + data.icon.setSize(iconSize) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (feature.attributes.title != null && feature.attributes.description != null) { │ │ │ │ + data["popupContentHTML"] = "<h2>" + feature.attributes.title + "</h2>" + "<p>" + feature.attributes.description + "</p>" │ │ │ │ + } │ │ │ │ + data["overflow"] = feature.attributes.overflow || "auto"; │ │ │ │ + var markerFeature = new OpenLayers.Feature(this, location, data); │ │ │ │ + this.features.push(markerFeature); │ │ │ │ + var marker = markerFeature.createMarker(); │ │ │ │ + if (feature.attributes.title != null && feature.attributes.description != null) { │ │ │ │ + marker.events.register("click", markerFeature, this.markerClick) │ │ │ │ + } │ │ │ │ + this.addMarker(marker) │ │ │ │ } │ │ │ │ + this.events.triggerEvent("loadend") │ │ │ │ }, │ │ │ │ - clearLayerFilter: function(id) { │ │ │ │ - if (id) { │ │ │ │ - delete this.layerDefs[id] │ │ │ │ - } else { │ │ │ │ - delete this.layerDefs │ │ │ │ + markerClick: function(evt) { │ │ │ │ + var sameMarkerClicked = this == this.layer.selectedFeature; │ │ │ │ + this.layer.selectedFeature = !sameMarkerClicked ? this : null; │ │ │ │ + for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ + this.layer.map.removePopup(this.layer.map.popups[i]) │ │ │ │ + } │ │ │ │ + if (!sameMarkerClicked) { │ │ │ │ + this.layer.map.addPopup(this.createPopup()) │ │ │ │ } │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ }, │ │ │ │ - mergeNewParams: function(newParams) { │ │ │ │ - var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ - var newArguments = [upperParams]; │ │ │ │ - return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, newArguments) │ │ │ │ + clearFeatures: function() { │ │ │ │ + if (this.features != null) { │ │ │ │ + while (this.features.length > 0) { │ │ │ │ + var feature = this.features[0]; │ │ │ │ + OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ + feature.destroy() │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.ArcGIS93Rest" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Text" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ - name: "OpenStreetMap", │ │ │ │ - url: ["http://a.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"], │ │ │ │ - attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ - sphericalMercator: true, │ │ │ │ - wrapDateLine: true, │ │ │ │ - tileOptions: null, │ │ │ │ +OpenLayers.Layer.TMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + serviceVersion: "1.0.0", │ │ │ │ + layername: null, │ │ │ │ + type: null, │ │ │ │ + isBaseLayer: true, │ │ │ │ + tileOrigin: null, │ │ │ │ + serverResolutions: null, │ │ │ │ + zoomOffset: 0, │ │ │ │ initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: "anonymous" │ │ │ │ - }, this.options && this.options.tileOptions) │ │ │ │ + var newArguments = []; │ │ │ │ + newArguments.push(name, url, {}, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.OSM(this.name, this.url, this.getOptions()) │ │ │ │ + obj = new OpenLayers.Layer.TMS(this.name, this.url, this.getOptions()) │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w)); │ │ │ │ + var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h)); │ │ │ │ + var z = this.getServerZoom(); │ │ │ │ + var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type; │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(path, url) │ │ │ │ + } │ │ │ │ + return url + path │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments); │ │ │ │ + if (!this.tileOrigin) { │ │ │ │ + this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left, this.map.maxExtent.bottom) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.TMS" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.MapServer = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - mode: "map", │ │ │ │ - map_imagetype: "png" │ │ │ │ +OpenLayers.Layer.GeoRSS = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ + location: null, │ │ │ │ + features: null, │ │ │ │ + formatOptions: null, │ │ │ │ + selectedFeature: null, │ │ │ │ + icon: null, │ │ │ │ + popupSize: null, │ │ │ │ + useFeedTitle: true, │ │ │ │ + initialize: function(name, location, options) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.initialize.apply(this, [name, options]); │ │ │ │ + this.location = location; │ │ │ │ + this.features = [] │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments); │ │ │ │ + this.clearFeatures(); │ │ │ │ + this.features = null │ │ │ │ + }, │ │ │ │ + loadRSS: function() { │ │ │ │ + if (!this.loaded) { │ │ │ │ + this.events.triggerEvent("loadstart"); │ │ │ │ + OpenLayers.Request.GET({ │ │ │ │ + url: this.location, │ │ │ │ + success: this.parseData, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.loaded = true │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + moveTo: function(bounds, zoomChanged, minor) { │ │ │ │ + OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments); │ │ │ │ + if (this.visibility && !this.loaded) { │ │ │ │ + this.loadRSS() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + parseData: function(ajaxRequest) { │ │ │ │ + var doc = ajaxRequest.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read(ajaxRequest.responseText) │ │ │ │ + } │ │ │ │ + if (this.useFeedTitle) { │ │ │ │ + var name = null; │ │ │ │ + try { │ │ │ │ + name = doc.getElementsByTagNameNS("*", "title")[0].firstChild.nodeValue │ │ │ │ + } catch (e) { │ │ │ │ + try { │ │ │ │ + name = doc.getElementsByTagName("title")[0].firstChild.nodeValue │ │ │ │ + } catch (e) {} │ │ │ │ + } │ │ │ │ + if (name) { │ │ │ │ + this.setName(name) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var options = {}; │ │ │ │ + OpenLayers.Util.extend(options, this.formatOptions); │ │ │ │ + if (this.map && !this.projection.equals(this.map.getProjectionObject())) { │ │ │ │ + options.externalProjection = this.projection; │ │ │ │ + options.internalProjection = this.map.getProjectionObject() │ │ │ │ + } │ │ │ │ + var format = new OpenLayers.Format.GeoRSS(options); │ │ │ │ + var features = format.read(doc); │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + var data = {}; │ │ │ │ + var feature = features[i]; │ │ │ │ + if (!feature.geometry) { │ │ │ │ + continue │ │ │ │ + } │ │ │ │ + var title = feature.attributes.title ? feature.attributes.title : "Untitled"; │ │ │ │ + var description = feature.attributes.description ? feature.attributes.description : "No description."; │ │ │ │ + var link = feature.attributes.link ? feature.attributes.link : ""; │ │ │ │ + var location = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ + data.icon = this.icon == null ? OpenLayers.Marker.defaultIcon() : this.icon.clone(); │ │ │ │ + data.popupSize = this.popupSize ? this.popupSize.clone() : new OpenLayers.Size(250, 120); │ │ │ │ + if (title || description) { │ │ │ │ + data.title = title; │ │ │ │ + data.description = description; │ │ │ │ + var contentHTML = '<div class="olLayerGeoRSSClose">[x]</div>'; │ │ │ │ + contentHTML += '<div class="olLayerGeoRSSTitle">'; │ │ │ │ + if (link) { │ │ │ │ + contentHTML += '<a class="link" href="' + link + '" target="_blank">' │ │ │ │ + } │ │ │ │ + contentHTML += title; │ │ │ │ + if (link) { │ │ │ │ + contentHTML += "</a>" │ │ │ │ + } │ │ │ │ + contentHTML += "</div>"; │ │ │ │ + contentHTML += '<div style="" class="olLayerGeoRSSDescription">'; │ │ │ │ + contentHTML += description; │ │ │ │ + contentHTML += "</div>"; │ │ │ │ + data["popupContentHTML"] = contentHTML │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature(this, location, data); │ │ │ │ + this.features.push(feature); │ │ │ │ + var marker = feature.createMarker(); │ │ │ │ + marker.events.register("click", feature, this.markerClick); │ │ │ │ + this.addMarker(marker) │ │ │ │ + } │ │ │ │ + this.events.triggerEvent("loadend") │ │ │ │ + }, │ │ │ │ + markerClick: function(evt) { │ │ │ │ + var sameMarkerClicked = this == this.layer.selectedFeature; │ │ │ │ + this.layer.selectedFeature = !sameMarkerClicked ? this : null; │ │ │ │ + for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ + this.layer.map.removePopup(this.layer.map.popups[i]) │ │ │ │ + } │ │ │ │ + if (!sameMarkerClicked) { │ │ │ │ + var popup = this.createPopup(); │ │ │ │ + OpenLayers.Event.observe(popup.div, "click", OpenLayers.Function.bind(function() { │ │ │ │ + for (var i = 0, len = this.layer.map.popups.length; i < len; i++) { │ │ │ │ + this.layer.map.removePopup(this.layer.map.popups[i]) │ │ │ │ + } │ │ │ │ + }, this)); │ │ │ │ + this.layer.map.addPopup(popup) │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ + }, │ │ │ │ + clearFeatures: function() { │ │ │ │ + if (this.features != null) { │ │ │ │ + while (this.features.length > 0) { │ │ │ │ + var feature = this.features[0]; │ │ │ │ + OpenLayers.Util.removeItem(this.features, feature); │ │ │ │ + feature.destroy() │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.GeoRSS" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.TileCache = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + isBaseLayer: true, │ │ │ │ + format: "image/png", │ │ │ │ + serverResolutions: null, │ │ │ │ + initialize: function(name, url, layername, options) { │ │ │ │ + this.layername = layername; │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name, url, {}, options]); │ │ │ │ + this.extension = this.format.split("/")[1].toLowerCase(); │ │ │ │ + this.extension = this.extension == "jpg" ? "jpeg" : this.extension │ │ │ │ + }, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.TileCache(this.name, this.url, this.layername, this.getOptions()) │ │ │ │ + } │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + var res = this.getServerResolution(); │ │ │ │ + var bbox = this.maxExtent; │ │ │ │ + var size = this.tileSize; │ │ │ │ + var tileX = Math.round((bounds.left - bbox.left) / (res * size.w)); │ │ │ │ + var tileY = Math.round((bounds.bottom - bbox.bottom) / (res * size.h)); │ │ │ │ + var tileZ = this.serverResolutions != null ? OpenLayers.Util.indexOf(this.serverResolutions, res) : this.map.getZoom(); │ │ │ │ + var components = [this.layername, OpenLayers.Number.zeroPad(tileZ, 2), OpenLayers.Number.zeroPad(parseInt(tileX / 1e6), 3), OpenLayers.Number.zeroPad(parseInt(tileX / 1e3) % 1e3, 3), OpenLayers.Number.zeroPad(parseInt(tileX) % 1e3, 3), OpenLayers.Number.zeroPad(parseInt(tileY / 1e6), 3), OpenLayers.Number.zeroPad(parseInt(tileY / 1e3) % 1e3, 3), OpenLayers.Number.zeroPad(parseInt(tileY) % 1e3, 3) + "." + this.extension]; │ │ │ │ + var path = components.join("/"); │ │ │ │ + var url = this.url; │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(path, url) │ │ │ │ + } │ │ │ │ + url = url.charAt(url.length - 1) == "/" ? url : url + "/"; │ │ │ │ + return url + path │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.TileCache" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.MapGuide = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + isBaseLayer: true, │ │ │ │ + useHttpTile: false, │ │ │ │ + singleTile: false, │ │ │ │ + useOverlay: false, │ │ │ │ + useAsyncOverlay: true, │ │ │ │ + TILE_PARAMS: { │ │ │ │ + operation: "GETTILEIMAGE", │ │ │ │ + version: "1.2.0" │ │ │ │ + }, │ │ │ │ + SINGLE_TILE_PARAMS: { │ │ │ │ + operation: "GETMAPIMAGE", │ │ │ │ + format: "PNG", │ │ │ │ + locale: "en", │ │ │ │ + clip: "1", │ │ │ │ + version: "1.0.0" │ │ │ │ + }, │ │ │ │ + OVERLAY_PARAMS: { │ │ │ │ + operation: "GETDYNAMICMAPOVERLAYIMAGE", │ │ │ │ + format: "PNG", │ │ │ │ + locale: "en", │ │ │ │ + clip: "1", │ │ │ │ + version: "2.0.0" │ │ │ │ + }, │ │ │ │ + FOLDER_PARAMS: { │ │ │ │ + tileColumnsPerFolder: 30, │ │ │ │ + tileRowsPerFolder: 30, │ │ │ │ + format: "png", │ │ │ │ + querystring: null │ │ │ │ }, │ │ │ │ + defaultSize: new OpenLayers.Size(300, 300), │ │ │ │ + tileOriginCorner: "tl", │ │ │ │ initialize: function(name, url, params, options) { │ │ │ │ OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ - this.params = OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS); │ │ │ │ if (options == null || options.isBaseLayer == null) { │ │ │ │ - this.isBaseLayer = this.params.transparent != "true" && this.params.transparent != true │ │ │ │ + this.isBaseLayer = this.transparent != "true" && this.transparent != true │ │ │ │ + } │ │ │ │ + if (options && options.useOverlay != null) { │ │ │ │ + this.useOverlay = options.useOverlay │ │ │ │ + } │ │ │ │ + if (this.singleTile) { │ │ │ │ + if (this.useOverlay) { │ │ │ │ + OpenLayers.Util.applyDefaults(this.params, this.OVERLAY_PARAMS); │ │ │ │ + if (!this.useAsyncOverlay) { │ │ │ │ + this.params.version = "1.0.0" │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + OpenLayers.Util.applyDefaults(this.params, this.SINGLE_TILE_PARAMS) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (this.useHttpTile) { │ │ │ │ + OpenLayers.Util.applyDefaults(this.params, this.FOLDER_PARAMS) │ │ │ │ + } else { │ │ │ │ + OpenLayers.Util.applyDefaults(this.params, this.TILE_PARAMS) │ │ │ │ + } │ │ │ │ + this.setTileSize(this.defaultSize) │ │ │ │ } │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.MapServer(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + obj = new OpenLayers.Layer.MapGuide(this.name, this.url, this.params, this.getOptions()) │ │ │ │ } │ │ │ │ obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var extent = [bounds.left, bounds.bottom, bounds.right, bounds.top]; │ │ │ │ - var imageSize = this.getImageSize(); │ │ │ │ - var url = this.getFullRequestString({ │ │ │ │ - mapext: extent, │ │ │ │ - imgext: extent, │ │ │ │ - map_size: [imageSize.w, imageSize.h], │ │ │ │ - imgx: imageSize.w / 2, │ │ │ │ - imgy: imageSize.h / 2, │ │ │ │ - imgxy: [imageSize.w, imageSize.h] │ │ │ │ - }); │ │ │ │ + var url; │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var mapSize = this.map.getSize(); │ │ │ │ + if (this.singleTile) { │ │ │ │ + var params = { │ │ │ │ + setdisplaydpi: OpenLayers.DOTS_PER_INCH, │ │ │ │ + setdisplayheight: mapSize.h * this.ratio, │ │ │ │ + setdisplaywidth: mapSize.w * this.ratio, │ │ │ │ + setviewcenterx: center.lon, │ │ │ │ + setviewcentery: center.lat, │ │ │ │ + setviewscale: this.map.getScale() │ │ │ │ + }; │ │ │ │ + if (this.useOverlay && !this.useAsyncOverlay) { │ │ │ │ + var getVisParams = {}; │ │ │ │ + getVisParams = OpenLayers.Util.extend(getVisParams, params); │ │ │ │ + getVisParams.operation = "GETVISIBLEMAPEXTENT"; │ │ │ │ + getVisParams.version = "1.0.0"; │ │ │ │ + getVisParams.session = this.params.session; │ │ │ │ + getVisParams.mapName = this.params.mapName; │ │ │ │ + getVisParams.format = "text/xml"; │ │ │ │ + url = this.getFullRequestString(getVisParams); │ │ │ │ + OpenLayers.Request.GET({ │ │ │ │ + url: url, │ │ │ │ + async: false │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + url = this.getFullRequestString(params) │ │ │ │ + } else { │ │ │ │ + var currentRes = this.map.getResolution(); │ │ │ │ + var colidx = Math.floor((bounds.left - this.maxExtent.left) / currentRes); │ │ │ │ + colidx = Math.round(colidx / this.tileSize.w); │ │ │ │ + var rowidx = Math.floor((this.maxExtent.top - bounds.top) / currentRes); │ │ │ │ + rowidx = Math.round(rowidx / this.tileSize.h); │ │ │ │ + if (this.useHttpTile) { │ │ │ │ + url = this.getImageFilePath({ │ │ │ │ + tilecol: colidx, │ │ │ │ + tilerow: rowidx, │ │ │ │ + scaleindex: this.resolutions.length - this.map.zoom - 1 │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + url = this.getFullRequestString({ │ │ │ │ + tilecol: colidx, │ │ │ │ + tilerow: rowidx, │ │ │ │ + scaleindex: this.resolutions.length - this.map.zoom - 1 │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } │ │ │ │ return url │ │ │ │ }, │ │ │ │ getFullRequestString: function(newParams, altUrl) { │ │ │ │ var url = altUrl == null ? this.url : altUrl; │ │ │ │ + if (typeof url == "object") { │ │ │ │ + url = url[Math.floor(Math.random() * url.length)] │ │ │ │ + } │ │ │ │ + var requestString = url; │ │ │ │ var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ - var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(paramsString, url) │ │ │ │ - } │ │ │ │ var urlParams = OpenLayers.Util.upperCaseObject(OpenLayers.Util.getParameters(url)); │ │ │ │ for (var key in allParams) { │ │ │ │ if (key.toUpperCase() in urlParams) { │ │ │ │ delete allParams[key] │ │ │ │ } │ │ │ │ } │ │ │ │ - paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ - var requestString = url; │ │ │ │ + var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ paramsString = paramsString.replace(/,/g, "+"); │ │ │ │ if (paramsString != "") { │ │ │ │ var lastServerChar = url.charAt(url.length - 1); │ │ │ │ if (lastServerChar == "&" || lastServerChar == "?") { │ │ │ │ requestString += paramsString │ │ │ │ } else { │ │ │ │ if (url.indexOf("?") == -1) { │ │ │ │ @@ -17677,202 +18228,400 @@ │ │ │ │ } else { │ │ │ │ requestString += "&" + paramsString │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return requestString │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.MapServer" │ │ │ │ -}); │ │ │ │ -OpenLayers.Layer.KaMap = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - isBaseLayer: true, │ │ │ │ - DEFAULT_PARAMS: { │ │ │ │ - i: "jpeg", │ │ │ │ - map: "" │ │ │ │ - }, │ │ │ │ - initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ - this.params = OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS) │ │ │ │ - }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - bounds = this.adjustBounds(bounds); │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - var scale = Math.round(this.map.getScale() * 1e4) / 1e4; │ │ │ │ - var pX = Math.round(bounds.left / mapRes); │ │ │ │ - var pY = -Math.round(bounds.top / mapRes); │ │ │ │ - return this.getFullRequestString({ │ │ │ │ - t: pY, │ │ │ │ - l: pX, │ │ │ │ - s: scale │ │ │ │ - }) │ │ │ │ + getImageFilePath: function(newParams, altUrl) { │ │ │ │ + var url = altUrl == null ? this.url : altUrl; │ │ │ │ + if (typeof url == "object") { │ │ │ │ + url = url[Math.floor(Math.random() * url.length)] │ │ │ │ + } │ │ │ │ + var requestString = url; │ │ │ │ + var tileRowGroup = ""; │ │ │ │ + var tileColGroup = ""; │ │ │ │ + if (newParams.tilerow < 0) { │ │ │ │ + tileRowGroup = "-" │ │ │ │ + } │ │ │ │ + if (newParams.tilerow == 0) { │ │ │ │ + tileRowGroup += "0" │ │ │ │ + } else { │ │ │ │ + tileRowGroup += Math.floor(Math.abs(newParams.tilerow / this.params.tileRowsPerFolder)) * this.params.tileRowsPerFolder │ │ │ │ + } │ │ │ │ + if (newParams.tilecol < 0) { │ │ │ │ + tileColGroup = "-" │ │ │ │ + } │ │ │ │ + if (newParams.tilecol == 0) { │ │ │ │ + tileColGroup += "0" │ │ │ │ + } else { │ │ │ │ + tileColGroup += Math.floor(Math.abs(newParams.tilecol / this.params.tileColumnsPerFolder)) * this.params.tileColumnsPerFolder │ │ │ │ + } │ │ │ │ + var tilePath = "/S" + Math.floor(newParams.scaleindex) + "/" + this.params.basemaplayergroupname + "/R" + tileRowGroup + "/C" + tileColGroup + "/" + newParams.tilerow % this.params.tileRowsPerFolder + "_" + newParams.tilecol % this.params.tileColumnsPerFolder + "." + this.params.format; │ │ │ │ + if (this.params.querystring) { │ │ │ │ + tilePath += "?" + this.params.querystring │ │ │ │ + } │ │ │ │ + requestString += tilePath; │ │ │ │ + return requestString │ │ │ │ }, │ │ │ │ - calculateGridLayout: function(bounds, origin, resolution) { │ │ │ │ - var tilelon = resolution * this.tileSize.w; │ │ │ │ - var tilelat = resolution * this.tileSize.h; │ │ │ │ - var offsetlon = bounds.left; │ │ │ │ - var tilecol = Math.floor(offsetlon / tilelon) - this.buffer; │ │ │ │ - var offsetlat = bounds.top; │ │ │ │ - var tilerow = Math.floor(offsetlat / tilelat) + this.buffer; │ │ │ │ - return { │ │ │ │ - tilelon: tilelon, │ │ │ │ - tilelat: tilelat, │ │ │ │ - startcol: tilecol, │ │ │ │ - startrow: tilerow │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.MapGuide" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.PointTrack = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ + dataFrom: null, │ │ │ │ + styleFrom: null, │ │ │ │ + addNodes: function(pointFeatures, options) { │ │ │ │ + if (pointFeatures.length < 2) { │ │ │ │ + throw new Error("At least two point features have to be added to " + "create a line from") │ │ │ │ + } │ │ │ │ + var lines = new Array(pointFeatures.length - 1); │ │ │ │ + var pointFeature, startPoint, endPoint; │ │ │ │ + for (var i = 0, len = pointFeatures.length; i < len; i++) { │ │ │ │ + pointFeature = pointFeatures[i]; │ │ │ │ + endPoint = pointFeature.geometry; │ │ │ │ + if (!endPoint) { │ │ │ │ + var lonlat = pointFeature.lonlat; │ │ │ │ + endPoint = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat) │ │ │ │ + } else if (endPoint.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ + throw new TypeError("Only features with point geometries are supported.") │ │ │ │ + } │ │ │ │ + if (i > 0) { │ │ │ │ + var attributes = this.dataFrom != null ? pointFeatures[i + this.dataFrom].data || pointFeatures[i + this.dataFrom].attributes : null; │ │ │ │ + var style = this.styleFrom != null ? pointFeatures[i + this.styleFrom].style : null; │ │ │ │ + var line = new OpenLayers.Geometry.LineString([startPoint, endPoint]); │ │ │ │ + lines[i - 1] = new OpenLayers.Feature.Vector(line, attributes, style) │ │ │ │ + } │ │ │ │ + startPoint = endPoint │ │ │ │ } │ │ │ │ + this.addFeatures(lines, options) │ │ │ │ }, │ │ │ │ - getTileBoundsForGridIndex: function(row, col) { │ │ │ │ - var origin = this.getTileOrigin(); │ │ │ │ - var tileLayout = this.gridLayout; │ │ │ │ - var tilelon = tileLayout.tilelon; │ │ │ │ - var tilelat = tileLayout.tilelat; │ │ │ │ - var minX = (tileLayout.startcol + col) * tilelon; │ │ │ │ - var minY = (tileLayout.startrow - row) * tilelat; │ │ │ │ - return new OpenLayers.Bounds(minX, minY, minX + tilelon, minY + tilelat) │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.PointTrack" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.PointTrack.SOURCE_NODE = -1; │ │ │ │ +OpenLayers.Layer.PointTrack.TARGET_NODE = 0; │ │ │ │ +OpenLayers.Layer.PointTrack.dataFrom = { │ │ │ │ + SOURCE_NODE: -1, │ │ │ │ + TARGET_NODE: 0 │ │ │ │ +}; │ │ │ │ +OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + name: "OpenStreetMap", │ │ │ │ + url: ["http://a.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png", "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"], │ │ │ │ + attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ + sphericalMercator: true, │ │ │ │ + wrapDateLine: true, │ │ │ │ + tileOptions: null, │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: "anonymous" │ │ │ │ + }, this.options && this.options.tileOptions) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.KaMap(this.name, this.url, this.params, this.getOptions()) │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ - if (this.tileSize != null) { │ │ │ │ - obj.tileSize = this.tileSize.clone() │ │ │ │ + obj = new OpenLayers.Layer.OSM(this.name, this.url, this.getOptions()) │ │ │ │ } │ │ │ │ - obj.grid = []; │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ - getTileBounds: function(viewPortPx) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var tileMapWidth = resolution * this.tileSize.w; │ │ │ │ - var tileMapHeight = resolution * this.tileSize.h; │ │ │ │ - var mapPoint = this.getLonLatFromViewPortPx(viewPortPx); │ │ │ │ - var tileLeft = tileMapWidth * Math.floor(mapPoint.lon / tileMapWidth); │ │ │ │ - var tileBottom = tileMapHeight * Math.floor(mapPoint.lat / tileMapHeight); │ │ │ │ - return new OpenLayers.Bounds(tileLeft, tileBottom, tileLeft + tileMapWidth, tileBottom + tileMapHeight) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.KaMap" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.KaMapCache = OpenLayers.Class(OpenLayers.Layer.KaMap, { │ │ │ │ - IMAGE_EXTENSIONS: { │ │ │ │ - jpeg: "jpg", │ │ │ │ - gif: "gif", │ │ │ │ - png: "png", │ │ │ │ - png8: "png", │ │ │ │ - png24: "png", │ │ │ │ - dithered: "png" │ │ │ │ +OpenLayers.Layer.ArcGIS93Rest = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + format: "png" │ │ │ │ }, │ │ │ │ - DEFAULT_FORMAT: "jpeg", │ │ │ │ + isBaseLayer: true, │ │ │ │ initialize: function(name, url, params, options) { │ │ │ │ - OpenLayers.Layer.KaMap.prototype.initialize.apply(this, arguments); │ │ │ │ - this.extension = this.IMAGE_EXTENSIONS[this.params.i.toLowerCase() || this.DEFAULT_FORMAT] │ │ │ │ + var newArguments = []; │ │ │ │ + params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ + newArguments.push(name, url, params, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ + OpenLayers.Util.applyDefaults(this.params, OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)); │ │ │ │ + if (this.params.TRANSPARENT && this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ + if (options == null || !options.isBaseLayer) { │ │ │ │ + this.isBaseLayer = false │ │ │ │ + } │ │ │ │ + if (this.params.FORMAT == "jpg") { │ │ │ │ + this.params.FORMAT = OpenLayers.Util.alphaHack() ? "gif" : "png" │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.ArcGIS93Rest(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + } │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ }, │ │ │ │ getURL: function(bounds) { │ │ │ │ bounds = this.adjustBounds(bounds); │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - var scale = Math.round(this.map.getScale() * 1e4) / 1e4; │ │ │ │ - var pX = Math.round(bounds.left / mapRes); │ │ │ │ - var pY = -Math.round(bounds.top / mapRes); │ │ │ │ - var metaX = Math.floor(pX / this.tileSize.w / this.params.metaTileSize.w) * this.tileSize.w * this.params.metaTileSize.w; │ │ │ │ - var metaY = Math.floor(pY / this.tileSize.h / this.params.metaTileSize.h) * this.tileSize.h * this.params.metaTileSize.h; │ │ │ │ - var components = ["/", this.params.map, "/", scale, "/", this.params.g.replace(/\s/g, "_"), "/def/t", metaY, "/l", metaX, "/t", pY, "l", pX, ".", this.extension]; │ │ │ │ - var url = this.url; │ │ │ │ - if (OpenLayers.Util.isArray(url)) { │ │ │ │ - url = this.selectUrl(components.join(""), url) │ │ │ │ + var projWords = this.projection.getCode().split(":"); │ │ │ │ + var srid = projWords[projWords.length - 1]; │ │ │ │ + var imageSize = this.getImageSize(); │ │ │ │ + var newParams = { │ │ │ │ + BBOX: bounds.toBBOX(), │ │ │ │ + SIZE: imageSize.w + "," + imageSize.h, │ │ │ │ + F: "image", │ │ │ │ + BBOXSR: srid, │ │ │ │ + IMAGESR: srid │ │ │ │ + }; │ │ │ │ + if (this.layerDefs) { │ │ │ │ + var layerDefStrList = []; │ │ │ │ + var layerID; │ │ │ │ + for (layerID in this.layerDefs) { │ │ │ │ + if (this.layerDefs.hasOwnProperty(layerID)) { │ │ │ │ + if (this.layerDefs[layerID]) { │ │ │ │ + layerDefStrList.push(layerID); │ │ │ │ + layerDefStrList.push(":"); │ │ │ │ + layerDefStrList.push(this.layerDefs[layerID]); │ │ │ │ + layerDefStrList.push(";") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (layerDefStrList.length > 0) { │ │ │ │ + newParams["LAYERDEFS"] = layerDefStrList.join("") │ │ │ │ + } │ │ │ │ } │ │ │ │ - return url + components.join("") │ │ │ │ + var requestString = this.getFullRequestString(newParams); │ │ │ │ + return requestString │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.KaMapCache" │ │ │ │ + setLayerFilter: function(id, queryDef) { │ │ │ │ + if (!this.layerDefs) { │ │ │ │ + this.layerDefs = {} │ │ │ │ + } │ │ │ │ + if (queryDef) { │ │ │ │ + this.layerDefs[id] = queryDef │ │ │ │ + } else { │ │ │ │ + delete this.layerDefs[id] │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clearLayerFilter: function(id) { │ │ │ │ + if (id) { │ │ │ │ + delete this.layerDefs[id] │ │ │ │ + } else { │ │ │ │ + delete this.layerDefs │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ + var newArguments = [upperParams]; │ │ │ │ + return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, newArguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.ArcGIS93Rest" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.Image = OpenLayers.Class(OpenLayers.Layer, { │ │ │ │ - isBaseLayer: true, │ │ │ │ - url: null, │ │ │ │ - extent: null, │ │ │ │ - size: null, │ │ │ │ - tile: null, │ │ │ │ - aspectRatio: null, │ │ │ │ - initialize: function(name, url, extent, size, options) { │ │ │ │ - this.url = url; │ │ │ │ - this.extent = extent; │ │ │ │ - this.maxExtent = extent; │ │ │ │ - this.size = size; │ │ │ │ - OpenLayers.Layer.prototype.initialize.apply(this, [name, options]); │ │ │ │ - this.aspectRatio = this.extent.getHeight() / this.size.h / (this.extent.getWidth() / this.size.w) │ │ │ │ +OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + key: null, │ │ │ │ + serverResolutions: [156543.03390625, 78271.516953125, 39135.7584765625, 19567.87923828125, 9783.939619140625, 4891.9698095703125, 2445.9849047851562, 1222.9924523925781, 611.4962261962891, 305.74811309814453, 152.87405654907226, 76.43702827453613, 38.218514137268066, 19.109257068634033, 9.554628534317017, 4.777314267158508, 2.388657133579254, 1.194328566789627, .5971642833948135, .29858214169740677, .14929107084870338, .07464553542435169], │ │ │ │ + attributionTemplate: '<span class="olBingAttribution ${type}">' + '<div><a target="_blank" href="http://www.bing.com/maps/">' + '<img src="${logo}" /></a></div>${copyrights}' + '<a style="white-space: nowrap" target="_blank" ' + 'href="http://www.microsoft.com/maps/product/terms.html">' + "Terms of Use</a></span>", │ │ │ │ + metadata: null, │ │ │ │ + protocolRegex: /^http:/i, │ │ │ │ + type: "Road", │ │ │ │ + culture: "en-US", │ │ │ │ + metadataParams: null, │ │ │ │ + tileOptions: null, │ │ │ │ + protocol: ~window.location.href.indexOf("http") ? "" : "http:", │ │ │ │ + initialize: function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + sphericalMercator: true │ │ │ │ + }, options); │ │ │ │ + var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ + var newArgs = [name, null, options]; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: "anonymous" │ │ │ │ + }, this.options.tileOptions); │ │ │ │ + this.loadMetadata() │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.tile) { │ │ │ │ - this.removeTileMonitoringHooks(this.tile); │ │ │ │ - this.tile.destroy(); │ │ │ │ - this.tile = null │ │ │ │ + loadMetadata: function() { │ │ │ │ + this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ + window[this._callbackId] = OpenLayers.Function.bind(OpenLayers.Layer.Bing.processMetadata, this); │ │ │ │ + var params = OpenLayers.Util.applyDefaults({ │ │ │ │ + key: this.key, │ │ │ │ + jsonp: this._callbackId, │ │ │ │ + include: "ImageryProviders" │ │ │ │ + }, this.metadataParams); │ │ │ │ + var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = this._callbackId; │ │ │ │ + document.getElementsByTagName("head")[0].appendChild(script) │ │ │ │ + }, │ │ │ │ + initLayer: function() { │ │ │ │ + var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ + var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ + url = url.replace("{culture}", this.culture); │ │ │ │ + url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.url = []; │ │ │ │ + for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ + this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])) │ │ │ │ } │ │ │ │ - OpenLayers.Layer.prototype.destroy.apply(this, arguments) │ │ │ │ + this.addOptions({ │ │ │ │ + maxResolution: Math.min(this.serverResolutions[res.zoomMin], this.maxResolution || Number.POSITIVE_INFINITY), │ │ │ │ + numZoomLevels: Math.min(res.zoomMax + 1 - res.zoomMin, this.numZoomLevels) │ │ │ │ + }, true); │ │ │ │ + if (!this.isBaseLayer) { │ │ │ │ + this.redraw() │ │ │ │ + } │ │ │ │ + this.updateAttribution() │ │ │ │ + }, │ │ │ │ + getURL: function(bounds) { │ │ │ │ + if (!this.url) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var xyz = this.getXYZ(bounds), │ │ │ │ + x = xyz.x, │ │ │ │ + y = xyz.y, │ │ │ │ + z = xyz.z; │ │ │ │ + var quadDigits = []; │ │ │ │ + for (var i = z; i > 0; --i) { │ │ │ │ + var digit = "0"; │ │ │ │ + var mask = 1 << i - 1; │ │ │ │ + if ((x & mask) != 0) { │ │ │ │ + digit++ │ │ │ │ + } │ │ │ │ + if ((y & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + digit++ │ │ │ │ + } │ │ │ │ + quadDigits.push(digit) │ │ │ │ + } │ │ │ │ + var quadKey = quadDigits.join(""); │ │ │ │ + var url = this.selectUrl("" + x + y + z, this.url); │ │ │ │ + return OpenLayers.String.format(url, { │ │ │ │ + quadkey: quadKey │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + updateAttribution: function() { │ │ │ │ + var metadata = this.metadata; │ │ │ │ + if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var res = metadata.resourceSets[0].resources[0]; │ │ │ │ + var extent = this.map.getExtent().transform(this.map.getProjectionObject(), new OpenLayers.Projection("EPSG:4326")); │ │ │ │ + var providers = res.imageryProviders || [], │ │ │ │ + zoom = OpenLayers.Util.indexOf(this.serverResolutions, this.getServerResolution()), │ │ │ │ + copyrights = "", │ │ │ │ + provider, i, ii, j, jj, bbox, coverage; │ │ │ │ + for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ + provider = providers[i]; │ │ │ │ + for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ + coverage = provider.coverageAreas[j]; │ │ │ │ + bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ + if (extent.intersectsBounds(bbox) && zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ + copyrights += provider.attribution + " " │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ + type: this.type.toLowerCase(), │ │ │ │ + logo: logo, │ │ │ │ + copyrights: copyrights │ │ │ │ + }); │ │ │ │ + this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "attribution" │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + setMap: function() { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("moveend", this, this.updateAttribution) │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Image(this.name, this.url, this.extent, this.size, this.getOptions()) │ │ │ │ + obj = new OpenLayers.Layer.Bing(this.options) │ │ │ │ } │ │ │ │ - obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]); │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - if (this.options.maxResolution == null) { │ │ │ │ - this.options.maxResolution = this.aspectRatio * this.extent.getWidth() / this.size.w │ │ │ │ - } │ │ │ │ - OpenLayers.Layer.prototype.setMap.apply(this, arguments) │ │ │ │ + destroy: function() { │ │ │ │ + this.map && this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ + OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - moveTo: function(bounds, zoomChanged, dragging) { │ │ │ │ - OpenLayers.Layer.prototype.moveTo.apply(this, arguments); │ │ │ │ - var firstRendering = this.tile == null; │ │ │ │ - if (zoomChanged || firstRendering) { │ │ │ │ - this.setTileSize(); │ │ │ │ - var ulPx = this.map.getLayerPxFromLonLat({ │ │ │ │ - lon: this.extent.left, │ │ │ │ - lat: this.extent.top │ │ │ │ - }); │ │ │ │ - if (firstRendering) { │ │ │ │ - this.tile = new OpenLayers.Tile.Image(this, ulPx, this.extent, null, this.tileSize); │ │ │ │ - this.addTileMonitoringHooks(this.tile) │ │ │ │ - } else { │ │ │ │ - this.tile.size = this.tileSize.clone(); │ │ │ │ - this.tile.position = ulPx.clone() │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ + this.metadata = metadata; │ │ │ │ + this.initLayer(); │ │ │ │ + var script = document.getElementById(this._callbackId); │ │ │ │ + script.parentNode.removeChild(script); │ │ │ │ + window[this._callbackId] = undefined; │ │ │ │ + delete this._callbackId │ │ │ │ +}; │ │ │ │ +OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + service: "WMS", │ │ │ │ + version: "1.1.1", │ │ │ │ + request: "GetMap", │ │ │ │ + styles: "", │ │ │ │ + format: "image/jpeg" │ │ │ │ + }, │ │ │ │ + isBaseLayer: true, │ │ │ │ + encodeBBOX: false, │ │ │ │ + noMagic: false, │ │ │ │ + yx: {}, │ │ │ │ + initialize: function(name, url, params, options) { │ │ │ │ + var newArguments = []; │ │ │ │ + params = OpenLayers.Util.upperCaseObject(params); │ │ │ │ + if (parseFloat(params.VERSION) >= 1.3 && !params.EXCEPTIONS) { │ │ │ │ + params.EXCEPTIONS = "INIMAGE" │ │ │ │ + } │ │ │ │ + newArguments.push(name, url, params, options); │ │ │ │ + OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments); │ │ │ │ + OpenLayers.Util.applyDefaults(this.params, OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)); │ │ │ │ + if (!this.noMagic && this.params.TRANSPARENT && this.params.TRANSPARENT.toString().toLowerCase() == "true") { │ │ │ │ + if (options == null || !options.isBaseLayer) { │ │ │ │ + this.isBaseLayer = false │ │ │ │ + } │ │ │ │ + if (this.params.FORMAT == "image/jpeg") { │ │ │ │ + this.params.FORMAT = OpenLayers.Util.alphaHack() ? "image/gif" : "image/png" │ │ │ │ } │ │ │ │ - this.tile.draw() │ │ │ │ } │ │ │ │ }, │ │ │ │ - setTileSize: function() { │ │ │ │ - var tileWidth = this.extent.getWidth() / this.map.getResolution(); │ │ │ │ - var tileHeight = this.extent.getHeight() / this.map.getResolution(); │ │ │ │ - this.tileSize = new OpenLayers.Size(tileWidth, tileHeight) │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.WMS(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + } │ │ │ │ + obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ + return obj │ │ │ │ }, │ │ │ │ - addTileMonitoringHooks: function(tile) { │ │ │ │ - tile.onLoadStart = function() { │ │ │ │ - this.events.triggerEvent("loadstart") │ │ │ │ - }; │ │ │ │ - tile.events.register("loadstart", this, tile.onLoadStart); │ │ │ │ - tile.onLoadEnd = function() { │ │ │ │ - this.events.triggerEvent("loadend") │ │ │ │ - }; │ │ │ │ - tile.events.register("loadend", this, tile.onLoadEnd); │ │ │ │ - tile.events.register("unload", this, tile.onLoadEnd) │ │ │ │ + reverseAxisOrder: function() { │ │ │ │ + var projCode = this.projection.getCode(); │ │ │ │ + return parseFloat(this.params.VERSION) >= 1.3 && !!(this.yx[projCode] || OpenLayers.Projection.defaults[projCode] && OpenLayers.Projection.defaults[projCode].yx) │ │ │ │ }, │ │ │ │ - removeTileMonitoringHooks: function(tile) { │ │ │ │ - tile.unload(); │ │ │ │ - tile.events.un({ │ │ │ │ - loadstart: tile.onLoadStart, │ │ │ │ - loadend: tile.onLoadEnd, │ │ │ │ - unload: tile.onLoadEnd, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + getURL: function(bounds) { │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var imageSize = this.getImageSize(); │ │ │ │ + var newParams = {}; │ │ │ │ + var reverseAxisOrder = this.reverseAxisOrder(); │ │ │ │ + newParams.BBOX = this.encodeBBOX ? bounds.toBBOX(null, reverseAxisOrder) : bounds.toArray(reverseAxisOrder); │ │ │ │ + newParams.WIDTH = imageSize.w; │ │ │ │ + newParams.HEIGHT = imageSize.h; │ │ │ │ + var requestString = this.getFullRequestString(newParams); │ │ │ │ + return requestString │ │ │ │ }, │ │ │ │ - setUrl: function(newUrl) { │ │ │ │ - this.url = newUrl; │ │ │ │ - this.tile.draw() │ │ │ │ + mergeNewParams: function(newParams) { │ │ │ │ + var upperParams = OpenLayers.Util.upperCaseObject(newParams); │ │ │ │ + var newArguments = [upperParams]; │ │ │ │ + return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, newArguments) │ │ │ │ }, │ │ │ │ - getURL: function(bounds) { │ │ │ │ - return this.url │ │ │ │ + getFullRequestString: function(newParams, altUrl) { │ │ │ │ + var mapProjection = this.map.getProjectionObject(); │ │ │ │ + var projectionCode = this.projection && this.projection.equals(mapProjection) ? this.projection.getCode() : mapProjection.getCode(); │ │ │ │ + var value = projectionCode == "none" ? null : projectionCode; │ │ │ │ + if (parseFloat(this.params.VERSION) >= 1.3) { │ │ │ │ + this.params.CRS = value │ │ │ │ + } else { │ │ │ │ + this.params.SRS = value │ │ │ │ + } │ │ │ │ + if (typeof this.params.TRANSPARENT == "boolean") { │ │ │ │ + newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE" │ │ │ │ + } │ │ │ │ + return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, arguments) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Image" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ }); │ │ │ │ OpenLayers.Layer.WMTS = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ isBaseLayer: true, │ │ │ │ version: "1.0.0", │ │ │ │ requestEncoding: "KVP", │ │ │ │ url: null, │ │ │ │ layer: null, │ │ │ │ @@ -18073,144 +18822,63 @@ │ │ │ │ mergeNewParams: function(newParams) { │ │ │ │ if (this.requestEncoding.toUpperCase() === "KVP") { │ │ │ │ return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, [OpenLayers.Util.upperCaseObject(newParams)]) │ │ │ │ } │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Layer.WMTS" │ │ │ │ }); │ │ │ │ -OpenLayers.Layer.MapGuide = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ - isBaseLayer: true, │ │ │ │ - useHttpTile: false, │ │ │ │ - singleTile: false, │ │ │ │ - useOverlay: false, │ │ │ │ - useAsyncOverlay: true, │ │ │ │ - TILE_PARAMS: { │ │ │ │ - operation: "GETTILEIMAGE", │ │ │ │ - version: "1.2.0" │ │ │ │ - }, │ │ │ │ - SINGLE_TILE_PARAMS: { │ │ │ │ - operation: "GETMAPIMAGE", │ │ │ │ - format: "PNG", │ │ │ │ - locale: "en", │ │ │ │ - clip: "1", │ │ │ │ - version: "1.0.0" │ │ │ │ - }, │ │ │ │ - OVERLAY_PARAMS: { │ │ │ │ - operation: "GETDYNAMICMAPOVERLAYIMAGE", │ │ │ │ - format: "PNG", │ │ │ │ - locale: "en", │ │ │ │ - clip: "1", │ │ │ │ - version: "2.0.0" │ │ │ │ - }, │ │ │ │ - FOLDER_PARAMS: { │ │ │ │ - tileColumnsPerFolder: 30, │ │ │ │ - tileRowsPerFolder: 30, │ │ │ │ - format: "png", │ │ │ │ - querystring: null │ │ │ │ +OpenLayers.Layer.MapServer = OpenLayers.Class(OpenLayers.Layer.Grid, { │ │ │ │ + DEFAULT_PARAMS: { │ │ │ │ + mode: "map", │ │ │ │ + map_imagetype: "png" │ │ │ │ }, │ │ │ │ - defaultSize: new OpenLayers.Size(300, 300), │ │ │ │ - tileOriginCorner: "tl", │ │ │ │ initialize: function(name, url, params, options) { │ │ │ │ OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); │ │ │ │ + this.params = OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS); │ │ │ │ if (options == null || options.isBaseLayer == null) { │ │ │ │ - this.isBaseLayer = this.transparent != "true" && this.transparent != true │ │ │ │ - } │ │ │ │ - if (options && options.useOverlay != null) { │ │ │ │ - this.useOverlay = options.useOverlay │ │ │ │ - } │ │ │ │ - if (this.singleTile) { │ │ │ │ - if (this.useOverlay) { │ │ │ │ - OpenLayers.Util.applyDefaults(this.params, this.OVERLAY_PARAMS); │ │ │ │ - if (!this.useAsyncOverlay) { │ │ │ │ - this.params.version = "1.0.0" │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Util.applyDefaults(this.params, this.SINGLE_TILE_PARAMS) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (this.useHttpTile) { │ │ │ │ - OpenLayers.Util.applyDefaults(this.params, this.FOLDER_PARAMS) │ │ │ │ - } else { │ │ │ │ - OpenLayers.Util.applyDefaults(this.params, this.TILE_PARAMS) │ │ │ │ - } │ │ │ │ - this.setTileSize(this.defaultSize) │ │ │ │ + this.isBaseLayer = this.params.transparent != "true" && this.params.transparent != true │ │ │ │ } │ │ │ │ }, │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.MapGuide(this.name, this.url, this.params, this.getOptions()) │ │ │ │ + obj = new OpenLayers.Layer.MapServer(this.name, this.url, this.params, this.getOptions()) │ │ │ │ } │ │ │ │ obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]); │ │ │ │ return obj │ │ │ │ }, │ │ │ │ getURL: function(bounds) { │ │ │ │ - var url; │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var mapSize = this.map.getSize(); │ │ │ │ - if (this.singleTile) { │ │ │ │ - var params = { │ │ │ │ - setdisplaydpi: OpenLayers.DOTS_PER_INCH, │ │ │ │ - setdisplayheight: mapSize.h * this.ratio, │ │ │ │ - setdisplaywidth: mapSize.w * this.ratio, │ │ │ │ - setviewcenterx: center.lon, │ │ │ │ - setviewcentery: center.lat, │ │ │ │ - setviewscale: this.map.getScale() │ │ │ │ - }; │ │ │ │ - if (this.useOverlay && !this.useAsyncOverlay) { │ │ │ │ - var getVisParams = {}; │ │ │ │ - getVisParams = OpenLayers.Util.extend(getVisParams, params); │ │ │ │ - getVisParams.operation = "GETVISIBLEMAPEXTENT"; │ │ │ │ - getVisParams.version = "1.0.0"; │ │ │ │ - getVisParams.session = this.params.session; │ │ │ │ - getVisParams.mapName = this.params.mapName; │ │ │ │ - getVisParams.format = "text/xml"; │ │ │ │ - url = this.getFullRequestString(getVisParams); │ │ │ │ - OpenLayers.Request.GET({ │ │ │ │ - url: url, │ │ │ │ - async: false │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - url = this.getFullRequestString(params) │ │ │ │ - } else { │ │ │ │ - var currentRes = this.map.getResolution(); │ │ │ │ - var colidx = Math.floor((bounds.left - this.maxExtent.left) / currentRes); │ │ │ │ - colidx = Math.round(colidx / this.tileSize.w); │ │ │ │ - var rowidx = Math.floor((this.maxExtent.top - bounds.top) / currentRes); │ │ │ │ - rowidx = Math.round(rowidx / this.tileSize.h); │ │ │ │ - if (this.useHttpTile) { │ │ │ │ - url = this.getImageFilePath({ │ │ │ │ - tilecol: colidx, │ │ │ │ - tilerow: rowidx, │ │ │ │ - scaleindex: this.resolutions.length - this.map.zoom - 1 │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - url = this.getFullRequestString({ │ │ │ │ - tilecol: colidx, │ │ │ │ - tilerow: rowidx, │ │ │ │ - scaleindex: this.resolutions.length - this.map.zoom - 1 │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + bounds = this.adjustBounds(bounds); │ │ │ │ + var extent = [bounds.left, bounds.bottom, bounds.right, bounds.top]; │ │ │ │ + var imageSize = this.getImageSize(); │ │ │ │ + var url = this.getFullRequestString({ │ │ │ │ + mapext: extent, │ │ │ │ + imgext: extent, │ │ │ │ + map_size: [imageSize.w, imageSize.h], │ │ │ │ + imgx: imageSize.w / 2, │ │ │ │ + imgy: imageSize.h / 2, │ │ │ │ + imgxy: [imageSize.w, imageSize.h] │ │ │ │ + }); │ │ │ │ return url │ │ │ │ }, │ │ │ │ getFullRequestString: function(newParams, altUrl) { │ │ │ │ var url = altUrl == null ? this.url : altUrl; │ │ │ │ - if (typeof url == "object") { │ │ │ │ - url = url[Math.floor(Math.random() * url.length)] │ │ │ │ - } │ │ │ │ - var requestString = url; │ │ │ │ var allParams = OpenLayers.Util.extend({}, this.params); │ │ │ │ allParams = OpenLayers.Util.extend(allParams, newParams); │ │ │ │ + var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + if (OpenLayers.Util.isArray(url)) { │ │ │ │ + url = this.selectUrl(paramsString, url) │ │ │ │ + } │ │ │ │ var urlParams = OpenLayers.Util.upperCaseObject(OpenLayers.Util.getParameters(url)); │ │ │ │ for (var key in allParams) { │ │ │ │ if (key.toUpperCase() in urlParams) { │ │ │ │ delete allParams[key] │ │ │ │ } │ │ │ │ } │ │ │ │ - var paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + paramsString = OpenLayers.Util.getParameterString(allParams); │ │ │ │ + var requestString = url; │ │ │ │ paramsString = paramsString.replace(/,/g, "+"); │ │ │ │ if (paramsString != "") { │ │ │ │ var lastServerChar = url.charAt(url.length - 1); │ │ │ │ if (lastServerChar == "&" || lastServerChar == "?") { │ │ │ │ requestString += paramsString │ │ │ │ } else { │ │ │ │ if (url.indexOf("?") == -1) { │ │ │ │ @@ -18218,46 +18886,46 @@ │ │ │ │ } else { │ │ │ │ requestString += "&" + paramsString │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return requestString │ │ │ │ }, │ │ │ │ - getImageFilePath: function(newParams, altUrl) { │ │ │ │ - var url = altUrl == null ? this.url : altUrl; │ │ │ │ - if (typeof url == "object") { │ │ │ │ - url = url[Math.floor(Math.random() * url.length)] │ │ │ │ - } │ │ │ │ - var requestString = url; │ │ │ │ - var tileRowGroup = ""; │ │ │ │ - var tileColGroup = ""; │ │ │ │ - if (newParams.tilerow < 0) { │ │ │ │ - tileRowGroup = "-" │ │ │ │ - } │ │ │ │ - if (newParams.tilerow == 0) { │ │ │ │ - tileRowGroup += "0" │ │ │ │ - } else { │ │ │ │ - tileRowGroup += Math.floor(Math.abs(newParams.tilerow / this.params.tileRowsPerFolder)) * this.params.tileRowsPerFolder │ │ │ │ - } │ │ │ │ - if (newParams.tilecol < 0) { │ │ │ │ - tileColGroup = "-" │ │ │ │ - } │ │ │ │ - if (newParams.tilecol == 0) { │ │ │ │ - tileColGroup += "0" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.MapServer" │ │ │ │ +}); │ │ │ │ +OpenLayers.Layer.Boxes = OpenLayers.Class(OpenLayers.Layer.Markers, { │ │ │ │ + drawMarker: function(marker) { │ │ │ │ + var topleft = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: marker.bounds.left, │ │ │ │ + lat: marker.bounds.top │ │ │ │ + }); │ │ │ │ + var botright = this.map.getLayerPxFromLonLat({ │ │ │ │ + lon: marker.bounds.right, │ │ │ │ + lat: marker.bounds.bottom │ │ │ │ + }); │ │ │ │ + if (botright == null || topleft == null) { │ │ │ │ + marker.display(false) │ │ │ │ } else { │ │ │ │ - tileColGroup += Math.floor(Math.abs(newParams.tilecol / this.params.tileColumnsPerFolder)) * this.params.tileColumnsPerFolder │ │ │ │ + var markerDiv = marker.draw(topleft, { │ │ │ │ + w: Math.max(1, botright.x - topleft.x), │ │ │ │ + h: Math.max(1, botright.y - topleft.y) │ │ │ │ + }); │ │ │ │ + if (!marker.drawn) { │ │ │ │ + this.div.appendChild(markerDiv); │ │ │ │ + marker.drawn = true │ │ │ │ + } │ │ │ │ } │ │ │ │ - var tilePath = "/S" + Math.floor(newParams.scaleindex) + "/" + this.params.basemaplayergroupname + "/R" + tileRowGroup + "/C" + tileColGroup + "/" + newParams.tilerow % this.params.tileRowsPerFolder + "_" + newParams.tilecol % this.params.tileColumnsPerFolder + "." + this.params.format; │ │ │ │ - if (this.params.querystring) { │ │ │ │ - tilePath += "?" + this.params.querystring │ │ │ │ + }, │ │ │ │ + removeMarker: function(marker) { │ │ │ │ + OpenLayers.Util.removeItem(this.markers, marker); │ │ │ │ + if (marker.div != null && marker.div.parentNode == this.div) { │ │ │ │ + this.div.removeChild(marker.div) │ │ │ │ } │ │ │ │ - requestString += tilePath; │ │ │ │ - return requestString │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.MapGuide" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Boxes" │ │ │ │ }); │ │ │ │ OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, { │ │ │ │ displayInLayerSwitcher: false, │ │ │ │ layers: null, │ │ │ │ display: function() {}, │ │ │ │ getFeatureFromEvent: function(evt) { │ │ │ │ var layers = this.layers; │ │ │ │ @@ -18453,2078 +19121,4868 @@ │ │ │ │ } │ │ │ │ return gLatLng │ │ │ │ }, │ │ │ │ getMapObjectPixelFromXY: function(x, y) { │ │ │ │ return new google.maps.Point(x, y) │ │ │ │ } │ │ │ │ }; │ │ │ │ -OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ - target: null, │ │ │ │ - events: ["mousedown", "mouseup", "click", "dblclick", "touchstart", "touchmove", "touchend", "keydown"], │ │ │ │ - startRegEx: /^mousedown|touchstart$/, │ │ │ │ - cancelRegEx: /^touchmove$/, │ │ │ │ - completeRegEx: /^mouseup|touchend$/, │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ - extension: true │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.unregister(this.events[i], this, this.buttonClick) │ │ │ │ - } │ │ │ │ - delete this.target │ │ │ │ - }, │ │ │ │ - getPressedButton: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - button; │ │ │ │ - do { │ │ │ │ - if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ - button = element; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - element = element.parentNode │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return button │ │ │ │ - }, │ │ │ │ - ignore: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - ignore = false; │ │ │ │ - do { │ │ │ │ - if (element.nodeName.toLowerCase() === "a") { │ │ │ │ - ignore = true; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - element = element.parentNode │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return ignore │ │ │ │ - }, │ │ │ │ - buttonClick: function(evt) { │ │ │ │ - var propagate = true, │ │ │ │ - element = OpenLayers.Event.element(evt); │ │ │ │ - if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ - var button = this.getPressedButton(element); │ │ │ │ - if (button) { │ │ │ │ - if (evt.type === "keydown") { │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_RETURN: │ │ │ │ - case OpenLayers.Event.KEY_SPACE: │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button │ │ │ │ - }); │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else if (this.startEvt) { │ │ │ │ - if (this.completeRegEx.test(evt.type)) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ - var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ - var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ - var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ - pos[0] = pos[0] - scrollLeft; │ │ │ │ - pos[1] = pos[1] - scrollTop; │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button, │ │ │ │ - buttonXY: { │ │ │ │ - x: this.startEvt.clientX - pos[0], │ │ │ │ - y: this.startEvt.clientY - pos[1] │ │ │ │ - } │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (this.cancelRegEx.test(evt.type)) { │ │ │ │ - delete this.startEvt │ │ │ │ - } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false │ │ │ │ +OpenLayers.Tile.Image.IFrame = { │ │ │ │ + useIFrame: null, │ │ │ │ + blankImageUrl: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAQAIBRAA7", │ │ │ │ + draw: function() { │ │ │ │ + var draw = OpenLayers.Tile.Image.prototype.shouldDraw.call(this); │ │ │ │ + if (draw) { │ │ │ │ + var url = this.layer.getURL(this.bounds); │ │ │ │ + var usedIFrame = this.useIFrame; │ │ │ │ + this.useIFrame = this.maxGetUrlLength !== null && !this.layer.async && url.length > this.maxGetUrlLength; │ │ │ │ + var fromIFrame = usedIFrame && !this.useIFrame; │ │ │ │ + var toIFrame = !usedIFrame && this.useIFrame; │ │ │ │ + if (fromIFrame || toIFrame) { │ │ │ │ + if (this.imgDiv && this.imgDiv.parentNode === this.frame) { │ │ │ │ + this.frame.removeChild(this.imgDiv) │ │ │ │ } │ │ │ │ - if (this.startRegEx.test(evt.type)) { │ │ │ │ - this.startEvt = evt; │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false │ │ │ │ + this.imgDiv = null; │ │ │ │ + if (fromIFrame) { │ │ │ │ + this.frame.removeChild(this.frame.firstChild) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ - delete this.startEvt │ │ │ │ } │ │ │ │ } │ │ │ │ - return propagate │ │ │ │ - } │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - controls: null, │ │ │ │ - autoActivate: true, │ │ │ │ - defaultControl: null, │ │ │ │ - saveState: false, │ │ │ │ - allowDepress: false, │ │ │ │ - activeState: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.controls = []; │ │ │ │ - this.activeState = {} │ │ │ │ + return OpenLayers.Tile.Image.prototype.draw.apply(this, arguments) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ - ctl = this.controls[i]; │ │ │ │ - if (ctl.events) { │ │ │ │ - ctl.events.un({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }) │ │ │ │ + getImage: function() { │ │ │ │ + if (this.useIFrame === true) { │ │ │ │ + if (!this.frame.childNodes.length) { │ │ │ │ + var eventPane = document.createElement("div"), │ │ │ │ + style = eventPane.style; │ │ │ │ + style.position = "absolute"; │ │ │ │ + style.width = "100%"; │ │ │ │ + style.height = "100%"; │ │ │ │ + style.zIndex = 1; │ │ │ │ + style.backgroundImage = "url(" + this.blankImageUrl + ")"; │ │ │ │ + this.frame.appendChild(eventPane) │ │ │ │ } │ │ │ │ - ctl.panel_div = null │ │ │ │ - } │ │ │ │ - this.activeState = null │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - if (control === this.defaultControl || this.saveState && this.activeState[control.id]) { │ │ │ │ - control.activate() │ │ │ │ - } │ │ │ │ + var id = this.id + "_iFrame", │ │ │ │ + iframe; │ │ │ │ + if (parseFloat(navigator.appVersion.split("MSIE")[1]) < 9) { │ │ │ │ + iframe = document.createElement('<iframe name="' + id + '">'); │ │ │ │ + iframe.style.backgroundColor = "#FFFFFF"; │ │ │ │ + iframe.style.filter = "chroma(color=#FFFFFF)" │ │ │ │ + } else { │ │ │ │ + iframe = document.createElement("iframe"); │ │ │ │ + iframe.style.backgroundColor = "transparent"; │ │ │ │ + iframe.name = id │ │ │ │ } │ │ │ │ - if (this.saveState === true) { │ │ │ │ - this.defaultControl = null │ │ │ │ + iframe.scrolling = "no"; │ │ │ │ + iframe.marginWidth = "0px"; │ │ │ │ + iframe.marginHeight = "0px"; │ │ │ │ + iframe.frameBorder = "0"; │ │ │ │ + iframe.style.position = "absolute"; │ │ │ │ + iframe.style.width = "100%"; │ │ │ │ + iframe.style.height = "100%"; │ │ │ │ + if (this.layer.opacity < 1) { │ │ │ │ + OpenLayers.Util.modifyDOMElement(iframe, null, null, null, null, null, null, this.layer.opacity) │ │ │ │ } │ │ │ │ - this.redraw(); │ │ │ │ - return true │ │ │ │ + this.frame.appendChild(iframe); │ │ │ │ + this.imgDiv = iframe; │ │ │ │ + return iframe │ │ │ │ } else { │ │ │ │ - return false │ │ │ │ + return OpenLayers.Tile.Image.prototype.getImage.apply(this, arguments) │ │ │ │ } │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - control = this.controls[i]; │ │ │ │ - this.activeState[control.id] = control.deactivate() │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + createRequestForm: function() { │ │ │ │ + var form = document.createElement("form"); │ │ │ │ + form.method = "POST"; │ │ │ │ + var cacheId = this.layer.params["_OLSALT"]; │ │ │ │ + cacheId = (cacheId ? cacheId + "_" : "") + this.bounds.toBBOX(); │ │ │ │ + form.action = OpenLayers.Util.urlAppend(this.layer.url, cacheId); │ │ │ │ + form.target = this.id + "_iFrame"; │ │ │ │ + var imageSize = this.layer.getImageSize(), │ │ │ │ + params = OpenLayers.Util.getParameters(this.url), │ │ │ │ + field; │ │ │ │ + for (var par in params) { │ │ │ │ + field = document.createElement("input"); │ │ │ │ + field.type = "hidden"; │ │ │ │ + field.name = par; │ │ │ │ + field.value = params[par]; │ │ │ │ + form.appendChild(field) │ │ │ │ } │ │ │ │ + return form │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + setImgSrc: function(url) { │ │ │ │ + if (this.useIFrame === true) { │ │ │ │ + if (url) { │ │ │ │ + var form = this.createRequestForm(); │ │ │ │ + this.frame.appendChild(form); │ │ │ │ + form.submit(); │ │ │ │ + this.frame.removeChild(form) │ │ │ │ + } else if (this.imgDiv.parentNode === this.frame) { │ │ │ │ + this.frame.removeChild(this.imgDiv); │ │ │ │ + this.imgDiv = null │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + OpenLayers.Tile.Image.prototype.setImgSrc.apply(this, arguments) │ │ │ │ } │ │ │ │ - this.addControlsToMap(this.controls); │ │ │ │ - return this.div │ │ │ │ }, │ │ │ │ - redraw: function() { │ │ │ │ - for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ - this.div.removeChild(this.div.childNodes[i]) │ │ │ │ - } │ │ │ │ - this.div.innerHTML = ""; │ │ │ │ - if (this.active) { │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - this.div.appendChild(this.controls[i].panel_div) │ │ │ │ - } │ │ │ │ + onImageLoad: function() { │ │ │ │ + OpenLayers.Tile.Image.prototype.onImageLoad.apply(this, arguments); │ │ │ │ + if (this.useIFrame === true) { │ │ │ │ + this.imgDiv.style.opacity = 1; │ │ │ │ + this.frame.style.opacity = this.layer.opacity │ │ │ │ } │ │ │ │ }, │ │ │ │ - activateControl: function(control) { │ │ │ │ - if (!this.active) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_BUTTON) { │ │ │ │ - control.trigger(); │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (control.type == OpenLayers.Control.TYPE_TOGGLE) { │ │ │ │ - if (control.active) { │ │ │ │ - control.deactivate() │ │ │ │ - } else { │ │ │ │ - control.activate() │ │ │ │ - } │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (this.allowDepress && control.active) { │ │ │ │ - control.deactivate() │ │ │ │ - } else { │ │ │ │ - var c; │ │ │ │ - for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ - c = this.controls[i]; │ │ │ │ - if (c != control && (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ - c.deactivate() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - control.activate() │ │ │ │ + createBackBuffer: function() { │ │ │ │ + var backBuffer; │ │ │ │ + if (this.useIFrame === false) { │ │ │ │ + backBuffer = OpenLayers.Tile.Image.prototype.createBackBuffer.call(this) │ │ │ │ } │ │ │ │ + return backBuffer │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +OpenLayers.Marker.Box = OpenLayers.Class(OpenLayers.Marker, { │ │ │ │ + bounds: null, │ │ │ │ + div: null, │ │ │ │ + initialize: function(bounds, borderColor, borderWidth) { │ │ │ │ + this.bounds = bounds; │ │ │ │ + this.div = OpenLayers.Util.createDiv(); │ │ │ │ + this.div.style.overflow = "hidden"; │ │ │ │ + this.events = new OpenLayers.Events(this, this.div); │ │ │ │ + this.setBorder(borderColor, borderWidth) │ │ │ │ }, │ │ │ │ - addControls: function(controls) { │ │ │ │ - if (!OpenLayers.Util.isArray(controls)) { │ │ │ │ - controls = [controls] │ │ │ │ + destroy: function() { │ │ │ │ + this.bounds = null; │ │ │ │ + this.div = null; │ │ │ │ + OpenLayers.Marker.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + setBorder: function(color, width) { │ │ │ │ + if (!color) { │ │ │ │ + color = "red" │ │ │ │ } │ │ │ │ - this.controls = this.controls.concat(controls); │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - var control = controls[i], │ │ │ │ - element = this.createControlMarkup(control); │ │ │ │ - OpenLayers.Element.addClass(element, control.displayClass + "ItemInactive"); │ │ │ │ - OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ - if (control.title != "" && !element.title) { │ │ │ │ - element.title = control.title │ │ │ │ - } │ │ │ │ - control.panel_div = element │ │ │ │ + if (!width) { │ │ │ │ + width = 2 │ │ │ │ } │ │ │ │ + this.div.style.border = width + "px solid " + color │ │ │ │ + }, │ │ │ │ + draw: function(px, sz) { │ │ │ │ + OpenLayers.Util.modifyDOMElement(this.div, null, px, sz); │ │ │ │ + return this.div │ │ │ │ + }, │ │ │ │ + onScreen: function() { │ │ │ │ + var onScreen = false; │ │ │ │ if (this.map) { │ │ │ │ - this.addControlsToMap(controls); │ │ │ │ - this.redraw() │ │ │ │ + var screenBounds = this.map.getExtent(); │ │ │ │ + onScreen = screenBounds.containsBounds(this.bounds, true, true) │ │ │ │ } │ │ │ │ + return onScreen │ │ │ │ }, │ │ │ │ - createControlMarkup: function(control) { │ │ │ │ - return document.createElement("div") │ │ │ │ + display: function(display) { │ │ │ │ + this.div.style.display = display ? "" : "none" │ │ │ │ }, │ │ │ │ - addControlsToMap: function(controls) { │ │ │ │ - var control; │ │ │ │ - for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ - control = controls[i]; │ │ │ │ - if (control.autoActivate === true) { │ │ │ │ - control.autoActivate = false; │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.autoActivate = true │ │ │ │ - } else { │ │ │ │ - this.map.addControl(control); │ │ │ │ - control.deactivate() │ │ │ │ - } │ │ │ │ - control.events.on({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }) │ │ │ │ + CLASS_NAME: "OpenLayers.Marker.Box" │ │ │ │ +}); │ │ │ │ +OpenLayers.Popup.Anchored = OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ + relativePosition: null, │ │ │ │ + keepInMap: true, │ │ │ │ + anchor: null, │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ + var newArguments = [id, lonlat, contentSize, 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) │ │ │ │ } │ │ │ │ }, │ │ │ │ - iconOn: function() { │ │ │ │ - var d = this.panel_div; │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Active") │ │ │ │ + destroy: function() { │ │ │ │ + this.anchor = null; │ │ │ │ + this.relativePosition = null; │ │ │ │ + OpenLayers.Popup.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - iconOff: function() { │ │ │ │ - var d = this.panel_div; │ │ │ │ - var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ - d.className = d.className.replace(re, "$1Inactive") │ │ │ │ + show: function() { │ │ │ │ + this.updatePosition(); │ │ │ │ + OpenLayers.Popup.prototype.show.apply(this, arguments) │ │ │ │ }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var controls = this.controls, │ │ │ │ - button = evt.buttonElement; │ │ │ │ - for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ - if (controls[i].panel_div === button) { │ │ │ │ - this.activateControl(controls[i]); │ │ │ │ - break │ │ │ │ - } │ │ │ │ + moveTo: function(px) { │ │ │ │ + var oldRelativePosition = this.relativePosition; │ │ │ │ + this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ + OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ + if (this.relativePosition != oldRelativePosition) { │ │ │ │ + this.updateRelativePosition() │ │ │ │ } │ │ │ │ }, │ │ │ │ - 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 │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ + if (this.lonlat && this.map) { │ │ │ │ + var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ + this.moveTo(px) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - getControlsByName: function(match) { │ │ │ │ - return this.getControlsBy("name", match) │ │ │ │ + calculateRelativePosition: function(px) { │ │ │ │ + var lonlat = this.map.getLonLatFromLayerPx(px); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var quadrant = extent.determineQuadrant(lonlat); │ │ │ │ + return OpenLayers.Bounds.oppositeQuadrant(quadrant) │ │ │ │ }, │ │ │ │ - getControlsByClass: function(match) { │ │ │ │ - return this.getControlsBy("CLASS_NAME", match) │ │ │ │ + updateRelativePosition: function() {}, │ │ │ │ + calculateNewPx: function(px) { │ │ │ │ + var newPx = px.offset(this.anchor.offset); │ │ │ │ + var size = this.size || this.contentSize; │ │ │ │ + var top = this.relativePosition.charAt(0) == "t"; │ │ │ │ + newPx.y += top ? -size.h : this.anchor.size.h; │ │ │ │ + var left = this.relativePosition.charAt(1) == "l"; │ │ │ │ + newPx.x += left ? -size.w : this.anchor.size.w; │ │ │ │ + return newPx │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.Snapping = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - DEFAULTS: { │ │ │ │ - tolerance: 10, │ │ │ │ - node: true, │ │ │ │ - edge: true, │ │ │ │ - vertex: true │ │ │ │ - }, │ │ │ │ - greedy: true, │ │ │ │ - precedence: ["node", "vertex", "edge"], │ │ │ │ - resolution: null, │ │ │ │ - geoToleranceCache: null, │ │ │ │ - layer: null, │ │ │ │ - feature: null, │ │ │ │ - point: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options || {}; │ │ │ │ - if (this.options.layer) { │ │ │ │ - this.setLayer(this.options.layer) │ │ │ │ - } │ │ │ │ - var defaults = OpenLayers.Util.extend({}, this.options.defaults); │ │ │ │ - this.defaults = OpenLayers.Util.applyDefaults(defaults, this.DEFAULTS); │ │ │ │ - this.setTargets(this.options.targets); │ │ │ │ - if (this.targets.length === 0 && this.layer) { │ │ │ │ - this.addTargetLayer(this.layer) │ │ │ │ +OpenLayers.Popup.Framed = OpenLayers.Class(OpenLayers.Popup.Anchored, { │ │ │ │ + imageSrc: null, │ │ │ │ + imageSize: null, │ │ │ │ + isAlphaImage: false, │ │ │ │ + positionBlocks: null, │ │ │ │ + blocks: null, │ │ │ │ + fixedRelativePosition: false, │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ + OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.fixedRelativePosition) { │ │ │ │ + this.updateRelativePosition(); │ │ │ │ + this.calculateRelativePosition = function(px) { │ │ │ │ + return this.relativePosition │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.geoToleranceCache = {} │ │ │ │ - }, │ │ │ │ - setLayer: function(layer) { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layer = layer; │ │ │ │ - this.activate() │ │ │ │ - } else { │ │ │ │ - this.layer = layer │ │ │ │ + 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%" │ │ │ │ }, │ │ │ │ - setTargets: function(targets) { │ │ │ │ - this.targets = []; │ │ │ │ - if (targets && targets.length) { │ │ │ │ - var target; │ │ │ │ - for (var i = 0, len = targets.length; i < len; ++i) { │ │ │ │ - target = targets[i]; │ │ │ │ - if (target instanceof OpenLayers.Layer.Vector) { │ │ │ │ - this.addTargetLayer(target) │ │ │ │ - } else { │ │ │ │ - this.addTarget(target) │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + this.imageSrc = null; │ │ │ │ + this.imageSize = null; │ │ │ │ + this.isAlphaImage = null; │ │ │ │ + this.fixedRelativePosition = false; │ │ │ │ + this.positionBlocks = null; │ │ │ │ + for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ + var block = this.blocks[i]; │ │ │ │ + if (block.image) { │ │ │ │ + block.div.removeChild(block.image) │ │ │ │ + } │ │ │ │ + block.image = null; │ │ │ │ + if (block.div) { │ │ │ │ + this.groupDiv.removeChild(block.div) │ │ │ │ } │ │ │ │ + block.div = null │ │ │ │ } │ │ │ │ + this.blocks = null; │ │ │ │ + OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - addTargetLayer: function(layer) { │ │ │ │ - this.addTarget({ │ │ │ │ - layer: layer │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - addTarget: function(target) { │ │ │ │ - target = OpenLayers.Util.applyDefaults(target, this.defaults); │ │ │ │ - target.nodeTolerance = target.nodeTolerance || target.tolerance; │ │ │ │ - target.vertexTolerance = target.vertexTolerance || target.tolerance; │ │ │ │ - target.edgeTolerance = target.edgeTolerance || target.tolerance; │ │ │ │ - this.targets.push(target) │ │ │ │ + setBackgroundColor: function(color) {}, │ │ │ │ + setBorder: function() {}, │ │ │ │ + setOpacity: function(opacity) {}, │ │ │ │ + setSize: function(contentSize) { │ │ │ │ + OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ + this.updateBlocks() │ │ │ │ }, │ │ │ │ - removeTargetLayer: function(layer) { │ │ │ │ - var target; │ │ │ │ - for (var i = this.targets.length - 1; i >= 0; --i) { │ │ │ │ - target = this.targets[i]; │ │ │ │ - if (target.layer === layer) { │ │ │ │ - this.removeTarget(target) │ │ │ │ - } │ │ │ │ + updateRelativePosition: function() { │ │ │ │ + this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ + if (this.closeDiv) { │ │ │ │ + var contentDivPadding = this.getContentDivPadding(); │ │ │ │ + this.closeDiv.style.right = contentDivPadding.right + this.padding.right + "px"; │ │ │ │ + this.closeDiv.style.top = contentDivPadding.top + this.padding.top + "px" │ │ │ │ } │ │ │ │ + this.updateBlocks() │ │ │ │ }, │ │ │ │ - removeTarget: function(target) { │ │ │ │ - return OpenLayers.Util.removeItem(this.targets, target) │ │ │ │ + calculateNewPx: function(px) { │ │ │ │ + var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply(this, arguments); │ │ │ │ + newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ + return newPx │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (this.layer && this.layer.events) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - sketchstarted: this.onSketchModified, │ │ │ │ - sketchmodified: this.onSketchModified, │ │ │ │ - vertexmodified: this.onVertexModified, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ + createBlocks: function() { │ │ │ │ + this.blocks = []; │ │ │ │ + var firstPosition = null; │ │ │ │ + for (var key in this.positionBlocks) { │ │ │ │ + firstPosition = key; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + var position = this.positionBlocks[firstPosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ + var block = {}; │ │ │ │ + this.blocks.push(block); │ │ │ │ + var divId = this.id + "_FrameDecorationDiv_" + i; │ │ │ │ + block.div = OpenLayers.Util.createDiv(divId, null, null, null, "absolute", null, "hidden", null); │ │ │ │ + var imgId = this.id + "_FrameDecorationImg_" + i; │ │ │ │ + var imageCreator = this.isAlphaImage ? OpenLayers.Util.createAlphaImageDiv : OpenLayers.Util.createImage; │ │ │ │ + block.image = imageCreator(imgId, null, this.imageSize, this.imageSrc, "absolute", null, null, null); │ │ │ │ + block.div.appendChild(block.image); │ │ │ │ + this.groupDiv.appendChild(block.div) │ │ │ │ } │ │ │ │ - return activated │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - if (this.layer && this.layer.events) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - sketchstarted: this.onSketchModified, │ │ │ │ - sketchmodified: this.onSketchModified, │ │ │ │ - vertexmodified: this.onVertexModified, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + updateBlocks: function() { │ │ │ │ + if (!this.blocks) { │ │ │ │ + this.createBlocks() │ │ │ │ + } │ │ │ │ + if (this.size && this.relativePosition) { │ │ │ │ + var position = this.positionBlocks[this.relativePosition]; │ │ │ │ + for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ + var positionBlock = position.blocks[i]; │ │ │ │ + var block = this.blocks[i]; │ │ │ │ + var l = positionBlock.anchor.left; │ │ │ │ + var b = positionBlock.anchor.bottom; │ │ │ │ + var r = positionBlock.anchor.right; │ │ │ │ + var t = positionBlock.anchor.top; │ │ │ │ + var w = isNaN(positionBlock.size.w) ? this.size.w - (r + l) : positionBlock.size.w; │ │ │ │ + var h = isNaN(positionBlock.size.h) ? this.size.h - (b + t) : positionBlock.size.h; │ │ │ │ + block.div.style.width = (w < 0 ? 0 : w) + "px"; │ │ │ │ + block.div.style.height = (h < 0 ? 0 : h) + "px"; │ │ │ │ + block.div.style.left = l != null ? l + "px" : ""; │ │ │ │ + block.div.style.bottom = b != null ? b + "px" : ""; │ │ │ │ + block.div.style.right = r != null ? r + "px" : ""; │ │ │ │ + block.div.style.top = t != null ? t + "px" : ""; │ │ │ │ + block.image.style.left = positionBlock.position.x + "px"; │ │ │ │ + block.image.style.top = positionBlock.position.y + "px" │ │ │ │ } │ │ │ │ + this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ + this.contentDiv.style.top = this.padding.top + "px" │ │ │ │ } │ │ │ │ - this.feature = null; │ │ │ │ - this.point = null; │ │ │ │ - return deactivated │ │ │ │ }, │ │ │ │ - onSketchModified: function(event) { │ │ │ │ - this.feature = event.feature; │ │ │ │ - this.considerSnapping(event.vertex, event.vertex) │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ +}); │ │ │ │ +OpenLayers.Popup.FramedCloud = OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ + contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ + autoSize: true, │ │ │ │ + panMapIfOutOfView: true, │ │ │ │ + imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ + isAlphaImage: false, │ │ │ │ + fixedRelativePosition: false, │ │ │ │ + positionBlocks: { │ │ │ │ + tl: { │ │ │ │ + offset: new OpenLayers.Pixel(44, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 18), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -688) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + tr: { │ │ │ │ + offset: new OpenLayers.Pixel(-45, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 19), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -631) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 19), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 35), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ + position: new OpenLayers.Pixel(-215, -687) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + bl: { │ │ │ │ + offset: new OpenLayers.Pixel(45, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ + position: new OpenLayers.Pixel(-101, -674) │ │ │ │ + }] │ │ │ │ + }, │ │ │ │ + br: { │ │ │ │ + offset: new OpenLayers.Pixel(-44, 0), │ │ │ │ + padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ + blocks: [{ │ │ │ │ + size: new OpenLayers.Size("auto", "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ + position: new OpenLayers.Pixel(0, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, "auto"), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ + position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size("auto", 21), │ │ │ │ + anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ + position: new OpenLayers.Pixel(0, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(22, 21), │ │ │ │ + anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ + position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ + }, { │ │ │ │ + size: new OpenLayers.Size(81, 33), │ │ │ │ + anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ + position: new OpenLayers.Pixel(-311, -674) │ │ │ │ + }] │ │ │ │ + } │ │ │ │ }, │ │ │ │ - onVertexModified: function(event) { │ │ │ │ - this.feature = event.feature; │ │ │ │ - var loc = this.layer.map.getLonLatFromViewPortPx(event.pixel); │ │ │ │ - this.considerSnapping(event.vertex, new OpenLayers.Geometry.Point(loc.lon, loc.lat)) │ │ │ │ + minSize: new OpenLayers.Size(105, 10), │ │ │ │ + maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ + initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ + this.imageSrc = OpenLayers.Util.getImageLocation("cloud-popup-relative.png"); │ │ │ │ + OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ + this.contentDiv.className = this.contentDisplayClass │ │ │ │ }, │ │ │ │ - considerSnapping: function(point, loc) { │ │ │ │ - var best = { │ │ │ │ - rank: Number.POSITIVE_INFINITY, │ │ │ │ - dist: Number.POSITIVE_INFINITY, │ │ │ │ - x: null, │ │ │ │ - y: null │ │ │ │ - }; │ │ │ │ - var snapped = false; │ │ │ │ - var result, target; │ │ │ │ - for (var i = 0, len = this.targets.length; i < len; ++i) { │ │ │ │ - target = this.targets[i]; │ │ │ │ - result = this.testTarget(target, loc); │ │ │ │ - if (result) { │ │ │ │ - if (this.greedy) { │ │ │ │ - best = result; │ │ │ │ - best.target = target; │ │ │ │ - snapped = true; │ │ │ │ - break │ │ │ │ - } else { │ │ │ │ - if (result.rank < best.rank || result.rank === best.rank && result.dist < best.dist) { │ │ │ │ - best = result; │ │ │ │ - best.target = target; │ │ │ │ - snapped = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.CSWGetRecords = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, OpenLayers.Format.CSWGetRecords.DEFAULTS); │ │ │ │ + var cls = OpenLayers.Format.CSWGetRecords["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported CSWGetRecords version: " + options.version │ │ │ │ + } │ │ │ │ + return new cls(options) │ │ │ │ +}; │ │ │ │ +OpenLayers.Format.CSWGetRecords.DEFAULTS = { │ │ │ │ + version: "2.0.2" │ │ │ │ +}; │ │ │ │ +OpenLayers.Format.WPSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.0.0", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WPSCapabilities" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMTSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.0.0", │ │ │ │ + yx: { │ │ │ │ + "urn:ogc:def:crs:EPSG::4326": true │ │ │ │ + }, │ │ │ │ + createLayer: function(capabilities, config) { │ │ │ │ + var layer; │ │ │ │ + if (!("layer" in config)) { │ │ │ │ + throw new Error("Missing property 'layer' in configuration.") │ │ │ │ } │ │ │ │ - if (snapped) { │ │ │ │ - var proceed = this.events.triggerEvent("beforesnap", { │ │ │ │ - point: point, │ │ │ │ - x: best.x, │ │ │ │ - y: best.y, │ │ │ │ - distance: best.dist, │ │ │ │ - layer: best.target.layer, │ │ │ │ - snapType: this.precedence[best.rank] │ │ │ │ - }); │ │ │ │ - if (proceed !== false) { │ │ │ │ - point.x = best.x; │ │ │ │ - point.y = best.y; │ │ │ │ - this.point = point; │ │ │ │ - this.events.triggerEvent("snap", { │ │ │ │ - point: point, │ │ │ │ - snapType: this.precedence[best.rank], │ │ │ │ - layer: best.target.layer, │ │ │ │ - distance: best.dist │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - snapped = false │ │ │ │ + var contents = capabilities.contents; │ │ │ │ + var layers = contents.layers; │ │ │ │ + var layerDef; │ │ │ │ + for (var i = 0, ii = contents.layers.length; i < ii; ++i) { │ │ │ │ + if (contents.layers[i].identifier === config.layer) { │ │ │ │ + layerDef = contents.layers[i]; │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - if (this.point && !snapped) { │ │ │ │ - point.x = loc.x; │ │ │ │ - point.y = loc.y; │ │ │ │ - this.point = null; │ │ │ │ - this.events.triggerEvent("unsnap", { │ │ │ │ - point: point │ │ │ │ - }) │ │ │ │ + if (!layerDef) { │ │ │ │ + throw new Error("Layer not found") │ │ │ │ } │ │ │ │ - }, │ │ │ │ - testTarget: function(target, loc) { │ │ │ │ - var resolution = this.layer.map.getResolution(); │ │ │ │ - if ("minResolution" in target) { │ │ │ │ - if (resolution < target.minResolution) { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ + var format = config.format; │ │ │ │ + if (!format && layerDef.formats && layerDef.formats.length) { │ │ │ │ + format = layerDef.formats[0] │ │ │ │ } │ │ │ │ - if ("maxResolution" in target) { │ │ │ │ - if (resolution >= target.maxResolution) { │ │ │ │ - return null │ │ │ │ + var matrixSet; │ │ │ │ + if (config.matrixSet) { │ │ │ │ + matrixSet = contents.tileMatrixSets[config.matrixSet] │ │ │ │ + } else if (layerDef.tileMatrixSetLinks.length >= 1) { │ │ │ │ + matrixSet = contents.tileMatrixSets[layerDef.tileMatrixSetLinks[0].tileMatrixSet] │ │ │ │ + } │ │ │ │ + if (!matrixSet) { │ │ │ │ + throw new Error("matrixSet not found") │ │ │ │ + } │ │ │ │ + var style; │ │ │ │ + for (var i = 0, ii = layerDef.styles.length; i < ii; ++i) { │ │ │ │ + style = layerDef.styles[i]; │ │ │ │ + if (style.isDefault) { │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - var tolerance = { │ │ │ │ - node: this.getGeoTolerance(target.nodeTolerance, resolution), │ │ │ │ - vertex: this.getGeoTolerance(target.vertexTolerance, resolution), │ │ │ │ - edge: this.getGeoTolerance(target.edgeTolerance, resolution) │ │ │ │ - }; │ │ │ │ - var maxTolerance = Math.max(tolerance.node, tolerance.vertex, tolerance.edge); │ │ │ │ - var result = { │ │ │ │ - rank: Number.POSITIVE_INFINITY, │ │ │ │ - dist: Number.POSITIVE_INFINITY │ │ │ │ - }; │ │ │ │ - var eligible = false; │ │ │ │ - var features = target.layer.features; │ │ │ │ - var feature, type, vertices, vertex, closest, dist, found; │ │ │ │ - var numTypes = this.precedence.length; │ │ │ │ - var ll = new OpenLayers.LonLat(loc.x, loc.y); │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (feature !== this.feature && !feature._sketch && feature.state !== OpenLayers.State.DELETE && (!target.filter || target.filter.evaluate(feature))) { │ │ │ │ - if (feature.atPoint(ll, maxTolerance, maxTolerance)) { │ │ │ │ - for (var j = 0, stop = Math.min(result.rank + 1, numTypes); j < stop; ++j) { │ │ │ │ - type = this.precedence[j]; │ │ │ │ - if (target[type]) { │ │ │ │ - if (type === "edge") { │ │ │ │ - closest = feature.geometry.distanceTo(loc, { │ │ │ │ - details: true │ │ │ │ - }); │ │ │ │ - dist = closest.distance; │ │ │ │ - if (dist <= tolerance[type] && dist < result.dist) { │ │ │ │ - result = { │ │ │ │ - rank: j, │ │ │ │ - dist: dist, │ │ │ │ - x: closest.x0, │ │ │ │ - y: closest.y0 │ │ │ │ - }; │ │ │ │ - eligible = true; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - vertices = feature.geometry.getVertices(type === "node"); │ │ │ │ - found = false; │ │ │ │ - for (var k = 0, klen = vertices.length; k < klen; ++k) { │ │ │ │ - vertex = vertices[k]; │ │ │ │ - dist = vertex.distanceTo(loc); │ │ │ │ - if (dist <= tolerance[type] && (j < result.rank || j === result.rank && dist < result.dist)) { │ │ │ │ - result = { │ │ │ │ - rank: j, │ │ │ │ - dist: dist, │ │ │ │ - x: vertex.x, │ │ │ │ - y: vertex.y │ │ │ │ - }; │ │ │ │ - eligible = true; │ │ │ │ - found = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (found) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var requestEncoding = config.requestEncoding; │ │ │ │ + if (!requestEncoding) { │ │ │ │ + requestEncoding = "KVP"; │ │ │ │ + if (capabilities.operationsMetadata.GetTile.dcp.http) { │ │ │ │ + var http = capabilities.operationsMetadata.GetTile.dcp.http; │ │ │ │ + if (http.get[0].constraints) { │ │ │ │ + var constraints = http.get[0].constraints; │ │ │ │ + var allowedValues = constraints.GetEncoding.allowedValues; │ │ │ │ + if (!allowedValues.KVP && (allowedValues.REST || allowedValues.RESTful)) { │ │ │ │ + requestEncoding = "REST" │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - return eligible ? result : null │ │ │ │ - }, │ │ │ │ - getGeoTolerance: function(tolerance, resolution) { │ │ │ │ - if (resolution !== this.resolution) { │ │ │ │ - this.resolution = resolution; │ │ │ │ - this.geoToleranceCache = {} │ │ │ │ + var dimensions = []; │ │ │ │ + var params = config.params || {}; │ │ │ │ + delete config.params; │ │ │ │ + for (var id = 0, ld = layerDef.dimensions.length; id < ld; id++) { │ │ │ │ + var dimension = layerDef.dimensions[id]; │ │ │ │ + dimensions.push(dimension.identifier); │ │ │ │ + if (!params.hasOwnProperty(dimension.identifier)) { │ │ │ │ + params[dimension.identifier] = dimension["default"] │ │ │ │ + } │ │ │ │ } │ │ │ │ - var geoTolerance = this.geoToleranceCache[tolerance]; │ │ │ │ - if (geoTolerance === undefined) { │ │ │ │ - geoTolerance = tolerance * resolution; │ │ │ │ - this.geoToleranceCache[tolerance] = geoTolerance │ │ │ │ + var projection = config.projection || matrixSet.supportedCRS.replace(/urn:ogc:def:crs:(\w+):(.*:)?(\w+)$/, "$1:$3"); │ │ │ │ + var units = config.units || (projection === "EPSG:4326" ? "degrees" : "m"); │ │ │ │ + var resolutions = []; │ │ │ │ + for (var mid in matrixSet.matrixIds) { │ │ │ │ + if (matrixSet.matrixIds.hasOwnProperty(mid)) { │ │ │ │ + resolutions.push(matrixSet.matrixIds[mid].scaleDenominator * 28e-5 / OpenLayers.METERS_PER_INCH / OpenLayers.INCHES_PER_UNIT[units]) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return geoTolerance │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate() │ │ │ │ + var url; │ │ │ │ + if (requestEncoding === "REST" && layerDef.resourceUrls) { │ │ │ │ + url = []; │ │ │ │ + var resourceUrls = layerDef.resourceUrls, │ │ │ │ + resourceUrl; │ │ │ │ + for (var t = 0, tt = layerDef.resourceUrls.length; t < tt; ++t) { │ │ │ │ + resourceUrl = layerDef.resourceUrls[t]; │ │ │ │ + if (resourceUrl.format === format && resourceUrl.resourceType === "tile") { │ │ │ │ + url.push(resourceUrl.template) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + var httpGet = capabilities.operationsMetadata.GetTile.dcp.http.get; │ │ │ │ + url = []; │ │ │ │ + var constraint; │ │ │ │ + for (var i = 0, ii = httpGet.length; i < ii; i++) { │ │ │ │ + constraint = httpGet[i].constraints; │ │ │ │ + if (!constraint || constraint && constraint.GetEncoding.allowedValues[requestEncoding]) { │ │ │ │ + url.push(httpGet[i].url) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - delete this.layer; │ │ │ │ - delete this.targets; │ │ │ │ - OpenLayers.Control.prototype.destroy.call(this) │ │ │ │ + return new OpenLayers.Layer.WMTS(OpenLayers.Util.applyDefaults(config, { │ │ │ │ + url: url, │ │ │ │ + requestEncoding: requestEncoding, │ │ │ │ + name: layerDef.title, │ │ │ │ + style: style.identifier, │ │ │ │ + format: format, │ │ │ │ + matrixIds: matrixSet.matrixIds, │ │ │ │ + matrixSet: matrixSet.identifier, │ │ │ │ + projection: projection, │ │ │ │ + units: units, │ │ │ │ + resolutions: config.isBaseLayer === false ? undefined : resolutions, │ │ │ │ + serverResolutions: resolutions, │ │ │ │ + tileFullExtent: matrixSet.bounds, │ │ │ │ + dimensions: dimensions, │ │ │ │ + params: params │ │ │ │ + })) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Snapping" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMTSCapabilities" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.CacheWrite = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - layers: null, │ │ │ │ - imageFormat: "image/png", │ │ │ │ - quotaRegEx: /quota/i, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - var i, layers = this.layers || map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.addLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (!this.layers) { │ │ │ │ - map.events.on({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - addLayer: function(evt) { │ │ │ │ - evt.layer.events.on({ │ │ │ │ - tileloadstart: this.makeSameOrigin, │ │ │ │ - tileloaded: this.onTileLoaded, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ +OpenLayers.Format.QueryStringFilter = function() { │ │ │ │ + var cmpToStr = {}; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.EQUAL_TO] = "eq"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.NOT_EQUAL_TO] = "ne"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN] = "lt"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO] = "lte"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN] = "gt"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO] = "gte"; │ │ │ │ + cmpToStr[OpenLayers.Filter.Comparison.LIKE] = "ilike"; │ │ │ │ + │ │ │ │ + function regex2value(value) { │ │ │ │ + value = value.replace(/%/g, "\\%"); │ │ │ │ + value = value.replace(/\\\\\.(\*)?/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "\\\\_" │ │ │ │ + }); │ │ │ │ + value = value.replace(/\\\\\.\*/g, "\\\\%"); │ │ │ │ + value = value.replace(/(\\)?\.(\*)?/g, function($0, $1, $2) { │ │ │ │ + return $1 || $2 ? $0 : "_" │ │ │ │ + }); │ │ │ │ + value = value.replace(/(\\)?\.\*/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "%" │ │ │ │ + }); │ │ │ │ + value = value.replace(/\\\./g, "."); │ │ │ │ + value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ + return $1 ? $0 : "*" │ │ │ │ + }); │ │ │ │ + return value │ │ │ │ + } │ │ │ │ + return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + wildcarded: false, │ │ │ │ + srsInBBOX: false, │ │ │ │ + write: function(filter, params) { │ │ │ │ + params = params || {}; │ │ │ │ + var className = filter.CLASS_NAME; │ │ │ │ + var filterType = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ + switch (filterType) { │ │ │ │ + case "Spatial": │ │ │ │ + switch (filter.type) { │ │ │ │ + case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ + params.bbox = filter.value.toArray(); │ │ │ │ + if (this.srsInBBOX && filter.projection) { │ │ │ │ + params.bbox.push(filter.projection.getCode()) │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ + params.tolerance = filter.distance; │ │ │ │ + case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ + params.lon = filter.value.x; │ │ │ │ + params.lat = filter.value.y; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + OpenLayers.Console.warn("Unknown spatial filter type " + filter.type) │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "Comparison": │ │ │ │ + var op = cmpToStr[filter.type]; │ │ │ │ + if (op !== undefined) { │ │ │ │ + var value = filter.value; │ │ │ │ + if (filter.type == OpenLayers.Filter.Comparison.LIKE) { │ │ │ │ + value = regex2value(value); │ │ │ │ + if (this.wildcarded) { │ │ │ │ + value = "%" + value + "%" │ │ │ │ + } │ │ │ │ + } │ │ │ │ + params[filter.property + "__" + op] = value; │ │ │ │ + params.queryable = params.queryable || []; │ │ │ │ + params.queryable.push(filter.property) │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.warn("Unknown comparison filter type " + filter.type) │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "Logical": │ │ │ │ + if (filter.type === OpenLayers.Filter.Logical.AND) { │ │ │ │ + for (var i = 0, len = filter.filters.length; i < len; i++) { │ │ │ │ + params = this.write(filter.filters[i], params) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.warn("Unsupported logical filter type " + filter.type) │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + OpenLayers.Console.warn("Unknown filter type " + filterType) │ │ │ │ + } │ │ │ │ + return params │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.QueryStringFilter" │ │ │ │ + }) │ │ │ │ +}(); │ │ │ │ +OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + geometryType: "linestring", │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - removeLayer: function(evt) { │ │ │ │ - evt.layer.events.un({ │ │ │ │ - tileloadstart: this.makeSameOrigin, │ │ │ │ - tileloaded: this.onTileLoaded, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + read: function(encoded) { │ │ │ │ + var geomType; │ │ │ │ + if (this.geometryType == "linestring") geomType = OpenLayers.Geometry.LineString; │ │ │ │ + else if (this.geometryType == "linearring") geomType = OpenLayers.Geometry.LinearRing; │ │ │ │ + else if (this.geometryType == "multipoint") geomType = OpenLayers.Geometry.MultiPoint; │ │ │ │ + else if (this.geometryType != "point" && this.geometryType != "polygon") return null; │ │ │ │ + var flatPoints = this.decodeDeltas(encoded, 2); │ │ │ │ + var flatPointsLength = flatPoints.length; │ │ │ │ + var pointGeometries = []; │ │ │ │ + for (var i = 0; i + 1 < flatPointsLength;) { │ │ │ │ + var y = flatPoints[i++], │ │ │ │ + x = flatPoints[i++]; │ │ │ │ + pointGeometries.push(new OpenLayers.Geometry.Point(x, y)) │ │ │ │ + } │ │ │ │ + if (this.geometryType == "point") return new OpenLayers.Feature.Vector(pointGeometries[0]); │ │ │ │ + if (this.geometryType == "polygon") return new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(pointGeometries)])); │ │ │ │ + return new OpenLayers.Feature.Vector(new geomType(pointGeometries)) │ │ │ │ }, │ │ │ │ - makeSameOrigin: function(evt) { │ │ │ │ - if (this.active) { │ │ │ │ - var tile = evt.tile; │ │ │ │ - if (tile instanceof OpenLayers.Tile.Image && !tile.crossOriginKeyword && tile.url.substr(0, 5) !== "data:") { │ │ │ │ - var sameOriginUrl = OpenLayers.Request.makeSameOrigin(tile.url, OpenLayers.ProxyHost); │ │ │ │ - OpenLayers.Control.CacheWrite.urlMap[sameOriginUrl] = tile.url; │ │ │ │ - tile.url = sameOriginUrl │ │ │ │ + decode: function(encoded, dims, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var flatPoints = this.decodeDeltas(encoded, dims, factor); │ │ │ │ + var flatPointsLength = flatPoints.length; │ │ │ │ + var points = []; │ │ │ │ + for (var i = 0; i + (dims - 1) < flatPointsLength;) { │ │ │ │ + var point = []; │ │ │ │ + for (var dim = 0; dim < dims; ++dim) { │ │ │ │ + point.push(flatPoints[i++]) │ │ │ │ } │ │ │ │ + points.push(point) │ │ │ │ } │ │ │ │ + return points │ │ │ │ }, │ │ │ │ - onTileLoaded: function(evt) { │ │ │ │ - if (this.active && !evt.aborted && evt.tile instanceof OpenLayers.Tile.Image && evt.tile.url.substr(0, 5) !== "data:") { │ │ │ │ - this.cache({ │ │ │ │ - tile: evt.tile │ │ │ │ - }); │ │ │ │ - delete OpenLayers.Control.CacheWrite.urlMap[evt.tile.url] │ │ │ │ + write: function(features) { │ │ │ │ + var feature; │ │ │ │ + if (features.constructor == Array) feature = features[0]; │ │ │ │ + else feature = features; │ │ │ │ + var geometry = feature.geometry; │ │ │ │ + var type = geometry.CLASS_NAME.split(".")[2].toLowerCase(); │ │ │ │ + var pointGeometries; │ │ │ │ + if (type == "point") pointGeometries = new Array(geometry); │ │ │ │ + else if (type == "linestring" || type == "linearring" || type == "multipoint") pointGeometries = geometry.components; │ │ │ │ + else if (type == "polygon") pointGeometries = geometry.components[0].components; │ │ │ │ + else return null; │ │ │ │ + var flatPoints = []; │ │ │ │ + var pointGeometriesLength = pointGeometries.length; │ │ │ │ + for (var i = 0; i < pointGeometriesLength; ++i) { │ │ │ │ + var pointGeometry = pointGeometries[i]; │ │ │ │ + flatPoints.push(pointGeometry.y); │ │ │ │ + flatPoints.push(pointGeometry.x) │ │ │ │ } │ │ │ │ + return this.encodeDeltas(flatPoints, 2) │ │ │ │ }, │ │ │ │ - cache: function(obj) { │ │ │ │ - if (window.localStorage) { │ │ │ │ - var tile = obj.tile; │ │ │ │ - try { │ │ │ │ - var canvasContext = tile.getCanvasContext(); │ │ │ │ - if (canvasContext) { │ │ │ │ - var urlMap = OpenLayers.Control.CacheWrite.urlMap; │ │ │ │ - var url = urlMap[tile.url] || tile.url; │ │ │ │ - window.localStorage.setItem("olCache_" + url, canvasContext.canvas.toDataURL(this.imageFormat)) │ │ │ │ - } │ │ │ │ - } catch (e) { │ │ │ │ - var reason = e.name || e.message; │ │ │ │ - if (reason && this.quotaRegEx.test(reason)) { │ │ │ │ - this.events.triggerEvent("cachefull", { │ │ │ │ - tile: tile │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.error(e.toString()) │ │ │ │ - } │ │ │ │ + encode: function(points, dims, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var flatPoints = []; │ │ │ │ + var pointsLength = points.length; │ │ │ │ + for (var i = 0; i < pointsLength; ++i) { │ │ │ │ + var point = points[i]; │ │ │ │ + for (var dim = 0; dim < dims; ++dim) { │ │ │ │ + flatPoints.push(point[dim]) │ │ │ │ } │ │ │ │ } │ │ │ │ + return this.encodeDeltas(flatPoints, dims, factor) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layers || this.map) { │ │ │ │ - var i, layers = this.layers || this.map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }) │ │ │ │ - } │ │ │ │ + encodeDeltas: function(numbers, dimension, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var d; │ │ │ │ + var lastNumbers = new Array(dimension); │ │ │ │ + for (d = 0; d < dimension; ++d) { │ │ │ │ + lastNumbers[d] = 0 │ │ │ │ } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.un({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength;) { │ │ │ │ + for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ + var num = numbers[i]; │ │ │ │ + var delta = num - lastNumbers[d]; │ │ │ │ + lastNumbers[d] = num; │ │ │ │ + numbers[i] = delta │ │ │ │ + } │ │ │ │ } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + return this.encodeFloats(numbers, factor) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.CacheWrite" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.CacheWrite.clearCache = function() { │ │ │ │ - if (!window.localStorage) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var i, key; │ │ │ │ - for (i = window.localStorage.length - 1; i >= 0; --i) { │ │ │ │ - key = window.localStorage.key(i); │ │ │ │ - if (key.substr(0, 8) === "olCache_") { │ │ │ │ - window.localStorage.removeItem(key) │ │ │ │ + decodeDeltas: function(encoded, dimension, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var d; │ │ │ │ + var lastNumbers = new Array(dimension); │ │ │ │ + for (d = 0; d < dimension; ++d) { │ │ │ │ + lastNumbers[d] = 0 │ │ │ │ } │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -OpenLayers.Control.CacheWrite.urlMap = {}; │ │ │ │ -OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - started: false, │ │ │ │ - stopDown: true, │ │ │ │ - dragging: false, │ │ │ │ - last: null, │ │ │ │ - start: null, │ │ │ │ - lastMoveEvt: null, │ │ │ │ - oldOnselectstart: null, │ │ │ │ - interval: 0, │ │ │ │ - timeoutId: null, │ │ │ │ - documentDrag: false, │ │ │ │ - documentEvents: null, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - var me = this; │ │ │ │ - this._docMove = function(evt) { │ │ │ │ - me.mousemove({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - }, │ │ │ │ - element: document │ │ │ │ - }) │ │ │ │ - }; │ │ │ │ - this._docUp = function(evt) { │ │ │ │ - me.mouseup({ │ │ │ │ - xy: { │ │ │ │ - x: evt.clientX, │ │ │ │ - y: evt.clientY │ │ │ │ - } │ │ │ │ - }) │ │ │ │ + var numbers = this.decodeFloats(encoded, factor); │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength;) { │ │ │ │ + for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ + lastNumbers[d] += numbers[i]; │ │ │ │ + numbers[i] = lastNumbers[d] │ │ │ │ } │ │ │ │ } │ │ │ │ + return numbers │ │ │ │ }, │ │ │ │ - dragstart: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - this.dragging = false; │ │ │ │ - if (this.checkModifiers(evt) && (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ - this.started = true; │ │ │ │ - this.start = evt.xy; │ │ │ │ - this.last = evt.xy; │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ - this.down(evt); │ │ │ │ - this.callback("down", [evt.xy]); │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart ? document.onselectstart : OpenLayers.Function.True │ │ │ │ - } │ │ │ │ - document.onselectstart = OpenLayers.Function.False; │ │ │ │ - propagate = !this.stopDown │ │ │ │ - } else { │ │ │ │ - this.started = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null │ │ │ │ + encodeFloats: function(numbers, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + numbers[i] = Math.round(numbers[i] * factor) │ │ │ │ } │ │ │ │ - return propagate │ │ │ │ + return this.encodeSignedIntegers(numbers) │ │ │ │ }, │ │ │ │ - dragmove: function(evt) { │ │ │ │ - this.lastMoveEvt = evt; │ │ │ │ - if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || evt.xy.y != this.last.y)) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - if (evt.element === document) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - this.setEvent(evt) │ │ │ │ - } else { │ │ │ │ - this.removeDocumentEvents() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.interval > 0) { │ │ │ │ - this.timeoutId = setTimeout(OpenLayers.Function.bind(this.removeTimeout, this), this.interval) │ │ │ │ - } │ │ │ │ - this.dragging = true; │ │ │ │ - this.move(evt); │ │ │ │ - this.callback("move", [evt.xy]); │ │ │ │ - if (!this.oldOnselectstart) { │ │ │ │ - this.oldOnselectstart = document.onselectstart; │ │ │ │ - document.onselectstart = OpenLayers.Function.False │ │ │ │ - } │ │ │ │ - this.last = evt.xy │ │ │ │ + decodeFloats: function(encoded, opt_factor) { │ │ │ │ + var factor = opt_factor || 1e5; │ │ │ │ + var numbers = this.decodeSignedIntegers(encoded); │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + numbers[i] /= factor │ │ │ │ } │ │ │ │ - return true │ │ │ │ + return numbers │ │ │ │ }, │ │ │ │ - dragend: function(evt) { │ │ │ │ - if (this.started) { │ │ │ │ - if (this.documentDrag === true && this.documentEvents) { │ │ │ │ - this.adjustXY(evt); │ │ │ │ - this.removeDocumentEvents() │ │ │ │ - } │ │ │ │ - var dragged = this.start != this.last; │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ - this.up(evt); │ │ │ │ - this.callback("up", [evt.xy]); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]) │ │ │ │ + encodeSignedIntegers: function(numbers) { │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + var num = numbers[i]; │ │ │ │ + var signedNum = num << 1; │ │ │ │ + if (num < 0) { │ │ │ │ + signedNum = ~signedNum │ │ │ │ } │ │ │ │ - document.onselectstart = this.oldOnselectstart │ │ │ │ + numbers[i] = signedNum │ │ │ │ } │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - down: function(evt) {}, │ │ │ │ - move: function(evt) {}, │ │ │ │ - up: function(evt) {}, │ │ │ │ - out: function(evt) {}, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - return this.dragstart(evt) │ │ │ │ - }, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return this.dragstart(evt) │ │ │ │ - }, │ │ │ │ - mousemove: function(evt) { │ │ │ │ - return this.dragmove(evt) │ │ │ │ - }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - return this.dragmove(evt) │ │ │ │ + return this.encodeUnsignedIntegers(numbers) │ │ │ │ }, │ │ │ │ - removeTimeout: function() { │ │ │ │ - this.timeoutId = null; │ │ │ │ - if (this.dragging) { │ │ │ │ - this.mousemove(this.lastMoveEvt) │ │ │ │ + decodeSignedIntegers: function(encoded) { │ │ │ │ + var numbers = this.decodeUnsignedIntegers(encoded); │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + var num = numbers[i]; │ │ │ │ + numbers[i] = num & 1 ? ~(num >> 1) : num >> 1 │ │ │ │ } │ │ │ │ + return numbers │ │ │ │ }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - return this.dragend(evt) │ │ │ │ - }, │ │ │ │ - touchend: function(evt) { │ │ │ │ - evt.xy = this.last; │ │ │ │ - return this.dragend(evt) │ │ │ │ + encodeUnsignedIntegers: function(numbers) { │ │ │ │ + var encoded = ""; │ │ │ │ + var numbersLength = numbers.length; │ │ │ │ + for (var i = 0; i < numbersLength; ++i) { │ │ │ │ + encoded += this.encodeUnsignedInteger(numbers[i]) │ │ │ │ + } │ │ │ │ + return encoded │ │ │ │ }, │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - if (this.documentDrag === true) { │ │ │ │ - this.addDocumentEvents() │ │ │ │ + decodeUnsignedIntegers: function(encoded) { │ │ │ │ + var numbers = []; │ │ │ │ + var current = 0; │ │ │ │ + var shift = 0; │ │ │ │ + var encodedLength = encoded.length; │ │ │ │ + for (var i = 0; i < encodedLength; ++i) { │ │ │ │ + var b = encoded.charCodeAt(i) - 63; │ │ │ │ + current |= (b & 31) << shift; │ │ │ │ + if (b < 32) { │ │ │ │ + numbers.push(current); │ │ │ │ + current = 0; │ │ │ │ + shift = 0 │ │ │ │ } else { │ │ │ │ - var dragged = this.start != this.last; │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ - this.out(evt); │ │ │ │ - this.callback("out", []); │ │ │ │ - if (dragged) { │ │ │ │ - this.callback("done", [evt.xy]) │ │ │ │ - } │ │ │ │ - if (document.onselectstart) { │ │ │ │ - document.onselectstart = this.oldOnselectstart │ │ │ │ - } │ │ │ │ + shift += 5 │ │ │ │ } │ │ │ │ } │ │ │ │ - return true │ │ │ │ + return numbers │ │ │ │ }, │ │ │ │ - click: function(evt) { │ │ │ │ - return this.start == this.last │ │ │ │ + encodeFloat: function(num, opt_factor) { │ │ │ │ + num = Math.round(num * (opt_factor || 1e5)); │ │ │ │ + return this.encodeSignedInteger(num) │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragging = false; │ │ │ │ - activated = true │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ + decodeFloat: function(encoded, opt_factor) { │ │ │ │ + var result = this.decodeSignedInteger(encoded); │ │ │ │ + return result / (opt_factor || 1e5) │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.started = false; │ │ │ │ - this.dragging = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown") │ │ │ │ + encodeSignedInteger: function(num) { │ │ │ │ + var signedNum = num << 1; │ │ │ │ + if (num < 0) { │ │ │ │ + signedNum = ~signedNum │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ + return this.encodeUnsignedInteger(signedNum) │ │ │ │ }, │ │ │ │ - adjustXY: function(evt) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ - evt.xy.x -= pos[0]; │ │ │ │ - evt.xy.y -= pos[1] │ │ │ │ + decodeSignedInteger: function(encoded) { │ │ │ │ + var result = this.decodeUnsignedInteger(encoded); │ │ │ │ + return result & 1 ? ~(result >> 1) : result >> 1 │ │ │ │ }, │ │ │ │ - addDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = true; │ │ │ │ - OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.observe(document, "mouseup", this._docUp) │ │ │ │ + encodeUnsignedInteger: function(num) { │ │ │ │ + var value, encoded = ""; │ │ │ │ + while (num >= 32) { │ │ │ │ + value = (32 | num & 31) + 63; │ │ │ │ + encoded += String.fromCharCode(value); │ │ │ │ + num >>= 5 │ │ │ │ + } │ │ │ │ + value = num + 63; │ │ │ │ + encoded += String.fromCharCode(value); │ │ │ │ + return encoded │ │ │ │ }, │ │ │ │ - removeDocumentEvents: function() { │ │ │ │ - OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ - this.documentEvents = false; │ │ │ │ - OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ - OpenLayers.Event.stopObserving(document, "mouseup", this._docUp) │ │ │ │ + decodeUnsignedInteger: function(encoded) { │ │ │ │ + var result = 0; │ │ │ │ + var shift = 0; │ │ │ │ + var encodedLength = encoded.length; │ │ │ │ + for (var i = 0; i < encodedLength; ++i) { │ │ │ │ + var b = encoded.charCodeAt(i) - 63; │ │ │ │ + result |= (b & 31) << shift; │ │ │ │ + if (b < 32) break; │ │ │ │ + shift += 5 │ │ │ │ + } │ │ │ │ + return result │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.EncodedPolyline" │ │ │ │ }); │ │ │ │ -OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - EVENTMAP: { │ │ │ │ - click: { │ │ │ │ - in: "click", │ │ │ │ - out: "clickout" │ │ │ │ - }, │ │ │ │ - mousemove: { │ │ │ │ - in: "over", │ │ │ │ - out: "out" │ │ │ │ +OpenLayers.Format.SOSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.0.0", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSCapabilities" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.CQL = function() { │ │ │ │ + var tokens = ["PROPERTY", "COMPARISON", "VALUE", "LOGICAL"], │ │ │ │ + patterns = { │ │ │ │ + PROPERTY: /^[_a-zA-Z]\w*/, │ │ │ │ + COMPARISON: /^(=|<>|<=|<|>=|>|LIKE)/i, │ │ │ │ + IS_NULL: /^IS NULL/i, │ │ │ │ + COMMA: /^,/, │ │ │ │ + LOGICAL: /^(AND|OR)/i, │ │ │ │ + VALUE: /^('([^']|'')*'|\d+(\.\d*)?|\.\d+)/, │ │ │ │ + LPAREN: /^\(/, │ │ │ │ + RPAREN: /^\)/, │ │ │ │ + SPATIAL: /^(BBOX|INTERSECTS|DWITHIN|WITHIN|CONTAINS)/i, │ │ │ │ + NOT: /^NOT/i, │ │ │ │ + BETWEEN: /^BETWEEN/i, │ │ │ │ + GEOMETRY: function(text) { │ │ │ │ + var type = /^(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)/.exec(text); │ │ │ │ + if (type) { │ │ │ │ + var len = text.length; │ │ │ │ + var idx = text.indexOf("(", type[0].length); │ │ │ │ + if (idx > -1) { │ │ │ │ + var depth = 1; │ │ │ │ + while (idx < len && depth > 0) { │ │ │ │ + idx++; │ │ │ │ + switch (text.charAt(idx)) { │ │ │ │ + case "(": │ │ │ │ + depth++; │ │ │ │ + break; │ │ │ │ + case ")": │ │ │ │ + depth--; │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return [text.substr(0, idx + 1)] │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + END: /^$/ │ │ │ │ }, │ │ │ │ - dblclick: { │ │ │ │ - in: "dblclick", │ │ │ │ - out: null │ │ │ │ + follows = { │ │ │ │ + LPAREN: ["GEOMETRY", "SPATIAL", "PROPERTY", "VALUE", "LPAREN"], │ │ │ │ + RPAREN: ["NOT", "LOGICAL", "END", "RPAREN"], │ │ │ │ + PROPERTY: ["COMPARISON", "BETWEEN", "COMMA", "IS_NULL"], │ │ │ │ + BETWEEN: ["VALUE"], │ │ │ │ + IS_NULL: ["END"], │ │ │ │ + COMPARISON: ["VALUE"], │ │ │ │ + COMMA: ["GEOMETRY", "VALUE", "PROPERTY"], │ │ │ │ + VALUE: ["LOGICAL", "COMMA", "RPAREN", "END"], │ │ │ │ + SPATIAL: ["LPAREN"], │ │ │ │ + LOGICAL: ["NOT", "VALUE", "SPATIAL", "PROPERTY", "LPAREN"], │ │ │ │ + NOT: ["PROPERTY", "LPAREN"], │ │ │ │ + GEOMETRY: ["COMMA", "RPAREN"] │ │ │ │ }, │ │ │ │ - mousedown: { │ │ │ │ - in: null, │ │ │ │ - out: null │ │ │ │ + operators = { │ │ │ │ + "=": OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ + "<>": OpenLayers.Filter.Comparison.NOT_EQUAL_TO, │ │ │ │ + "<": OpenLayers.Filter.Comparison.LESS_THAN, │ │ │ │ + "<=": OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO, │ │ │ │ + ">": OpenLayers.Filter.Comparison.GREATER_THAN, │ │ │ │ + ">=": OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO, │ │ │ │ + LIKE: OpenLayers.Filter.Comparison.LIKE, │ │ │ │ + BETWEEN: OpenLayers.Filter.Comparison.BETWEEN, │ │ │ │ + "IS NULL": OpenLayers.Filter.Comparison.IS_NULL │ │ │ │ }, │ │ │ │ - mouseup: { │ │ │ │ - in: null, │ │ │ │ - out: null │ │ │ │ + operatorReverse = {}, │ │ │ │ + logicals = { │ │ │ │ + AND: OpenLayers.Filter.Logical.AND, │ │ │ │ + OR: OpenLayers.Filter.Logical.OR │ │ │ │ }, │ │ │ │ - touchstart: { │ │ │ │ - in: "click", │ │ │ │ - out: "clickout" │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - feature: null, │ │ │ │ - lastFeature: null, │ │ │ │ - down: null, │ │ │ │ - up: null, │ │ │ │ - clickTolerance: 4, │ │ │ │ - geometryTypes: null, │ │ │ │ - stopClick: true, │ │ │ │ - stopDown: true, │ │ │ │ - stopUp: false, │ │ │ │ - initialize: function(control, layer, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ - this.layer = layer │ │ │ │ - }, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - return OpenLayers.Event.isMultiTouch(evt) ? true : this.mousedown(evt) │ │ │ │ - }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - OpenLayers.Event.preventDefault(evt) │ │ │ │ - }, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ - this.down = evt.xy │ │ │ │ + logicalReverse = {}, │ │ │ │ + precedence = { │ │ │ │ + RPAREN: 3, │ │ │ │ + LOGICAL: 2, │ │ │ │ + COMPARISON: 1 │ │ │ │ + }; │ │ │ │ + var i; │ │ │ │ + for (i in operators) { │ │ │ │ + if (operators.hasOwnProperty(i)) { │ │ │ │ + operatorReverse[operators[i]] = i │ │ │ │ } │ │ │ │ - return this.handle(evt) ? !this.stopDown : true │ │ │ │ - }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - this.up = evt.xy; │ │ │ │ - return this.handle(evt) ? !this.stopUp : true │ │ │ │ - }, │ │ │ │ - click: function(evt) { │ │ │ │ - return this.handle(evt) ? !this.stopClick : true │ │ │ │ - }, │ │ │ │ - mousemove: function(evt) { │ │ │ │ - if (!this.callbacks["over"] && !this.callbacks["out"]) { │ │ │ │ - return true │ │ │ │ + } │ │ │ │ + for (i in logicals) { │ │ │ │ + if (logicals.hasOwnProperty(i)) { │ │ │ │ + logicalReverse[logicals[i]] = i │ │ │ │ } │ │ │ │ - this.handle(evt); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - dblclick: function(evt) { │ │ │ │ - return !this.handle(evt) │ │ │ │ - }, │ │ │ │ - geometryTypeMatches: function(feature) { │ │ │ │ - return this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1 │ │ │ │ - }, │ │ │ │ - handle: function(evt) { │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - this.feature = null │ │ │ │ + } │ │ │ │ + │ │ │ │ + function tryToken(text, pattern) { │ │ │ │ + if (pattern instanceof RegExp) { │ │ │ │ + return pattern.exec(text) │ │ │ │ + } else { │ │ │ │ + return pattern(text) │ │ │ │ } │ │ │ │ - var type = evt.type; │ │ │ │ - var handled = false; │ │ │ │ - var previouslyIn = !!this.feature; │ │ │ │ - var click = type == "click" || type == "dblclick" || type == "touchstart"; │ │ │ │ - this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ - if (this.feature && !this.feature.layer) { │ │ │ │ - this.feature = null │ │ │ │ + } │ │ │ │ + │ │ │ │ + function nextToken(text, tokens) { │ │ │ │ + var i, token, len = tokens.length; │ │ │ │ + for (i = 0; i < len; i++) { │ │ │ │ + token = tokens[i]; │ │ │ │ + var pat = patterns[token]; │ │ │ │ + var matches = tryToken(text, pat); │ │ │ │ + if (matches) { │ │ │ │ + var match = matches[0]; │ │ │ │ + var remainder = text.substr(match.length).replace(/^\s*/, ""); │ │ │ │ + return { │ │ │ │ + type: token, │ │ │ │ + text: match, │ │ │ │ + remainder: remainder │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ - this.lastFeature = null │ │ │ │ + var msg = "ERROR: In parsing: [" + text + "], expected one of: "; │ │ │ │ + for (i = 0; i < len; i++) { │ │ │ │ + token = tokens[i]; │ │ │ │ + msg += "\n " + token + ": " + patterns[token] │ │ │ │ } │ │ │ │ - if (this.feature) { │ │ │ │ - if (type === "touchstart") { │ │ │ │ - OpenLayers.Event.preventDefault(evt) │ │ │ │ + throw new Error(msg) │ │ │ │ + } │ │ │ │ + │ │ │ │ + function tokenize(text) { │ │ │ │ + var results = []; │ │ │ │ + var token, expect = ["NOT", "GEOMETRY", "SPATIAL", "PROPERTY", "LPAREN"]; │ │ │ │ + do { │ │ │ │ + token = nextToken(text, expect); │ │ │ │ + text = token.remainder; │ │ │ │ + expect = follows[token.type]; │ │ │ │ + if (token.type != "END" && !expect) { │ │ │ │ + throw new Error("No follows list for " + token.type) │ │ │ │ } │ │ │ │ - var inNew = this.feature != this.lastFeature; │ │ │ │ - if (this.geometryTypeMatches(this.feature)) { │ │ │ │ - if (previouslyIn && inNew) { │ │ │ │ - if (this.lastFeature) { │ │ │ │ - this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ + results.push(token) │ │ │ │ + } while (token.type != "END"); │ │ │ │ + return results │ │ │ │ + } │ │ │ │ + │ │ │ │ + function buildAst(tokens) { │ │ │ │ + var operatorStack = [], │ │ │ │ + postfix = []; │ │ │ │ + while (tokens.length) { │ │ │ │ + var tok = tokens.shift(); │ │ │ │ + switch (tok.type) { │ │ │ │ + case "PROPERTY": │ │ │ │ + case "GEOMETRY": │ │ │ │ + case "VALUE": │ │ │ │ + postfix.push(tok); │ │ │ │ + break; │ │ │ │ + case "COMPARISON": │ │ │ │ + case "BETWEEN": │ │ │ │ + case "IS_NULL": │ │ │ │ + case "LOGICAL": │ │ │ │ + var p = precedence[tok.type]; │ │ │ │ + while (operatorStack.length > 0 && precedence[operatorStack[operatorStack.length - 1].type] <= p) { │ │ │ │ + postfix.push(operatorStack.pop()) │ │ │ │ } │ │ │ │ - this.triggerCallback(type, "in", [this.feature]) │ │ │ │ - } else if (!previouslyIn || click) { │ │ │ │ - this.triggerCallback(type, "in", [this.feature]) │ │ │ │ - } │ │ │ │ - this.lastFeature = this.feature; │ │ │ │ - handled = true │ │ │ │ - } else { │ │ │ │ - if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ - this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ - } │ │ │ │ - this.feature = null │ │ │ │ + operatorStack.push(tok); │ │ │ │ + break; │ │ │ │ + case "SPATIAL": │ │ │ │ + case "NOT": │ │ │ │ + case "LPAREN": │ │ │ │ + operatorStack.push(tok); │ │ │ │ + break; │ │ │ │ + case "RPAREN": │ │ │ │ + while (operatorStack.length > 0 && operatorStack[operatorStack.length - 1].type != "LPAREN") { │ │ │ │ + postfix.push(operatorStack.pop()) │ │ │ │ + } │ │ │ │ + operatorStack.pop(); │ │ │ │ + if (operatorStack.length > 0 && operatorStack[operatorStack.length - 1].type == "SPATIAL") { │ │ │ │ + postfix.push(operatorStack.pop()) │ │ │ │ + } │ │ │ │ + case "COMMA": │ │ │ │ + case "END": │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + throw new Error("Unknown token type " + tok.type) │ │ │ │ } │ │ │ │ - } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ - this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ } │ │ │ │ - return handled │ │ │ │ - }, │ │ │ │ - triggerCallback: function(type, mode, args) { │ │ │ │ - var key = this.EVENTMAP[type][mode]; │ │ │ │ - if (key) { │ │ │ │ - if (type == "click" && this.up && this.down) { │ │ │ │ - var dpx = Math.sqrt(Math.pow(this.up.x - this.down.x, 2) + Math.pow(this.up.y - this.down.y, 2)); │ │ │ │ - if (dpx <= this.clickTolerance) { │ │ │ │ - this.callback(key, args) │ │ │ │ - } │ │ │ │ - this.up = this.down = null │ │ │ │ - } else { │ │ │ │ - this.callback(key, args) │ │ │ │ - } │ │ │ │ + while (operatorStack.length > 0) { │ │ │ │ + postfix.push(operatorStack.pop()) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - this.map.events.on({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - activated = true │ │ │ │ + │ │ │ │ + function buildTree() { │ │ │ │ + var tok = postfix.pop(); │ │ │ │ + switch (tok.type) { │ │ │ │ + case "LOGICAL": │ │ │ │ + var rhs = buildTree(), │ │ │ │ + lhs = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Logical({ │ │ │ │ + filters: [lhs, rhs], │ │ │ │ + type: logicals[tok.text.toUpperCase()] │ │ │ │ + }); │ │ │ │ + case "NOT": │ │ │ │ + var operand = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Logical({ │ │ │ │ + filters: [operand], │ │ │ │ + type: OpenLayers.Filter.Logical.NOT │ │ │ │ + }); │ │ │ │ + case "BETWEEN": │ │ │ │ + var min, max, property; │ │ │ │ + postfix.pop(); │ │ │ │ + max = buildTree(); │ │ │ │ + min = buildTree(); │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Comparison({ │ │ │ │ + property: property, │ │ │ │ + lowerBoundary: min, │ │ │ │ + upperBoundary: max, │ │ │ │ + type: OpenLayers.Filter.Comparison.BETWEEN │ │ │ │ + }); │ │ │ │ + case "COMPARISON": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Comparison({ │ │ │ │ + property: property, │ │ │ │ + value: value, │ │ │ │ + type: operators[tok.text.toUpperCase()] │ │ │ │ + }); │ │ │ │ + case "IS_NULL": │ │ │ │ + var property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Comparison({ │ │ │ │ + property: property, │ │ │ │ + type: operators[tok.text.toUpperCase()] │ │ │ │ + }); │ │ │ │ + case "VALUE": │ │ │ │ + var match = tok.text.match(/^'(.*)'$/); │ │ │ │ + if (match) { │ │ │ │ + return match[1].replace(/''/g, "'") │ │ │ │ + } else { │ │ │ │ + return Number(tok.text) │ │ │ │ + } │ │ │ │ + case "SPATIAL": │ │ │ │ + switch (tok.text.toUpperCase()) { │ │ │ │ + case "BBOX": │ │ │ │ + var maxy = buildTree(), │ │ │ │ + maxx = buildTree(), │ │ │ │ + miny = buildTree(), │ │ │ │ + minx = buildTree(), │ │ │ │ + prop = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + property: prop, │ │ │ │ + value: OpenLayers.Bounds.fromArray([minx, miny, maxx, maxy]) │ │ │ │ + }); │ │ │ │ + case "INTERSECTS": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + case "WITHIN": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.WITHIN, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + case "CONTAINS": │ │ │ │ + var value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.CONTAINS, │ │ │ │ + property: property, │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + case "DWITHIN": │ │ │ │ + var distance = buildTree(), │ │ │ │ + value = buildTree(), │ │ │ │ + property = buildTree(); │ │ │ │ + return new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ + value: value, │ │ │ │ + property: property, │ │ │ │ + distance: Number(distance) │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + case "GEOMETRY": │ │ │ │ + return OpenLayers.Geometry.fromWKT(tok.text); │ │ │ │ + default: │ │ │ │ + return tok.text │ │ │ │ + } │ │ │ │ } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.moveLayerBack(); │ │ │ │ - this.feature = null; │ │ │ │ - this.lastFeature = null; │ │ │ │ - this.down = null; │ │ │ │ - this.up = null; │ │ │ │ - this.map.events.un({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - deactivated = true │ │ │ │ + var result = buildTree(); │ │ │ │ + if (postfix.length > 0) { │ │ │ │ + var msg = "Remaining tokens after building AST: \n"; │ │ │ │ + for (var i = postfix.length - 1; i >= 0; i--) { │ │ │ │ + msg += postfix[i].type + ": " + postfix[i].text + "\n" │ │ │ │ + } │ │ │ │ + throw new Error(msg) │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ + return result │ │ │ │ + } │ │ │ │ + return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ + read: function(text) { │ │ │ │ + var result = buildAst(tokenize(text)); │ │ │ │ + if (this.keepData) { │ │ │ │ + this.data = result │ │ │ │ + } │ │ │ │ + return result │ │ │ │ + }, │ │ │ │ + write: function(filter) { │ │ │ │ + if (filter instanceof OpenLayers.Geometry) { │ │ │ │ + return filter.toString() │ │ │ │ + } │ │ │ │ + switch (filter.CLASS_NAME) { │ │ │ │ + case "OpenLayers.Filter.Spatial": │ │ │ │ + switch (filter.type) { │ │ │ │ + case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ + return "BBOX(" + filter.property + "," + filter.value.toBBOX() + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ + return "DWITHIN(" + filter.property + ", " + this.write(filter.value) + ", " + filter.distance + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ + return "WITHIN(" + filter.property + ", " + this.write(filter.value) + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ + return "INTERSECTS(" + filter.property + ", " + this.write(filter.value) + ")"; │ │ │ │ + case OpenLayers.Filter.Spatial.CONTAINS: │ │ │ │ + return "CONTAINS(" + filter.property + ", " + this.write(filter.value) + ")"; │ │ │ │ + default: │ │ │ │ + throw new Error("Unknown spatial filter type: " + filter.type) │ │ │ │ + } │ │ │ │ + case "OpenLayers.Filter.Logical": │ │ │ │ + if (filter.type == OpenLayers.Filter.Logical.NOT) { │ │ │ │ + return "NOT (" + this.write(filter.filters[0]) + ")" │ │ │ │ + } else { │ │ │ │ + var res = "("; │ │ │ │ + var first = true; │ │ │ │ + for (var i = 0; i < filter.filters.length; i++) { │ │ │ │ + if (first) { │ │ │ │ + first = false │ │ │ │ + } else { │ │ │ │ + res += ") " + logicalReverse[filter.type] + " (" │ │ │ │ + } │ │ │ │ + res += this.write(filter.filters[i]) │ │ │ │ + } │ │ │ │ + return res + ")" │ │ │ │ + } │ │ │ │ + case "OpenLayers.Filter.Comparison": │ │ │ │ + if (filter.type == OpenLayers.Filter.Comparison.BETWEEN) { │ │ │ │ + return filter.property + " BETWEEN " + this.write(filter.lowerBoundary) + " AND " + this.write(filter.upperBoundary) │ │ │ │ + } else { │ │ │ │ + return filter.value !== null ? filter.property + " " + operatorReverse[filter.type] + " " + this.write(filter.value) : filter.property + " " + operatorReverse[filter.type] │ │ │ │ + } │ │ │ │ + case undefined: │ │ │ │ + if (typeof filter === "string") { │ │ │ │ + return "'" + filter.replace(/'/g, "''") + "'" │ │ │ │ + } else if (typeof filter === "number") { │ │ │ │ + return String(filter) │ │ │ │ + } │ │ │ │ + default: │ │ │ │ + throw new Error("Can't encode: " + filter.CLASS_NAME + " " + filter) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.CQL" │ │ │ │ + }) │ │ │ │ +}(); │ │ │ │ +OpenLayers.Format.Atom = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + atom: "http://www.w3.org/2005/Atom", │ │ │ │ + georss: "http://www.georss.org/georss" │ │ │ │ }, │ │ │ │ - handleMapEvents: function(evt) { │ │ │ │ - if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ - this.moveLayerToTop() │ │ │ │ + feedTitle: "untitled", │ │ │ │ + defaultEntryTitle: "untitled", │ │ │ │ + gmlParser: null, │ │ │ │ + xy: false, │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ } │ │ │ │ + return this.parseFeatures(doc) │ │ │ │ }, │ │ │ │ - moveLayerToTop: function() { │ │ │ │ - var index = Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) + 1; │ │ │ │ - this.layer.setZIndex(index) │ │ │ │ - }, │ │ │ │ - moveLayerBack: function() { │ │ │ │ - var index = this.layer.getZIndex() - 1; │ │ │ │ - if (index >= this.map.Z_INDEX_BASE["Feature"]) { │ │ │ │ - this.layer.setZIndex(index) │ │ │ │ + write: function(features) { │ │ │ │ + var doc; │ │ │ │ + if (OpenLayers.Util.isArray(features)) { │ │ │ │ + doc = this.createElementNSPlus("atom:feed"); │ │ │ │ + doc.appendChild(this.createElementNSPlus("atom:title", { │ │ │ │ + value: this.feedTitle │ │ │ │ + })); │ │ │ │ + for (var i = 0, ii = features.length; i < ii; i++) { │ │ │ │ + doc.appendChild(this.buildEntryNode(features[i])) │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.DragFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - geometryTypes: null, │ │ │ │ - onStart: function(feature, pixel) {}, │ │ │ │ - onDrag: function(feature, pixel) {}, │ │ │ │ - onComplete: function(feature, pixel) {}, │ │ │ │ - onEnter: function(feature) {}, │ │ │ │ - onLeave: function(feature) {}, │ │ │ │ - documentDrag: false, │ │ │ │ - layer: null, │ │ │ │ - feature: null, │ │ │ │ - dragCallbacks: {}, │ │ │ │ - featureCallbacks: {}, │ │ │ │ - lastPixel: null, │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.layer = layer; │ │ │ │ - this.handlers = { │ │ │ │ - drag: new OpenLayers.Handler.Drag(this, OpenLayers.Util.extend({ │ │ │ │ - down: this.downFeature, │ │ │ │ - move: this.moveFeature, │ │ │ │ - up: this.upFeature, │ │ │ │ - out: this.cancel, │ │ │ │ - done: this.doneDragging │ │ │ │ - }, this.dragCallbacks), { │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }), │ │ │ │ - feature: new OpenLayers.Handler.Feature(this, this.layer, OpenLayers.Util.extend({ │ │ │ │ - click: this.clickFeature, │ │ │ │ - clickout: this.clickoutFeature, │ │ │ │ - over: this.overFeature, │ │ │ │ - out: this.outFeature │ │ │ │ - }, this.featureCallbacks), { │ │ │ │ - geometryTypes: this.geometryTypes │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clickFeature: function(feature) { │ │ │ │ - if (this.handlers.feature.touch && !this.over && this.overFeature(feature)) { │ │ │ │ - this.handlers.drag.dragstart(this.handlers.feature.evt); │ │ │ │ - this.handlers.drag.stopDown = false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clickoutFeature: function(feature) { │ │ │ │ - if (this.handlers.feature.touch && this.over) { │ │ │ │ - this.outFeature(feature); │ │ │ │ - this.handlers.drag.stopDown = true │ │ │ │ + doc = this.buildEntryNode(features) │ │ │ │ } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [doc]) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.layer = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, []) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - return this.handlers.feature.activate() && OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - this.handlers.feature.deactivate(); │ │ │ │ - this.feature = null; │ │ │ │ - this.dragging = false; │ │ │ │ - this.lastPixel = null; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - overFeature: function(feature) { │ │ │ │ - var activated = false; │ │ │ │ - if (!this.handlers.drag.dragging) { │ │ │ │ - this.feature = feature; │ │ │ │ - this.handlers.drag.activate(); │ │ │ │ - activated = true; │ │ │ │ - this.over = true; │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ - this.onEnter(feature) │ │ │ │ + buildContentNode: function(content) { │ │ │ │ + var node = this.createElementNSPlus("atom:content", { │ │ │ │ + attributes: { │ │ │ │ + type: content.type || null │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (content.src) { │ │ │ │ + node.setAttribute("src", content.src) │ │ │ │ } else { │ │ │ │ - if (this.feature.id == feature.id) { │ │ │ │ - this.over = true │ │ │ │ + if (content.type == "text" || content.type == null) { │ │ │ │ + node.appendChild(this.createTextNode(content.value)) │ │ │ │ + } else if (content.type == "html") { │ │ │ │ + if (typeof content.value != "string") { │ │ │ │ + throw "HTML content must be in form of an escaped string" │ │ │ │ + } │ │ │ │ + node.appendChild(this.createTextNode(content.value)) │ │ │ │ + } else if (content.type == "xhtml") { │ │ │ │ + node.appendChild(content.value) │ │ │ │ + } else if (content.type == "xhtml" || content.type.match(/(\+|\/)xml$/)) { │ │ │ │ + node.appendChild(content.value) │ │ │ │ } else { │ │ │ │ - this.over = false │ │ │ │ + node.appendChild(this.createTextNode(content.value)) │ │ │ │ } │ │ │ │ } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - downFeature: function(pixel) { │ │ │ │ - this.lastPixel = pixel; │ │ │ │ - this.onStart(this.feature, pixel) │ │ │ │ - }, │ │ │ │ - moveFeature: function(pixel) { │ │ │ │ - var res = this.map.getResolution(); │ │ │ │ - this.feature.geometry.move(res * (pixel.x - this.lastPixel.x), res * (this.lastPixel.y - pixel.y)); │ │ │ │ - this.layer.drawFeature(this.feature); │ │ │ │ - this.lastPixel = pixel; │ │ │ │ - this.onDrag(this.feature, pixel) │ │ │ │ - }, │ │ │ │ - upFeature: function(pixel) { │ │ │ │ - if (!this.over) { │ │ │ │ - this.handlers.drag.deactivate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - doneDragging: function(pixel) { │ │ │ │ - this.onComplete(this.feature, pixel) │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - outFeature: function(feature) { │ │ │ │ - if (!this.handlers.drag.dragging) { │ │ │ │ - this.over = false; │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ - this.onLeave(feature); │ │ │ │ - this.feature = null │ │ │ │ - } else { │ │ │ │ - if (this.feature.id == feature.id) { │ │ │ │ - this.over = false │ │ │ │ + buildEntryNode: function(feature) { │ │ │ │ + var attrib = feature.attributes; │ │ │ │ + var atomAttrib = attrib.atom || {}; │ │ │ │ + var entryNode = this.createElementNSPlus("atom:entry"); │ │ │ │ + if (atomAttrib.authors) { │ │ │ │ + var authors = OpenLayers.Util.isArray(atomAttrib.authors) ? atomAttrib.authors : [atomAttrib.authors]; │ │ │ │ + for (var i = 0, ii = authors.length; i < ii; i++) { │ │ │ │ + entryNode.appendChild(this.buildPersonConstructNode("author", authors[i])) │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - cancel: function() { │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - this.over = false │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.drag.setMap(map); │ │ │ │ - this.handlers.feature.setMap(map); │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DragFeature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.RegularPolygon = OpenLayers.Class(OpenLayers.Handler.Drag, { │ │ │ │ - sides: 4, │ │ │ │ - radius: null, │ │ │ │ - snapAngle: null, │ │ │ │ - snapToggle: "shiftKey", │ │ │ │ - layerOptions: null, │ │ │ │ - persist: false, │ │ │ │ - irregular: false, │ │ │ │ - citeCompliant: false, │ │ │ │ - angle: null, │ │ │ │ - fixedRadius: false, │ │ │ │ - feature: null, │ │ │ │ - layer: null, │ │ │ │ - origin: null, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ - this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style["default"], {}) │ │ │ │ - } │ │ │ │ - OpenLayers.Handler.Drag.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ - this.options = options ? options : {} │ │ │ │ - }, │ │ │ │ - setOptions: function(newOptions) { │ │ │ │ - OpenLayers.Util.extend(this.options, newOptions); │ │ │ │ - OpenLayers.Util.extend(this, newOptions) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.Drag.prototype.activate.apply(this, arguments)) { │ │ │ │ - var options = OpenLayers.Util.extend({ │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - calculateInRange: OpenLayers.Function.True, │ │ │ │ - wrapDateLine: this.citeCompliant │ │ │ │ - }, this.layerOptions); │ │ │ │ - this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ - this.map.addLayer(this.layer); │ │ │ │ - activated = true │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.Drag.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - if (this.dragging) { │ │ │ │ - this.cancel() │ │ │ │ - } │ │ │ │ - if (this.layer.map != null) { │ │ │ │ - this.layer.destroy(false); │ │ │ │ - if (this.feature) { │ │ │ │ - this.feature.destroy() │ │ │ │ - } │ │ │ │ + if (atomAttrib.categories) { │ │ │ │ + var categories = OpenLayers.Util.isArray(atomAttrib.categories) ? atomAttrib.categories : [atomAttrib.categories]; │ │ │ │ + var category; │ │ │ │ + for (var i = 0, ii = categories.length; i < ii; i++) { │ │ │ │ + category = categories[i]; │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:category", { │ │ │ │ + attributes: { │ │ │ │ + term: category.term, │ │ │ │ + scheme: category.scheme || null, │ │ │ │ + label: category.label || null │ │ │ │ + } │ │ │ │ + })) │ │ │ │ } │ │ │ │ - this.layer = null; │ │ │ │ - this.feature = null; │ │ │ │ - deactivated = true │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - down: function(evt) { │ │ │ │ - this.fixedRadius = !!this.radius; │ │ │ │ - var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ - this.origin = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ - if (!this.fixedRadius || this.irregular) { │ │ │ │ - this.radius = this.map.getResolution() │ │ │ │ + if (atomAttrib.content) { │ │ │ │ + entryNode.appendChild(this.buildContentNode(atomAttrib.content)) │ │ │ │ } │ │ │ │ - if (this.persist) { │ │ │ │ - this.clear() │ │ │ │ + if (atomAttrib.contributors) { │ │ │ │ + var contributors = OpenLayers.Util.isArray(atomAttrib.contributors) ? atomAttrib.contributors : [atomAttrib.contributors]; │ │ │ │ + for (var i = 0, ii = contributors.length; i < ii; i++) { │ │ │ │ + entryNode.appendChild(this.buildPersonConstructNode("contributor", contributors[i])) │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.feature = new OpenLayers.Feature.Vector; │ │ │ │ - this.createGeometry(); │ │ │ │ - this.callback("create", [this.origin, this.feature]); │ │ │ │ - this.layer.addFeatures([this.feature], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.layer.drawFeature(this.feature, this.style) │ │ │ │ - }, │ │ │ │ - move: function(evt) { │ │ │ │ - var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ - var point = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ - if (this.irregular) { │ │ │ │ - var ry = Math.sqrt(2) * Math.abs(point.y - this.origin.y) / 2; │ │ │ │ - this.radius = Math.max(this.map.getResolution() / 2, ry) │ │ │ │ - } else if (this.fixedRadius) { │ │ │ │ - this.origin = point │ │ │ │ - } else { │ │ │ │ - this.calculateAngle(point, evt); │ │ │ │ - this.radius = Math.max(this.map.getResolution() / 2, point.distanceTo(this.origin)) │ │ │ │ + if (feature.fid) { │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:id", { │ │ │ │ + value: feature.fid │ │ │ │ + })) │ │ │ │ } │ │ │ │ - this.modifyGeometry(); │ │ │ │ - if (this.irregular) { │ │ │ │ - var dx = point.x - this.origin.x; │ │ │ │ - var dy = point.y - this.origin.y; │ │ │ │ - var ratio; │ │ │ │ - if (dy == 0) { │ │ │ │ - ratio = dx / (this.radius * Math.sqrt(2)) │ │ │ │ - } else { │ │ │ │ - ratio = dx / dy │ │ │ │ + if (atomAttrib.links) { │ │ │ │ + var links = OpenLayers.Util.isArray(atomAttrib.links) ? atomAttrib.links : [atomAttrib.links]; │ │ │ │ + var link; │ │ │ │ + for (var i = 0, ii = links.length; i < ii; i++) { │ │ │ │ + link = links[i]; │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:link", { │ │ │ │ + attributes: { │ │ │ │ + href: link.href, │ │ │ │ + rel: link.rel || null, │ │ │ │ + type: link.type || null, │ │ │ │ + hreflang: link.hreflang || null, │ │ │ │ + title: link.title || null, │ │ │ │ + length: link.length || null │ │ │ │ + } │ │ │ │ + })) │ │ │ │ } │ │ │ │ - this.feature.geometry.resize(1, this.origin, ratio); │ │ │ │ - this.feature.geometry.move(dx / 2, dy / 2) │ │ │ │ } │ │ │ │ - this.layer.drawFeature(this.feature, this.style) │ │ │ │ - }, │ │ │ │ - up: function(evt) { │ │ │ │ - this.finalize(); │ │ │ │ - if (this.start == this.last) { │ │ │ │ - this.callback("done", [evt.xy]) │ │ │ │ + if (atomAttrib.published) { │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:published", { │ │ │ │ + value: atomAttrib.published │ │ │ │ + })) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - out: function(evt) { │ │ │ │ - this.finalize() │ │ │ │ - }, │ │ │ │ - createGeometry: function() { │ │ │ │ - this.angle = Math.PI * (1 / this.sides - 1 / 2); │ │ │ │ - if (this.snapAngle) { │ │ │ │ - this.angle += this.snapAngle * (Math.PI / 180) │ │ │ │ + if (atomAttrib.rights) { │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:rights", { │ │ │ │ + value: atomAttrib.rights │ │ │ │ + })) │ │ │ │ } │ │ │ │ - this.feature.geometry = OpenLayers.Geometry.Polygon.createRegularPolygon(this.origin, this.radius, this.sides, this.snapAngle) │ │ │ │ - }, │ │ │ │ - modifyGeometry: function() { │ │ │ │ - var angle, point; │ │ │ │ - var ring = this.feature.geometry.components[0]; │ │ │ │ - if (ring.components.length != this.sides + 1) { │ │ │ │ - this.createGeometry(); │ │ │ │ - ring = this.feature.geometry.components[0] │ │ │ │ + if (atomAttrib.summary || attrib.description) { │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:summary", { │ │ │ │ + value: atomAttrib.summary || attrib.description │ │ │ │ + })) │ │ │ │ } │ │ │ │ - for (var i = 0; i < this.sides; ++i) { │ │ │ │ - point = ring.components[i]; │ │ │ │ - angle = this.angle + i * 2 * Math.PI / this.sides; │ │ │ │ - point.x = this.origin.x + this.radius * Math.cos(angle); │ │ │ │ - point.y = this.origin.y + this.radius * Math.sin(angle); │ │ │ │ - point.clearBounds() │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:title", { │ │ │ │ + value: atomAttrib.title || attrib.title || this.defaultEntryTitle │ │ │ │ + })); │ │ │ │ + if (atomAttrib.updated) { │ │ │ │ + entryNode.appendChild(this.createElementNSPlus("atom:updated", { │ │ │ │ + value: atomAttrib.updated │ │ │ │ + })) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - calculateAngle: function(point, evt) { │ │ │ │ - var alpha = Math.atan2(point.y - this.origin.y, point.x - this.origin.x); │ │ │ │ - if (this.snapAngle && (this.snapToggle && !evt[this.snapToggle])) { │ │ │ │ - var snapAngleRad = Math.PI / 180 * this.snapAngle; │ │ │ │ - this.angle = Math.round(alpha / snapAngleRad) * snapAngleRad │ │ │ │ - } else { │ │ │ │ - this.angle = alpha │ │ │ │ + if (feature.geometry) { │ │ │ │ + var whereNode = this.createElementNSPlus("georss:where"); │ │ │ │ + whereNode.appendChild(this.buildGeometryNode(feature.geometry)); │ │ │ │ + entryNode.appendChild(whereNode) │ │ │ │ } │ │ │ │ + return entryNode │ │ │ │ }, │ │ │ │ - cancel: function() { │ │ │ │ - this.callback("cancel", null); │ │ │ │ - this.finalize() │ │ │ │ - }, │ │ │ │ - finalize: function() { │ │ │ │ - this.origin = null; │ │ │ │ - this.radius = this.options.radius │ │ │ │ + initGmlParser: function() { │ │ │ │ + this.gmlParser = new OpenLayers.Format.GML.v3({ │ │ │ │ + xy: this.xy, │ │ │ │ + featureNS: "http://example.com#feature", │ │ │ │ + internalProjection: this.internalProjection, │ │ │ │ + externalProjection: this.externalProjection │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - clear: function() { │ │ │ │ - if (this.layer) { │ │ │ │ - this.layer.renderer.clear(); │ │ │ │ - this.layer.destroyFeatures() │ │ │ │ + buildGeometryNode: function(geometry) { │ │ │ │ + if (!this.gmlParser) { │ │ │ │ + this.initGmlParser() │ │ │ │ } │ │ │ │ + var node = this.gmlParser.writeNode("feature:_geometry", geometry); │ │ │ │ + return node.firstChild │ │ │ │ }, │ │ │ │ - callback: function(name, args) { │ │ │ │ - if (this.callbacks[name]) { │ │ │ │ - this.callbacks[name].apply(this.control, [this.feature.geometry.clone()]) │ │ │ │ - } │ │ │ │ - if (!this.persist && (name == "done" || name == "cancel")) { │ │ │ │ - this.clear() │ │ │ │ + buildPersonConstructNode: function(name, value) { │ │ │ │ + var oNames = ["uri", "email"]; │ │ │ │ + var personNode = this.createElementNSPlus("atom:" + name); │ │ │ │ + personNode.appendChild(this.createElementNSPlus("atom:name", { │ │ │ │ + value: value.name │ │ │ │ + })); │ │ │ │ + for (var i = 0, ii = oNames.length; i < ii; i++) { │ │ │ │ + if (value[oNames[i]]) { │ │ │ │ + personNode.appendChild(this.createElementNSPlus("atom:" + oNames[i], { │ │ │ │ + value: value[oNames[i]] │ │ │ │ + })) │ │ │ │ + } │ │ │ │ } │ │ │ │ + return personNode │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.RegularPolygon" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.Point = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - point: null, │ │ │ │ - layer: null, │ │ │ │ - multi: false, │ │ │ │ - citeCompliant: false, │ │ │ │ - mouseDown: false, │ │ │ │ - stoppedDown: null, │ │ │ │ - lastDown: null, │ │ │ │ - lastUp: null, │ │ │ │ - persist: false, │ │ │ │ - stopDown: false, │ │ │ │ - stopUp: false, │ │ │ │ - layerOptions: null, │ │ │ │ - pixelTolerance: 5, │ │ │ │ - lastTouchPx: null, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ - this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style["default"], {}) │ │ │ │ + getFirstChildValue: function(node, nsuri, name, def) { │ │ │ │ + var value; │ │ │ │ + var nodes = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ + if (nodes && nodes.length > 0) { │ │ │ │ + value = this.getChildValue(nodes[0], def) │ │ │ │ + } else { │ │ │ │ + value = def │ │ │ │ } │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments) │ │ │ │ + return value │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (!OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - return false │ │ │ │ + parseFeature: function(node) { │ │ │ │ + var atomAttrib = {}; │ │ │ │ + var value = null; │ │ │ │ + var nodes = null; │ │ │ │ + var attval = null; │ │ │ │ + var atomns = this.namespaces.atom; │ │ │ │ + this.parsePersonConstructs(node, "author", atomAttrib); │ │ │ │ + nodes = this.getElementsByTagNameNS(node, atomns, "category"); │ │ │ │ + if (nodes.length > 0) { │ │ │ │ + atomAttrib.categories = [] │ │ │ │ } │ │ │ │ - var options = OpenLayers.Util.extend({ │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - calculateInRange: OpenLayers.Function.True, │ │ │ │ - wrapDateLine: this.citeCompliant │ │ │ │ - }, this.layerOptions); │ │ │ │ - this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ - this.map.addLayer(this.layer); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - createFeature: function(pixel) { │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - this.callback("create", [this.point.geometry, this.point]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.layer.addFeatures([this.point], { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (!OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - return false │ │ │ │ + for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ + value = {}; │ │ │ │ + value.term = nodes[i].getAttribute("term"); │ │ │ │ + attval = nodes[i].getAttribute("scheme"); │ │ │ │ + if (attval) { │ │ │ │ + value.scheme = attval │ │ │ │ + } │ │ │ │ + attval = nodes[i].getAttribute("label"); │ │ │ │ + if (attval) { │ │ │ │ + value.label = attval │ │ │ │ + } │ │ │ │ + atomAttrib.categories.push(value) │ │ │ │ } │ │ │ │ - this.cancel(); │ │ │ │ - if (this.layer.map != null) { │ │ │ │ - this.destroyFeature(true); │ │ │ │ - this.layer.destroy(false) │ │ │ │ + nodes = this.getElementsByTagNameNS(node, atomns, "content"); │ │ │ │ + if (nodes.length > 0) { │ │ │ │ + value = {}; │ │ │ │ + attval = nodes[0].getAttribute("type"); │ │ │ │ + if (attval) { │ │ │ │ + value.type = attval │ │ │ │ + } │ │ │ │ + attval = nodes[0].getAttribute("src"); │ │ │ │ + if (attval) { │ │ │ │ + value.src = attval │ │ │ │ + } else { │ │ │ │ + if (value.type == "text" || value.type == "html" || value.type == null) { │ │ │ │ + value.value = this.getFirstChildValue(node, atomns, "content", null) │ │ │ │ + } else if (value.type == "xhtml" || value.type.match(/(\+|\/)xml$/)) { │ │ │ │ + value.value = this.getChildEl(nodes[0]) │ │ │ │ + } else { │ │ │ │ + value.value = this.getFirstChildValue(node, atomns, "content", null) │ │ │ │ + } │ │ │ │ + atomAttrib.content = value │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.layer = null; │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - destroyFeature: function(force) { │ │ │ │ - if (this.layer && (force || !this.persist)) { │ │ │ │ - this.layer.destroyFeatures() │ │ │ │ + this.parsePersonConstructs(node, "contributor", atomAttrib); │ │ │ │ + atomAttrib.id = this.getFirstChildValue(node, atomns, "id", null); │ │ │ │ + nodes = this.getElementsByTagNameNS(node, atomns, "link"); │ │ │ │ + if (nodes.length > 0) { │ │ │ │ + atomAttrib.links = new Array(nodes.length) │ │ │ │ } │ │ │ │ - this.point = null │ │ │ │ - }, │ │ │ │ - destroyPersistedFeature: function() { │ │ │ │ - var layer = this.layer; │ │ │ │ - if (layer && layer.features.length > 1) { │ │ │ │ - this.layer.features[0].destroy() │ │ │ │ + var oAtts = ["rel", "type", "hreflang", "title", "length"]; │ │ │ │ + for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ + value = {}; │ │ │ │ + value.href = nodes[i].getAttribute("href"); │ │ │ │ + for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ + attval = nodes[i].getAttribute(oAtts[j]); │ │ │ │ + if (attval) { │ │ │ │ + value[oAtts[j]] = attval │ │ │ │ + } │ │ │ │ + } │ │ │ │ + atomAttrib.links[i] = value │ │ │ │ } │ │ │ │ - }, │ │ │ │ - finalize: function(cancel) { │ │ │ │ - var key = cancel ? "cancel" : "done"; │ │ │ │ - this.mouseDown = false; │ │ │ │ - this.lastDown = null; │ │ │ │ - this.lastUp = null; │ │ │ │ - this.lastTouchPx = null; │ │ │ │ - this.callback(key, [this.geometryClone()]); │ │ │ │ - this.destroyFeature(cancel) │ │ │ │ - }, │ │ │ │ - cancel: function() { │ │ │ │ - this.finalize(true) │ │ │ │ - }, │ │ │ │ - click: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - dblclick: function(evt) { │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - modifyFeature: function(pixel) { │ │ │ │ - if (!this.point) { │ │ │ │ - this.createFeature(pixel) │ │ │ │ + value = this.getFirstChildValue(node, atomns, "published", null); │ │ │ │ + if (value) { │ │ │ │ + atomAttrib.published = value │ │ │ │ } │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - this.point.geometry.x = lonlat.lon; │ │ │ │ - this.point.geometry.y = lonlat.lat; │ │ │ │ - this.callback("modify", [this.point.geometry, this.point, false]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.drawFeature() │ │ │ │ - }, │ │ │ │ - drawFeature: function() { │ │ │ │ - this.layer.drawFeature(this.point, this.style) │ │ │ │ - }, │ │ │ │ - getGeometry: function() { │ │ │ │ - var geometry = this.point && this.point.geometry; │ │ │ │ - if (geometry && this.multi) { │ │ │ │ - geometry = new OpenLayers.Geometry.MultiPoint([geometry]) │ │ │ │ + value = this.getFirstChildValue(node, atomns, "rights", null); │ │ │ │ + if (value) { │ │ │ │ + atomAttrib.rights = value │ │ │ │ } │ │ │ │ - return geometry │ │ │ │ - }, │ │ │ │ - geometryClone: function() { │ │ │ │ - var geom = this.getGeometry(); │ │ │ │ - return geom && geom.clone() │ │ │ │ - }, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - return this.down(evt) │ │ │ │ - }, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - this.lastTouchPx = evt.xy; │ │ │ │ - return this.down(evt) │ │ │ │ - }, │ │ │ │ - mousemove: function(evt) { │ │ │ │ - return this.move(evt) │ │ │ │ - }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - this.lastTouchPx = evt.xy; │ │ │ │ - return this.move(evt) │ │ │ │ - }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - return this.up(evt) │ │ │ │ - }, │ │ │ │ - touchend: function(evt) { │ │ │ │ - evt.xy = this.lastTouchPx; │ │ │ │ - return this.up(evt) │ │ │ │ - }, │ │ │ │ - down: function(evt) { │ │ │ │ - this.mouseDown = true; │ │ │ │ - this.lastDown = evt.xy; │ │ │ │ - if (!this.touch) { │ │ │ │ - this.modifyFeature(evt.xy) │ │ │ │ + value = this.getFirstChildValue(node, atomns, "summary", null); │ │ │ │ + if (value) { │ │ │ │ + atomAttrib.summary = value │ │ │ │ } │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - return !this.stopDown │ │ │ │ + atomAttrib.title = this.getFirstChildValue(node, atomns, "title", null); │ │ │ │ + atomAttrib.updated = this.getFirstChildValue(node, atomns, "updated", null); │ │ │ │ + var featureAttrib = { │ │ │ │ + title: atomAttrib.title, │ │ │ │ + description: atomAttrib.summary, │ │ │ │ + atom: atomAttrib │ │ │ │ + }; │ │ │ │ + var geometry = this.parseLocations(node)[0]; │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, featureAttrib); │ │ │ │ + feature.fid = atomAttrib.id; │ │ │ │ + return feature │ │ │ │ }, │ │ │ │ - move: function(evt) { │ │ │ │ - if (!this.touch && (!this.mouseDown || this.stoppedDown)) { │ │ │ │ - this.modifyFeature(evt.xy) │ │ │ │ + parseFeatures: function(node) { │ │ │ │ + var features = []; │ │ │ │ + var entries = this.getElementsByTagNameNS(node, this.namespaces.atom, "entry"); │ │ │ │ + if (entries.length == 0) { │ │ │ │ + entries = [node] │ │ │ │ } │ │ │ │ - return true │ │ │ │ + for (var i = 0, ii = entries.length; i < ii; i++) { │ │ │ │ + features.push(this.parseFeature(entries[i])) │ │ │ │ + } │ │ │ │ + return features │ │ │ │ }, │ │ │ │ - up: function(evt) { │ │ │ │ - this.mouseDown = false; │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - if (!this.checkModifiers(evt)) { │ │ │ │ - return true │ │ │ │ + parseLocations: function(node) { │ │ │ │ + var georssns = this.namespaces.georss; │ │ │ │ + var locations = { │ │ │ │ + components: [] │ │ │ │ + }; │ │ │ │ + var where = this.getElementsByTagNameNS(node, georssns, "where"); │ │ │ │ + if (where && where.length > 0) { │ │ │ │ + if (!this.gmlParser) { │ │ │ │ + this.initGmlParser() │ │ │ │ + } │ │ │ │ + for (var i = 0, ii = where.length; i < ii; i++) { │ │ │ │ + this.gmlParser.readChildNodes(where[i], locations) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.lastUp && this.lastUp.equals(evt.xy)) { │ │ │ │ - return true │ │ │ │ + var components = locations.components; │ │ │ │ + var point = this.getElementsByTagNameNS(node, georssns, "point"); │ │ │ │ + if (point && point.length > 0) { │ │ │ │ + for (var i = 0, ii = point.length; i < ii; i++) { │ │ │ │ + var xy = OpenLayers.String.trim(point[i].firstChild.nodeValue).split(/\s+/); │ │ │ │ + if (xy.length != 2) { │ │ │ │ + xy = OpenLayers.String.trim(point[i].firstChild.nodeValue).split(/\s*,\s*/) │ │ │ │ + } │ │ │ │ + components.push(new OpenLayers.Geometry.Point(xy[1], xy[0])) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy, this.pixelTolerance)) { │ │ │ │ - if (this.touch) { │ │ │ │ - this.modifyFeature(evt.xy) │ │ │ │ + var line = this.getElementsByTagNameNS(node, georssns, "line"); │ │ │ │ + if (line && line.length > 0) { │ │ │ │ + var coords; │ │ │ │ + var p; │ │ │ │ + var points; │ │ │ │ + for (var i = 0, ii = line.length; i < ii; i++) { │ │ │ │ + coords = OpenLayers.String.trim(line[i].firstChild.nodeValue).split(/\s+/); │ │ │ │ + points = []; │ │ │ │ + for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ + p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ + points.push(p) │ │ │ │ + } │ │ │ │ + components.push(new OpenLayers.Geometry.LineString(points)) │ │ │ │ } │ │ │ │ - if (this.persist) { │ │ │ │ - this.destroyPersistedFeature() │ │ │ │ + } │ │ │ │ + var polygon = this.getElementsByTagNameNS(node, georssns, "polygon"); │ │ │ │ + if (polygon && polygon.length > 0) { │ │ │ │ + var coords; │ │ │ │ + var p; │ │ │ │ + var points; │ │ │ │ + for (var i = 0, ii = polygon.length; i < ii; i++) { │ │ │ │ + coords = OpenLayers.String.trim(polygon[i].firstChild.nodeValue).split(/\s+/); │ │ │ │ + points = []; │ │ │ │ + for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ + p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ + points.push(p) │ │ │ │ + } │ │ │ │ + components.push(new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(points)])) │ │ │ │ } │ │ │ │ - this.lastUp = evt.xy; │ │ │ │ - this.finalize(); │ │ │ │ - return !this.stopUp │ │ │ │ - } else { │ │ │ │ - return true │ │ │ │ } │ │ │ │ - }, │ │ │ │ - mouseout: function(evt) { │ │ │ │ - if (OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - this.mouseDown = false │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + for (var i = 0, ii = components.length; i < ii; i++) { │ │ │ │ + if (components[i]) { │ │ │ │ + components[i].transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return components │ │ │ │ }, │ │ │ │ - passesTolerance: function(pixel1, pixel2, tolerance) { │ │ │ │ - var passes = true; │ │ │ │ - if (tolerance != null && pixel1 && pixel2) { │ │ │ │ - var dist = pixel1.distanceTo(pixel2); │ │ │ │ - if (dist > tolerance) { │ │ │ │ - passes = false │ │ │ │ + parsePersonConstructs: function(node, name, data) { │ │ │ │ + var persons = []; │ │ │ │ + var atomns = this.namespaces.atom; │ │ │ │ + var nodes = this.getElementsByTagNameNS(node, atomns, name); │ │ │ │ + var oAtts = ["uri", "email"]; │ │ │ │ + for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ + var value = {}; │ │ │ │ + value.name = this.getFirstChildValue(nodes[i], atomns, "name", null); │ │ │ │ + for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ + var attval = this.getFirstChildValue(nodes[i], atomns, oAtts[j], null); │ │ │ │ + if (attval) { │ │ │ │ + value[oAtts[j]] = attval │ │ │ │ + } │ │ │ │ } │ │ │ │ + persons.push(value) │ │ │ │ + } │ │ │ │ + if (persons.length > 0) { │ │ │ │ + data[name + "s"] = persons │ │ │ │ } │ │ │ │ - return passes │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Point" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Atom" │ │ │ │ }); │ │ │ │ -OpenLayers.Handler.Path = OpenLayers.Class(OpenLayers.Handler.Point, { │ │ │ │ - line: null, │ │ │ │ - maxVertices: null, │ │ │ │ - doubleTouchTolerance: 20, │ │ │ │ - freehand: false, │ │ │ │ - freehandToggle: "shiftKey", │ │ │ │ - timerId: null, │ │ │ │ - redoStack: null, │ │ │ │ - createFeature: function(pixel) { │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - this.line = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString([this.point.geometry])); │ │ │ │ - this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.layer.addFeatures([this.line, this.point], { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ +OpenLayers.Format.GeoRSS = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + rssns: "http://backend.userland.com/rss2", │ │ │ │ + featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ + georssns: "http://www.georss.org/georss", │ │ │ │ + geons: "http://www.w3.org/2003/01/geo/wgs84_pos#", │ │ │ │ + featureTitle: "Untitled", │ │ │ │ + featureDescription: "No Description", │ │ │ │ + gmlParser: null, │ │ │ │ + xy: false, │ │ │ │ + createGeometryFromItem: function(item) { │ │ │ │ + var point = this.getElementsByTagNameNS(item, this.georssns, "point"); │ │ │ │ + var lat = this.getElementsByTagNameNS(item, this.geons, "lat"); │ │ │ │ + var lon = this.getElementsByTagNameNS(item, this.geons, "long"); │ │ │ │ + var line = this.getElementsByTagNameNS(item, this.georssns, "line"); │ │ │ │ + var polygon = this.getElementsByTagNameNS(item, this.georssns, "polygon"); │ │ │ │ + var where = this.getElementsByTagNameNS(item, this.georssns, "where"); │ │ │ │ + var box = this.getElementsByTagNameNS(item, this.georssns, "box"); │ │ │ │ + if (point.length > 0 || lat.length > 0 && lon.length > 0) { │ │ │ │ + var location; │ │ │ │ + if (point.length > 0) { │ │ │ │ + location = OpenLayers.String.trim(point[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ + if (location.length != 2) { │ │ │ │ + location = OpenLayers.String.trim(point[0].firstChild.nodeValue).split(/\s*,\s*/) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + location = [parseFloat(lat[0].firstChild.nodeValue), parseFloat(lon[0].firstChild.nodeValue)] │ │ │ │ + } │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(location[1], location[0]) │ │ │ │ + } else if (line.length > 0) { │ │ │ │ + var coords = OpenLayers.String.trim(this.getChildValue(line[0])).split(/\s+/); │ │ │ │ + var components = []; │ │ │ │ + var point; │ │ │ │ + for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ + components.push(point) │ │ │ │ + } │ │ │ │ + geometry = new OpenLayers.Geometry.LineString(components) │ │ │ │ + } else if (polygon.length > 0) { │ │ │ │ + var coords = OpenLayers.String.trim(this.getChildValue(polygon[0])).split(/\s+/); │ │ │ │ + var components = []; │ │ │ │ + var point; │ │ │ │ + for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ + components.push(point) │ │ │ │ + } │ │ │ │ + geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]) │ │ │ │ + } else if (where.length > 0) { │ │ │ │ + if (!this.gmlParser) { │ │ │ │ + this.gmlParser = new OpenLayers.Format.GML({ │ │ │ │ + xy: this.xy │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + var feature = this.gmlParser.parseFeature(where[0]); │ │ │ │ + geometry = feature.geometry │ │ │ │ + } else if (box.length > 0) { │ │ │ │ + var coords = OpenLayers.String.trim(box[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ + var components = []; │ │ │ │ + var point; │ │ │ │ + if (coords.length > 3) { │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[1], coords[2]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[3], coords[2]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[3], coords[0]); │ │ │ │ + components.push(point); │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ + components.push(point) │ │ │ │ + } │ │ │ │ + geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]) │ │ │ │ + } │ │ │ │ + if (geometry && this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + return geometry │ │ │ │ }, │ │ │ │ - destroyFeature: function(force) { │ │ │ │ - OpenLayers.Handler.Point.prototype.destroyFeature.call(this, force); │ │ │ │ - this.line = null │ │ │ │ + createFeatureFromItem: function(item) { │ │ │ │ + var geometry = this.createGeometryFromItem(item); │ │ │ │ + var title = this._getChildValue(item, "*", "title", this.featureTitle); │ │ │ │ + var description = this._getChildValue(item, "*", "description", this._getChildValue(item, "*", "content", this._getChildValue(item, "*", "summary", this.featureDescription))); │ │ │ │ + var link = this._getChildValue(item, "*", "link"); │ │ │ │ + if (!link) { │ │ │ │ + try { │ │ │ │ + link = this.getElementsByTagNameNS(item, "*", "link")[0].getAttribute("href") │ │ │ │ + } catch (e) { │ │ │ │ + link = null │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var id = this._getChildValue(item, "*", "id", null); │ │ │ │ + var data = { │ │ │ │ + title: title, │ │ │ │ + description: description, │ │ │ │ + link: link │ │ │ │ + }; │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, data); │ │ │ │ + feature.fid = id; │ │ │ │ + return feature │ │ │ │ }, │ │ │ │ - destroyPersistedFeature: function() { │ │ │ │ - var layer = this.layer; │ │ │ │ - if (layer && layer.features.length > 2) { │ │ │ │ - this.layer.features[0].destroy() │ │ │ │ + _getChildValue: function(node, nsuri, name, def) { │ │ │ │ + var value; │ │ │ │ + var eles = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ + if (eles && eles[0] && eles[0].firstChild && eles[0].firstChild.nodeValue) { │ │ │ │ + value = this.getChildValue(eles[0]) │ │ │ │ + } else { │ │ │ │ + value = def == undefined ? "" : def │ │ │ │ } │ │ │ │ + return value │ │ │ │ }, │ │ │ │ - removePoint: function() { │ │ │ │ - if (this.point) { │ │ │ │ - this.layer.removeFeatures([this.point]) │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + } │ │ │ │ + var itemlist = null; │ │ │ │ + itemlist = this.getElementsByTagNameNS(doc, "*", "item"); │ │ │ │ + if (itemlist.length == 0) { │ │ │ │ + itemlist = this.getElementsByTagNameNS(doc, "*", "entry") │ │ │ │ + } │ │ │ │ + var numItems = itemlist.length; │ │ │ │ + var features = new Array(numItems); │ │ │ │ + for (var i = 0; i < numItems; i++) { │ │ │ │ + features[i] = this.createFeatureFromItem(itemlist[i]) │ │ │ │ } │ │ │ │ + return features │ │ │ │ }, │ │ │ │ - addPoint: function(pixel) { │ │ │ │ - this.layer.removeFeatures([this.point]); │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat)); │ │ │ │ - this.line.geometry.addComponent(this.point.geometry, this.line.geometry.components.length); │ │ │ │ - this.layer.addFeatures([this.point]); │ │ │ │ - this.callback("point", [this.point.geometry, this.getGeometry()]); │ │ │ │ - this.callback("modify", [this.point.geometry, this.getSketch()]); │ │ │ │ - this.drawFeature(); │ │ │ │ - delete this.redoStack │ │ │ │ + write: function(features) { │ │ │ │ + var georss; │ │ │ │ + if (OpenLayers.Util.isArray(features)) { │ │ │ │ + georss = this.createElementNS(this.rssns, "rss"); │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + georss.appendChild(this.createFeatureXML(features[i])) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + georss = this.createFeatureXML(features) │ │ │ │ + } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [georss]) │ │ │ │ }, │ │ │ │ - insertXY: function(x, y) { │ │ │ │ - this.line.geometry.addComponent(new OpenLayers.Geometry.Point(x, y), this.getCurrentPointIndex()); │ │ │ │ - this.drawFeature(); │ │ │ │ - delete this.redoStack │ │ │ │ + createFeatureXML: function(feature) { │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + var featureNode = this.createElementNS(this.rssns, "item"); │ │ │ │ + var titleNode = this.createElementNS(this.rssns, "title"); │ │ │ │ + titleNode.appendChild(this.createTextNode(feature.attributes.title ? feature.attributes.title : "")); │ │ │ │ + var descNode = this.createElementNS(this.rssns, "description"); │ │ │ │ + descNode.appendChild(this.createTextNode(feature.attributes.description ? feature.attributes.description : "")); │ │ │ │ + featureNode.appendChild(titleNode); │ │ │ │ + featureNode.appendChild(descNode); │ │ │ │ + if (feature.attributes.link) { │ │ │ │ + var linkNode = this.createElementNS(this.rssns, "link"); │ │ │ │ + linkNode.appendChild(this.createTextNode(feature.attributes.link)); │ │ │ │ + featureNode.appendChild(linkNode) │ │ │ │ + } │ │ │ │ + for (var attr in feature.attributes) { │ │ │ │ + if (attr == "link" || attr == "title" || attr == "description") { │ │ │ │ + continue │ │ │ │ + } │ │ │ │ + var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ + var nodename = attr; │ │ │ │ + if (attr.search(":") != -1) { │ │ │ │ + nodename = attr.split(":")[1] │ │ │ │ + } │ │ │ │ + var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ + attrContainer.appendChild(attrText); │ │ │ │ + featureNode.appendChild(attrContainer) │ │ │ │ + } │ │ │ │ + featureNode.appendChild(geometryNode); │ │ │ │ + return featureNode │ │ │ │ }, │ │ │ │ - insertDeltaXY: function(dx, dy) { │ │ │ │ - var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ - var p0 = this.line.geometry.components[previousIndex]; │ │ │ │ - if (p0 && !isNaN(p0.x) && !isNaN(p0.y)) { │ │ │ │ - this.insertXY(p0.x + dx, p0.y + dy) │ │ │ │ + buildGeometryNode: function(geometry) { │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + geometry.transform(this.internalProjection, this.externalProjection) │ │ │ │ + } │ │ │ │ + var node; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") { │ │ │ │ + node = this.createElementNS(this.georssns, "georss:polygon"); │ │ │ │ + node.appendChild(this.buildCoordinatesNode(geometry.components[0])) │ │ │ │ + } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") { │ │ │ │ + node = this.createElementNS(this.georssns, "georss:line"); │ │ │ │ + node.appendChild(this.buildCoordinatesNode(geometry)) │ │ │ │ + } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + node = this.createElementNS(this.georssns, "georss:point"); │ │ │ │ + node.appendChild(this.buildCoordinatesNode(geometry)) │ │ │ │ + } else { │ │ │ │ + throw "Couldn't parse " + geometry.CLASS_NAME │ │ │ │ } │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - insertDirectionLength: function(direction, length) { │ │ │ │ - direction *= Math.PI / 180; │ │ │ │ - var dx = length * Math.cos(direction); │ │ │ │ - var dy = length * Math.sin(direction); │ │ │ │ - this.insertDeltaXY(dx, dy) │ │ │ │ + buildCoordinatesNode: function(geometry) { │ │ │ │ + var points = null; │ │ │ │ + if (geometry.components) { │ │ │ │ + points = geometry.components │ │ │ │ + } │ │ │ │ + var path; │ │ │ │ + if (points) { │ │ │ │ + var numPoints = points.length; │ │ │ │ + var parts = new Array(numPoints); │ │ │ │ + for (var i = 0; i < numPoints; i++) { │ │ │ │ + parts[i] = points[i].y + " " + points[i].x │ │ │ │ + } │ │ │ │ + path = parts.join(" ") │ │ │ │ + } else { │ │ │ │ + path = geometry.y + " " + geometry.x │ │ │ │ + } │ │ │ │ + return this.createTextNode(path) │ │ │ │ }, │ │ │ │ - insertDeflectionLength: function(deflection, length) { │ │ │ │ - var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ - if (previousIndex > 0) { │ │ │ │ - var p1 = this.line.geometry.components[previousIndex]; │ │ │ │ - var p0 = this.line.geometry.components[previousIndex - 1]; │ │ │ │ - var theta = Math.atan2(p1.y - p0.y, p1.x - p0.x); │ │ │ │ - this.insertDirectionLength(theta * 180 / Math.PI + deflection, length) │ │ │ │ + CLASS_NAME: "OpenLayers.Format.GeoRSS" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.1.1", │ │ │ │ + profile: null, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.CSWGetDomain = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, OpenLayers.Format.CSWGetDomain.DEFAULTS); │ │ │ │ + var cls = OpenLayers.Format.CSWGetDomain["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported CSWGetDomain version: " + options.version │ │ │ │ + } │ │ │ │ + return new cls(options) │ │ │ │ +}; │ │ │ │ +OpenLayers.Format.CSWGetDomain.DEFAULTS = { │ │ │ │ + version: "2.0.2" │ │ │ │ +}; │ │ │ │ +OpenLayers.Format.Context = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + layerOptions: null, │ │ │ │ + layerParams: null, │ │ │ │ + read: function(data, options) { │ │ │ │ + var context = OpenLayers.Format.XML.VersionedOGC.prototype.read.apply(this, arguments); │ │ │ │ + var map; │ │ │ │ + if (options && options.map) { │ │ │ │ + this.context = context; │ │ │ │ + if (options.map instanceof OpenLayers.Map) { │ │ │ │ + map = this.mergeContextToMap(context, options.map) │ │ │ │ + } else { │ │ │ │ + var mapOptions = options.map; │ │ │ │ + if (OpenLayers.Util.isElement(mapOptions) || typeof mapOptions == "string") { │ │ │ │ + mapOptions = { │ │ │ │ + div: mapOptions │ │ │ │ + } │ │ │ │ + } │ │ │ │ + map = this.contextToMap(context, mapOptions) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + map = context │ │ │ │ } │ │ │ │ + return map │ │ │ │ }, │ │ │ │ - getCurrentPointIndex: function() { │ │ │ │ - return this.line.geometry.components.length - 1 │ │ │ │ + getLayerFromContext: function(layerContext) { │ │ │ │ + var i, len; │ │ │ │ + var options = { │ │ │ │ + queryable: layerContext.queryable, │ │ │ │ + visibility: layerContext.visibility, │ │ │ │ + maxExtent: layerContext.maxExtent, │ │ │ │ + metadata: OpenLayers.Util.applyDefaults(layerContext.metadata, { │ │ │ │ + styles: layerContext.styles, │ │ │ │ + formats: layerContext.formats, │ │ │ │ + abstract: layerContext["abstract"], │ │ │ │ + dataURL: layerContext.dataURL │ │ │ │ + }), │ │ │ │ + numZoomLevels: layerContext.numZoomLevels, │ │ │ │ + units: layerContext.units, │ │ │ │ + isBaseLayer: layerContext.isBaseLayer, │ │ │ │ + opacity: layerContext.opacity, │ │ │ │ + displayInLayerSwitcher: layerContext.displayInLayerSwitcher, │ │ │ │ + singleTile: layerContext.singleTile, │ │ │ │ + tileSize: layerContext.tileSize ? new OpenLayers.Size(layerContext.tileSize.width, layerContext.tileSize.height) : undefined, │ │ │ │ + minScale: layerContext.minScale || layerContext.maxScaleDenominator, │ │ │ │ + maxScale: layerContext.maxScale || layerContext.minScaleDenominator, │ │ │ │ + srs: layerContext.srs, │ │ │ │ + dimensions: layerContext.dimensions, │ │ │ │ + metadataURL: layerContext.metadataURL │ │ │ │ + }; │ │ │ │ + if (this.layerOptions) { │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.layerOptions) │ │ │ │ + } │ │ │ │ + var params = { │ │ │ │ + layers: layerContext.name, │ │ │ │ + transparent: layerContext.transparent, │ │ │ │ + version: layerContext.version │ │ │ │ + }; │ │ │ │ + if (layerContext.formats && layerContext.formats.length > 0) { │ │ │ │ + params.format = layerContext.formats[0].value; │ │ │ │ + for (i = 0, len = layerContext.formats.length; i < len; i++) { │ │ │ │ + var format = layerContext.formats[i]; │ │ │ │ + if (format.current == true) { │ │ │ │ + params.format = format.value; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (layerContext.styles && layerContext.styles.length > 0) { │ │ │ │ + for (i = 0, len = layerContext.styles.length; i < len; i++) { │ │ │ │ + var style = layerContext.styles[i]; │ │ │ │ + if (style.current == true) { │ │ │ │ + if (style.href) { │ │ │ │ + params.sld = style.href │ │ │ │ + } else if (style.body) { │ │ │ │ + params.sld_body = style.body │ │ │ │ + } else { │ │ │ │ + params.styles = style.name │ │ │ │ + } │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.layerParams) { │ │ │ │ + OpenLayers.Util.applyDefaults(params, this.layerParams) │ │ │ │ + } │ │ │ │ + var layer = null; │ │ │ │ + var service = layerContext.service; │ │ │ │ + if (service == OpenLayers.Format.Context.serviceTypes.WFS) { │ │ │ │ + options.strategies = [new OpenLayers.Strategy.BBOX]; │ │ │ │ + options.protocol = new OpenLayers.Protocol.WFS({ │ │ │ │ + url: layerContext.url, │ │ │ │ + featurePrefix: layerContext.name.split(":")[0], │ │ │ │ + featureType: layerContext.name.split(":").pop() │ │ │ │ + }); │ │ │ │ + layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options) │ │ │ │ + } else if (service == OpenLayers.Format.Context.serviceTypes.KML) { │ │ │ │ + options.strategies = [new OpenLayers.Strategy.Fixed]; │ │ │ │ + options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ + url: layerContext.url, │ │ │ │ + format: new OpenLayers.Format.KML │ │ │ │ + }); │ │ │ │ + layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options) │ │ │ │ + } else if (service == OpenLayers.Format.Context.serviceTypes.GML) { │ │ │ │ + options.strategies = [new OpenLayers.Strategy.Fixed]; │ │ │ │ + options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ + url: layerContext.url, │ │ │ │ + format: new OpenLayers.Format.GML │ │ │ │ + }); │ │ │ │ + layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options) │ │ │ │ + } else if (layerContext.features) { │ │ │ │ + layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options); │ │ │ │ + layer.addFeatures(layerContext.features) │ │ │ │ + } else if (layerContext.categoryLayer !== true) { │ │ │ │ + layer = new OpenLayers.Layer.WMS(layerContext.title || layerContext.name, layerContext.url, params, options) │ │ │ │ + } │ │ │ │ + return layer │ │ │ │ }, │ │ │ │ - undo: function() { │ │ │ │ - var geometry = this.line.geometry; │ │ │ │ - var components = geometry.components; │ │ │ │ - var index = this.getCurrentPointIndex() - 1; │ │ │ │ - var target = components[index]; │ │ │ │ - var undone = geometry.removeComponent(target); │ │ │ │ - if (undone) { │ │ │ │ - if (this.touch && index > 0) { │ │ │ │ - components = geometry.components; │ │ │ │ - var lastpt = components[index - 1]; │ │ │ │ - var curptidx = this.getCurrentPointIndex(); │ │ │ │ - var curpt = components[curptidx]; │ │ │ │ - curpt.x = lastpt.x; │ │ │ │ - curpt.y = lastpt.y │ │ │ │ + getLayersFromContext: function(layersContext) { │ │ │ │ + var layers = []; │ │ │ │ + for (var i = 0, len = layersContext.length; i < len; i++) { │ │ │ │ + var layer = this.getLayerFromContext(layersContext[i]); │ │ │ │ + if (layer !== null) { │ │ │ │ + layers.push(layer) │ │ │ │ } │ │ │ │ - if (!this.redoStack) { │ │ │ │ - this.redoStack = [] │ │ │ │ + } │ │ │ │ + return layers │ │ │ │ + }, │ │ │ │ + contextToMap: function(context, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + maxExtent: context.maxExtent, │ │ │ │ + projection: context.projection, │ │ │ │ + units: context.units │ │ │ │ + }, options); │ │ │ │ + if (options.maxExtent) { │ │ │ │ + options.maxResolution = options.maxExtent.getWidth() / OpenLayers.Map.TILE_WIDTH │ │ │ │ + } │ │ │ │ + var metadata = { │ │ │ │ + contactInformation: context.contactInformation, │ │ │ │ + abstract: context["abstract"], │ │ │ │ + keywords: context.keywords, │ │ │ │ + logo: context.logo, │ │ │ │ + descriptionURL: context.descriptionURL │ │ │ │ + }; │ │ │ │ + options.metadata = metadata; │ │ │ │ + var map = new OpenLayers.Map(options); │ │ │ │ + map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ + map.setCenter(context.bounds.getCenterLonLat(), map.getZoomForExtent(context.bounds, true)); │ │ │ │ + return map │ │ │ │ + }, │ │ │ │ + mergeContextToMap: function(context, map) { │ │ │ │ + map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ + return map │ │ │ │ + }, │ │ │ │ + write: function(obj, options) { │ │ │ │ + obj = this.toContext(obj); │ │ │ │ + return OpenLayers.Format.XML.VersionedOGC.prototype.write.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.Context" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.Context.serviceTypes = { │ │ │ │ + WMS: "urn:ogc:serviceType:WMS", │ │ │ │ + WFS: "urn:ogc:serviceType:WFS", │ │ │ │ + WCS: "urn:ogc:serviceType:WCS", │ │ │ │ + GML: "urn:ogc:serviceType:GML", │ │ │ │ + SLD: "urn:ogc:serviceType:SLD", │ │ │ │ + FES: "urn:ogc:serviceType:FES", │ │ │ │ + KML: "urn:ogc:serviceType:KML" │ │ │ │ +}; │ │ │ │ +OpenLayers.Format.OWSContext = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ + defaultVersion: "0.3.1", │ │ │ │ + getVersion: function(root, options) { │ │ │ │ + var version = OpenLayers.Format.XML.VersionedOGC.prototype.getVersion.apply(this, arguments); │ │ │ │ + if (version === "0.3.0") { │ │ │ │ + version = this.defaultVersion │ │ │ │ + } │ │ │ │ + return version │ │ │ │ + }, │ │ │ │ + toContext: function(obj) { │ │ │ │ + var context = {}; │ │ │ │ + if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ + context.bounds = obj.getExtent(); │ │ │ │ + context.maxExtent = obj.maxExtent; │ │ │ │ + context.projection = obj.projection; │ │ │ │ + context.size = obj.getSize(); │ │ │ │ + context.layers = obj.layers │ │ │ │ + } │ │ │ │ + return context │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.OWSContext" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + defaultDesc: "No description available", │ │ │ │ + extractWaypoints: true, │ │ │ │ + extractTracks: true, │ │ │ │ + extractRoutes: true, │ │ │ │ + extractAttributes: true, │ │ │ │ + namespaces: { │ │ │ │ + gpx: "http://www.topografix.com/GPX/1/1", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + schemaLocation: "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd", │ │ │ │ + creator: "OpenLayers", │ │ │ │ + initialize: function(options) { │ │ │ │ + this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + } │ │ │ │ + var features = []; │ │ │ │ + if (this.extractTracks) { │ │ │ │ + var tracks = doc.getElementsByTagName("trk"); │ │ │ │ + for (var i = 0, len = tracks.length; i < len; i++) { │ │ │ │ + var attrs = {}; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attrs = this.parseAttributes(tracks[i]) │ │ │ │ + } │ │ │ │ + var segs = this.getElementsByTagNameNS(tracks[i], tracks[i].namespaceURI, "trkseg"); │ │ │ │ + for (var j = 0, seglen = segs.length; j < seglen; j++) { │ │ │ │ + var track = this.extractSegment(segs[j], "trkpt"); │ │ │ │ + features.push(new OpenLayers.Feature.Vector(track, attrs)) │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.redoStack.push(target); │ │ │ │ - this.drawFeature() │ │ │ │ } │ │ │ │ - return undone │ │ │ │ + if (this.extractRoutes) { │ │ │ │ + var routes = doc.getElementsByTagName("rte"); │ │ │ │ + for (var k = 0, klen = routes.length; k < klen; k++) { │ │ │ │ + var attrs = {}; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attrs = this.parseAttributes(routes[k]) │ │ │ │ + } │ │ │ │ + var route = this.extractSegment(routes[k], "rtept"); │ │ │ │ + features.push(new OpenLayers.Feature.Vector(route, attrs)) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.extractWaypoints) { │ │ │ │ + var waypoints = doc.getElementsByTagName("wpt"); │ │ │ │ + for (var l = 0, len = waypoints.length; l < len; l++) { │ │ │ │ + var attrs = {}; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attrs = this.parseAttributes(waypoints[l]) │ │ │ │ + } │ │ │ │ + var wpt = new OpenLayers.Geometry.Point(waypoints[l].getAttribute("lon"), waypoints[l].getAttribute("lat")); │ │ │ │ + features.push(new OpenLayers.Feature.Vector(wpt, attrs)) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + for (var g = 0, featLength = features.length; g < featLength; g++) { │ │ │ │ + features[g].geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return features │ │ │ │ }, │ │ │ │ - redo: function() { │ │ │ │ - var target = this.redoStack && this.redoStack.pop(); │ │ │ │ - if (target) { │ │ │ │ - this.line.geometry.addComponent(target, this.getCurrentPointIndex()); │ │ │ │ - this.drawFeature() │ │ │ │ + extractSegment: function(segment, segmentType) { │ │ │ │ + var points = this.getElementsByTagNameNS(segment, segment.namespaceURI, segmentType); │ │ │ │ + var point_features = []; │ │ │ │ + for (var i = 0, len = points.length; i < len; i++) { │ │ │ │ + point_features.push(new OpenLayers.Geometry.Point(points[i].getAttribute("lon"), points[i].getAttribute("lat"))) │ │ │ │ } │ │ │ │ - return !!target │ │ │ │ + return new OpenLayers.Geometry.LineString(point_features) │ │ │ │ }, │ │ │ │ - freehandMode: function(evt) { │ │ │ │ - return this.freehandToggle && evt[this.freehandToggle] ? !this.freehand : this.freehand │ │ │ │ + parseAttributes: function(node) { │ │ │ │ + var attributes = {}; │ │ │ │ + var attrNode = node.firstChild, │ │ │ │ + value, name; │ │ │ │ + while (attrNode) { │ │ │ │ + if (attrNode.nodeType == 1 && attrNode.firstChild) { │ │ │ │ + value = attrNode.firstChild; │ │ │ │ + if (value.nodeType == 3 || value.nodeType == 4) { │ │ │ │ + name = attrNode.prefix ? attrNode.nodeName.split(":")[1] : attrNode.nodeName; │ │ │ │ + if (name != "trkseg" && name != "rtept") { │ │ │ │ + attributes[name] = value.nodeValue │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + attrNode = attrNode.nextSibling │ │ │ │ + } │ │ │ │ + return attributes │ │ │ │ }, │ │ │ │ - modifyFeature: function(pixel, drawing) { │ │ │ │ - if (!this.line) { │ │ │ │ - this.createFeature(pixel) │ │ │ │ + write: function(features, metadata) { │ │ │ │ + features = OpenLayers.Util.isArray(features) ? features : [features]; │ │ │ │ + var gpx = this.createElementNS(this.namespaces.gpx, "gpx"); │ │ │ │ + gpx.setAttribute("version", "1.1"); │ │ │ │ + gpx.setAttribute("creator", this.creator); │ │ │ │ + this.setAttributes(gpx, { │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ + }); │ │ │ │ + if (metadata && typeof metadata == "object") { │ │ │ │ + gpx.appendChild(this.buildMetadataNode(metadata)) │ │ │ │ } │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - this.point.geometry.x = lonlat.lon; │ │ │ │ - this.point.geometry.y = lonlat.lat; │ │ │ │ - this.callback("modify", [this.point.geometry, this.getSketch(), drawing]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.drawFeature() │ │ │ │ + for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ + gpx.appendChild(this.buildFeatureNode(features[i])) │ │ │ │ + } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [gpx]) │ │ │ │ }, │ │ │ │ - drawFeature: function() { │ │ │ │ - this.layer.drawFeature(this.line, this.style); │ │ │ │ - this.layer.drawFeature(this.point, this.style) │ │ │ │ + buildMetadataNode: function(metadata) { │ │ │ │ + var types = ["name", "desc", "author"], │ │ │ │ + node = this.createElementNS(this.namespaces.gpx, "metadata"); │ │ │ │ + for (var i = 0; i < types.length; i++) { │ │ │ │ + var type = types[i]; │ │ │ │ + if (metadata[type]) { │ │ │ │ + var n = this.createElementNS(this.namespaces.gpx, type); │ │ │ │ + n.appendChild(this.createTextNode(metadata[type])); │ │ │ │ + node.appendChild(n) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - getSketch: function() { │ │ │ │ - return this.line │ │ │ │ + buildFeatureNode: function(feature) { │ │ │ │ + var geometry = feature.geometry; │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.internalProjection, this.externalProjection) │ │ │ │ + } │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + var wpt = this.buildWptNode(geometry); │ │ │ │ + this.appendAttributesNode(wpt, feature); │ │ │ │ + return wpt │ │ │ │ + } else { │ │ │ │ + var trkNode = this.createElementNS(this.namespaces.gpx, "trk"); │ │ │ │ + this.appendAttributesNode(trkNode, feature); │ │ │ │ + var trkSegNodes = this.buildTrkSegNode(geometry); │ │ │ │ + trkSegNodes = OpenLayers.Util.isArray(trkSegNodes) ? trkSegNodes : [trkSegNodes]; │ │ │ │ + for (var i = 0, len = trkSegNodes.length; i < len; i++) { │ │ │ │ + trkNode.appendChild(trkSegNodes[i]) │ │ │ │ + } │ │ │ │ + return trkNode │ │ │ │ + } │ │ │ │ }, │ │ │ │ - getGeometry: function() { │ │ │ │ - var geometry = this.line && this.line.geometry; │ │ │ │ - if (geometry && this.multi) { │ │ │ │ - geometry = new OpenLayers.Geometry.MultiLineString([geometry]) │ │ │ │ + buildTrkSegNode: function(geometry) { │ │ │ │ + var node, i, len, point, nodes; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" || geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ + node = this.createElementNS(this.namespaces.gpx, "trkseg"); │ │ │ │ + for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ + point = geometry.components[i]; │ │ │ │ + node.appendChild(this.buildTrkPtNode(point)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + } else { │ │ │ │ + nodes = []; │ │ │ │ + for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ + nodes.push(this.buildTrkSegNode(geometry.components[i])) │ │ │ │ + } │ │ │ │ + return nodes │ │ │ │ } │ │ │ │ - return geometry │ │ │ │ }, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - if (this.timerId && this.passesTolerance(this.lastTouchPx, evt.xy, this.doubleTouchTolerance)) { │ │ │ │ - this.finishGeometry(); │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - return false │ │ │ │ + buildTrkPtNode: function(point) { │ │ │ │ + var node = this.createElementNS(this.namespaces.gpx, "trkpt"); │ │ │ │ + node.setAttribute("lon", point.x); │ │ │ │ + node.setAttribute("lat", point.y); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + buildWptNode: function(geometry) { │ │ │ │ + var node = this.createElementNS(this.namespaces.gpx, "wpt"); │ │ │ │ + node.setAttribute("lon", geometry.x); │ │ │ │ + node.setAttribute("lat", geometry.y); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + appendAttributesNode: function(node, feature) { │ │ │ │ + var name = this.createElementNS(this.namespaces.gpx, "name"); │ │ │ │ + name.appendChild(this.createTextNode(feature.attributes.name || feature.id)); │ │ │ │ + node.appendChild(name); │ │ │ │ + var desc = this.createElementNS(this.namespaces.gpx, "desc"); │ │ │ │ + desc.appendChild(this.createTextNode(feature.attributes.description || this.defaultDesc)); │ │ │ │ + node.appendChild(desc) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.GPX" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMC = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ + layerToContext: function(layer) { │ │ │ │ + var parser = this.getParser(); │ │ │ │ + var layerContext = { │ │ │ │ + queryable: layer.queryable, │ │ │ │ + visibility: layer.visibility, │ │ │ │ + name: layer.params["LAYERS"], │ │ │ │ + title: layer.name, │ │ │ │ + abstract: layer.metadata["abstract"], │ │ │ │ + dataURL: layer.metadata.dataURL, │ │ │ │ + metadataURL: layer.metadataURL, │ │ │ │ + server: { │ │ │ │ + version: layer.params["VERSION"], │ │ │ │ + url: layer.url │ │ │ │ + }, │ │ │ │ + maxExtent: layer.maxExtent, │ │ │ │ + transparent: layer.params["TRANSPARENT"], │ │ │ │ + numZoomLevels: layer.numZoomLevels, │ │ │ │ + units: layer.units, │ │ │ │ + isBaseLayer: layer.isBaseLayer, │ │ │ │ + opacity: layer.opacity == 1 ? undefined : layer.opacity, │ │ │ │ + displayInLayerSwitcher: layer.displayInLayerSwitcher, │ │ │ │ + singleTile: layer.singleTile, │ │ │ │ + tileSize: layer.singleTile || !layer.tileSize ? undefined : { │ │ │ │ + width: layer.tileSize.w, │ │ │ │ + height: layer.tileSize.h │ │ │ │ + }, │ │ │ │ + minScale: layer.options.resolutions || layer.options.scales || layer.options.maxResolution || layer.options.minScale ? layer.minScale : undefined, │ │ │ │ + maxScale: layer.options.resolutions || layer.options.scales || layer.options.minResolution || layer.options.maxScale ? layer.maxScale : undefined, │ │ │ │ + formats: [], │ │ │ │ + styles: [], │ │ │ │ + srs: layer.srs, │ │ │ │ + dimensions: layer.dimensions │ │ │ │ + }; │ │ │ │ + if (layer.metadata.servertitle) { │ │ │ │ + layerContext.server.title = layer.metadata.servertitle │ │ │ │ + } │ │ │ │ + if (layer.metadata.formats && layer.metadata.formats.length > 0) { │ │ │ │ + for (var i = 0, len = layer.metadata.formats.length; i < len; i++) { │ │ │ │ + var format = layer.metadata.formats[i]; │ │ │ │ + layerContext.formats.push({ │ │ │ │ + value: format.value, │ │ │ │ + current: format.value == layer.params["FORMAT"] │ │ │ │ + }) │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - if (this.timerId) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null │ │ │ │ + layerContext.formats.push({ │ │ │ │ + value: layer.params["FORMAT"], │ │ │ │ + current: true │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ + for (var i = 0, len = layer.metadata.styles.length; i < len; i++) { │ │ │ │ + var style = layer.metadata.styles[i]; │ │ │ │ + if (style.href == layer.params["SLD"] || style.body == layer.params["SLD_BODY"] || style.name == layer.params["STYLES"]) { │ │ │ │ + style.current = true │ │ │ │ + } else { │ │ │ │ + style.current = false │ │ │ │ + } │ │ │ │ + layerContext.styles.push(style) │ │ │ │ } │ │ │ │ - this.timerId = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ - this.timerId = null │ │ │ │ - }, this), 300); │ │ │ │ - return OpenLayers.Handler.Point.prototype.touchstart.call(this, evt) │ │ │ │ + } else { │ │ │ │ + layerContext.styles.push({ │ │ │ │ + href: layer.params["SLD"], │ │ │ │ + body: layer.params["SLD_BODY"], │ │ │ │ + name: layer.params["STYLES"] || parser.defaultStyleName, │ │ │ │ + title: parser.defaultStyleTitle, │ │ │ │ + current: true │ │ │ │ + }) │ │ │ │ } │ │ │ │ + return layerContext │ │ │ │ }, │ │ │ │ - down: function(evt) { │ │ │ │ - var stopDown = this.stopDown; │ │ │ │ - if (this.freehandMode(evt)) { │ │ │ │ - stopDown = true; │ │ │ │ - if (this.touch) { │ │ │ │ - this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ + toContext: function(obj) { │ │ │ │ + var context = {}; │ │ │ │ + var layers = obj.layers; │ │ │ │ + if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ + var metadata = obj.metadata || {}; │ │ │ │ + context.size = obj.getSize(); │ │ │ │ + context.bounds = obj.getExtent(); │ │ │ │ + context.projection = obj.projection; │ │ │ │ + context.title = obj.title; │ │ │ │ + context.keywords = metadata.keywords; │ │ │ │ + context["abstract"] = metadata["abstract"]; │ │ │ │ + context.logo = metadata.logo; │ │ │ │ + context.descriptionURL = metadata.descriptionURL; │ │ │ │ + context.contactInformation = metadata.contactInformation; │ │ │ │ + context.maxExtent = obj.maxExtent │ │ │ │ + } else { │ │ │ │ + OpenLayers.Util.applyDefaults(context, obj); │ │ │ │ + if (context.layers != undefined) { │ │ │ │ + delete context.layers │ │ │ │ } │ │ │ │ } │ │ │ │ - if (!this.touch && (!this.lastDown || !this.passesTolerance(this.lastDown, evt.xy, this.pixelTolerance))) { │ │ │ │ - this.modifyFeature(evt.xy, !!this.lastUp) │ │ │ │ + if (context.layersContext == undefined) { │ │ │ │ + context.layersContext = [] │ │ │ │ } │ │ │ │ - this.mouseDown = true; │ │ │ │ - this.lastDown = evt.xy; │ │ │ │ - this.stoppedDown = stopDown; │ │ │ │ - return !stopDown │ │ │ │ + if (layers != undefined && OpenLayers.Util.isArray(layers)) { │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ + context.layersContext.push(this.layerToContext(layer)) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return context │ │ │ │ }, │ │ │ │ - move: function(evt) { │ │ │ │ - if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ - if (this.persist) { │ │ │ │ - this.destroyPersistedFeature() │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSDescribeLayer = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.1.1", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WFS = OpenLayers.Class(OpenLayers.Format.GML, { │ │ │ │ + layer: null, │ │ │ │ + wfsns: "http://www.opengis.net/wfs", │ │ │ │ + ogcns: "http://www.opengis.net/ogc", │ │ │ │ + initialize: function(options, layer) { │ │ │ │ + OpenLayers.Format.GML.prototype.initialize.apply(this, [options]); │ │ │ │ + this.layer = layer; │ │ │ │ + if (this.layer.featureNS) { │ │ │ │ + this.featureNS = this.layer.featureNS │ │ │ │ + } │ │ │ │ + if (this.layer.options.geometry_column) { │ │ │ │ + this.geometryName = this.layer.options.geometry_column │ │ │ │ + } │ │ │ │ + if (this.layer.options.typename) { │ │ │ │ + this.featureName = this.layer.options.typename │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + write: function(features) { │ │ │ │ + var transaction = this.createElementNS(this.wfsns, "wfs:Transaction"); │ │ │ │ + transaction.setAttribute("version", "1.0.0"); │ │ │ │ + transaction.setAttribute("service", "WFS"); │ │ │ │ + for (var i = 0; i < features.length; i++) { │ │ │ │ + switch (features[i].state) { │ │ │ │ + case OpenLayers.State.INSERT: │ │ │ │ + transaction.appendChild(this.insert(features[i])); │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + transaction.appendChild(this.update(features[i])); │ │ │ │ + break; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + transaction.appendChild(this.remove(features[i])); │ │ │ │ + break │ │ │ │ } │ │ │ │ - if (this.maxVertices && this.line && this.line.geometry.components.length === this.maxVertices) { │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize() │ │ │ │ - } else { │ │ │ │ - this.addPoint(evt.xy) │ │ │ │ + } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [transaction]) │ │ │ │ + }, │ │ │ │ + createFeatureXML: function(feature) { │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + var geomContainer = this.createElementNS(this.featureNS, "feature:" + this.geometryName); │ │ │ │ + geomContainer.appendChild(geometryNode); │ │ │ │ + var featureContainer = this.createElementNS(this.featureNS, "feature:" + this.featureName); │ │ │ │ + featureContainer.appendChild(geomContainer); │ │ │ │ + for (var attr in feature.attributes) { │ │ │ │ + var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ + var nodename = attr; │ │ │ │ + if (attr.search(":") != -1) { │ │ │ │ + nodename = attr.split(":")[1] │ │ │ │ } │ │ │ │ + var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ + attrContainer.appendChild(attrText); │ │ │ │ + featureContainer.appendChild(attrContainer) │ │ │ │ + } │ │ │ │ + return featureContainer │ │ │ │ + }, │ │ │ │ + insert: function(feature) { │ │ │ │ + var insertNode = this.createElementNS(this.wfsns, "wfs:Insert"); │ │ │ │ + insertNode.appendChild(this.createFeatureXML(feature)); │ │ │ │ + return insertNode │ │ │ │ + }, │ │ │ │ + update: function(feature) { │ │ │ │ + if (!feature.fid) { │ │ │ │ + OpenLayers.Console.userError(OpenLayers.i18n("noFID")) │ │ │ │ + } │ │ │ │ + var updateNode = this.createElementNS(this.wfsns, "wfs:Update"); │ │ │ │ + updateNode.setAttribute("typeName", this.featurePrefix + ":" + this.featureName); │ │ │ │ + updateNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ + var propertyNode = this.createElementNS(this.wfsns, "wfs:Property"); │ │ │ │ + var nameNode = this.createElementNS(this.wfsns, "wfs:Name"); │ │ │ │ + var txtNode = this.createTextNode(this.geometryName); │ │ │ │ + nameNode.appendChild(txtNode); │ │ │ │ + propertyNode.appendChild(nameNode); │ │ │ │ + var valueNode = this.createElementNS(this.wfsns, "wfs:Value"); │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + if (feature.layer) { │ │ │ │ + geometryNode.setAttribute("srsName", feature.layer.projection.getCode()) │ │ │ │ + } │ │ │ │ + valueNode.appendChild(geometryNode); │ │ │ │ + propertyNode.appendChild(valueNode); │ │ │ │ + updateNode.appendChild(propertyNode); │ │ │ │ + for (var propName in feature.attributes) { │ │ │ │ + propertyNode = this.createElementNS(this.wfsns, "wfs:Property"); │ │ │ │ + nameNode = this.createElementNS(this.wfsns, "wfs:Name"); │ │ │ │ + nameNode.appendChild(this.createTextNode(propName)); │ │ │ │ + propertyNode.appendChild(nameNode); │ │ │ │ + valueNode = this.createElementNS(this.wfsns, "wfs:Value"); │ │ │ │ + valueNode.appendChild(this.createTextNode(feature.attributes[propName])); │ │ │ │ + propertyNode.appendChild(valueNode); │ │ │ │ + updateNode.appendChild(propertyNode) │ │ │ │ + } │ │ │ │ + var filterNode = this.createElementNS(this.ogcns, "ogc:Filter"); │ │ │ │ + var filterIdNode = this.createElementNS(this.ogcns, "ogc:FeatureId"); │ │ │ │ + filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ + filterNode.appendChild(filterIdNode); │ │ │ │ + updateNode.appendChild(filterNode); │ │ │ │ + return updateNode │ │ │ │ + }, │ │ │ │ + remove: function(feature) { │ │ │ │ + if (!feature.fid) { │ │ │ │ + OpenLayers.Console.userError(OpenLayers.i18n("noFID")); │ │ │ │ return false │ │ │ │ } │ │ │ │ - if (!this.touch && (!this.mouseDown || this.stoppedDown)) { │ │ │ │ - this.modifyFeature(evt.xy, !!this.lastUp) │ │ │ │ + var deleteNode = this.createElementNS(this.wfsns, "wfs:Delete"); │ │ │ │ + deleteNode.setAttribute("typeName", this.featurePrefix + ":" + this.featureName); │ │ │ │ + deleteNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ + var filterNode = this.createElementNS(this.ogcns, "ogc:Filter"); │ │ │ │ + var filterIdNode = this.createElementNS(this.ogcns, "ogc:FeatureId"); │ │ │ │ + filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ + filterNode.appendChild(filterIdNode); │ │ │ │ + deleteNode.appendChild(filterNode); │ │ │ │ + return deleteNode │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.layer = null │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFS" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.SOSGetFeatureOfInterest = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + VERSION: "1.0.0", │ │ │ │ + namespaces: { │ │ │ │ + sos: "http://www.opengis.net/sos/1.0", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosAll.xsd", │ │ │ │ + defaultPrefix: "sos", │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ + }, │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - return true │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var info = { │ │ │ │ + features: [] │ │ │ │ + }; │ │ │ │ + this.readNode(data, info); │ │ │ │ + var features = []; │ │ │ │ + for (var i = 0, len = info.features.length; i < len; i++) { │ │ │ │ + var container = info.features[i]; │ │ │ │ + if (this.internalProjection && this.externalProjection && container.components[0]) { │ │ │ │ + container.components[0].transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature.Vector(container.components[0], container.attributes); │ │ │ │ + features.push(feature) │ │ │ │ + } │ │ │ │ + return features │ │ │ │ }, │ │ │ │ - up: function(evt) { │ │ │ │ - if (this.mouseDown && (!this.lastUp || !this.lastUp.equals(evt.xy))) { │ │ │ │ - if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ - if (this.persist) { │ │ │ │ - this.destroyPersistedFeature() │ │ │ │ + readers: { │ │ │ │ + sa: { │ │ │ │ + SamplingPoint: function(node, obj) { │ │ │ │ + if (!obj.attributes) { │ │ │ │ + var feature = { │ │ │ │ + attributes: {} │ │ │ │ + }; │ │ │ │ + obj.features.push(feature); │ │ │ │ + obj = feature │ │ │ │ } │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize() │ │ │ │ - } else { │ │ │ │ - if (this.passesTolerance(this.lastDown, evt.xy, this.pixelTolerance)) { │ │ │ │ - if (this.touch) { │ │ │ │ - this.modifyFeature(evt.xy) │ │ │ │ - } │ │ │ │ - if (this.lastUp == null && this.persist) { │ │ │ │ - this.destroyPersistedFeature() │ │ │ │ + obj.attributes.id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + position: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + gml: OpenLayers.Util.applyDefaults({ │ │ │ │ + FeatureCollection: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + featureMember: function(node, obj) { │ │ │ │ + var feature = { │ │ │ │ + attributes: {} │ │ │ │ + }; │ │ │ │ + obj.features.push(feature); │ │ │ │ + this.readChildNodes(node, feature) │ │ │ │ + }, │ │ │ │ + name: function(node, obj) { │ │ │ │ + obj.attributes.name = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + pos: function(node, obj) { │ │ │ │ + if (!this.externalProjection) { │ │ │ │ + this.externalProjection = new OpenLayers.Projection(node.getAttribute("srsName")) │ │ │ │ + } │ │ │ │ + OpenLayers.Format.GML.v3.prototype.readers.gml.pos.apply(this, [node, obj]) │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.GML.v3.prototype.readers.gml) │ │ │ │ + }, │ │ │ │ + writers: { │ │ │ │ + sos: { │ │ │ │ + GetFeatureOfInterest: function(options) { │ │ │ │ + var node = this.createElementNSPlus("GetFeatureOfInterest", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + service: "SOS", │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ } │ │ │ │ - this.addPoint(evt.xy); │ │ │ │ - this.lastUp = evt.xy; │ │ │ │ - if (this.line.geometry.components.length === this.maxVertices + 1) { │ │ │ │ - this.finishGeometry() │ │ │ │ + }); │ │ │ │ + for (var i = 0, len = options.fois.length; i < len; i++) { │ │ │ │ + this.writeNode("FeatureOfInterestId", { │ │ │ │ + foi: options.fois[i] │ │ │ │ + }, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + FeatureOfInterestId: function(options) { │ │ │ │ + var node = this.createElementNSPlus("FeatureOfInterestId", { │ │ │ │ + value: options.foi │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSGetFeatureOfInterest" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.OSM = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + checkTags: false, │ │ │ │ + interestingTagsExclude: null, │ │ │ │ + areaTags: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + var layer_defaults = { │ │ │ │ + interestingTagsExclude: ["source", "source_ref", "source:ref", "history", "attribution", "created_by"], │ │ │ │ + areaTags: ["area", "building", "leisure", "tourism", "ruins", "historic", "landuse", "military", "natural", "sport"] │ │ │ │ + }; │ │ │ │ + layer_defaults = OpenLayers.Util.extend(layer_defaults, options); │ │ │ │ + var interesting = {}; │ │ │ │ + for (var i = 0; i < layer_defaults.interestingTagsExclude.length; i++) { │ │ │ │ + interesting[layer_defaults.interestingTagsExclude[i]] = true │ │ │ │ + } │ │ │ │ + layer_defaults.interestingTagsExclude = interesting; │ │ │ │ + var area = {}; │ │ │ │ + for (var i = 0; i < layer_defaults.areaTags.length; i++) { │ │ │ │ + area[layer_defaults.areaTags[i]] = true │ │ │ │ + } │ │ │ │ + layer_defaults.areaTags = area; │ │ │ │ + this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [layer_defaults]) │ │ │ │ + }, │ │ │ │ + read: function(doc) { │ │ │ │ + if (typeof doc == "string") { │ │ │ │ + doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + } │ │ │ │ + var nodes = this.getNodes(doc); │ │ │ │ + var ways = this.getWays(doc); │ │ │ │ + var feat_list = new Array(ways.length); │ │ │ │ + for (var i = 0; i < ways.length; i++) { │ │ │ │ + var point_list = new Array(ways[i].nodes.length); │ │ │ │ + var poly = this.isWayArea(ways[i]) ? 1 : 0; │ │ │ │ + for (var j = 0; j < ways[i].nodes.length; j++) { │ │ │ │ + var node = nodes[ways[i].nodes[j]]; │ │ │ │ + var point = new OpenLayers.Geometry.Point(node.lon, node.lat); │ │ │ │ + point.osm_id = parseInt(ways[i].nodes[j]); │ │ │ │ + point_list[j] = point; │ │ │ │ + node.used = true │ │ │ │ + } │ │ │ │ + var geometry = null; │ │ │ │ + if (poly) { │ │ │ │ + geometry = new OpenLayers.Geometry.Polygon(new OpenLayers.Geometry.LinearRing(point_list)) │ │ │ │ + } else { │ │ │ │ + geometry = new OpenLayers.Geometry.LineString(point_list) │ │ │ │ + } │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + var feat = new OpenLayers.Feature.Vector(geometry, ways[i].tags); │ │ │ │ + feat.osm_id = parseInt(ways[i].id); │ │ │ │ + feat.fid = "way." + feat.osm_id; │ │ │ │ + feat_list[i] = feat │ │ │ │ + } │ │ │ │ + for (var node_id in nodes) { │ │ │ │ + var node = nodes[node_id]; │ │ │ │ + if (!node.used || this.checkTags) { │ │ │ │ + var tags = null; │ │ │ │ + if (this.checkTags) { │ │ │ │ + var result = this.getTags(node.node, true); │ │ │ │ + if (node.used && !result[1]) { │ │ │ │ + continue │ │ │ │ } │ │ │ │ + tags = result[0] │ │ │ │ + } else { │ │ │ │ + tags = this.getTags(node.node) │ │ │ │ + } │ │ │ │ + var feat = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(node["lon"], node["lat"]), tags); │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + feat.geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ } │ │ │ │ + feat.osm_id = parseInt(node_id); │ │ │ │ + feat.fid = "node." + feat.osm_id; │ │ │ │ + feat_list.push(feat) │ │ │ │ } │ │ │ │ + node.node = null │ │ │ │ } │ │ │ │ - this.stoppedDown = this.stopDown; │ │ │ │ - this.mouseDown = false; │ │ │ │ - return !this.stopUp │ │ │ │ + return feat_list │ │ │ │ }, │ │ │ │ - finishGeometry: function() { │ │ │ │ - var index = this.line.geometry.components.length - 1; │ │ │ │ - this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize() │ │ │ │ + getNodes: function(doc) { │ │ │ │ + var node_list = doc.getElementsByTagName("node"); │ │ │ │ + var nodes = {}; │ │ │ │ + for (var i = 0; i < node_list.length; i++) { │ │ │ │ + var node = node_list[i]; │ │ │ │ + var id = node.getAttribute("id"); │ │ │ │ + nodes[id] = { │ │ │ │ + lat: node.getAttribute("lat"), │ │ │ │ + lon: node.getAttribute("lon"), │ │ │ │ + node: node │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return nodes │ │ │ │ }, │ │ │ │ - dblclick: function(evt) { │ │ │ │ - if (!this.freehandMode(evt)) { │ │ │ │ - this.finishGeometry() │ │ │ │ + getWays: function(doc) { │ │ │ │ + var way_list = doc.getElementsByTagName("way"); │ │ │ │ + var return_ways = []; │ │ │ │ + for (var i = 0; i < way_list.length; i++) { │ │ │ │ + var way = way_list[i]; │ │ │ │ + var way_object = { │ │ │ │ + id: way.getAttribute("id") │ │ │ │ + }; │ │ │ │ + way_object.tags = this.getTags(way); │ │ │ │ + var node_list = way.getElementsByTagName("nd"); │ │ │ │ + way_object.nodes = new Array(node_list.length); │ │ │ │ + for (var j = 0; j < node_list.length; j++) { │ │ │ │ + way_object.nodes[j] = node_list[j].getAttribute("ref") │ │ │ │ + } │ │ │ │ + return_ways.push(way_object) │ │ │ │ } │ │ │ │ - return false │ │ │ │ + return return_ways │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Path" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.Polygon = OpenLayers.Class(OpenLayers.Handler.Path, { │ │ │ │ - holeModifier: null, │ │ │ │ - drawingHole: false, │ │ │ │ - polygon: null, │ │ │ │ - createFeature: function(pixel) { │ │ │ │ - var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ - this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - this.line = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LinearRing([this.point.geometry])); │ │ │ │ - this.polygon = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Polygon([this.line.geometry])); │ │ │ │ - this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ - this.point.geometry.clearBounds(); │ │ │ │ - this.layer.addFeatures([this.polygon, this.point], { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ + getTags: function(dom_node, interesting_tags) { │ │ │ │ + var tag_list = dom_node.getElementsByTagName("tag"); │ │ │ │ + var tags = {}; │ │ │ │ + var interesting = false; │ │ │ │ + for (var j = 0; j < tag_list.length; j++) { │ │ │ │ + var key = tag_list[j].getAttribute("k"); │ │ │ │ + tags[key] = tag_list[j].getAttribute("v"); │ │ │ │ + if (interesting_tags) { │ │ │ │ + if (!this.interestingTagsExclude[key]) { │ │ │ │ + interesting = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return interesting_tags ? [tags, interesting] : tags │ │ │ │ }, │ │ │ │ - addPoint: function(pixel) { │ │ │ │ - if (!this.drawingHole && this.holeModifier && this.evt && this.evt[this.holeModifier]) { │ │ │ │ - var geometry = this.point.geometry; │ │ │ │ - var features = this.control.layer.features; │ │ │ │ - var candidate, polygon; │ │ │ │ - for (var i = features.length - 1; i >= 0; --i) { │ │ │ │ - candidate = features[i].geometry; │ │ │ │ - if ((candidate instanceof OpenLayers.Geometry.Polygon || candidate instanceof OpenLayers.Geometry.MultiPolygon) && candidate.intersects(geometry)) { │ │ │ │ - polygon = features[i]; │ │ │ │ - this.control.layer.removeFeatures([polygon], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.control.layer.events.registerPriority("sketchcomplete", this, this.finalizeInteriorRing); │ │ │ │ - this.control.layer.events.registerPriority("sketchmodified", this, this.enforceTopology); │ │ │ │ - polygon.geometry.addComponent(this.line.geometry); │ │ │ │ - this.polygon = polygon; │ │ │ │ - this.drawingHole = true; │ │ │ │ + isWayArea: function(way) { │ │ │ │ + var poly_shaped = false; │ │ │ │ + var poly_tags = false; │ │ │ │ + if (way.nodes[0] == way.nodes[way.nodes.length - 1]) { │ │ │ │ + poly_shaped = true │ │ │ │ + } │ │ │ │ + if (this.checkTags) { │ │ │ │ + for (var key in way.tags) { │ │ │ │ + if (this.areaTags[key]) { │ │ │ │ + poly_tags = true; │ │ │ │ break │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - OpenLayers.Handler.Path.prototype.addPoint.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - getCurrentPointIndex: function() { │ │ │ │ - return this.line.geometry.components.length - 2 │ │ │ │ + return poly_shaped && (this.checkTags ? poly_tags : true) │ │ │ │ }, │ │ │ │ - enforceTopology: function(event) { │ │ │ │ - var point = event.vertex; │ │ │ │ - var components = this.line.geometry.components; │ │ │ │ - if (!this.polygon.geometry.intersects(point)) { │ │ │ │ - var last = components[components.length - 3]; │ │ │ │ - point.x = last.x; │ │ │ │ - point.y = last.y │ │ │ │ + write: function(features) { │ │ │ │ + if (!OpenLayers.Util.isArray(features)) { │ │ │ │ + features = [features] │ │ │ │ + } │ │ │ │ + this.osm_id = 1; │ │ │ │ + this.created_nodes = {}; │ │ │ │ + var root_node = this.createElementNS(null, "osm"); │ │ │ │ + root_node.setAttribute("version", "0.5"); │ │ │ │ + root_node.setAttribute("generator", "OpenLayers " + OpenLayers.VERSION_NUMBER); │ │ │ │ + for (var i = features.length - 1; i >= 0; i--) { │ │ │ │ + var nodes = this.createFeatureNodes(features[i]); │ │ │ │ + for (var j = 0; j < nodes.length; j++) { │ │ │ │ + root_node.appendChild(nodes[j]) │ │ │ │ + } │ │ │ │ } │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root_node]) │ │ │ │ }, │ │ │ │ - finishGeometry: function() { │ │ │ │ - var index = this.line.geometry.components.length - 2; │ │ │ │ - this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ - this.removePoint(); │ │ │ │ - this.finalize() │ │ │ │ + createFeatureNodes: function(feature) { │ │ │ │ + var nodes = []; │ │ │ │ + var className = feature.geometry.CLASS_NAME; │ │ │ │ + var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ + type = type.toLowerCase(); │ │ │ │ + var builder = this.createXML[type]; │ │ │ │ + if (builder) { │ │ │ │ + nodes = builder.apply(this, [feature]) │ │ │ │ + } │ │ │ │ + return nodes │ │ │ │ }, │ │ │ │ - finalizeInteriorRing: function() { │ │ │ │ - var ring = this.line.geometry; │ │ │ │ - var modified = ring.getArea() !== 0; │ │ │ │ - if (modified) { │ │ │ │ - var rings = this.polygon.geometry.components; │ │ │ │ - for (var i = rings.length - 2; i >= 0; --i) { │ │ │ │ - if (ring.intersects(rings[i])) { │ │ │ │ - modified = false; │ │ │ │ - break │ │ │ │ - } │ │ │ │ + createXML: { │ │ │ │ + point: function(point) { │ │ │ │ + var id = null; │ │ │ │ + var geometry = point.geometry ? point.geometry : point; │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + geometry.transform(this.internalProjection, this.externalProjection) │ │ │ │ } │ │ │ │ - if (modified) { │ │ │ │ - var target; │ │ │ │ - outer: for (var i = rings.length - 2; i > 0; --i) { │ │ │ │ - var points = rings[i].components; │ │ │ │ - for (var j = 0, jj = points.length; j < jj; ++j) { │ │ │ │ - if (ring.containsPoint(points[j])) { │ │ │ │ - modified = false; │ │ │ │ - break outer │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var already_exists = false; │ │ │ │ + if (point.osm_id) { │ │ │ │ + id = point.osm_id; │ │ │ │ + if (this.created_nodes[id]) { │ │ │ │ + already_exists = true │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + id = -this.osm_id; │ │ │ │ + this.osm_id++ │ │ │ │ } │ │ │ │ - } │ │ │ │ - if (modified) { │ │ │ │ - if (this.polygon.state !== OpenLayers.State.INSERT) { │ │ │ │ - this.polygon.state = OpenLayers.State.UPDATE │ │ │ │ + if (already_exists) { │ │ │ │ + node = this.created_nodes[id] │ │ │ │ + } else { │ │ │ │ + var node = this.createElementNS(null, "node") │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - this.polygon.geometry.removeComponent(ring) │ │ │ │ + this.created_nodes[id] = node; │ │ │ │ + node.setAttribute("id", id); │ │ │ │ + node.setAttribute("lon", geometry.x); │ │ │ │ + node.setAttribute("lat", geometry.y); │ │ │ │ + if (point.attributes) { │ │ │ │ + this.serializeTags(point, node) │ │ │ │ + } │ │ │ │ + this.setState(point, node); │ │ │ │ + return already_exists ? [] : [node] │ │ │ │ + }, │ │ │ │ + linestring: function(feature) { │ │ │ │ + var id; │ │ │ │ + var nodes = []; │ │ │ │ + var geometry = feature.geometry; │ │ │ │ + if (feature.osm_id) { │ │ │ │ + id = feature.osm_id │ │ │ │ + } else { │ │ │ │ + id = -this.osm_id; │ │ │ │ + this.osm_id++ │ │ │ │ + } │ │ │ │ + var way = this.createElementNS(null, "way"); │ │ │ │ + way.setAttribute("id", id); │ │ │ │ + for (var i = 0; i < geometry.components.length; i++) { │ │ │ │ + var node = this.createXML["point"].apply(this, [geometry.components[i]]); │ │ │ │ + if (node.length) { │ │ │ │ + node = node[0]; │ │ │ │ + var node_ref = node.getAttribute("id"); │ │ │ │ + nodes.push(node) │ │ │ │ + } else { │ │ │ │ + node_ref = geometry.components[i].osm_id; │ │ │ │ + node = this.created_nodes[node_ref] │ │ │ │ + } │ │ │ │ + this.setState(feature, node); │ │ │ │ + var nd_dom = this.createElementNS(null, "nd"); │ │ │ │ + nd_dom.setAttribute("ref", node_ref); │ │ │ │ + way.appendChild(nd_dom) │ │ │ │ + } │ │ │ │ + this.serializeTags(feature, way); │ │ │ │ + nodes.push(way); │ │ │ │ + return nodes │ │ │ │ + }, │ │ │ │ + polygon: function(feature) { │ │ │ │ + var attrs = OpenLayers.Util.extend({ │ │ │ │ + area: "yes" │ │ │ │ + }, feature.attributes); │ │ │ │ + var feat = new OpenLayers.Feature.Vector(feature.geometry.components[0], attrs); │ │ │ │ + feat.osm_id = feature.osm_id; │ │ │ │ + return this.createXML["linestring"].apply(this, [feat]) │ │ │ │ } │ │ │ │ - this.restoreFeature(); │ │ │ │ - return false │ │ │ │ }, │ │ │ │ - cancel: function() { │ │ │ │ - if (this.drawingHole) { │ │ │ │ - this.polygon.geometry.removeComponent(this.line.geometry); │ │ │ │ - this.restoreFeature(true) │ │ │ │ + serializeTags: function(feature, node) { │ │ │ │ + for (var key in feature.attributes) { │ │ │ │ + var tag = this.createElementNS(null, "tag"); │ │ │ │ + tag.setAttribute("k", key); │ │ │ │ + tag.setAttribute("v", feature.attributes[key]); │ │ │ │ + node.appendChild(tag) │ │ │ │ } │ │ │ │ - return OpenLayers.Handler.Path.prototype.cancel.apply(this, arguments) │ │ │ │ }, │ │ │ │ - restoreFeature: function(cancel) { │ │ │ │ - this.control.layer.events.unregister("sketchcomplete", this, this.finalizeInteriorRing); │ │ │ │ - this.control.layer.events.unregister("sketchmodified", this, this.enforceTopology); │ │ │ │ - this.layer.removeFeatures([this.polygon], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.control.layer.addFeatures([this.polygon], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.drawingHole = false; │ │ │ │ - if (!cancel) { │ │ │ │ - this.control.layer.events.triggerEvent("sketchcomplete", { │ │ │ │ - feature: this.polygon │ │ │ │ - }) │ │ │ │ + setState: function(feature, node) { │ │ │ │ + if (feature.state) { │ │ │ │ + var state = null; │ │ │ │ + switch (feature.state) { │ │ │ │ + case OpenLayers.State.UPDATE: │ │ │ │ + state = "modify"; │ │ │ │ + case OpenLayers.State.DELETE: │ │ │ │ + state = "delete" │ │ │ │ + } │ │ │ │ + if (state) { │ │ │ │ + node.setAttribute("action", state) │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - destroyFeature: function(force) { │ │ │ │ - OpenLayers.Handler.Path.prototype.destroyFeature.call(this, force); │ │ │ │ - this.polygon = null │ │ │ │ + CLASS_NAME: "OpenLayers.Format.OSM" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.SOSGetObservation = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + sos: "http://www.opengis.net/sos/1.0", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + om: "http://www.opengis.net/om/1.0", │ │ │ │ + sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ }, │ │ │ │ - drawFeature: function() { │ │ │ │ - this.layer.drawFeature(this.polygon, this.style); │ │ │ │ - this.layer.drawFeature(this.point, this.style) │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ }, │ │ │ │ - getSketch: function() { │ │ │ │ - return this.polygon │ │ │ │ + VERSION: "1.0.0", │ │ │ │ + schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosGetObservation.xsd", │ │ │ │ + defaultPrefix: "sos", │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var info = { │ │ │ │ + measurements: [], │ │ │ │ + observations: [] │ │ │ │ + }; │ │ │ │ + this.readNode(data, info); │ │ │ │ + return info │ │ │ │ }, │ │ │ │ - getGeometry: function() { │ │ │ │ - var geometry = this.polygon && this.polygon.geometry; │ │ │ │ - if (geometry && this.multi) { │ │ │ │ - geometry = new OpenLayers.Geometry.MultiPolygon([geometry]) │ │ │ │ + write: function(options) { │ │ │ │ + var node = this.writeNode("sos:GetObservation", options); │ │ │ │ + node.setAttribute("xmlns:om", this.namespaces.om); │ │ │ │ + node.setAttribute("xmlns:ogc", this.namespaces.ogc); │ │ │ │ + this.setAttributeNS(node, this.namespaces.xsi, "xsi:schemaLocation", this.schemaLocation); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [node]) │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + om: { │ │ │ │ + ObservationCollection: function(node, obj) { │ │ │ │ + obj.id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + member: function(node, observationCollection) { │ │ │ │ + this.readChildNodes(node, observationCollection) │ │ │ │ + }, │ │ │ │ + Measurement: function(node, observationCollection) { │ │ │ │ + var measurement = {}; │ │ │ │ + observationCollection.measurements.push(measurement); │ │ │ │ + this.readChildNodes(node, measurement) │ │ │ │ + }, │ │ │ │ + Observation: function(node, observationCollection) { │ │ │ │ + var observation = {}; │ │ │ │ + observationCollection.observations.push(observation); │ │ │ │ + this.readChildNodes(node, observation) │ │ │ │ + }, │ │ │ │ + samplingTime: function(node, measurement) { │ │ │ │ + var samplingTime = {}; │ │ │ │ + measurement.samplingTime = samplingTime; │ │ │ │ + this.readChildNodes(node, samplingTime) │ │ │ │ + }, │ │ │ │ + observedProperty: function(node, measurement) { │ │ │ │ + measurement.observedProperty = this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ + this.readChildNodes(node, measurement) │ │ │ │ + }, │ │ │ │ + procedure: function(node, measurement) { │ │ │ │ + measurement.procedure = this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ + this.readChildNodes(node, measurement) │ │ │ │ + }, │ │ │ │ + featureOfInterest: function(node, observation) { │ │ │ │ + var foi = { │ │ │ │ + features: [] │ │ │ │ + }; │ │ │ │ + observation.fois = []; │ │ │ │ + observation.fois.push(foi); │ │ │ │ + this.readChildNodes(node, foi); │ │ │ │ + var features = []; │ │ │ │ + for (var i = 0, len = foi.features.length; i < len; i++) { │ │ │ │ + var feature = foi.features[i]; │ │ │ │ + features.push(new OpenLayers.Feature.Vector(feature.components[0], feature.attributes)) │ │ │ │ + } │ │ │ │ + foi.features = features │ │ │ │ + }, │ │ │ │ + result: function(node, measurement) { │ │ │ │ + var result = {}; │ │ │ │ + measurement.result = result; │ │ │ │ + if (this.getChildValue(node) !== "") { │ │ │ │ + result.value = this.getChildValue(node); │ │ │ │ + result.uom = node.getAttribute("uom") │ │ │ │ + } else { │ │ │ │ + this.readChildNodes(node, result) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + sa: OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.sa, │ │ │ │ + gml: OpenLayers.Util.applyDefaults({ │ │ │ │ + TimeInstant: function(node, samplingTime) { │ │ │ │ + var timeInstant = {}; │ │ │ │ + samplingTime.timeInstant = timeInstant; │ │ │ │ + this.readChildNodes(node, timeInstant) │ │ │ │ + }, │ │ │ │ + timePosition: function(node, timeInstant) { │ │ │ │ + timeInstant.timePosition = this.getChildValue(node) │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.gml) │ │ │ │ + }, │ │ │ │ + writers: { │ │ │ │ + sos: { │ │ │ │ + GetObservation: function(options) { │ │ │ │ + var node = this.createElementNSPlus("GetObservation", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + service: "SOS" │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("offering", options, node); │ │ │ │ + if (options.eventTime) { │ │ │ │ + this.writeNode("eventTime", options, node) │ │ │ │ + } │ │ │ │ + for (var procedure in options.procedures) { │ │ │ │ + this.writeNode("procedure", options.procedures[procedure], node) │ │ │ │ + } │ │ │ │ + for (var observedProperty in options.observedProperties) { │ │ │ │ + this.writeNode("observedProperty", options.observedProperties[observedProperty], node) │ │ │ │ + } │ │ │ │ + if (options.foi) { │ │ │ │ + this.writeNode("featureOfInterest", options.foi, node) │ │ │ │ + } │ │ │ │ + this.writeNode("responseFormat", options, node); │ │ │ │ + if (options.resultModel) { │ │ │ │ + this.writeNode("resultModel", options, node) │ │ │ │ + } │ │ │ │ + if (options.responseMode) { │ │ │ │ + this.writeNode("responseMode", options, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + featureOfInterest: function(foi) { │ │ │ │ + var node = this.createElementNSPlus("featureOfInterest"); │ │ │ │ + this.writeNode("ObjectID", foi.objectId, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + ObjectID: function(options) { │ │ │ │ + return this.createElementNSPlus("ObjectID", { │ │ │ │ + value: options │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + responseFormat: function(options) { │ │ │ │ + return this.createElementNSPlus("responseFormat", { │ │ │ │ + value: options.responseFormat │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + procedure: function(procedure) { │ │ │ │ + return this.createElementNSPlus("procedure", { │ │ │ │ + value: procedure │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + offering: function(options) { │ │ │ │ + return this.createElementNSPlus("offering", { │ │ │ │ + value: options.offering │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + observedProperty: function(observedProperty) { │ │ │ │ + return this.createElementNSPlus("observedProperty", { │ │ │ │ + value: observedProperty │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + eventTime: function(options) { │ │ │ │ + var node = this.createElementNSPlus("eventTime"); │ │ │ │ + if (options.eventTime === "latest") { │ │ │ │ + this.writeNode("ogc:TM_Equals", options, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + resultModel: function(options) { │ │ │ │ + return this.createElementNSPlus("resultModel", { │ │ │ │ + value: options.resultModel │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + responseMode: function(options) { │ │ │ │ + return this.createElementNSPlus("responseMode", { │ │ │ │ + value: options.responseMode │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + ogc: { │ │ │ │ + TM_Equals: function(options) { │ │ │ │ + var node = this.createElementNSPlus("ogc:TM_Equals"); │ │ │ │ + this.writeNode("ogc:PropertyName", { │ │ │ │ + property: "urn:ogc:data:time:iso8601" │ │ │ │ + }, node); │ │ │ │ + if (options.eventTime === "latest") { │ │ │ │ + this.writeNode("gml:TimeInstant", { │ │ │ │ + value: "latest" │ │ │ │ + }, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + PropertyName: function(options) { │ │ │ │ + return this.createElementNSPlus("ogc:PropertyName", { │ │ │ │ + value: options.property │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + gml: { │ │ │ │ + TimeInstant: function(options) { │ │ │ │ + var node = this.createElementNSPlus("gml:TimeInstant"); │ │ │ │ + this.writeNode("gml:timePosition", options, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + timePosition: function(options) { │ │ │ │ + var node = this.createElementNSPlus("gml:timePosition", { │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + } │ │ │ │ } │ │ │ │ - return geometry │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Polygon" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSGetObservation" │ │ │ │ }); │ │ │ │ -OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - delay: 300, │ │ │ │ - single: true, │ │ │ │ - double: false, │ │ │ │ - pixelTolerance: 0, │ │ │ │ - dblclickTolerance: 13, │ │ │ │ - stopSingle: false, │ │ │ │ - stopDouble: false, │ │ │ │ - timerId: null, │ │ │ │ - down: null, │ │ │ │ - last: null, │ │ │ │ - first: null, │ │ │ │ - rightclickTimerId: null, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - this.startTouch(); │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true │ │ │ │ +OpenLayers.Format.KML = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + kml: "http://www.opengis.net/kml/2.2", │ │ │ │ + gx: "http://www.google.com/kml/ext/2.2" │ │ │ │ }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true │ │ │ │ + kmlns: "http://earth.google.com/kml/2.0", │ │ │ │ + placemarksDesc: "No description available", │ │ │ │ + foldersName: "OpenLayers export", │ │ │ │ + foldersDesc: "Exported on " + new Date, │ │ │ │ + extractAttributes: true, │ │ │ │ + kvpAttributes: false, │ │ │ │ + extractStyles: false, │ │ │ │ + extractTracks: false, │ │ │ │ + trackAttributes: null, │ │ │ │ + internalns: null, │ │ │ │ + features: null, │ │ │ │ + styles: null, │ │ │ │ + styleBaseUrl: "", │ │ │ │ + fetched: null, │ │ │ │ + maxDepth: 0, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.regExes = { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g, │ │ │ │ + kmlColor: /(\w{2})(\w{2})(\w{2})(\w{2})/, │ │ │ │ + kmlIconPalette: /root:\/\/icons\/palette-(\d+)(\.\w+)/, │ │ │ │ + straightBracket: /\$\[(.*?)\]/g │ │ │ │ + }; │ │ │ │ + this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - touchend: function(evt) { │ │ │ │ - if (this.down) { │ │ │ │ - evt.xy = this.last.xy; │ │ │ │ - evt.lastTouches = this.last.touches; │ │ │ │ - this.handleSingle(evt); │ │ │ │ - this.down = null │ │ │ │ + read: function(data) { │ │ │ │ + this.features = []; │ │ │ │ + this.styles = {}; │ │ │ │ + this.fetched = {}; │ │ │ │ + var options = { │ │ │ │ + depth: 0, │ │ │ │ + styleBaseUrl: this.styleBaseUrl │ │ │ │ + }; │ │ │ │ + return this.parseData(data, options) │ │ │ │ + }, │ │ │ │ + parseData: function(data, options) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - return true │ │ │ │ + var types = ["Link", "NetworkLink", "Style", "StyleMap", "Placemark"]; │ │ │ │ + for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ + var type = types[i]; │ │ │ │ + var nodes = this.getElementsByTagNameNS(data, "*", type); │ │ │ │ + if (nodes.length == 0) { │ │ │ │ + continue │ │ │ │ + } │ │ │ │ + switch (type.toLowerCase()) { │ │ │ │ + case "link": │ │ │ │ + case "networklink": │ │ │ │ + this.parseLinks(nodes, options); │ │ │ │ + break; │ │ │ │ + case "style": │ │ │ │ + if (this.extractStyles) { │ │ │ │ + this.parseStyles(nodes, options) │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "stylemap": │ │ │ │ + if (this.extractStyles) { │ │ │ │ + this.parseStyleMaps(nodes, options) │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "placemark": │ │ │ │ + this.parseFeatures(nodes, options); │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return this.features │ │ │ │ }, │ │ │ │ - mousedown: function(evt) { │ │ │ │ - this.down = this.getEventInfo(evt); │ │ │ │ - this.last = this.getEventInfo(evt); │ │ │ │ - return true │ │ │ │ + parseLinks: function(nodes, options) { │ │ │ │ + if (options.depth >= this.maxDepth) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ + newOptions.depth++; │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var href = this.parseProperty(nodes[i], "*", "href"); │ │ │ │ + if (href && !this.fetched[href]) { │ │ │ │ + this.fetched[href] = true; │ │ │ │ + var data = this.fetchLink(href); │ │ │ │ + if (data) { │ │ │ │ + this.parseData(data, newOptions) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - mouseup: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - if (this.checkModifiers(evt) && this.control.handleRightClicks && OpenLayers.Event.isRightClick(evt)) { │ │ │ │ - propagate = this.rightclick(evt) │ │ │ │ + fetchLink: function(href) { │ │ │ │ + var request = OpenLayers.Request.GET({ │ │ │ │ + url: href, │ │ │ │ + async: false │ │ │ │ + }); │ │ │ │ + if (request) { │ │ │ │ + return request.responseText │ │ │ │ } │ │ │ │ - return propagate │ │ │ │ }, │ │ │ │ - rightclick: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.callback("dblrightclick", [evt]); │ │ │ │ - return !this.stopDouble │ │ │ │ - } else { │ │ │ │ - var clickEvent = this["double"] ? OpenLayers.Util.extend({}, evt) : this.callback("rightclick", [evt]); │ │ │ │ - var delayedRightCall = OpenLayers.Function.bind(this.delayedRightCall, this, clickEvent); │ │ │ │ - this.rightclickTimerId = window.setTimeout(delayedRightCall, this.delay) │ │ │ │ + parseStyles: function(nodes, options) { │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var style = this.parseStyle(nodes[i]); │ │ │ │ + if (style) { │ │ │ │ + var styleName = (options.styleBaseUrl || "") + "#" + style.id; │ │ │ │ + this.styles[styleName] = style │ │ │ │ } │ │ │ │ } │ │ │ │ - return !this.stopSingle │ │ │ │ }, │ │ │ │ - delayedRightCall: function(evt) { │ │ │ │ - this.rightclickTimerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback("rightclick", [evt]) │ │ │ │ + parseKmlColor: function(kmlColor) { │ │ │ │ + var color = null; │ │ │ │ + if (kmlColor) { │ │ │ │ + var matches = kmlColor.match(this.regExes.kmlColor); │ │ │ │ + if (matches) { │ │ │ │ + color = { │ │ │ │ + color: "#" + matches[4] + matches[3] + matches[2], │ │ │ │ + opacity: parseInt(matches[1], 16) / 255 │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return color │ │ │ │ }, │ │ │ │ - click: function(evt) { │ │ │ │ - if (!this.last) { │ │ │ │ - this.last = this.getEventInfo(evt) │ │ │ │ + parseStyle: function(node) { │ │ │ │ + var style = {}; │ │ │ │ + var types = ["LineStyle", "PolyStyle", "IconStyle", "BalloonStyle", "LabelStyle"]; │ │ │ │ + var type, styleTypeNode, nodeList, geometry, parser; │ │ │ │ + for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ + type = types[i]; │ │ │ │ + styleTypeNode = this.getElementsByTagNameNS(node, "*", type)[0]; │ │ │ │ + if (!styleTypeNode) { │ │ │ │ + continue │ │ │ │ + } │ │ │ │ + switch (type.toLowerCase()) { │ │ │ │ + case "linestyle": │ │ │ │ + var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ + var color = this.parseKmlColor(kmlColor); │ │ │ │ + if (color) { │ │ │ │ + style["strokeColor"] = color.color; │ │ │ │ + style["strokeOpacity"] = color.opacity │ │ │ │ + } │ │ │ │ + var width = this.parseProperty(styleTypeNode, "*", "width"); │ │ │ │ + if (width) { │ │ │ │ + style["strokeWidth"] = width │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "polystyle": │ │ │ │ + var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ + var color = this.parseKmlColor(kmlColor); │ │ │ │ + if (color) { │ │ │ │ + style["fillOpacity"] = color.opacity; │ │ │ │ + style["fillColor"] = color.color │ │ │ │ + } │ │ │ │ + var fill = this.parseProperty(styleTypeNode, "*", "fill"); │ │ │ │ + if (fill == "0") { │ │ │ │ + style["fillColor"] = "none" │ │ │ │ + } │ │ │ │ + var outline = this.parseProperty(styleTypeNode, "*", "outline"); │ │ │ │ + if (outline == "0") { │ │ │ │ + style["strokeWidth"] = "0" │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "iconstyle": │ │ │ │ + var scale = parseFloat(this.parseProperty(styleTypeNode, "*", "scale") || 1); │ │ │ │ + var width = 32 * scale; │ │ │ │ + var height = 32 * scale; │ │ │ │ + var iconNode = this.getElementsByTagNameNS(styleTypeNode, "*", "Icon")[0]; │ │ │ │ + if (iconNode) { │ │ │ │ + var href = this.parseProperty(iconNode, "*", "href"); │ │ │ │ + if (href) { │ │ │ │ + var w = this.parseProperty(iconNode, "*", "w"); │ │ │ │ + var h = this.parseProperty(iconNode, "*", "h"); │ │ │ │ + var google = "http://maps.google.com/mapfiles/kml"; │ │ │ │ + if (OpenLayers.String.startsWith(href, google) && !w && !h) { │ │ │ │ + w = 64; │ │ │ │ + h = 64; │ │ │ │ + scale = scale / 2 │ │ │ │ + } │ │ │ │ + w = w || h; │ │ │ │ + h = h || w; │ │ │ │ + if (w) { │ │ │ │ + width = parseInt(w) * scale │ │ │ │ + } │ │ │ │ + if (h) { │ │ │ │ + height = parseInt(h) * scale │ │ │ │ + } │ │ │ │ + var matches = href.match(this.regExes.kmlIconPalette); │ │ │ │ + if (matches) { │ │ │ │ + var palette = matches[1]; │ │ │ │ + var file_extension = matches[2]; │ │ │ │ + var x = this.parseProperty(iconNode, "*", "x"); │ │ │ │ + var y = this.parseProperty(iconNode, "*", "y"); │ │ │ │ + var posX = x ? x / 32 : 0; │ │ │ │ + var posY = y ? 7 - y / 32 : 7; │ │ │ │ + var pos = posY * 8 + posX; │ │ │ │ + href = "http://maps.google.com/mapfiles/kml/pal" + palette + "/icon" + pos + file_extension │ │ │ │ + } │ │ │ │ + style["graphicOpacity"] = 1; │ │ │ │ + style["externalGraphic"] = href │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var hotSpotNode = this.getElementsByTagNameNS(styleTypeNode, "*", "hotSpot")[0]; │ │ │ │ + if (hotSpotNode) { │ │ │ │ + var x = parseFloat(hotSpotNode.getAttribute("x")); │ │ │ │ + var y = parseFloat(hotSpotNode.getAttribute("y")); │ │ │ │ + var xUnits = hotSpotNode.getAttribute("xunits"); │ │ │ │ + if (xUnits == "pixels") { │ │ │ │ + style["graphicXOffset"] = -x * scale │ │ │ │ + } else if (xUnits == "insetPixels") { │ │ │ │ + style["graphicXOffset"] = -width + x * scale │ │ │ │ + } else if (xUnits == "fraction") { │ │ │ │ + style["graphicXOffset"] = -width * x │ │ │ │ + } │ │ │ │ + var yUnits = hotSpotNode.getAttribute("yunits"); │ │ │ │ + if (yUnits == "pixels") { │ │ │ │ + style["graphicYOffset"] = -height + y * scale + 1 │ │ │ │ + } else if (yUnits == "insetPixels") { │ │ │ │ + style["graphicYOffset"] = -(y * scale) + 1 │ │ │ │ + } else if (yUnits == "fraction") { │ │ │ │ + style["graphicYOffset"] = -height * (1 - y) + 1 │ │ │ │ + } │ │ │ │ + } │ │ │ │ + style["graphicWidth"] = width; │ │ │ │ + style["graphicHeight"] = height; │ │ │ │ + break; │ │ │ │ + case "balloonstyle": │ │ │ │ + var balloonStyle = OpenLayers.Util.getXmlNodeValue(styleTypeNode); │ │ │ │ + if (balloonStyle) { │ │ │ │ + style["balloonStyle"] = balloonStyle.replace(this.regExes.straightBracket, "${$1}") │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + case "labelstyle": │ │ │ │ + var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ + var color = this.parseKmlColor(kmlColor); │ │ │ │ + if (color) { │ │ │ │ + style["fontColor"] = color.color; │ │ │ │ + style["fontOpacity"] = color.opacity │ │ │ │ + } │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.handleSingle(evt); │ │ │ │ - return !this.stopSingle │ │ │ │ - }, │ │ │ │ - dblclick: function(evt) { │ │ │ │ - this.handleDouble(evt); │ │ │ │ - return !this.stopDouble │ │ │ │ + if (!style["strokeColor"] && style["fillColor"]) { │ │ │ │ + style["strokeColor"] = style["fillColor"] │ │ │ │ + } │ │ │ │ + var id = node.getAttribute("id"); │ │ │ │ + if (id && style) { │ │ │ │ + style.id = id │ │ │ │ + } │ │ │ │ + return style │ │ │ │ }, │ │ │ │ - handleDouble: function(evt) { │ │ │ │ - if (this.passesDblclickTolerance(evt)) { │ │ │ │ - if (this["double"]) { │ │ │ │ - this.callback("dblclick", [evt]) │ │ │ │ + parseStyleMaps: function(nodes, options) { │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var node = nodes[i]; │ │ │ │ + var pairs = this.getElementsByTagNameNS(node, "*", "Pair"); │ │ │ │ + var id = node.getAttribute("id"); │ │ │ │ + for (var j = 0, jlen = pairs.length; j < jlen; j++) { │ │ │ │ + var pair = pairs[j]; │ │ │ │ + var key = this.parseProperty(pair, "*", "key"); │ │ │ │ + var styleUrl = this.parseProperty(pair, "*", "styleUrl"); │ │ │ │ + if (styleUrl && key == "normal") { │ │ │ │ + this.styles[(options.styleBaseUrl || "") + "#" + id] = this.styles[(options.styleBaseUrl || "") + styleUrl] │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.clearTimer() │ │ │ │ } │ │ │ │ }, │ │ │ │ - handleSingle: function(evt) { │ │ │ │ - if (this.passesTolerance(evt)) { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ - if (this["double"]) { │ │ │ │ - OpenLayers.Event.preventDefault(evt) │ │ │ │ + parseFeatures: function(nodes, options) { │ │ │ │ + var features = []; │ │ │ │ + for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ + var featureNode = nodes[i]; │ │ │ │ + var feature = this.parseFeature.apply(this, [featureNode]); │ │ │ │ + if (feature) { │ │ │ │ + if (this.extractStyles && feature.attributes && feature.attributes.styleUrl) { │ │ │ │ + feature.style = this.getStyle(feature.attributes.styleUrl, options) │ │ │ │ + } │ │ │ │ + if (this.extractStyles) { │ │ │ │ + var inlineStyleNode = this.getElementsByTagNameNS(featureNode, "*", "Style")[0]; │ │ │ │ + if (inlineStyleNode) { │ │ │ │ + var inlineStyle = this.parseStyle(inlineStyleNode); │ │ │ │ + if (inlineStyle) { │ │ │ │ + feature.style = OpenLayers.Util.extend(feature.style, inlineStyle) │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.handleDouble(evt) │ │ │ │ } │ │ │ │ - if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ - this.clearTimer() │ │ │ │ + if (this.extractTracks) { │ │ │ │ + var tracks = this.getElementsByTagNameNS(featureNode, this.namespaces.gx, "Track"); │ │ │ │ + if (tracks && tracks.length > 0) { │ │ │ │ + var track = tracks[0]; │ │ │ │ + var container = { │ │ │ │ + features: [], │ │ │ │ + feature: feature │ │ │ │ + }; │ │ │ │ + this.readNode(track, container); │ │ │ │ + if (container.features.length > 0) { │ │ │ │ + features.push.apply(features, container.features) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + features.push(feature) │ │ │ │ } │ │ │ │ } else { │ │ │ │ - this.first = this.getEventInfo(evt); │ │ │ │ - var clickEvent = this.single ? OpenLayers.Util.extend({}, evt) : null; │ │ │ │ - this.queuePotentialClick(clickEvent) │ │ │ │ + throw "Bad Placemark: " + i │ │ │ │ } │ │ │ │ } │ │ │ │ + this.features = this.features.concat(features) │ │ │ │ }, │ │ │ │ - queuePotentialClick: function(evt) { │ │ │ │ - this.timerId = window.setTimeout(OpenLayers.Function.bind(this.delayedCall, this, evt), this.delay) │ │ │ │ + readers: { │ │ │ │ + kml: { │ │ │ │ + when: function(node, container) { │ │ │ │ + container.whens.push(OpenLayers.Date.parse(this.getChildValue(node))) │ │ │ │ + }, │ │ │ │ + _trackPointAttribute: function(node, container) { │ │ │ │ + var name = node.nodeName.split(":").pop(); │ │ │ │ + container.attributes[name].push(this.getChildValue(node)) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + gx: { │ │ │ │ + Track: function(node, container) { │ │ │ │ + var obj = { │ │ │ │ + whens: [], │ │ │ │ + points: [], │ │ │ │ + angles: [] │ │ │ │ + }; │ │ │ │ + if (this.trackAttributes) { │ │ │ │ + var name; │ │ │ │ + obj.attributes = {}; │ │ │ │ + for (var i = 0, ii = this.trackAttributes.length; i < ii; ++i) { │ │ │ │ + name = this.trackAttributes[i]; │ │ │ │ + obj.attributes[name] = []; │ │ │ │ + if (!(name in this.readers.kml)) { │ │ │ │ + this.readers.kml[name] = this.readers.kml._trackPointAttribute │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + if (obj.whens.length !== obj.points.length) { │ │ │ │ + throw new Error("gx:Track with unequal number of when (" + obj.whens.length + ") and gx:coord (" + obj.points.length + ") elements.") │ │ │ │ + } │ │ │ │ + var hasAngles = obj.angles.length > 0; │ │ │ │ + if (hasAngles && obj.whens.length !== obj.angles.length) { │ │ │ │ + throw new Error("gx:Track with unequal number of when (" + obj.whens.length + ") and gx:angles (" + obj.angles.length + ") elements.") │ │ │ │ + } │ │ │ │ + var feature, point, angles; │ │ │ │ + for (var i = 0, ii = obj.whens.length; i < ii; ++i) { │ │ │ │ + feature = container.feature.clone(); │ │ │ │ + feature.fid = container.feature.fid || container.feature.id; │ │ │ │ + point = obj.points[i]; │ │ │ │ + feature.geometry = point; │ │ │ │ + if ("z" in point) { │ │ │ │ + feature.attributes.altitude = point.z │ │ │ │ + } │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + feature.geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ + } │ │ │ │ + if (this.trackAttributes) { │ │ │ │ + for (var j = 0, jj = this.trackAttributes.length; j < jj; ++j) { │ │ │ │ + var name = this.trackAttributes[j]; │ │ │ │ + feature.attributes[name] = obj.attributes[name][i] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + feature.attributes.when = obj.whens[i]; │ │ │ │ + feature.attributes.trackId = container.feature.id; │ │ │ │ + if (hasAngles) { │ │ │ │ + angles = obj.angles[i]; │ │ │ │ + feature.attributes.heading = parseFloat(angles[0]); │ │ │ │ + feature.attributes.tilt = parseFloat(angles[1]); │ │ │ │ + feature.attributes.roll = parseFloat(angles[2]) │ │ │ │ + } │ │ │ │ + container.features.push(feature) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + coord: function(node, container) { │ │ │ │ + var str = this.getChildValue(node); │ │ │ │ + var coords = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ + var point = new OpenLayers.Geometry.Point(coords[0], coords[1]); │ │ │ │ + if (coords.length > 2) { │ │ │ │ + point.z = parseFloat(coords[2]) │ │ │ │ + } │ │ │ │ + container.points.push(point) │ │ │ │ + }, │ │ │ │ + angles: function(node, container) { │ │ │ │ + var str = this.getChildValue(node); │ │ │ │ + var parts = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ + container.angles.push(parts) │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - passesTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ - passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ - if (passes && this.touch && this.down.touches.length === this.last.touches.length) { │ │ │ │ - for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ - if (this.getTouchDistance(this.down.touches[i], this.last.touches[i]) > this.pixelTolerance) { │ │ │ │ - passes = false; │ │ │ │ - break │ │ │ │ + parseFeature: function(node) { │ │ │ │ + var order = ["MultiGeometry", "Polygon", "LineString", "Point"]; │ │ │ │ + var type, nodeList, geometry, parser; │ │ │ │ + for (var i = 0, len = order.length; i < len; ++i) { │ │ │ │ + type = order[i]; │ │ │ │ + this.internalns = node.namespaceURI ? node.namespaceURI : this.kmlns; │ │ │ │ + nodeList = this.getElementsByTagNameNS(node, this.internalns, type); │ │ │ │ + if (nodeList.length > 0) { │ │ │ │ + var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ + if (parser) { │ │ │ │ + geometry = parser.apply(this, [nodeList[0]]); │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + throw new TypeError("Unsupported geometry type: " + type) │ │ │ │ } │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - return passes │ │ │ │ + var attributes; │ │ │ │ + if (this.extractAttributes) { │ │ │ │ + attributes = this.parseAttributes(node) │ │ │ │ + } │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry, attributes); │ │ │ │ + var fid = node.getAttribute("id") || node.getAttribute("name"); │ │ │ │ + if (fid != null) { │ │ │ │ + feature.fid = fid │ │ │ │ + } │ │ │ │ + return feature │ │ │ │ }, │ │ │ │ - getTouchDistance: function(from, to) { │ │ │ │ - return Math.sqrt(Math.pow(from.clientX - to.clientX, 2) + Math.pow(from.clientY - to.clientY, 2)) │ │ │ │ + getStyle: function(styleUrl, options) { │ │ │ │ + var styleBaseUrl = OpenLayers.Util.removeTail(styleUrl); │ │ │ │ + var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ + newOptions.depth++; │ │ │ │ + newOptions.styleBaseUrl = styleBaseUrl; │ │ │ │ + if (!this.styles[styleUrl] && !OpenLayers.String.startsWith(styleUrl, "#") && newOptions.depth <= this.maxDepth && !this.fetched[styleBaseUrl]) { │ │ │ │ + var data = this.fetchLink(styleBaseUrl); │ │ │ │ + if (data) { │ │ │ │ + this.parseData(data, newOptions) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var style = OpenLayers.Util.extend({}, this.styles[styleUrl]); │ │ │ │ + return style │ │ │ │ }, │ │ │ │ - passesDblclickTolerance: function(evt) { │ │ │ │ - var passes = true; │ │ │ │ - if (this.down && this.first) { │ │ │ │ - passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance │ │ │ │ + parseGeometry: { │ │ │ │ + point: function(node) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, this.internalns, "coordinates"); │ │ │ │ + var coords = []; │ │ │ │ + if (nodeList.length > 0) { │ │ │ │ + var coordString = nodeList[0].firstChild.nodeValue; │ │ │ │ + coordString = coordString.replace(this.regExes.removeSpace, ""); │ │ │ │ + coords = coordString.split(",") │ │ │ │ + } │ │ │ │ + var point = null; │ │ │ │ + if (coords.length > 1) { │ │ │ │ + if (coords.length == 2) { │ │ │ │ + coords[2] = null │ │ │ │ + } │ │ │ │ + point = new OpenLayers.Geometry.Point(coords[0], coords[1], coords[2]) │ │ │ │ + } else { │ │ │ │ + throw "Bad coordinate string: " + coordString │ │ │ │ + } │ │ │ │ + return point │ │ │ │ + }, │ │ │ │ + linestring: function(node, ring) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, this.internalns, "coordinates"); │ │ │ │ + var line = null; │ │ │ │ + if (nodeList.length > 0) { │ │ │ │ + var coordString = this.getChildValue(nodeList[0]); │ │ │ │ + coordString = coordString.replace(this.regExes.trimSpace, ""); │ │ │ │ + coordString = coordString.replace(this.regExes.trimComma, ","); │ │ │ │ + var pointList = coordString.split(this.regExes.splitSpace); │ │ │ │ + var numPoints = pointList.length; │ │ │ │ + var points = new Array(numPoints); │ │ │ │ + var coords, numCoords; │ │ │ │ + for (var i = 0; i < numPoints; ++i) { │ │ │ │ + coords = pointList[i].split(","); │ │ │ │ + numCoords = coords.length; │ │ │ │ + if (numCoords > 1) { │ │ │ │ + if (coords.length == 2) { │ │ │ │ + coords[2] = null │ │ │ │ + } │ │ │ │ + points[i] = new OpenLayers.Geometry.Point(coords[0], coords[1], coords[2]) │ │ │ │ + } else { │ │ │ │ + throw "Bad LineString point coordinates: " + pointList[i] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (numPoints) { │ │ │ │ + if (ring) { │ │ │ │ + line = new OpenLayers.Geometry.LinearRing(points) │ │ │ │ + } else { │ │ │ │ + line = new OpenLayers.Geometry.LineString(points) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + throw "Bad LineString coordinates: " + coordString │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return line │ │ │ │ + }, │ │ │ │ + polygon: function(node) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, this.internalns, "LinearRing"); │ │ │ │ + var numRings = nodeList.length; │ │ │ │ + var components = new Array(numRings); │ │ │ │ + if (numRings > 0) { │ │ │ │ + var ring; │ │ │ │ + for (var i = 0, len = nodeList.length; i < len; ++i) { │ │ │ │ + ring = this.parseGeometry.linestring.apply(this, [nodeList[i], true]); │ │ │ │ + if (ring) { │ │ │ │ + components[i] = ring │ │ │ │ + } else { │ │ │ │ + throw "Bad LinearRing geometry: " + i │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Polygon(components) │ │ │ │ + }, │ │ │ │ + multigeometry: function(node) { │ │ │ │ + var child, parser; │ │ │ │ + var parts = []; │ │ │ │ + var children = node.childNodes; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + var type = child.prefix ? child.nodeName.split(":")[1] : child.nodeName; │ │ │ │ + var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ + if (parser) { │ │ │ │ + parts.push(parser.apply(this, [child])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return new OpenLayers.Geometry.Collection(parts) │ │ │ │ } │ │ │ │ - return passes │ │ │ │ }, │ │ │ │ - clearTimer: function() { │ │ │ │ - if (this.timerId != null) { │ │ │ │ - window.clearTimeout(this.timerId); │ │ │ │ - this.timerId = null │ │ │ │ + parseAttributes: function(node) { │ │ │ │ + var attributes = {}; │ │ │ │ + var edNodes = node.getElementsByTagName("ExtendedData"); │ │ │ │ + if (edNodes.length) { │ │ │ │ + attributes = this.parseExtendedData(edNodes[0]) │ │ │ │ } │ │ │ │ - if (this.rightclickTimerId != null) { │ │ │ │ - window.clearTimeout(this.rightclickTimerId); │ │ │ │ - this.rightclickTimerId = null │ │ │ │ + var child, grandchildren, grandchild; │ │ │ │ + var children = node.childNodes; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + grandchildren = child.childNodes; │ │ │ │ + if (grandchildren.length >= 1 && grandchildren.length <= 3) { │ │ │ │ + var grandchild; │ │ │ │ + switch (grandchildren.length) { │ │ │ │ + case 1: │ │ │ │ + grandchild = grandchildren[0]; │ │ │ │ + break; │ │ │ │ + case 2: │ │ │ │ + var c1 = grandchildren[0]; │ │ │ │ + var c2 = grandchildren[1]; │ │ │ │ + grandchild = c1.nodeType == 3 || c1.nodeType == 4 ? c1 : c2; │ │ │ │ + break; │ │ │ │ + case 3: │ │ │ │ + default: │ │ │ │ + grandchild = grandchildren[1]; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + if (grandchild.nodeType == 3 || grandchild.nodeType == 4) { │ │ │ │ + var name = child.prefix ? child.nodeName.split(":")[1] : child.nodeName; │ │ │ │ + var value = OpenLayers.Util.getXmlNodeValue(grandchild); │ │ │ │ + if (value) { │ │ │ │ + value = value.replace(this.regExes.trimSpace, ""); │ │ │ │ + attributes[name] = value │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return attributes │ │ │ │ }, │ │ │ │ - delayedCall: function(evt) { │ │ │ │ - this.timerId = null; │ │ │ │ - if (evt) { │ │ │ │ - this.callback("click", [evt]) │ │ │ │ + parseExtendedData: function(node) { │ │ │ │ + var attributes = {}; │ │ │ │ + var i, len, data, key; │ │ │ │ + var dataNodes = node.getElementsByTagName("Data"); │ │ │ │ + for (i = 0, len = dataNodes.length; i < len; i++) { │ │ │ │ + data = dataNodes[i]; │ │ │ │ + key = data.getAttribute("name"); │ │ │ │ + var ed = {}; │ │ │ │ + var valueNode = data.getElementsByTagName("value"); │ │ │ │ + if (valueNode.length) { │ │ │ │ + ed["value"] = this.getChildValue(valueNode[0]) │ │ │ │ + } │ │ │ │ + if (this.kvpAttributes) { │ │ │ │ + attributes[key] = ed["value"] │ │ │ │ + } else { │ │ │ │ + var nameNode = data.getElementsByTagName("displayName"); │ │ │ │ + if (nameNode.length) { │ │ │ │ + ed["displayName"] = this.getChildValue(nameNode[0]) │ │ │ │ + } │ │ │ │ + attributes[key] = ed │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var simpleDataNodes = node.getElementsByTagName("SimpleData"); │ │ │ │ + for (i = 0, len = simpleDataNodes.length; i < len; i++) { │ │ │ │ + var ed = {}; │ │ │ │ + data = simpleDataNodes[i]; │ │ │ │ + key = data.getAttribute("name"); │ │ │ │ + ed["value"] = this.getChildValue(data); │ │ │ │ + if (this.kvpAttributes) { │ │ │ │ + attributes[key] = ed["value"] │ │ │ │ + } else { │ │ │ │ + ed["displayName"] = key; │ │ │ │ + attributes[key] = ed │ │ │ │ + } │ │ │ │ } │ │ │ │ + return attributes │ │ │ │ }, │ │ │ │ - getEventInfo: function(evt) { │ │ │ │ - var touches; │ │ │ │ - if (evt.touches) { │ │ │ │ - var len = evt.touches.length; │ │ │ │ - touches = new Array(len); │ │ │ │ - var touch; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - touch = evt.touches[i]; │ │ │ │ - touches[i] = { │ │ │ │ - clientX: touch.olClientX, │ │ │ │ - clientY: touch.olClientY │ │ │ │ + parseProperty: function(xmlNode, namespace, tagName) { │ │ │ │ + var value; │ │ │ │ + var nodeList = this.getElementsByTagNameNS(xmlNode, namespace, tagName); │ │ │ │ + try { │ │ │ │ + value = OpenLayers.Util.getXmlNodeValue(nodeList[0]) │ │ │ │ + } catch (e) { │ │ │ │ + value = null │ │ │ │ + } │ │ │ │ + return value │ │ │ │ + }, │ │ │ │ + write: function(features) { │ │ │ │ + if (!OpenLayers.Util.isArray(features)) { │ │ │ │ + features = [features] │ │ │ │ + } │ │ │ │ + var kml = this.createElementNS(this.kmlns, "kml"); │ │ │ │ + var folder = this.createFolderXML(); │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + folder.appendChild(this.createPlacemarkXML(features[i])) │ │ │ │ + } │ │ │ │ + kml.appendChild(folder); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [kml]) │ │ │ │ + }, │ │ │ │ + createFolderXML: function() { │ │ │ │ + var folder = this.createElementNS(this.kmlns, "Folder"); │ │ │ │ + if (this.foldersName) { │ │ │ │ + var folderName = this.createElementNS(this.kmlns, "name"); │ │ │ │ + var folderNameText = this.createTextNode(this.foldersName); │ │ │ │ + folderName.appendChild(folderNameText); │ │ │ │ + folder.appendChild(folderName) │ │ │ │ + } │ │ │ │ + if (this.foldersDesc) { │ │ │ │ + var folderDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ + var folderDescText = this.createTextNode(this.foldersDesc); │ │ │ │ + folderDesc.appendChild(folderDescText); │ │ │ │ + folder.appendChild(folderDesc) │ │ │ │ + } │ │ │ │ + return folder │ │ │ │ + }, │ │ │ │ + createPlacemarkXML: function(feature) { │ │ │ │ + var placemarkName = this.createElementNS(this.kmlns, "name"); │ │ │ │ + var label = feature.style && feature.style.label ? feature.style.label : feature.id; │ │ │ │ + var name = feature.attributes.name || label; │ │ │ │ + placemarkName.appendChild(this.createTextNode(name)); │ │ │ │ + var placemarkDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ + var desc = feature.attributes.description || this.placemarksDesc; │ │ │ │ + placemarkDesc.appendChild(this.createTextNode(desc)); │ │ │ │ + var placemarkNode = this.createElementNS(this.kmlns, "Placemark"); │ │ │ │ + if (feature.fid != null) { │ │ │ │ + placemarkNode.setAttribute("id", feature.fid) │ │ │ │ + } │ │ │ │ + placemarkNode.appendChild(placemarkName); │ │ │ │ + placemarkNode.appendChild(placemarkDesc); │ │ │ │ + var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ + placemarkNode.appendChild(geometryNode); │ │ │ │ + if (feature.attributes) { │ │ │ │ + var edNode = this.buildExtendedData(feature.attributes); │ │ │ │ + if (edNode) { │ │ │ │ + placemarkNode.appendChild(edNode) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return placemarkNode │ │ │ │ + }, │ │ │ │ + buildGeometryNode: function(geometry) { │ │ │ │ + var className = geometry.CLASS_NAME; │ │ │ │ + var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ + var builder = this.buildGeometry[type.toLowerCase()]; │ │ │ │ + var node = null; │ │ │ │ + if (builder) { │ │ │ │ + node = builder.apply(this, [geometry]) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + buildGeometry: { │ │ │ │ + point: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "Point"); │ │ │ │ + kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + return kml │ │ │ │ + }, │ │ │ │ + multipoint: function(geometry) { │ │ │ │ + return this.buildGeometry.collection.apply(this, [geometry]) │ │ │ │ + }, │ │ │ │ + linestring: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "LineString"); │ │ │ │ + kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + return kml │ │ │ │ + }, │ │ │ │ + multilinestring: function(geometry) { │ │ │ │ + return this.buildGeometry.collection.apply(this, [geometry]) │ │ │ │ + }, │ │ │ │ + linearring: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "LinearRing"); │ │ │ │ + kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ + return kml │ │ │ │ + }, │ │ │ │ + polygon: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "Polygon"); │ │ │ │ + var rings = geometry.components; │ │ │ │ + var ringMember, ringGeom, type; │ │ │ │ + for (var i = 0, len = rings.length; i < len; ++i) { │ │ │ │ + type = i == 0 ? "outerBoundaryIs" : "innerBoundaryIs"; │ │ │ │ + ringMember = this.createElementNS(this.kmlns, type); │ │ │ │ + ringGeom = this.buildGeometry.linearring.apply(this, [rings[i]]); │ │ │ │ + ringMember.appendChild(ringGeom); │ │ │ │ + kml.appendChild(ringMember) │ │ │ │ + } │ │ │ │ + return kml │ │ │ │ + }, │ │ │ │ + multipolygon: function(geometry) { │ │ │ │ + return this.buildGeometry.collection.apply(this, [geometry]) │ │ │ │ + }, │ │ │ │ + collection: function(geometry) { │ │ │ │ + var kml = this.createElementNS(this.kmlns, "MultiGeometry"); │ │ │ │ + var child; │ │ │ │ + for (var i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ + child = this.buildGeometryNode.apply(this, [geometry.components[i]]); │ │ │ │ + if (child) { │ │ │ │ + kml.appendChild(child) │ │ │ │ } │ │ │ │ } │ │ │ │ + return kml │ │ │ │ } │ │ │ │ - return { │ │ │ │ - xy: evt.xy, │ │ │ │ - touches: touches │ │ │ │ + }, │ │ │ │ + buildCoordinatesNode: function(geometry) { │ │ │ │ + var coordinatesNode = this.createElementNS(this.kmlns, "coordinates"); │ │ │ │ + var path; │ │ │ │ + var points = geometry.components; │ │ │ │ + if (points) { │ │ │ │ + var point; │ │ │ │ + var numPoints = points.length; │ │ │ │ + var parts = new Array(numPoints); │ │ │ │ + for (var i = 0; i < numPoints; ++i) { │ │ │ │ + point = points[i]; │ │ │ │ + parts[i] = this.buildCoordinates(point) │ │ │ │ + } │ │ │ │ + path = parts.join(" ") │ │ │ │ + } else { │ │ │ │ + path = this.buildCoordinates(geometry) │ │ │ │ } │ │ │ │ + var txtNode = this.createTextNode(path); │ │ │ │ + coordinatesNode.appendChild(txtNode); │ │ │ │ + return coordinatesNode │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.clearTimer(); │ │ │ │ - this.down = null; │ │ │ │ - this.first = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true │ │ │ │ + buildCoordinates: function(point) { │ │ │ │ + if (this.internalProjection && this.externalProjection) { │ │ │ │ + point = point.clone(); │ │ │ │ + point.transform(this.internalProjection, this.externalProjection) │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ + return point.x + "," + point.y │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ + buildExtendedData: function(attributes) { │ │ │ │ + var extendedData = this.createElementNS(this.kmlns, "ExtendedData"); │ │ │ │ + for (var attributeName in attributes) { │ │ │ │ + if (attributes[attributeName] && attributeName != "name" && attributeName != "description" && attributeName != "styleUrl") { │ │ │ │ + var data = this.createElementNS(this.kmlns, "Data"); │ │ │ │ + data.setAttribute("name", attributeName); │ │ │ │ + var value = this.createElementNS(this.kmlns, "value"); │ │ │ │ + if (typeof attributes[attributeName] == "object") { │ │ │ │ + if (attributes[attributeName].value) { │ │ │ │ + value.appendChild(this.createTextNode(attributes[attributeName].value)) │ │ │ │ + } │ │ │ │ + if (attributes[attributeName].displayName) { │ │ │ │ + var displayName = this.createElementNS(this.kmlns, "displayName"); │ │ │ │ + displayName.appendChild(this.getXMLDoc().createCDATASection(attributes[attributeName].displayName)); │ │ │ │ + data.appendChild(displayName) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + value.appendChild(this.createTextNode(attributes[attributeName])) │ │ │ │ + } │ │ │ │ + data.appendChild(value); │ │ │ │ + extendedData.appendChild(data) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (this.isSimpleContent(extendedData)) { │ │ │ │ + return null │ │ │ │ + } else { │ │ │ │ + return extendedData │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.KML" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.XLS = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ + stringifyOutput: true, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.XLS" │ │ │ │ }); │ │ │ │ OpenLayers.Format.SLD = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ profile: null, │ │ │ │ defaultVersion: "1.0.0", │ │ │ │ stringifyOutput: true, │ │ │ │ namedLayersAsArray: false, │ │ │ │ CLASS_NAME: "OpenLayers.Format.SLD" │ │ │ │ }); │ │ │ │ +OpenLayers.Format.WMSGetFeatureInfo = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + layerIdentifier: "_layer", │ │ │ │ + featureIdentifier: "_feature", │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ + }, │ │ │ │ + gmlFormat: null, │ │ │ │ + read: function(data) { │ │ │ │ + var result; │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + var root = data.documentElement; │ │ │ │ + if (root) { │ │ │ │ + var scope = this; │ │ │ │ + var read = this["read_" + root.nodeName]; │ │ │ │ + if (read) { │ │ │ │ + result = read.call(this, root) │ │ │ │ + } else { │ │ │ │ + result = new OpenLayers.Format.GML(this.options ? this.options : {}).read(data) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + result = data │ │ │ │ + } │ │ │ │ + return result │ │ │ │ + }, │ │ │ │ + read_msGMLOutput: function(data) { │ │ │ │ + var response = []; │ │ │ │ + var layerNodes = this.getSiblingNodesByTagCriteria(data, this.layerIdentifier); │ │ │ │ + if (layerNodes) { │ │ │ │ + for (var i = 0, len = layerNodes.length; i < len; ++i) { │ │ │ │ + var node = layerNodes[i]; │ │ │ │ + var layerName = node.nodeName; │ │ │ │ + if (node.prefix) { │ │ │ │ + layerName = layerName.split(":")[1] │ │ │ │ + } │ │ │ │ + var layerName = layerName.replace(this.layerIdentifier, ""); │ │ │ │ + var featureNodes = this.getSiblingNodesByTagCriteria(node, this.featureIdentifier); │ │ │ │ + if (featureNodes) { │ │ │ │ + for (var j = 0; j < featureNodes.length; j++) { │ │ │ │ + var featureNode = featureNodes[j]; │ │ │ │ + var geomInfo = this.parseGeometry(featureNode); │ │ │ │ + var attributes = this.parseAttributes(featureNode); │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geomInfo.geometry, attributes, null); │ │ │ │ + feature.bounds = geomInfo.bounds; │ │ │ │ + feature.type = layerName; │ │ │ │ + response.push(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return response │ │ │ │ + }, │ │ │ │ + read_FeatureInfoResponse: function(data) { │ │ │ │ + var response = []; │ │ │ │ + var featureNodes = this.getElementsByTagNameNS(data, "*", "FIELDS"); │ │ │ │ + for (var i = 0, len = featureNodes.length; i < len; i++) { │ │ │ │ + var featureNode = featureNodes[i]; │ │ │ │ + var geom = null; │ │ │ │ + var attributes = {}; │ │ │ │ + var j; │ │ │ │ + var jlen = featureNode.attributes.length; │ │ │ │ + if (jlen > 0) { │ │ │ │ + for (j = 0; j < jlen; j++) { │ │ │ │ + var attribute = featureNode.attributes[j]; │ │ │ │ + attributes[attribute.nodeName] = attribute.nodeValue │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + var nodes = featureNode.childNodes; │ │ │ │ + for (j = 0, jlen = nodes.length; j < jlen; ++j) { │ │ │ │ + var node = nodes[j]; │ │ │ │ + if (node.nodeType != 3) { │ │ │ │ + attributes[node.getAttribute("name")] = node.getAttribute("value") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + response.push(new OpenLayers.Feature.Vector(geom, attributes, null)) │ │ │ │ + } │ │ │ │ + return response │ │ │ │ + }, │ │ │ │ + getSiblingNodesByTagCriteria: function(node, criteria) { │ │ │ │ + var nodes = []; │ │ │ │ + var children, tagName, n, matchNodes, child; │ │ │ │ + if (node && node.hasChildNodes()) { │ │ │ │ + children = node.childNodes; │ │ │ │ + n = children.length; │ │ │ │ + for (var k = 0; k < n; k++) { │ │ │ │ + child = children[k]; │ │ │ │ + while (child && child.nodeType != 1) { │ │ │ │ + child = child.nextSibling; │ │ │ │ + k++ │ │ │ │ + } │ │ │ │ + tagName = child ? child.nodeName : ""; │ │ │ │ + if (tagName.length > 0 && tagName.indexOf(criteria) > -1) { │ │ │ │ + nodes.push(child) │ │ │ │ + } else { │ │ │ │ + matchNodes = this.getSiblingNodesByTagCriteria(child, criteria); │ │ │ │ + if (matchNodes.length > 0) { │ │ │ │ + nodes.length == 0 ? nodes = matchNodes : nodes.push(matchNodes) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return nodes │ │ │ │ + }, │ │ │ │ + parseAttributes: function(node) { │ │ │ │ + var attributes = {}; │ │ │ │ + if (node.nodeType == 1) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var n = children.length; │ │ │ │ + for (var i = 0; i < n; ++i) { │ │ │ │ + var child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + var grandchildren = child.childNodes; │ │ │ │ + var name = child.prefix ? child.nodeName.split(":")[1] : child.nodeName; │ │ │ │ + if (grandchildren.length == 0) { │ │ │ │ + attributes[name] = null │ │ │ │ + } else if (grandchildren.length == 1) { │ │ │ │ + var grandchild = grandchildren[0]; │ │ │ │ + if (grandchild.nodeType == 3 || grandchild.nodeType == 4) { │ │ │ │ + var value = grandchild.nodeValue.replace(this.regExes.trimSpace, ""); │ │ │ │ + attributes[name] = value │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return attributes │ │ │ │ + }, │ │ │ │ + parseGeometry: function(node) { │ │ │ │ + if (!this.gmlFormat) { │ │ │ │ + this.gmlFormat = new OpenLayers.Format.GML │ │ │ │ + } │ │ │ │ + var feature = this.gmlFormat.parseFeature(node); │ │ │ │ + var geometry, bounds = null; │ │ │ │ + if (feature) { │ │ │ │ + geometry = feature.geometry && feature.geometry.clone(); │ │ │ │ + bounds = feature.bounds && feature.bounds.clone(); │ │ │ │ + feature.destroy() │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + geometry: geometry, │ │ │ │ + bounds: bounds │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSGetFeatureInfo" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WFSDescribeFeatureType = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g │ │ │ │ + }, │ │ │ │ + namespaces: { │ │ │ │ + xsd: "http://www.w3.org/2001/XMLSchema" │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + xsd: { │ │ │ │ + schema: function(node, obj) { │ │ │ │ + var complexTypes = []; │ │ │ │ + var customTypes = {}; │ │ │ │ + var schema = { │ │ │ │ + complexTypes: complexTypes, │ │ │ │ + customTypes: customTypes │ │ │ │ + }; │ │ │ │ + var i, len; │ │ │ │ + this.readChildNodes(node, schema); │ │ │ │ + var attributes = node.attributes; │ │ │ │ + var attr, name; │ │ │ │ + for (i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ + attr = attributes[i]; │ │ │ │ + name = attr.name; │ │ │ │ + if (name.indexOf("xmlns") === 0) { │ │ │ │ + this.setNamespace(name.split(":")[1] || "", attr.value) │ │ │ │ + } else { │ │ │ │ + obj[name] = attr.value │ │ │ │ + } │ │ │ │ + } │ │ │ │ + obj.featureTypes = complexTypes; │ │ │ │ + obj.targetPrefix = this.namespaceAlias[obj.targetNamespace]; │ │ │ │ + var complexType, customType; │ │ │ │ + for (i = 0, len = complexTypes.length; i < len; ++i) { │ │ │ │ + complexType = complexTypes[i]; │ │ │ │ + customType = customTypes[complexType.typeName]; │ │ │ │ + if (customTypes[complexType.typeName]) { │ │ │ │ + complexType.typeName = customType.name │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + complexType: function(node, obj) { │ │ │ │ + var complexType = { │ │ │ │ + typeName: node.getAttribute("name") │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, complexType); │ │ │ │ + obj.complexTypes.push(complexType) │ │ │ │ + }, │ │ │ │ + complexContent: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + extension: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + sequence: function(node, obj) { │ │ │ │ + var sequence = { │ │ │ │ + elements: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, sequence); │ │ │ │ + obj.properties = sequence.elements │ │ │ │ + }, │ │ │ │ + element: function(node, obj) { │ │ │ │ + var type; │ │ │ │ + if (obj.elements) { │ │ │ │ + var element = {}; │ │ │ │ + var attributes = node.attributes; │ │ │ │ + var attr; │ │ │ │ + for (var i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ + attr = attributes[i]; │ │ │ │ + element[attr.name] = attr.value │ │ │ │ + } │ │ │ │ + type = element.type; │ │ │ │ + if (!type) { │ │ │ │ + type = {}; │ │ │ │ + this.readChildNodes(node, type); │ │ │ │ + element.restriction = type; │ │ │ │ + element.type = type.base │ │ │ │ + } │ │ │ │ + var fullType = type.base || type; │ │ │ │ + element.localType = fullType.split(":").pop(); │ │ │ │ + obj.elements.push(element); │ │ │ │ + this.readChildNodes(node, element) │ │ │ │ + } │ │ │ │ + if (obj.complexTypes) { │ │ │ │ + type = node.getAttribute("type"); │ │ │ │ + var localType = type.split(":").pop(); │ │ │ │ + obj.customTypes[localType] = { │ │ │ │ + name: node.getAttribute("name"), │ │ │ │ + type: type │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + annotation: function(node, obj) { │ │ │ │ + obj.annotation = {}; │ │ │ │ + this.readChildNodes(node, obj.annotation) │ │ │ │ + }, │ │ │ │ + appinfo: function(node, obj) { │ │ │ │ + if (!obj.appinfo) { │ │ │ │ + obj.appinfo = [] │ │ │ │ + } │ │ │ │ + obj.appinfo.push(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + documentation: function(node, obj) { │ │ │ │ + if (!obj.documentation) { │ │ │ │ + obj.documentation = [] │ │ │ │ + } │ │ │ │ + var value = this.getChildValue(node); │ │ │ │ + obj.documentation.push({ │ │ │ │ + lang: node.getAttribute("xml:lang"), │ │ │ │ + textContent: value.replace(this.regExes.trimSpace, "") │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + simpleType: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + restriction: function(node, obj) { │ │ │ │ + obj.base = node.getAttribute("base"); │ │ │ │ + this.readRestriction(node, obj) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + readRestriction: function(node, obj) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var child, nodeName, value; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + child = children[i]; │ │ │ │ + if (child.nodeType == 1) { │ │ │ │ + nodeName = child.nodeName.split(":").pop(); │ │ │ │ + value = child.getAttribute("value"); │ │ │ │ + if (!obj[nodeName]) { │ │ │ │ + obj[nodeName] = value │ │ │ │ + } else { │ │ │ │ + if (typeof obj[nodeName] == "string") { │ │ │ │ + obj[nodeName] = [obj[nodeName]] │ │ │ │ + } │ │ │ │ + obj[nodeName].push(value) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var schema = {}; │ │ │ │ + if (data.nodeName.split(":").pop() === "ExceptionReport") { │ │ │ │ + var parser = new OpenLayers.Format.OGCExceptionReport; │ │ │ │ + schema.error = parser.read(data) │ │ │ │ + } else { │ │ │ │ + this.readNode(data, schema) │ │ │ │ + } │ │ │ │ + return schema │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSDescribeFeatureType" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WCSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WFSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ + defaultVersion: "1.1.0", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + ol: "http://openlayers.org/context", │ │ │ │ + wmc: "http://www.opengis.net/context", │ │ │ │ + sld: "http://www.opengis.net/sld", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + schemaLocation: "", │ │ │ │ + getNamespacePrefix: function(uri) { │ │ │ │ + var prefix = null; │ │ │ │ + if (uri == null) { │ │ │ │ + prefix = this.namespaces[this.defaultPrefix] │ │ │ │ + } else { │ │ │ │ + for (prefix in this.namespaces) { │ │ │ │ + if (this.namespaces[prefix] == uri) { │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return prefix │ │ │ │ + }, │ │ │ │ + defaultPrefix: "wmc", │ │ │ │ + rootPrefix: null, │ │ │ │ + defaultStyleName: "", │ │ │ │ + defaultStyleTitle: "Default", │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + var root = data.documentElement; │ │ │ │ + this.rootPrefix = root.prefix; │ │ │ │ + var context = { │ │ │ │ + version: root.getAttribute("version") │ │ │ │ + }; │ │ │ │ + this.runChildNodes(context, root); │ │ │ │ + return context │ │ │ │ + }, │ │ │ │ + runChildNodes: function(obj, node) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var childNode, processor, prefix, local; │ │ │ │ + for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ + childNode = children[i]; │ │ │ │ + if (childNode.nodeType == 1) { │ │ │ │ + prefix = this.getNamespacePrefix(childNode.namespaceURI); │ │ │ │ + local = childNode.nodeName.split(":").pop(); │ │ │ │ + processor = this["read_" + prefix + "_" + local]; │ │ │ │ + if (processor) { │ │ │ │ + processor.apply(this, [obj, childNode]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_General: function(context, node) { │ │ │ │ + this.runChildNodes(context, node) │ │ │ │ + }, │ │ │ │ + read_wmc_BoundingBox: function(context, node) { │ │ │ │ + context.projection = node.getAttribute("SRS"); │ │ │ │ + context.bounds = new OpenLayers.Bounds(node.getAttribute("minx"), node.getAttribute("miny"), node.getAttribute("maxx"), node.getAttribute("maxy")) │ │ │ │ + }, │ │ │ │ + read_wmc_LayerList: function(context, node) { │ │ │ │ + context.layersContext = []; │ │ │ │ + this.runChildNodes(context, node) │ │ │ │ + }, │ │ │ │ + read_wmc_Layer: function(context, node) { │ │ │ │ + var layerContext = { │ │ │ │ + visibility: node.getAttribute("hidden") != "1", │ │ │ │ + queryable: node.getAttribute("queryable") == "1", │ │ │ │ + formats: [], │ │ │ │ + styles: [], │ │ │ │ + metadata: {} │ │ │ │ + }; │ │ │ │ + this.runChildNodes(layerContext, node); │ │ │ │ + context.layersContext.push(layerContext) │ │ │ │ + }, │ │ │ │ + read_wmc_Extension: function(obj, node) { │ │ │ │ + this.runChildNodes(obj, node) │ │ │ │ + }, │ │ │ │ + read_ol_units: function(layerContext, node) { │ │ │ │ + layerContext.units = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + read_ol_maxExtent: function(obj, node) { │ │ │ │ + var bounds = new OpenLayers.Bounds(node.getAttribute("minx"), node.getAttribute("miny"), node.getAttribute("maxx"), node.getAttribute("maxy")); │ │ │ │ + obj.maxExtent = bounds │ │ │ │ + }, │ │ │ │ + read_ol_transparent: function(layerContext, node) { │ │ │ │ + layerContext.transparent = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + read_ol_numZoomLevels: function(layerContext, node) { │ │ │ │ + layerContext.numZoomLevels = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + read_ol_opacity: function(layerContext, node) { │ │ │ │ + layerContext.opacity = parseFloat(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + read_ol_singleTile: function(layerContext, node) { │ │ │ │ + layerContext.singleTile = this.getChildValue(node) == "true" │ │ │ │ + }, │ │ │ │ + read_ol_tileSize: function(layerContext, node) { │ │ │ │ + var obj = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height") │ │ │ │ + }; │ │ │ │ + layerContext.tileSize = obj │ │ │ │ + }, │ │ │ │ + read_ol_isBaseLayer: function(layerContext, node) { │ │ │ │ + layerContext.isBaseLayer = this.getChildValue(node) == "true" │ │ │ │ + }, │ │ │ │ + read_ol_displayInLayerSwitcher: function(layerContext, node) { │ │ │ │ + layerContext.displayInLayerSwitcher = this.getChildValue(node) == "true" │ │ │ │ + }, │ │ │ │ + read_wmc_Server: function(layerContext, node) { │ │ │ │ + layerContext.version = node.getAttribute("version"); │ │ │ │ + layerContext.url = this.getOnlineResource_href(node); │ │ │ │ + layerContext.metadata.servertitle = node.getAttribute("title") │ │ │ │ + }, │ │ │ │ + read_wmc_FormatList: function(layerContext, node) { │ │ │ │ + this.runChildNodes(layerContext, node) │ │ │ │ + }, │ │ │ │ + read_wmc_Format: function(layerContext, node) { │ │ │ │ + var format = { │ │ │ │ + value: this.getChildValue(node) │ │ │ │ + }; │ │ │ │ + if (node.getAttribute("current") == "1") { │ │ │ │ + format.current = true │ │ │ │ + } │ │ │ │ + layerContext.formats.push(format) │ │ │ │ + }, │ │ │ │ + read_wmc_StyleList: function(layerContext, node) { │ │ │ │ + this.runChildNodes(layerContext, node) │ │ │ │ + }, │ │ │ │ + read_wmc_Style: function(layerContext, node) { │ │ │ │ + var style = {}; │ │ │ │ + this.runChildNodes(style, node); │ │ │ │ + if (node.getAttribute("current") == "1") { │ │ │ │ + style.current = true │ │ │ │ + } │ │ │ │ + layerContext.styles.push(style) │ │ │ │ + }, │ │ │ │ + read_wmc_SLD: function(style, node) { │ │ │ │ + this.runChildNodes(style, node) │ │ │ │ + }, │ │ │ │ + read_sld_StyledLayerDescriptor: function(sld, node) { │ │ │ │ + var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + sld.body = xml │ │ │ │ + }, │ │ │ │ + read_sld_FeatureTypeStyle: function(sld, node) { │ │ │ │ + var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ + sld.body = xml │ │ │ │ + }, │ │ │ │ + read_wmc_OnlineResource: function(obj, node) { │ │ │ │ + obj.href = this.getAttributeNS(node, this.namespaces.xlink, "href") │ │ │ │ + }, │ │ │ │ + read_wmc_Name: function(obj, node) { │ │ │ │ + var name = this.getChildValue(node); │ │ │ │ + if (name) { │ │ │ │ + obj.name = name │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_Title: function(obj, node) { │ │ │ │ + var title = this.getChildValue(node); │ │ │ │ + if (title) { │ │ │ │ + obj.title = title │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_MetadataURL: function(layerContext, node) { │ │ │ │ + layerContext.metadataURL = this.getOnlineResource_href(node) │ │ │ │ + }, │ │ │ │ + read_wmc_KeywordList: function(context, node) { │ │ │ │ + context.keywords = []; │ │ │ │ + this.runChildNodes(context.keywords, node) │ │ │ │ + }, │ │ │ │ + read_wmc_Keyword: function(keywords, node) { │ │ │ │ + keywords.push(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + read_wmc_Abstract: function(obj, node) { │ │ │ │ + var abst = this.getChildValue(node); │ │ │ │ + if (abst) { │ │ │ │ + obj["abstract"] = abst │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_LogoURL: function(context, node) { │ │ │ │ + context.logo = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height"), │ │ │ │ + format: node.getAttribute("format"), │ │ │ │ + href: this.getOnlineResource_href(node) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_DescriptionURL: function(context, node) { │ │ │ │ + context.descriptionURL = this.getOnlineResource_href(node) │ │ │ │ + }, │ │ │ │ + read_wmc_ContactInformation: function(obj, node) { │ │ │ │ + var contact = {}; │ │ │ │ + this.runChildNodes(contact, node); │ │ │ │ + obj.contactInformation = contact │ │ │ │ + }, │ │ │ │ + read_wmc_ContactPersonPrimary: function(contact, node) { │ │ │ │ + var personPrimary = {}; │ │ │ │ + this.runChildNodes(personPrimary, node); │ │ │ │ + contact.personPrimary = personPrimary │ │ │ │ + }, │ │ │ │ + read_wmc_ContactPerson: function(primaryPerson, node) { │ │ │ │ + var person = this.getChildValue(node); │ │ │ │ + if (person) { │ │ │ │ + primaryPerson.person = person │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_ContactOrganization: function(primaryPerson, node) { │ │ │ │ + var organization = this.getChildValue(node); │ │ │ │ + if (organization) { │ │ │ │ + primaryPerson.organization = organization │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_ContactPosition: function(contact, node) { │ │ │ │ + var position = this.getChildValue(node); │ │ │ │ + if (position) { │ │ │ │ + contact.position = position │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_ContactAddress: function(contact, node) { │ │ │ │ + var contactAddress = {}; │ │ │ │ + this.runChildNodes(contactAddress, node); │ │ │ │ + contact.contactAddress = contactAddress │ │ │ │ + }, │ │ │ │ + read_wmc_AddressType: function(contactAddress, node) { │ │ │ │ + var type = this.getChildValue(node); │ │ │ │ + if (type) { │ │ │ │ + contactAddress.type = type │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_Address: function(contactAddress, node) { │ │ │ │ + var address = this.getChildValue(node); │ │ │ │ + if (address) { │ │ │ │ + contactAddress.address = address │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_City: function(contactAddress, node) { │ │ │ │ + var city = this.getChildValue(node); │ │ │ │ + if (city) { │ │ │ │ + contactAddress.city = city │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_StateOrProvince: function(contactAddress, node) { │ │ │ │ + var stateOrProvince = this.getChildValue(node); │ │ │ │ + if (stateOrProvince) { │ │ │ │ + contactAddress.stateOrProvince = stateOrProvince │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_PostCode: function(contactAddress, node) { │ │ │ │ + var postcode = this.getChildValue(node); │ │ │ │ + if (postcode) { │ │ │ │ + contactAddress.postcode = postcode │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_Country: function(contactAddress, node) { │ │ │ │ + var country = this.getChildValue(node); │ │ │ │ + if (country) { │ │ │ │ + contactAddress.country = country │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_ContactVoiceTelephone: function(contact, node) { │ │ │ │ + var phone = this.getChildValue(node); │ │ │ │ + if (phone) { │ │ │ │ + contact.phone = phone │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_ContactFacsimileTelephone: function(contact, node) { │ │ │ │ + var fax = this.getChildValue(node); │ │ │ │ + if (fax) { │ │ │ │ + contact.fax = fax │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_ContactElectronicMailAddress: function(contact, node) { │ │ │ │ + var email = this.getChildValue(node); │ │ │ │ + if (email) { │ │ │ │ + contact.email = email │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_wmc_DataURL: function(layerContext, node) { │ │ │ │ + layerContext.dataURL = this.getOnlineResource_href(node) │ │ │ │ + }, │ │ │ │ + read_wmc_LegendURL: function(style, node) { │ │ │ │ + var legend = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height"), │ │ │ │ + format: node.getAttribute("format"), │ │ │ │ + href: this.getOnlineResource_href(node) │ │ │ │ + }; │ │ │ │ + style.legend = legend │ │ │ │ + }, │ │ │ │ + read_wmc_DimensionList: function(layerContext, node) { │ │ │ │ + layerContext.dimensions = {}; │ │ │ │ + this.runChildNodes(layerContext.dimensions, node) │ │ │ │ + }, │ │ │ │ + read_wmc_Dimension: function(dimensions, node) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + var dim = { │ │ │ │ + name: name, │ │ │ │ + units: node.getAttribute("units") || "", │ │ │ │ + unitSymbol: node.getAttribute("unitSymbol") || "", │ │ │ │ + userValue: node.getAttribute("userValue") || "", │ │ │ │ + nearestValue: node.getAttribute("nearestValue") === "1", │ │ │ │ + multipleValues: node.getAttribute("multipleValues") === "1", │ │ │ │ + current: node.getAttribute("current") === "1", │ │ │ │ + default: node.getAttribute("default") || "" │ │ │ │ + }; │ │ │ │ + var values = this.getChildValue(node); │ │ │ │ + dim.values = values.split(","); │ │ │ │ + dimensions[dim.name] = dim │ │ │ │ + }, │ │ │ │ + write: function(context, options) { │ │ │ │ + var root = this.createElementDefaultNS("ViewContext"); │ │ │ │ + this.setAttributes(root, { │ │ │ │ + version: this.VERSION, │ │ │ │ + id: options && typeof options.id == "string" ? options.id : OpenLayers.Util.createUniqueID("OpenLayers_Context_") │ │ │ │ + }); │ │ │ │ + this.setAttributeNS(root, this.namespaces.xsi, "xsi:schemaLocation", this.schemaLocation); │ │ │ │ + root.appendChild(this.write_wmc_General(context)); │ │ │ │ + root.appendChild(this.write_wmc_LayerList(context)); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root]) │ │ │ │ + }, │ │ │ │ + createElementDefaultNS: function(name, childValue, attributes) { │ │ │ │ + var node = this.createElementNS(this.namespaces[this.defaultPrefix], name); │ │ │ │ + if (childValue) { │ │ │ │ + node.appendChild(this.createTextNode(childValue)) │ │ │ │ + } │ │ │ │ + if (attributes) { │ │ │ │ + this.setAttributes(node, attributes) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + setAttributes: function(node, obj) { │ │ │ │ + var value; │ │ │ │ + for (var name in obj) { │ │ │ │ + value = obj[name].toString(); │ │ │ │ + if (value.match(/[A-Z]/)) { │ │ │ │ + this.setAttributeNS(node, null, name, value) │ │ │ │ + } else { │ │ │ │ + node.setAttribute(name, value) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + write_wmc_General: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("General"); │ │ │ │ + if (context.size) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("Window", null, { │ │ │ │ + width: context.size.w, │ │ │ │ + height: context.size.h │ │ │ │ + })) │ │ │ │ + } │ │ │ │ + var bounds = context.bounds; │ │ │ │ + node.appendChild(this.createElementDefaultNS("BoundingBox", null, { │ │ │ │ + minx: bounds.left.toPrecision(18), │ │ │ │ + miny: bounds.bottom.toPrecision(18), │ │ │ │ + maxx: bounds.right.toPrecision(18), │ │ │ │ + maxy: bounds.top.toPrecision(18), │ │ │ │ + SRS: context.projection │ │ │ │ + })); │ │ │ │ + node.appendChild(this.createElementDefaultNS("Title", context.title)); │ │ │ │ + if (context.keywords) { │ │ │ │ + node.appendChild(this.write_wmc_KeywordList(context.keywords)) │ │ │ │ + } │ │ │ │ + if (context["abstract"]) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("Abstract", context["abstract"])) │ │ │ │ + } │ │ │ │ + if (context.logo) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("LogoURL", context.logo.href, context.logo)) │ │ │ │ + } │ │ │ │ + if (context.descriptionURL) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("DescriptionURL", context.descriptionURL)) │ │ │ │ + } │ │ │ │ + if (context.contactInformation) { │ │ │ │ + node.appendChild(this.write_wmc_ContactInformation(context.contactInformation)) │ │ │ │ + } │ │ │ │ + node.appendChild(this.write_ol_MapExtension(context)); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_KeywordList: function(keywords) { │ │ │ │ + var node = this.createElementDefaultNS("KeywordList"); │ │ │ │ + for (var i = 0, len = keywords.length; i < len; i++) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("Keyword", keywords[i])) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_ContactInformation: function(contact) { │ │ │ │ + var node = this.createElementDefaultNS("ContactInformation"); │ │ │ │ + if (contact.personPrimary) { │ │ │ │ + node.appendChild(this.write_wmc_ContactPersonPrimary(contact.personPrimary)) │ │ │ │ + } │ │ │ │ + if (contact.position) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("ContactPosition", contact.position)) │ │ │ │ + } │ │ │ │ + if (contact.contactAddress) { │ │ │ │ + node.appendChild(this.write_wmc_ContactAddress(contact.contactAddress)) │ │ │ │ + } │ │ │ │ + if (contact.phone) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("ContactVoiceTelephone", contact.phone)) │ │ │ │ + } │ │ │ │ + if (contact.fax) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("ContactFacsimileTelephone", contact.fax)) │ │ │ │ + } │ │ │ │ + if (contact.email) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("ContactElectronicMailAddress", contact.email)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_ContactPersonPrimary: function(personPrimary) { │ │ │ │ + var node = this.createElementDefaultNS("ContactPersonPrimary"); │ │ │ │ + if (personPrimary.person) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("ContactPerson", personPrimary.person)) │ │ │ │ + } │ │ │ │ + if (personPrimary.organization) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("ContactOrganization", personPrimary.organization)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_ContactAddress: function(contactAddress) { │ │ │ │ + var node = this.createElementDefaultNS("ContactAddress"); │ │ │ │ + if (contactAddress.type) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("AddressType", contactAddress.type)) │ │ │ │ + } │ │ │ │ + if (contactAddress.address) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("Address", contactAddress.address)) │ │ │ │ + } │ │ │ │ + if (contactAddress.city) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("City", contactAddress.city)) │ │ │ │ + } │ │ │ │ + if (contactAddress.stateOrProvince) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("StateOrProvince", contactAddress.stateOrProvince)) │ │ │ │ + } │ │ │ │ + if (contactAddress.postcode) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("PostCode", contactAddress.postcode)) │ │ │ │ + } │ │ │ │ + if (contactAddress.country) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("Country", contactAddress.country)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_ol_MapExtension: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("Extension"); │ │ │ │ + var bounds = context.maxExtent; │ │ │ │ + if (bounds) { │ │ │ │ + var maxExtent = this.createElementNS(this.namespaces.ol, "ol:maxExtent"); │ │ │ │ + this.setAttributes(maxExtent, { │ │ │ │ + minx: bounds.left.toPrecision(18), │ │ │ │ + miny: bounds.bottom.toPrecision(18), │ │ │ │ + maxx: bounds.right.toPrecision(18), │ │ │ │ + maxy: bounds.top.toPrecision(18) │ │ │ │ + }); │ │ │ │ + node.appendChild(maxExtent) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_LayerList: function(context) { │ │ │ │ + var list = this.createElementDefaultNS("LayerList"); │ │ │ │ + for (var i = 0, len = context.layersContext.length; i < len; ++i) { │ │ │ │ + list.appendChild(this.write_wmc_Layer(context.layersContext[i])) │ │ │ │ + } │ │ │ │ + return list │ │ │ │ + }, │ │ │ │ + write_wmc_Layer: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("Layer", null, { │ │ │ │ + queryable: context.queryable ? "1" : "0", │ │ │ │ + hidden: context.visibility ? "0" : "1" │ │ │ │ + }); │ │ │ │ + node.appendChild(this.write_wmc_Server(context)); │ │ │ │ + node.appendChild(this.createElementDefaultNS("Name", context.name)); │ │ │ │ + node.appendChild(this.createElementDefaultNS("Title", context.title)); │ │ │ │ + if (context["abstract"]) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("Abstract", context["abstract"])) │ │ │ │ + } │ │ │ │ + if (context.dataURL) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("DataURL", context.dataURL)) │ │ │ │ + } │ │ │ │ + if (context.metadataURL) { │ │ │ │ + node.appendChild(this.write_wmc_URLType("MetadataURL", context.metadataURL)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_LayerExtension: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("Extension"); │ │ │ │ + var bounds = context.maxExtent; │ │ │ │ + var maxExtent = this.createElementNS(this.namespaces.ol, "ol:maxExtent"); │ │ │ │ + this.setAttributes(maxExtent, { │ │ │ │ + minx: bounds.left.toPrecision(18), │ │ │ │ + miny: bounds.bottom.toPrecision(18), │ │ │ │ + maxx: bounds.right.toPrecision(18), │ │ │ │ + maxy: bounds.top.toPrecision(18) │ │ │ │ + }); │ │ │ │ + node.appendChild(maxExtent); │ │ │ │ + if (context.tileSize && !context.singleTile) { │ │ │ │ + var size = this.createElementNS(this.namespaces.ol, "ol:tileSize"); │ │ │ │ + this.setAttributes(size, context.tileSize); │ │ │ │ + node.appendChild(size) │ │ │ │ + } │ │ │ │ + var properties = ["transparent", "numZoomLevels", "units", "isBaseLayer", "opacity", "displayInLayerSwitcher", "singleTile"]; │ │ │ │ + var child; │ │ │ │ + for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ + child = this.createOLPropertyNode(context, properties[i]); │ │ │ │ + if (child) { │ │ │ │ + node.appendChild(child) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + createOLPropertyNode: function(obj, prop) { │ │ │ │ + var node = null; │ │ │ │ + if (obj[prop] != null) { │ │ │ │ + node = this.createElementNS(this.namespaces.ol, "ol:" + prop); │ │ │ │ + node.appendChild(this.createTextNode(obj[prop].toString())) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_Server: function(context) { │ │ │ │ + var server = context.server; │ │ │ │ + var node = this.createElementDefaultNS("Server"); │ │ │ │ + var attributes = { │ │ │ │ + service: "OGC:WMS", │ │ │ │ + version: server.version │ │ │ │ + }; │ │ │ │ + if (server.title) { │ │ │ │ + attributes.title = server.title │ │ │ │ + } │ │ │ │ + this.setAttributes(node, attributes); │ │ │ │ + node.appendChild(this.write_wmc_OnlineResource(server.url)); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_URLType: function(elName, url, attr) { │ │ │ │ + var node = this.createElementDefaultNS(elName); │ │ │ │ + node.appendChild(this.write_wmc_OnlineResource(url)); │ │ │ │ + if (attr) { │ │ │ │ + var optionalAttributes = ["width", "height", "format"]; │ │ │ │ + for (var i = 0; i < optionalAttributes.length; i++) { │ │ │ │ + if (optionalAttributes[i] in attr) { │ │ │ │ + node.setAttribute(optionalAttributes[i], attr[optionalAttributes[i]]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_DimensionList: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("DimensionList"); │ │ │ │ + var required_attributes = { │ │ │ │ + name: true, │ │ │ │ + units: true, │ │ │ │ + unitSymbol: true, │ │ │ │ + userValue: true │ │ │ │ + }; │ │ │ │ + for (var dim in context.dimensions) { │ │ │ │ + var attributes = {}; │ │ │ │ + var dimension = context.dimensions[dim]; │ │ │ │ + for (var name in dimension) { │ │ │ │ + if (typeof dimension[name] == "boolean") { │ │ │ │ + attributes[name] = Number(dimension[name]) │ │ │ │ + } else { │ │ │ │ + attributes[name] = dimension[name] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var values = ""; │ │ │ │ + if (attributes.values) { │ │ │ │ + values = attributes.values.join(","); │ │ │ │ + delete attributes.values │ │ │ │ + } │ │ │ │ + node.appendChild(this.createElementDefaultNS("Dimension", values, attributes)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_FormatList: function(context) { │ │ │ │ + var node = this.createElementDefaultNS("FormatList"); │ │ │ │ + for (var i = 0, len = context.formats.length; i < len; i++) { │ │ │ │ + var format = context.formats[i]; │ │ │ │ + node.appendChild(this.createElementDefaultNS("Format", format.value, format.current && format.current == true ? { │ │ │ │ + current: "1" │ │ │ │ + } : null)) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_StyleList: function(layer) { │ │ │ │ + var node = this.createElementDefaultNS("StyleList"); │ │ │ │ + var styles = layer.styles; │ │ │ │ + if (styles && OpenLayers.Util.isArray(styles)) { │ │ │ │ + var sld; │ │ │ │ + for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ + var s = styles[i]; │ │ │ │ + var style = this.createElementDefaultNS("Style", null, s.current && s.current == true ? { │ │ │ │ + current: "1" │ │ │ │ + } : null); │ │ │ │ + if (s.href) { │ │ │ │ + sld = this.createElementDefaultNS("SLD"); │ │ │ │ + if (s.name) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Name", s.name)) │ │ │ │ + } │ │ │ │ + if (s.title) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Title", s.title)) │ │ │ │ + } │ │ │ │ + if (s.legend) { │ │ │ │ + sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)) │ │ │ │ + } │ │ │ │ + var link = this.write_wmc_OnlineResource(s.href); │ │ │ │ + sld.appendChild(link); │ │ │ │ + style.appendChild(sld) │ │ │ │ + } else if (s.body) { │ │ │ │ + sld = this.createElementDefaultNS("SLD"); │ │ │ │ + if (s.name) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Name", s.name)) │ │ │ │ + } │ │ │ │ + if (s.title) { │ │ │ │ + sld.appendChild(this.createElementDefaultNS("Title", s.title)) │ │ │ │ + } │ │ │ │ + if (s.legend) { │ │ │ │ + sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)) │ │ │ │ + } │ │ │ │ + var doc = OpenLayers.Format.XML.prototype.read.apply(this, [s.body]); │ │ │ │ + var imported = doc.documentElement; │ │ │ │ + if (sld.ownerDocument && sld.ownerDocument.importNode) { │ │ │ │ + imported = sld.ownerDocument.importNode(imported, true) │ │ │ │ + } │ │ │ │ + sld.appendChild(imported); │ │ │ │ + style.appendChild(sld) │ │ │ │ + } else { │ │ │ │ + style.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ + style.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ + if (s["abstract"]) { │ │ │ │ + style.appendChild(this.createElementDefaultNS("Abstract", s["abstract"])) │ │ │ │ + } │ │ │ │ + if (s.legend) { │ │ │ │ + style.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + node.appendChild(style) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + write_wmc_OnlineResource: function(href) { │ │ │ │ + var node = this.createElementDefaultNS("OnlineResource"); │ │ │ │ + this.setAttributeNS(node, this.namespaces.xlink, "xlink:type", "simple"); │ │ │ │ + this.setAttributeNS(node, this.namespaces.xlink, "xlink:href", href); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + getOnlineResource_href: function(node) { │ │ │ │ + var object = {}; │ │ │ │ + var links = node.getElementsByTagName("OnlineResource"); │ │ │ │ + if (links.length > 0) { │ │ │ │ + this.read_wmc_OnlineResource(object, links[0]) │ │ │ │ + } │ │ │ │ + return object.href │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC.v1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMC.v1_0_0 = OpenLayers.Class(OpenLayers.Format.WMC.v1, { │ │ │ │ + VERSION: "1.0.0", │ │ │ │ + schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.0.0/context.xsd", │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.WMC.v1.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + read_wmc_SRS: function(layerContext, node) { │ │ │ │ + var srs = this.getChildValue(node); │ │ │ │ + if (typeof layerContext.projections != "object") { │ │ │ │ + layerContext.projections = {} │ │ │ │ + } │ │ │ │ + var values = srs.split(/ +/); │ │ │ │ + for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ + layerContext.projections[values[i]] = true │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + write_wmc_Layer: function(context) { │ │ │ │ + var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply(this, [context]); │ │ │ │ + if (context.srs) { │ │ │ │ + var projections = []; │ │ │ │ + for (var name in context.srs) { │ │ │ │ + projections.push(name) │ │ │ │ + } │ │ │ │ + node.appendChild(this.createElementDefaultNS("SRS", projections.join(" "))) │ │ │ │ + } │ │ │ │ + node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ + node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ + if (context.dimensions) { │ │ │ │ + node.appendChild(this.write_wmc_DimensionList(context)) │ │ │ │ + } │ │ │ │ + node.appendChild(this.write_wmc_LayerExtension(context)) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMC.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WMC.v1, { │ │ │ │ + VERSION: "1.1.0", │ │ │ │ + schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.1.0/context.xsd", │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.WMC.v1.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + read_sld_MinScaleDenominator: function(layerContext, node) { │ │ │ │ + var minScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ + if (minScaleDenominator > 0) { │ │ │ │ + layerContext.maxScale = minScaleDenominator │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + read_sld_MaxScaleDenominator: function(layerContext, node) { │ │ │ │ + layerContext.minScale = parseFloat(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + read_wmc_SRS: function(layerContext, node) { │ │ │ │ + if (!("srs" in layerContext)) { │ │ │ │ + layerContext.srs = {} │ │ │ │ + } │ │ │ │ + layerContext.srs[this.getChildValue(node)] = true │ │ │ │ + }, │ │ │ │ + write_wmc_Layer: function(context) { │ │ │ │ + var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply(this, [context]); │ │ │ │ + if (context.maxScale) { │ │ │ │ + var minSD = this.createElementNS(this.namespaces.sld, "sld:MinScaleDenominator"); │ │ │ │ + minSD.appendChild(this.createTextNode(context.maxScale.toPrecision(16))); │ │ │ │ + node.appendChild(minSD) │ │ │ │ + } │ │ │ │ + if (context.minScale) { │ │ │ │ + var maxSD = this.createElementNS(this.namespaces.sld, "sld:MaxScaleDenominator"); │ │ │ │ + maxSD.appendChild(this.createTextNode(context.minScale.toPrecision(16))); │ │ │ │ + node.appendChild(maxSD) │ │ │ │ + } │ │ │ │ + if (context.srs) { │ │ │ │ + for (var name in context.srs) { │ │ │ │ + node.appendChild(this.createElementDefaultNS("SRS", name)) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ + node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ + if (context.dimensions) { │ │ │ │ + node.appendChild(this.write_wmc_DimensionList(context)) │ │ │ │ + } │ │ │ │ + node.appendChild(this.write_wmc_LayerExtension(context)); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMC.v1_1_0" │ │ │ │ +}); │ │ │ │ OpenLayers.Format.GML.v2 = OpenLayers.Class(OpenLayers.Format.GML.Base, { │ │ │ │ schemaLocation: "http://www.opengis.net/gml http://schemas.opengis.net/gml/2.1.2/feature.xsd", │ │ │ │ initialize: function(options) { │ │ │ │ OpenLayers.Format.GML.Base.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ readers: { │ │ │ │ gml: OpenLayers.Util.applyDefaults({ │ │ │ │ @@ -20735,375 +24193,1710 @@ │ │ │ │ } │ │ │ │ node.appendChild(child) │ │ │ │ } │ │ │ │ return node │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Format.Filter.v1_0_0" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, { │ │ │ │ - namespaces: { │ │ │ │ - sld: "http://www.opengis.net/sld", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ +OpenLayers.Format.WFST.v1_0_0 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, OpenLayers.Format.WFST.v1, { │ │ │ │ + version: "1.0.0", │ │ │ │ + srsNameInQuery: false, │ │ │ │ + schemaLocations: { │ │ │ │ + wfs: "http://schemas.opengis.net/wfs/1.0.0/WFS-transaction.xsd" │ │ │ │ }, │ │ │ │ - defaultPrefix: "sld", │ │ │ │ - schemaLocation: null, │ │ │ │ - multipleSymbolizers: false, │ │ │ │ - featureTypeCounter: null, │ │ │ │ - defaultSymbolizer: { │ │ │ │ - fillColor: "#808080", │ │ │ │ - fillOpacity: 1, │ │ │ │ - strokeColor: "#000000", │ │ │ │ - strokeOpacity: 1, │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeDashstyle: "solid", │ │ │ │ - pointRadius: 3, │ │ │ │ - graphicName: "square" │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.Filter.v1_0_0.prototype.initialize.apply(this, [options]); │ │ │ │ + OpenLayers.Format.WFST.v1.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - read: function(data, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var sld = { │ │ │ │ - namedLayers: options.namedLayersAsArray === true ? [] : {} │ │ │ │ - }; │ │ │ │ - this.readChildNodes(data, sld); │ │ │ │ - return sld │ │ │ │ + readNode: function(node, obj, first) { │ │ │ │ + return OpenLayers.Format.GML.v2.prototype.readNode.apply(this, arguments) │ │ │ │ }, │ │ │ │ - readers: OpenLayers.Util.applyDefaults({ │ │ │ │ - sld: { │ │ │ │ - StyledLayerDescriptor: function(node, sld) { │ │ │ │ - sld.version = node.getAttribute("version"); │ │ │ │ - this.readChildNodes(node, sld) │ │ │ │ - }, │ │ │ │ - Name: function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Title: function(node, obj) { │ │ │ │ - obj.title = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Abstract: function(node, obj) { │ │ │ │ - obj.description = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - NamedLayer: function(node, sld) { │ │ │ │ - var layer = { │ │ │ │ - userStyles: [], │ │ │ │ - namedStyles: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, layer); │ │ │ │ - for (var i = 0, len = layer.userStyles.length; i < len; ++i) { │ │ │ │ - layer.userStyles[i].layerName = layer.name │ │ │ │ - } │ │ │ │ - if (OpenLayers.Util.isArray(sld.namedLayers)) { │ │ │ │ - sld.namedLayers.push(layer) │ │ │ │ - } else { │ │ │ │ - sld.namedLayers[layer.name] = layer │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - NamedStyle: function(node, layer) { │ │ │ │ - layer.namedStyles.push(this.getChildName(node.firstChild)) │ │ │ │ + readers: { │ │ │ │ + wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ + WFS_TransactionResponse: function(node, obj) { │ │ │ │ + obj.insertIds = []; │ │ │ │ + obj.success = false; │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ }, │ │ │ │ - UserStyle: function(node, layer) { │ │ │ │ + InsertResult: function(node, container) { │ │ │ │ var obj = { │ │ │ │ - defaultsPerSymbolizer: true, │ │ │ │ - rules: [] │ │ │ │ + fids: [] │ │ │ │ }; │ │ │ │ - this.featureTypeCounter = -1; │ │ │ │ this.readChildNodes(node, obj); │ │ │ │ - var style; │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - delete obj.defaultsPerSymbolizer; │ │ │ │ - style = new OpenLayers.Style2(obj) │ │ │ │ - } else { │ │ │ │ - style = new OpenLayers.Style(this.defaultSymbolizer, obj) │ │ │ │ - } │ │ │ │ - layer.userStyles.push(style) │ │ │ │ + container.insertIds = container.insertIds.concat(obj.fids) │ │ │ │ }, │ │ │ │ - IsDefault: function(node, style) { │ │ │ │ - if (this.getChildValue(node) == "1") { │ │ │ │ - style.isDefault = true │ │ │ │ - } │ │ │ │ + TransactionResult: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ }, │ │ │ │ - FeatureTypeStyle: function(node, style) { │ │ │ │ - ++this.featureTypeCounter; │ │ │ │ - var obj = { │ │ │ │ - rules: this.multipleSymbolizers ? style.rules : [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - if (!this.multipleSymbolizers) { │ │ │ │ - style.rules = obj.rules │ │ │ │ - } │ │ │ │ + Status: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ }, │ │ │ │ - Rule: function(node, obj) { │ │ │ │ - var config; │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config = { │ │ │ │ - symbolizers: [] │ │ │ │ + SUCCESS: function(node, obj) { │ │ │ │ + obj.success = true │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WFST.v1.prototype.readers["wfs"]), │ │ │ │ + gml: OpenLayers.Format.GML.v2.prototype.readers["gml"], │ │ │ │ + feature: OpenLayers.Format.GML.v2.prototype.readers["feature"], │ │ │ │ + ogc: OpenLayers.Format.Filter.v1_0_0.prototype.readers["ogc"] │ │ │ │ + }, │ │ │ │ + writers: { │ │ │ │ + wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ + Query: function(options) { │ │ │ │ + options = OpenLayers.Util.extend({ │ │ │ │ + featureNS: this.featureNS, │ │ │ │ + featurePrefix: this.featurePrefix, │ │ │ │ + featureType: this.featureType, │ │ │ │ + srsName: this.srsName, │ │ │ │ + srsNameInQuery: this.srsNameInQuery │ │ │ │ + }, options); │ │ │ │ + var prefix = options.featurePrefix; │ │ │ │ + var node = this.createElementNSPlus("wfs:Query", { │ │ │ │ + attributes: { │ │ │ │ + typeName: (prefix ? prefix + ":" : "") + options.featureType │ │ │ │ } │ │ │ │ + }); │ │ │ │ + if (options.srsNameInQuery && options.srsName) { │ │ │ │ + node.setAttribute("srsName", options.srsName) │ │ │ │ } │ │ │ │ - var rule = new OpenLayers.Rule(config); │ │ │ │ - this.readChildNodes(node, rule); │ │ │ │ - obj.rules.push(rule) │ │ │ │ - }, │ │ │ │ - ElseFilter: function(node, rule) { │ │ │ │ - rule.elseFilter = true │ │ │ │ - }, │ │ │ │ - MinScaleDenominator: function(node, rule) { │ │ │ │ - rule.minScaleDenominator = parseFloat(this.getChildValue(node)) │ │ │ │ + if (options.featureNS) { │ │ │ │ + node.setAttribute("xmlns:" + prefix, options.featureNS) │ │ │ │ + } │ │ │ │ + if (options.propertyNames) { │ │ │ │ + for (var i = 0, len = options.propertyNames.length; i < len; i++) { │ │ │ │ + this.writeNode("ogc:PropertyName", { │ │ │ │ + property: options.propertyNames[i] │ │ │ │ + }, node) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (options.filter) { │ │ │ │ + this.setFilterProperty(options.filter); │ │ │ │ + this.writeNode("ogc:Filter", options.filter, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WFST.v1.prototype.writers["wfs"]), │ │ │ │ + gml: OpenLayers.Format.GML.v2.prototype.writers["gml"], │ │ │ │ + feature: OpenLayers.Format.GML.v2.prototype.writers["feature"], │ │ │ │ + ogc: OpenLayers.Format.Filter.v1_0_0.prototype.writers["ogc"] │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFST.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WCSCapabilities.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + splitSpace: /\s+/ │ │ │ │ + }, │ │ │ │ + defaultPrefix: "wcs", │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + var raw = data; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WCSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ + namespaces: { │ │ │ │ + wcs: "http://www.opengis.net/wcs", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + ows: "http://www.opengis.net/ows" │ │ │ │ + }, │ │ │ │ + errorProperty: "service", │ │ │ │ + readers: { │ │ │ │ + wcs: { │ │ │ │ + WCS_Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ }, │ │ │ │ - MaxScaleDenominator: function(node, rule) { │ │ │ │ - rule.maxScaleDenominator = parseFloat(this.getChildValue(node)) │ │ │ │ + Service: function(node, obj) { │ │ │ │ + obj.service = {}; │ │ │ │ + this.readChildNodes(node, obj.service) │ │ │ │ }, │ │ │ │ - TextSymbolizer: function(node, rule) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push(new OpenLayers.Symbolizer.Text(config)) │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Text"] = OpenLayers.Util.applyDefaults(config, rule.symbolizer["Text"]) │ │ │ │ - } │ │ │ │ + name: function(node, service) { │ │ │ │ + service.name = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - LabelPlacement: function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + label: function(node, service) { │ │ │ │ + service.label = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - PointPlacement: function(node, symbolizer) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - config.labelRotation = config.rotation; │ │ │ │ - delete config.rotation; │ │ │ │ - var labelAlign, x = symbolizer.labelAnchorPointX, │ │ │ │ - y = symbolizer.labelAnchorPointY; │ │ │ │ - if (x <= 1 / 3) { │ │ │ │ - labelAlign = "l" │ │ │ │ - } else if (x > 1 / 3 && x < 2 / 3) { │ │ │ │ - labelAlign = "c" │ │ │ │ - } else if (x >= 2 / 3) { │ │ │ │ - labelAlign = "r" │ │ │ │ - } │ │ │ │ - if (y <= 1 / 3) { │ │ │ │ - labelAlign += "b" │ │ │ │ - } else if (y > 1 / 3 && y < 2 / 3) { │ │ │ │ - labelAlign += "m" │ │ │ │ - } else if (y >= 2 / 3) { │ │ │ │ - labelAlign += "t" │ │ │ │ - } │ │ │ │ - config.labelAlign = labelAlign; │ │ │ │ - OpenLayers.Util.applyDefaults(symbolizer, config) │ │ │ │ + keywords: function(node, service) { │ │ │ │ + service.keywords = []; │ │ │ │ + this.readChildNodes(node, service.keywords) │ │ │ │ }, │ │ │ │ - AnchorPoint: function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + keyword: function(node, keywords) { │ │ │ │ + keywords.push(this.getChildValue(node)) │ │ │ │ }, │ │ │ │ - AnchorPointX: function(node, symbolizer) { │ │ │ │ - var labelAnchorPointX = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (labelAnchorPointX) { │ │ │ │ - symbolizer.labelAnchorPointX = labelAnchorPointX │ │ │ │ - } │ │ │ │ + responsibleParty: function(node, service) { │ │ │ │ + service.responsibleParty = {}; │ │ │ │ + this.readChildNodes(node, service.responsibleParty) │ │ │ │ }, │ │ │ │ - AnchorPointY: function(node, symbolizer) { │ │ │ │ - var labelAnchorPointY = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (labelAnchorPointY) { │ │ │ │ - symbolizer.labelAnchorPointY = labelAnchorPointY │ │ │ │ - } │ │ │ │ + individualName: function(node, responsibleParty) { │ │ │ │ + responsibleParty.individualName = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Displacement: function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + organisationName: function(node, responsibleParty) { │ │ │ │ + responsibleParty.organisationName = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - DisplacementX: function(node, symbolizer) { │ │ │ │ - var labelXOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (labelXOffset) { │ │ │ │ - symbolizer.labelXOffset = labelXOffset │ │ │ │ - } │ │ │ │ + positionName: function(node, responsibleParty) { │ │ │ │ + responsibleParty.positionName = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - DisplacementY: function(node, symbolizer) { │ │ │ │ - var labelYOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (labelYOffset) { │ │ │ │ - symbolizer.labelYOffset = labelYOffset │ │ │ │ - } │ │ │ │ + contactInfo: function(node, responsibleParty) { │ │ │ │ + responsibleParty.contactInfo = {}; │ │ │ │ + this.readChildNodes(node, responsibleParty.contactInfo) │ │ │ │ }, │ │ │ │ - LinePlacement: function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + phone: function(node, contactInfo) { │ │ │ │ + contactInfo.phone = {}; │ │ │ │ + this.readChildNodes(node, contactInfo.phone) │ │ │ │ }, │ │ │ │ - PerpendicularOffset: function(node, symbolizer) { │ │ │ │ - var labelPerpendicularOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (labelPerpendicularOffset) { │ │ │ │ - symbolizer.labelPerpendicularOffset = labelPerpendicularOffset │ │ │ │ - } │ │ │ │ + voice: function(node, phone) { │ │ │ │ + phone.voice = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Label: function(node, symbolizer) { │ │ │ │ - var value = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (value) { │ │ │ │ - symbolizer.label = value │ │ │ │ - } │ │ │ │ + facsimile: function(node, phone) { │ │ │ │ + phone.facsimile = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Font: function(node, symbolizer) { │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + address: function(node, contactInfo) { │ │ │ │ + contactInfo.address = {}; │ │ │ │ + this.readChildNodes(node, contactInfo.address) │ │ │ │ }, │ │ │ │ - Halo: function(node, symbolizer) { │ │ │ │ - var obj = {}; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - symbolizer.haloRadius = obj.haloRadius; │ │ │ │ - symbolizer.haloColor = obj.fillColor; │ │ │ │ - symbolizer.haloOpacity = obj.fillOpacity │ │ │ │ + deliveryPoint: function(node, address) { │ │ │ │ + address.deliveryPoint = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Radius: function(node, symbolizer) { │ │ │ │ - var radius = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (radius != null) { │ │ │ │ - symbolizer.haloRadius = radius │ │ │ │ - } │ │ │ │ + city: function(node, address) { │ │ │ │ + address.city = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - RasterSymbolizer: function(node, rule) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push(new OpenLayers.Symbolizer.Raster(config)) │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Raster"] = OpenLayers.Util.applyDefaults(config, rule.symbolizer["Raster"]) │ │ │ │ - } │ │ │ │ + postalCode: function(node, address) { │ │ │ │ + address.postalCode = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Geometry: function(node, obj) { │ │ │ │ - obj.geometry = {}; │ │ │ │ - this.readChildNodes(node, obj.geometry) │ │ │ │ + country: function(node, address) { │ │ │ │ + address.country = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - ColorMap: function(node, symbolizer) { │ │ │ │ - symbolizer.colorMap = []; │ │ │ │ - this.readChildNodes(node, symbolizer.colorMap) │ │ │ │ + electronicMailAddress: function(node, address) { │ │ │ │ + address.electronicMailAddress = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - ColorMapEntry: function(node, colorMap) { │ │ │ │ - var q = node.getAttribute("quantity"); │ │ │ │ - var o = node.getAttribute("opacity"); │ │ │ │ - colorMap.push({ │ │ │ │ - color: node.getAttribute("color"), │ │ │ │ - quantity: q !== null ? parseFloat(q) : undefined, │ │ │ │ - label: node.getAttribute("label") || undefined, │ │ │ │ - opacity: o !== null ? parseFloat(o) : undefined │ │ │ │ - }) │ │ │ │ + fees: function(node, service) { │ │ │ │ + service.fees = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - LineSymbolizer: function(node, rule) { │ │ │ │ - var config = {}; │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push(new OpenLayers.Symbolizer.Line(config)) │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Line"] = OpenLayers.Util.applyDefaults(config, rule.symbolizer["Line"]) │ │ │ │ - } │ │ │ │ + accessConstraints: function(node, service) { │ │ │ │ + service.accessConstraints = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - PolygonSymbolizer: function(node, rule) { │ │ │ │ - var config = { │ │ │ │ - fill: false, │ │ │ │ - stroke: false │ │ │ │ - }; │ │ │ │ - if (!this.multipleSymbolizers) { │ │ │ │ - config = rule.symbolizer["Polygon"] || config │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push(new OpenLayers.Symbolizer.Polygon(config)) │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Polygon"] = config │ │ │ │ - } │ │ │ │ + ContentMetadata: function(node, obj) { │ │ │ │ + obj.contentMetadata = []; │ │ │ │ + this.readChildNodes(node, obj.contentMetadata) │ │ │ │ }, │ │ │ │ - PointSymbolizer: function(node, rule) { │ │ │ │ - var config = { │ │ │ │ - fill: false, │ │ │ │ - stroke: false, │ │ │ │ - graphic: false │ │ │ │ - }; │ │ │ │ - if (!this.multipleSymbolizers) { │ │ │ │ - config = rule.symbolizer["Point"] || config │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, config); │ │ │ │ - if (this.multipleSymbolizers) { │ │ │ │ - config.zIndex = this.featureTypeCounter; │ │ │ │ - rule.symbolizers.push(new OpenLayers.Symbolizer.Point(config)) │ │ │ │ - } else { │ │ │ │ - rule.symbolizer["Point"] = config │ │ │ │ - } │ │ │ │ + CoverageOfferingBrief: function(node, contentMetadata) { │ │ │ │ + var coverageOfferingBrief = {}; │ │ │ │ + this.readChildNodes(node, coverageOfferingBrief); │ │ │ │ + contentMetadata.push(coverageOfferingBrief) │ │ │ │ }, │ │ │ │ - Stroke: function(node, symbolizer) { │ │ │ │ - symbolizer.stroke = true; │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + name: function(node, coverageOfferingBrief) { │ │ │ │ + coverageOfferingBrief.name = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Fill: function(node, symbolizer) { │ │ │ │ - symbolizer.fill = true; │ │ │ │ - this.readChildNodes(node, symbolizer) │ │ │ │ + label: function(node, coverageOfferingBrief) { │ │ │ │ + coverageOfferingBrief.label = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - CssParameter: function(node, symbolizer) { │ │ │ │ - var cssProperty = node.getAttribute("name"); │ │ │ │ - var symProperty = this.cssMap[cssProperty]; │ │ │ │ - if (symbolizer.label) { │ │ │ │ - if (cssProperty === "fill") { │ │ │ │ - symProperty = "fontColor" │ │ │ │ - } else if (cssProperty === "fill-opacity") { │ │ │ │ - symProperty = "fontOpacity" │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (symProperty) { │ │ │ │ - var value = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (value) { │ │ │ │ - symbolizer[symProperty] = value │ │ │ │ - } │ │ │ │ + lonLatEnvelope: function(node, coverageOfferingBrief) { │ │ │ │ + var nodeList = this.getElementsByTagNameNS(node, "http://www.opengis.net/gml", "pos"); │ │ │ │ + if (nodeList.length == 2) { │ │ │ │ + var min = {}; │ │ │ │ + var max = {}; │ │ │ │ + OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[0], min]); │ │ │ │ + OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[1], max]); │ │ │ │ + coverageOfferingBrief.lonLatEnvelope = {}; │ │ │ │ + coverageOfferingBrief.lonLatEnvelope.srsName = node.getAttribute("srsName"); │ │ │ │ + coverageOfferingBrief.lonLatEnvelope.min = min.points[0]; │ │ │ │ + coverageOfferingBrief.lonLatEnvelope.max = max.points[0] │ │ │ │ } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WCSCapabilities.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ + namespaces: { │ │ │ │ + wcs: "http://www.opengis.net/wcs/1.1", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + ows: "http://www.opengis.net/ows/1.1" │ │ │ │ + }, │ │ │ │ + errorProperty: "operationsMetadata", │ │ │ │ + readers: { │ │ │ │ + wcs: OpenLayers.Util.applyDefaults({ │ │ │ │ + Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ }, │ │ │ │ - Graphic: function(node, symbolizer) { │ │ │ │ - symbolizer.graphic = true; │ │ │ │ - var graphic = {}; │ │ │ │ - this.readChildNodes(node, graphic); │ │ │ │ - var properties = ["stroke", "strokeColor", "strokeWidth", "strokeOpacity", "strokeLinecap", "fill", "fillColor", "fillOpacity", "graphicName", "rotation", "graphicFormat"]; │ │ │ │ - var prop, value; │ │ │ │ - for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ - prop = properties[i]; │ │ │ │ - value = graphic[prop]; │ │ │ │ - if (value != undefined) { │ │ │ │ - symbolizer[prop] = value │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (graphic.opacity != undefined) { │ │ │ │ - symbolizer.graphicOpacity = graphic.opacity │ │ │ │ - } │ │ │ │ - if (graphic.size != undefined) { │ │ │ │ - var pointRadius = graphic.size / 2; │ │ │ │ - if (isNaN(pointRadius)) { │ │ │ │ - symbolizer.graphicWidth = graphic.size │ │ │ │ - } else { │ │ │ │ - symbolizer.pointRadius = graphic.size / 2 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (graphic.href != undefined) { │ │ │ │ - symbolizer.externalGraphic = graphic.href │ │ │ │ - } │ │ │ │ - if (graphic.rotation != undefined) { │ │ │ │ - symbolizer.rotation = graphic.rotation │ │ │ │ - } │ │ │ │ + Contents: function(node, request) { │ │ │ │ + request.contentMetadata = []; │ │ │ │ + this.readChildNodes(node, request.contentMetadata) │ │ │ │ }, │ │ │ │ - ExternalGraphic: function(node, graphic) { │ │ │ │ - this.readChildNodes(node, graphic) │ │ │ │ + CoverageSummary: function(node, contentMetadata) { │ │ │ │ + var coverageSummary = {}; │ │ │ │ + this.readChildNodes(node, coverageSummary); │ │ │ │ + contentMetadata.push(coverageSummary) │ │ │ │ }, │ │ │ │ - Mark: function(node, graphic) { │ │ │ │ - this.readChildNodes(node, graphic) │ │ │ │ + Identifier: function(node, coverageSummary) { │ │ │ │ + coverageSummary.identifier = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - WellKnownName: function(node, graphic) { │ │ │ │ - graphic.graphicName = this.getChildValue(node) │ │ │ │ + Title: function(node, coverageSummary) { │ │ │ │ + coverageSummary.title = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Opacity: function(node, obj) { │ │ │ │ - var opacity = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (opacity) { │ │ │ │ - obj.opacity = opacity │ │ │ │ - } │ │ │ │ + Abstract: function(node, coverageSummary) { │ │ │ │ + coverageSummary["abstract"] = this.getChildValue(node) │ │ │ │ }, │ │ │ │ - Size: function(node, obj) { │ │ │ │ - var size = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (size) { │ │ │ │ - obj.size = size │ │ │ │ + SupportedCRS: function(node, coverageSummary) { │ │ │ │ + var crs = this.getChildValue(node); │ │ │ │ + if (crs) { │ │ │ │ + if (!coverageSummary.supportedCRS) { │ │ │ │ + coverageSummary.supportedCRS = [] │ │ │ │ + } │ │ │ │ + coverageSummary.supportedCRS.push(crs) │ │ │ │ } │ │ │ │ }, │ │ │ │ - Rotation: function(node, obj) { │ │ │ │ + SupportedFormat: function(node, coverageSummary) { │ │ │ │ + var format = this.getChildValue(node); │ │ │ │ + if (format) { │ │ │ │ + if (!coverageSummary.supportedFormat) { │ │ │ │ + coverageSummary.supportedFormat = [] │ │ │ │ + } │ │ │ │ + coverageSummary.supportedFormat.push(format) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WCSCapabilities.v1.prototype.readers["wcs"]), │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_1_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.CSWGetDomain.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + csw: "http://www.opengis.net/cat/csw/2.0.2" │ │ │ │ + }, │ │ │ │ + defaultPrefix: "csw", │ │ │ │ + version: "2.0.2", │ │ │ │ + schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ + PropertyName: null, │ │ │ │ + ParameterName: null, │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var obj = {}; │ │ │ │ + this.readNode(data, obj); │ │ │ │ + return obj │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + csw: { │ │ │ │ + GetDomainResponse: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + DomainValues: function(node, obj) { │ │ │ │ + if (!OpenLayers.Util.isArray(obj.DomainValues)) { │ │ │ │ + obj.DomainValues = [] │ │ │ │ + } │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var domainValue = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + domainValue[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, domainValue); │ │ │ │ + obj.DomainValues.push(domainValue) │ │ │ │ + }, │ │ │ │ + PropertyName: function(node, obj) { │ │ │ │ + obj.PropertyName = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ParameterName: function(node, obj) { │ │ │ │ + obj.ParameterName = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ListOfValues: function(node, obj) { │ │ │ │ + if (!OpenLayers.Util.isArray(obj.ListOfValues)) { │ │ │ │ + obj.ListOfValues = [] │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, obj.ListOfValues) │ │ │ │ + }, │ │ │ │ + Value: function(node, obj) { │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var value = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + value[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + } │ │ │ │ + value.value = this.getChildValue(node); │ │ │ │ + obj.push({ │ │ │ │ + Value: value │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + ConceptualScheme: function(node, obj) { │ │ │ │ + obj.ConceptualScheme = {}; │ │ │ │ + this.readChildNodes(node, obj.ConceptualScheme) │ │ │ │ + }, │ │ │ │ + Name: function(node, obj) { │ │ │ │ + obj.Name = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Document: function(node, obj) { │ │ │ │ + obj.Document = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Authority: function(node, obj) { │ │ │ │ + obj.Authority = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + RangeOfValues: function(node, obj) { │ │ │ │ + obj.RangeOfValues = {}; │ │ │ │ + this.readChildNodes(node, obj.RangeOfValues) │ │ │ │ + }, │ │ │ │ + MinValue: function(node, obj) { │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var value = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + value[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + } │ │ │ │ + value.value = this.getChildValue(node); │ │ │ │ + obj.MinValue = value │ │ │ │ + }, │ │ │ │ + MaxValue: function(node, obj) { │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var value = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + value[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + } │ │ │ │ + value.value = this.getChildValue(node); │ │ │ │ + obj.MaxValue = value │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + write: function(options) { │ │ │ │ + var node = this.writeNode("csw:GetDomain", options); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [node]) │ │ │ │ + }, │ │ │ │ + writers: { │ │ │ │ + csw: { │ │ │ │ + GetDomain: function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:GetDomain", { │ │ │ │ + attributes: { │ │ │ │ + service: "CSW", │ │ │ │ + version: this.version │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.PropertyName || this.PropertyName) { │ │ │ │ + this.writeNode("csw:PropertyName", options.PropertyName || this.PropertyName, node) │ │ │ │ + } else if (options.ParameterName || this.ParameterName) { │ │ │ │ + this.writeNode("csw:ParameterName", options.ParameterName || this.ParameterName, node) │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, options); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + PropertyName: function(value) { │ │ │ │ + var node = this.createElementNSPlus("csw:PropertyName", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + ParameterName: function(value) { │ │ │ │ + var node = this.createElementNSPlus("csw:ParameterName", { │ │ │ │ + value: value │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.CSWGetDomain.v2_0_2" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.ArcXML.Features = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + read: function(data) { │ │ │ │ + var axl = new OpenLayers.Format.ArcXML; │ │ │ │ + var parsed = axl.read(data); │ │ │ │ + return parsed.features.feature │ │ │ │ + } │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WPSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink" │ │ │ │ + }, │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ + }, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + wps: { │ │ │ │ + Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + ProcessOfferings: function(node, obj) { │ │ │ │ + obj.processOfferings = {}; │ │ │ │ + this.readChildNodes(node, obj.processOfferings) │ │ │ │ + }, │ │ │ │ + Process: function(node, processOfferings) { │ │ │ │ + var processVersion = this.getAttributeNS(node, this.namespaces.wps, "processVersion"); │ │ │ │ + var process = { │ │ │ │ + processVersion: processVersion │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, process); │ │ │ │ + processOfferings[process.identifier] = process │ │ │ │ + }, │ │ │ │ + Languages: function(node, obj) { │ │ │ │ + obj.languages = []; │ │ │ │ + this.readChildNodes(node, obj.languages) │ │ │ │ + }, │ │ │ │ + Default: function(node, languages) { │ │ │ │ + var language = { │ │ │ │ + isDefault: true │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, language); │ │ │ │ + languages.push(language) │ │ │ │ + }, │ │ │ │ + Supported: function(node, languages) { │ │ │ │ + var language = {}; │ │ │ │ + this.readChildNodes(node, language); │ │ │ │ + languages.push(language) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WPSCapabilities.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WFSCapabilities.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + wfs: "http://www.opengis.net/wfs", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ + ows: "http://www.opengis.net/ows" │ │ │ │ + }, │ │ │ │ + errorProperty: "featureTypeList", │ │ │ │ + defaultPrefix: "wfs", │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + var raw = data; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + wfs: { │ │ │ │ + WFS_Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + FeatureTypeList: function(node, request) { │ │ │ │ + request.featureTypeList = { │ │ │ │ + featureTypes: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, request.featureTypeList) │ │ │ │ + }, │ │ │ │ + FeatureType: function(node, featureTypeList) { │ │ │ │ + var featureType = {}; │ │ │ │ + this.readChildNodes(node, featureType); │ │ │ │ + featureTypeList.featureTypes.push(featureType) │ │ │ │ + }, │ │ │ │ + Name: function(node, obj) { │ │ │ │ + var name = this.getChildValue(node); │ │ │ │ + if (name) { │ │ │ │ + var parts = name.split(":"); │ │ │ │ + obj.name = parts.pop(); │ │ │ │ + if (parts.length > 0) { │ │ │ │ + obj.featureNS = this.lookupNamespaceURI(node, parts[0]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Title: function(node, obj) { │ │ │ │ + var title = this.getChildValue(node); │ │ │ │ + if (title) { │ │ │ │ + obj.title = title │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Abstract: function(node, obj) { │ │ │ │ + var abst = this.getChildValue(node); │ │ │ │ + if (abst) { │ │ │ │ + obj["abstract"] = abst │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WFSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ + readers: { │ │ │ │ + wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ + Service: function(node, capabilities) { │ │ │ │ + capabilities.service = {}; │ │ │ │ + this.readChildNodes(node, capabilities.service) │ │ │ │ + }, │ │ │ │ + Fees: function(node, service) { │ │ │ │ + var fees = this.getChildValue(node); │ │ │ │ + if (fees && fees.toLowerCase() != "none") { │ │ │ │ + service.fees = fees │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + AccessConstraints: function(node, service) { │ │ │ │ + var constraints = this.getChildValue(node); │ │ │ │ + if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ + service.accessConstraints = constraints │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + OnlineResource: function(node, service) { │ │ │ │ + var onlineResource = this.getChildValue(node); │ │ │ │ + if (onlineResource && onlineResource.toLowerCase() != "none") { │ │ │ │ + service.onlineResource = onlineResource │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Keywords: function(node, service) { │ │ │ │ + var keywords = this.getChildValue(node); │ │ │ │ + if (keywords && keywords.toLowerCase() != "none") { │ │ │ │ + service.keywords = keywords.split(", ") │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Capability: function(node, capabilities) { │ │ │ │ + capabilities.capability = {}; │ │ │ │ + this.readChildNodes(node, capabilities.capability) │ │ │ │ + }, │ │ │ │ + Request: function(node, obj) { │ │ │ │ + obj.request = {}; │ │ │ │ + this.readChildNodes(node, obj.request) │ │ │ │ + }, │ │ │ │ + GetFeature: function(node, request) { │ │ │ │ + request.getfeature = { │ │ │ │ + href: {}, │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, request.getfeature) │ │ │ │ + }, │ │ │ │ + ResultFormat: function(node, obj) { │ │ │ │ + var children = node.childNodes; │ │ │ │ + var childNode; │ │ │ │ + for (var i = 0; i < children.length; i++) { │ │ │ │ + childNode = children[i]; │ │ │ │ + if (childNode.nodeType == 1) { │ │ │ │ + obj.formats.push(childNode.nodeName) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + DCPType: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + HTTP: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj.href) │ │ │ │ + }, │ │ │ │ + Get: function(node, obj) { │ │ │ │ + obj.get = node.getAttribute("onlineResource") │ │ │ │ + }, │ │ │ │ + Post: function(node, obj) { │ │ │ │ + obj.post = node.getAttribute("onlineResource") │ │ │ │ + }, │ │ │ │ + SRS: function(node, obj) { │ │ │ │ + var srs = this.getChildValue(node); │ │ │ │ + if (srs) { │ │ │ │ + obj.srs = srs │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WFSCapabilities.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ + DefaultSRS: function(node, obj) { │ │ │ │ + var defaultSRS = this.getChildValue(node); │ │ │ │ + if (defaultSRS) { │ │ │ │ + obj.srs = defaultSRS │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]), │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1.prototype.readers.ows │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_1_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMTSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.OWSCommon.v1_1_0, { │ │ │ │ + version: "1.0.0", │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + wmts: "http://www.opengis.net/wmts/1.0", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink" │ │ │ │ + }, │ │ │ │ + yx: null, │ │ │ │ + defaultPrefix: "wmts", │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options; │ │ │ │ + var yx = OpenLayers.Util.extend({}, OpenLayers.Format.WMTSCapabilities.prototype.yx); │ │ │ │ + this.yx = OpenLayers.Util.extend(yx, this.yx) │ │ │ │ + }, │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + capabilities.version = this.version; │ │ │ │ + return capabilities │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + wmts: { │ │ │ │ + Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + Contents: function(node, obj) { │ │ │ │ + obj.contents = {}; │ │ │ │ + obj.contents.layers = []; │ │ │ │ + obj.contents.tileMatrixSets = {}; │ │ │ │ + this.readChildNodes(node, obj.contents) │ │ │ │ + }, │ │ │ │ + Layer: function(node, obj) { │ │ │ │ + var layer = { │ │ │ │ + styles: [], │ │ │ │ + formats: [], │ │ │ │ + dimensions: [], │ │ │ │ + tileMatrixSetLinks: [] │ │ │ │ + }; │ │ │ │ + layer.layers = []; │ │ │ │ + this.readChildNodes(node, layer); │ │ │ │ + obj.layers.push(layer) │ │ │ │ + }, │ │ │ │ + Style: function(node, obj) { │ │ │ │ + var style = {}; │ │ │ │ + style.isDefault = node.getAttribute("isDefault") === "true"; │ │ │ │ + this.readChildNodes(node, style); │ │ │ │ + obj.styles.push(style) │ │ │ │ + }, │ │ │ │ + Format: function(node, obj) { │ │ │ │ + obj.formats.push(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + TileMatrixSetLink: function(node, obj) { │ │ │ │ + var tileMatrixSetLink = {}; │ │ │ │ + this.readChildNodes(node, tileMatrixSetLink); │ │ │ │ + obj.tileMatrixSetLinks.push(tileMatrixSetLink) │ │ │ │ + }, │ │ │ │ + TileMatrixSet: function(node, obj) { │ │ │ │ + if (obj.layers) { │ │ │ │ + var tileMatrixSet = { │ │ │ │ + matrixIds: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, tileMatrixSet); │ │ │ │ + obj.tileMatrixSets[tileMatrixSet.identifier] = tileMatrixSet │ │ │ │ + } else { │ │ │ │ + obj.tileMatrixSet = this.getChildValue(node) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + TileMatrix: function(node, obj) { │ │ │ │ + var tileMatrix = { │ │ │ │ + supportedCRS: obj.supportedCRS │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, tileMatrix); │ │ │ │ + obj.matrixIds.push(tileMatrix) │ │ │ │ + }, │ │ │ │ + ScaleDenominator: function(node, obj) { │ │ │ │ + obj.scaleDenominator = parseFloat(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + TopLeftCorner: function(node, obj) { │ │ │ │ + var topLeftCorner = this.getChildValue(node); │ │ │ │ + var coords = topLeftCorner.split(" "); │ │ │ │ + var yx; │ │ │ │ + if (obj.supportedCRS) { │ │ │ │ + var crs = obj.supportedCRS.replace(/urn:ogc:def:crs:(\w+):.+:(\w+)$/, "urn:ogc:def:crs:$1::$2"); │ │ │ │ + yx = !!this.yx[crs] │ │ │ │ + } │ │ │ │ + if (yx) { │ │ │ │ + obj.topLeftCorner = new OpenLayers.LonLat(coords[1], coords[0]) │ │ │ │ + } else { │ │ │ │ + obj.topLeftCorner = new OpenLayers.LonLat(coords[0], coords[1]) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + TileWidth: function(node, obj) { │ │ │ │ + obj.tileWidth = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + TileHeight: function(node, obj) { │ │ │ │ + obj.tileHeight = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + MatrixWidth: function(node, obj) { │ │ │ │ + obj.matrixWidth = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + MatrixHeight: function(node, obj) { │ │ │ │ + obj.matrixHeight = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + ResourceURL: function(node, obj) { │ │ │ │ + obj.resourceUrl = obj.resourceUrl || {}; │ │ │ │ + var resourceType = node.getAttribute("resourceType"); │ │ │ │ + if (!obj.resourceUrls) { │ │ │ │ + obj.resourceUrls = [] │ │ │ │ + } │ │ │ │ + var resourceUrl = obj.resourceUrl[resourceType] = { │ │ │ │ + format: node.getAttribute("format"), │ │ │ │ + template: node.getAttribute("template"), │ │ │ │ + resourceType: resourceType │ │ │ │ + }; │ │ │ │ + obj.resourceUrls.push(resourceUrl) │ │ │ │ + }, │ │ │ │ + WSDL: function(node, obj) { │ │ │ │ + obj.wsdl = {}; │ │ │ │ + obj.wsdl.href = node.getAttribute("xlink:href") │ │ │ │ + }, │ │ │ │ + ServiceMetadataURL: function(node, obj) { │ │ │ │ + obj.serviceMetadataUrl = {}; │ │ │ │ + obj.serviceMetadataUrl.href = node.getAttribute("xlink:href") │ │ │ │ + }, │ │ │ │ + LegendURL: function(node, obj) { │ │ │ │ + obj.legend = {}; │ │ │ │ + obj.legend.href = node.getAttribute("xlink:href"); │ │ │ │ + obj.legend.format = node.getAttribute("format") │ │ │ │ + }, │ │ │ │ + Dimension: function(node, obj) { │ │ │ │ + var dimension = { │ │ │ │ + values: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, dimension); │ │ │ │ + obj.dimensions.push(dimension) │ │ │ │ + }, │ │ │ │ + Default: function(node, obj) { │ │ │ │ + obj["default"] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Value: function(node, obj) { │ │ │ │ + obj.values.push(this.getChildValue(node)) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMTSCapabilities.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + wms: "http://www.opengis.net/wms", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + defaultPrefix: "wms", │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + } │ │ │ │ + var raw = data; │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ + } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + if (capabilities.service === undefined) { │ │ │ │ + var parser = new OpenLayers.Format.OGCExceptionReport; │ │ │ │ + capabilities.error = parser.read(raw) │ │ │ │ + } │ │ │ │ + return capabilities │ │ │ │ + }, │ │ │ │ + readers: { │ │ │ │ + wms: { │ │ │ │ + Service: function(node, obj) { │ │ │ │ + obj.service = {}; │ │ │ │ + this.readChildNodes(node, obj.service) │ │ │ │ + }, │ │ │ │ + Name: function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Title: function(node, obj) { │ │ │ │ + obj.title = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Abstract: function(node, obj) { │ │ │ │ + obj["abstract"] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + BoundingBox: function(node, obj) { │ │ │ │ + var bbox = {}; │ │ │ │ + bbox.bbox = [parseFloat(node.getAttribute("minx")), parseFloat(node.getAttribute("miny")), parseFloat(node.getAttribute("maxx")), parseFloat(node.getAttribute("maxy"))]; │ │ │ │ + var res = { │ │ │ │ + x: parseFloat(node.getAttribute("resx")), │ │ │ │ + y: parseFloat(node.getAttribute("resy")) │ │ │ │ + }; │ │ │ │ + if (!(isNaN(res.x) && isNaN(res.y))) { │ │ │ │ + bbox.res = res │ │ │ │ + } │ │ │ │ + return bbox │ │ │ │ + }, │ │ │ │ + OnlineResource: function(node, obj) { │ │ │ │ + obj.href = this.getAttributeNS(node, this.namespaces.xlink, "href") │ │ │ │ + }, │ │ │ │ + ContactInformation: function(node, obj) { │ │ │ │ + obj.contactInformation = {}; │ │ │ │ + this.readChildNodes(node, obj.contactInformation) │ │ │ │ + }, │ │ │ │ + ContactPersonPrimary: function(node, obj) { │ │ │ │ + obj.personPrimary = {}; │ │ │ │ + this.readChildNodes(node, obj.personPrimary) │ │ │ │ + }, │ │ │ │ + ContactPerson: function(node, obj) { │ │ │ │ + obj.person = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ContactOrganization: function(node, obj) { │ │ │ │ + obj.organization = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ContactPosition: function(node, obj) { │ │ │ │ + obj.position = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ContactAddress: function(node, obj) { │ │ │ │ + obj.contactAddress = {}; │ │ │ │ + this.readChildNodes(node, obj.contactAddress) │ │ │ │ + }, │ │ │ │ + AddressType: function(node, obj) { │ │ │ │ + obj.type = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Address: function(node, obj) { │ │ │ │ + obj.address = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + City: function(node, obj) { │ │ │ │ + obj.city = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + StateOrProvince: function(node, obj) { │ │ │ │ + obj.stateOrProvince = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + PostCode: function(node, obj) { │ │ │ │ + obj.postcode = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Country: function(node, obj) { │ │ │ │ + obj.country = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ContactVoiceTelephone: function(node, obj) { │ │ │ │ + obj.phone = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ContactFacsimileTelephone: function(node, obj) { │ │ │ │ + obj.fax = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + ContactElectronicMailAddress: function(node, obj) { │ │ │ │ + obj.email = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Fees: function(node, obj) { │ │ │ │ + var fees = this.getChildValue(node); │ │ │ │ + if (fees && fees.toLowerCase() != "none") { │ │ │ │ + obj.fees = fees │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + AccessConstraints: function(node, obj) { │ │ │ │ + var constraints = this.getChildValue(node); │ │ │ │ + if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ + obj.accessConstraints = constraints │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Capability: function(node, obj) { │ │ │ │ + obj.capability = { │ │ │ │ + nestedLayers: [], │ │ │ │ + layers: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.capability) │ │ │ │ + }, │ │ │ │ + Request: function(node, obj) { │ │ │ │ + obj.request = {}; │ │ │ │ + this.readChildNodes(node, obj.request) │ │ │ │ + }, │ │ │ │ + GetCapabilities: function(node, obj) { │ │ │ │ + obj.getcapabilities = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getcapabilities) │ │ │ │ + }, │ │ │ │ + Format: function(node, obj) { │ │ │ │ + if (OpenLayers.Util.isArray(obj.formats)) { │ │ │ │ + obj.formats.push(this.getChildValue(node)) │ │ │ │ + } else { │ │ │ │ + obj.format = this.getChildValue(node) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + DCPType: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + HTTP: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + Get: function(node, obj) { │ │ │ │ + obj.get = {}; │ │ │ │ + this.readChildNodes(node, obj.get); │ │ │ │ + if (!obj.href) { │ │ │ │ + obj.href = obj.get.href │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Post: function(node, obj) { │ │ │ │ + obj.post = {}; │ │ │ │ + this.readChildNodes(node, obj.post); │ │ │ │ + if (!obj.href) { │ │ │ │ + obj.href = obj.get.href │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + GetMap: function(node, obj) { │ │ │ │ + obj.getmap = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getmap) │ │ │ │ + }, │ │ │ │ + GetFeatureInfo: function(node, obj) { │ │ │ │ + obj.getfeatureinfo = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getfeatureinfo) │ │ │ │ + }, │ │ │ │ + Exception: function(node, obj) { │ │ │ │ + obj.exception = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.exception) │ │ │ │ + }, │ │ │ │ + Layer: function(node, obj) { │ │ │ │ + var parentLayer, capability; │ │ │ │ + if (obj.capability) { │ │ │ │ + capability = obj.capability; │ │ │ │ + parentLayer = obj │ │ │ │ + } else { │ │ │ │ + capability = obj │ │ │ │ + } │ │ │ │ + var attrNode = node.getAttributeNode("queryable"); │ │ │ │ + var queryable = attrNode && attrNode.specified ? node.getAttribute("queryable") : null; │ │ │ │ + attrNode = node.getAttributeNode("cascaded"); │ │ │ │ + var cascaded = attrNode && attrNode.specified ? node.getAttribute("cascaded") : null; │ │ │ │ + attrNode = node.getAttributeNode("opaque"); │ │ │ │ + var opaque = attrNode && attrNode.specified ? node.getAttribute("opaque") : null; │ │ │ │ + var noSubsets = node.getAttribute("noSubsets"); │ │ │ │ + var fixedWidth = node.getAttribute("fixedWidth"); │ │ │ │ + var fixedHeight = node.getAttribute("fixedHeight"); │ │ │ │ + var parent = parentLayer || {}, │ │ │ │ + extend = OpenLayers.Util.extend; │ │ │ │ + var layer = { │ │ │ │ + nestedLayers: [], │ │ │ │ + styles: parentLayer ? [].concat(parentLayer.styles) : [], │ │ │ │ + srs: parentLayer ? extend({}, parent.srs) : {}, │ │ │ │ + metadataURLs: [], │ │ │ │ + bbox: parentLayer ? extend({}, parent.bbox) : {}, │ │ │ │ + llbbox: parent.llbbox, │ │ │ │ + dimensions: parentLayer ? extend({}, parent.dimensions) : {}, │ │ │ │ + authorityURLs: parentLayer ? extend({}, parent.authorityURLs) : {}, │ │ │ │ + identifiers: {}, │ │ │ │ + keywords: [], │ │ │ │ + queryable: queryable && queryable !== "" ? queryable === "1" || queryable === "true" : parent.queryable || false, │ │ │ │ + cascaded: cascaded !== null ? parseInt(cascaded) : parent.cascaded || 0, │ │ │ │ + opaque: opaque ? opaque === "1" || opaque === "true" : parent.opaque || false, │ │ │ │ + noSubsets: noSubsets !== null ? noSubsets === "1" || noSubsets === "true" : parent.noSubsets || false, │ │ │ │ + fixedWidth: fixedWidth != null ? parseInt(fixedWidth) : parent.fixedWidth || 0, │ │ │ │ + fixedHeight: fixedHeight != null ? parseInt(fixedHeight) : parent.fixedHeight || 0, │ │ │ │ + minScale: parent.minScale, │ │ │ │ + maxScale: parent.maxScale, │ │ │ │ + attribution: parent.attribution │ │ │ │ + }; │ │ │ │ + obj.nestedLayers.push(layer); │ │ │ │ + layer.capability = capability; │ │ │ │ + this.readChildNodes(node, layer); │ │ │ │ + delete layer.capability; │ │ │ │ + if (layer.name) { │ │ │ │ + var parts = layer.name.split(":"), │ │ │ │ + request = capability.request, │ │ │ │ + gfi = request.getfeatureinfo; │ │ │ │ + if (parts.length > 0) { │ │ │ │ + layer.prefix = parts[0] │ │ │ │ + } │ │ │ │ + capability.layers.push(layer); │ │ │ │ + if (layer.formats === undefined) { │ │ │ │ + layer.formats = request.getmap.formats │ │ │ │ + } │ │ │ │ + if (layer.infoFormats === undefined && gfi) { │ │ │ │ + layer.infoFormats = gfi.formats │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Attribution: function(node, obj) { │ │ │ │ + obj.attribution = {}; │ │ │ │ + this.readChildNodes(node, obj.attribution) │ │ │ │ + }, │ │ │ │ + LogoURL: function(node, obj) { │ │ │ │ + obj.logo = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height") │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.logo) │ │ │ │ + }, │ │ │ │ + Style: function(node, obj) { │ │ │ │ + var style = {}; │ │ │ │ + obj.styles.push(style); │ │ │ │ + this.readChildNodes(node, style) │ │ │ │ + }, │ │ │ │ + LegendURL: function(node, obj) { │ │ │ │ + var legend = { │ │ │ │ + width: node.getAttribute("width"), │ │ │ │ + height: node.getAttribute("height") │ │ │ │ + }; │ │ │ │ + obj.legend = legend; │ │ │ │ + this.readChildNodes(node, legend) │ │ │ │ + }, │ │ │ │ + MetadataURL: function(node, obj) { │ │ │ │ + var metadataURL = { │ │ │ │ + type: node.getAttribute("type") │ │ │ │ + }; │ │ │ │ + obj.metadataURLs.push(metadataURL); │ │ │ │ + this.readChildNodes(node, metadataURL) │ │ │ │ + }, │ │ │ │ + DataURL: function(node, obj) { │ │ │ │ + obj.dataURL = {}; │ │ │ │ + this.readChildNodes(node, obj.dataURL) │ │ │ │ + }, │ │ │ │ + FeatureListURL: function(node, obj) { │ │ │ │ + obj.featureListURL = {}; │ │ │ │ + this.readChildNodes(node, obj.featureListURL) │ │ │ │ + }, │ │ │ │ + AuthorityURL: function(node, obj) { │ │ │ │ + var name = node.getAttribute("name"); │ │ │ │ + var authority = {}; │ │ │ │ + this.readChildNodes(node, authority); │ │ │ │ + obj.authorityURLs[name] = authority.href │ │ │ │ + }, │ │ │ │ + Identifier: function(node, obj) { │ │ │ │ + var authority = node.getAttribute("authority"); │ │ │ │ + obj.identifiers[authority] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + KeywordList: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + SRS: function(node, obj) { │ │ │ │ + obj.srs[this.getChildValue(node)] = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ + readers: { │ │ │ │ + wms: OpenLayers.Util.applyDefaults({ │ │ │ │ + WMT_MS_Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + Keyword: function(node, obj) { │ │ │ │ + if (obj.keywords) { │ │ │ │ + obj.keywords.push(this.getChildValue(node)) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + DescribeLayer: function(node, obj) { │ │ │ │ + obj.describelayer = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.describelayer) │ │ │ │ + }, │ │ │ │ + GetLegendGraphic: function(node, obj) { │ │ │ │ + obj.getlegendgraphic = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getlegendgraphic) │ │ │ │ + }, │ │ │ │ + GetStyles: function(node, obj) { │ │ │ │ + obj.getstyles = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.getstyles) │ │ │ │ + }, │ │ │ │ + PutStyles: function(node, obj) { │ │ │ │ + obj.putstyles = { │ │ │ │ + formats: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.putstyles) │ │ │ │ + }, │ │ │ │ + UserDefinedSymbolization: function(node, obj) { │ │ │ │ + var userSymbols = { │ │ │ │ + supportSLD: parseInt(node.getAttribute("SupportSLD")) == 1, │ │ │ │ + userLayer: parseInt(node.getAttribute("UserLayer")) == 1, │ │ │ │ + userStyle: parseInt(node.getAttribute("UserStyle")) == 1, │ │ │ │ + remoteWFS: parseInt(node.getAttribute("RemoteWFS")) == 1 │ │ │ │ + }; │ │ │ │ + obj.userSymbols = userSymbols │ │ │ │ + }, │ │ │ │ + LatLonBoundingBox: function(node, obj) { │ │ │ │ + obj.llbbox = [parseFloat(node.getAttribute("minx")), parseFloat(node.getAttribute("miny")), parseFloat(node.getAttribute("maxx")), parseFloat(node.getAttribute("maxy"))] │ │ │ │ + }, │ │ │ │ + BoundingBox: function(node, obj) { │ │ │ │ + var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ + bbox.srs = node.getAttribute("SRS"); │ │ │ │ + obj.bbox[bbox.srs] = bbox │ │ │ │ + }, │ │ │ │ + ScaleHint: function(node, obj) { │ │ │ │ + var min = node.getAttribute("min"); │ │ │ │ + var max = node.getAttribute("max"); │ │ │ │ + var rad2 = Math.pow(2, .5); │ │ │ │ + var ipm = OpenLayers.INCHES_PER_UNIT["m"]; │ │ │ │ + if (min != 0) { │ │ │ │ + obj.maxScale = parseFloat((min / rad2 * ipm * OpenLayers.DOTS_PER_INCH).toPrecision(13)) │ │ │ │ + } │ │ │ │ + if (max != Number.POSITIVE_INFINITY) { │ │ │ │ + obj.minScale = parseFloat((max / rad2 * ipm * OpenLayers.DOTS_PER_INCH).toPrecision(13)) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Dimension: function(node, obj) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + var dim = { │ │ │ │ + name: name, │ │ │ │ + units: node.getAttribute("units"), │ │ │ │ + unitsymbol: node.getAttribute("unitSymbol") │ │ │ │ + }; │ │ │ │ + obj.dimensions[dim.name] = dim │ │ │ │ + }, │ │ │ │ + Extent: function(node, obj) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + if (name in obj["dimensions"]) { │ │ │ │ + var extent = obj.dimensions[name]; │ │ │ │ + extent.nearestVal = node.getAttribute("nearestValue") === "1"; │ │ │ │ + extent.multipleVal = node.getAttribute("multipleValues") === "1"; │ │ │ │ + extent.current = node.getAttribute("current") === "1"; │ │ │ │ + extent["default"] = node.getAttribute("default") || ""; │ │ │ │ + var values = this.getChildValue(node); │ │ │ │ + extent.values = values.split(",") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1_1 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ + version: "1.1.1", │ │ │ │ + readers: { │ │ │ │ + wms: OpenLayers.Util.applyDefaults({ │ │ │ │ + SRS: function(node, obj) { │ │ │ │ + obj.srs[this.getChildValue(node)] = true │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_1_1, { │ │ │ │ + version: "1.1.1", │ │ │ │ + profile: "WMSC", │ │ │ │ + readers: { │ │ │ │ + wms: OpenLayers.Util.applyDefaults({ │ │ │ │ + VendorSpecificCapabilities: function(node, obj) { │ │ │ │ + obj.vendorSpecific = { │ │ │ │ + tileSets: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj.vendorSpecific) │ │ │ │ + }, │ │ │ │ + TileSet: function(node, vendorSpecific) { │ │ │ │ + var tileset = { │ │ │ │ + srs: {}, │ │ │ │ + bbox: {}, │ │ │ │ + resolutions: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, tileset); │ │ │ │ + vendorSpecific.tileSets.push(tileset) │ │ │ │ + }, │ │ │ │ + Resolutions: function(node, tileset) { │ │ │ │ + var res = this.getChildValue(node).split(" "); │ │ │ │ + for (var i = 0, len = res.length; i < len; i++) { │ │ │ │ + if (res[i] != "") { │ │ │ │ + tileset.resolutions.push(parseFloat(res[i])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Width: function(node, tileset) { │ │ │ │ + tileset.width = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + Height: function(node, tileset) { │ │ │ │ + tileset.height = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + Layers: function(node, tileset) { │ │ │ │ + tileset.layers = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Styles: function(node, tileset) { │ │ │ │ + tileset.styles = this.getChildValue(node) │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1_1_1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ + version: "1.1.0", │ │ │ │ + readers: { │ │ │ │ + wms: OpenLayers.Util.applyDefaults({ │ │ │ │ + SRS: function(node, obj) { │ │ │ │ + var srs = this.getChildValue(node); │ │ │ │ + var values = srs.split(/ +/); │ │ │ │ + for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ + obj.srs[values[i]] = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_3 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ + readers: { │ │ │ │ + wms: OpenLayers.Util.applyDefaults({ │ │ │ │ + WMS_Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + LayerLimit: function(node, obj) { │ │ │ │ + obj.layerLimit = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + MaxWidth: function(node, obj) { │ │ │ │ + obj.maxWidth = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + MaxHeight: function(node, obj) { │ │ │ │ + obj.maxHeight = parseInt(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + BoundingBox: function(node, obj) { │ │ │ │ + var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ + bbox.srs = node.getAttribute("CRS"); │ │ │ │ + obj.bbox[bbox.srs] = bbox │ │ │ │ + }, │ │ │ │ + CRS: function(node, obj) { │ │ │ │ + this.readers.wms.SRS.apply(this, [node, obj]) │ │ │ │ + }, │ │ │ │ + EX_GeographicBoundingBox: function(node, obj) { │ │ │ │ + obj.llbbox = []; │ │ │ │ + this.readChildNodes(node, obj.llbbox) │ │ │ │ + }, │ │ │ │ + westBoundLongitude: function(node, obj) { │ │ │ │ + obj[0] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + eastBoundLongitude: function(node, obj) { │ │ │ │ + obj[2] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + southBoundLatitude: function(node, obj) { │ │ │ │ + obj[1] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + northBoundLatitude: function(node, obj) { │ │ │ │ + obj[3] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + MinScaleDenominator: function(node, obj) { │ │ │ │ + obj.maxScale = parseFloat(this.getChildValue(node)).toPrecision(16) │ │ │ │ + }, │ │ │ │ + MaxScaleDenominator: function(node, obj) { │ │ │ │ + obj.minScale = parseFloat(this.getChildValue(node)).toPrecision(16) │ │ │ │ + }, │ │ │ │ + Dimension: function(node, obj) { │ │ │ │ + var name = node.getAttribute("name").toLowerCase(); │ │ │ │ + var dim = { │ │ │ │ + name: name, │ │ │ │ + units: node.getAttribute("units"), │ │ │ │ + unitsymbol: node.getAttribute("unitSymbol"), │ │ │ │ + nearestVal: node.getAttribute("nearestValue") === "1", │ │ │ │ + multipleVal: node.getAttribute("multipleValues") === "1", │ │ │ │ + default: node.getAttribute("default") || "", │ │ │ │ + current: node.getAttribute("current") === "1", │ │ │ │ + values: this.getChildValue(node).split(",") │ │ │ │ + }; │ │ │ │ + obj.dimensions[dim.name] = dim │ │ │ │ + }, │ │ │ │ + Keyword: function(node, obj) { │ │ │ │ + var keyword = { │ │ │ │ + value: this.getChildValue(node), │ │ │ │ + vocabulary: node.getAttribute("vocabulary") │ │ │ │ + }; │ │ │ │ + if (obj.keywords) { │ │ │ │ + obj.keywords.push(keyword) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]), │ │ │ │ + sld: { │ │ │ │ + UserDefinedSymbolization: function(node, obj) { │ │ │ │ + this.readers.wms.UserDefinedSymbolization.apply(this, [node, obj]); │ │ │ │ + obj.userSymbols.inlineFeature = parseInt(node.getAttribute("InlineFeature")) == 1; │ │ │ │ + obj.userSymbols.remoteWCS = parseInt(node.getAttribute("RemoteWCS")) == 1 │ │ │ │ + }, │ │ │ │ + DescribeLayer: function(node, obj) { │ │ │ │ + this.readers.wms.DescribeLayer.apply(this, [node, obj]) │ │ │ │ + }, │ │ │ │ + GetLegendGraphic: function(node, obj) { │ │ │ │ + this.readers.wms.GetLegendGraphic.apply(this, [node, obj]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.WMSCapabilities.v1_3_0 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_3, { │ │ │ │ + version: "1.3.0", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, { │ │ │ │ + namespaces: { │ │ │ │ + sld: "http://www.opengis.net/sld", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + }, │ │ │ │ + defaultPrefix: "sld", │ │ │ │ + schemaLocation: null, │ │ │ │ + multipleSymbolizers: false, │ │ │ │ + featureTypeCounter: null, │ │ │ │ + defaultSymbolizer: { │ │ │ │ + fillColor: "#808080", │ │ │ │ + fillOpacity: 1, │ │ │ │ + strokeColor: "#000000", │ │ │ │ + strokeOpacity: 1, │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeDashstyle: "solid", │ │ │ │ + pointRadius: 3, │ │ │ │ + graphicName: "square" │ │ │ │ + }, │ │ │ │ + read: function(data, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var sld = { │ │ │ │ + namedLayers: options.namedLayersAsArray === true ? [] : {} │ │ │ │ + }; │ │ │ │ + this.readChildNodes(data, sld); │ │ │ │ + return sld │ │ │ │ + }, │ │ │ │ + readers: OpenLayers.Util.applyDefaults({ │ │ │ │ + sld: { │ │ │ │ + StyledLayerDescriptor: function(node, sld) { │ │ │ │ + sld.version = node.getAttribute("version"); │ │ │ │ + this.readChildNodes(node, sld) │ │ │ │ + }, │ │ │ │ + Name: function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Title: function(node, obj) { │ │ │ │ + obj.title = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Abstract: function(node, obj) { │ │ │ │ + obj.description = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + NamedLayer: function(node, sld) { │ │ │ │ + var layer = { │ │ │ │ + userStyles: [], │ │ │ │ + namedStyles: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, layer); │ │ │ │ + for (var i = 0, len = layer.userStyles.length; i < len; ++i) { │ │ │ │ + layer.userStyles[i].layerName = layer.name │ │ │ │ + } │ │ │ │ + if (OpenLayers.Util.isArray(sld.namedLayers)) { │ │ │ │ + sld.namedLayers.push(layer) │ │ │ │ + } else { │ │ │ │ + sld.namedLayers[layer.name] = layer │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + NamedStyle: function(node, layer) { │ │ │ │ + layer.namedStyles.push(this.getChildName(node.firstChild)) │ │ │ │ + }, │ │ │ │ + UserStyle: function(node, layer) { │ │ │ │ + var obj = { │ │ │ │ + defaultsPerSymbolizer: true, │ │ │ │ + rules: [] │ │ │ │ + }; │ │ │ │ + this.featureTypeCounter = -1; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + var style; │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + delete obj.defaultsPerSymbolizer; │ │ │ │ + style = new OpenLayers.Style2(obj) │ │ │ │ + } else { │ │ │ │ + style = new OpenLayers.Style(this.defaultSymbolizer, obj) │ │ │ │ + } │ │ │ │ + layer.userStyles.push(style) │ │ │ │ + }, │ │ │ │ + IsDefault: function(node, style) { │ │ │ │ + if (this.getChildValue(node) == "1") { │ │ │ │ + style.isDefault = true │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + FeatureTypeStyle: function(node, style) { │ │ │ │ + ++this.featureTypeCounter; │ │ │ │ + var obj = { │ │ │ │ + rules: this.multipleSymbolizers ? style.rules : [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + if (!this.multipleSymbolizers) { │ │ │ │ + style.rules = obj.rules │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Rule: function(node, obj) { │ │ │ │ + var config; │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config = { │ │ │ │ + symbolizers: [] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var rule = new OpenLayers.Rule(config); │ │ │ │ + this.readChildNodes(node, rule); │ │ │ │ + obj.rules.push(rule) │ │ │ │ + }, │ │ │ │ + ElseFilter: function(node, rule) { │ │ │ │ + rule.elseFilter = true │ │ │ │ + }, │ │ │ │ + MinScaleDenominator: function(node, rule) { │ │ │ │ + rule.minScaleDenominator = parseFloat(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + MaxScaleDenominator: function(node, rule) { │ │ │ │ + rule.maxScaleDenominator = parseFloat(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + TextSymbolizer: function(node, rule) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push(new OpenLayers.Symbolizer.Text(config)) │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Text"] = OpenLayers.Util.applyDefaults(config, rule.symbolizer["Text"]) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + LabelPlacement: function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + PointPlacement: function(node, symbolizer) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + config.labelRotation = config.rotation; │ │ │ │ + delete config.rotation; │ │ │ │ + var labelAlign, x = symbolizer.labelAnchorPointX, │ │ │ │ + y = symbolizer.labelAnchorPointY; │ │ │ │ + if (x <= 1 / 3) { │ │ │ │ + labelAlign = "l" │ │ │ │ + } else if (x > 1 / 3 && x < 2 / 3) { │ │ │ │ + labelAlign = "c" │ │ │ │ + } else if (x >= 2 / 3) { │ │ │ │ + labelAlign = "r" │ │ │ │ + } │ │ │ │ + if (y <= 1 / 3) { │ │ │ │ + labelAlign += "b" │ │ │ │ + } else if (y > 1 / 3 && y < 2 / 3) { │ │ │ │ + labelAlign += "m" │ │ │ │ + } else if (y >= 2 / 3) { │ │ │ │ + labelAlign += "t" │ │ │ │ + } │ │ │ │ + config.labelAlign = labelAlign; │ │ │ │ + OpenLayers.Util.applyDefaults(symbolizer, config) │ │ │ │ + }, │ │ │ │ + AnchorPoint: function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + AnchorPointX: function(node, symbolizer) { │ │ │ │ + var labelAnchorPointX = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (labelAnchorPointX) { │ │ │ │ + symbolizer.labelAnchorPointX = labelAnchorPointX │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + AnchorPointY: function(node, symbolizer) { │ │ │ │ + var labelAnchorPointY = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (labelAnchorPointY) { │ │ │ │ + symbolizer.labelAnchorPointY = labelAnchorPointY │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Displacement: function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + DisplacementX: function(node, symbolizer) { │ │ │ │ + var labelXOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (labelXOffset) { │ │ │ │ + symbolizer.labelXOffset = labelXOffset │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + DisplacementY: function(node, symbolizer) { │ │ │ │ + var labelYOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (labelYOffset) { │ │ │ │ + symbolizer.labelYOffset = labelYOffset │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + LinePlacement: function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + PerpendicularOffset: function(node, symbolizer) { │ │ │ │ + var labelPerpendicularOffset = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (labelPerpendicularOffset) { │ │ │ │ + symbolizer.labelPerpendicularOffset = labelPerpendicularOffset │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Label: function(node, symbolizer) { │ │ │ │ + var value = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (value) { │ │ │ │ + symbolizer.label = value │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Font: function(node, symbolizer) { │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + Halo: function(node, symbolizer) { │ │ │ │ + var obj = {}; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + symbolizer.haloRadius = obj.haloRadius; │ │ │ │ + symbolizer.haloColor = obj.fillColor; │ │ │ │ + symbolizer.haloOpacity = obj.fillOpacity │ │ │ │ + }, │ │ │ │ + Radius: function(node, symbolizer) { │ │ │ │ + var radius = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (radius != null) { │ │ │ │ + symbolizer.haloRadius = radius │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + RasterSymbolizer: function(node, rule) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push(new OpenLayers.Symbolizer.Raster(config)) │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Raster"] = OpenLayers.Util.applyDefaults(config, rule.symbolizer["Raster"]) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Geometry: function(node, obj) { │ │ │ │ + obj.geometry = {}; │ │ │ │ + this.readChildNodes(node, obj.geometry) │ │ │ │ + }, │ │ │ │ + ColorMap: function(node, symbolizer) { │ │ │ │ + symbolizer.colorMap = []; │ │ │ │ + this.readChildNodes(node, symbolizer.colorMap) │ │ │ │ + }, │ │ │ │ + ColorMapEntry: function(node, colorMap) { │ │ │ │ + var q = node.getAttribute("quantity"); │ │ │ │ + var o = node.getAttribute("opacity"); │ │ │ │ + colorMap.push({ │ │ │ │ + color: node.getAttribute("color"), │ │ │ │ + quantity: q !== null ? parseFloat(q) : undefined, │ │ │ │ + label: node.getAttribute("label") || undefined, │ │ │ │ + opacity: o !== null ? parseFloat(o) : undefined │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + LineSymbolizer: function(node, rule) { │ │ │ │ + var config = {}; │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push(new OpenLayers.Symbolizer.Line(config)) │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Line"] = OpenLayers.Util.applyDefaults(config, rule.symbolizer["Line"]) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + PolygonSymbolizer: function(node, rule) { │ │ │ │ + var config = { │ │ │ │ + fill: false, │ │ │ │ + stroke: false │ │ │ │ + }; │ │ │ │ + if (!this.multipleSymbolizers) { │ │ │ │ + config = rule.symbolizer["Polygon"] || config │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push(new OpenLayers.Symbolizer.Polygon(config)) │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Polygon"] = config │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + PointSymbolizer: function(node, rule) { │ │ │ │ + var config = { │ │ │ │ + fill: false, │ │ │ │ + stroke: false, │ │ │ │ + graphic: false │ │ │ │ + }; │ │ │ │ + if (!this.multipleSymbolizers) { │ │ │ │ + config = rule.symbolizer["Point"] || config │ │ │ │ + } │ │ │ │ + this.readChildNodes(node, config); │ │ │ │ + if (this.multipleSymbolizers) { │ │ │ │ + config.zIndex = this.featureTypeCounter; │ │ │ │ + rule.symbolizers.push(new OpenLayers.Symbolizer.Point(config)) │ │ │ │ + } else { │ │ │ │ + rule.symbolizer["Point"] = config │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Stroke: function(node, symbolizer) { │ │ │ │ + symbolizer.stroke = true; │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + Fill: function(node, symbolizer) { │ │ │ │ + symbolizer.fill = true; │ │ │ │ + this.readChildNodes(node, symbolizer) │ │ │ │ + }, │ │ │ │ + CssParameter: function(node, symbolizer) { │ │ │ │ + var cssProperty = node.getAttribute("name"); │ │ │ │ + var symProperty = this.cssMap[cssProperty]; │ │ │ │ + if (symbolizer.label) { │ │ │ │ + if (cssProperty === "fill") { │ │ │ │ + symProperty = "fontColor" │ │ │ │ + } else if (cssProperty === "fill-opacity") { │ │ │ │ + symProperty = "fontOpacity" │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (symProperty) { │ │ │ │ + var value = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (value) { │ │ │ │ + symbolizer[symProperty] = value │ │ │ │ + } │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Graphic: function(node, symbolizer) { │ │ │ │ + symbolizer.graphic = true; │ │ │ │ + var graphic = {}; │ │ │ │ + this.readChildNodes(node, graphic); │ │ │ │ + var properties = ["stroke", "strokeColor", "strokeWidth", "strokeOpacity", "strokeLinecap", "fill", "fillColor", "fillOpacity", "graphicName", "rotation", "graphicFormat"]; │ │ │ │ + var prop, value; │ │ │ │ + for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ + prop = properties[i]; │ │ │ │ + value = graphic[prop]; │ │ │ │ + if (value != undefined) { │ │ │ │ + symbolizer[prop] = value │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (graphic.opacity != undefined) { │ │ │ │ + symbolizer.graphicOpacity = graphic.opacity │ │ │ │ + } │ │ │ │ + if (graphic.size != undefined) { │ │ │ │ + var pointRadius = graphic.size / 2; │ │ │ │ + if (isNaN(pointRadius)) { │ │ │ │ + symbolizer.graphicWidth = graphic.size │ │ │ │ + } else { │ │ │ │ + symbolizer.pointRadius = graphic.size / 2 │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (graphic.href != undefined) { │ │ │ │ + symbolizer.externalGraphic = graphic.href │ │ │ │ + } │ │ │ │ + if (graphic.rotation != undefined) { │ │ │ │ + symbolizer.rotation = graphic.rotation │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + ExternalGraphic: function(node, graphic) { │ │ │ │ + this.readChildNodes(node, graphic) │ │ │ │ + }, │ │ │ │ + Mark: function(node, graphic) { │ │ │ │ + this.readChildNodes(node, graphic) │ │ │ │ + }, │ │ │ │ + WellKnownName: function(node, graphic) { │ │ │ │ + graphic.graphicName = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + Opacity: function(node, obj) { │ │ │ │ + var opacity = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (opacity) { │ │ │ │ + obj.opacity = opacity │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Size: function(node, obj) { │ │ │ │ + var size = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (size) { │ │ │ │ + obj.size = size │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Rotation: function(node, obj) { │ │ │ │ var rotation = this.readers.ogc._expression.call(this, node); │ │ │ │ if (rotation) { │ │ │ │ obj.rotation = rotation │ │ │ │ } │ │ │ │ }, │ │ │ │ OnlineResource: function(node, obj) { │ │ │ │ obj.href = this.getAttributeNS(node, this.namespaces.xlink, "href") │ │ │ │ @@ -21723,1126 +26516,1147 @@ │ │ │ │ CLASS_NAME: "OpenLayers.Format.SLD.v1" │ │ │ │ }); │ │ │ │ OpenLayers.Format.SLD.v1_0_0 = OpenLayers.Class(OpenLayers.Format.SLD.v1, { │ │ │ │ VERSION: "1.0.0", │ │ │ │ schemaLocation: "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd", │ │ │ │ CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.SLDSelect = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - clearOnDeactivate: false, │ │ │ │ - layers: null, │ │ │ │ - callbacks: null, │ │ │ │ - selectionSymbolizer: { │ │ │ │ - Polygon: { │ │ │ │ - fillColor: "#FF0000", │ │ │ │ - stroke: false │ │ │ │ - }, │ │ │ │ - Line: { │ │ │ │ - strokeColor: "#FF0000", │ │ │ │ - strokeWidth: 2 │ │ │ │ - }, │ │ │ │ - Point: { │ │ │ │ - graphicName: "square", │ │ │ │ - fillColor: "#FF0000", │ │ │ │ - pointRadius: 5 │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - layerOptions: null, │ │ │ │ - sketchStyle: null, │ │ │ │ - wfsCache: {}, │ │ │ │ - layerCache: {}, │ │ │ │ - initialize: function(handler, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.callbacks = OpenLayers.Util.extend({ │ │ │ │ - done: this.select, │ │ │ │ - click: this.select │ │ │ │ - }, this.callbacks); │ │ │ │ - this.handlerOptions = this.handlerOptions || {}; │ │ │ │ - this.layerOptions = OpenLayers.Util.applyDefaults(this.layerOptions, { │ │ │ │ - displayInLayerSwitcher: false, │ │ │ │ - tileOptions: { │ │ │ │ - maxGetUrlLength: 2048 │ │ │ │ +OpenLayers.Format.SLD.v1_0_0_GeoServer = OpenLayers.Class(OpenLayers.Format.SLD.v1_0_0, { │ │ │ │ + version: "1.0.0", │ │ │ │ + profile: "GeoServer", │ │ │ │ + readers: OpenLayers.Util.applyDefaults({ │ │ │ │ + sld: OpenLayers.Util.applyDefaults({ │ │ │ │ + Priority: function(node, obj) { │ │ │ │ + var value = this.readers.ogc._expression.call(this, node); │ │ │ │ + if (value) { │ │ │ │ + obj.priority = value │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + VendorOption: function(node, obj) { │ │ │ │ + if (!obj.vendorOptions) { │ │ │ │ + obj.vendorOptions = {} │ │ │ │ + } │ │ │ │ + obj.vendorOptions[node.getAttribute("name")] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + TextSymbolizer: function(node, rule) { │ │ │ │ + OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld.TextSymbolizer.apply(this, arguments); │ │ │ │ + var symbolizer = this.multipleSymbolizers ? rule.symbolizers[rule.symbolizers.length - 1] : rule.symbolizer["Text"]; │ │ │ │ + if (symbolizer.graphic === undefined) { │ │ │ │ + symbolizer.graphic = false │ │ │ │ + } │ │ │ │ } │ │ │ │ - }); │ │ │ │ - if (this.sketchStyle) { │ │ │ │ - this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(this.handlerOptions.layerOptions, { │ │ │ │ - styleMap: new OpenLayers.StyleMap({ │ │ │ │ - default: this.sketchStyle │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.readers["sld"]) │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.readers), │ │ │ │ + writers: OpenLayers.Util.applyDefaults({ │ │ │ │ + sld: OpenLayers.Util.applyDefaults({ │ │ │ │ + Priority: function(priority) { │ │ │ │ + return this.writers.sld._OGCExpression.call(this, "sld:Priority", priority) │ │ │ │ + }, │ │ │ │ + VendorOption: function(option) { │ │ │ │ + return this.createElementNSPlus("sld:VendorOption", { │ │ │ │ + attributes: { │ │ │ │ + name: option.name │ │ │ │ + }, │ │ │ │ + value: option.value │ │ │ │ }) │ │ │ │ - }) │ │ │ │ + }, │ │ │ │ + TextSymbolizer: function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["TextSymbolizer"].apply(this, arguments); │ │ │ │ + if (symbolizer.graphic !== false && (symbolizer.externalGraphic || symbolizer.graphicName)) { │ │ │ │ + this.writeNode("Graphic", symbolizer, node) │ │ │ │ + } │ │ │ │ + if ("priority" in symbolizer) { │ │ │ │ + this.writeNode("Priority", symbolizer.priority, node) │ │ │ │ + } │ │ │ │ + return this.addVendorOptions(node, symbolizer) │ │ │ │ + }, │ │ │ │ + PointSymbolizer: function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["PointSymbolizer"].apply(this, arguments); │ │ │ │ + return this.addVendorOptions(node, symbolizer) │ │ │ │ + }, │ │ │ │ + LineSymbolizer: function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["LineSymbolizer"].apply(this, arguments); │ │ │ │ + return this.addVendorOptions(node, symbolizer) │ │ │ │ + }, │ │ │ │ + PolygonSymbolizer: function(symbolizer) { │ │ │ │ + var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ + var node = writers["sld"]["PolygonSymbolizer"].apply(this, arguments); │ │ │ │ + return this.addVendorOptions(node, symbolizer) │ │ │ │ + } │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.writers["sld"]) │ │ │ │ + }, OpenLayers.Format.SLD.v1_0_0.prototype.writers), │ │ │ │ + addVendorOptions: function(node, symbolizer) { │ │ │ │ + var options = symbolizer.vendorOptions; │ │ │ │ + if (options) { │ │ │ │ + for (var key in symbolizer.vendorOptions) { │ │ │ │ + this.writeNode("VendorOption", { │ │ │ │ + name: key, │ │ │ │ + value: symbolizer.vendorOptions[key] │ │ │ │ + }, node) │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.handler = new handler(this, this.callbacks, this.handlerOptions) │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - for (var key in this.layerCache) { │ │ │ │ - delete this.layerCache[key] │ │ │ │ - } │ │ │ │ - for (var key in this.wfsCache) { │ │ │ │ - delete this.wfsCache[key] │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0_GeoServer" │ │ │ │ +}); │ │ │ │ +OpenLayers.Format.OWSContext.v0_3_1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + owc: "http://www.opengis.net/ows-context", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + kml: "http://www.opengis.net/kml/2.2", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + ows: "http://www.opengis.net/ows", │ │ │ │ + sld: "http://www.opengis.net/sld", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ }, │ │ │ │ - coupleLayerVisiblity: function(evt) { │ │ │ │ - this.setVisibility(evt.object.getVisibility()) │ │ │ │ + VERSION: "0.3.1", │ │ │ │ + schemaLocation: "http://www.opengis.net/ows-context http://www.ogcnetwork.net/schemas/owc/0.3.1/owsContext.xsd", │ │ │ │ + defaultPrefix: "owc", │ │ │ │ + extractAttributes: true, │ │ │ │ + xy: true, │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ }, │ │ │ │ - createSelectionLayer: function(source) { │ │ │ │ - var selectionLayer; │ │ │ │ - if (!this.layerCache[source.id]) { │ │ │ │ - selectionLayer = new OpenLayers.Layer.WMS(source.name, source.url, source.params, OpenLayers.Util.applyDefaults(this.layerOptions, source.getOptions())); │ │ │ │ - this.layerCache[source.id] = selectionLayer; │ │ │ │ - if (this.layerOptions.displayInLayerSwitcher === false) { │ │ │ │ - source.events.on({ │ │ │ │ - visibilitychanged: this.coupleLayerVisiblity, │ │ │ │ - scope: selectionLayer │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.map.addLayer(selectionLayer) │ │ │ │ - } else { │ │ │ │ - selectionLayer = this.layerCache[source.id] │ │ │ │ - } │ │ │ │ - return selectionLayer │ │ │ │ + featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ + featureType: "vector", │ │ │ │ + geometryName: "geometry", │ │ │ │ + nestingLayerLookup: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + OpenLayers.Format.GML.v2.prototype.setGeometryTypes.call(this) │ │ │ │ }, │ │ │ │ - createSLD: function(layer, filters, geometryAttributes) { │ │ │ │ - var sld = { │ │ │ │ - version: "1.0.0", │ │ │ │ - namedLayers: {} │ │ │ │ - }; │ │ │ │ - var layerNames = [layer.params.LAYERS].join(",").split(","); │ │ │ │ - for (var i = 0, len = layerNames.length; i < len; i++) { │ │ │ │ - var name = layerNames[i]; │ │ │ │ - sld.namedLayers[name] = { │ │ │ │ - name: name, │ │ │ │ - userStyles: [] │ │ │ │ - }; │ │ │ │ - var symbolizer = this.selectionSymbolizer; │ │ │ │ - var geometryAttribute = geometryAttributes[i]; │ │ │ │ - if (geometryAttribute.type.indexOf("Polygon") >= 0) { │ │ │ │ - symbolizer = { │ │ │ │ - Polygon: this.selectionSymbolizer["Polygon"] │ │ │ │ + setNestingPath: function(l) { │ │ │ │ + if (l.layersContext) { │ │ │ │ + for (var i = 0, len = l.layersContext.length; i < len; i++) { │ │ │ │ + var layerContext = l.layersContext[i]; │ │ │ │ + var nPath = []; │ │ │ │ + var nTitle = l.title || ""; │ │ │ │ + if (l.metadata && l.metadata.nestingPath) { │ │ │ │ + nPath = l.metadata.nestingPath.slice() │ │ │ │ } │ │ │ │ - } else if (geometryAttribute.type.indexOf("LineString") >= 0) { │ │ │ │ - symbolizer = { │ │ │ │ - Line: this.selectionSymbolizer["Line"] │ │ │ │ + if (nTitle != "") { │ │ │ │ + nPath.push(nTitle) │ │ │ │ } │ │ │ │ - } else if (geometryAttribute.type.indexOf("Point") >= 0) { │ │ │ │ - symbolizer = { │ │ │ │ - Point: this.selectionSymbolizer["Point"] │ │ │ │ + layerContext.metadata.nestingPath = nPath; │ │ │ │ + if (layerContext.layersContext) { │ │ │ │ + this.setNestingPath(layerContext) │ │ │ │ } │ │ │ │ } │ │ │ │ - var filter = filters[i]; │ │ │ │ - sld.namedLayers[name].userStyles.push({ │ │ │ │ - name: "default", │ │ │ │ - rules: [new OpenLayers.Rule({ │ │ │ │ - symbolizer: symbolizer, │ │ │ │ - filter: filter, │ │ │ │ - maxScaleDenominator: layer.options.minScale │ │ │ │ - })] │ │ │ │ - }) │ │ │ │ } │ │ │ │ - return new OpenLayers.Format.SLD({ │ │ │ │ - srsName: this.map.getProjection() │ │ │ │ - }).write(sld) │ │ │ │ }, │ │ │ │ - parseDescribeLayer: function(request) { │ │ │ │ - var format = new OpenLayers.Format.WMSDescribeLayer; │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ - } │ │ │ │ - var describeLayer = format.read(doc); │ │ │ │ - var typeNames = []; │ │ │ │ - var url = null; │ │ │ │ - for (var i = 0, len = describeLayer.length; i < len; i++) { │ │ │ │ - if (describeLayer[i].owsType == "WFS") { │ │ │ │ - typeNames.push(describeLayer[i].typeName); │ │ │ │ - url = describeLayer[i].owsURL │ │ │ │ + decomposeNestingPath: function(nPath) { │ │ │ │ + var a = []; │ │ │ │ + if (OpenLayers.Util.isArray(nPath)) { │ │ │ │ + var path = nPath.slice(); │ │ │ │ + while (path.length > 0) { │ │ │ │ + a.push(path.slice()); │ │ │ │ + path.pop() │ │ │ │ } │ │ │ │ + a.reverse() │ │ │ │ } │ │ │ │ - var options = { │ │ │ │ - url: url, │ │ │ │ - params: { │ │ │ │ - SERVICE: "WFS", │ │ │ │ - TYPENAME: typeNames.toString(), │ │ │ │ - REQUEST: "DescribeFeatureType", │ │ │ │ - VERSION: "1.0.0" │ │ │ │ - }, │ │ │ │ - callback: function(request) { │ │ │ │ - var format = new OpenLayers.Format.WFSDescribeFeatureType; │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ - } │ │ │ │ - var describeFeatureType = format.read(doc); │ │ │ │ - this.control.wfsCache[this.layer.id] = describeFeatureType; │ │ │ │ - this.control._queue && this.control.applySelection() │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }; │ │ │ │ - OpenLayers.Request.GET(options) │ │ │ │ + return a │ │ │ │ }, │ │ │ │ - getGeometryAttributes: function(layer) { │ │ │ │ - var result = []; │ │ │ │ - var cache = this.wfsCache[layer.id]; │ │ │ │ - for (var i = 0, len = cache.featureTypes.length; i < len; i++) { │ │ │ │ - var typeName = cache.featureTypes[i]; │ │ │ │ - var properties = typeName.properties; │ │ │ │ - for (var j = 0, lenj = properties.length; j < lenj; j++) { │ │ │ │ - var property = properties[j]; │ │ │ │ - var type = property.type; │ │ │ │ - if (type.indexOf("LineString") >= 0 || type.indexOf("GeometryAssociationType") >= 0 || type.indexOf("GeometryPropertyType") >= 0 || type.indexOf("Point") >= 0 || type.indexOf("Polygon") >= 0) { │ │ │ │ - result.push(property) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - return result │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - var layer = this.layers[i]; │ │ │ │ - if (layer && !this.wfsCache[layer.id]) { │ │ │ │ - var options = { │ │ │ │ - url: layer.url, │ │ │ │ - params: { │ │ │ │ - SERVICE: "WMS", │ │ │ │ - VERSION: layer.params.VERSION, │ │ │ │ - LAYERS: layer.params.LAYERS, │ │ │ │ - REQUEST: "DescribeLayer" │ │ │ │ - }, │ │ │ │ - callback: this.parseDescribeLayer, │ │ │ │ - scope: { │ │ │ │ - layer: layer, │ │ │ │ - control: this │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - OpenLayers.Request.GET(options) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ } │ │ │ │ - return activated │ │ │ │ + var context = {}; │ │ │ │ + this.readNode(data, context); │ │ │ │ + this.setNestingPath({ │ │ │ │ + layersContext: context.layersContext │ │ │ │ + }); │ │ │ │ + var layers = []; │ │ │ │ + this.processLayer(layers, context); │ │ │ │ + delete context.layersContext; │ │ │ │ + context.layersContext = layers; │ │ │ │ + return context │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - var layer = this.layers[i]; │ │ │ │ - if (layer && this.clearOnDeactivate === true) { │ │ │ │ - var layerCache = this.layerCache; │ │ │ │ - var selectionLayer = layerCache[layer.id]; │ │ │ │ - if (selectionLayer) { │ │ │ │ - layer.events.un({ │ │ │ │ - visibilitychanged: this.coupleLayerVisiblity, │ │ │ │ - scope: selectionLayer │ │ │ │ - }); │ │ │ │ - selectionLayer.destroy(); │ │ │ │ - delete layerCache[layer.id] │ │ │ │ - } │ │ │ │ + processLayer: function(layerArray, layer) { │ │ │ │ + if (layer.layersContext) { │ │ │ │ + for (var i = 0, len = layer.layersContext.length; i < len; i++) { │ │ │ │ + var l = layer.layersContext[i]; │ │ │ │ + layerArray.push(l); │ │ │ │ + if (l.layersContext) { │ │ │ │ + this.processLayer(layerArray, l) │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ }, │ │ │ │ - setLayers: function(layers) { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - this.layers = layers; │ │ │ │ - this.activate() │ │ │ │ - } else { │ │ │ │ - this.layers = layers │ │ │ │ - } │ │ │ │ + write: function(context, options) { │ │ │ │ + var name = "OWSContext"; │ │ │ │ + this.nestingLayerLookup = {}; │ │ │ │ + options = options || {}; │ │ │ │ + OpenLayers.Util.applyDefaults(options, context); │ │ │ │ + var root = this.writeNode(name, options); │ │ │ │ + this.nestingLayerLookup = null; │ │ │ │ + this.setAttributeNS(root, this.namespaces["xsi"], "xsi:schemaLocation", this.schemaLocation); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [root]) │ │ │ │ }, │ │ │ │ - createFilter: function(geometryAttribute, geometry) { │ │ │ │ - var filter = null; │ │ │ │ - if (this.handler instanceof OpenLayers.Handler.RegularPolygon) { │ │ │ │ - if (this.handler.irregular === true) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry.getBounds() │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } else if (this.handler instanceof OpenLayers.Handler.Polygon) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }) │ │ │ │ - } else if (this.handler instanceof OpenLayers.Handler.Path) { │ │ │ │ - if (geometryAttribute.type.indexOf("Point") >= 0) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - distance: this.map.getExtent().getWidth() * .01, │ │ │ │ - distanceUnits: this.map.getUnits(), │ │ │ │ - value: geometry │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }) │ │ │ │ + readers: { │ │ │ │ + kml: { │ │ │ │ + Document: function(node, obj) { │ │ │ │ + obj.features = new OpenLayers.Format.KML({ │ │ │ │ + kmlns: this.namespaces.kml, │ │ │ │ + extractStyles: true │ │ │ │ + }).read(node) │ │ │ │ } │ │ │ │ - } else if (this.handler instanceof OpenLayers.Handler.Click) { │ │ │ │ - if (geometryAttribute.type.indexOf("Polygon") >= 0) { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - value: geometry │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ - property: geometryAttribute.name, │ │ │ │ - distance: this.map.getExtent().getWidth() * .01, │ │ │ │ - distanceUnits: this.map.getUnits(), │ │ │ │ - value: geometry │ │ │ │ - }) │ │ │ │ + }, │ │ │ │ + owc: { │ │ │ │ + OWSContext: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + General: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + ResourceList: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + Layer: function(node, obj) { │ │ │ │ + var layerContext = { │ │ │ │ + metadata: {}, │ │ │ │ + visibility: node.getAttribute("hidden") != "1", │ │ │ │ + queryable: node.getAttribute("queryable") == "1", │ │ │ │ + opacity: node.getAttribute("opacity") != null ? parseFloat(node.getAttribute("opacity")) : null, │ │ │ │ + name: node.getAttribute("name"), │ │ │ │ + categoryLayer: node.getAttribute("name") == null, │ │ │ │ + formats: [], │ │ │ │ + styles: [] │ │ │ │ + }; │ │ │ │ + if (!obj.layersContext) { │ │ │ │ + obj.layersContext = [] │ │ │ │ + } │ │ │ │ + obj.layersContext.push(layerContext); │ │ │ │ + this.readChildNodes(node, layerContext) │ │ │ │ + }, │ │ │ │ + InlineGeometry: function(node, obj) { │ │ │ │ + obj.features = []; │ │ │ │ + var elements = this.getElementsByTagNameNS(node, this.namespaces.gml, "featureMember"); │ │ │ │ + var el; │ │ │ │ + if (elements.length >= 1) { │ │ │ │ + el = elements[0] │ │ │ │ + } │ │ │ │ + if (el && el.firstChild) { │ │ │ │ + var featurenode = el.firstChild.nextSibling ? el.firstChild.nextSibling : el.firstChild; │ │ │ │ + this.setNamespace("feature", featurenode.namespaceURI); │ │ │ │ + this.featureType = featurenode.localName || featurenode.nodeName.split(":").pop(); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Server: function(node, obj) { │ │ │ │ + if (!obj.service && !obj.version || obj.service != OpenLayers.Format.Context.serviceTypes.WMS) { │ │ │ │ + obj.service = node.getAttribute("service"); │ │ │ │ + obj.version = node.getAttribute("version"); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Name: function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + Title: function(node, obj) { │ │ │ │ + obj.title = this.getChildValue(node); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + StyleList: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj.styles) │ │ │ │ + }, │ │ │ │ + Style: function(node, obj) { │ │ │ │ + var style = {}; │ │ │ │ + obj.push(style); │ │ │ │ + this.readChildNodes(node, style) │ │ │ │ + }, │ │ │ │ + LegendURL: function(node, obj) { │ │ │ │ + var legend = {}; │ │ │ │ + obj.legend = legend; │ │ │ │ + this.readChildNodes(node, legend) │ │ │ │ + }, │ │ │ │ + OnlineResource: function(node, obj) { │ │ │ │ + obj.url = this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ } │ │ │ │ - } │ │ │ │ - return filter │ │ │ │ + }, │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers.ows, │ │ │ │ + gml: OpenLayers.Format.GML.v2.prototype.readers.gml, │ │ │ │ + sld: OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld, │ │ │ │ + feature: OpenLayers.Format.GML.v2.prototype.readers.feature │ │ │ │ }, │ │ │ │ - select: function(geometry) { │ │ │ │ - this._queue = function() { │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - var layer = this.layers[i]; │ │ │ │ - var geometryAttributes = this.getGeometryAttributes(layer); │ │ │ │ - var filters = []; │ │ │ │ - for (var j = 0, lenj = geometryAttributes.length; j < lenj; j++) { │ │ │ │ - var geometryAttribute = geometryAttributes[j]; │ │ │ │ - if (geometryAttribute !== null) { │ │ │ │ - if (!(geometry instanceof OpenLayers.Geometry)) { │ │ │ │ - var point = this.map.getLonLatFromPixel(geometry.xy); │ │ │ │ - geometry = new OpenLayers.Geometry.Point(point.lon, point.lat) │ │ │ │ - } │ │ │ │ - var filter = this.createFilter(geometryAttribute, geometry); │ │ │ │ - if (filter !== null) { │ │ │ │ - filters.push(filter) │ │ │ │ + writers: { │ │ │ │ + owc: { │ │ │ │ + OWSContext: function(options) { │ │ │ │ + var node = this.createElementNSPlus("OWSContext", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + id: options.id || OpenLayers.Util.createUniqueID("OpenLayers_OWSContext_") │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("General", options, node); │ │ │ │ + this.writeNode("ResourceList", options, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + General: function(options) { │ │ │ │ + var node = this.createElementNSPlus("General"); │ │ │ │ + this.writeNode("ows:BoundingBox", options, node); │ │ │ │ + this.writeNode("ows:Title", options.title || "OpenLayers OWSContext", node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + ResourceList: function(options) { │ │ │ │ + var node = this.createElementNSPlus("ResourceList"); │ │ │ │ + for (var i = 0, len = options.layers.length; i < len; i++) { │ │ │ │ + var layer = options.layers[i]; │ │ │ │ + var decomposedPath = this.decomposeNestingPath(layer.metadata.nestingPath); │ │ │ │ + this.writeNode("_Layer", { │ │ │ │ + layer: layer, │ │ │ │ + subPaths: decomposedPath │ │ │ │ + }, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Server: function(options) { │ │ │ │ + var node = this.createElementNSPlus("Server", { │ │ │ │ + attributes: { │ │ │ │ + version: options.version, │ │ │ │ + service: options.service │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("OnlineResource", options, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + OnlineResource: function(options) { │ │ │ │ + var node = this.createElementNSPlus("OnlineResource", { │ │ │ │ + attributes: { │ │ │ │ + "xlink:href": options.url │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + InlineGeometry: function(layer) { │ │ │ │ + var node = this.createElementNSPlus("InlineGeometry"), │ │ │ │ + dataExtent = layer.getDataExtent(); │ │ │ │ + if (dataExtent !== null) { │ │ │ │ + this.writeNode("gml:boundedBy", dataExtent, node) │ │ │ │ + } │ │ │ │ + for (var i = 0, len = layer.features.length; i < len; i++) { │ │ │ │ + this.writeNode("gml:featureMember", layer.features[i], node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + StyleList: function(styles) { │ │ │ │ + var node = this.createElementNSPlus("StyleList"); │ │ │ │ + for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ + this.writeNode("Style", styles[i], node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Style: function(style) { │ │ │ │ + var node = this.createElementNSPlus("Style"); │ │ │ │ + this.writeNode("Name", style, node); │ │ │ │ + this.writeNode("Title", style, node); │ │ │ │ + if (style.legend) { │ │ │ │ + this.writeNode("LegendURL", style, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Name: function(obj) { │ │ │ │ + var node = this.createElementNSPlus("Name", { │ │ │ │ + value: obj.name │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Title: function(obj) { │ │ │ │ + var node = this.createElementNSPlus("Title", { │ │ │ │ + value: obj.title │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + LegendURL: function(style) { │ │ │ │ + var node = this.createElementNSPlus("LegendURL"); │ │ │ │ + this.writeNode("OnlineResource", style.legend, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + _WMS: function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer", { │ │ │ │ + attributes: { │ │ │ │ + name: layer.params.LAYERS, │ │ │ │ + queryable: layer.queryable ? "1" : "0", │ │ │ │ + hidden: layer.visibility ? "0" : "1", │ │ │ │ + opacity: layer.hasOwnProperty("opacity") ? layer.opacity : null │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("ows:OutputFormat", layer.params.FORMAT, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.WMS, │ │ │ │ + version: layer.params.VERSION, │ │ │ │ + url: layer.url │ │ │ │ + }, node); │ │ │ │ + if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ + this.writeNode("StyleList", layer.metadata.styles, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + _Layer: function(options) { │ │ │ │ + var layer, subPaths, node, title; │ │ │ │ + layer = options.layer; │ │ │ │ + subPaths = options.subPaths; │ │ │ │ + node = null; │ │ │ │ + title = null; │ │ │ │ + if (subPaths.length > 0) { │ │ │ │ + var path = subPaths[0].join("/"); │ │ │ │ + var index = path.lastIndexOf("/"); │ │ │ │ + node = this.nestingLayerLookup[path]; │ │ │ │ + title = index > 0 ? path.substring(index + 1, path.length) : path; │ │ │ │ + if (!node) { │ │ │ │ + node = this.createElementNSPlus("Layer"); │ │ │ │ + this.writeNode("ows:Title", title, node); │ │ │ │ + this.nestingLayerLookup[path] = node │ │ │ │ + } │ │ │ │ + options.subPaths.shift(); │ │ │ │ + this.writeNode("_Layer", options, node); │ │ │ │ + return node │ │ │ │ + } else { │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ + node = this.writeNode("_WMS", layer) │ │ │ │ + } else if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ + if (layer.protocol instanceof OpenLayers.Protocol.WFS.v1) { │ │ │ │ + node = this.writeNode("_WFS", layer) │ │ │ │ + } else if (layer.protocol instanceof OpenLayers.Protocol.HTTP) { │ │ │ │ + if (layer.protocol.format instanceof OpenLayers.Format.GML) { │ │ │ │ + layer.protocol.format.version = "2.1.2"; │ │ │ │ + node = this.writeNode("_GML", layer) │ │ │ │ + } else if (layer.protocol.format instanceof OpenLayers.Format.KML) { │ │ │ │ + layer.protocol.format.version = "2.2"; │ │ │ │ + node = this.writeNode("_KML", layer) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.setNamespace("feature", this.featureNS); │ │ │ │ + node = this.writeNode("_InlineGeometry", layer) │ │ │ │ } │ │ │ │ } │ │ │ │ + if (layer.options.maxScale) { │ │ │ │ + this.writeNode("sld:MinScaleDenominator", layer.options.maxScale, node) │ │ │ │ + } │ │ │ │ + if (layer.options.minScale) { │ │ │ │ + this.writeNode("sld:MaxScaleDenominator", layer.options.minScale, node) │ │ │ │ + } │ │ │ │ + this.nestingLayerLookup[layer.name] = node; │ │ │ │ + return node │ │ │ │ } │ │ │ │ - var selectionLayer = this.createSelectionLayer(layer); │ │ │ │ - this.events.triggerEvent("selected", { │ │ │ │ - layer: layer, │ │ │ │ - filters: filters │ │ │ │ + }, │ │ │ │ + _WFS: function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer", { │ │ │ │ + attributes: { │ │ │ │ + name: layer.protocol.featurePrefix + ":" + layer.protocol.featureType, │ │ │ │ + hidden: layer.visibility ? "0" : "1" │ │ │ │ + } │ │ │ │ }); │ │ │ │ - var sld = this.createSLD(layer, filters, geometryAttributes); │ │ │ │ - selectionLayer.mergeNewParams({ │ │ │ │ - SLD_BODY: sld │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.WFS, │ │ │ │ + version: layer.protocol.version, │ │ │ │ + url: layer.protocol.url │ │ │ │ + }, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + _InlineGeometry: function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer", { │ │ │ │ + attributes: { │ │ │ │ + name: this.featureType, │ │ │ │ + hidden: layer.visibility ? "0" : "1" │ │ │ │ + } │ │ │ │ }); │ │ │ │ - delete this._queue │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("InlineGeometry", layer, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + _GML: function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer"); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.GML, │ │ │ │ + url: layer.protocol.url, │ │ │ │ + version: layer.protocol.format.version │ │ │ │ + }, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + _KML: function(layer) { │ │ │ │ + var node = this.createElementNSPlus("Layer"); │ │ │ │ + this.writeNode("ows:Title", layer.name, node); │ │ │ │ + this.writeNode("Server", { │ │ │ │ + service: OpenLayers.Format.Context.serviceTypes.KML, │ │ │ │ + version: layer.protocol.format.version, │ │ │ │ + url: layer.protocol.url │ │ │ │ + }, node); │ │ │ │ + return node │ │ │ │ } │ │ │ │ - }; │ │ │ │ - this.applySelection() │ │ │ │ - }, │ │ │ │ - applySelection: function() { │ │ │ │ - var canApply = true; │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ - if (!this.wfsCache[this.layers[i].id]) { │ │ │ │ - canApply = false; │ │ │ │ - break │ │ │ │ + }, │ │ │ │ + gml: OpenLayers.Util.applyDefaults({ │ │ │ │ + boundedBy: function(bounds) { │ │ │ │ + var node = this.createElementNSPlus("gml:boundedBy"); │ │ │ │ + this.writeNode("gml:Box", bounds, node); │ │ │ │ + return node │ │ │ │ } │ │ │ │ - } │ │ │ │ - canApply && this._queue.call(this) │ │ │ │ + }, OpenLayers.Format.GML.v2.prototype.writers.gml), │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1_0_0.prototype.writers.ows, │ │ │ │ + sld: OpenLayers.Format.SLD.v1_0_0.prototype.writers.sld, │ │ │ │ + feature: OpenLayers.Format.GML.v2.prototype.writers.feature │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.SLDSelect" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Button = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_BUTTON, │ │ │ │ - trigger: function() {}, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Button" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.OWSContext.v0_3_1" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.NavigationHistory = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_TOGGLE, │ │ │ │ - previous: null, │ │ │ │ - previousOptions: null, │ │ │ │ - next: null, │ │ │ │ - nextOptions: null, │ │ │ │ - limit: 50, │ │ │ │ - autoActivate: true, │ │ │ │ - clearOnDeactivate: false, │ │ │ │ - registry: null, │ │ │ │ - nextStack: null, │ │ │ │ - previousStack: null, │ │ │ │ - listeners: null, │ │ │ │ - restoring: false, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.registry = OpenLayers.Util.extend({ │ │ │ │ - moveend: this.getState │ │ │ │ - }, this.registry); │ │ │ │ - var previousOptions = { │ │ │ │ - trigger: OpenLayers.Function.bind(this.previousTrigger, this), │ │ │ │ - displayClass: 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 + " " + this.displayClass + "Next" │ │ │ │ - }; │ │ │ │ - OpenLayers.Util.extend(nextOptions, this.nextOptions); │ │ │ │ - this.next = new OpenLayers.Control.Button(nextOptions); │ │ │ │ - this.clear() │ │ │ │ - }, │ │ │ │ - onPreviousChange: function(state, length) { │ │ │ │ - if (state && !this.previous.active) { │ │ │ │ - this.previous.activate() │ │ │ │ - } else if (!state && this.previous.active) { │ │ │ │ - this.previous.deactivate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - onNextChange: function(state, length) { │ │ │ │ - if (state && !this.next.active) { │ │ │ │ - this.next.activate() │ │ │ │ - } else if (!state && this.next.active) { │ │ │ │ - this.next.deactivate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ - this.previous.destroy(); │ │ │ │ - this.next.destroy(); │ │ │ │ - this.deactivate(); │ │ │ │ - for (var prop in this) { │ │ │ │ - this[prop] = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - this.next.setMap(map); │ │ │ │ - this.previous.setMap(map) │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - this.next.draw(); │ │ │ │ - this.previous.draw() │ │ │ │ - }, │ │ │ │ - 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 │ │ │ │ +OpenLayers.Format.XLS.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + xls: "http://www.opengis.net/xls", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ }, │ │ │ │ - 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 │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ }, │ │ │ │ - clear: function() { │ │ │ │ - this.previousStack = []; │ │ │ │ - this.previous.deactivate(); │ │ │ │ - this.nextStack = []; │ │ │ │ - this.next.deactivate() │ │ │ │ + xy: true, │ │ │ │ + defaultPrefix: "xls", │ │ │ │ + schemaLocation: null, │ │ │ │ + read: function(data, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var xls = {}; │ │ │ │ + this.readChildNodes(data, xls); │ │ │ │ + return xls │ │ │ │ }, │ │ │ │ - getState: function() { │ │ │ │ - return { │ │ │ │ - center: this.map.getCenter(), │ │ │ │ - resolution: this.map.getResolution(), │ │ │ │ - projection: this.map.getProjectionObject(), │ │ │ │ - units: this.map.getProjectionObject().getUnits() || this.map.units || this.map.baseLayer.units │ │ │ │ - } │ │ │ │ + readers: { │ │ │ │ + xls: { │ │ │ │ + XLS: function(node, xls) { │ │ │ │ + xls.version = node.getAttribute("version"); │ │ │ │ + this.readChildNodes(node, xls) │ │ │ │ + }, │ │ │ │ + Response: function(node, xls) { │ │ │ │ + this.readChildNodes(node, xls) │ │ │ │ + }, │ │ │ │ + GeocodeResponse: function(node, xls) { │ │ │ │ + xls.responseLists = []; │ │ │ │ + this.readChildNodes(node, xls) │ │ │ │ + }, │ │ │ │ + GeocodeResponseList: function(node, xls) { │ │ │ │ + var responseList = { │ │ │ │ + features: [], │ │ │ │ + numberOfGeocodedAddresses: parseInt(node.getAttribute("numberOfGeocodedAddresses")) │ │ │ │ + }; │ │ │ │ + xls.responseLists.push(responseList); │ │ │ │ + this.readChildNodes(node, responseList) │ │ │ │ + }, │ │ │ │ + GeocodedAddress: function(node, responseList) { │ │ │ │ + var feature = new OpenLayers.Feature.Vector; │ │ │ │ + responseList.features.push(feature); │ │ │ │ + this.readChildNodes(node, feature); │ │ │ │ + feature.geometry = feature.components[0] │ │ │ │ + }, │ │ │ │ + GeocodeMatchCode: function(node, feature) { │ │ │ │ + feature.attributes.matchCode = { │ │ │ │ + accuracy: parseFloat(node.getAttribute("accuracy")), │ │ │ │ + matchType: node.getAttribute("matchType") │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Address: function(node, feature) { │ │ │ │ + var address = { │ │ │ │ + countryCode: node.getAttribute("countryCode"), │ │ │ │ + addressee: node.getAttribute("addressee"), │ │ │ │ + street: [], │ │ │ │ + place: [] │ │ │ │ + }; │ │ │ │ + feature.attributes.address = address; │ │ │ │ + this.readChildNodes(node, address) │ │ │ │ + }, │ │ │ │ + freeFormAddress: function(node, address) { │ │ │ │ + address.freeFormAddress = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + StreetAddress: function(node, address) { │ │ │ │ + this.readChildNodes(node, address) │ │ │ │ + }, │ │ │ │ + Building: function(node, address) { │ │ │ │ + address.building = { │ │ │ │ + number: node.getAttribute("number"), │ │ │ │ + subdivision: node.getAttribute("subdivision"), │ │ │ │ + buildingName: node.getAttribute("buildingName") │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + Street: function(node, address) { │ │ │ │ + address.street.push(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + Place: function(node, address) { │ │ │ │ + address.place[node.getAttribute("type")] = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + PostalCode: function(node, address) { │ │ │ │ + address.postalCode = this.getChildValue(node) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + gml: OpenLayers.Format.GML.v3.prototype.readers.gml │ │ │ │ }, │ │ │ │ - restore: function(state) { │ │ │ │ - var center, zoom; │ │ │ │ - if (this.map.getProjectionObject() == state.projection) { │ │ │ │ - zoom = this.map.getZoomForResolution(state.resolution); │ │ │ │ - center = state.center │ │ │ │ - } else { │ │ │ │ - center = state.center.clone(); │ │ │ │ - center.transform(state.projection, this.map.getProjectionObject()); │ │ │ │ - var sourceUnits = state.units; │ │ │ │ - var targetUnits = this.map.getProjectionObject().getUnits() || this.map.units || this.map.baseLayer.units; │ │ │ │ - var resolutionFactor = sourceUnits && targetUnits ? OpenLayers.INCHES_PER_UNIT[sourceUnits] / OpenLayers.INCHES_PER_UNIT[targetUnits] : 1; │ │ │ │ - zoom = this.map.getZoomForResolution(resolutionFactor * state.resolution) │ │ │ │ - } │ │ │ │ - this.map.setCenter(center, zoom) │ │ │ │ + write: function(request) { │ │ │ │ + return this.writers.xls.XLS.apply(this, [request]) │ │ │ │ }, │ │ │ │ - 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() │ │ │ │ + writers: { │ │ │ │ + xls: { │ │ │ │ + XLS: function(request) { │ │ │ │ + var root = this.createElementNSPlus("xls:XLS", { │ │ │ │ + attributes: { │ │ │ │ + version: this.VERSION, │ │ │ │ + "xsi:schemaLocation": this.schemaLocation │ │ │ │ } │ │ │ │ - if (this.nextStack.length > 0) { │ │ │ │ - this.nextStack = []; │ │ │ │ - this.onNextChange(null, 0) │ │ │ │ + }); │ │ │ │ + this.writeNode("RequestHeader", request.header, root); │ │ │ │ + this.writeNode("Request", request, root); │ │ │ │ + return root │ │ │ │ + }, │ │ │ │ + RequestHeader: function(header) { │ │ │ │ + return this.createElementNSPlus("xls:RequestHeader") │ │ │ │ + }, │ │ │ │ + Request: function(request) { │ │ │ │ + var node = this.createElementNSPlus("xls:Request", { │ │ │ │ + attributes: { │ │ │ │ + methodName: "GeocodeRequest", │ │ │ │ + requestID: request.requestID || "", │ │ │ │ + version: this.VERSION │ │ │ │ } │ │ │ │ + }); │ │ │ │ + this.writeNode("GeocodeRequest", request.addresses, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + GeocodeRequest: function(addresses) { │ │ │ │ + var node = this.createElementNSPlus("xls:GeocodeRequest"); │ │ │ │ + for (var i = 0, len = addresses.length; i < len; i++) { │ │ │ │ + this.writeNode("Address", addresses[i], node) │ │ │ │ } │ │ │ │ - return true │ │ │ │ - }, this) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - 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]) │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Address: function(address) { │ │ │ │ + var node = this.createElementNSPlus("xls:Address", { │ │ │ │ + attributes: { │ │ │ │ + countryCode: address.countryCode │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (address.freeFormAddress) { │ │ │ │ + this.writeNode("freeFormAddress", address.freeFormAddress, node) │ │ │ │ + } else { │ │ │ │ + if (address.street) { │ │ │ │ + this.writeNode("StreetAddress", address, node) │ │ │ │ + } │ │ │ │ + if (address.municipality) { │ │ │ │ + this.writeNode("Municipality", address.municipality, node) │ │ │ │ + } │ │ │ │ + if (address.countrySubdivision) { │ │ │ │ + this.writeNode("CountrySubdivision", address.countrySubdivision, node) │ │ │ │ + } │ │ │ │ + if (address.postalCode) { │ │ │ │ + this.writeNode("PostalCode", address.postalCode, node) │ │ │ │ + } │ │ │ │ } │ │ │ │ - activated = true; │ │ │ │ - if (this.previousStack.length == 0) { │ │ │ │ - this.initStack() │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + freeFormAddress: function(freeFormAddress) { │ │ │ │ + return this.createElementNSPlus("freeFormAddress", { │ │ │ │ + value: freeFormAddress │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + StreetAddress: function(address) { │ │ │ │ + var node = this.createElementNSPlus("xls:StreetAddress"); │ │ │ │ + if (address.building) { │ │ │ │ + this.writeNode(node, "Building", address.building) │ │ │ │ } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - initStack: function() { │ │ │ │ - if (this.map.getCenter()) { │ │ │ │ - this.listeners.moveend() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - 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]) │ │ │ │ + var street = address.street; │ │ │ │ + if (!OpenLayers.Util.isArray(street)) { │ │ │ │ + street = [street] │ │ │ │ } │ │ │ │ - if (this.clearOnDeactivate) { │ │ │ │ - this.clear() │ │ │ │ + for (var i = 0, len = street.length; i < len; i++) { │ │ │ │ + this.writeNode("Street", street[i], node) │ │ │ │ } │ │ │ │ - deactivated = true │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Building: function(building) { │ │ │ │ + return this.createElementNSPlus("xls:Building", { │ │ │ │ + attributes: { │ │ │ │ + number: building["number"], │ │ │ │ + subdivision: building.subdivision, │ │ │ │ + buildingName: building.buildingName │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + Street: function(street) { │ │ │ │ + return this.createElementNSPlus("xls:Street", { │ │ │ │ + value: street │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + Municipality: function(municipality) { │ │ │ │ + return this.createElementNSPlus("xls:Place", { │ │ │ │ + attributes: { │ │ │ │ + type: "Municipality" │ │ │ │ + }, │ │ │ │ + value: municipality │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + CountrySubdivision: function(countrySubdivision) { │ │ │ │ + return this.createElementNSPlus("xls:Place", { │ │ │ │ + attributes: { │ │ │ │ + type: "CountrySubdivision" │ │ │ │ + }, │ │ │ │ + value: countrySubdivision │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + PostalCode: function(postalCode) { │ │ │ │ + return this.createElementNSPlus("xls:PostalCode", { │ │ │ │ + value: postalCode │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.NavigationHistory" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.XLS.v1" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.Geolocate = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - geolocation: null, │ │ │ │ - available: "geolocation" in navigator, │ │ │ │ - bind: true, │ │ │ │ - watch: false, │ │ │ │ - geolocationOptions: null, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (this.available && !this.geolocation) { │ │ │ │ - this.geolocation = navigator.geolocation │ │ │ │ - } │ │ │ │ - if (!this.geolocation) { │ │ │ │ - this.events.triggerEvent("locationuncapable"); │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - if (this.watch) { │ │ │ │ - this.watchId = this.geolocation.watchPosition(OpenLayers.Function.bind(this.geolocate, this), OpenLayers.Function.bind(this.failure, this), this.geolocationOptions) │ │ │ │ - } else { │ │ │ │ - this.getCurrentLocation() │ │ │ │ - } │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active && this.watchId !== null) { │ │ │ │ - this.geolocation.clearWatch(this.watchId) │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - geolocate: function(position) { │ │ │ │ - var center = new OpenLayers.LonLat(position.coords.longitude, position.coords.latitude).transform(new OpenLayers.Projection("EPSG:4326"), this.map.getProjectionObject()); │ │ │ │ - if (this.bind) { │ │ │ │ - this.map.setCenter(center) │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("locationupdated", { │ │ │ │ - position: position, │ │ │ │ - point: new OpenLayers.Geometry.Point(center.lon, center.lat) │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - getCurrentLocation: function() { │ │ │ │ - if (!this.active || this.watch) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - this.geolocation.getCurrentPosition(OpenLayers.Function.bind(this.geolocate, this), OpenLayers.Function.bind(this.failure, this), this.geolocationOptions); │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - failure: function(error) { │ │ │ │ - this.events.triggerEvent("locationfailed", { │ │ │ │ - error: error │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Geolocate" │ │ │ │ +OpenLayers.Format.XLS.v1_1_0 = OpenLayers.Class(OpenLayers.Format.XLS.v1, { │ │ │ │ + VERSION: "1.1", │ │ │ │ + schemaLocation: "http://www.opengis.net/xls http://schemas.opengis.net/ols/1.1.0/LocationUtilityService.xsd", │ │ │ │ + CLASS_NAME: "OpenLayers.Format.XLS.v1_1_0" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.PanZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - slideFactor: 50, │ │ │ │ - slideRatio: null, │ │ │ │ - buttons: null, │ │ │ │ - position: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X, OpenLayers.Control.PanZoom.Y); │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick) │ │ │ │ - } │ │ │ │ - this.removeButtons(); │ │ │ │ - this.buttons = null; │ │ │ │ - this.position = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ - }, │ │ │ │ - draw: function(px) { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - px = this.position; │ │ │ │ - this.buttons = []; │ │ │ │ - var sz = { │ │ │ │ - w: 18, │ │ │ │ - h: 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 │ │ │ │ - }, │ │ │ │ - _addButton: function(id, img, xy, sz) { │ │ │ │ - var imgLocation = OpenLayers.Util.getImageLocation(img); │ │ │ │ - var btn = OpenLayers.Util.createAlphaImageDiv(this.id + "_" + id, xy, sz, imgLocation, "absolute"); │ │ │ │ - btn.style.cursor = "pointer"; │ │ │ │ - this.div.appendChild(btn); │ │ │ │ - btn.action = id; │ │ │ │ - btn.className = "olButton"; │ │ │ │ - this.buttons.push(btn); │ │ │ │ - return btn │ │ │ │ +OpenLayers.Format.XLS.v1_1 = OpenLayers.Format.XLS.v1_1_0; │ │ │ │ +OpenLayers.Format.CSWGetRecords.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ + namespaces: { │ │ │ │ + csw: "http://www.opengis.net/cat/csw/2.0.2", │ │ │ │ + dc: "http://purl.org/dc/elements/1.1/", │ │ │ │ + dct: "http://purl.org/dc/terms/", │ │ │ │ + gmd: "http://www.isotc211.org/2005/gmd", │ │ │ │ + geonet: "http://www.fao.org/geonetwork", │ │ │ │ + ogc: "http://www.opengis.net/ogc", │ │ │ │ + ows: "http://www.opengis.net/ows", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink", │ │ │ │ + xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ }, │ │ │ │ - _removeButton: function(btn) { │ │ │ │ - this.div.removeChild(btn); │ │ │ │ - OpenLayers.Util.removeItem(this.buttons, btn) │ │ │ │ + defaultPrefix: "csw", │ │ │ │ + version: "2.0.2", │ │ │ │ + schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ + requestId: null, │ │ │ │ + resultType: null, │ │ │ │ + outputFormat: null, │ │ │ │ + outputSchema: null, │ │ │ │ + startPosition: null, │ │ │ │ + maxRecords: null, │ │ │ │ + DistributedSearch: null, │ │ │ │ + ResponseHandler: null, │ │ │ │ + Query: null, │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ }, │ │ │ │ - removeButtons: function() { │ │ │ │ - for (var i = this.buttons.length - 1; i >= 0; --i) { │ │ │ │ - this._removeButton(this.buttons[i]) │ │ │ │ - } │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var btn = evt.buttonElement; │ │ │ │ - switch (btn.action) { │ │ │ │ - case "panup": │ │ │ │ - this.map.pan(0, -this.getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case "pandown": │ │ │ │ - this.map.pan(0, this.getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case "panleft": │ │ │ │ - this.map.pan(-this.getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - case "panright": │ │ │ │ - this.map.pan(this.getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - case "zoomin": │ │ │ │ - this.map.zoomIn(); │ │ │ │ - break; │ │ │ │ - case "zoomout": │ │ │ │ - this.map.zoomOut(); │ │ │ │ - break; │ │ │ │ - case "zoomworld": │ │ │ │ - this.map.zoomToMaxExtent(); │ │ │ │ - break │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - getSlideFactor: function(dim) { │ │ │ │ - return this.slideRatio ? this.map.getSize()[dim] * this.slideRatio : this.slideFactor │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PanZoom" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.PanZoom.X = 4; │ │ │ │ -OpenLayers.Control.PanZoom.Y = 4; │ │ │ │ -OpenLayers.Control.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoom, { │ │ │ │ - zoomStopWidth: 18, │ │ │ │ - zoomStopHeight: 11, │ │ │ │ - slider: null, │ │ │ │ - sliderEvents: null, │ │ │ │ - zoombarDiv: null, │ │ │ │ - zoomWorldIcon: false, │ │ │ │ - panIcons: true, │ │ │ │ - forceFixedZoomLevel: false, │ │ │ │ - mouseDragStart: null, │ │ │ │ - deltaY: null, │ │ │ │ - zoomStart: null, │ │ │ │ - destroy: function() { │ │ │ │ - this._removeZoomBar(); │ │ │ │ - this.map.events.un({ │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - updatesize: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - OpenLayers.Control.PanZoom.prototype.destroy.apply(this, arguments); │ │ │ │ - delete this.mouseDragStart; │ │ │ │ - delete this.zoomStart │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.PanZoom.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.on({ │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - updatesize: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - redraw: function() { │ │ │ │ - if (this.div != null) { │ │ │ │ - this.removeButtons(); │ │ │ │ - this._removeZoomBar() │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ } │ │ │ │ - this.draw() │ │ │ │ + var obj = {}; │ │ │ │ + this.readNode(data, obj); │ │ │ │ + return obj │ │ │ │ }, │ │ │ │ - draw: function(px) { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - px = this.position.clone(); │ │ │ │ - this.buttons = []; │ │ │ │ - var sz = { │ │ │ │ - w: 18, │ │ │ │ - h: 18 │ │ │ │ - }; │ │ │ │ - if (this.panIcons) { │ │ │ │ - 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) │ │ │ │ + readers: { │ │ │ │ + csw: { │ │ │ │ + GetRecordsResponse: function(node, obj) { │ │ │ │ + obj.records = []; │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + var version = this.getAttributeNS(node, "", "version"); │ │ │ │ + if (version != "") { │ │ │ │ + obj.version = version │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + RequestId: function(node, obj) { │ │ │ │ + obj.RequestId = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + SearchStatus: function(node, obj) { │ │ │ │ + obj.SearchStatus = {}; │ │ │ │ + var timestamp = this.getAttributeNS(node, "", "timestamp"); │ │ │ │ + if (timestamp != "") { │ │ │ │ + obj.SearchStatus.timestamp = timestamp │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + SearchResults: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj); │ │ │ │ + var attrs = node.attributes; │ │ │ │ + var SearchResults = {}; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + if (attrs[i].name == "numberOfRecordsMatched" || attrs[i].name == "numberOfRecordsReturned" || attrs[i].name == "nextRecord") { │ │ │ │ + SearchResults[attrs[i].name] = parseInt(attrs[i].nodeValue) │ │ │ │ + } else { │ │ │ │ + SearchResults[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + } │ │ │ │ + } │ │ │ │ + obj.SearchResults = SearchResults │ │ │ │ + }, │ │ │ │ + SummaryRecord: function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "SummaryRecord" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record) │ │ │ │ + }, │ │ │ │ + BriefRecord: function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "BriefRecord" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record) │ │ │ │ + }, │ │ │ │ + DCMIRecord: function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "DCMIRecord" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record) │ │ │ │ + }, │ │ │ │ + Record: function(node, obj) { │ │ │ │ + var record = { │ │ │ │ + type: "Record" │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, record); │ │ │ │ + obj.records.push(record) │ │ │ │ + }, │ │ │ │ + "*": function(node, obj) { │ │ │ │ + var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ + obj[name] = this.getChildValue(node) │ │ │ │ } │ │ │ │ - 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 │ │ │ │ + }, │ │ │ │ + geonet: { │ │ │ │ + info: function(node, obj) { │ │ │ │ + var gninfo = {}; │ │ │ │ + this.readChildNodes(node, gninfo); │ │ │ │ + obj.gninfo = gninfo │ │ │ │ } │ │ │ │ - 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) │ │ │ │ - } else { │ │ │ │ - this._addButton("zoomin", "zoom-plus-mini.png", px, sz); │ │ │ │ - centered = this._addZoomBar(px.add(0, sz.h)); │ │ │ │ - this._addButton("zoomout", "zoom-minus-mini.png", centered, sz); │ │ │ │ - if (this.zoomWorldIcon) { │ │ │ │ - centered = centered.add(0, sz.h + 3); │ │ │ │ - this._addButton("zoomworld", "zoom-world-mini.png", centered, sz) │ │ │ │ + }, │ │ │ │ + dc: { │ │ │ │ + "*": function(node, obj) { │ │ │ │ + var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ + if (!OpenLayers.Util.isArray(obj[name])) { │ │ │ │ + obj[name] = [] │ │ │ │ + } │ │ │ │ + var dc_element = {}; │ │ │ │ + var attrs = node.attributes; │ │ │ │ + for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ + dc_element[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + } │ │ │ │ + dc_element.value = this.getChildValue(node); │ │ │ │ + if (dc_element.value != "") { │ │ │ │ + obj[name].push(dc_element) │ │ │ │ + } │ │ │ │ } │ │ │ │ - } │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - _addZoomBar: function(centered) { │ │ │ │ - var imgLocation = OpenLayers.Util.getImageLocation("slider.png"); │ │ │ │ - var id = this.id + "_" + this.map.id; │ │ │ │ - var minZoom = this.map.getMinZoom(); │ │ │ │ - var zoomsToEnd = this.map.getNumZoomLevels() - 1 - this.map.getZoom(); │ │ │ │ - var slider = OpenLayers.Util.createAlphaImageDiv(id, centered.add(-1, zoomsToEnd * this.zoomStopHeight), { │ │ │ │ - w: 20, │ │ │ │ - h: 9 │ │ │ │ - }, imgLocation, "absolute"); │ │ │ │ - slider.style.cursor = "move"; │ │ │ │ - this.slider = slider; │ │ │ │ - this.sliderEvents = new OpenLayers.Events(this, slider, null, true, { │ │ │ │ - includeXY: true │ │ │ │ - }); │ │ │ │ - this.sliderEvents.on({ │ │ │ │ - touchstart: this.zoomBarDown, │ │ │ │ - touchmove: this.zoomBarDrag, │ │ │ │ - touchend: this.zoomBarUp, │ │ │ │ - mousedown: this.zoomBarDown, │ │ │ │ - mousemove: this.zoomBarDrag, │ │ │ │ - mouseup: this.zoomBarUp │ │ │ │ - }); │ │ │ │ - var sz = { │ │ │ │ - w: this.zoomStopWidth, │ │ │ │ - h: this.zoomStopHeight * (this.map.getNumZoomLevels() - minZoom) │ │ │ │ - }; │ │ │ │ - var imgLocation = OpenLayers.Util.getImageLocation("zoombar.png"); │ │ │ │ - var div = null; │ │ │ │ - if (OpenLayers.Util.alphaHack()) { │ │ │ │ - var id = this.id + "_" + this.map.id; │ │ │ │ - div = OpenLayers.Util.createAlphaImageDiv(id, centered, { │ │ │ │ - w: sz.w, │ │ │ │ - h: this.zoomStopHeight │ │ │ │ - }, imgLocation, "absolute", null, "crop"); │ │ │ │ - div.style.height = sz.h + "px" │ │ │ │ - } else { │ │ │ │ - div = OpenLayers.Util.createDiv("OpenLayers_Control_PanZoomBar_Zoombar" + this.map.id, centered, sz, imgLocation) │ │ │ │ - } │ │ │ │ - div.style.cursor = "pointer"; │ │ │ │ - div.className = "olButton"; │ │ │ │ - this.zoombarDiv = div; │ │ │ │ - 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() - minZoom)); │ │ │ │ - return centered │ │ │ │ - }, │ │ │ │ - _removeZoomBar: function() { │ │ │ │ - this.sliderEvents.un({ │ │ │ │ - touchstart: this.zoomBarDown, │ │ │ │ - touchmove: this.zoomBarDrag, │ │ │ │ - touchend: this.zoomBarUp, │ │ │ │ - mousedown: this.zoomBarDown, │ │ │ │ - mousemove: this.zoomBarDrag, │ │ │ │ - mouseup: this.zoomBarUp │ │ │ │ - }); │ │ │ │ - this.sliderEvents.destroy(); │ │ │ │ - this.div.removeChild(this.zoombarDiv); │ │ │ │ - this.zoombarDiv = null; │ │ │ │ - this.div.removeChild(this.slider); │ │ │ │ - this.slider = null; │ │ │ │ - this.map.events.unregister("zoomend", this, this.moveZoomBar) │ │ │ │ - }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - OpenLayers.Control.PanZoom.prototype.onButtonClick.apply(this, arguments); │ │ │ │ - if (evt.buttonElement === this.zoombarDiv) { │ │ │ │ - var levels = evt.buttonXY.y / this.zoomStopHeight; │ │ │ │ - if (this.forceFixedZoomLevel || !this.map.fractionalZoom) { │ │ │ │ - levels = Math.floor(levels) │ │ │ │ + }, │ │ │ │ + dct: { │ │ │ │ + "*": function(node, obj) { │ │ │ │ + var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ + if (!OpenLayers.Util.isArray(obj[name])) { │ │ │ │ + obj[name] = [] │ │ │ │ + } │ │ │ │ + obj[name].push(this.getChildValue(node)) │ │ │ │ } │ │ │ │ - var zoom = this.map.getNumZoomLevels() - 1 - levels; │ │ │ │ - zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1); │ │ │ │ - this.map.zoomTo(zoom) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - passEventToSlider: function(evt) { │ │ │ │ - this.sliderEvents.handleBrowserEvent(evt) │ │ │ │ - }, │ │ │ │ - zoomBarDown: function(evt) { │ │ │ │ - if (!OpenLayers.Event.isLeftClick(evt) && !OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - this.map.events.on({ │ │ │ │ - touchmove: this.passEventToSlider, │ │ │ │ - mousemove: this.passEventToSlider, │ │ │ │ - mouseup: this.passEventToSlider, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.mouseDragStart = evt.xy.clone(); │ │ │ │ - this.zoomStart = evt.xy.clone(); │ │ │ │ - this.div.style.cursor = "move"; │ │ │ │ - this.zoombarDiv.offsets = null; │ │ │ │ - OpenLayers.Event.stop(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() │ │ │ │ + }, │ │ │ │ + ows: OpenLayers.Util.applyDefaults({ │ │ │ │ + BoundingBox: function(node, obj) { │ │ │ │ + if (obj.bounds) { │ │ │ │ + obj.BoundingBox = [{ │ │ │ │ + crs: obj.projection, │ │ │ │ + value: [obj.bounds.left, obj.bounds.bottom, obj.bounds.right, obj.bounds.top] │ │ │ │ + }]; │ │ │ │ + delete obj.projection; │ │ │ │ + delete obj.bounds │ │ │ │ + } │ │ │ │ + OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]["BoundingBox"].apply(this, arguments) │ │ │ │ } │ │ │ │ - this.deltaY = this.zoomStart.y - evt.xy.y; │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ - } │ │ │ │ + }, OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]) │ │ │ │ }, │ │ │ │ - zoomBarUp: function(evt) { │ │ │ │ - if (!OpenLayers.Event.isLeftClick(evt) && evt.type !== "touchend") { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - if (this.mouseDragStart) { │ │ │ │ - this.div.style.cursor = ""; │ │ │ │ - this.map.events.un({ │ │ │ │ - touchmove: this.passEventToSlider, │ │ │ │ - mouseup: this.passEventToSlider, │ │ │ │ - mousemove: this.passEventToSlider, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - var zoomLevel = this.map.zoom; │ │ │ │ - if (!this.forceFixedZoomLevel && this.map.fractionalZoom) { │ │ │ │ - zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ - zoomLevel = Math.min(Math.max(zoomLevel, 0), this.map.getNumZoomLevels() - 1) │ │ │ │ - } else { │ │ │ │ - zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ - zoomLevel = Math.max(Math.round(zoomLevel), 0) │ │ │ │ - } │ │ │ │ - this.map.zoomTo(zoomLevel); │ │ │ │ - this.mouseDragStart = null; │ │ │ │ - this.zoomStart = null; │ │ │ │ - this.deltaY = 0; │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ - } │ │ │ │ + write: function(options) { │ │ │ │ + var node = this.writeNode("csw:GetRecords", options); │ │ │ │ + node.setAttribute("xmlns:gmd", this.namespaces.gmd); │ │ │ │ + return OpenLayers.Format.XML.prototype.write.apply(this, [node]) │ │ │ │ }, │ │ │ │ - moveZoomBar: function() { │ │ │ │ - var newTop = (this.map.getNumZoomLevels() - 1 - this.map.getZoom()) * this.zoomStopHeight + this.startTop + 1; │ │ │ │ - this.slider.style.top = newTop + "px" │ │ │ │ + writers: { │ │ │ │ + csw: { │ │ │ │ + GetRecords: function(options) { │ │ │ │ + if (!options) { │ │ │ │ + options = {} │ │ │ │ + } │ │ │ │ + var node = this.createElementNSPlus("csw:GetRecords", { │ │ │ │ + attributes: { │ │ │ │ + service: "CSW", │ │ │ │ + version: this.version, │ │ │ │ + requestId: options.requestId || this.requestId, │ │ │ │ + resultType: options.resultType || this.resultType, │ │ │ │ + outputFormat: options.outputFormat || this.outputFormat, │ │ │ │ + outputSchema: options.outputSchema || this.outputSchema, │ │ │ │ + startPosition: options.startPosition || this.startPosition, │ │ │ │ + maxRecords: options.maxRecords || this.maxRecords │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.DistributedSearch || this.DistributedSearch) { │ │ │ │ + this.writeNode("csw:DistributedSearch", options.DistributedSearch || this.DistributedSearch, node) │ │ │ │ + } │ │ │ │ + var ResponseHandler = options.ResponseHandler || this.ResponseHandler; │ │ │ │ + if (OpenLayers.Util.isArray(ResponseHandler) && ResponseHandler.length > 0) { │ │ │ │ + for (var i = 0, len = ResponseHandler.length; i < len; i++) { │ │ │ │ + this.writeNode("csw:ResponseHandler", ResponseHandler[i], node) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.writeNode("Query", options.Query || this.Query, node); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + DistributedSearch: function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:DistributedSearch", { │ │ │ │ + attributes: { │ │ │ │ + hopCount: options.hopCount │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + ResponseHandler: function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:ResponseHandler", { │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Query: function(options) { │ │ │ │ + if (!options) { │ │ │ │ + options = {} │ │ │ │ + } │ │ │ │ + var node = this.createElementNSPlus("csw:Query", { │ │ │ │ + attributes: { │ │ │ │ + typeNames: options.typeNames || "csw:Record" │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + var ElementName = options.ElementName; │ │ │ │ + if (OpenLayers.Util.isArray(ElementName) && ElementName.length > 0) { │ │ │ │ + for (var i = 0, len = ElementName.length; i < len; i++) { │ │ │ │ + this.writeNode("csw:ElementName", ElementName[i], node) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.writeNode("csw:ElementSetName", options.ElementSetName || { │ │ │ │ + value: "summary" │ │ │ │ + }, node) │ │ │ │ + } │ │ │ │ + if (options.Constraint) { │ │ │ │ + this.writeNode("csw:Constraint", options.Constraint, node) │ │ │ │ + } │ │ │ │ + if (options.SortBy) { │ │ │ │ + this.writeNode("ogc:SortBy", options.SortBy, node) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + ElementName: function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:ElementName", { │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + ElementSetName: function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:ElementSetName", { │ │ │ │ + attributes: { │ │ │ │ + typeNames: options.typeNames │ │ │ │ + }, │ │ │ │ + value: options.value │ │ │ │ + }); │ │ │ │ + return node │ │ │ │ + }, │ │ │ │ + Constraint: function(options) { │ │ │ │ + var node = this.createElementNSPlus("csw:Constraint", { │ │ │ │ + attributes: { │ │ │ │ + version: options.version │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (options.Filter) { │ │ │ │ + var format = new OpenLayers.Format.Filter({ │ │ │ │ + version: options.version │ │ │ │ + }); │ │ │ │ + node.appendChild(format.write(options.Filter)) │ │ │ │ + } else if (options.CqlText) { │ │ │ │ + var child = this.createElementNSPlus("CqlText", { │ │ │ │ + value: options.CqlText.value │ │ │ │ + }); │ │ │ │ + node.appendChild(child) │ │ │ │ + } │ │ │ │ + return node │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + ogc: OpenLayers.Format.Filter.v1_1_0.prototype.writers["ogc"] │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PanZoomBar" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.CSWGetRecords.v2_0_2" │ │ │ │ }); │ │ │ │ -OpenLayers.Handler.Pinch = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - started: false, │ │ │ │ - stopDown: false, │ │ │ │ - pinching: false, │ │ │ │ - last: null, │ │ │ │ - start: null, │ │ │ │ - touchstart: function(evt) { │ │ │ │ - var propagate = true; │ │ │ │ - this.pinching = false; │ │ │ │ - if (OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ - this.started = true; │ │ │ │ - this.last = this.start = { │ │ │ │ - distance: this.getDistance(evt.touches), │ │ │ │ - delta: 0, │ │ │ │ - scale: 1 │ │ │ │ - }; │ │ │ │ - this.callback("start", [evt, this.start]); │ │ │ │ - propagate = !this.stopDown │ │ │ │ - } else if (this.started) { │ │ │ │ - return false │ │ │ │ - } else { │ │ │ │ - this.started = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null │ │ │ │ - } │ │ │ │ - OpenLayers.Event.preventDefault(evt); │ │ │ │ - return propagate │ │ │ │ - }, │ │ │ │ - touchmove: function(evt) { │ │ │ │ - if (this.started && OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ - this.pinching = true; │ │ │ │ - var current = this.getPinchData(evt); │ │ │ │ - this.callback("move", [evt, current]); │ │ │ │ - this.last = current; │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ - } else if (this.started) { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - touchend: function(evt) { │ │ │ │ - if (this.started && !OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ - this.started = false; │ │ │ │ - this.pinching = false; │ │ │ │ - this.callback("done", [evt, this.start, this.last]); │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - return true │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.pinching = false; │ │ │ │ - activated = true │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ +OpenLayers.Format.WMSDescribeLayer.v1_1_1 = OpenLayers.Class(OpenLayers.Format.WMSDescribeLayer, { │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.WMSDescribeLayer.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.started = false; │ │ │ │ - this.pinching = false; │ │ │ │ - this.start = null; │ │ │ │ - this.last = null; │ │ │ │ - deactivated = true │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - getDistance: function(touches) { │ │ │ │ - var t0 = touches[0]; │ │ │ │ - var t1 = touches[1]; │ │ │ │ - return Math.sqrt(Math.pow(t0.olClientX - t1.olClientX, 2) + Math.pow(t0.olClientY - t1.olClientY, 2)) │ │ │ │ - }, │ │ │ │ - getPinchData: function(evt) { │ │ │ │ - var distance = this.getDistance(evt.touches); │ │ │ │ - var scale = distance / this.start.distance; │ │ │ │ - return { │ │ │ │ - distance: distance, │ │ │ │ - delta: this.last.distance - distance, │ │ │ │ - scale: scale │ │ │ │ + var root = data.documentElement; │ │ │ │ + var children = root.childNodes; │ │ │ │ + var describelayer = { │ │ │ │ + layerDescriptions: [] │ │ │ │ + }; │ │ │ │ + var childNode, nodeName; │ │ │ │ + for (var i = 0; i < children.length; ++i) { │ │ │ │ + childNode = children[i]; │ │ │ │ + nodeName = childNode.nodeName; │ │ │ │ + if (nodeName == "LayerDescription") { │ │ │ │ + var layerName = childNode.getAttribute("name"); │ │ │ │ + var owsType = ""; │ │ │ │ + var owsURL = ""; │ │ │ │ + var typeName = ""; │ │ │ │ + if (childNode.getAttribute("owsType")) { │ │ │ │ + owsType = childNode.getAttribute("owsType"); │ │ │ │ + owsURL = childNode.getAttribute("owsURL") │ │ │ │ + } else { │ │ │ │ + if (childNode.getAttribute("wfs") != "") { │ │ │ │ + owsType = "WFS"; │ │ │ │ + owsURL = childNode.getAttribute("wfs") │ │ │ │ + } else if (childNode.getAttribute("wcs") != "") { │ │ │ │ + owsType = "WCS"; │ │ │ │ + owsURL = childNode.getAttribute("wcs") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var query = childNode.getElementsByTagName("Query"); │ │ │ │ + if (query.length > 0) { │ │ │ │ + typeName = query[0].getAttribute("typeName"); │ │ │ │ + if (!typeName) { │ │ │ │ + typeName = query[0].getAttribute("typename") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var layerDescription = { │ │ │ │ + layerName: layerName, │ │ │ │ + owsType: owsType, │ │ │ │ + owsURL: owsURL, │ │ │ │ + typeName: typeName │ │ │ │ + }; │ │ │ │ + describelayer.layerDescriptions.push(layerDescription); │ │ │ │ + describelayer.length = describelayer.layerDescriptions.length; │ │ │ │ + describelayer[describelayer.length - 1] = layerDescription │ │ │ │ + } else if (nodeName == "ServiceException") { │ │ │ │ + var parser = new OpenLayers.Format.OGCExceptionReport; │ │ │ │ + return { │ │ │ │ + error: parser.read(data) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return describelayer │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Pinch" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer.v1_1_1" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.PinchZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - pinchOrigin: null, │ │ │ │ - currentCenter: null, │ │ │ │ - autoActivate: true, │ │ │ │ - preserveCenter: false, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - this.handler = new OpenLayers.Handler.Pinch(this, { │ │ │ │ - start: this.pinchStart, │ │ │ │ - move: this.pinchMove, │ │ │ │ - done: this.pinchDone │ │ │ │ - }, this.handlerOptions) │ │ │ │ +OpenLayers.Format.WMSDescribeLayer.v1_1_0 = OpenLayers.Format.WMSDescribeLayer.v1_1_1; │ │ │ │ +OpenLayers.Format.SOSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.SOSCapabilities, { │ │ │ │ + namespaces: { │ │ │ │ + ows: "http://www.opengis.net/ows/1.1", │ │ │ │ + sos: "http://www.opengis.net/sos/1.0", │ │ │ │ + gml: "http://www.opengis.net/gml", │ │ │ │ + xlink: "http://www.w3.org/1999/xlink" │ │ │ │ }, │ │ │ │ - pinchStart: function(evt, pinchData) { │ │ │ │ - var xy = this.preserveCenter ? this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ - this.pinchOrigin = xy; │ │ │ │ - this.currentCenter = xy │ │ │ │ + regExes: { │ │ │ │ + trimSpace: /^\s*|\s*$/g, │ │ │ │ + removeSpace: /\s*/g, │ │ │ │ + splitSpace: /\s+/, │ │ │ │ + trimComma: /\s*,\s*/g │ │ │ │ }, │ │ │ │ - pinchMove: function(evt, pinchData) { │ │ │ │ - var scale = pinchData.scale; │ │ │ │ - var containerOrigin = this.map.layerContainerOriginPx; │ │ │ │ - var pinchOrigin = this.pinchOrigin; │ │ │ │ - var current = this.preserveCenter ? this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ - var dx = Math.round(containerOrigin.x + current.x - pinchOrigin.x + (scale - 1) * (containerOrigin.x - pinchOrigin.x)); │ │ │ │ - var dy = Math.round(containerOrigin.y + current.y - pinchOrigin.y + (scale - 1) * (containerOrigin.y - pinchOrigin.y)); │ │ │ │ - this.map.applyTransform(dx, dy, scale); │ │ │ │ - this.currentCenter = current │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options │ │ │ │ }, │ │ │ │ - pinchDone: function(evt, start, last) { │ │ │ │ - this.map.applyTransform(); │ │ │ │ - var zoom = this.map.getZoomForResolution(this.map.getResolution() / last.scale, true); │ │ │ │ - if (zoom !== this.map.getZoom() || !this.currentCenter.equals(this.pinchOrigin)) { │ │ │ │ - var resolution = this.map.getResolutionForZoom(zoom); │ │ │ │ - var location = this.map.getLonLatFromPixel(this.pinchOrigin); │ │ │ │ - var zoomPixel = this.currentCenter; │ │ │ │ - var size = this.map.getSize(); │ │ │ │ - location.lon += resolution * (size.w / 2 - zoomPixel.x); │ │ │ │ - location.lat -= resolution * (size.h / 2 - zoomPixel.y); │ │ │ │ - this.map.div.clientWidth = this.map.div.clientWidth; │ │ │ │ - this.map.setCenter(location, zoom) │ │ │ │ + read: function(data) { │ │ │ │ + if (typeof data == "string") { │ │ │ │ + data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PinchZoom" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ZoomIn = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.zoomIn() │ │ │ │ + if (data && data.nodeType == 9) { │ │ │ │ + data = data.documentElement │ │ │ │ } │ │ │ │ + var capabilities = {}; │ │ │ │ + this.readNode(data, capabilities); │ │ │ │ + return capabilities │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomIn" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ScaleLine = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - maxWidth: 100, │ │ │ │ - topOutUnits: "km", │ │ │ │ - topInUnits: "m", │ │ │ │ - bottomOutUnits: "mi", │ │ │ │ - bottomInUnits: "ft", │ │ │ │ - eTop: null, │ │ │ │ - eBottom: null, │ │ │ │ - geodesic: false, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.eTop) { │ │ │ │ - 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" │ │ │ │ + readers: { │ │ │ │ + gml: OpenLayers.Util.applyDefaults({ │ │ │ │ + name: function(node, obj) { │ │ │ │ + obj.name = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + TimePeriod: function(node, obj) { │ │ │ │ + obj.timePeriod = {}; │ │ │ │ + this.readChildNodes(node, obj.timePeriod) │ │ │ │ + }, │ │ │ │ + beginPosition: function(node, timePeriod) { │ │ │ │ + timePeriod.beginPosition = this.getChildValue(node) │ │ │ │ + }, │ │ │ │ + endPosition: function(node, timePeriod) { │ │ │ │ + timePeriod.endPosition = this.getChildValue(node) │ │ │ │ } │ │ │ │ - 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" │ │ │ │ + }, OpenLayers.Format.GML.v3.prototype.readers["gml"]), │ │ │ │ + sos: { │ │ │ │ + Capabilities: function(node, obj) { │ │ │ │ + this.readChildNodes(node, obj) │ │ │ │ + }, │ │ │ │ + Contents: function(node, obj) { │ │ │ │ + obj.contents = {}; │ │ │ │ + this.readChildNodes(node, obj.contents) │ │ │ │ + }, │ │ │ │ + ObservationOfferingList: function(node, contents) { │ │ │ │ + contents.offeringList = {}; │ │ │ │ + this.readChildNodes(node, contents.offeringList) │ │ │ │ + }, │ │ │ │ + ObservationOffering: function(node, offeringList) { │ │ │ │ + var id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ + offeringList[id] = { │ │ │ │ + procedures: [], │ │ │ │ + observedProperties: [], │ │ │ │ + featureOfInterestIds: [], │ │ │ │ + responseFormats: [], │ │ │ │ + resultModels: [], │ │ │ │ + responseModes: [] │ │ │ │ + }; │ │ │ │ + this.readChildNodes(node, offeringList[id]) │ │ │ │ + }, │ │ │ │ + time: function(node, offering) { │ │ │ │ + offering.time = {}; │ │ │ │ + this.readChildNodes(node, offering.time) │ │ │ │ + }, │ │ │ │ + procedure: function(node, offering) { │ │ │ │ + offering.procedures.push(this.getAttributeNS(node, this.namespaces.xlink, "href")) │ │ │ │ + }, │ │ │ │ + observedProperty: function(node, offering) { │ │ │ │ + offering.observedProperties.push(this.getAttributeNS(node, this.namespaces.xlink, "href")) │ │ │ │ + }, │ │ │ │ + featureOfInterest: function(node, offering) { │ │ │ │ + offering.featureOfInterestIds.push(this.getAttributeNS(node, this.namespaces.xlink, "href")) │ │ │ │ + }, │ │ │ │ + responseFormat: function(node, offering) { │ │ │ │ + offering.responseFormats.push(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + resultModel: function(node, offering) { │ │ │ │ + offering.resultModels.push(this.getChildValue(node)) │ │ │ │ + }, │ │ │ │ + responseMode: function(node, offering) { │ │ │ │ + offering.responseModes.push(this.getChildValue(node)) │ │ │ │ } │ │ │ │ - } │ │ │ │ - this.map.events.register("moveend", this, this.update); │ │ │ │ - this.update(); │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - getBarLen: function(maxLen) { │ │ │ │ - var digits = parseInt(Math.log(maxLen) / Math.log(10)); │ │ │ │ - var pow10 = Math.pow(10, digits); │ │ │ │ - var firstChar = parseInt(maxLen / pow10); │ │ │ │ - var barLen; │ │ │ │ - if (firstChar > 5) { │ │ │ │ - barLen = 5 │ │ │ │ - } else if (firstChar > 2) { │ │ │ │ - barLen = 2 │ │ │ │ - } else { │ │ │ │ - barLen = 1 │ │ │ │ - } │ │ │ │ - return barLen * pow10 │ │ │ │ - }, │ │ │ │ - update: function() { │ │ │ │ - var res = this.map.getResolution(); │ │ │ │ - if (!res) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var curMapUnits = this.map.getUnits(); │ │ │ │ - var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ - var maxSizeData = this.maxWidth * res * inches[curMapUnits]; │ │ │ │ - var geodesicRatio = 1; │ │ │ │ - if (this.geodesic === true) { │ │ │ │ - var maxSizeGeodesic = (this.map.getGeodesicPixelSize().w || 1e-6) * this.maxWidth; │ │ │ │ - var maxSizeKilometers = maxSizeData / inches["km"]; │ │ │ │ - geodesicRatio = maxSizeGeodesic / maxSizeKilometers; │ │ │ │ - maxSizeData *= geodesicRatio │ │ │ │ - } │ │ │ │ - var topUnits; │ │ │ │ - var bottomUnits; │ │ │ │ - if (maxSizeData > 1e5) { │ │ │ │ - topUnits = this.topOutUnits; │ │ │ │ - bottomUnits = this.bottomOutUnits │ │ │ │ - } else { │ │ │ │ - topUnits = this.topInUnits; │ │ │ │ - bottomUnits = this.bottomInUnits │ │ │ │ - } │ │ │ │ - var topMax = maxSizeData / inches[topUnits]; │ │ │ │ - var bottomMax = maxSizeData / inches[bottomUnits]; │ │ │ │ - var topRounded = this.getBarLen(topMax); │ │ │ │ - var bottomRounded = this.getBarLen(bottomMax); │ │ │ │ - topMax = topRounded / inches[curMapUnits] * inches[topUnits]; │ │ │ │ - bottomMax = bottomRounded / inches[curMapUnits] * inches[bottomUnits]; │ │ │ │ - var topPx = topMax / res / geodesicRatio; │ │ │ │ - var bottomPx = bottomMax / res / geodesicRatio; │ │ │ │ - if (this.eBottom.style.visibility == "visible") { │ │ │ │ - this.eBottom.style.width = Math.round(bottomPx) + "px"; │ │ │ │ - this.eBottom.innerHTML = bottomRounded + " " + bottomUnits │ │ │ │ - } │ │ │ │ - if (this.eTop.style.visibility == "visible") { │ │ │ │ - this.eTop.style.width = Math.round(topPx) + "px"; │ │ │ │ - this.eTop.innerHTML = topRounded + " " + topUnits │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ScaleLine" │ │ │ │ + CLASS_NAME: "OpenLayers.Format.SOSCapabilities.v1_0_0" │ │ │ │ }); │ │ │ │ OpenLayers.Handler.Hover = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ delay: 500, │ │ │ │ pixelTolerance: null, │ │ │ │ stopMove: false, │ │ │ │ px: null, │ │ │ │ timerId: null, │ │ │ │ @@ -22888,1372 +27702,1324 @@ │ │ │ │ this.clearTimer(); │ │ │ │ deactivated = true │ │ │ │ } │ │ │ │ return deactivated │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Handler.Hover" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WMSGetFeatureInfo = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - layerIdentifier: "_layer", │ │ │ │ - featureIdentifier: "_feature", │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ - }, │ │ │ │ - gmlFormat: null, │ │ │ │ - read: function(data) { │ │ │ │ - var result; │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ +OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + EVENTMAP: { │ │ │ │ + click: { │ │ │ │ + in: "click", │ │ │ │ + out: "clickout" │ │ │ │ + }, │ │ │ │ + mousemove: { │ │ │ │ + in: "over", │ │ │ │ + out: "out" │ │ │ │ + }, │ │ │ │ + dblclick: { │ │ │ │ + in: "dblclick", │ │ │ │ + out: null │ │ │ │ + }, │ │ │ │ + mousedown: { │ │ │ │ + in: null, │ │ │ │ + out: null │ │ │ │ + }, │ │ │ │ + mouseup: { │ │ │ │ + in: null, │ │ │ │ + out: null │ │ │ │ + }, │ │ │ │ + touchstart: { │ │ │ │ + in: "click", │ │ │ │ + out: "clickout" │ │ │ │ } │ │ │ │ - var root = data.documentElement; │ │ │ │ - if (root) { │ │ │ │ - var scope = this; │ │ │ │ - var read = this["read_" + root.nodeName]; │ │ │ │ - if (read) { │ │ │ │ - result = read.call(this, root) │ │ │ │ - } else { │ │ │ │ - result = new OpenLayers.Format.GML(this.options ? this.options : {}).read(data) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - result = data │ │ │ │ + }, │ │ │ │ + feature: null, │ │ │ │ + lastFeature: null, │ │ │ │ + down: null, │ │ │ │ + up: null, │ │ │ │ + clickTolerance: 4, │ │ │ │ + geometryTypes: null, │ │ │ │ + stopClick: true, │ │ │ │ + stopDown: true, │ │ │ │ + stopUp: false, │ │ │ │ + initialize: function(control, layer, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ + this.layer = layer │ │ │ │ + }, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return OpenLayers.Event.isMultiTouch(evt) ? true : this.mousedown(evt) │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + OpenLayers.Event.preventDefault(evt) │ │ │ │ + }, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + if (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ + this.down = evt.xy │ │ │ │ } │ │ │ │ - return result │ │ │ │ + return this.handle(evt) ? !this.stopDown : true │ │ │ │ }, │ │ │ │ - read_msGMLOutput: function(data) { │ │ │ │ - var response = []; │ │ │ │ - var layerNodes = this.getSiblingNodesByTagCriteria(data, this.layerIdentifier); │ │ │ │ - if (layerNodes) { │ │ │ │ - for (var i = 0, len = layerNodes.length; i < len; ++i) { │ │ │ │ - var node = layerNodes[i]; │ │ │ │ - var layerName = node.nodeName; │ │ │ │ - if (node.prefix) { │ │ │ │ - layerName = layerName.split(":")[1] │ │ │ │ - } │ │ │ │ - var layerName = layerName.replace(this.layerIdentifier, ""); │ │ │ │ - var featureNodes = this.getSiblingNodesByTagCriteria(node, this.featureIdentifier); │ │ │ │ - if (featureNodes) { │ │ │ │ - for (var j = 0; j < featureNodes.length; j++) { │ │ │ │ - var featureNode = featureNodes[j]; │ │ │ │ - var geomInfo = this.parseGeometry(featureNode); │ │ │ │ - var attributes = this.parseAttributes(featureNode); │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geomInfo.geometry, attributes, null); │ │ │ │ - feature.bounds = geomInfo.bounds; │ │ │ │ - feature.type = layerName; │ │ │ │ - response.push(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + mouseup: function(evt) { │ │ │ │ + this.up = evt.xy; │ │ │ │ + return this.handle(evt) ? !this.stopUp : true │ │ │ │ + }, │ │ │ │ + click: function(evt) { │ │ │ │ + return this.handle(evt) ? !this.stopClick : true │ │ │ │ + }, │ │ │ │ + mousemove: function(evt) { │ │ │ │ + if (!this.callbacks["over"] && !this.callbacks["out"]) { │ │ │ │ + return true │ │ │ │ } │ │ │ │ - return response │ │ │ │ + this.handle(evt); │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - read_FeatureInfoResponse: function(data) { │ │ │ │ - var response = []; │ │ │ │ - var featureNodes = this.getElementsByTagNameNS(data, "*", "FIELDS"); │ │ │ │ - for (var i = 0, len = featureNodes.length; i < len; i++) { │ │ │ │ - var featureNode = featureNodes[i]; │ │ │ │ - var geom = null; │ │ │ │ - var attributes = {}; │ │ │ │ - var j; │ │ │ │ - var jlen = featureNode.attributes.length; │ │ │ │ - if (jlen > 0) { │ │ │ │ - for (j = 0; j < jlen; j++) { │ │ │ │ - var attribute = featureNode.attributes[j]; │ │ │ │ - attributes[attribute.nodeName] = attribute.nodeValue │ │ │ │ + dblclick: function(evt) { │ │ │ │ + return !this.handle(evt) │ │ │ │ + }, │ │ │ │ + geometryTypeMatches: function(feature) { │ │ │ │ + return this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1 │ │ │ │ + }, │ │ │ │ + handle: function(evt) { │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + this.feature = null │ │ │ │ + } │ │ │ │ + var type = evt.type; │ │ │ │ + var handled = false; │ │ │ │ + var previouslyIn = !!this.feature; │ │ │ │ + var click = type == "click" || type == "dblclick" || type == "touchstart"; │ │ │ │ + this.feature = this.layer.getFeatureFromEvent(evt); │ │ │ │ + if (this.feature && !this.feature.layer) { │ │ │ │ + this.feature = null │ │ │ │ + } │ │ │ │ + if (this.lastFeature && !this.lastFeature.layer) { │ │ │ │ + this.lastFeature = null │ │ │ │ + } │ │ │ │ + if (this.feature) { │ │ │ │ + if (type === "touchstart") { │ │ │ │ + OpenLayers.Event.preventDefault(evt) │ │ │ │ + } │ │ │ │ + var inNew = this.feature != this.lastFeature; │ │ │ │ + if (this.geometryTypeMatches(this.feature)) { │ │ │ │ + if (previouslyIn && inNew) { │ │ │ │ + if (this.lastFeature) { │ │ │ │ + this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ + } │ │ │ │ + this.triggerCallback(type, "in", [this.feature]) │ │ │ │ + } else if (!previouslyIn || click) { │ │ │ │ + this.triggerCallback(type, "in", [this.feature]) │ │ │ │ } │ │ │ │ + this.lastFeature = this.feature; │ │ │ │ + handled = true │ │ │ │ } else { │ │ │ │ - var nodes = featureNode.childNodes; │ │ │ │ - for (j = 0, jlen = nodes.length; j < jlen; ++j) { │ │ │ │ - var node = nodes[j]; │ │ │ │ - if (node.nodeType != 3) { │ │ │ │ - attributes[node.getAttribute("name")] = node.getAttribute("value") │ │ │ │ - } │ │ │ │ + if (this.lastFeature && (previouslyIn && inNew || click)) { │ │ │ │ + this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ } │ │ │ │ + this.feature = null │ │ │ │ } │ │ │ │ - response.push(new OpenLayers.Feature.Vector(geom, attributes, null)) │ │ │ │ + } else if (this.lastFeature && (previouslyIn || click)) { │ │ │ │ + this.triggerCallback(type, "out", [this.lastFeature]) │ │ │ │ } │ │ │ │ - return response │ │ │ │ + return handled │ │ │ │ }, │ │ │ │ - getSiblingNodesByTagCriteria: function(node, criteria) { │ │ │ │ - var nodes = []; │ │ │ │ - var children, tagName, n, matchNodes, child; │ │ │ │ - if (node && node.hasChildNodes()) { │ │ │ │ - children = node.childNodes; │ │ │ │ - n = children.length; │ │ │ │ - for (var k = 0; k < n; k++) { │ │ │ │ - child = children[k]; │ │ │ │ - while (child && child.nodeType != 1) { │ │ │ │ - child = child.nextSibling; │ │ │ │ - k++ │ │ │ │ - } │ │ │ │ - tagName = child ? child.nodeName : ""; │ │ │ │ - if (tagName.length > 0 && tagName.indexOf(criteria) > -1) { │ │ │ │ - nodes.push(child) │ │ │ │ - } else { │ │ │ │ - matchNodes = this.getSiblingNodesByTagCriteria(child, criteria); │ │ │ │ - if (matchNodes.length > 0) { │ │ │ │ - nodes.length == 0 ? nodes = matchNodes : nodes.push(matchNodes) │ │ │ │ - } │ │ │ │ + triggerCallback: function(type, mode, args) { │ │ │ │ + var key = this.EVENTMAP[type][mode]; │ │ │ │ + if (key) { │ │ │ │ + if (type == "click" && this.up && this.down) { │ │ │ │ + var dpx = Math.sqrt(Math.pow(this.up.x - this.down.x, 2) + Math.pow(this.up.y - this.down.y, 2)); │ │ │ │ + if (dpx <= this.clickTolerance) { │ │ │ │ + this.callback(key, args) │ │ │ │ } │ │ │ │ + this.up = this.down = null │ │ │ │ + } else { │ │ │ │ + this.callback(key, args) │ │ │ │ } │ │ │ │ } │ │ │ │ - return nodes │ │ │ │ }, │ │ │ │ - parseAttributes: function(node) { │ │ │ │ - var attributes = {}; │ │ │ │ - if (node.nodeType == 1) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var n = children.length; │ │ │ │ - for (var i = 0; i < n; ++i) { │ │ │ │ - var child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - var grandchildren = child.childNodes; │ │ │ │ - var name = child.prefix ? child.nodeName.split(":")[1] : child.nodeName; │ │ │ │ - if (grandchildren.length == 0) { │ │ │ │ - attributes[name] = null │ │ │ │ - } else if (grandchildren.length == 1) { │ │ │ │ - var grandchild = grandchildren[0]; │ │ │ │ - if (grandchild.nodeType == 3 || grandchild.nodeType == 4) { │ │ │ │ - var value = grandchild.nodeValue.replace(this.regExes.trimSpace, ""); │ │ │ │ - attributes[name] = value │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + this.map.events.on({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + activated = true │ │ │ │ } │ │ │ │ - return attributes │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - parseGeometry: function(node) { │ │ │ │ - if (!this.gmlFormat) { │ │ │ │ - this.gmlFormat = new OpenLayers.Format.GML │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.moveLayerBack(); │ │ │ │ + this.feature = null; │ │ │ │ + this.lastFeature = null; │ │ │ │ + this.down = null; │ │ │ │ + this.up = null; │ │ │ │ + this.map.events.un({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ - var feature = this.gmlFormat.parseFeature(node); │ │ │ │ - var geometry, bounds = null; │ │ │ │ - if (feature) { │ │ │ │ - geometry = feature.geometry && feature.geometry.clone(); │ │ │ │ - bounds = feature.bounds && feature.bounds.clone(); │ │ │ │ - feature.destroy() │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + handleMapEvents: function(evt) { │ │ │ │ + if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ + this.moveLayerToTop() │ │ │ │ } │ │ │ │ - return { │ │ │ │ - geometry: geometry, │ │ │ │ - bounds: bounds │ │ │ │ + }, │ │ │ │ + moveLayerToTop: function() { │ │ │ │ + var index = Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) + 1; │ │ │ │ + this.layer.setZIndex(index) │ │ │ │ + }, │ │ │ │ + moveLayerBack: function() { │ │ │ │ + var index = this.layer.getZIndex() - 1; │ │ │ │ + if (index >= this.map.Z_INDEX_BASE["Feature"]) { │ │ │ │ + this.layer.setZIndex(index) │ │ │ │ + } else { │ │ │ │ + this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer)) │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSGetFeatureInfo" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Feature" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.WMSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - hover: false, │ │ │ │ - drillDown: false, │ │ │ │ - maxFeatures: 10, │ │ │ │ - clickCallback: "click", │ │ │ │ - output: "features", │ │ │ │ - layers: null, │ │ │ │ - queryVisible: false, │ │ │ │ - url: null, │ │ │ │ - layerUrls: null, │ │ │ │ - infoFormat: "text/html", │ │ │ │ - vendorParams: {}, │ │ │ │ - format: null, │ │ │ │ - formatOptions: null, │ │ │ │ - handler: null, │ │ │ │ - hoverRequest: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.handlerOptions = options.handlerOptions || {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.WMSGetFeatureInfo(options.formatOptions) │ │ │ │ - } │ │ │ │ - if (this.drillDown === true) { │ │ │ │ - this.hover = false │ │ │ │ - } │ │ │ │ - if (this.hover) { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ - move: this.cancelHover, │ │ │ │ - pause: this.getInfoForHover │ │ │ │ - }, OpenLayers.Util.extend(this.handlerOptions.hover || {}, { │ │ │ │ - delay: 250 │ │ │ │ - })) │ │ │ │ - } else { │ │ │ │ - var callbacks = {}; │ │ │ │ - callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ - this.handler = new OpenLayers.Handler.Click(this, callbacks, this.handlerOptions.click || {}) │ │ │ │ +OpenLayers.Handler.Point = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + point: null, │ │ │ │ + layer: null, │ │ │ │ + multi: false, │ │ │ │ + citeCompliant: false, │ │ │ │ + mouseDown: false, │ │ │ │ + stoppedDown: null, │ │ │ │ + lastDown: null, │ │ │ │ + lastUp: null, │ │ │ │ + persist: false, │ │ │ │ + stopDown: false, │ │ │ │ + stopUp: false, │ │ │ │ + layerOptions: null, │ │ │ │ + pixelTolerance: 5, │ │ │ │ + lastTouchPx: null, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ + this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style["default"], {}) │ │ │ │ } │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments) │ │ │ │ }, │ │ │ │ - getInfoForClick: function(evt) { │ │ │ │ - this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ - xy: evt.xy │ │ │ │ - }); │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - this.request(evt.xy, {}) │ │ │ │ + activate: function() { │ │ │ │ + if (!OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + var options = OpenLayers.Util.extend({ │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + calculateInRange: OpenLayers.Function.True, │ │ │ │ + wrapDateLine: this.citeCompliant │ │ │ │ + }, this.layerOptions); │ │ │ │ + this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ + this.map.addLayer(this.layer); │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - getInfoForHover: function(evt) { │ │ │ │ - this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ - xy: evt.xy │ │ │ │ - }); │ │ │ │ - this.request(evt.xy, { │ │ │ │ - hover: true │ │ │ │ + createFeature: function(pixel) { │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + this.callback("create", [this.point.geometry, this.point]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.layer.addFeatures([this.point], { │ │ │ │ + silent: true │ │ │ │ }) │ │ │ │ }, │ │ │ │ - cancelHover: function() { │ │ │ │ - if (this.hoverRequest) { │ │ │ │ - this.hoverRequest.abort(); │ │ │ │ - this.hoverRequest = null │ │ │ │ + deactivate: function() { │ │ │ │ + if (!OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + this.cancel(); │ │ │ │ + if (this.layer.map != null) { │ │ │ │ + this.destroyFeature(true); │ │ │ │ + this.layer.destroy(false) │ │ │ │ } │ │ │ │ + this.layer = null; │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - findLayers: function() { │ │ │ │ - var candidates = this.layers || this.map.layers; │ │ │ │ - var layers = []; │ │ │ │ - var layer, url; │ │ │ │ - for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ - layer = candidates[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMS && (!this.queryVisible || layer.getVisibility())) { │ │ │ │ - url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ - if (this.drillDown === false && !this.url) { │ │ │ │ - this.url = url │ │ │ │ - } │ │ │ │ - if (this.drillDown === true || this.urlMatches(url)) { │ │ │ │ - layers.push(layer) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + destroyFeature: function(force) { │ │ │ │ + if (this.layer && (force || !this.persist)) { │ │ │ │ + this.layer.destroyFeatures() │ │ │ │ } │ │ │ │ - return layers │ │ │ │ + this.point = null │ │ │ │ }, │ │ │ │ - urlMatches: function(url) { │ │ │ │ - var matches = OpenLayers.Util.isEquivalentUrl(this.url, url); │ │ │ │ - if (!matches && this.layerUrls) { │ │ │ │ - for (var i = 0, len = this.layerUrls.length; i < len; ++i) { │ │ │ │ - if (OpenLayers.Util.isEquivalentUrl(this.layerUrls[i], url)) { │ │ │ │ - matches = true; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ + destroyPersistedFeature: function() { │ │ │ │ + var layer = this.layer; │ │ │ │ + if (layer && layer.features.length > 1) { │ │ │ │ + this.layer.features[0].destroy() │ │ │ │ } │ │ │ │ - return matches │ │ │ │ }, │ │ │ │ - buildWMSOptions: function(url, layers, clickPosition, format) { │ │ │ │ - var layerNames = [], │ │ │ │ - styleNames = []; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - if (layers[i].params.LAYERS != null) { │ │ │ │ - layerNames = layerNames.concat(layers[i].params.LAYERS); │ │ │ │ - styleNames = styleNames.concat(this.getStyleNames(layers[i])) │ │ │ │ - } │ │ │ │ + finalize: function(cancel) { │ │ │ │ + var key = cancel ? "cancel" : "done"; │ │ │ │ + this.mouseDown = false; │ │ │ │ + this.lastDown = null; │ │ │ │ + this.lastUp = null; │ │ │ │ + this.lastTouchPx = null; │ │ │ │ + this.callback(key, [this.geometryClone()]); │ │ │ │ + this.destroyFeature(cancel) │ │ │ │ + }, │ │ │ │ + cancel: function() { │ │ │ │ + this.finalize(true) │ │ │ │ + }, │ │ │ │ + click: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + dblclick: function(evt) { │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + modifyFeature: function(pixel) { │ │ │ │ + if (!this.point) { │ │ │ │ + this.createFeature(pixel) │ │ │ │ } │ │ │ │ - var firstLayer = layers[0]; │ │ │ │ - var projection = this.map.getProjection(); │ │ │ │ - var layerProj = firstLayer.projection; │ │ │ │ - if (layerProj && layerProj.equals(this.map.getProjectionObject())) { │ │ │ │ - projection = layerProj.getCode() │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + this.point.geometry.x = lonlat.lon; │ │ │ │ + this.point.geometry.y = lonlat.lat; │ │ │ │ + this.callback("modify", [this.point.geometry, this.point, false]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.drawFeature() │ │ │ │ + }, │ │ │ │ + drawFeature: function() { │ │ │ │ + this.layer.drawFeature(this.point, this.style) │ │ │ │ + }, │ │ │ │ + getGeometry: function() { │ │ │ │ + var geometry = this.point && this.point.geometry; │ │ │ │ + if (geometry && this.multi) { │ │ │ │ + geometry = new OpenLayers.Geometry.MultiPoint([geometry]) │ │ │ │ } │ │ │ │ - var params = OpenLayers.Util.extend({ │ │ │ │ - service: "WMS", │ │ │ │ - version: firstLayer.params.VERSION, │ │ │ │ - request: "GetFeatureInfo", │ │ │ │ - exceptions: firstLayer.params.EXCEPTIONS, │ │ │ │ - bbox: this.map.getExtent().toBBOX(null, firstLayer.reverseAxisOrder()), │ │ │ │ - feature_count: this.maxFeatures, │ │ │ │ - height: this.map.getSize().h, │ │ │ │ - width: this.map.getSize().w, │ │ │ │ - format: format, │ │ │ │ - info_format: firstLayer.params.INFO_FORMAT || this.infoFormat │ │ │ │ - }, parseFloat(firstLayer.params.VERSION) >= 1.3 ? { │ │ │ │ - crs: projection, │ │ │ │ - i: parseInt(clickPosition.x), │ │ │ │ - j: parseInt(clickPosition.y) │ │ │ │ - } : { │ │ │ │ - srs: projection, │ │ │ │ - x: parseInt(clickPosition.x), │ │ │ │ - y: parseInt(clickPosition.y) │ │ │ │ - }); │ │ │ │ - if (layerNames.length != 0) { │ │ │ │ - params = OpenLayers.Util.extend({ │ │ │ │ - layers: layerNames, │ │ │ │ - query_layers: layerNames, │ │ │ │ - styles: styleNames │ │ │ │ - }, params) │ │ │ │ + return geometry │ │ │ │ + }, │ │ │ │ + geometryClone: function() { │ │ │ │ + var geom = this.getGeometry(); │ │ │ │ + return geom && geom.clone() │ │ │ │ + }, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + return this.down(evt) │ │ │ │ + }, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + this.lastTouchPx = evt.xy; │ │ │ │ + return this.down(evt) │ │ │ │ + }, │ │ │ │ + mousemove: function(evt) { │ │ │ │ + return this.move(evt) │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + this.lastTouchPx = evt.xy; │ │ │ │ + return this.move(evt) │ │ │ │ + }, │ │ │ │ + mouseup: function(evt) { │ │ │ │ + return this.up(evt) │ │ │ │ + }, │ │ │ │ + touchend: function(evt) { │ │ │ │ + evt.xy = this.lastTouchPx; │ │ │ │ + return this.up(evt) │ │ │ │ + }, │ │ │ │ + down: function(evt) { │ │ │ │ + this.mouseDown = true; │ │ │ │ + this.lastDown = evt.xy; │ │ │ │ + if (!this.touch) { │ │ │ │ + this.modifyFeature(evt.xy) │ │ │ │ } │ │ │ │ - OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ - return { │ │ │ │ - url: url, │ │ │ │ - params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ - callback: function(request) { │ │ │ │ - this.handleResponse(clickPosition, request, url) │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + return !this.stopDown │ │ │ │ + }, │ │ │ │ + move: function(evt) { │ │ │ │ + if (!this.touch && (!this.mouseDown || this.stoppedDown)) { │ │ │ │ + this.modifyFeature(evt.xy) │ │ │ │ } │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - getStyleNames: function(layer) { │ │ │ │ - var styleNames; │ │ │ │ - if (layer.params.STYLES) { │ │ │ │ - styleNames = layer.params.STYLES │ │ │ │ - } else { │ │ │ │ - if (OpenLayers.Util.isArray(layer.params.LAYERS)) { │ │ │ │ - styleNames = new Array(layer.params.LAYERS.length) │ │ │ │ - } else { │ │ │ │ - styleNames = layer.params.LAYERS.replace(/[^,]/g, "") │ │ │ │ + up: function(evt) { │ │ │ │ + this.mouseDown = false; │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + if (!this.checkModifiers(evt)) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + if (this.lastUp && this.lastUp.equals(evt.xy)) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy, this.pixelTolerance)) { │ │ │ │ + if (this.touch) { │ │ │ │ + this.modifyFeature(evt.xy) │ │ │ │ + } │ │ │ │ + if (this.persist) { │ │ │ │ + this.destroyPersistedFeature() │ │ │ │ } │ │ │ │ + this.lastUp = evt.xy; │ │ │ │ + this.finalize(); │ │ │ │ + return !this.stopUp │ │ │ │ + } else { │ │ │ │ + return true │ │ │ │ } │ │ │ │ - return styleNames │ │ │ │ }, │ │ │ │ - request: function(clickPosition, options) { │ │ │ │ - var layers = this.findLayers(); │ │ │ │ - if (layers.length == 0) { │ │ │ │ - this.events.triggerEvent("nogetfeatureinfo"); │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - return │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + this.mouseDown = false │ │ │ │ } │ │ │ │ - options = options || {}; │ │ │ │ - if (this.drillDown === false) { │ │ │ │ - var wmsOptions = this.buildWMSOptions(this.url, layers, clickPosition, layers[0].params.FORMAT); │ │ │ │ - var request = OpenLayers.Request.GET(wmsOptions); │ │ │ │ - if (options.hover === true) { │ │ │ │ - this.hoverRequest = request │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this._requestCount = 0; │ │ │ │ - this._numRequests = 0; │ │ │ │ - this.features = []; │ │ │ │ - var services = {}, │ │ │ │ - url; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - var service, found = false; │ │ │ │ - url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ - if (url in services) { │ │ │ │ - services[url].push(layer) │ │ │ │ - } else { │ │ │ │ - this._numRequests++; │ │ │ │ - services[url] = [layer] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var layers; │ │ │ │ - for (var url in services) { │ │ │ │ - layers = services[url]; │ │ │ │ - var wmsOptions = this.buildWMSOptions(url, layers, clickPosition, layers[0].params.FORMAT); │ │ │ │ - OpenLayers.Request.GET(wmsOptions) │ │ │ │ + }, │ │ │ │ + passesTolerance: function(pixel1, pixel2, tolerance) { │ │ │ │ + var passes = true; │ │ │ │ + if (tolerance != null && pixel1 && pixel2) { │ │ │ │ + var dist = pixel1.distanceTo(pixel2); │ │ │ │ + if (dist > tolerance) { │ │ │ │ + passes = false │ │ │ │ } │ │ │ │ } │ │ │ │ + return passes │ │ │ │ }, │ │ │ │ - triggerGetFeatureInfo: function(request, xy, features) { │ │ │ │ - this.events.triggerEvent("getfeatureinfo", { │ │ │ │ - text: request.responseText, │ │ │ │ - features: features, │ │ │ │ - request: request, │ │ │ │ - xy: xy │ │ │ │ - }); │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Point" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Path = OpenLayers.Class(OpenLayers.Handler.Point, { │ │ │ │ + line: null, │ │ │ │ + maxVertices: null, │ │ │ │ + doubleTouchTolerance: 20, │ │ │ │ + freehand: false, │ │ │ │ + freehandToggle: "shiftKey", │ │ │ │ + timerId: null, │ │ │ │ + redoStack: null, │ │ │ │ + createFeature: function(pixel) { │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + this.line = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString([this.point.geometry])); │ │ │ │ + this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.layer.addFeatures([this.line, this.point], { │ │ │ │ + silent: true │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - handleResponse: function(xy, request, url) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ + destroyFeature: function(force) { │ │ │ │ + OpenLayers.Handler.Point.prototype.destroyFeature.call(this, force); │ │ │ │ + this.line = null │ │ │ │ + }, │ │ │ │ + destroyPersistedFeature: function() { │ │ │ │ + var layer = this.layer; │ │ │ │ + if (layer && layer.features.length > 2) { │ │ │ │ + this.layer.features[0].destroy() │ │ │ │ } │ │ │ │ - var features = this.format.read(doc); │ │ │ │ - if (this.drillDown === false) { │ │ │ │ - this.triggerGetFeatureInfo(request, xy, features) │ │ │ │ - } else { │ │ │ │ - this._requestCount++; │ │ │ │ - if (this.output === "object") { │ │ │ │ - this._features = (this._features || []).concat({ │ │ │ │ - url: url, │ │ │ │ - features: features │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - this._features = (this._features || []).concat(features) │ │ │ │ - } │ │ │ │ - if (this._requestCount === this._numRequests) { │ │ │ │ - this.triggerGetFeatureInfo(request, xy, this._features.concat()); │ │ │ │ - delete this._features; │ │ │ │ - delete this._requestCount; │ │ │ │ - delete this._numRequests │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + removePoint: function() { │ │ │ │ + if (this.point) { │ │ │ │ + this.layer.removeFeatures([this.point]) │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.WMSGetFeatureInfo" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.OverviewMap = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - element: null, │ │ │ │ - ovmap: null, │ │ │ │ - size: { │ │ │ │ - w: 180, │ │ │ │ - h: 90 │ │ │ │ + addPoint: function(pixel) { │ │ │ │ + this.layer.removeFeatures([this.point]); │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat)); │ │ │ │ + this.line.geometry.addComponent(this.point.geometry, this.line.geometry.components.length); │ │ │ │ + this.layer.addFeatures([this.point]); │ │ │ │ + this.callback("point", [this.point.geometry, this.getGeometry()]); │ │ │ │ + this.callback("modify", [this.point.geometry, this.getSketch()]); │ │ │ │ + this.drawFeature(); │ │ │ │ + delete this.redoStack │ │ │ │ }, │ │ │ │ - layers: null, │ │ │ │ - minRectSize: 15, │ │ │ │ - minRectDisplayClass: "RectReplacement", │ │ │ │ - minRatio: 8, │ │ │ │ - maxRatio: 32, │ │ │ │ - mapOptions: null, │ │ │ │ - autoPan: false, │ │ │ │ - handlers: null, │ │ │ │ - resolutionFactor: 1, │ │ │ │ - maximized: false, │ │ │ │ - maximizeTitle: "", │ │ │ │ - minimizeTitle: "", │ │ │ │ - initialize: function(options) { │ │ │ │ - this.layers = []; │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]) │ │ │ │ + insertXY: function(x, y) { │ │ │ │ + this.line.geometry.addComponent(new OpenLayers.Geometry.Point(x, y), this.getCurrentPointIndex()); │ │ │ │ + this.drawFeature(); │ │ │ │ + delete this.redoStack │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (!this.mapDiv) { │ │ │ │ - return │ │ │ │ + insertDeltaXY: function(dx, dy) { │ │ │ │ + var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ + var p0 = this.line.geometry.components[previousIndex]; │ │ │ │ + if (p0 && !isNaN(p0.x) && !isNaN(p0.y)) { │ │ │ │ + this.insertXY(p0.x + dx, p0.y + dy) │ │ │ │ } │ │ │ │ - if (this.handlers.click) { │ │ │ │ - this.handlers.click.destroy() │ │ │ │ + }, │ │ │ │ + insertDirectionLength: function(direction, length) { │ │ │ │ + direction *= Math.PI / 180; │ │ │ │ + var dx = length * Math.cos(direction); │ │ │ │ + var dy = length * Math.sin(direction); │ │ │ │ + this.insertDeltaXY(dx, dy) │ │ │ │ + }, │ │ │ │ + insertDeflectionLength: function(deflection, length) { │ │ │ │ + var previousIndex = this.getCurrentPointIndex() - 1; │ │ │ │ + if (previousIndex > 0) { │ │ │ │ + var p1 = this.line.geometry.components[previousIndex]; │ │ │ │ + var p0 = this.line.geometry.components[previousIndex - 1]; │ │ │ │ + var theta = Math.atan2(p1.y - p0.y, p1.x - p0.x); │ │ │ │ + this.insertDirectionLength(theta * 180 / Math.PI + deflection, length) │ │ │ │ } │ │ │ │ - if (this.handlers.drag) { │ │ │ │ - this.handlers.drag.destroy() │ │ │ │ + }, │ │ │ │ + getCurrentPointIndex: function() { │ │ │ │ + return this.line.geometry.components.length - 1 │ │ │ │ + }, │ │ │ │ + undo: function() { │ │ │ │ + var geometry = this.line.geometry; │ │ │ │ + var components = geometry.components; │ │ │ │ + var index = this.getCurrentPointIndex() - 1; │ │ │ │ + var target = components[index]; │ │ │ │ + var undone = geometry.removeComponent(target); │ │ │ │ + if (undone) { │ │ │ │ + if (this.touch && index > 0) { │ │ │ │ + components = geometry.components; │ │ │ │ + var lastpt = components[index - 1]; │ │ │ │ + var curptidx = this.getCurrentPointIndex(); │ │ │ │ + var curpt = components[curptidx]; │ │ │ │ + curpt.x = lastpt.x; │ │ │ │ + curpt.y = lastpt.y │ │ │ │ + } │ │ │ │ + if (!this.redoStack) { │ │ │ │ + this.redoStack = [] │ │ │ │ + } │ │ │ │ + this.redoStack.push(target); │ │ │ │ + this.drawFeature() │ │ │ │ } │ │ │ │ - this.ovmap && this.ovmap.viewPortDiv.removeChild(this.extentRectangle); │ │ │ │ - this.extentRectangle = null; │ │ │ │ - if (this.rectEvents) { │ │ │ │ - this.rectEvents.destroy(); │ │ │ │ - this.rectEvents = null │ │ │ │ + return undone │ │ │ │ + }, │ │ │ │ + redo: function() { │ │ │ │ + var target = this.redoStack && this.redoStack.pop(); │ │ │ │ + if (target) { │ │ │ │ + this.line.geometry.addComponent(target, this.getCurrentPointIndex()); │ │ │ │ + this.drawFeature() │ │ │ │ } │ │ │ │ - if (this.ovmap) { │ │ │ │ - this.ovmap.destroy(); │ │ │ │ - this.ovmap = null │ │ │ │ + return !!target │ │ │ │ + }, │ │ │ │ + freehandMode: function(evt) { │ │ │ │ + return this.freehandToggle && evt[this.freehandToggle] ? !this.freehand : this.freehand │ │ │ │ + }, │ │ │ │ + modifyFeature: function(pixel, drawing) { │ │ │ │ + if (!this.line) { │ │ │ │ + this.createFeature(pixel) │ │ │ │ } │ │ │ │ - this.element.removeChild(this.mapDiv); │ │ │ │ - this.mapDiv = null; │ │ │ │ - this.div.removeChild(this.element); │ │ │ │ - this.element = null; │ │ │ │ - if (this.maximizeDiv) { │ │ │ │ - this.div.removeChild(this.maximizeDiv); │ │ │ │ - this.maximizeDiv = null │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + this.point.geometry.x = lonlat.lon; │ │ │ │ + this.point.geometry.y = lonlat.lat; │ │ │ │ + this.callback("modify", [this.point.geometry, this.getSketch(), drawing]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.drawFeature() │ │ │ │ + }, │ │ │ │ + drawFeature: function() { │ │ │ │ + this.layer.drawFeature(this.line, this.style); │ │ │ │ + this.layer.drawFeature(this.point, this.style) │ │ │ │ + }, │ │ │ │ + getSketch: function() { │ │ │ │ + return this.line │ │ │ │ + }, │ │ │ │ + getGeometry: function() { │ │ │ │ + var geometry = this.line && this.line.geometry; │ │ │ │ + if (geometry && this.multi) { │ │ │ │ + geometry = new OpenLayers.Geometry.MultiLineString([geometry]) │ │ │ │ } │ │ │ │ - if (this.minimizeDiv) { │ │ │ │ - this.div.removeChild(this.minimizeDiv); │ │ │ │ - this.minimizeDiv = null │ │ │ │ + return geometry │ │ │ │ + }, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + if (this.timerId && this.passesTolerance(this.lastTouchPx, evt.xy, this.doubleTouchTolerance)) { │ │ │ │ + this.finishGeometry(); │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + return false │ │ │ │ + } else { │ │ │ │ + if (this.timerId) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null │ │ │ │ + } │ │ │ │ + this.timerId = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ + this.timerId = null │ │ │ │ + }, this), 300); │ │ │ │ + return OpenLayers.Handler.Point.prototype.touchstart.call(this, evt) │ │ │ │ } │ │ │ │ - this.map.events.un({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - moveend: this.update, │ │ │ │ - changebaselayer: this.baseLayerDraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.layers.length === 0) { │ │ │ │ - if (this.map.baseLayer) { │ │ │ │ - var layer = this.map.baseLayer.clone(); │ │ │ │ - this.layers = [layer] │ │ │ │ - } else { │ │ │ │ - this.map.events.register("changebaselayer", this, this.baseLayerDraw); │ │ │ │ - return this.div │ │ │ │ + down: function(evt) { │ │ │ │ + var stopDown = this.stopDown; │ │ │ │ + if (this.freehandMode(evt)) { │ │ │ │ + stopDown = true; │ │ │ │ + if (this.touch) { │ │ │ │ + this.modifyFeature(evt.xy, !!this.lastUp); │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ } │ │ │ │ } │ │ │ │ - this.element = document.createElement("div"); │ │ │ │ - this.element.className = this.displayClass + "Element"; │ │ │ │ - this.element.style.display = "none"; │ │ │ │ - this.mapDiv = document.createElement("div"); │ │ │ │ - this.mapDiv.style.width = this.size.w + "px"; │ │ │ │ - this.mapDiv.style.height = this.size.h + "px"; │ │ │ │ - this.mapDiv.style.position = "relative"; │ │ │ │ - this.mapDiv.style.overflow = "hidden"; │ │ │ │ - this.mapDiv.id = OpenLayers.Util.createUniqueID("overviewMap"); │ │ │ │ - this.extentRectangle = document.createElement("div"); │ │ │ │ - this.extentRectangle.style.position = "absolute"; │ │ │ │ - this.extentRectangle.style.zIndex = 1e3; │ │ │ │ - this.extentRectangle.className = this.displayClass + "ExtentRectangle"; │ │ │ │ - this.element.appendChild(this.mapDiv); │ │ │ │ - this.div.appendChild(this.element); │ │ │ │ - if (!this.outsideViewport) { │ │ │ │ - this.div.className += " " + this.displayClass + "Container"; │ │ │ │ - var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png"); │ │ │ │ - this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv(this.displayClass + "MaximizeButton", null, null, img, "absolute"); │ │ │ │ - this.maximizeDiv.style.display = "none"; │ │ │ │ - this.maximizeDiv.className = this.displayClass + "MaximizeButton olButton"; │ │ │ │ - if (this.maximizeTitle) { │ │ │ │ - this.maximizeDiv.title = this.maximizeTitle │ │ │ │ + if (!this.touch && (!this.lastDown || !this.passesTolerance(this.lastDown, evt.xy, this.pixelTolerance))) { │ │ │ │ + this.modifyFeature(evt.xy, !!this.lastUp) │ │ │ │ + } │ │ │ │ + this.mouseDown = true; │ │ │ │ + this.lastDown = evt.xy; │ │ │ │ + this.stoppedDown = stopDown; │ │ │ │ + return !stopDown │ │ │ │ + }, │ │ │ │ + move: function(evt) { │ │ │ │ + if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ + if (this.persist) { │ │ │ │ + this.destroyPersistedFeature() │ │ │ │ } │ │ │ │ - this.div.appendChild(this.maximizeDiv); │ │ │ │ - var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png"); │ │ │ │ - this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_minimizeDiv", null, null, img, "absolute"); │ │ │ │ - this.minimizeDiv.style.display = "none"; │ │ │ │ - this.minimizeDiv.className = this.displayClass + "MinimizeButton olButton"; │ │ │ │ - if (this.minimizeTitle) { │ │ │ │ - this.minimizeDiv.title = this.minimizeTitle │ │ │ │ + if (this.maxVertices && this.line && this.line.geometry.components.length === this.maxVertices) { │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize() │ │ │ │ + } else { │ │ │ │ + this.addPoint(evt.xy) │ │ │ │ } │ │ │ │ - this.div.appendChild(this.minimizeDiv); │ │ │ │ - this.minimizeControl() │ │ │ │ - } else { │ │ │ │ - this.element.style.display = "" │ │ │ │ + return false │ │ │ │ } │ │ │ │ - if (this.map.getExtent()) { │ │ │ │ - this.update() │ │ │ │ + if (!this.touch && (!this.mouseDown || this.stoppedDown)) { │ │ │ │ + this.modifyFeature(evt.xy, !!this.lastUp) │ │ │ │ } │ │ │ │ - this.map.events.on({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - moveend: this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (this.maximized) { │ │ │ │ - this.maximizeControl() │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + up: function(evt) { │ │ │ │ + if (this.mouseDown && (!this.lastUp || !this.lastUp.equals(evt.xy))) { │ │ │ │ + if (this.stoppedDown && this.freehandMode(evt)) { │ │ │ │ + if (this.persist) { │ │ │ │ + this.destroyPersistedFeature() │ │ │ │ + } │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize() │ │ │ │ + } else { │ │ │ │ + if (this.passesTolerance(this.lastDown, evt.xy, this.pixelTolerance)) { │ │ │ │ + if (this.touch) { │ │ │ │ + this.modifyFeature(evt.xy) │ │ │ │ + } │ │ │ │ + if (this.lastUp == null && this.persist) { │ │ │ │ + this.destroyPersistedFeature() │ │ │ │ + } │ │ │ │ + this.addPoint(evt.xy); │ │ │ │ + this.lastUp = evt.xy; │ │ │ │ + if (this.line.geometry.components.length === this.maxVertices + 1) { │ │ │ │ + this.finishGeometry() │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - return this.div │ │ │ │ + this.stoppedDown = this.stopDown; │ │ │ │ + this.mouseDown = false; │ │ │ │ + return !this.stopUp │ │ │ │ }, │ │ │ │ - baseLayerDraw: function() { │ │ │ │ - this.draw(); │ │ │ │ - this.map.events.unregister("changebaselayer", this, this.baseLayerDraw) │ │ │ │ + finishGeometry: function() { │ │ │ │ + var index = this.line.geometry.components.length - 1; │ │ │ │ + this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize() │ │ │ │ }, │ │ │ │ - rectDrag: function(px) { │ │ │ │ - var deltaX = this.handlers.drag.last.x - px.x; │ │ │ │ - var deltaY = this.handlers.drag.last.y - px.y; │ │ │ │ - if (deltaX != 0 || deltaY != 0) { │ │ │ │ - var rectTop = this.rectPxBounds.top; │ │ │ │ - var rectLeft = this.rectPxBounds.left; │ │ │ │ - var rectHeight = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ - var rectWidth = this.rectPxBounds.getWidth(); │ │ │ │ - var newTop = Math.max(0, rectTop - deltaY); │ │ │ │ - newTop = Math.min(newTop, this.ovmap.size.h - this.hComp - rectHeight); │ │ │ │ - var newLeft = Math.max(0, rectLeft - deltaX); │ │ │ │ - newLeft = Math.min(newLeft, this.ovmap.size.w - this.wComp - rectWidth); │ │ │ │ - this.setRectPxBounds(new OpenLayers.Bounds(newLeft, newTop + rectHeight, newLeft + rectWidth, newTop)) │ │ │ │ + dblclick: function(evt) { │ │ │ │ + if (!this.freehandMode(evt)) { │ │ │ │ + this.finishGeometry() │ │ │ │ } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - mapDivClick: function(evt) { │ │ │ │ - var pxCenter = this.rectPxBounds.getCenterPixel(); │ │ │ │ - var deltaX = evt.xy.x - pxCenter.x; │ │ │ │ - var deltaY = evt.xy.y - pxCenter.y; │ │ │ │ - var top = this.rectPxBounds.top; │ │ │ │ - var left = this.rectPxBounds.left; │ │ │ │ - var height = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ - var width = this.rectPxBounds.getWidth(); │ │ │ │ - var newTop = Math.max(0, top + deltaY); │ │ │ │ - newTop = Math.min(newTop, this.ovmap.size.h - height); │ │ │ │ - var newLeft = Math.max(0, left + deltaX); │ │ │ │ - newLeft = Math.min(newLeft, this.ovmap.size.w - width); │ │ │ │ - this.setRectPxBounds(new OpenLayers.Bounds(newLeft, newTop + height, newLeft + width, newTop)); │ │ │ │ - this.updateMapToRect() │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Path" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Polygon = OpenLayers.Class(OpenLayers.Handler.Path, { │ │ │ │ + holeModifier: null, │ │ │ │ + drawingHole: false, │ │ │ │ + polygon: null, │ │ │ │ + createFeature: function(pixel) { │ │ │ │ + var lonlat = this.layer.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geometry = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat); │ │ │ │ + this.point = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + this.line = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LinearRing([this.point.geometry])); │ │ │ │ + this.polygon = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Polygon([this.line.geometry])); │ │ │ │ + this.callback("create", [this.point.geometry, this.getSketch()]); │ │ │ │ + this.point.geometry.clearBounds(); │ │ │ │ + this.layer.addFeatures([this.polygon, this.point], { │ │ │ │ + silent: true │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - if (evt.buttonElement === this.minimizeDiv) { │ │ │ │ - this.minimizeControl() │ │ │ │ - } else if (evt.buttonElement === this.maximizeDiv) { │ │ │ │ - this.maximizeControl() │ │ │ │ + addPoint: function(pixel) { │ │ │ │ + if (!this.drawingHole && this.holeModifier && this.evt && this.evt[this.holeModifier]) { │ │ │ │ + var geometry = this.point.geometry; │ │ │ │ + var features = this.control.layer.features; │ │ │ │ + var candidate, polygon; │ │ │ │ + for (var i = features.length - 1; i >= 0; --i) { │ │ │ │ + candidate = features[i].geometry; │ │ │ │ + if ((candidate instanceof OpenLayers.Geometry.Polygon || candidate instanceof OpenLayers.Geometry.MultiPolygon) && candidate.intersects(geometry)) { │ │ │ │ + polygon = features[i]; │ │ │ │ + this.control.layer.removeFeatures([polygon], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.control.layer.events.registerPriority("sketchcomplete", this, this.finalizeInteriorRing); │ │ │ │ + this.control.layer.events.registerPriority("sketchmodified", this, this.enforceTopology); │ │ │ │ + polygon.geometry.addComponent(this.line.geometry); │ │ │ │ + this.polygon = polygon; │ │ │ │ + this.drawingHole = true; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + OpenLayers.Handler.Path.prototype.addPoint.apply(this, arguments) │ │ │ │ }, │ │ │ │ - maximizeControl: function(e) { │ │ │ │ - this.element.style.display = ""; │ │ │ │ - this.showToggle(false); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ - } │ │ │ │ + getCurrentPointIndex: function() { │ │ │ │ + return this.line.geometry.components.length - 2 │ │ │ │ }, │ │ │ │ - minimizeControl: function(e) { │ │ │ │ - this.element.style.display = "none"; │ │ │ │ - this.showToggle(true); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ + enforceTopology: function(event) { │ │ │ │ + var point = event.vertex; │ │ │ │ + var components = this.line.geometry.components; │ │ │ │ + if (!this.polygon.geometry.intersects(point)) { │ │ │ │ + var last = components[components.length - 3]; │ │ │ │ + point.x = last.x; │ │ │ │ + point.y = last.y │ │ │ │ } │ │ │ │ }, │ │ │ │ - showToggle: function(minimize) { │ │ │ │ - if (this.maximizeDiv) { │ │ │ │ - this.maximizeDiv.style.display = minimize ? "" : "none" │ │ │ │ + finishGeometry: function() { │ │ │ │ + var index = this.line.geometry.components.length - 2; │ │ │ │ + this.line.geometry.removeComponent(this.line.geometry.components[index]); │ │ │ │ + this.removePoint(); │ │ │ │ + this.finalize() │ │ │ │ + }, │ │ │ │ + finalizeInteriorRing: function() { │ │ │ │ + var ring = this.line.geometry; │ │ │ │ + var modified = ring.getArea() !== 0; │ │ │ │ + if (modified) { │ │ │ │ + var rings = this.polygon.geometry.components; │ │ │ │ + for (var i = rings.length - 2; i >= 0; --i) { │ │ │ │ + if (ring.intersects(rings[i])) { │ │ │ │ + modified = false; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (modified) { │ │ │ │ + var target; │ │ │ │ + outer: for (var i = rings.length - 2; i > 0; --i) { │ │ │ │ + var points = rings[i].components; │ │ │ │ + for (var j = 0, jj = points.length; j < jj; ++j) { │ │ │ │ + if (ring.containsPoint(points[j])) { │ │ │ │ + modified = false; │ │ │ │ + break outer │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.minimizeDiv) { │ │ │ │ - this.minimizeDiv.style.display = minimize ? "none" : "" │ │ │ │ + if (modified) { │ │ │ │ + if (this.polygon.state !== OpenLayers.State.INSERT) { │ │ │ │ + this.polygon.state = OpenLayers.State.UPDATE │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.polygon.geometry.removeComponent(ring) │ │ │ │ } │ │ │ │ + this.restoreFeature(); │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - update: function() { │ │ │ │ - if (this.ovmap == null) { │ │ │ │ - this.createMap() │ │ │ │ + cancel: function() { │ │ │ │ + if (this.drawingHole) { │ │ │ │ + this.polygon.geometry.removeComponent(this.line.geometry); │ │ │ │ + this.restoreFeature(true) │ │ │ │ } │ │ │ │ - if (this.autoPan || !this.isSuitableOverview()) { │ │ │ │ - this.updateOverview() │ │ │ │ + return OpenLayers.Handler.Path.prototype.cancel.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + restoreFeature: function(cancel) { │ │ │ │ + this.control.layer.events.unregister("sketchcomplete", this, this.finalizeInteriorRing); │ │ │ │ + this.control.layer.events.unregister("sketchmodified", this, this.enforceTopology); │ │ │ │ + this.layer.removeFeatures([this.polygon], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.control.layer.addFeatures([this.polygon], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.drawingHole = false; │ │ │ │ + if (!cancel) { │ │ │ │ + this.control.layer.events.triggerEvent("sketchcomplete", { │ │ │ │ + feature: this.polygon │ │ │ │ + }) │ │ │ │ } │ │ │ │ - this.updateRectToMap() │ │ │ │ }, │ │ │ │ - isSuitableOverview: function() { │ │ │ │ - var mapExtent = this.map.getExtent(); │ │ │ │ - var maxExtent = this.map.getMaxExtent(); │ │ │ │ - var testExtent = new OpenLayers.Bounds(Math.max(mapExtent.left, maxExtent.left), Math.max(mapExtent.bottom, maxExtent.bottom), Math.min(mapExtent.right, maxExtent.right), Math.min(mapExtent.top, maxExtent.top)); │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - testExtent = testExtent.transform(this.map.getProjectionObject(), this.ovmap.getProjectionObject()) │ │ │ │ + destroyFeature: function(force) { │ │ │ │ + OpenLayers.Handler.Path.prototype.destroyFeature.call(this, force); │ │ │ │ + this.polygon = null │ │ │ │ + }, │ │ │ │ + drawFeature: function() { │ │ │ │ + this.layer.drawFeature(this.polygon, this.style); │ │ │ │ + this.layer.drawFeature(this.point, this.style) │ │ │ │ + }, │ │ │ │ + getSketch: function() { │ │ │ │ + return this.polygon │ │ │ │ + }, │ │ │ │ + getGeometry: function() { │ │ │ │ + var geometry = this.polygon && this.polygon.geometry; │ │ │ │ + if (geometry && this.multi) { │ │ │ │ + geometry = new OpenLayers.Geometry.MultiPolygon([geometry]) │ │ │ │ } │ │ │ │ - var resRatio = this.ovmap.getResolution() / this.map.getResolution(); │ │ │ │ - return resRatio > this.minRatio && resRatio <= this.maxRatio && this.ovmap.getExtent().containsBounds(testExtent) │ │ │ │ + return geometry │ │ │ │ }, │ │ │ │ - updateOverview: function() { │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - var targetRes = this.ovmap.getResolution(); │ │ │ │ - var resRatio = targetRes / mapRes; │ │ │ │ - if (resRatio > this.maxRatio) { │ │ │ │ - targetRes = this.minRatio * mapRes │ │ │ │ - } else if (resRatio <= this.minRatio) { │ │ │ │ - targetRes = this.maxRatio * mapRes │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Polygon" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + delay: 300, │ │ │ │ + single: true, │ │ │ │ + double: false, │ │ │ │ + pixelTolerance: 0, │ │ │ │ + dblclickTolerance: 13, │ │ │ │ + stopSingle: false, │ │ │ │ + stopDouble: false, │ │ │ │ + timerId: null, │ │ │ │ + down: null, │ │ │ │ + last: null, │ │ │ │ + first: null, │ │ │ │ + rightclickTimerId: null, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + touchend: function(evt) { │ │ │ │ + if (this.down) { │ │ │ │ + evt.xy = this.last.xy; │ │ │ │ + evt.lastTouches = this.last.touches; │ │ │ │ + this.handleSingle(evt); │ │ │ │ + this.down = null │ │ │ │ } │ │ │ │ - var center; │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - center = this.map.center.clone(); │ │ │ │ - center.transform(this.map.getProjectionObject(), this.ovmap.getProjectionObject()) │ │ │ │ - } else { │ │ │ │ - center = this.map.center │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + this.down = this.getEventInfo(evt); │ │ │ │ + this.last = this.getEventInfo(evt); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + mouseup: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + if (this.checkModifiers(evt) && this.control.handleRightClicks && OpenLayers.Event.isRightClick(evt)) { │ │ │ │ + propagate = this.rightclick(evt) │ │ │ │ } │ │ │ │ - this.ovmap.setCenter(center, this.ovmap.getZoomForResolution(targetRes * this.resolutionFactor)); │ │ │ │ - this.updateRectToMap() │ │ │ │ + return propagate │ │ │ │ }, │ │ │ │ - createMap: function() { │ │ │ │ - var options = OpenLayers.Util.extend({ │ │ │ │ - controls: [], │ │ │ │ - maxResolution: "auto", │ │ │ │ - fallThrough: false │ │ │ │ - }, this.mapOptions); │ │ │ │ - this.ovmap = new OpenLayers.Map(this.mapDiv, options); │ │ │ │ - this.ovmap.viewPortDiv.appendChild(this.extentRectangle); │ │ │ │ - OpenLayers.Event.stopObserving(window, "unload", this.ovmap.unloadDestroy); │ │ │ │ - this.ovmap.addLayers(this.layers); │ │ │ │ - this.ovmap.zoomToMaxExtent(); │ │ │ │ - this.wComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-left-width")) + parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-right-width")); │ │ │ │ - this.wComp = this.wComp ? this.wComp : 2; │ │ │ │ - this.hComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-top-width")) + parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-bottom-width")); │ │ │ │ - this.hComp = this.hComp ? this.hComp : 2; │ │ │ │ - this.handlers.drag = new OpenLayers.Handler.Drag(this, { │ │ │ │ - move: this.rectDrag, │ │ │ │ - done: this.updateMapToRect │ │ │ │ - }, { │ │ │ │ - map: this.ovmap │ │ │ │ - }); │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click(this, { │ │ │ │ - click: this.mapDivClick │ │ │ │ - }, { │ │ │ │ - single: true, │ │ │ │ - double: false, │ │ │ │ - stopSingle: true, │ │ │ │ - stopDouble: true, │ │ │ │ - pixelTolerance: 1, │ │ │ │ - map: this.ovmap │ │ │ │ - }); │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, null, true); │ │ │ │ - this.rectEvents.register("mouseover", this, function(e) { │ │ │ │ - if (!this.handlers.drag.active && !this.map.dragging) { │ │ │ │ - this.handlers.drag.activate() │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.rectEvents.register("mouseout", this, function(e) { │ │ │ │ - if (!this.handlers.drag.dragging) { │ │ │ │ - this.handlers.drag.deactivate() │ │ │ │ + rightclick: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.callback("dblrightclick", [evt]); │ │ │ │ + return !this.stopDouble │ │ │ │ + } else { │ │ │ │ + var clickEvent = this["double"] ? OpenLayers.Util.extend({}, evt) : this.callback("rightclick", [evt]); │ │ │ │ + var delayedRightCall = OpenLayers.Function.bind(this.delayedRightCall, this, clickEvent); │ │ │ │ + this.rightclickTimerId = window.setTimeout(delayedRightCall, this.delay) │ │ │ │ } │ │ │ │ - }); │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - var sourceUnits = this.map.getProjectionObject().getUnits() || this.map.units || this.map.baseLayer.units; │ │ │ │ - var targetUnits = this.ovmap.getProjectionObject().getUnits() || this.ovmap.units || this.ovmap.baseLayer.units; │ │ │ │ - this.resolutionFactor = sourceUnits && targetUnits ? OpenLayers.INCHES_PER_UNIT[sourceUnits] / OpenLayers.INCHES_PER_UNIT[targetUnits] : 1 │ │ │ │ } │ │ │ │ + return !this.stopSingle │ │ │ │ }, │ │ │ │ - updateRectToMap: function() { │ │ │ │ - var bounds; │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - bounds = this.map.getExtent().transform(this.map.getProjectionObject(), this.ovmap.getProjectionObject()) │ │ │ │ - } else { │ │ │ │ - bounds = this.map.getExtent() │ │ │ │ - } │ │ │ │ - var pxBounds = this.getRectBoundsFromMapBounds(bounds); │ │ │ │ - if (pxBounds) { │ │ │ │ - this.setRectPxBounds(pxBounds) │ │ │ │ + delayedRightCall: function(evt) { │ │ │ │ + this.rightclickTimerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback("rightclick", [evt]) │ │ │ │ } │ │ │ │ }, │ │ │ │ - updateMapToRect: function() { │ │ │ │ - var lonLatBounds = this.getMapBoundsFromRectBounds(this.rectPxBounds); │ │ │ │ - if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ - lonLatBounds = lonLatBounds.transform(this.ovmap.getProjectionObject(), this.map.getProjectionObject()) │ │ │ │ + click: function(evt) { │ │ │ │ + if (!this.last) { │ │ │ │ + this.last = this.getEventInfo(evt) │ │ │ │ } │ │ │ │ - this.map.panTo(lonLatBounds.getCenterLonLat()) │ │ │ │ + this.handleSingle(evt); │ │ │ │ + return !this.stopSingle │ │ │ │ }, │ │ │ │ - setRectPxBounds: function(pxBounds) { │ │ │ │ - var top = Math.max(pxBounds.top, 0); │ │ │ │ - var left = Math.max(pxBounds.left, 0); │ │ │ │ - var bottom = Math.min(pxBounds.top + Math.abs(pxBounds.getHeight()), this.ovmap.size.h - this.hComp); │ │ │ │ - var right = Math.min(pxBounds.left + pxBounds.getWidth(), this.ovmap.size.w - this.wComp); │ │ │ │ - var width = Math.max(right - left, 0); │ │ │ │ - var height = Math.max(bottom - top, 0); │ │ │ │ - if (width < this.minRectSize || height < this.minRectSize) { │ │ │ │ - this.extentRectangle.className = this.displayClass + this.minRectDisplayClass; │ │ │ │ - var rLeft = left + width / 2 - this.minRectSize / 2; │ │ │ │ - var rTop = top + height / 2 - this.minRectSize / 2; │ │ │ │ - this.extentRectangle.style.top = Math.round(rTop) + "px"; │ │ │ │ - this.extentRectangle.style.left = Math.round(rLeft) + "px"; │ │ │ │ - this.extentRectangle.style.height = this.minRectSize + "px"; │ │ │ │ - this.extentRectangle.style.width = this.minRectSize + "px" │ │ │ │ - } else { │ │ │ │ - this.extentRectangle.className = this.displayClass + "ExtentRectangle"; │ │ │ │ - this.extentRectangle.style.top = Math.round(top) + "px"; │ │ │ │ - this.extentRectangle.style.left = Math.round(left) + "px"; │ │ │ │ - this.extentRectangle.style.height = Math.round(height) + "px"; │ │ │ │ - this.extentRectangle.style.width = Math.round(width) + "px" │ │ │ │ + dblclick: function(evt) { │ │ │ │ + this.handleDouble(evt); │ │ │ │ + return !this.stopDouble │ │ │ │ + }, │ │ │ │ + handleDouble: function(evt) { │ │ │ │ + if (this.passesDblclickTolerance(evt)) { │ │ │ │ + if (this["double"]) { │ │ │ │ + this.callback("dblclick", [evt]) │ │ │ │ + } │ │ │ │ + this.clearTimer() │ │ │ │ } │ │ │ │ - this.rectPxBounds = new OpenLayers.Bounds(Math.round(left), Math.round(bottom), Math.round(right), Math.round(top)) │ │ │ │ }, │ │ │ │ - getRectBoundsFromMapBounds: function(lonLatBounds) { │ │ │ │ - var leftBottomPx = this.getOverviewPxFromLonLat({ │ │ │ │ - lon: lonLatBounds.left, │ │ │ │ - lat: lonLatBounds.bottom │ │ │ │ - }); │ │ │ │ - var rightTopPx = this.getOverviewPxFromLonLat({ │ │ │ │ - lon: lonLatBounds.right, │ │ │ │ - lat: lonLatBounds.top │ │ │ │ - }); │ │ │ │ - var bounds = null; │ │ │ │ - if (leftBottomPx && rightTopPx) { │ │ │ │ - bounds = new OpenLayers.Bounds(leftBottomPx.x, leftBottomPx.y, rightTopPx.x, rightTopPx.y) │ │ │ │ + handleSingle: function(evt) { │ │ │ │ + if (this.passesTolerance(evt)) { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + if (this.last.touches && this.last.touches.length === 1) { │ │ │ │ + if (this["double"]) { │ │ │ │ + OpenLayers.Event.preventDefault(evt) │ │ │ │ + } │ │ │ │ + this.handleDouble(evt) │ │ │ │ + } │ │ │ │ + if (!this.last.touches || this.last.touches.length !== 2) { │ │ │ │ + this.clearTimer() │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.first = this.getEventInfo(evt); │ │ │ │ + var clickEvent = this.single ? OpenLayers.Util.extend({}, evt) : null; │ │ │ │ + this.queuePotentialClick(clickEvent) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return bounds │ │ │ │ }, │ │ │ │ - getMapBoundsFromRectBounds: function(pxBounds) { │ │ │ │ - var leftBottomLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ - x: pxBounds.left, │ │ │ │ - y: pxBounds.bottom │ │ │ │ - }); │ │ │ │ - var rightTopLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ - x: pxBounds.right, │ │ │ │ - y: pxBounds.top │ │ │ │ - }); │ │ │ │ - return new OpenLayers.Bounds(leftBottomLonLat.lon, leftBottomLonLat.lat, rightTopLonLat.lon, rightTopLonLat.lat) │ │ │ │ + queuePotentialClick: function(evt) { │ │ │ │ + this.timerId = window.setTimeout(OpenLayers.Function.bind(this.delayedCall, this, evt), this.delay) │ │ │ │ }, │ │ │ │ - getLonLatFromOverviewPx: function(overviewMapPx) { │ │ │ │ - var size = this.ovmap.size; │ │ │ │ - var res = this.ovmap.getResolution(); │ │ │ │ - var center = this.ovmap.getExtent().getCenterLonLat(); │ │ │ │ - var deltaX = overviewMapPx.x - size.w / 2; │ │ │ │ - var deltaY = overviewMapPx.y - size.h / 2; │ │ │ │ - return { │ │ │ │ - lon: center.lon + deltaX * res, │ │ │ │ - lat: center.lat - deltaY * res │ │ │ │ + passesTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.pixelTolerance != null && this.down && this.down.xy) { │ │ │ │ + passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy); │ │ │ │ + if (passes && this.touch && this.down.touches.length === this.last.touches.length) { │ │ │ │ + for (var i = 0, ii = this.down.touches.length; i < ii; ++i) { │ │ │ │ + if (this.getTouchDistance(this.down.touches[i], this.last.touches[i]) > this.pixelTolerance) { │ │ │ │ + passes = false; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + return passes │ │ │ │ }, │ │ │ │ - getOverviewPxFromLonLat: function(lonlat) { │ │ │ │ - var res = this.ovmap.getResolution(); │ │ │ │ - var extent = this.ovmap.getExtent(); │ │ │ │ - if (extent) { │ │ │ │ - return { │ │ │ │ - x: Math.round(1 / res * (lonlat.lon - extent.left)), │ │ │ │ - y: Math.round(1 / res * (extent.top - lonlat.lat)) │ │ │ │ - } │ │ │ │ + getTouchDistance: function(from, to) { │ │ │ │ + return Math.sqrt(Math.pow(from.clientX - to.clientX, 2) + Math.pow(from.clientY - to.clientY, 2)) │ │ │ │ + }, │ │ │ │ + passesDblclickTolerance: function(evt) { │ │ │ │ + var passes = true; │ │ │ │ + if (this.down && this.first) { │ │ │ │ + passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance │ │ │ │ } │ │ │ │ + return passes │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.OverviewMap" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Scale = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - element: null, │ │ │ │ - geodesic: false, │ │ │ │ - initialize: function(element, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.element = OpenLayers.Util.getElement(element) │ │ │ │ + clearTimer: function() { │ │ │ │ + if (this.timerId != null) { │ │ │ │ + window.clearTimeout(this.timerId); │ │ │ │ + this.timerId = null │ │ │ │ + } │ │ │ │ + if (this.rightclickTimerId != null) { │ │ │ │ + window.clearTimeout(this.rightclickTimerId); │ │ │ │ + this.rightclickTimerId = null │ │ │ │ + } │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.element) { │ │ │ │ - this.element = document.createElement("div"); │ │ │ │ - this.div.appendChild(this.element) │ │ │ │ + delayedCall: function(evt) { │ │ │ │ + this.timerId = null; │ │ │ │ + if (evt) { │ │ │ │ + this.callback("click", [evt]) │ │ │ │ } │ │ │ │ - this.map.events.register("moveend", this, this.updateScale); │ │ │ │ - this.updateScale(); │ │ │ │ - return this.div │ │ │ │ }, │ │ │ │ - updateScale: function() { │ │ │ │ - var scale; │ │ │ │ - if (this.geodesic === true) { │ │ │ │ - var units = this.map.getUnits(); │ │ │ │ - if (!units) { │ │ │ │ - return │ │ │ │ + getEventInfo: function(evt) { │ │ │ │ + var touches; │ │ │ │ + if (evt.touches) { │ │ │ │ + var len = evt.touches.length; │ │ │ │ + touches = new Array(len); │ │ │ │ + var touch; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + touch = evt.touches[i]; │ │ │ │ + touches[i] = { │ │ │ │ + clientX: touch.olClientX, │ │ │ │ + clientY: touch.olClientY │ │ │ │ + } │ │ │ │ } │ │ │ │ - var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ - scale = (this.map.getGeodesicPixelSize().w || 1e-6) * inches["km"] * OpenLayers.DOTS_PER_INCH │ │ │ │ - } else { │ │ │ │ - scale = this.map.getScale() │ │ │ │ } │ │ │ │ - if (!scale) { │ │ │ │ - return │ │ │ │ + return { │ │ │ │ + xy: evt.xy, │ │ │ │ + touches: touches │ │ │ │ } │ │ │ │ - if (scale >= 9500 && scale <= 95e4) { │ │ │ │ - scale = Math.round(scale / 1e3) + "K" │ │ │ │ - } else if (scale >= 95e4) { │ │ │ │ - scale = Math.round(scale / 1e6) + "M" │ │ │ │ - } else { │ │ │ │ - scale = Math.round(scale) │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.clearTimer(); │ │ │ │ + this.down = null; │ │ │ │ + this.first = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ - this.element.innerHTML = OpenLayers.i18n("Scale = 1 : ${scaleDenom}", { │ │ │ │ - scaleDenom: scale │ │ │ │ - }) │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Scale" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Click" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.Graticule = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - autoActivate: true, │ │ │ │ - intervals: [45, 30, 20, 10, 5, 2, 1, .5, .2, .1, .05, .01, .005, .002, .001], │ │ │ │ - displayInLayerSwitcher: true, │ │ │ │ - visible: true, │ │ │ │ - numPoints: 50, │ │ │ │ - targetSize: 200, │ │ │ │ - layerName: null, │ │ │ │ - labelled: true, │ │ │ │ - labelFormat: "dm", │ │ │ │ - lineSymbolizer: { │ │ │ │ - strokeColor: "#333", │ │ │ │ - strokeWidth: 1, │ │ │ │ - strokeOpacity: .5 │ │ │ │ - }, │ │ │ │ - labelSymbolizer: {}, │ │ │ │ - gratLayer: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.layerName = options.layerName || OpenLayers.i18n("Graticule"); │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.labelSymbolizer.stroke = false; │ │ │ │ - this.labelSymbolizer.fill = false; │ │ │ │ - this.labelSymbolizer.label = "${label}"; │ │ │ │ - this.labelSymbolizer.labelAlign = "${labelAlign}"; │ │ │ │ - this.labelSymbolizer.labelXOffset = "${xOffset}"; │ │ │ │ - this.labelSymbolizer.labelYOffset = "${yOffset}" │ │ │ │ +OpenLayers.Handler.Keyboard = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + KEY_EVENTS: ["keydown", "keyup"], │ │ │ │ + eventListener: null, │ │ │ │ + observeElement: null, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + this.eventListener = OpenLayers.Function.bindAsEventListener(this.handleKeyEvent, this) │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ this.deactivate(); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.gratLayer) { │ │ │ │ - this.gratLayer.destroy(); │ │ │ │ - this.gratLayer = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.gratLayer) { │ │ │ │ - var gratStyle = new OpenLayers.Style({}, { │ │ │ │ - rules: [new OpenLayers.Rule({ │ │ │ │ - symbolizer: { │ │ │ │ - Point: this.labelSymbolizer, │ │ │ │ - Line: this.lineSymbolizer │ │ │ │ - } │ │ │ │ - })] │ │ │ │ - }); │ │ │ │ - this.gratLayer = new OpenLayers.Layer.Vector(this.layerName, { │ │ │ │ - styleMap: new OpenLayers.StyleMap({ │ │ │ │ - default: gratStyle │ │ │ │ - }), │ │ │ │ - visibility: this.visible, │ │ │ │ - displayInLayerSwitcher: this.displayInLayerSwitcher │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return this.div │ │ │ │ + this.eventListener = null; │ │ │ │ + OpenLayers.Handler.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.map.addLayer(this.gratLayer); │ │ │ │ - this.map.events.register("moveend", this, this.update); │ │ │ │ - this.update(); │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.observeElement = this.observeElement || document; │ │ │ │ + for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ + OpenLayers.Event.observe(this.observeElement, this.KEY_EVENTS[i], this.eventListener) │ │ │ │ + } │ │ │ │ return true │ │ │ │ } else { │ │ │ │ return false │ │ │ │ } │ │ │ │ }, │ │ │ │ deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.map.events.unregister("moveend", this, this.update); │ │ │ │ - this.map.removeLayer(this.gratLayer); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ + OpenLayers.Event.stopObserving(this.observeElement, this.KEY_EVENTS[i], this.eventListener) │ │ │ │ + } │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - update: function() { │ │ │ │ - var mapBounds = this.map.getExtent(); │ │ │ │ - if (!mapBounds) { │ │ │ │ - return │ │ │ │ + handleKeyEvent: function(evt) { │ │ │ │ + if (this.checkModifiers(evt)) { │ │ │ │ + this.callback(evt.type, [evt]) │ │ │ │ } │ │ │ │ - this.gratLayer.destroyFeatures(); │ │ │ │ - var llProj = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - var mapProj = this.map.getProjectionObject(); │ │ │ │ - var mapRes = this.map.getResolution(); │ │ │ │ - if (mapProj.proj && mapProj.proj.projName == "longlat") { │ │ │ │ - this.numPoints = 1 │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Keyboard" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + started: false, │ │ │ │ + stopDown: true, │ │ │ │ + dragging: false, │ │ │ │ + last: null, │ │ │ │ + start: null, │ │ │ │ + lastMoveEvt: null, │ │ │ │ + oldOnselectstart: null, │ │ │ │ + interval: 0, │ │ │ │ + timeoutId: null, │ │ │ │ + documentDrag: false, │ │ │ │ + documentEvents: null, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + var me = this; │ │ │ │ + this._docMove = function(evt) { │ │ │ │ + me.mousemove({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + }, │ │ │ │ + element: document │ │ │ │ + }) │ │ │ │ + }; │ │ │ │ + this._docUp = function(evt) { │ │ │ │ + me.mouseup({ │ │ │ │ + xy: { │ │ │ │ + x: evt.clientX, │ │ │ │ + y: evt.clientY │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + } │ │ │ │ } │ │ │ │ - var mapCenter = this.map.getCenter(); │ │ │ │ - var mapCenterLL = new OpenLayers.Pixel(mapCenter.lon, mapCenter.lat); │ │ │ │ - OpenLayers.Projection.transform(mapCenterLL, mapProj, llProj); │ │ │ │ - var testSq = this.targetSize * mapRes; │ │ │ │ - testSq *= testSq; │ │ │ │ - var llInterval; │ │ │ │ - for (var i = 0; i < this.intervals.length; ++i) { │ │ │ │ - llInterval = this.intervals[i]; │ │ │ │ - var delta = llInterval / 2; │ │ │ │ - var p1 = mapCenterLL.offset({ │ │ │ │ - x: -delta, │ │ │ │ - y: -delta │ │ │ │ - }); │ │ │ │ - var p2 = mapCenterLL.offset({ │ │ │ │ - x: delta, │ │ │ │ - y: delta │ │ │ │ - }); │ │ │ │ - OpenLayers.Projection.transform(p1, llProj, mapProj); │ │ │ │ - OpenLayers.Projection.transform(p2, llProj, mapProj); │ │ │ │ - var distSq = (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y); │ │ │ │ - if (distSq <= testSq) { │ │ │ │ - break │ │ │ │ + }, │ │ │ │ + dragstart: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + this.dragging = false; │ │ │ │ + if (this.checkModifiers(evt) && (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt))) { │ │ │ │ + this.started = true; │ │ │ │ + this.start = evt.xy; │ │ │ │ + this.last = evt.xy; │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ + this.down(evt); │ │ │ │ + this.callback("down", [evt.xy]); │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart ? document.onselectstart : OpenLayers.Function.True │ │ │ │ } │ │ │ │ + document.onselectstart = OpenLayers.Function.False; │ │ │ │ + propagate = !this.stopDown │ │ │ │ + } else { │ │ │ │ + this.started = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null │ │ │ │ } │ │ │ │ - mapCenterLL.x = Math.floor(mapCenterLL.x / llInterval) * llInterval; │ │ │ │ - mapCenterLL.y = Math.floor(mapCenterLL.y / llInterval) * llInterval; │ │ │ │ - var iter = 0; │ │ │ │ - var centerLonPoints = [mapCenterLL.clone()]; │ │ │ │ - var newPoint = mapCenterLL.clone(); │ │ │ │ - var mapXY; │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: 0, │ │ │ │ - y: llInterval │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLonPoints.unshift(newPoint) │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ - newPoint = mapCenterLL.clone(); │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: 0, │ │ │ │ - y: -llInterval │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLonPoints.push(newPoint) │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ - iter = 0; │ │ │ │ - var centerLatPoints = [mapCenterLL.clone()]; │ │ │ │ - newPoint = mapCenterLL.clone(); │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: -llInterval, │ │ │ │ - y: 0 │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLatPoints.unshift(newPoint) │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ - newPoint = mapCenterLL.clone(); │ │ │ │ - do { │ │ │ │ - newPoint = newPoint.offset({ │ │ │ │ - x: llInterval, │ │ │ │ - y: 0 │ │ │ │ - }); │ │ │ │ - mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ - centerLatPoints.push(newPoint) │ │ │ │ - } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ - var lines = []; │ │ │ │ - for (var i = 0; i < centerLatPoints.length; ++i) { │ │ │ │ - var lon = centerLatPoints[i].x; │ │ │ │ - var pointList = []; │ │ │ │ - var labelPoint = null; │ │ │ │ - var latEnd = Math.min(centerLonPoints[0].y, 90); │ │ │ │ - var latStart = Math.max(centerLonPoints[centerLonPoints.length - 1].y, -90); │ │ │ │ - var latDelta = (latEnd - latStart) / this.numPoints; │ │ │ │ - var lat = latStart; │ │ │ │ - for (var j = 0; j <= this.numPoints; ++j) { │ │ │ │ - var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ - gridPoint.transform(llProj, mapProj); │ │ │ │ - pointList.push(gridPoint); │ │ │ │ - lat += latDelta; │ │ │ │ - if (gridPoint.y >= mapBounds.bottom && !labelPoint) { │ │ │ │ - labelPoint = gridPoint │ │ │ │ + return propagate │ │ │ │ + }, │ │ │ │ + dragmove: function(evt) { │ │ │ │ + this.lastMoveEvt = evt; │ │ │ │ + if (this.started && !this.timeoutId && (evt.xy.x != this.last.x || evt.xy.y != this.last.y)) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + if (evt.element === document) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + this.setEvent(evt) │ │ │ │ + } else { │ │ │ │ + this.removeDocumentEvents() │ │ │ │ } │ │ │ │ } │ │ │ │ - if (this.labelled) { │ │ │ │ - var labelPos = new OpenLayers.Geometry.Point(labelPoint.x, mapBounds.bottom); │ │ │ │ - var labelAttrs = { │ │ │ │ - value: lon, │ │ │ │ - label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lon, "lon", this.labelFormat) : "", │ │ │ │ - labelAlign: "cb", │ │ │ │ - xOffset: 0, │ │ │ │ - yOffset: 2 │ │ │ │ - }; │ │ │ │ - this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)) │ │ │ │ + if (this.interval > 0) { │ │ │ │ + this.timeoutId = setTimeout(OpenLayers.Function.bind(this.removeTimeout, this), this.interval) │ │ │ │ } │ │ │ │ - var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ - lines.push(new OpenLayers.Feature.Vector(geom)) │ │ │ │ - } │ │ │ │ - for (var j = 0; j < centerLonPoints.length; ++j) { │ │ │ │ - lat = centerLonPoints[j].y; │ │ │ │ - if (lat < -90 || lat > 90) { │ │ │ │ - continue │ │ │ │ + this.dragging = true; │ │ │ │ + this.move(evt); │ │ │ │ + this.callback("move", [evt.xy]); │ │ │ │ + if (!this.oldOnselectstart) { │ │ │ │ + this.oldOnselectstart = document.onselectstart; │ │ │ │ + document.onselectstart = OpenLayers.Function.False │ │ │ │ } │ │ │ │ - var pointList = []; │ │ │ │ - var lonStart = centerLatPoints[0].x; │ │ │ │ - var lonEnd = centerLatPoints[centerLatPoints.length - 1].x; │ │ │ │ - var lonDelta = (lonEnd - lonStart) / this.numPoints; │ │ │ │ - var lon = lonStart; │ │ │ │ - var labelPoint = null; │ │ │ │ - for (var i = 0; i <= this.numPoints; ++i) { │ │ │ │ - var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ - gridPoint.transform(llProj, mapProj); │ │ │ │ - pointList.push(gridPoint); │ │ │ │ - lon += lonDelta; │ │ │ │ - if (gridPoint.x < mapBounds.right) { │ │ │ │ - labelPoint = gridPoint │ │ │ │ - } │ │ │ │ + this.last = evt.xy │ │ │ │ + } │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + dragend: function(evt) { │ │ │ │ + if (this.started) { │ │ │ │ + if (this.documentDrag === true && this.documentEvents) { │ │ │ │ + this.adjustXY(evt); │ │ │ │ + this.removeDocumentEvents() │ │ │ │ } │ │ │ │ - if (this.labelled) { │ │ │ │ - var labelPos = new OpenLayers.Geometry.Point(mapBounds.right, labelPoint.y); │ │ │ │ - var labelAttrs = { │ │ │ │ - value: lat, │ │ │ │ - label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lat, "lat", this.labelFormat) : "", │ │ │ │ - labelAlign: "rb", │ │ │ │ - xOffset: -2, │ │ │ │ - yOffset: 2 │ │ │ │ - }; │ │ │ │ - this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)) │ │ │ │ + var dragged = this.start != this.last; │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ + this.up(evt); │ │ │ │ + this.callback("up", [evt.xy]); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]) │ │ │ │ } │ │ │ │ - var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ - lines.push(new OpenLayers.Feature.Vector(geom)) │ │ │ │ + document.onselectstart = this.oldOnselectstart │ │ │ │ } │ │ │ │ - this.gratLayer.addFeatures(lines) │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Graticule" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ArgParser = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - center: null, │ │ │ │ - zoom: null, │ │ │ │ - layers: null, │ │ │ │ - displayProjection: null, │ │ │ │ - getParameters: function(url) { │ │ │ │ - url = url || window.location.href; │ │ │ │ - var parameters = OpenLayers.Util.getParameters(url); │ │ │ │ - var index = url.indexOf("#"); │ │ │ │ - if (index > 0) { │ │ │ │ - url = "?" + url.substring(index + 1, url.length); │ │ │ │ - OpenLayers.Util.extend(parameters, OpenLayers.Util.getParameters(url)) │ │ │ │ + down: function(evt) {}, │ │ │ │ + move: function(evt) {}, │ │ │ │ + up: function(evt) {}, │ │ │ │ + out: function(evt) {}, │ │ │ │ + mousedown: function(evt) { │ │ │ │ + return this.dragstart(evt) │ │ │ │ + }, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + this.startTouch(); │ │ │ │ + return this.dragstart(evt) │ │ │ │ + }, │ │ │ │ + mousemove: function(evt) { │ │ │ │ + return this.dragmove(evt) │ │ │ │ + }, │ │ │ │ + touchmove: function(evt) { │ │ │ │ + return this.dragmove(evt) │ │ │ │ + }, │ │ │ │ + removeTimeout: function() { │ │ │ │ + this.timeoutId = null; │ │ │ │ + if (this.dragging) { │ │ │ │ + this.mousemove(this.lastMoveEvt) │ │ │ │ } │ │ │ │ - return parameters │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ - var control = this.map.controls[i]; │ │ │ │ - if (control != this && control.CLASS_NAME == "OpenLayers.Control.ArgParser") { │ │ │ │ - if (control.displayProjection != this.displayProjection) { │ │ │ │ - this.displayProjection = control.displayProjection │ │ │ │ + mouseup: function(evt) { │ │ │ │ + return this.dragend(evt) │ │ │ │ + }, │ │ │ │ + touchend: function(evt) { │ │ │ │ + evt.xy = this.last; │ │ │ │ + return this.dragend(evt) │ │ │ │ + }, │ │ │ │ + mouseout: function(evt) { │ │ │ │ + if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) { │ │ │ │ + if (this.documentDrag === true) { │ │ │ │ + this.addDocumentEvents() │ │ │ │ + } else { │ │ │ │ + var dragged = this.start != this.last; │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown"); │ │ │ │ + this.out(evt); │ │ │ │ + this.callback("out", []); │ │ │ │ + if (dragged) { │ │ │ │ + this.callback("done", [evt.xy]) │ │ │ │ } │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i == this.map.controls.length) { │ │ │ │ - var args = this.getParameters(); │ │ │ │ - if (args.layers) { │ │ │ │ - this.layers = args.layers; │ │ │ │ - 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 = parseFloat(args.zoom) │ │ │ │ + if (document.onselectstart) { │ │ │ │ + document.onselectstart = this.oldOnselectstart │ │ │ │ } │ │ │ │ - this.map.events.register("changebaselayer", this, this.setCenter); │ │ │ │ - this.setCenter() │ │ │ │ } │ │ │ │ } │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - setCenter: function() { │ │ │ │ - if (this.map.baseLayer) { │ │ │ │ - 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) │ │ │ │ - } │ │ │ │ + click: function(evt) { │ │ │ │ + return this.start == this.last │ │ │ │ }, │ │ │ │ - configureLayers: function() { │ │ │ │ - if (this.layers.length == this.map.layers.length) { │ │ │ │ - this.map.events.unregister("addlayer", this, this.configureLayers); │ │ │ │ - for (var i = 0, len = this.layers.length; i < len; 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") │ │ │ │ - } │ │ │ │ - } │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragging = false; │ │ │ │ + activated = true │ │ │ │ } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ArgParser" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - argParserClass: OpenLayers.Control.ArgParser, │ │ │ │ - element: null, │ │ │ │ - anchor: false, │ │ │ │ - base: "", │ │ │ │ - displayProjection: null, │ │ │ │ - initialize: function(element, base, options) { │ │ │ │ - if (element !== null && typeof element == "object" && !OpenLayers.Util.isElement(element)) { │ │ │ │ - options = element; │ │ │ │ - this.base = document.location.href; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (this.element != null) { │ │ │ │ - this.element = OpenLayers.Util.getElement(this.element) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.element = OpenLayers.Util.getElement(element); │ │ │ │ - this.base = base || document.location.href │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.started = false; │ │ │ │ + this.dragging = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown") │ │ │ │ } │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.element && this.element.parentNode == this.div) { │ │ │ │ - this.div.removeChild(this.element); │ │ │ │ - this.element = null │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("moveend", this, this.updateLink) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + adjustXY: function(evt) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv); │ │ │ │ + evt.xy.x -= pos[0]; │ │ │ │ + evt.xy.y -= pos[1] │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ - var control = this.map.controls[i]; │ │ │ │ - if (control.CLASS_NAME == this.argParserClass.CLASS_NAME) { │ │ │ │ - if (control.displayProjection != this.displayProjection) { │ │ │ │ - this.displayProjection = control.displayProjection │ │ │ │ - } │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i == this.map.controls.length) { │ │ │ │ - this.map.addControl(new this.argParserClass({ │ │ │ │ - displayProjection: this.displayProjection │ │ │ │ - })) │ │ │ │ - } │ │ │ │ + addDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.addClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = true; │ │ │ │ + OpenLayers.Event.observe(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.observe(document, "mouseup", this._docUp) │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.element && !this.anchor) { │ │ │ │ - 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 │ │ │ │ - }); │ │ │ │ - this.updateLink(); │ │ │ │ - return this.div │ │ │ │ + removeDocumentEvents: function() { │ │ │ │ + OpenLayers.Element.removeClass(document.body, "olDragDown"); │ │ │ │ + this.documentEvents = false; │ │ │ │ + OpenLayers.Event.stopObserving(document, "mousemove", this._docMove); │ │ │ │ + OpenLayers.Event.stopObserving(document, "mouseup", this._docUp) │ │ │ │ }, │ │ │ │ - updateLink: function() { │ │ │ │ - var separator = this.anchor ? "#" : "?"; │ │ │ │ - var href = this.base; │ │ │ │ - var anchor = null; │ │ │ │ - if (href.indexOf("#") != -1 && this.anchor == false) { │ │ │ │ - anchor = href.substring(href.indexOf("#"), href.length) │ │ │ │ - } │ │ │ │ - if (href.indexOf(separator) != -1) { │ │ │ │ - href = href.substring(0, href.indexOf(separator)) │ │ │ │ - } │ │ │ │ - var splits = href.split("#"); │ │ │ │ - href = splits[0] + separator + OpenLayers.Util.getParameterString(this.createParams()); │ │ │ │ - if (anchor) { │ │ │ │ - href += anchor │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Drag" │ │ │ │ +}); │ │ │ │ +OpenLayers.Handler.RegularPolygon = OpenLayers.Class(OpenLayers.Handler.Drag, { │ │ │ │ + sides: 4, │ │ │ │ + radius: null, │ │ │ │ + snapAngle: null, │ │ │ │ + snapToggle: "shiftKey", │ │ │ │ + layerOptions: null, │ │ │ │ + persist: false, │ │ │ │ + irregular: false, │ │ │ │ + citeCompliant: false, │ │ │ │ + angle: null, │ │ │ │ + fixedRadius: false, │ │ │ │ + feature: null, │ │ │ │ + layer: null, │ │ │ │ + origin: null, │ │ │ │ + initialize: function(control, callbacks, options) { │ │ │ │ + if (!(options && options.layerOptions && options.layerOptions.styleMap)) { │ │ │ │ + this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style["default"], {}) │ │ │ │ } │ │ │ │ - if (this.anchor && !this.element) { │ │ │ │ - window.location.href = href │ │ │ │ - } else { │ │ │ │ - this.element.href = href │ │ │ │ + OpenLayers.Handler.Drag.prototype.initialize.apply(this, [control, callbacks, options]); │ │ │ │ + this.options = options ? options : {} │ │ │ │ + }, │ │ │ │ + setOptions: function(newOptions) { │ │ │ │ + OpenLayers.Util.extend(this.options, newOptions); │ │ │ │ + OpenLayers.Util.extend(this, newOptions) │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.Drag.prototype.activate.apply(this, arguments)) { │ │ │ │ + var options = OpenLayers.Util.extend({ │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + calculateInRange: OpenLayers.Function.True, │ │ │ │ + wrapDateLine: this.citeCompliant │ │ │ │ + }, this.layerOptions); │ │ │ │ + this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options); │ │ │ │ + this.map.addLayer(this.layer); │ │ │ │ + activated = true │ │ │ │ } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - createParams: function(center, zoom, layers) { │ │ │ │ - center = center || this.map.getCenter(); │ │ │ │ - var params = OpenLayers.Util.getParameters(this.base); │ │ │ │ - if (center) { │ │ │ │ - params.zoom = 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 │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.Drag.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + if (this.dragging) { │ │ │ │ + this.cancel() │ │ │ │ } │ │ │ │ - params.lat = Math.round(lat * 1e5) / 1e5; │ │ │ │ - params.lon = Math.round(lon * 1e5) / 1e5; │ │ │ │ - layers = layers || this.map.layers; │ │ │ │ - params.layers = ""; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - if (layer.isBaseLayer) { │ │ │ │ - params.layers += layer == this.map.baseLayer ? "B" : "0" │ │ │ │ - } else { │ │ │ │ - params.layers += layer.getVisibility() ? "T" : "F" │ │ │ │ + if (this.layer.map != null) { │ │ │ │ + this.layer.destroy(false); │ │ │ │ + if (this.feature) { │ │ │ │ + this.feature.destroy() │ │ │ │ } │ │ │ │ } │ │ │ │ + this.layer = null; │ │ │ │ + this.feature = null; │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ - return params │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Permalink" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Measure = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - callbacks: null, │ │ │ │ - displaySystem: "metric", │ │ │ │ - geodesic: false, │ │ │ │ - displaySystemUnits: { │ │ │ │ - geographic: ["dd"], │ │ │ │ - english: ["mi", "ft", "in"], │ │ │ │ - metric: ["km", "m"] │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - partialDelay: 300, │ │ │ │ - delayedTrigger: null, │ │ │ │ - persist: false, │ │ │ │ - immediate: false, │ │ │ │ - initialize: function(handler, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - var callbacks = { │ │ │ │ - done: this.measureComplete, │ │ │ │ - point: this.measurePartial │ │ │ │ - }; │ │ │ │ - if (this.immediate) { │ │ │ │ - callbacks.modify = this.measureImmediate │ │ │ │ + down: function(evt) { │ │ │ │ + this.fixedRadius = !!this.radius; │ │ │ │ + var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ + this.origin = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ + if (!this.fixedRadius || this.irregular) { │ │ │ │ + this.radius = this.map.getResolution() │ │ │ │ } │ │ │ │ - this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ - this.handlerOptions = OpenLayers.Util.extend({ │ │ │ │ - persist: this.persist │ │ │ │ - }, this.handlerOptions); │ │ │ │ - this.handler = new handler(this, this.callbacks, this.handlerOptions) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - this.cancelDelay(); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - cancel: function() { │ │ │ │ - this.cancelDelay(); │ │ │ │ - this.handler.cancel() │ │ │ │ + if (this.persist) { │ │ │ │ + this.clear() │ │ │ │ + } │ │ │ │ + this.feature = new OpenLayers.Feature.Vector; │ │ │ │ + this.createGeometry(); │ │ │ │ + this.callback("create", [this.origin, this.feature]); │ │ │ │ + this.layer.addFeatures([this.feature], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.layer.drawFeature(this.feature, this.style) │ │ │ │ }, │ │ │ │ - setImmediate: function(immediate) { │ │ │ │ - this.immediate = immediate; │ │ │ │ - if (this.immediate) { │ │ │ │ - this.callbacks.modify = this.measureImmediate │ │ │ │ + move: function(evt) { │ │ │ │ + var maploc = this.layer.getLonLatFromViewPortPx(evt.xy); │ │ │ │ + var point = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); │ │ │ │ + if (this.irregular) { │ │ │ │ + var ry = Math.sqrt(2) * Math.abs(point.y - this.origin.y) / 2; │ │ │ │ + this.radius = Math.max(this.map.getResolution() / 2, ry) │ │ │ │ + } else if (this.fixedRadius) { │ │ │ │ + this.origin = point │ │ │ │ } else { │ │ │ │ - delete this.callbacks.modify │ │ │ │ + this.calculateAngle(point, evt); │ │ │ │ + this.radius = Math.max(this.map.getResolution() / 2, point.distanceTo(this.origin)) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - updateHandler: function(handler, options) { │ │ │ │ - var active = this.active; │ │ │ │ - if (active) { │ │ │ │ - this.deactivate() │ │ │ │ + this.modifyGeometry(); │ │ │ │ + if (this.irregular) { │ │ │ │ + var dx = point.x - this.origin.x; │ │ │ │ + var dy = point.y - this.origin.y; │ │ │ │ + var ratio; │ │ │ │ + if (dy == 0) { │ │ │ │ + ratio = dx / (this.radius * Math.sqrt(2)) │ │ │ │ + } else { │ │ │ │ + ratio = dx / dy │ │ │ │ + } │ │ │ │ + this.feature.geometry.resize(1, this.origin, ratio); │ │ │ │ + this.feature.geometry.move(dx / 2, dy / 2) │ │ │ │ } │ │ │ │ - this.handler = new handler(this, this.callbacks, options); │ │ │ │ - if (active) { │ │ │ │ - this.activate() │ │ │ │ + this.layer.drawFeature(this.feature, this.style) │ │ │ │ + }, │ │ │ │ + up: function(evt) { │ │ │ │ + this.finalize(); │ │ │ │ + if (this.start == this.last) { │ │ │ │ + this.callback("done", [evt.xy]) │ │ │ │ } │ │ │ │ }, │ │ │ │ - measureComplete: function(geometry) { │ │ │ │ - this.cancelDelay(); │ │ │ │ - this.measure(geometry, "measure") │ │ │ │ + out: function(evt) { │ │ │ │ + this.finalize() │ │ │ │ }, │ │ │ │ - measurePartial: function(point, geometry) { │ │ │ │ - this.cancelDelay(); │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - if (this.handler.freehandMode(this.handler.evt)) { │ │ │ │ - this.measure(geometry, "measurepartial") │ │ │ │ - } else { │ │ │ │ - this.delayedTrigger = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ - this.delayedTrigger = null; │ │ │ │ - this.measure(geometry, "measurepartial") │ │ │ │ - }, this), this.partialDelay) │ │ │ │ + createGeometry: function() { │ │ │ │ + this.angle = Math.PI * (1 / this.sides - 1 / 2); │ │ │ │ + if (this.snapAngle) { │ │ │ │ + this.angle += this.snapAngle * (Math.PI / 180) │ │ │ │ } │ │ │ │ + this.feature.geometry = OpenLayers.Geometry.Polygon.createRegularPolygon(this.origin, this.radius, this.sides, this.snapAngle) │ │ │ │ }, │ │ │ │ - measureImmediate: function(point, feature, drawing) { │ │ │ │ - if (drawing && !this.handler.freehandMode(this.handler.evt)) { │ │ │ │ - this.cancelDelay(); │ │ │ │ - this.measure(feature.geometry, "measurepartial") │ │ │ │ + modifyGeometry: function() { │ │ │ │ + var angle, point; │ │ │ │ + var ring = this.feature.geometry.components[0]; │ │ │ │ + if (ring.components.length != this.sides + 1) { │ │ │ │ + this.createGeometry(); │ │ │ │ + ring = this.feature.geometry.components[0] │ │ │ │ } │ │ │ │ - }, │ │ │ │ - cancelDelay: function() { │ │ │ │ - if (this.delayedTrigger !== null) { │ │ │ │ - window.clearTimeout(this.delayedTrigger); │ │ │ │ - this.delayedTrigger = null │ │ │ │ + for (var i = 0; i < this.sides; ++i) { │ │ │ │ + point = ring.components[i]; │ │ │ │ + angle = this.angle + i * 2 * Math.PI / this.sides; │ │ │ │ + point.x = this.origin.x + this.radius * Math.cos(angle); │ │ │ │ + point.y = this.origin.y + this.radius * Math.sin(angle); │ │ │ │ + point.clearBounds() │ │ │ │ } │ │ │ │ }, │ │ │ │ - measure: function(geometry, eventType) { │ │ │ │ - var stat, order; │ │ │ │ - if (geometry.CLASS_NAME.indexOf("LineString") > -1) { │ │ │ │ - stat = this.getBestLength(geometry); │ │ │ │ - order = 1 │ │ │ │ + calculateAngle: function(point, evt) { │ │ │ │ + var alpha = Math.atan2(point.y - this.origin.y, point.x - this.origin.x); │ │ │ │ + if (this.snapAngle && (this.snapToggle && !evt[this.snapToggle])) { │ │ │ │ + var snapAngleRad = Math.PI / 180 * this.snapAngle; │ │ │ │ + this.angle = Math.round(alpha / snapAngleRad) * snapAngleRad │ │ │ │ } else { │ │ │ │ - stat = this.getBestArea(geometry); │ │ │ │ - order = 2 │ │ │ │ + this.angle = alpha │ │ │ │ } │ │ │ │ - this.events.triggerEvent(eventType, { │ │ │ │ - measure: stat[0], │ │ │ │ - units: stat[1], │ │ │ │ - order: order, │ │ │ │ - geometry: geometry │ │ │ │ - }) │ │ │ │ }, │ │ │ │ - getBestArea: function(geometry) { │ │ │ │ - var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ - var unit, area; │ │ │ │ - for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ - unit = units[i]; │ │ │ │ - area = this.getArea(geometry, unit); │ │ │ │ - if (area > 1) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return [area, unit] │ │ │ │ + cancel: function() { │ │ │ │ + this.callback("cancel", null); │ │ │ │ + this.finalize() │ │ │ │ }, │ │ │ │ - getArea: function(geometry, units) { │ │ │ │ - var area, geomUnits; │ │ │ │ - if (this.geodesic) { │ │ │ │ - area = geometry.getGeodesicArea(this.map.getProjectionObject()); │ │ │ │ - geomUnits = "m" │ │ │ │ - } else { │ │ │ │ - area = geometry.getArea(); │ │ │ │ - geomUnits = this.map.getUnits() │ │ │ │ - } │ │ │ │ - var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ - if (inPerDisplayUnit) { │ │ │ │ - var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ - area *= Math.pow(inPerMapUnit / inPerDisplayUnit, 2) │ │ │ │ - } │ │ │ │ - return area │ │ │ │ + finalize: function() { │ │ │ │ + this.origin = null; │ │ │ │ + this.radius = this.options.radius │ │ │ │ }, │ │ │ │ - getBestLength: function(geometry) { │ │ │ │ - var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ - var unit, length; │ │ │ │ - for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ - unit = units[i]; │ │ │ │ - length = this.getLength(geometry, unit); │ │ │ │ - if (length > 1) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ + clear: function() { │ │ │ │ + if (this.layer) { │ │ │ │ + this.layer.renderer.clear(); │ │ │ │ + this.layer.destroyFeatures() │ │ │ │ } │ │ │ │ - return [length, unit] │ │ │ │ }, │ │ │ │ - getLength: function(geometry, units) { │ │ │ │ - var length, geomUnits; │ │ │ │ - if (this.geodesic) { │ │ │ │ - length = geometry.getGeodesicLength(this.map.getProjectionObject()); │ │ │ │ - geomUnits = "m" │ │ │ │ - } else { │ │ │ │ - length = geometry.getLength(); │ │ │ │ - geomUnits = this.map.getUnits() │ │ │ │ + callback: function(name, args) { │ │ │ │ + if (this.callbacks[name]) { │ │ │ │ + this.callbacks[name].apply(this.control, [this.feature.geometry.clone()]) │ │ │ │ } │ │ │ │ - var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ - if (inPerDisplayUnit) { │ │ │ │ - var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ - length *= inPerMapUnit / inPerDisplayUnit │ │ │ │ + if (!this.persist && (name == "done" || name == "cancel")) { │ │ │ │ + this.clear() │ │ │ │ } │ │ │ │ - return length │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Measure" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.RegularPolygon" │ │ │ │ }); │ │ │ │ OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ dragHandler: null, │ │ │ │ boxDivClassName: "olHandlerBoxZoomBox", │ │ │ │ boxOffsets: null, │ │ │ │ initialize: function(control, callbacks, options) { │ │ │ │ OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ @@ -24364,148 +29130,99 @@ │ │ │ │ height: w3cBoxModel === false ? top + bottom : 0 │ │ │ │ } │ │ │ │ } │ │ │ │ return this.boxOffsets │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Handler.Box" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - out: false, │ │ │ │ - keyMask: null, │ │ │ │ - alwaysZoom: false, │ │ │ │ - zoomOnClick: true, │ │ │ │ - draw: function() { │ │ │ │ - this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.zoomBox │ │ │ │ - }, { │ │ │ │ - keyMask: this.keyMask │ │ │ │ - }) │ │ │ │ +OpenLayers.Handler.Pinch = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ + started: false, │ │ │ │ + stopDown: false, │ │ │ │ + pinching: false, │ │ │ │ + last: null, │ │ │ │ + start: null, │ │ │ │ + touchstart: function(evt) { │ │ │ │ + var propagate = true; │ │ │ │ + this.pinching = false; │ │ │ │ + if (OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ + this.started = true; │ │ │ │ + this.last = this.start = { │ │ │ │ + distance: this.getDistance(evt.touches), │ │ │ │ + delta: 0, │ │ │ │ + scale: 1 │ │ │ │ + }; │ │ │ │ + this.callback("start", [evt, this.start]); │ │ │ │ + propagate = !this.stopDown │ │ │ │ + } else if (this.started) { │ │ │ │ + return false │ │ │ │ + } else { │ │ │ │ + this.started = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null │ │ │ │ + } │ │ │ │ + OpenLayers.Event.preventDefault(evt); │ │ │ │ + return propagate │ │ │ │ }, │ │ │ │ - zoomBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var bounds, targetCenterPx = position.getCenterPixel(); │ │ │ │ - if (!this.out) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat) │ │ │ │ - } else { │ │ │ │ - var pixWidth = position.right - position.left; │ │ │ │ - var pixHeight = position.bottom - position.top; │ │ │ │ - var zoomFactor = Math.min(this.map.size.h / pixHeight, this.map.size.w / pixWidth); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ - var xmin = center.lon - extent.getWidth() / 2 * zoomFactor; │ │ │ │ - var xmax = center.lon + extent.getWidth() / 2 * zoomFactor; │ │ │ │ - var ymin = center.lat - extent.getHeight() / 2 * zoomFactor; │ │ │ │ - var ymax = center.lat + extent.getHeight() / 2 * zoomFactor; │ │ │ │ - bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax) │ │ │ │ - } │ │ │ │ - var lastZoom = this.map.getZoom(), │ │ │ │ - size = this.map.getSize(), │ │ │ │ - centerPx = { │ │ │ │ - x: size.w / 2, │ │ │ │ - y: size.h / 2 │ │ │ │ - }, │ │ │ │ - zoom = this.map.getZoomForExtent(bounds), │ │ │ │ - oldRes = this.map.getResolution(), │ │ │ │ - newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ - if (oldRes == newRes) { │ │ │ │ - this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)) │ │ │ │ - } else { │ │ │ │ - var zoomOriginPx = { │ │ │ │ - x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / (oldRes - newRes), │ │ │ │ - y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / (oldRes - newRes) │ │ │ │ - }; │ │ │ │ - this.map.zoomTo(zoom, zoomOriginPx) │ │ │ │ - } │ │ │ │ - if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ - this.map.zoomTo(lastZoom + (this.out ? -1 : 1)) │ │ │ │ - } │ │ │ │ - } else if (this.zoomOnClick) { │ │ │ │ - if (!this.out) { │ │ │ │ - this.map.zoomTo(this.map.getZoom() + 1, position) │ │ │ │ - } else { │ │ │ │ - this.map.zoomTo(this.map.getZoom() - 1, position) │ │ │ │ - } │ │ │ │ + touchmove: function(evt) { │ │ │ │ + if (this.started && OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ + this.pinching = true; │ │ │ │ + var current = this.getPinchData(evt); │ │ │ │ + this.callback("move", [evt, current]); │ │ │ │ + this.last = current; │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ + } else if (this.started) { │ │ │ │ + return false │ │ │ │ } │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ - panned: false, │ │ │ │ - interval: 0, │ │ │ │ - documentDrag: false, │ │ │ │ - kinetic: null, │ │ │ │ - enableKinetic: true, │ │ │ │ - kineticInterval: 10, │ │ │ │ - draw: function() { │ │ │ │ - if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ - var config = { │ │ │ │ - interval: this.kineticInterval │ │ │ │ - }; │ │ │ │ - if (typeof this.enableKinetic === "object") { │ │ │ │ - config = OpenLayers.Util.extend(config, this.enableKinetic) │ │ │ │ - } │ │ │ │ - this.kinetic = new OpenLayers.Kinetic(config) │ │ │ │ + touchend: function(evt) { │ │ │ │ + if (this.started && !OpenLayers.Event.isMultiTouch(evt)) { │ │ │ │ + this.started = false; │ │ │ │ + this.pinching = false; │ │ │ │ + this.callback("done", [evt, this.start, this.last]); │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + return false │ │ │ │ } │ │ │ │ - this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ - move: this.panMap, │ │ │ │ - done: this.panMapDone, │ │ │ │ - down: this.panMapStart │ │ │ │ - }, { │ │ │ │ - interval: this.interval, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }) │ │ │ │ + return true │ │ │ │ }, │ │ │ │ - panMapStart: function() { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.begin() │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.pinching = false; │ │ │ │ + activated = true │ │ │ │ } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - panMap: function(xy) { │ │ │ │ - if (this.kinetic) { │ │ │ │ - this.kinetic.update(xy) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.started = false; │ │ │ │ + this.pinching = false; │ │ │ │ + this.start = null; │ │ │ │ + this.last = null; │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ - this.panned = true; │ │ │ │ - this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ - dragging: true, │ │ │ │ - animate: false │ │ │ │ - }) │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - panMapDone: function(xy) { │ │ │ │ - if (this.panned) { │ │ │ │ - var res = null; │ │ │ │ - if (this.kinetic) { │ │ │ │ - res = this.kinetic.end(xy) │ │ │ │ - } │ │ │ │ - this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ - dragging: !!res, │ │ │ │ - animate: false │ │ │ │ - }); │ │ │ │ - if (res) { │ │ │ │ - var self = this; │ │ │ │ - this.kinetic.move(res, function(x, y, end) { │ │ │ │ - self.map.pan(x, y, { │ │ │ │ - dragging: !end, │ │ │ │ - animate: false │ │ │ │ - }) │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.panned = false │ │ │ │ + getDistance: function(touches) { │ │ │ │ + var t0 = touches[0]; │ │ │ │ + var t1 = touches[1]; │ │ │ │ + return Math.sqrt(Math.pow(t0.olClientX - t1.olClientX, 2) + Math.pow(t0.olClientY - t1.olClientY, 2)) │ │ │ │ + }, │ │ │ │ + getPinchData: function(evt) { │ │ │ │ + var distance = this.getDistance(evt.touches); │ │ │ │ + var scale = distance / this.start.distance; │ │ │ │ + return { │ │ │ │ + distance: distance, │ │ │ │ + delta: this.last.distance - distance, │ │ │ │ + scale: scale │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ + CLASS_NAME: "OpenLayers.Handler.Pinch" │ │ │ │ }); │ │ │ │ OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ wheelListener: null, │ │ │ │ interval: 0, │ │ │ │ maxDelta: Number.POSITIVE_INFINITY, │ │ │ │ delta: 0, │ │ │ │ cumulative: true, │ │ │ │ @@ -24611,3617 +29328,1112 @@ │ │ │ │ return true │ │ │ │ } else { │ │ │ │ return false │ │ │ │ } │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Handler.MouseWheel" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - dragPan: null, │ │ │ │ - dragPanOptions: null, │ │ │ │ - pinchZoom: null, │ │ │ │ - pinchZoomOptions: null, │ │ │ │ - documentDrag: false, │ │ │ │ - zoomBox: null, │ │ │ │ - zoomBoxEnabled: true, │ │ │ │ - zoomWheelEnabled: true, │ │ │ │ - mouseWheelOptions: null, │ │ │ │ - handleRightClicks: false, │ │ │ │ - zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ - autoActivate: true, │ │ │ │ +OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + url: null, │ │ │ │ + params: null, │ │ │ │ + callback: null, │ │ │ │ + callbackTemplate: "OpenLayers.Protocol.Script.registry.${id}", │ │ │ │ + callbackKey: "callback", │ │ │ │ + callbackPrefix: "", │ │ │ │ + scope: null, │ │ │ │ + format: null, │ │ │ │ + pendingRequests: null, │ │ │ │ + srsInBBOX: false, │ │ │ │ initialize: function(options) { │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.dragPan) { │ │ │ │ - this.dragPan.destroy() │ │ │ │ - } │ │ │ │ - this.dragPan = null; │ │ │ │ - if (this.zoomBox) { │ │ │ │ - this.zoomBox.destroy() │ │ │ │ - } │ │ │ │ - this.zoomBox = null; │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.destroy() │ │ │ │ - } │ │ │ │ - this.pinchZoom = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - this.dragPan.activate(); │ │ │ │ - if (this.zoomWheelEnabled) { │ │ │ │ - this.handlers.wheel.activate() │ │ │ │ - } │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - if (this.zoomBoxEnabled) { │ │ │ │ - this.zoomBox.activate() │ │ │ │ + options = options || {}; │ │ │ │ + this.params = {}; │ │ │ │ + this.pendingRequests = {}; │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + if (!this.format) { │ │ │ │ + this.format = new OpenLayers.Format.GeoJSON │ │ │ │ } │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.activate() │ │ │ │ + if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ + var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ + srsInBBOX: this.srsInBBOX │ │ │ │ + }); │ │ │ │ + this.filterToParams = function(filter, params) { │ │ │ │ + return format.write(filter, params) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.deactivate() │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + options.params = OpenLayers.Util.applyDefaults(options.params, this.options.params); │ │ │ │ + if (options.filter && this.filterToParams) { │ │ │ │ + options.params = this.filterToParams(options.filter, options.params) │ │ │ │ } │ │ │ │ - this.zoomBox.deactivate(); │ │ │ │ - this.dragPan.deactivate(); │ │ │ │ - this.handlers.click.deactivate(); │ │ │ │ - this.handlers.wheel.deactivate(); │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + var request = this.createRequest(options.url, options.params, OpenLayers.Function.bind(function(data) { │ │ │ │ + response.data = data; │ │ │ │ + this.handleRead(response, options) │ │ │ │ + }, this)); │ │ │ │ + response.priv = request; │ │ │ │ + return response │ │ │ │ }, │ │ │ │ - draw: function() { │ │ │ │ - if (this.handleRightClicks) { │ │ │ │ - this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False │ │ │ │ - } │ │ │ │ - var clickCallbacks = { │ │ │ │ - click: this.defaultClick, │ │ │ │ - dblclick: this.defaultDblClick, │ │ │ │ - dblrightclick: this.defaultDblRightClick │ │ │ │ - }; │ │ │ │ - var clickOptions = { │ │ │ │ - double: true, │ │ │ │ - stopDouble: true │ │ │ │ - }; │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks, clickOptions); │ │ │ │ - this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend({ │ │ │ │ - map: this.map, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }, this.dragPanOptions)); │ │ │ │ - this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ - map: this.map, │ │ │ │ - keyMask: this.zoomBoxKeyMask │ │ │ │ + createRequest: function(url, params, callback) { │ │ │ │ + var id = OpenLayers.Protocol.Script.register(callback); │ │ │ │ + var name = OpenLayers.String.format(this.callbackTemplate, { │ │ │ │ + id: id │ │ │ │ }); │ │ │ │ - this.dragPan.draw(); │ │ │ │ - this.zoomBox.draw(); │ │ │ │ - var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ - cumulative: false, │ │ │ │ - interval: 50, │ │ │ │ - maxDelta: 6 │ │ │ │ - }; │ │ │ │ - this.handlers.wheel = new OpenLayers.Handler.MouseWheel(this, { │ │ │ │ - up: this.wheelUp, │ │ │ │ - down: this.wheelDown │ │ │ │ - }, OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions)); │ │ │ │ - if (OpenLayers.Control.PinchZoom) { │ │ │ │ - this.pinchZoom = new OpenLayers.Control.PinchZoom(OpenLayers.Util.extend({ │ │ │ │ - map: this.map │ │ │ │ - }, this.pinchZoomOptions)) │ │ │ │ - } │ │ │ │ + params = OpenLayers.Util.extend({}, params); │ │ │ │ + params[this.callbackKey] = this.callbackPrefix + name; │ │ │ │ + url = OpenLayers.Util.urlAppend(url, OpenLayers.Util.getParameterString(params)); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = "OpenLayers_Protocol_Script_" + id; │ │ │ │ + this.pendingRequests[script.id] = script; │ │ │ │ + var head = document.getElementsByTagName("head")[0]; │ │ │ │ + head.appendChild(script); │ │ │ │ + return script │ │ │ │ }, │ │ │ │ - defaultClick: function(evt) { │ │ │ │ - if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ - this.map.zoomOut() │ │ │ │ + destroyRequest: function(script) { │ │ │ │ + OpenLayers.Protocol.Script.unregister(script.id.split("_").pop()); │ │ │ │ + delete this.pendingRequests[script.id]; │ │ │ │ + if (script.parentNode) { │ │ │ │ + script.parentNode.removeChild(script) │ │ │ │ } │ │ │ │ }, │ │ │ │ - defaultDblClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom + 1, evt.xy) │ │ │ │ - }, │ │ │ │ - defaultDblRightClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom - 1, evt.xy) │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + this.handleResponse(response, options) │ │ │ │ }, │ │ │ │ - wheelChange: function(evt, deltaZ) { │ │ │ │ - if (!this.map.fractionalZoom) { │ │ │ │ - deltaZ = Math.round(deltaZ) │ │ │ │ - } │ │ │ │ - var currentZoom = this.map.getZoom(), │ │ │ │ - newZoom = currentZoom + deltaZ; │ │ │ │ - newZoom = Math.max(newZoom, 0); │ │ │ │ - newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ - if (newZoom === currentZoom) { │ │ │ │ - return │ │ │ │ + handleResponse: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + if (response.data) { │ │ │ │ + response.features = this.parseFeatures(response.data); │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ + } │ │ │ │ + this.destroyRequest(response.priv); │ │ │ │ + options.callback.call(options.scope, response) │ │ │ │ } │ │ │ │ - this.map.zoomTo(newZoom, evt.xy) │ │ │ │ - }, │ │ │ │ - wheelUp: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || 1) │ │ │ │ }, │ │ │ │ - wheelDown: function(evt, delta) { │ │ │ │ - this.wheelChange(evt, delta || -1) │ │ │ │ - }, │ │ │ │ - disableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = false; │ │ │ │ - this.zoomBox.deactivate() │ │ │ │ + parseFeatures: function(data) { │ │ │ │ + return this.format.read(data) │ │ │ │ }, │ │ │ │ - enableZoomBox: function() { │ │ │ │ - this.zoomBoxEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.zoomBox.activate() │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + this.destroyRequest(response.priv) │ │ │ │ + } else { │ │ │ │ + for (var key in this.pendingRequests) { │ │ │ │ + this.destroyRequest(this.pendingRequests[key]) │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - disableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = false; │ │ │ │ - this.handlers.wheel.deactivate() │ │ │ │ - }, │ │ │ │ - enableZoomWheel: function() { │ │ │ │ - this.zoomWheelEnabled = true; │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.wheel.activate() │ │ │ │ - } │ │ │ │ + destroy: function() { │ │ │ │ + this.abort(); │ │ │ │ + delete this.params; │ │ │ │ + delete this.format; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.Script" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.NavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ +(function() { │ │ │ │ + var o = OpenLayers.Protocol.Script; │ │ │ │ + var counter = 0; │ │ │ │ + o.registry = {}; │ │ │ │ + o.register = function(callback) { │ │ │ │ + var id = "c" + ++counter; │ │ │ │ + o.registry[id] = function() { │ │ │ │ + callback.apply(this, arguments) │ │ │ │ + }; │ │ │ │ + return id │ │ │ │ + }; │ │ │ │ + o.unregister = function(id) { │ │ │ │ + delete o.registry[id] │ │ │ │ + } │ │ │ │ +})(); │ │ │ │ +OpenLayers.Protocol.WFS = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, OpenLayers.Protocol.WFS.DEFAULTS); │ │ │ │ + var cls = OpenLayers.Protocol.WFS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported WFS version: " + options.version │ │ │ │ + } │ │ │ │ + return new cls(options) │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.WFS.fromWMSLayer = function(layer, options) { │ │ │ │ + var typeName, featurePrefix; │ │ │ │ + var param = layer.params["LAYERS"]; │ │ │ │ + var parts = (OpenLayers.Util.isArray(param) ? param[0] : param).split(":"); │ │ │ │ + if (parts.length > 1) { │ │ │ │ + featurePrefix = parts[0] │ │ │ │ + } │ │ │ │ + typeName = parts.pop(); │ │ │ │ + var protocolOptions = { │ │ │ │ + url: layer.url, │ │ │ │ + featureType: typeName, │ │ │ │ + featurePrefix: featurePrefix, │ │ │ │ + srsName: layer.projection && layer.projection.getCode() || layer.map && layer.map.getProjectionObject().getCode(), │ │ │ │ + version: "1.1.0" │ │ │ │ + }; │ │ │ │ + return new OpenLayers.Protocol.WFS(OpenLayers.Util.applyDefaults(options, protocolOptions)) │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.WFS.DEFAULTS = { │ │ │ │ + version: "1.0.0" │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.CSW = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, OpenLayers.Protocol.CSW.DEFAULTS); │ │ │ │ + var cls = OpenLayers.Protocol.CSW["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported CSW version: " + options.version │ │ │ │ + } │ │ │ │ + return new cls(options) │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.CSW.DEFAULTS = { │ │ │ │ + version: "2.0.2" │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + url: null, │ │ │ │ + headers: null, │ │ │ │ + params: null, │ │ │ │ + callback: null, │ │ │ │ + scope: null, │ │ │ │ + readWithPOST: false, │ │ │ │ + updateWithPOST: false, │ │ │ │ + deleteWithPOST: false, │ │ │ │ + wildcarded: false, │ │ │ │ + srsInBBOX: false, │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - this.addControls([new OpenLayers.Control.Navigation, new OpenLayers.Control.ZoomBox]) │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.defaultControl === null) { │ │ │ │ - this.defaultControl = this.controls[0] │ │ │ │ - } │ │ │ │ - return div │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.NavToolbar" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.TransformFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - geometryTypes: null, │ │ │ │ - layer: null, │ │ │ │ - preserveAspectRatio: false, │ │ │ │ - rotate: true, │ │ │ │ - feature: null, │ │ │ │ - renderIntent: "temporary", │ │ │ │ - rotationHandleSymbolizer: null, │ │ │ │ - box: null, │ │ │ │ - center: null, │ │ │ │ - scale: 1, │ │ │ │ - ratio: 1, │ │ │ │ - rotation: 0, │ │ │ │ - handles: null, │ │ │ │ - rotationHandles: null, │ │ │ │ - dragControl: null, │ │ │ │ - irregular: false, │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.layer = layer; │ │ │ │ - if (!this.rotationHandleSymbolizer) { │ │ │ │ - this.rotationHandleSymbolizer = { │ │ │ │ - stroke: false, │ │ │ │ - pointRadius: 10, │ │ │ │ - fillOpacity: 0, │ │ │ │ - cursor: "pointer" │ │ │ │ + options = options || {}; │ │ │ │ + this.params = {}; │ │ │ │ + this.headers = {}; │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ + var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ + wildcarded: this.wildcarded, │ │ │ │ + srsInBBOX: this.srsInBBOX │ │ │ │ + }); │ │ │ │ + this.filterToParams = function(filter, params) { │ │ │ │ + return format.write(filter, params) │ │ │ │ } │ │ │ │ } │ │ │ │ - this.createBox(); │ │ │ │ - this.createControl() │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = false; │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragControl.activate(); │ │ │ │ - this.layer.addFeatures([this.box]); │ │ │ │ - this.rotate && this.layer.addFeatures(this.rotationHandles); │ │ │ │ - this.layer.addFeatures(this.handles); │ │ │ │ - activated = true │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ + destroy: function() { │ │ │ │ + this.params = null; │ │ │ │ + this.headers = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.layer.removeFeatures(this.handles); │ │ │ │ - this.rotate && this.layer.removeFeatures(this.rotationHandles); │ │ │ │ - this.layer.removeFeatures([this.box]); │ │ │ │ - this.dragControl.deactivate(); │ │ │ │ - deactivated = true │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = options || {}; │ │ │ │ + options.params = OpenLayers.Util.applyDefaults(options.params, this.options.params); │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + if (options.filter && this.filterToParams) { │ │ │ │ + options.params = this.filterToParams(options.filter, options.params) │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ + var readWithPOST = options.readWithPOST !== undefined ? options.readWithPOST : this.readWithPOST; │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + if (readWithPOST) { │ │ │ │ + var headers = options.headers || {}; │ │ │ │ + headers["Content-Type"] = "application/x-www-form-urlencoded"; │ │ │ │ + resp.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ + data: OpenLayers.Util.getParameterString(options.params), │ │ │ │ + headers: headers │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + resp.priv = OpenLayers.Request.GET({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return resp │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.dragControl.setMap(map); │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ + handleRead: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options) │ │ │ │ }, │ │ │ │ - setFeature: function(feature, initialParams) { │ │ │ │ - initialParams = OpenLayers.Util.applyDefaults(initialParams, { │ │ │ │ - rotation: 0, │ │ │ │ - scale: 1, │ │ │ │ - ratio: 1 │ │ │ │ + create: function(features, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: features, │ │ │ │ + requestType: "create" │ │ │ │ }); │ │ │ │ - var oldRotation = this.rotation; │ │ │ │ - var oldCenter = this.center; │ │ │ │ - OpenLayers.Util.extend(this, initialParams); │ │ │ │ - var cont = this.events.triggerEvent("beforesetfeature", { │ │ │ │ - feature: feature │ │ │ │ + resp.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleCreate, resp, options), │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(features) │ │ │ │ }); │ │ │ │ - if (cont === false) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - this.feature = feature; │ │ │ │ - this.activate(); │ │ │ │ - this._setfeature = true; │ │ │ │ - var featureBounds = this.feature.geometry.getBounds(); │ │ │ │ - this.box.move(featureBounds.getCenterLonLat()); │ │ │ │ - this.box.geometry.rotate(-oldRotation, oldCenter); │ │ │ │ - this._angle = 0; │ │ │ │ - var ll; │ │ │ │ - if (this.rotation) { │ │ │ │ - var geom = feature.geometry.clone(); │ │ │ │ - geom.rotate(-this.rotation, this.center); │ │ │ │ - var box = new OpenLayers.Feature.Vector(geom.getBounds().toGeometry()); │ │ │ │ - box.geometry.rotate(this.rotation, this.center); │ │ │ │ - this.box.geometry.rotate(this.rotation, this.center); │ │ │ │ - this.box.move(box.geometry.getBounds().getCenterLonLat()); │ │ │ │ - var llGeom = box.geometry.components[0].components[0]; │ │ │ │ - ll = llGeom.getBounds().getCenterLonLat() │ │ │ │ - } else { │ │ │ │ - ll = new OpenLayers.LonLat(featureBounds.left, featureBounds.bottom) │ │ │ │ - } │ │ │ │ - this.handles[0].move(ll); │ │ │ │ - delete this._setfeature; │ │ │ │ - this.events.triggerEvent("setfeature", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ + return resp │ │ │ │ }, │ │ │ │ - unsetFeature: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate() │ │ │ │ - } else { │ │ │ │ - this.feature = null; │ │ │ │ - this.rotation = 0; │ │ │ │ - this.scale = 1; │ │ │ │ - this.ratio = 1 │ │ │ │ - } │ │ │ │ + handleCreate: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options) │ │ │ │ }, │ │ │ │ - createBox: function() { │ │ │ │ - var control = this; │ │ │ │ - this.center = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ - this.box = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString([new OpenLayers.Geometry.Point(-1, -1), new OpenLayers.Geometry.Point(0, -1), new OpenLayers.Geometry.Point(1, -1), new OpenLayers.Geometry.Point(1, 0), new OpenLayers.Geometry.Point(1, 1), new OpenLayers.Geometry.Point(0, 1), new OpenLayers.Geometry.Point(-1, 1), new OpenLayers.Geometry.Point(-1, 0), new OpenLayers.Geometry.Point(-1, -1)]), null, typeof this.renderIntent == "string" ? null : this.renderIntent); │ │ │ │ - this.box.geometry.move = function(x, y) { │ │ │ │ - control._moving = true; │ │ │ │ - OpenLayers.Geometry.LineString.prototype.move.apply(this, arguments); │ │ │ │ - control.center.move(x, y); │ │ │ │ - delete control._moving │ │ │ │ - }; │ │ │ │ - var vertexMoveFn = function(x, y) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.apply(this, arguments); │ │ │ │ - this._rotationHandle && this._rotationHandle.geometry.move(x, y); │ │ │ │ - this._handle.geometry.move(x, y) │ │ │ │ - }; │ │ │ │ - var vertexResizeFn = function(scale, center, ratio) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.resize.apply(this, arguments); │ │ │ │ - this._rotationHandle && this._rotationHandle.geometry.resize(scale, center, ratio); │ │ │ │ - this._handle.geometry.resize(scale, center, ratio) │ │ │ │ - }; │ │ │ │ - var vertexRotateFn = function(angle, center) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.rotate.apply(this, arguments); │ │ │ │ - this._rotationHandle && this._rotationHandle.geometry.rotate(angle, center); │ │ │ │ - this._handle.geometry.rotate(angle, center) │ │ │ │ - }; │ │ │ │ - var handleMoveFn = function(x, y) { │ │ │ │ - var oldX = this.x, │ │ │ │ - oldY = this.y; │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - if (control._moving) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var evt = control.dragControl.handlers.drag.evt; │ │ │ │ - var preserveAspectRatio = !control._setfeature && control.preserveAspectRatio; │ │ │ │ - var reshape = !preserveAspectRatio && !(evt && evt.shiftKey); │ │ │ │ - var oldGeom = new OpenLayers.Geometry.Point(oldX, oldY); │ │ │ │ - var centerGeometry = control.center; │ │ │ │ - this.rotate(-control.rotation, centerGeometry); │ │ │ │ - oldGeom.rotate(-control.rotation, centerGeometry); │ │ │ │ - var dx1 = this.x - centerGeometry.x; │ │ │ │ - var dy1 = this.y - centerGeometry.y; │ │ │ │ - var dx0 = dx1 - (this.x - oldGeom.x); │ │ │ │ - var dy0 = dy1 - (this.y - oldGeom.y); │ │ │ │ - if (control.irregular && !control._setfeature) { │ │ │ │ - dx1 -= (this.x - oldGeom.x) / 2; │ │ │ │ - dy1 -= (this.y - oldGeom.y) / 2 │ │ │ │ - } │ │ │ │ - this.x = oldX; │ │ │ │ - this.y = oldY; │ │ │ │ - var scale, ratio = 1; │ │ │ │ - if (reshape) { │ │ │ │ - scale = Math.abs(dy0) < 1e-5 ? 1 : dy1 / dy0; │ │ │ │ - ratio = (Math.abs(dx0) < 1e-5 ? 1 : dx1 / dx0) / scale │ │ │ │ - } else { │ │ │ │ - var l0 = Math.sqrt(dx0 * dx0 + dy0 * dy0); │ │ │ │ - var l1 = Math.sqrt(dx1 * dx1 + dy1 * dy1); │ │ │ │ - scale = l1 / l0 │ │ │ │ - } │ │ │ │ - control._moving = true; │ │ │ │ - control.box.geometry.rotate(-control.rotation, centerGeometry); │ │ │ │ - delete control._moving; │ │ │ │ - control.box.geometry.resize(scale, centerGeometry, ratio); │ │ │ │ - control.box.geometry.rotate(control.rotation, centerGeometry); │ │ │ │ - control.transformFeature({ │ │ │ │ - scale: scale, │ │ │ │ - ratio: ratio │ │ │ │ - }); │ │ │ │ - if (control.irregular && !control._setfeature) { │ │ │ │ - var newCenter = centerGeometry.clone(); │ │ │ │ - newCenter.x += Math.abs(oldX - centerGeometry.x) < 1e-5 ? 0 : this.x - oldX; │ │ │ │ - newCenter.y += Math.abs(oldY - centerGeometry.y) < 1e-5 ? 0 : this.y - oldY; │ │ │ │ - control.box.geometry.move(this.x - oldX, this.y - oldY); │ │ │ │ - control.transformFeature({ │ │ │ │ - center: newCenter │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - var rotationHandleMoveFn = function(x, y) { │ │ │ │ - var oldX = this.x, │ │ │ │ - oldY = this.y; │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - if (control._moving) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var evt = control.dragControl.handlers.drag.evt; │ │ │ │ - var constrain = evt && evt.shiftKey ? 45 : 1; │ │ │ │ - var centerGeometry = control.center; │ │ │ │ - var dx1 = this.x - centerGeometry.x; │ │ │ │ - var dy1 = this.y - centerGeometry.y; │ │ │ │ - var dx0 = dx1 - x; │ │ │ │ - var dy0 = dy1 - y; │ │ │ │ - this.x = oldX; │ │ │ │ - this.y = oldY; │ │ │ │ - var a0 = Math.atan2(dy0, dx0); │ │ │ │ - var a1 = Math.atan2(dy1, dx1); │ │ │ │ - var angle = a1 - a0; │ │ │ │ - angle *= 180 / Math.PI; │ │ │ │ - control._angle = (control._angle + angle) % 360; │ │ │ │ - var diff = control.rotation % constrain; │ │ │ │ - if (Math.abs(control._angle) >= constrain || diff !== 0) { │ │ │ │ - angle = Math.round(control._angle / constrain) * constrain - diff; │ │ │ │ - control._angle = 0; │ │ │ │ - control.box.geometry.rotate(angle, centerGeometry); │ │ │ │ - control.transformFeature({ │ │ │ │ - rotation: angle │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - var handles = new Array(8); │ │ │ │ - var rotationHandles = new Array(4); │ │ │ │ - var geom, handle, rotationHandle; │ │ │ │ - var positions = ["sw", "s", "se", "e", "ne", "n", "nw", "w"]; │ │ │ │ - for (var i = 0; i < 8; ++i) { │ │ │ │ - geom = this.box.geometry.components[i]; │ │ │ │ - handle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ - role: positions[i] + "-resize" │ │ │ │ - }, typeof this.renderIntent == "string" ? null : this.renderIntent); │ │ │ │ - if (i % 2 == 0) { │ │ │ │ - rotationHandle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ - role: positions[i] + "-rotate" │ │ │ │ - }, typeof this.rotationHandleSymbolizer == "string" ? null : this.rotationHandleSymbolizer); │ │ │ │ - rotationHandle.geometry.move = rotationHandleMoveFn; │ │ │ │ - geom._rotationHandle = rotationHandle; │ │ │ │ - rotationHandles[i / 2] = rotationHandle │ │ │ │ - } │ │ │ │ - geom.move = vertexMoveFn; │ │ │ │ - geom.resize = vertexResizeFn; │ │ │ │ - geom.rotate = vertexRotateFn; │ │ │ │ - handle.geometry.move = handleMoveFn; │ │ │ │ - geom._handle = handle; │ │ │ │ - handles[i] = handle │ │ │ │ - } │ │ │ │ - this.rotationHandles = rotationHandles; │ │ │ │ - this.handles = handles │ │ │ │ + update: function(feature, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var url = options.url || feature.url || this.options.url + "/" + feature.fid; │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: feature, │ │ │ │ + requestType: "update" │ │ │ │ + }); │ │ │ │ + var method = this.updateWithPOST ? "POST" : "PUT"; │ │ │ │ + resp.priv = OpenLayers.Request[method]({ │ │ │ │ + url: url, │ │ │ │ + callback: this.createCallback(this.handleUpdate, resp, options), │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(feature) │ │ │ │ + }); │ │ │ │ + return resp │ │ │ │ }, │ │ │ │ - createControl: function() { │ │ │ │ - var control = this; │ │ │ │ - this.dragControl = new OpenLayers.Control.DragFeature(this.layer, { │ │ │ │ - documentDrag: true, │ │ │ │ - moveFeature: function(pixel) { │ │ │ │ - if (this.feature === control.feature) { │ │ │ │ - this.feature = control.box │ │ │ │ - } │ │ │ │ - OpenLayers.Control.DragFeature.prototype.moveFeature.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - onDrag: function(feature, pixel) { │ │ │ │ - if (feature === control.box) { │ │ │ │ - control.transformFeature({ │ │ │ │ - center: control.center │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - onStart: function(feature, pixel) { │ │ │ │ - var eligible = !control.geometryTypes || OpenLayers.Util.indexOf(control.geometryTypes, feature.geometry.CLASS_NAME) !== -1; │ │ │ │ - var i = OpenLayers.Util.indexOf(control.handles, feature); │ │ │ │ - i += OpenLayers.Util.indexOf(control.rotationHandles, feature); │ │ │ │ - if (feature !== control.feature && feature !== control.box && i == -2 && eligible) { │ │ │ │ - control.setFeature(feature) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - onComplete: function(feature, pixel) { │ │ │ │ - control.events.triggerEvent("transformcomplete", { │ │ │ │ - feature: control.feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }) │ │ │ │ + handleUpdate: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options) │ │ │ │ }, │ │ │ │ - drawHandles: function() { │ │ │ │ - var layer = this.layer; │ │ │ │ - for (var i = 0; i < 8; ++i) { │ │ │ │ - if (this.rotate && i % 2 === 0) { │ │ │ │ - layer.drawFeature(this.rotationHandles[i / 2], this.rotationHandleSymbolizer) │ │ │ │ - } │ │ │ │ - layer.drawFeature(this.handles[i], this.renderIntent) │ │ │ │ + delete: function(feature, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var url = options.url || feature.url || this.options.url + "/" + feature.fid; │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var resp = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: feature, │ │ │ │ + requestType: "delete" │ │ │ │ + }); │ │ │ │ + var method = this.deleteWithPOST ? "POST" : "DELETE"; │ │ │ │ + var requestOptions = { │ │ │ │ + url: url, │ │ │ │ + callback: this.createCallback(this.handleDelete, resp, options), │ │ │ │ + headers: options.headers │ │ │ │ + }; │ │ │ │ + if (this.deleteWithPOST) { │ │ │ │ + requestOptions.data = this.format.write(feature) │ │ │ │ } │ │ │ │ + resp.priv = OpenLayers.Request[method](requestOptions); │ │ │ │ + return resp │ │ │ │ }, │ │ │ │ - transformFeature: function(mods) { │ │ │ │ - if (!this._setfeature) { │ │ │ │ - this.scale *= mods.scale || 1; │ │ │ │ - this.ratio *= mods.ratio || 1; │ │ │ │ - var oldRotation = this.rotation; │ │ │ │ - this.rotation = (this.rotation + (mods.rotation || 0)) % 360; │ │ │ │ - if (this.events.triggerEvent("beforetransform", mods) !== false) { │ │ │ │ - var feature = this.feature; │ │ │ │ - var geom = feature.geometry; │ │ │ │ - var center = this.center; │ │ │ │ - geom.rotate(-oldRotation, center); │ │ │ │ - if (mods.scale || mods.ratio) { │ │ │ │ - geom.resize(mods.scale, center, mods.ratio) │ │ │ │ - } else if (mods.center) { │ │ │ │ - feature.move(mods.center.getBounds().getCenterLonLat()) │ │ │ │ + handleDelete: function(resp, options) { │ │ │ │ + this.handleResponse(resp, options) │ │ │ │ + }, │ │ │ │ + handleResponse: function(resp, options) { │ │ │ │ + var request = resp.priv; │ │ │ │ + if (options.callback) { │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + if (resp.requestType != "delete") { │ │ │ │ + resp.features = this.parseFeatures(request) │ │ │ │ } │ │ │ │ - geom.rotate(this.rotation, center); │ │ │ │ - this.layer.drawFeature(feature); │ │ │ │ - feature.toState(OpenLayers.State.UPDATE); │ │ │ │ - this.events.triggerEvent("transform", mods) │ │ │ │ + resp.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + } else { │ │ │ │ + resp.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ } │ │ │ │ + options.callback.call(options.scope, resp) │ │ │ │ } │ │ │ │ - this.layer.drawFeature(this.box, this.renderIntent); │ │ │ │ - this.drawHandles() │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0; i < 8; ++i) { │ │ │ │ - geom = this.box.geometry.components[i]; │ │ │ │ - geom._handle.destroy(); │ │ │ │ - geom._handle = null; │ │ │ │ - geom._rotationHandle && geom._rotationHandle.destroy(); │ │ │ │ - geom._rotationHandle = null │ │ │ │ + parseFeatures: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ } │ │ │ │ - this.center = null; │ │ │ │ - this.feature = null; │ │ │ │ - this.handles = null; │ │ │ │ - this.rotationHandleSymbolizer = null; │ │ │ │ - this.rotationHandles = null; │ │ │ │ - this.box.destroy(); │ │ │ │ - this.box = null; │ │ │ │ - this.layer = null; │ │ │ │ - this.dragControl.destroy(); │ │ │ │ - this.dragControl = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ + return this.format.read(doc) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.TransformFeature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.DrawFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - layer: null, │ │ │ │ - callbacks: null, │ │ │ │ - multi: false, │ │ │ │ - featureAdded: function() {}, │ │ │ │ - initialize: function(layer, handler, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.callbacks = OpenLayers.Util.extend({ │ │ │ │ - done: this.drawFeature, │ │ │ │ - modify: function(vertex, feature) { │ │ │ │ - this.layer.events.triggerEvent("sketchmodified", { │ │ │ │ - vertex: vertex, │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - create: function(vertex, feature) { │ │ │ │ - this.layer.events.triggerEvent("sketchstarted", { │ │ │ │ - vertex: vertex, │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ + commit: function(features, options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var resp = [], │ │ │ │ + nResponses = 0; │ │ │ │ + var types = {}; │ │ │ │ + types[OpenLayers.State.INSERT] = []; │ │ │ │ + types[OpenLayers.State.UPDATE] = []; │ │ │ │ + types[OpenLayers.State.DELETE] = []; │ │ │ │ + var feature, list, requestFeatures = []; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + list = types[feature.state]; │ │ │ │ + if (list) { │ │ │ │ + list.push(feature); │ │ │ │ + requestFeatures.push(feature) │ │ │ │ } │ │ │ │ - }, this.callbacks); │ │ │ │ - this.layer = layer; │ │ │ │ - this.handlerOptions = this.handlerOptions || {}; │ │ │ │ - this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(this.handlerOptions.layerOptions, { │ │ │ │ - renderers: layer.renderers, │ │ │ │ - rendererOptions: layer.rendererOptions │ │ │ │ + } │ │ │ │ + var nRequests = (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) + types[OpenLayers.State.UPDATE].length + types[OpenLayers.State.DELETE].length; │ │ │ │ + var success = true; │ │ │ │ + var finalResponse = new OpenLayers.Protocol.Response({ │ │ │ │ + reqFeatures: requestFeatures │ │ │ │ }); │ │ │ │ - if (!("multi" in this.handlerOptions)) { │ │ │ │ - this.handlerOptions.multi = this.multi │ │ │ │ + │ │ │ │ + function insertCallback(response) { │ │ │ │ + var len = response.features ? response.features.length : 0; │ │ │ │ + var fids = new Array(len); │ │ │ │ + for (var i = 0; i < len; ++i) { │ │ │ │ + fids[i] = response.features[i].fid │ │ │ │ + } │ │ │ │ + finalResponse.insertIds = fids; │ │ │ │ + callback.apply(this, [response]) │ │ │ │ } │ │ │ │ - var sketchStyle = this.layer.styleMap && this.layer.styleMap.styles.temporary; │ │ │ │ - if (sketchStyle) { │ │ │ │ - this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(this.handlerOptions.layerOptions, { │ │ │ │ - styleMap: new OpenLayers.StyleMap({ │ │ │ │ - default: sketchStyle │ │ │ │ - }) │ │ │ │ - }) │ │ │ │ + │ │ │ │ + function callback(response) { │ │ │ │ + this.callUserCallback(response, options); │ │ │ │ + success = success && response.success(); │ │ │ │ + nResponses++; │ │ │ │ + if (nResponses >= nRequests) { │ │ │ │ + if (options.callback) { │ │ │ │ + finalResponse.code = success ? OpenLayers.Protocol.Response.SUCCESS : OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + options.callback.apply(options.scope, [finalResponse]) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.handler = new handler(this, this.callbacks, this.handlerOptions) │ │ │ │ - }, │ │ │ │ - drawFeature: function(geometry) { │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - var proceed = this.layer.events.triggerEvent("sketchcomplete", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (proceed !== false) { │ │ │ │ - feature.state = OpenLayers.State.INSERT; │ │ │ │ - this.layer.addFeatures([feature]); │ │ │ │ - this.featureAdded(feature); │ │ │ │ - this.events.triggerEvent("featureadded", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ + var queue = types[OpenLayers.State.INSERT]; │ │ │ │ + if (queue.length > 0) { │ │ │ │ + resp.push(this.create(queue, OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: insertCallback, │ │ │ │ + scope: this │ │ │ │ + }, options.create))) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - insertXY: function(x, y) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertXY(x, y) │ │ │ │ + queue = types[OpenLayers.State.UPDATE]; │ │ │ │ + for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ + resp.push(this.update(queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: callback, │ │ │ │ + scope: this │ │ │ │ + }, options.update))) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - insertDeltaXY: function(dx, dy) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertDeltaXY(dx, dy) │ │ │ │ + queue = types[OpenLayers.State.DELETE]; │ │ │ │ + for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ + resp.push(this["delete"](queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: callback, │ │ │ │ + scope: this │ │ │ │ + }, options["delete"]))) │ │ │ │ } │ │ │ │ + return resp │ │ │ │ }, │ │ │ │ - insertDirectionLength: function(direction, length) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertDirectionLength(direction, length) │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + response.priv.abort() │ │ │ │ } │ │ │ │ }, │ │ │ │ - insertDeflectionLength: function(deflection, length) { │ │ │ │ - if (this.handler && this.handler.line) { │ │ │ │ - this.handler.insertDeflectionLength(deflection, length) │ │ │ │ + callUserCallback: function(resp, options) { │ │ │ │ + var opt = options[resp.requestType]; │ │ │ │ + if (opt && opt.callback) { │ │ │ │ + opt.callback.call(opt.scope, resp) │ │ │ │ } │ │ │ │ }, │ │ │ │ - undo: function() { │ │ │ │ - return this.handler.undo && this.handler.undo() │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ +}); │ │ │ │ +OpenLayers.Protocol.SOS = function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults(options, OpenLayers.Protocol.SOS.DEFAULTS); │ │ │ │ + var cls = OpenLayers.Protocol.SOS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ + if (!cls) { │ │ │ │ + throw "Unsupported SOS version: " + options.version │ │ │ │ + } │ │ │ │ + return new cls(options) │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.SOS.DEFAULTS = { │ │ │ │ + version: "1.0.0" │ │ │ │ +}; │ │ │ │ +OpenLayers.Protocol.CSW.v2_0_2 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + formatOptions: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!options.format) { │ │ │ │ + this.format = new OpenLayers.Format.CSWGetRecords.v2_0_2(OpenLayers.Util.extend({}, this.formatOptions)) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - redo: function() { │ │ │ │ - return this.handler.redo && this.handler.redo() │ │ │ │ + destroy: function() { │ │ │ │ + if (this.options && !this.options.format) { │ │ │ │ + this.format.destroy() │ │ │ │ + } │ │ │ │ + this.format = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - finishSketch: function() { │ │ │ │ - this.handler.finishGeometry() │ │ │ │ + read: function(options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + var data = this.format.write(options.params || options); │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, response, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers, │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + return response │ │ │ │ }, │ │ │ │ - cancel: function() { │ │ │ │ - this.handler.cancel() │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + response.data = this.parseData(request); │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ + } │ │ │ │ + options.callback.call(options.scope, response) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.DrawFeature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ZoomOut = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.zoomOut() │ │ │ │ + parseData: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ + } │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null │ │ │ │ } │ │ │ │ + return this.format.read(doc) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomOut" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.CSW.v2_0_2" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.UTFGrid = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - autoActivate: true, │ │ │ │ - layers: null, │ │ │ │ - defaultHandlerOptions: { │ │ │ │ - delay: 300, │ │ │ │ - pixelTolerance: 4, │ │ │ │ - stopMove: false, │ │ │ │ - single: true, │ │ │ │ - double: false, │ │ │ │ - stopSingle: false, │ │ │ │ - stopDouble: false │ │ │ │ - }, │ │ │ │ - handlerMode: "click", │ │ │ │ - setHandler: function(hm) { │ │ │ │ - this.handlerMode = hm; │ │ │ │ - this.resetHandler() │ │ │ │ - }, │ │ │ │ - resetHandler: function() { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate(); │ │ │ │ - this.handler.destroy(); │ │ │ │ - this.handler = null │ │ │ │ +OpenLayers.Protocol.WFS.v1 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + version: null, │ │ │ │ + srsName: "EPSG:4326", │ │ │ │ + featureType: null, │ │ │ │ + featureNS: null, │ │ │ │ + geometryName: "the_geom", │ │ │ │ + schema: null, │ │ │ │ + featurePrefix: "feature", │ │ │ │ + formatOptions: null, │ │ │ │ + readFormat: null, │ │ │ │ + readOptions: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!options.format) { │ │ │ │ + this.format = OpenLayers.Format.WFST(OpenLayers.Util.extend({ │ │ │ │ + version: this.version, │ │ │ │ + featureType: this.featureType, │ │ │ │ + featureNS: this.featureNS, │ │ │ │ + featurePrefix: this.featurePrefix, │ │ │ │ + geometryName: this.geometryName, │ │ │ │ + srsName: this.srsName, │ │ │ │ + schema: this.schema │ │ │ │ + }, this.formatOptions)) │ │ │ │ } │ │ │ │ - if (this.handlerMode == "hover") { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ - pause: this.handleEvent, │ │ │ │ - move: this.reset │ │ │ │ - }, this.handlerOptions) │ │ │ │ - } else if (this.handlerMode == "click") { │ │ │ │ - this.handler = new OpenLayers.Handler.Click(this, { │ │ │ │ - click: this.handleEvent │ │ │ │ - }, this.handlerOptions) │ │ │ │ - } else if (this.handlerMode == "move") { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ - pause: this.handleEvent, │ │ │ │ - move: this.handleEvent │ │ │ │ - }, this.handlerOptions) │ │ │ │ + if (!options.geometryName && parseFloat(this.format.version) > 1) { │ │ │ │ + this.setGeometryName(null) │ │ │ │ } │ │ │ │ - if (this.handler) { │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.options && !this.options.format) { │ │ │ │ + this.format.destroy() │ │ │ │ } │ │ │ │ + this.format = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.handlerOptions = options.handlerOptions || this.defaultHandlerOptions; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.resetHandler() │ │ │ │ + read: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + var data = OpenLayers.Format.XML.prototype.write.apply(this.format, [this.format.writeNode("wfs:GetFeature", options)]); │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, response, options), │ │ │ │ + params: options.params, │ │ │ │ + headers: options.headers, │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + return response │ │ │ │ }, │ │ │ │ - handleEvent: function(evt) { │ │ │ │ - if (evt == null) { │ │ │ │ - this.reset(); │ │ │ │ - return │ │ │ │ + setFeatureType: function(featureType) { │ │ │ │ + this.featureType = featureType; │ │ │ │ + this.format.featureType = featureType │ │ │ │ + }, │ │ │ │ + setGeometryName: function(geometryName) { │ │ │ │ + this.geometryName = geometryName; │ │ │ │ + this.format.geometryName = geometryName │ │ │ │ + }, │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + var result = this.parseResponse(request, options.readOptions); │ │ │ │ + if (result && result.success !== false) { │ │ │ │ + if (options.readOptions && options.readOptions.output == "object") { │ │ │ │ + OpenLayers.Util.extend(response, result) │ │ │ │ + } else { │ │ │ │ + response.features = result │ │ │ │ + } │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + response.error = result │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ + } │ │ │ │ + options.callback.call(options.scope, response) │ │ │ │ } │ │ │ │ - var lonLat = this.map.getLonLatFromPixel(evt.xy); │ │ │ │ - if (!lonLat) { │ │ │ │ - return │ │ │ │ + }, │ │ │ │ + parseResponse: function(request, options) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ } │ │ │ │ - var layers = this.findLayers(); │ │ │ │ - if (layers.length > 0) { │ │ │ │ - var infoLookup = {}; │ │ │ │ - var layer, idx; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - layer = layers[i]; │ │ │ │ - idx = OpenLayers.Util.indexOf(this.map.layers, layer); │ │ │ │ - infoLookup[idx] = layer.getFeatureInfo(lonLat) │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ + var result = this.readFormat !== null ? this.readFormat.read(doc) : this.format.read(doc, options); │ │ │ │ + if (!this.featureNS) { │ │ │ │ + var format = this.readFormat || this.format; │ │ │ │ + this.featureNS = format.featureNS; │ │ │ │ + format.autoConfig = false; │ │ │ │ + if (!this.geometryName) { │ │ │ │ + this.setGeometryName(format.geometryName) │ │ │ │ } │ │ │ │ - this.callback(infoLookup, lonLat, evt.xy) │ │ │ │ } │ │ │ │ + return result │ │ │ │ }, │ │ │ │ - callback: function(infoLookup) {}, │ │ │ │ - reset: function(evt) { │ │ │ │ - this.callback(null) │ │ │ │ + commit: function(features, options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "commit", │ │ │ │ + reqFeatures: features │ │ │ │ + }); │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + headers: options.headers, │ │ │ │ + data: this.format.write(features, options), │ │ │ │ + callback: this.createCallback(this.handleCommit, response, options) │ │ │ │ + }); │ │ │ │ + return response │ │ │ │ }, │ │ │ │ - findLayers: function() { │ │ │ │ - var candidates = this.layers || this.map.layers; │ │ │ │ - var layers = []; │ │ │ │ - var layer; │ │ │ │ - for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ - layer = candidates[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.UTFGrid) { │ │ │ │ - layers.push(layer) │ │ │ │ + handleCommit: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + var data = request.responseXML; │ │ │ │ + if (!data || !data.documentElement) { │ │ │ │ + data = request.responseText │ │ │ │ + } │ │ │ │ + var obj = this.format.read(data) || {}; │ │ │ │ + response.insertIds = obj.insertIds || []; │ │ │ │ + if (obj.success) { │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ + response.error = obj │ │ │ │ } │ │ │ │ + options.callback.call(options.scope, response) │ │ │ │ } │ │ │ │ - return layers │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.UTFGrid" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.EditingToolbar = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ - citeCompliant: false, │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - this.addControls([new OpenLayers.Control.Navigation]); │ │ │ │ - var controls = [new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Point, { │ │ │ │ - displayClass: "olControlDrawFeaturePoint", │ │ │ │ - handlerOptions: { │ │ │ │ - citeCompliant: this.citeCompliant │ │ │ │ - } │ │ │ │ - }), new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Path, { │ │ │ │ - displayClass: "olControlDrawFeaturePath", │ │ │ │ - handlerOptions: { │ │ │ │ - citeCompliant: this.citeCompliant │ │ │ │ + filterDelete: function(filter, options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "commit" │ │ │ │ + }); │ │ │ │ + var root = this.format.createElementNSPlus("wfs:Transaction", { │ │ │ │ + attributes: { │ │ │ │ + service: "WFS", │ │ │ │ + version: this.version │ │ │ │ } │ │ │ │ - }), new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Polygon, { │ │ │ │ - displayClass: "olControlDrawFeaturePolygon", │ │ │ │ - handlerOptions: { │ │ │ │ - citeCompliant: this.citeCompliant │ │ │ │ + }); │ │ │ │ + var deleteNode = this.format.createElementNSPlus("wfs:Delete", { │ │ │ │ + attributes: { │ │ │ │ + typeName: (options.featureNS ? this.featurePrefix + ":" : "") + options.featureType │ │ │ │ } │ │ │ │ - })]; │ │ │ │ - this.addControls(controls) │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ - if (this.defaultControl === null) { │ │ │ │ - this.defaultControl = this.controls[0] │ │ │ │ + }); │ │ │ │ + if (options.featureNS) { │ │ │ │ + deleteNode.setAttribute("xmlns:" + this.featurePrefix, options.featureNS) │ │ │ │ } │ │ │ │ - return div │ │ │ │ + var filterNode = this.format.writeNode("ogc:Filter", filter); │ │ │ │ + deleteNode.appendChild(filterNode); │ │ │ │ + root.appendChild(deleteNode); │ │ │ │ + var data = OpenLayers.Format.XML.prototype.write.apply(this.format, [root]); │ │ │ │ + return OpenLayers.Request.POST({ │ │ │ │ + url: this.url, │ │ │ │ + callback: options.callback || function() {}, │ │ │ │ + data: data │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.EditingToolbar" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - zoomInText: "+", │ │ │ │ - zoomInId: "olZoomInLink", │ │ │ │ - zoomOutText: "−", │ │ │ │ - zoomOutId: "olZoomOutLink", │ │ │ │ - draw: function() { │ │ │ │ - var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ - links = this.getOrCreateLinks(div), │ │ │ │ - zoomIn = links.zoomIn, │ │ │ │ - zoomOut = links.zoomOut, │ │ │ │ - eventsInstance = this.map.events; │ │ │ │ - if (zoomOut.parentNode !== div) { │ │ │ │ - eventsInstance = this.events; │ │ │ │ - eventsInstance.attachToElement(zoomOut.parentNode) │ │ │ │ + abort: function(response) { │ │ │ │ + if (response) { │ │ │ │ + response.priv.abort() │ │ │ │ } │ │ │ │ - eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ - this.zoomInLink = zoomIn; │ │ │ │ - this.zoomOutLink = zoomOut; │ │ │ │ - return div │ │ │ │ }, │ │ │ │ - getOrCreateLinks: function(el) { │ │ │ │ - var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ - zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ - if (!zoomIn) { │ │ │ │ - zoomIn = document.createElement("a"); │ │ │ │ - zoomIn.href = "#zoomIn"; │ │ │ │ - zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ - zoomIn.className = "olControlZoomIn"; │ │ │ │ - el.appendChild(zoomIn) │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ - if (!zoomOut) { │ │ │ │ - zoomOut = document.createElement("a"); │ │ │ │ - zoomOut.href = "#zoomOut"; │ │ │ │ - zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ - zoomOut.className = "olControlZoomOut"; │ │ │ │ - el.appendChild(zoomOut) │ │ │ │ - } │ │ │ │ - OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ - return { │ │ │ │ - zoomIn: zoomIn, │ │ │ │ - zoomOut: zoomOut │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.WFS.v1" │ │ │ │ +}); │ │ │ │ +OpenLayers.Protocol.WFS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ + version: "1.0.0", │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.WFS.v1_0_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Protocol.WFS.v1_1_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ + version: "1.1.0", │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.WFS.v1.prototype.initialize.apply(this, arguments); │ │ │ │ + if (this.outputFormat && !this.readFormat) { │ │ │ │ + if (this.outputFormat.toLowerCase() == "gml2") { │ │ │ │ + this.readFormat = new OpenLayers.Format.GML.v2({ │ │ │ │ + featureType: this.featureType, │ │ │ │ + featureNS: this.featureNS, │ │ │ │ + geometryName: this.geometryName │ │ │ │ + }) │ │ │ │ + } else if (this.outputFormat.toLowerCase() == "json") { │ │ │ │ + this.readFormat = new OpenLayers.Format.GeoJSON │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - onZoomClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.zoomInLink) { │ │ │ │ - this.map.zoomIn() │ │ │ │ - } else if (button === this.zoomOutLink) { │ │ │ │ - this.map.zoomOut() │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.WFS.v1_1_0" │ │ │ │ +}); │ │ │ │ +OpenLayers.Protocol.SOS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + fois: null, │ │ │ │ + formatOptions: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!options.format) { │ │ │ │ + this.format = new OpenLayers.Format.SOSGetFeatureOfInterest(this.formatOptions) │ │ │ │ } │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onZoomClick) │ │ │ │ + if (this.options && !this.options.format) { │ │ │ │ + this.format.destroy() │ │ │ │ } │ │ │ │ - delete this.zoomInLink; │ │ │ │ - delete this.zoomOutLink; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ -}); │ │ │ │ -OpenLayers.Handler.Keyboard = OpenLayers.Class(OpenLayers.Handler, { │ │ │ │ - KEY_EVENTS: ["keydown", "keyup"], │ │ │ │ - eventListener: null, │ │ │ │ - observeElement: null, │ │ │ │ - initialize: function(control, callbacks, options) { │ │ │ │ - OpenLayers.Handler.prototype.initialize.apply(this, arguments); │ │ │ │ - this.eventListener = OpenLayers.Function.bindAsEventListener(this.handleKeyEvent, this) │ │ │ │ + this.format = null; │ │ │ │ + OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - this.eventListener = null; │ │ │ │ - OpenLayers.Handler.prototype.destroy.apply(this, arguments) │ │ │ │ + read: function(options) { │ │ │ │ + options = OpenLayers.Util.extend({}, options); │ │ │ │ + OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ + var response = new OpenLayers.Protocol.Response({ │ │ │ │ + requestType: "read" │ │ │ │ + }); │ │ │ │ + var format = this.format; │ │ │ │ + var data = OpenLayers.Format.XML.prototype.write.apply(format, [format.writeNode("sos:GetFeatureOfInterest", { │ │ │ │ + fois: this.fois │ │ │ │ + })]); │ │ │ │ + response.priv = OpenLayers.Request.POST({ │ │ │ │ + url: options.url, │ │ │ │ + callback: this.createCallback(this.handleRead, response, options), │ │ │ │ + data: data │ │ │ │ + }); │ │ │ │ + return response │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.observeElement = this.observeElement || document; │ │ │ │ - for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ - OpenLayers.Event.observe(this.observeElement, this.KEY_EVENTS[i], this.eventListener) │ │ │ │ + handleRead: function(response, options) { │ │ │ │ + if (options.callback) { │ │ │ │ + var request = response.priv; │ │ │ │ + if (request.status >= 200 && request.status < 300) { │ │ │ │ + response.features = this.parseFeatures(request); │ │ │ │ + response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + } else { │ │ │ │ + response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ } │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + options.callback.call(options.scope, response) │ │ │ │ } │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - for (var i = 0, len = this.KEY_EVENTS.length; i < len; i++) { │ │ │ │ - OpenLayers.Event.stopObserving(this.observeElement, this.KEY_EVENTS[i], this.eventListener) │ │ │ │ - } │ │ │ │ - deactivated = true │ │ │ │ + parseFeatures: function(request) { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - handleKeyEvent: function(evt) { │ │ │ │ - if (this.checkModifiers(evt)) { │ │ │ │ - this.callback(evt.type, [evt]) │ │ │ │ + if (!doc || doc.length <= 0) { │ │ │ │ + return null │ │ │ │ } │ │ │ │ + return this.format.read(doc) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Handler.Keyboard" │ │ │ │ + CLASS_NAME: "OpenLayers.Protocol.SOS.v1_0_0" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - documentDrag: false, │ │ │ │ - geometryTypes: null, │ │ │ │ - clickout: true, │ │ │ │ - toggle: true, │ │ │ │ - standalone: false, │ │ │ │ - layer: null, │ │ │ │ - feature: null, │ │ │ │ - vertex: null, │ │ │ │ - vertices: null, │ │ │ │ - virtualVertices: null, │ │ │ │ - handlers: null, │ │ │ │ - deleteCodes: null, │ │ │ │ - virtualStyle: null, │ │ │ │ - vertexRenderIntent: null, │ │ │ │ - mode: null, │ │ │ │ - createVertices: true, │ │ │ │ - modified: false, │ │ │ │ - radiusHandle: null, │ │ │ │ - dragHandle: null, │ │ │ │ - onModificationStart: function() {}, │ │ │ │ - onModification: function() {}, │ │ │ │ - onModificationEnd: function() {}, │ │ │ │ - initialize: function(layer, options) { │ │ │ │ - options = options || {}; │ │ │ │ - this.layer = layer; │ │ │ │ - this.vertices = []; │ │ │ │ - this.virtualVertices = []; │ │ │ │ - this.virtualStyle = OpenLayers.Util.extend({}, this.layer.style || this.layer.styleMap.createSymbolizer(null, options.vertexRenderIntent)); │ │ │ │ - this.virtualStyle.fillOpacity = .3; │ │ │ │ - this.virtualStyle.strokeOpacity = .3; │ │ │ │ - this.deleteCodes = [46, 68]; │ │ │ │ - this.mode = OpenLayers.Control.ModifyFeature.RESHAPE; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!OpenLayers.Util.isArray(this.deleteCodes)) { │ │ │ │ - this.deleteCodes = [this.deleteCodes] │ │ │ │ - } │ │ │ │ - var dragCallbacks = { │ │ │ │ - down: function(pixel) { │ │ │ │ - this.vertex = null; │ │ │ │ - var feature = this.layer.getFeatureFromEvent(this.handlers.drag.evt); │ │ │ │ - if (feature) { │ │ │ │ - this.dragStart(feature) │ │ │ │ - } else if (this.clickout) { │ │ │ │ - this._unselect = this.feature │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - move: function(pixel) { │ │ │ │ - delete this._unselect; │ │ │ │ - if (this.vertex) { │ │ │ │ - this.dragVertex(this.vertex, pixel) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - up: function() { │ │ │ │ - this.handlers.drag.stopDown = false; │ │ │ │ - if (this._unselect) { │ │ │ │ - this.unselectFeature(this._unselect); │ │ │ │ - delete this._unselect │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - done: function(pixel) { │ │ │ │ - if (this.vertex) { │ │ │ │ - this.dragComplete(this.vertex) │ │ │ │ - } │ │ │ │ +OpenLayers.Events.featureclick = OpenLayers.Class({ │ │ │ │ + cache: null, │ │ │ │ + map: null, │ │ │ │ + provides: ["featureclick", "nofeatureclick", "featureover", "featureout"], │ │ │ │ + initialize: function(target) { │ │ │ │ + this.target = target; │ │ │ │ + if (target.object instanceof OpenLayers.Map) { │ │ │ │ + this.setMap(target.object) │ │ │ │ + } else if (target.object instanceof OpenLayers.Layer.Vector) { │ │ │ │ + if (target.object.map) { │ │ │ │ + this.setMap(target.object.map) │ │ │ │ + } else { │ │ │ │ + target.object.events.register("added", this, function(evt) { │ │ │ │ + this.setMap(target.object.map) │ │ │ │ + }) │ │ │ │ } │ │ │ │ - }; │ │ │ │ - var dragOptions = { │ │ │ │ - documentDrag: this.documentDrag, │ │ │ │ - stopDown: false │ │ │ │ - }; │ │ │ │ - var keyboardOptions = { │ │ │ │ - keydown: this.handleKeypress │ │ │ │ - }; │ │ │ │ - this.handlers = { │ │ │ │ - keyboard: new OpenLayers.Handler.Keyboard(this, keyboardOptions), │ │ │ │ - drag: new OpenLayers.Handler.Drag(this, dragCallbacks, dragOptions) │ │ │ │ + } else { │ │ │ │ + throw "Listeners for '" + this.provides.join("', '") + "' events can only be registered for OpenLayers.Layer.Vector " + "or OpenLayers.Map instances" │ │ │ │ } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.un({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ + for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ + target.extensions[this.provides[i]] = true │ │ │ │ } │ │ │ │ - this.layer = null; │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, []) │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - this.moveLayerToTop(); │ │ │ │ - this.map.events.on({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + this.cache = {}; │ │ │ │ + map.events.register("mousedown", this, this.start, { │ │ │ │ + extension: true │ │ │ │ }); │ │ │ │ - return this.handlers.keyboard.activate() && this.handlers.drag.activate() && OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ + map.events.register("mouseup", this, this.onClick, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("touchstart", this, this.start, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("touchmove", this, this.cancel, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("touchend", this, this.onClick, { │ │ │ │ + extension: true │ │ │ │ + }); │ │ │ │ + map.events.register("mousemove", this, this.onMousemove, { │ │ │ │ + extension: true │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = false; │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.moveLayerBack(); │ │ │ │ - this.map.events.un({ │ │ │ │ - removelayer: this.handleMapEvents, │ │ │ │ - changelayer: this.handleMapEvents, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - this.handlers.drag.deactivate(); │ │ │ │ - this.handlers.keyboard.deactivate(); │ │ │ │ - var feature = this.feature; │ │ │ │ - if (feature && feature.geometry && feature.layer) { │ │ │ │ - this.unselectFeature(feature) │ │ │ │ - } │ │ │ │ - deactivated = true │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ + start: function(evt) { │ │ │ │ + this.startEvt = evt │ │ │ │ }, │ │ │ │ - beforeSelectFeature: function(feature) { │ │ │ │ - return this.layer.events.triggerEvent("beforefeaturemodified", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ + cancel: function(evt) { │ │ │ │ + delete this.startEvt │ │ │ │ }, │ │ │ │ - selectFeature: function(feature) { │ │ │ │ - if (this.feature === feature || this.geometryTypes && OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) == -1) { │ │ │ │ + onClick: function(evt) { │ │ │ │ + if (!this.startEvt || evt.type !== "touchend" && !OpenLayers.Event.isLeftClick(evt)) { │ │ │ │ return │ │ │ │ } │ │ │ │ - if (this.beforeSelectFeature(feature) !== false) { │ │ │ │ - if (this.feature) { │ │ │ │ - this.unselectFeature(this.feature) │ │ │ │ + var features = this.getFeatures(this.startEvt); │ │ │ │ + delete this.startEvt; │ │ │ │ + var feature, layer, more, clicked = {}; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + layer = feature.layer; │ │ │ │ + clicked[layer.id] = true; │ │ │ │ + more = this.triggerEvent("featureclick", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (more === false) { │ │ │ │ + break │ │ │ │ } │ │ │ │ - this.feature = feature; │ │ │ │ - this.layer.selectedFeatures.push(feature); │ │ │ │ - this.layer.drawFeature(feature, "select"); │ │ │ │ - this.modified = false; │ │ │ │ - this.resetVertices(); │ │ │ │ - this.onModificationStart(this.feature) │ │ │ │ } │ │ │ │ - var modified = feature.modified; │ │ │ │ - if (feature.geometry && !(modified && modified.geometry)) { │ │ │ │ - this._originalGeometry = feature.geometry.clone() │ │ │ │ + for (i = 0, len = this.map.layers.length; i < len; ++i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector && !clicked[layer.id]) { │ │ │ │ + this.triggerEvent("nofeatureclick", { │ │ │ │ + layer: layer │ │ │ │ + }) │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - unselectFeature: function(feature) { │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.virtualVertices = []; │ │ │ │ - if (this.dragHandle) { │ │ │ │ - this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - delete this.dragHandle │ │ │ │ + onMousemove: function(evt) { │ │ │ │ + delete this.startEvt; │ │ │ │ + var features = this.getFeatures(evt); │ │ │ │ + var over = {}, │ │ │ │ + newly = [], │ │ │ │ + feature; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + over[feature.id] = feature; │ │ │ │ + if (!this.cache[feature.id]) { │ │ │ │ + newly.push(feature) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (this.radiusHandle) { │ │ │ │ - this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ + var out = []; │ │ │ │ + for (var id in this.cache) { │ │ │ │ + feature = this.cache[id]; │ │ │ │ + if (feature.layer && feature.layer.map) { │ │ │ │ + if (!over[feature.id]) { │ │ │ │ + out.push(feature) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + delete this.cache[id] │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var more; │ │ │ │ + for (i = 0, len = newly.length; i < len; ++i) { │ │ │ │ + feature = newly[i]; │ │ │ │ + this.cache[feature.id] = feature; │ │ │ │ + more = this.triggerEvent("featureover", { │ │ │ │ + feature: feature │ │ │ │ }); │ │ │ │ - delete this.radiusHandle │ │ │ │ + if (more === false) { │ │ │ │ + break │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.layer.drawFeature(this.feature, "default"); │ │ │ │ - this.feature = null; │ │ │ │ - OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); │ │ │ │ - this.onModificationEnd(feature); │ │ │ │ - this.layer.events.triggerEvent("afterfeaturemodified", { │ │ │ │ - feature: feature, │ │ │ │ - modified: this.modified │ │ │ │ - }); │ │ │ │ - this.modified = false │ │ │ │ - }, │ │ │ │ - dragStart: function(feature) { │ │ │ │ - var isPoint = feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point"; │ │ │ │ - if (!this.standalone && (!feature._sketch && isPoint || !feature._sketch)) { │ │ │ │ - if (this.toggle && this.feature === feature) { │ │ │ │ - this._unselect = feature │ │ │ │ + for (i = 0, len = out.length; i < len; ++i) { │ │ │ │ + feature = out[i]; │ │ │ │ + delete this.cache[feature.id]; │ │ │ │ + more = this.triggerEvent("featureout", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (more === false) { │ │ │ │ + break │ │ │ │ } │ │ │ │ - this.selectFeature(feature) │ │ │ │ } │ │ │ │ - if (feature._sketch || isPoint) { │ │ │ │ - this.vertex = feature; │ │ │ │ - this.handlers.drag.stopDown = true │ │ │ │ + }, │ │ │ │ + triggerEvent: function(type, evt) { │ │ │ │ + var layer = evt.feature ? evt.feature.layer : evt.layer, │ │ │ │ + object = this.target.object; │ │ │ │ + if (object instanceof OpenLayers.Map || object === layer) { │ │ │ │ + return this.target.triggerEvent(type, evt) │ │ │ │ } │ │ │ │ }, │ │ │ │ - dragVertex: function(vertex, pixel) { │ │ │ │ - var pos = this.map.getLonLatFromViewPortPx(pixel); │ │ │ │ - var geom = vertex.geometry; │ │ │ │ - geom.move(pos.lon - geom.x, pos.lat - geom.y); │ │ │ │ - this.modified = true; │ │ │ │ - if (this.feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ - vertex: vertex.geometry, │ │ │ │ - feature: this.feature, │ │ │ │ - pixel: pixel │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - if (vertex._index) { │ │ │ │ - vertex.geometry.parent.addComponent(vertex.geometry, vertex._index); │ │ │ │ - delete vertex._index; │ │ │ │ - OpenLayers.Util.removeItem(this.virtualVertices, vertex); │ │ │ │ - this.vertices.push(vertex) │ │ │ │ - } else if (vertex == this.dragHandle) { │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = []; │ │ │ │ - if (this.radiusHandle) { │ │ │ │ - this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.radiusHandle = null │ │ │ │ + getFeatures: function(evt) { │ │ │ │ + var x = evt.clientX, │ │ │ │ + y = evt.clientY, │ │ │ │ + features = [], │ │ │ │ + targets = [], │ │ │ │ + layers = [], │ │ │ │ + layer, target, feature, i, len; │ │ │ │ + for (i = this.map.layers.length - 1; i >= 0; --i) { │ │ │ │ + layer = this.map.layers[i]; │ │ │ │ + if (layer.div.style.display !== "none") { │ │ │ │ + if (layer.renderer instanceof OpenLayers.Renderer.Elements) { │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ + target = document.elementFromPoint(x, y); │ │ │ │ + while (target && target._featureId) { │ │ │ │ + feature = layer.getFeatureById(target._featureId); │ │ │ │ + if (feature) { │ │ │ │ + features.push(feature); │ │ │ │ + target.style.display = "none"; │ │ │ │ + targets.push(target); │ │ │ │ + target = document.elementFromPoint(x, y) │ │ │ │ + } else { │ │ │ │ + target = false │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + layers.push(layer); │ │ │ │ + layer.div.style.display = "none" │ │ │ │ + } else if (layer.renderer instanceof OpenLayers.Renderer.Canvas) { │ │ │ │ + feature = layer.renderer.getFeatureIdFromEvent(evt); │ │ │ │ + if (feature) { │ │ │ │ + features.push(feature); │ │ │ │ + layers.push(layer) │ │ │ │ + } │ │ │ │ } │ │ │ │ - } else if (vertex !== this.radiusHandle) { │ │ │ │ - this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ - vertex: vertex.geometry, │ │ │ │ - feature: this.feature, │ │ │ │ - pixel: pixel │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (this.virtualVertices.length > 0) { │ │ │ │ - this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.virtualVertices = [] │ │ │ │ } │ │ │ │ - this.layer.drawFeature(this.feature, this.standalone ? undefined : "select") │ │ │ │ } │ │ │ │ - this.layer.drawFeature(vertex) │ │ │ │ - }, │ │ │ │ - dragComplete: function(vertex) { │ │ │ │ - this.resetVertices(); │ │ │ │ - this.setFeatureState(); │ │ │ │ - this.onModification(this.feature); │ │ │ │ - this.layer.events.triggerEvent("featuremodified", { │ │ │ │ - feature: this.feature │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - setFeatureState: function() { │ │ │ │ - if (this.feature.state != OpenLayers.State.INSERT && this.feature.state != OpenLayers.State.DELETE) { │ │ │ │ - this.feature.state = OpenLayers.State.UPDATE; │ │ │ │ - if (this.modified && this._originalGeometry) { │ │ │ │ - var feature = this.feature; │ │ │ │ - feature.modified = OpenLayers.Util.extend(feature.modified, { │ │ │ │ - geometry: this._originalGeometry │ │ │ │ - }); │ │ │ │ - delete this._originalGeometry │ │ │ │ - } │ │ │ │ + for (i = 0, len = targets.length; i < len; ++i) { │ │ │ │ + targets[i].style.display = "" │ │ │ │ } │ │ │ │ - }, │ │ │ │ - resetVertices: function() { │ │ │ │ - if (this.vertices.length > 0) { │ │ │ │ - this.layer.removeFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.vertices = [] │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + layers[i].div.style.display = "block" │ │ │ │ } │ │ │ │ - if (this.virtualVertices.length > 0) { │ │ │ │ - this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.virtualVertices = [] │ │ │ │ + return features │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ + delete this.target.extensions[this.provides[i]] │ │ │ │ } │ │ │ │ - if (this.dragHandle) { │ │ │ │ - this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.dragHandle = null │ │ │ │ + this.map.events.un({ │ │ │ │ + mousemove: this.onMousemove, │ │ │ │ + mousedown: this.start, │ │ │ │ + mouseup: this.onClick, │ │ │ │ + touchstart: this.start, │ │ │ │ + touchmove: this.cancel, │ │ │ │ + touchend: this.onClick, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + delete this.cache; │ │ │ │ + delete this.map; │ │ │ │ + delete this.target │ │ │ │ + } │ │ │ │ +}); │ │ │ │ +OpenLayers.Events.nofeatureclick = OpenLayers.Events.featureclick; │ │ │ │ +OpenLayers.Events.featureover = OpenLayers.Events.featureclick; │ │ │ │ +OpenLayers.Events.featureout = OpenLayers.Events.featureclick; │ │ │ │ +OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ + target: null, │ │ │ │ + events: ["mousedown", "mouseup", "click", "dblclick", "touchstart", "touchmove", "touchend", "keydown"], │ │ │ │ + startRegEx: /^mousedown|touchstart$/, │ │ │ │ + cancelRegEx: /^touchmove$/, │ │ │ │ + completeRegEx: /^mouseup|touchend$/, │ │ │ │ + initialize: function(target) { │ │ │ │ + this.target = target; │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ + extension: true │ │ │ │ + }) │ │ │ │ } │ │ │ │ - if (this.radiusHandle) { │ │ │ │ - this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.radiusHandle = null │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ + this.target.unregister(this.events[i], this, this.buttonClick) │ │ │ │ } │ │ │ │ - if (this.feature && this.feature.geometry.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ - if (this.mode & OpenLayers.Control.ModifyFeature.DRAG) { │ │ │ │ - this.collectDragHandle() │ │ │ │ + delete this.target │ │ │ │ + }, │ │ │ │ + getPressedButton: function(element) { │ │ │ │ + var depth = 3, │ │ │ │ + button; │ │ │ │ + do { │ │ │ │ + if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ + button = element; │ │ │ │ + break │ │ │ │ } │ │ │ │ - if (this.mode & (OpenLayers.Control.ModifyFeature.ROTATE | OpenLayers.Control.ModifyFeature.RESIZE)) { │ │ │ │ - this.collectRadiusHandle() │ │ │ │ + element = element.parentNode │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return button │ │ │ │ + }, │ │ │ │ + ignore: function(element) { │ │ │ │ + var depth = 3, │ │ │ │ + ignore = false; │ │ │ │ + do { │ │ │ │ + if (element.nodeName.toLowerCase() === "a") { │ │ │ │ + ignore = true; │ │ │ │ + break │ │ │ │ } │ │ │ │ - if (this.mode & OpenLayers.Control.ModifyFeature.RESHAPE) { │ │ │ │ - if (!(this.mode & OpenLayers.Control.ModifyFeature.RESIZE)) { │ │ │ │ - this.collectVertices() │ │ │ │ + element = element.parentNode │ │ │ │ + } while (--depth > 0 && element); │ │ │ │ + return ignore │ │ │ │ + }, │ │ │ │ + buttonClick: function(evt) { │ │ │ │ + var propagate = true, │ │ │ │ + element = OpenLayers.Event.element(evt); │ │ │ │ + if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ + var button = this.getPressedButton(element); │ │ │ │ + if (button) { │ │ │ │ + if (evt.type === "keydown") { │ │ │ │ + switch (evt.keyCode) { │ │ │ │ + case OpenLayers.Event.KEY_RETURN: │ │ │ │ + case OpenLayers.Event.KEY_SPACE: │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button │ │ │ │ + }); │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false; │ │ │ │ + break │ │ │ │ + } │ │ │ │ + } else if (this.startEvt) { │ │ │ │ + if (this.completeRegEx.test(evt.type)) { │ │ │ │ + var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ + var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ + var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ + var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ + pos[0] = pos[0] - scrollLeft; │ │ │ │ + pos[1] = pos[1] - scrollTop; │ │ │ │ + this.target.triggerEvent("buttonclick", { │ │ │ │ + buttonElement: button, │ │ │ │ + buttonXY: { │ │ │ │ + x: this.startEvt.clientX - pos[0], │ │ │ │ + y: this.startEvt.clientY - pos[1] │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + if (this.cancelRegEx.test(evt.type)) { │ │ │ │ + delete this.startEvt │ │ │ │ + } │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false │ │ │ │ + } │ │ │ │ + if (this.startRegEx.test(evt.type)) { │ │ │ │ + this.startEvt = evt; │ │ │ │ + OpenLayers.Event.stop(evt); │ │ │ │ + propagate = false │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ + delete this.startEvt │ │ │ │ } │ │ │ │ } │ │ │ │ + return propagate │ │ │ │ + } │ │ │ │ +}); │ │ │ │ +OpenLayers.ElementsIndexer = OpenLayers.Class({ │ │ │ │ + maxZIndex: null, │ │ │ │ + order: null, │ │ │ │ + indices: null, │ │ │ │ + compare: null, │ │ │ │ + initialize: function(yOrdering) { │ │ │ │ + this.compare = yOrdering ? OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER : OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER; │ │ │ │ + this.clear() │ │ │ │ }, │ │ │ │ - handleKeypress: function(evt) { │ │ │ │ - var code = evt.keyCode; │ │ │ │ - if (this.feature && OpenLayers.Util.indexOf(this.deleteCodes, code) != -1) { │ │ │ │ - var vertex = this.layer.getFeatureFromEvent(this.handlers.drag.evt); │ │ │ │ - if (vertex && OpenLayers.Util.indexOf(this.vertices, vertex) != -1 && !this.handlers.drag.dragging && vertex.geometry.parent) { │ │ │ │ - vertex.geometry.parent.removeComponent(vertex.geometry); │ │ │ │ - this.layer.events.triggerEvent("vertexremoved", { │ │ │ │ - vertex: vertex.geometry, │ │ │ │ - feature: this.feature, │ │ │ │ - pixel: evt.xy │ │ │ │ - }); │ │ │ │ - this.layer.drawFeature(this.feature, this.standalone ? undefined : "select"); │ │ │ │ - this.modified = true; │ │ │ │ - this.resetVertices(); │ │ │ │ - this.setFeatureState(); │ │ │ │ - this.onModification(this.feature); │ │ │ │ - this.layer.events.triggerEvent("featuremodified", { │ │ │ │ - feature: this.feature │ │ │ │ - }) │ │ │ │ + insert: function(newNode) { │ │ │ │ + if (this.exists(newNode)) { │ │ │ │ + this.remove(newNode) │ │ │ │ + } │ │ │ │ + var nodeId = newNode.id; │ │ │ │ + this.determineZIndex(newNode); │ │ │ │ + var leftIndex = -1; │ │ │ │ + var rightIndex = this.order.length; │ │ │ │ + var middle; │ │ │ │ + while (rightIndex - leftIndex > 1) { │ │ │ │ + middle = parseInt((leftIndex + rightIndex) / 2); │ │ │ │ + var placement = this.compare(this, newNode, OpenLayers.Util.getElement(this.order[middle])); │ │ │ │ + if (placement > 0) { │ │ │ │ + leftIndex = middle │ │ │ │ + } else { │ │ │ │ + rightIndex = middle │ │ │ │ } │ │ │ │ } │ │ │ │ + this.order.splice(rightIndex, 0, nodeId); │ │ │ │ + this.indices[nodeId] = this.getZIndex(newNode); │ │ │ │ + return this.getNextElement(rightIndex) │ │ │ │ }, │ │ │ │ - collectVertices: function() { │ │ │ │ - this.vertices = []; │ │ │ │ - this.virtualVertices = []; │ │ │ │ - var control = this; │ │ │ │ - │ │ │ │ - function collectComponentVertices(geometry) { │ │ │ │ - var i, vertex, component, len; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - vertex = new OpenLayers.Feature.Vector(geometry); │ │ │ │ - vertex._sketch = true; │ │ │ │ - vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ - control.vertices.push(vertex) │ │ │ │ + remove: function(node) { │ │ │ │ + var nodeId = node.id; │ │ │ │ + var arrayIndex = OpenLayers.Util.indexOf(this.order, nodeId); │ │ │ │ + if (arrayIndex >= 0) { │ │ │ │ + this.order.splice(arrayIndex, 1); │ │ │ │ + delete this.indices[nodeId]; │ │ │ │ + if (this.order.length > 0) { │ │ │ │ + var lastId = this.order[this.order.length - 1]; │ │ │ │ + this.maxZIndex = this.indices[lastId] │ │ │ │ } else { │ │ │ │ - var numVert = geometry.components.length; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ - numVert -= 1 │ │ │ │ - } │ │ │ │ - for (i = 0; i < numVert; ++i) { │ │ │ │ - component = geometry.components[i]; │ │ │ │ - if (component.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - vertex = new OpenLayers.Feature.Vector(component); │ │ │ │ - vertex._sketch = true; │ │ │ │ - vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ - control.vertices.push(vertex) │ │ │ │ - } else { │ │ │ │ - collectComponentVertices(component) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (control.createVertices && geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") { │ │ │ │ - for (i = 0, len = geometry.components.length; i < len - 1; ++i) { │ │ │ │ - var prevVertex = geometry.components[i]; │ │ │ │ - var nextVertex = geometry.components[i + 1]; │ │ │ │ - if (prevVertex.CLASS_NAME == "OpenLayers.Geometry.Point" && nextVertex.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - var x = (prevVertex.x + nextVertex.x) / 2; │ │ │ │ - var y = (prevVertex.y + nextVertex.y) / 2; │ │ │ │ - var point = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(x, y), null, control.virtualStyle); │ │ │ │ - point.geometry.parent = geometry; │ │ │ │ - point._index = i + 1; │ │ │ │ - point._sketch = true; │ │ │ │ - control.virtualVertices.push(point) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.maxZIndex = 0 │ │ │ │ } │ │ │ │ } │ │ │ │ - collectComponentVertices.call(this, this.feature.geometry); │ │ │ │ - this.layer.addFeatures(this.virtualVertices, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.layer.addFeatures(this.vertices, { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ }, │ │ │ │ - collectDragHandle: function() { │ │ │ │ - var geometry = this.feature.geometry; │ │ │ │ - var center = geometry.getBounds().getCenterLonLat(); │ │ │ │ - var originGeometry = new OpenLayers.Geometry.Point(center.lon, center.lat); │ │ │ │ - var origin = new OpenLayers.Feature.Vector(originGeometry); │ │ │ │ - originGeometry.move = function(x, y) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - geometry.move(x, y) │ │ │ │ - }; │ │ │ │ - origin._sketch = true; │ │ │ │ - this.dragHandle = origin; │ │ │ │ - this.dragHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ - this.layer.addFeatures([this.dragHandle], { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ + clear: function() { │ │ │ │ + this.order = []; │ │ │ │ + this.indices = {}; │ │ │ │ + this.maxZIndex = 0 │ │ │ │ }, │ │ │ │ - collectRadiusHandle: function() { │ │ │ │ - var geometry = this.feature.geometry; │ │ │ │ - var bounds = geometry.getBounds(); │ │ │ │ - var center = bounds.getCenterLonLat(); │ │ │ │ - var originGeometry = new OpenLayers.Geometry.Point(center.lon, center.lat); │ │ │ │ - var radiusGeometry = new OpenLayers.Geometry.Point(bounds.right, bounds.bottom); │ │ │ │ - var radius = new OpenLayers.Feature.Vector(radiusGeometry); │ │ │ │ - var resize = this.mode & OpenLayers.Control.ModifyFeature.RESIZE; │ │ │ │ - var reshape = this.mode & OpenLayers.Control.ModifyFeature.RESHAPE; │ │ │ │ - var rotate = this.mode & OpenLayers.Control.ModifyFeature.ROTATE; │ │ │ │ - radiusGeometry.move = function(x, y) { │ │ │ │ - OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ - var dx1 = this.x - originGeometry.x; │ │ │ │ - var dy1 = this.y - originGeometry.y; │ │ │ │ - var dx0 = dx1 - x; │ │ │ │ - var dy0 = dy1 - y; │ │ │ │ - if (rotate) { │ │ │ │ - var a0 = Math.atan2(dy0, dx0); │ │ │ │ - var a1 = Math.atan2(dy1, dx1); │ │ │ │ - var angle = a1 - a0; │ │ │ │ - angle *= 180 / Math.PI; │ │ │ │ - geometry.rotate(angle, originGeometry) │ │ │ │ - } │ │ │ │ - if (resize) { │ │ │ │ - var scale, ratio; │ │ │ │ - if (reshape) { │ │ │ │ - scale = dy1 / dy0; │ │ │ │ - ratio = dx1 / dx0 / scale │ │ │ │ - } else { │ │ │ │ - var l0 = Math.sqrt(dx0 * dx0 + dy0 * dy0); │ │ │ │ - var l1 = Math.sqrt(dx1 * dx1 + dy1 * dy1); │ │ │ │ - scale = l1 / l0 │ │ │ │ - } │ │ │ │ - geometry.resize(scale, originGeometry, ratio) │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - radius._sketch = true; │ │ │ │ - this.radiusHandle = radius; │ │ │ │ - this.radiusHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ - this.layer.addFeatures([this.radiusHandle], { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ + exists: function(node) { │ │ │ │ + return this.indices[node.id] != null │ │ │ │ }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.drag.setMap(map); │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ + getZIndex: function(node) { │ │ │ │ + return node._style.graphicZIndex │ │ │ │ }, │ │ │ │ - handleMapEvents: function(evt) { │ │ │ │ - if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ - this.moveLayerToTop() │ │ │ │ + determineZIndex: function(node) { │ │ │ │ + var zIndex = node._style.graphicZIndex; │ │ │ │ + if (zIndex == null) { │ │ │ │ + zIndex = this.maxZIndex; │ │ │ │ + node._style.graphicZIndex = zIndex │ │ │ │ + } else if (zIndex > this.maxZIndex) { │ │ │ │ + this.maxZIndex = zIndex │ │ │ │ } │ │ │ │ }, │ │ │ │ - moveLayerToTop: function() { │ │ │ │ - var index = Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) + 1; │ │ │ │ - this.layer.setZIndex(index) │ │ │ │ - }, │ │ │ │ - moveLayerBack: function() { │ │ │ │ - var index = this.layer.getZIndex() - 1; │ │ │ │ - if (index >= this.map.Z_INDEX_BASE["Feature"]) { │ │ │ │ - this.layer.setZIndex(index) │ │ │ │ + getNextElement: function(index) { │ │ │ │ + var nextIndex = index + 1; │ │ │ │ + if (nextIndex < this.order.length) { │ │ │ │ + var nextElement = OpenLayers.Util.getElement(this.order[nextIndex]); │ │ │ │ + if (nextElement == undefined) { │ │ │ │ + nextElement = this.getNextElement(nextIndex) │ │ │ │ + } │ │ │ │ + return nextElement │ │ │ │ } else { │ │ │ │ - this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer)) │ │ │ │ + return null │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ModifyFeature" │ │ │ │ + CLASS_NAME: "OpenLayers.ElementsIndexer" │ │ │ │ }); │ │ │ │ -OpenLayers.Control.ModifyFeature.RESHAPE = 1; │ │ │ │ -OpenLayers.Control.ModifyFeature.RESIZE = 2; │ │ │ │ -OpenLayers.Control.ModifyFeature.ROTATE = 4; │ │ │ │ -OpenLayers.Control.ModifyFeature.DRAG = 8; │ │ │ │ -OpenLayers.Control.Pan = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ - slideFactor: 50, │ │ │ │ - slideRatio: null, │ │ │ │ - direction: null, │ │ │ │ - initialize: function(direction, options) { │ │ │ │ - this.direction = direction; │ │ │ │ - this.CLASS_NAME += this.direction; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]) │ │ │ │ - }, │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - var getSlideFactor = OpenLayers.Function.bind(function(dim) { │ │ │ │ - return this.slideRatio ? this.map.getSize()[dim] * this.slideRatio : this.slideFactor │ │ │ │ - }, this); │ │ │ │ - switch (this.direction) { │ │ │ │ - case OpenLayers.Control.Pan.NORTH: │ │ │ │ - this.map.pan(0, -getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Control.Pan.SOUTH: │ │ │ │ - this.map.pan(0, getSlideFactor("h")); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Control.Pan.WEST: │ │ │ │ - this.map.pan(-getSlideFactor("w"), 0); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Control.Pan.EAST: │ │ │ │ - this.map.pan(getSlideFactor("w"), 0); │ │ │ │ - break │ │ │ │ - } │ │ │ │ +OpenLayers.ElementsIndexer.IndexingMethods = { │ │ │ │ + Z_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ + var newZIndex = indexer.getZIndex(newNode); │ │ │ │ + var returnVal = 0; │ │ │ │ + if (nextNode) { │ │ │ │ + var nextZIndex = indexer.getZIndex(nextNode); │ │ │ │ + returnVal = newZIndex - nextZIndex │ │ │ │ } │ │ │ │ + return returnVal │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Pan" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Pan.NORTH = "North"; │ │ │ │ -OpenLayers.Control.Pan.SOUTH = "South"; │ │ │ │ -OpenLayers.Control.Pan.EAST = "East"; │ │ │ │ -OpenLayers.Control.Pan.WEST = "West"; │ │ │ │ -OpenLayers.Control.PanPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ - slideFactor: 50, │ │ │ │ - slideRatio: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - var options = { │ │ │ │ - slideFactor: this.slideFactor, │ │ │ │ - slideRatio: this.slideRatio │ │ │ │ - }; │ │ │ │ - this.addControls([new OpenLayers.Control.Pan(OpenLayers.Control.Pan.NORTH, options), new OpenLayers.Control.Pan(OpenLayers.Control.Pan.SOUTH, options), new OpenLayers.Control.Pan(OpenLayers.Control.Pan.EAST, options), new OpenLayers.Control.Pan(OpenLayers.Control.Pan.WEST, options)]) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.PanPanel" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.GetFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - protocol: null, │ │ │ │ - multipleKey: null, │ │ │ │ - toggleKey: null, │ │ │ │ - modifiers: null, │ │ │ │ - multiple: false, │ │ │ │ - click: true, │ │ │ │ - single: true, │ │ │ │ - clickout: true, │ │ │ │ - toggle: false, │ │ │ │ - clickTolerance: 5, │ │ │ │ - hover: false, │ │ │ │ - box: false, │ │ │ │ - maxFeatures: 10, │ │ │ │ - features: null, │ │ │ │ - hoverFeature: null, │ │ │ │ - handlers: null, │ │ │ │ - hoverResponse: null, │ │ │ │ - filterType: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - initialize: function(options) { │ │ │ │ - options.handlerOptions = options.handlerOptions || {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.features = {}; │ │ │ │ - this.handlers = {}; │ │ │ │ - if (this.click) { │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click(this, { │ │ │ │ - click: this.selectClick │ │ │ │ - }, this.handlerOptions.click || {}) │ │ │ │ - } │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.selectBox │ │ │ │ - }, OpenLayers.Util.extend(this.handlerOptions.box, { │ │ │ │ - boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - if (this.hover) { │ │ │ │ - this.handlers.hover = new OpenLayers.Handler.Hover(this, { │ │ │ │ - move: this.cancelHover, │ │ │ │ - pause: this.selectHover │ │ │ │ - }, OpenLayers.Util.extend(this.handlerOptions.hover, { │ │ │ │ - delay: 250, │ │ │ │ - pixelTolerance: 2 │ │ │ │ - })) │ │ │ │ + Z_ORDER_DRAWING_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ + var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ + if (nextNode && returnVal == 0) { │ │ │ │ + returnVal = 1 │ │ │ │ } │ │ │ │ + return returnVal │ │ │ │ }, │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - for (var i in this.handlers) { │ │ │ │ - this.handlers[i].activate() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - for (var i in this.handlers) { │ │ │ │ - this.handlers[i].deactivate() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - selectClick: function(evt) { │ │ │ │ - var bounds = this.pixelToBounds(evt.xy); │ │ │ │ - this.setModifiers(evt); │ │ │ │ - this.request(bounds, { │ │ │ │ - single: this.single │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - selectBox: function(position) { │ │ │ │ - var bounds; │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat) │ │ │ │ - } else { │ │ │ │ - if (this.click) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - bounds = this.pixelToBounds(position) │ │ │ │ - } │ │ │ │ - this.setModifiers(this.handlers.box.dragHandler.evt); │ │ │ │ - this.request(bounds) │ │ │ │ - }, │ │ │ │ - selectHover: function(evt) { │ │ │ │ - var bounds = this.pixelToBounds(evt.xy); │ │ │ │ - this.request(bounds, { │ │ │ │ - single: true, │ │ │ │ - hover: true │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - cancelHover: function() { │ │ │ │ - if (this.hoverResponse) { │ │ │ │ - this.protocol.abort(this.hoverResponse); │ │ │ │ - this.hoverResponse = null; │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - request: function(bounds, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: this.filterType, │ │ │ │ - value: bounds │ │ │ │ - }); │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - var response = this.protocol.read({ │ │ │ │ - maxFeatures: options.single == true ? this.maxFeatures : undefined, │ │ │ │ - filter: filter, │ │ │ │ - callback: function(result) { │ │ │ │ - if (result.success()) { │ │ │ │ - if (result.features.length) { │ │ │ │ - if (options.single == true) { │ │ │ │ - this.selectBestFeature(result.features, bounds.getCenterLonLat(), options) │ │ │ │ - } else { │ │ │ │ - this.select(result.features) │ │ │ │ - } │ │ │ │ - } else if (options.hover) { │ │ │ │ - this.hoverSelect() │ │ │ │ - } else { │ │ │ │ - this.events.triggerEvent("clickout"); │ │ │ │ - if (this.clickout) { │ │ │ │ - this.unselectAll() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (options.hover == true) { │ │ │ │ - this.hoverResponse = response │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - selectBestFeature: function(features, clickPosition, options) { │ │ │ │ - options = options || {}; │ │ │ │ - if (features.length) { │ │ │ │ - var point = new OpenLayers.Geometry.Point(clickPosition.lon, clickPosition.lat); │ │ │ │ - var feature, resultFeature, dist; │ │ │ │ - var minDist = Number.MAX_VALUE; │ │ │ │ - for (var i = 0; i < features.length; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (feature.geometry) { │ │ │ │ - dist = point.distanceTo(feature.geometry, { │ │ │ │ - edge: false │ │ │ │ - }); │ │ │ │ - if (dist < minDist) { │ │ │ │ - minDist = dist; │ │ │ │ - resultFeature = feature; │ │ │ │ - if (minDist == 0) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (options.hover == true) { │ │ │ │ - this.hoverSelect(resultFeature) │ │ │ │ - } else { │ │ │ │ - this.select(resultFeature || features) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setModifiers: function(evt) { │ │ │ │ - this.modifiers = { │ │ │ │ - multiple: this.multiple || this.multipleKey && evt[this.multipleKey], │ │ │ │ - toggle: this.toggle || this.toggleKey && evt[this.toggleKey] │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - select: function(features) { │ │ │ │ - if (!this.modifiers.multiple && !this.modifiers.toggle) { │ │ │ │ - this.unselectAll() │ │ │ │ - } │ │ │ │ - if (!OpenLayers.Util.isArray(features)) { │ │ │ │ - features = [features] │ │ │ │ - } │ │ │ │ - var cont = this.events.triggerEvent("beforefeaturesselected", { │ │ │ │ - features: features │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - var selectedFeatures = []; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (this.features[feature.fid || feature.id]) { │ │ │ │ - if (this.modifiers.toggle) { │ │ │ │ - this.unselect(this.features[feature.fid || feature.id]) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - cont = this.events.triggerEvent("beforefeatureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - this.features[feature.fid || feature.id] = feature; │ │ │ │ - selectedFeatures.push(feature); │ │ │ │ - this.events.triggerEvent("featureselected", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("featuresselected", { │ │ │ │ - features: selectedFeatures │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - hoverSelect: function(feature) { │ │ │ │ - var fid = feature ? feature.fid || feature.id : null; │ │ │ │ - var hfid = this.hoverFeature ? this.hoverFeature.fid || this.hoverFeature.id : null; │ │ │ │ - if (hfid && hfid != fid) { │ │ │ │ - this.events.triggerEvent("outfeature", { │ │ │ │ - feature: this.hoverFeature │ │ │ │ - }); │ │ │ │ - this.hoverFeature = null │ │ │ │ - } │ │ │ │ - if (fid && fid != hfid) { │ │ │ │ - this.events.triggerEvent("hoverfeature", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.hoverFeature = feature │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - unselect: function(feature) { │ │ │ │ - delete this.features[feature.fid || feature.id]; │ │ │ │ - this.events.triggerEvent("featureunselected", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - unselectAll: function() { │ │ │ │ - for (var fid in this.features) { │ │ │ │ - this.unselect(this.features[fid]) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - for (var i in this.handlers) { │ │ │ │ - this.handlers[i].setMap(map) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - pixelToBounds: function(pixel) { │ │ │ │ - var llPx = pixel.add(-this.clickTolerance / 2, this.clickTolerance / 2); │ │ │ │ - var urPx = pixel.add(this.clickTolerance / 2, -this.clickTolerance / 2); │ │ │ │ - var ll = this.map.getLonLatFromPixel(llPx); │ │ │ │ - var ur = this.map.getLonLatFromPixel(urPx); │ │ │ │ - return new OpenLayers.Bounds(ll.lon, ll.lat, ur.lon, ur.lat) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.GetFeature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ZoomToMaxExtent = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ - trigger: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.zoomToMaxExtent() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomToMaxExtent" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.CacheRead = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - fetchEvent: "tileloadstart", │ │ │ │ - layers: null, │ │ │ │ - autoActivate: true, │ │ │ │ - setMap: function(map) { │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ - var i, layers = this.layers || map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.addLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (!this.layers) { │ │ │ │ - map.events.on({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - addLayer: function(evt) { │ │ │ │ - evt.layer.events.register(this.fetchEvent, this, this.fetch) │ │ │ │ - }, │ │ │ │ - removeLayer: function(evt) { │ │ │ │ - evt.layer.events.unregister(this.fetchEvent, this, this.fetch) │ │ │ │ - }, │ │ │ │ - fetch: function(evt) { │ │ │ │ - if (this.active && window.localStorage && evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ - var tile = evt.tile, │ │ │ │ - url = tile.url; │ │ │ │ - if (!tile.layer.crossOriginKeyword && OpenLayers.ProxyHost && url.indexOf(OpenLayers.ProxyHost) === 0) { │ │ │ │ - url = OpenLayers.Control.CacheWrite.urlMap[url] │ │ │ │ - } │ │ │ │ - var dataURI = window.localStorage.getItem("olCache_" + url); │ │ │ │ - if (dataURI) { │ │ │ │ - tile.url = dataURI; │ │ │ │ - if (evt.type === "tileerror") { │ │ │ │ - tile.setImgSrc(dataURI) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.layers || this.map) { │ │ │ │ - var i, layers = this.layers || this.map.layers; │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - this.removeLayer({ │ │ │ │ - layer: layers[i] │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.un({ │ │ │ │ - addlayer: this.addLayer, │ │ │ │ - removeLayer: this.removeLayer, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.CacheRead" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - layerStates: null, │ │ │ │ - layersDiv: null, │ │ │ │ - baseLayersDiv: null, │ │ │ │ - baseLayers: null, │ │ │ │ - dataLbl: null, │ │ │ │ - dataLayersDiv: null, │ │ │ │ - dataLayers: null, │ │ │ │ - minimizeDiv: null, │ │ │ │ - maximizeDiv: null, │ │ │ │ - ascending: true, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ - this.layerStates = [] │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ - this.map.events.un({ │ │ │ │ - buttonclick: this.onButtonClick, │ │ │ │ - addlayer: this.redraw, │ │ │ │ - changelayer: this.redraw, │ │ │ │ - removelayer: this.redraw, │ │ │ │ - changebaselayer: this.redraw, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - 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 │ │ │ │ - }); │ │ │ │ - if (this.outsideViewport) { │ │ │ │ - this.events.attachToElement(this.div); │ │ │ │ - this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ - } else { │ │ │ │ - this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ - this.loadContents(); │ │ │ │ - if (!this.outsideViewport) { │ │ │ │ - this.minimizeControl() │ │ │ │ - } │ │ │ │ - this.redraw(); │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - onButtonClick: function(evt) { │ │ │ │ - var button = evt.buttonElement; │ │ │ │ - if (button === this.minimizeDiv) { │ │ │ │ - this.minimizeControl() │ │ │ │ - } else if (button === this.maximizeDiv) { │ │ │ │ - this.maximizeControl() │ │ │ │ - } else if (button._layerSwitcher === this.id) { │ │ │ │ - if (button["for"]) { │ │ │ │ - button = document.getElementById(button["for"]) │ │ │ │ - } │ │ │ │ - if (!button.disabled) { │ │ │ │ - if (button.type == "radio") { │ │ │ │ - button.checked = true; │ │ │ │ - this.map.setBaseLayer(this.map.getLayer(button._layer)) │ │ │ │ - } else { │ │ │ │ - button.checked = !button.checked; │ │ │ │ - this.updateMap() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clearLayersArray: function(layersType) { │ │ │ │ - this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ - this[layersType + "Layers"] = [] │ │ │ │ - }, │ │ │ │ - checkRedraw: function() { │ │ │ │ - if (!this.layerStates.length || this.map.layers.length != this.layerStates.length) { │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - for (var i = 0, len = this.layerStates.length; i < len; 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) { │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - redraw: function() { │ │ │ │ - if (!this.checkRedraw()) { │ │ │ │ - return this.div │ │ │ │ - } │ │ │ │ - this.clearLayersArray("base"); │ │ │ │ - this.clearLayersArray("data"); │ │ │ │ - var containsOverlays = false; │ │ │ │ - var containsBaseLayers = false; │ │ │ │ - var len = this.map.layers.length; │ │ │ │ - this.layerStates = new Array(len); │ │ │ │ - for (var i = 0; i < len; 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, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - var baseLayer = layer.isBaseLayer; │ │ │ │ - if (layer.displayInLayerSwitcher) { │ │ │ │ - if (baseLayer) { │ │ │ │ - containsBaseLayers = true │ │ │ │ - } else { │ │ │ │ - containsOverlays = true │ │ │ │ - } │ │ │ │ - var checked = baseLayer ? layer == this.map.baseLayer : layer.getVisibility(); │ │ │ │ - var inputElem = document.createElement("input"), │ │ │ │ - inputId = OpenLayers.Util.createUniqueID(this.id + "_input_"); │ │ │ │ - inputElem.id = inputId; │ │ │ │ - inputElem.name = baseLayer ? this.id + "_baseLayers" : layer.name; │ │ │ │ - inputElem.type = baseLayer ? "radio" : "checkbox"; │ │ │ │ - inputElem.value = layer.name; │ │ │ │ - inputElem.checked = checked; │ │ │ │ - inputElem.defaultChecked = checked; │ │ │ │ - inputElem.className = "olButton"; │ │ │ │ - inputElem._layer = layer.id; │ │ │ │ - inputElem._layerSwitcher = this.id; │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - inputElem.disabled = true │ │ │ │ - } │ │ │ │ - var labelSpan = document.createElement("label"); │ │ │ │ - labelSpan["for"] = inputElem.id; │ │ │ │ - OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ - labelSpan._layer = layer.id; │ │ │ │ - labelSpan._layerSwitcher = this.id; │ │ │ │ - if (!baseLayer && !layer.inRange) { │ │ │ │ - labelSpan.style.color = "gray" │ │ │ │ - } │ │ │ │ - labelSpan.innerHTML = layer.name; │ │ │ │ - labelSpan.style.verticalAlign = baseLayer ? "bottom" : "baseline"; │ │ │ │ - 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) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.dataLbl.style.display = containsOverlays ? "" : "none"; │ │ │ │ - this.baseLbl.style.display = containsBaseLayers ? "" : "none"; │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - updateMap: function() { │ │ │ │ - for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.baseLayers[i]; │ │ │ │ - if (layerEntry.inputElem.checked) { │ │ │ │ - this.map.setBaseLayer(layerEntry.layer, false) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ - var layerEntry = this.dataLayers[i]; │ │ │ │ - layerEntry.layer.setVisibility(layerEntry.inputElem.checked) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - maximizeControl: function(e) { │ │ │ │ - this.div.style.width = ""; │ │ │ │ - this.div.style.height = ""; │ │ │ │ - this.showControls(false); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - minimizeControl: function(e) { │ │ │ │ - this.div.style.width = "0px"; │ │ │ │ - this.div.style.height = "0px"; │ │ │ │ - this.showControls(true); │ │ │ │ - if (e != null) { │ │ │ │ - OpenLayers.Event.stop(e) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - showControls: function(minimize) { │ │ │ │ - this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ - this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ - this.layersDiv.style.display = minimize ? "none" : "" │ │ │ │ - }, │ │ │ │ - loadContents: function() { │ │ │ │ - this.layersDiv = document.createElement("div"); │ │ │ │ - this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ - OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ - this.baseLbl = document.createElement("div"); │ │ │ │ - this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ - this.baseLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ - this.dataLbl = document.createElement("div"); │ │ │ │ - this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ - this.dataLayersDiv = document.createElement("div"); │ │ │ │ - OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ - 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); │ │ │ │ - var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png"); │ │ │ │ - this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MaximizeDiv", null, null, img, "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ - this.maximizeDiv.style.display = "none"; │ │ │ │ - this.div.appendChild(this.maximizeDiv); │ │ │ │ - var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png"); │ │ │ │ - this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MinimizeDiv", null, null, img, "absolute"); │ │ │ │ - OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ - this.minimizeDiv.style.display = "none"; │ │ │ │ - this.div.appendChild(this.minimizeDiv) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.ZoomPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ - this.addControls([new OpenLayers.Control.ZoomIn, new OpenLayers.Control.ZoomToMaxExtent, new OpenLayers.Control.ZoomOut]) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.ZoomPanel" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.WMTSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - hover: false, │ │ │ │ - requestEncoding: "KVP", │ │ │ │ - drillDown: false, │ │ │ │ - maxFeatures: 10, │ │ │ │ - clickCallback: "click", │ │ │ │ - layers: null, │ │ │ │ - queryVisible: true, │ │ │ │ - infoFormat: "text/html", │ │ │ │ - vendorParams: {}, │ │ │ │ - format: null, │ │ │ │ - formatOptions: null, │ │ │ │ - handler: null, │ │ │ │ - hoverRequest: null, │ │ │ │ - pending: 0, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - options.handlerOptions = options.handlerOptions || {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.WMSGetFeatureInfo(options.formatOptions) │ │ │ │ - } │ │ │ │ - if (this.drillDown === true) { │ │ │ │ - this.hover = false │ │ │ │ - } │ │ │ │ - if (this.hover) { │ │ │ │ - this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ - move: this.cancelHover, │ │ │ │ - pause: this.getInfoForHover │ │ │ │ - }, OpenLayers.Util.extend(this.handlerOptions.hover || {}, { │ │ │ │ - delay: 250 │ │ │ │ - })) │ │ │ │ - } else { │ │ │ │ - var callbacks = {}; │ │ │ │ - callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ - this.handler = new OpenLayers.Handler.Click(this, callbacks, this.handlerOptions.click || {}) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getInfoForClick: function(evt) { │ │ │ │ - this.request(evt.xy, {}) │ │ │ │ - }, │ │ │ │ - getInfoForHover: function(evt) { │ │ │ │ - this.request(evt.xy, { │ │ │ │ - hover: true │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - cancelHover: function() { │ │ │ │ - if (this.hoverRequest) { │ │ │ │ - --this.pending; │ │ │ │ - if (this.pending <= 0) { │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - this.pending = 0 │ │ │ │ - } │ │ │ │ - this.hoverRequest.abort(); │ │ │ │ - this.hoverRequest = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - findLayers: function() { │ │ │ │ - var candidates = this.layers || this.map.layers; │ │ │ │ - var layers = []; │ │ │ │ - var layer; │ │ │ │ - for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ - layer = candidates[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMTS && layer.requestEncoding === this.requestEncoding && (!this.queryVisible || layer.getVisibility())) { │ │ │ │ - layers.push(layer); │ │ │ │ - if (!this.drillDown || this.hover) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return layers │ │ │ │ - }, │ │ │ │ - buildRequestOptions: function(layer, xy) { │ │ │ │ - var loc = this.map.getLonLatFromPixel(xy); │ │ │ │ - var getTileUrl = layer.getURL(new OpenLayers.Bounds(loc.lon, loc.lat, loc.lon, loc.lat)); │ │ │ │ - var params = OpenLayers.Util.getParameters(getTileUrl); │ │ │ │ - var tileInfo = layer.getTileInfo(loc); │ │ │ │ - OpenLayers.Util.extend(params, { │ │ │ │ - service: "WMTS", │ │ │ │ - version: layer.version, │ │ │ │ - request: "GetFeatureInfo", │ │ │ │ - infoFormat: this.infoFormat, │ │ │ │ - i: tileInfo.i, │ │ │ │ - j: tileInfo.j │ │ │ │ - }); │ │ │ │ - OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ - return { │ │ │ │ - url: OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url, │ │ │ │ - params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ - callback: function(request) { │ │ │ │ - this.handleResponse(xy, request, layer) │ │ │ │ - }, │ │ │ │ - scope: this │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - request: function(xy, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var layers = this.findLayers(); │ │ │ │ - if (layers.length > 0) { │ │ │ │ - var issue, layer; │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - layer = layers[i]; │ │ │ │ - issue = this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ - xy: xy, │ │ │ │ - layer: layer │ │ │ │ - }); │ │ │ │ - if (issue !== false) { │ │ │ │ - ++this.pending; │ │ │ │ - var requestOptions = this.buildRequestOptions(layer, xy); │ │ │ │ - var request = OpenLayers.Request.GET(requestOptions); │ │ │ │ - if (options.hover === true) { │ │ │ │ - this.hoverRequest = request │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.pending > 0) { │ │ │ │ - OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - handleResponse: function(xy, request, layer) { │ │ │ │ - --this.pending; │ │ │ │ - if (this.pending <= 0) { │ │ │ │ - OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ - this.pending = 0 │ │ │ │ - } │ │ │ │ - if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ - this.events.triggerEvent("exception", { │ │ │ │ - xy: xy, │ │ │ │ - request: request, │ │ │ │ - layer: layer │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ - } │ │ │ │ - var features, except; │ │ │ │ - try { │ │ │ │ - features = this.format.read(doc) │ │ │ │ - } catch (error) { │ │ │ │ - except = true; │ │ │ │ - this.events.triggerEvent("exception", { │ │ │ │ - xy: xy, │ │ │ │ - request: request, │ │ │ │ - error: error, │ │ │ │ - layer: layer │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (!except) { │ │ │ │ - this.events.triggerEvent("getfeatureinfo", { │ │ │ │ - text: request.responseText, │ │ │ │ - features: features, │ │ │ │ - request: request, │ │ │ │ - xy: xy, │ │ │ │ - layer: layer │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.WMTSGetFeatureInfo" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Attribution = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - separator: ", ", │ │ │ │ - template: "${layers}", │ │ │ │ - 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) │ │ │ │ - }, │ │ │ │ - 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 │ │ │ │ - }, │ │ │ │ - updateAttribution: function() { │ │ │ │ - var attributions = []; │ │ │ │ - if (this.map && this.map.layers) { │ │ │ │ - for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ - var layer = this.map.layers[i]; │ │ │ │ - if (layer.attribution && layer.getVisibility()) { │ │ │ │ - if (OpenLayers.Util.indexOf(attributions, layer.attribution) === -1) { │ │ │ │ - attributions.push(layer.attribution) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ - layers: attributions.join(this.separator) │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.Split = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - layer: null, │ │ │ │ - source: null, │ │ │ │ - sourceOptions: null, │ │ │ │ - tolerance: null, │ │ │ │ - edge: true, │ │ │ │ - deferDelete: false, │ │ │ │ - mutual: true, │ │ │ │ - targetFilter: null, │ │ │ │ - sourceFilter: null, │ │ │ │ - handler: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options || {}; │ │ │ │ - if (this.options.source) { │ │ │ │ - this.setSource(this.options.source) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setSource: function(layer) { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.destroy(); │ │ │ │ - delete this.handler │ │ │ │ - } │ │ │ │ - this.source = layer; │ │ │ │ - this.activate() │ │ │ │ - } else { │ │ │ │ - this.source = layer │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (!this.source) { │ │ │ │ - if (!this.handler) { │ │ │ │ - this.handler = new OpenLayers.Handler.Path(this, { │ │ │ │ - done: function(geometry) { │ │ │ │ - this.onSketchComplete({ │ │ │ │ - feature: new OpenLayers.Feature.Vector(geometry) │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, { │ │ │ │ - layerOptions: this.sourceOptions │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.handler.activate() │ │ │ │ - } else if (this.source.events) { │ │ │ │ - this.source.events.on({ │ │ │ │ - sketchcomplete: this.onSketchComplete, │ │ │ │ - afterfeaturemodified: this.afterFeatureModified, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - if (this.source && this.source.events) { │ │ │ │ - this.source.events.un({ │ │ │ │ - sketchcomplete: this.onSketchComplete, │ │ │ │ - afterfeaturemodified: this.afterFeatureModified, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - onSketchComplete: function(event) { │ │ │ │ - this.feature = null; │ │ │ │ - return !this.considerSplit(event.feature) │ │ │ │ - }, │ │ │ │ - afterFeatureModified: function(event) { │ │ │ │ - if (event.modified) { │ │ │ │ - var feature = event.feature; │ │ │ │ - if (typeof feature.geometry.split === "function") { │ │ │ │ - this.feature = event.feature; │ │ │ │ - this.considerSplit(event.feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - removeByGeometry: function(features, geometry) { │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - if (features[i].geometry === geometry) { │ │ │ │ - features.splice(i, 1); │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - isEligible: function(target) { │ │ │ │ - if (!target.geometry) { │ │ │ │ - return false │ │ │ │ - } else { │ │ │ │ - return target.state !== OpenLayers.State.DELETE && typeof target.geometry.split === "function" && this.feature !== target && (!this.targetFilter || this.targetFilter.evaluate(target.attributes)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - considerSplit: function(feature) { │ │ │ │ - var sourceSplit = false; │ │ │ │ - var targetSplit = false; │ │ │ │ - if (!this.sourceFilter || this.sourceFilter.evaluate(feature.attributes)) { │ │ │ │ - var features = this.layer && this.layer.features || []; │ │ │ │ - var target, results, proceed; │ │ │ │ - var additions = [], │ │ │ │ - removals = []; │ │ │ │ - var mutual = this.layer === this.source && this.mutual; │ │ │ │ - var options = { │ │ │ │ - edge: this.edge, │ │ │ │ - tolerance: this.tolerance, │ │ │ │ - mutual: mutual │ │ │ │ - }; │ │ │ │ - var sourceParts = [feature.geometry]; │ │ │ │ - var targetFeature, targetParts; │ │ │ │ - var source, parts; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - targetFeature = features[i]; │ │ │ │ - if (this.isEligible(targetFeature)) { │ │ │ │ - targetParts = [targetFeature.geometry]; │ │ │ │ - for (var j = 0; j < sourceParts.length; ++j) { │ │ │ │ - source = sourceParts[j]; │ │ │ │ - for (var k = 0; k < targetParts.length; ++k) { │ │ │ │ - target = targetParts[k]; │ │ │ │ - if (source.getBounds().intersectsBounds(target.getBounds())) { │ │ │ │ - results = source.split(target, options); │ │ │ │ - if (results) { │ │ │ │ - proceed = this.events.triggerEvent("beforesplit", { │ │ │ │ - source: feature, │ │ │ │ - target: targetFeature │ │ │ │ - }); │ │ │ │ - if (proceed !== false) { │ │ │ │ - if (mutual) { │ │ │ │ - parts = results[0]; │ │ │ │ - if (parts.length > 1) { │ │ │ │ - parts.unshift(j, 1); │ │ │ │ - Array.prototype.splice.apply(sourceParts, parts); │ │ │ │ - j += parts.length - 3 │ │ │ │ - } │ │ │ │ - results = results[1] │ │ │ │ - } │ │ │ │ - if (results.length > 1) { │ │ │ │ - results.unshift(k, 1); │ │ │ │ - Array.prototype.splice.apply(targetParts, results); │ │ │ │ - k += results.length - 3 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (targetParts && targetParts.length > 1) { │ │ │ │ - this.geomsToFeatures(targetFeature, targetParts); │ │ │ │ - this.events.triggerEvent("split", { │ │ │ │ - original: targetFeature, │ │ │ │ - features: targetParts │ │ │ │ - }); │ │ │ │ - Array.prototype.push.apply(additions, targetParts); │ │ │ │ - removals.push(targetFeature); │ │ │ │ - targetSplit = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (sourceParts && sourceParts.length > 1) { │ │ │ │ - this.geomsToFeatures(feature, sourceParts); │ │ │ │ - this.events.triggerEvent("split", { │ │ │ │ - original: feature, │ │ │ │ - features: sourceParts │ │ │ │ - }); │ │ │ │ - Array.prototype.push.apply(additions, sourceParts); │ │ │ │ - removals.push(feature); │ │ │ │ - sourceSplit = true │ │ │ │ - } │ │ │ │ - if (sourceSplit || targetSplit) { │ │ │ │ - if (this.deferDelete) { │ │ │ │ - var feat, destroys = []; │ │ │ │ - for (var i = 0, len = removals.length; i < len; ++i) { │ │ │ │ - feat = removals[i]; │ │ │ │ - if (feat.state === OpenLayers.State.INSERT) { │ │ │ │ - destroys.push(feat) │ │ │ │ - } else { │ │ │ │ - feat.state = OpenLayers.State.DELETE; │ │ │ │ - this.layer.drawFeature(feat) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.layer.destroyFeatures(destroys, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - for (var i = 0, len = additions.length; i < len; ++i) { │ │ │ │ - additions[i].state = OpenLayers.State.INSERT │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.layer.destroyFeatures(removals, { │ │ │ │ - silent: true │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.layer.addFeatures(additions, { │ │ │ │ - silent: true │ │ │ │ - }); │ │ │ │ - this.events.triggerEvent("aftersplit", { │ │ │ │ - source: feature, │ │ │ │ - features: additions │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return sourceSplit │ │ │ │ - }, │ │ │ │ - geomsToFeatures: function(feature, geoms) { │ │ │ │ - var clone = feature.clone(); │ │ │ │ - delete clone.geometry; │ │ │ │ - var newFeature; │ │ │ │ - for (var i = 0, len = geoms.length; i < len; ++i) { │ │ │ │ - newFeature = clone.clone(); │ │ │ │ - newFeature.geometry = geoms[i]; │ │ │ │ - newFeature.state = OpenLayers.State.INSERT; │ │ │ │ - geoms[i] = newFeature │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.deactivate() │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.call(this) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.Split" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.KeyboardDefaults = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - autoActivate: true, │ │ │ │ - slideFactor: 75, │ │ │ │ - observeElement: null, │ │ │ │ - draw: function() { │ │ │ │ - var observeElement = this.observeElement || document; │ │ │ │ - this.handler = new OpenLayers.Handler.Keyboard(this, { │ │ │ │ - keydown: this.defaultKeyPress │ │ │ │ - }, { │ │ │ │ - observeElement: observeElement │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - defaultKeyPress: function(evt) { │ │ │ │ - var size, handled = true; │ │ │ │ - var target = OpenLayers.Event.element(evt); │ │ │ │ - if (target && (target.tagName == "INPUT" || target.tagName == "TEXTAREA" || target.tagName == "SELECT")) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_LEFT: │ │ │ │ - this.map.pan(-this.slideFactor, 0); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Event.KEY_RIGHT: │ │ │ │ - this.map.pan(this.slideFactor, 0); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Event.KEY_UP: │ │ │ │ - this.map.pan(0, -this.slideFactor); │ │ │ │ - break; │ │ │ │ - case OpenLayers.Event.KEY_DOWN: │ │ │ │ - this.map.pan(0, this.slideFactor); │ │ │ │ - break; │ │ │ │ - case 33: │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(0, -.75 * size.h); │ │ │ │ - break; │ │ │ │ - case 34: │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(0, .75 * size.h); │ │ │ │ - break; │ │ │ │ - case 35: │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(.75 * size.w, 0); │ │ │ │ - break; │ │ │ │ - case 36: │ │ │ │ - size = this.map.getSize(); │ │ │ │ - this.map.pan(-.75 * size.w, 0); │ │ │ │ - break; │ │ │ │ - case 43: │ │ │ │ - case 61: │ │ │ │ - case 187: │ │ │ │ - case 107: │ │ │ │ - this.map.zoomIn(); │ │ │ │ - break; │ │ │ │ - case 45: │ │ │ │ - case 109: │ │ │ │ - case 189: │ │ │ │ - case 95: │ │ │ │ - this.map.zoomOut(); │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - handled = false │ │ │ │ - } │ │ │ │ - if (handled) { │ │ │ │ - OpenLayers.Event.stop(evt) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.KeyboardDefaults" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - multipleKey: null, │ │ │ │ - toggleKey: null, │ │ │ │ - multiple: false, │ │ │ │ - clickout: true, │ │ │ │ - toggle: false, │ │ │ │ - hover: false, │ │ │ │ - highlightOnly: false, │ │ │ │ - box: false, │ │ │ │ - onBeforeSelect: function() {}, │ │ │ │ - onSelect: function() {}, │ │ │ │ - onUnselect: function() {}, │ │ │ │ - scope: null, │ │ │ │ - geometryTypes: null, │ │ │ │ - layer: null, │ │ │ │ - layers: null, │ │ │ │ - callbacks: null, │ │ │ │ - selectStyle: null, │ │ │ │ - renderIntent: "select", │ │ │ │ - handlers: null, │ │ │ │ - initialize: function(layers, options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - if (this.scope === null) { │ │ │ │ - this.scope = this │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - var callbacks = { │ │ │ │ - click: this.clickFeature, │ │ │ │ - clickout: this.clickoutFeature │ │ │ │ - }; │ │ │ │ - if (this.hover) { │ │ │ │ - callbacks.over = this.overFeature; │ │ │ │ - callbacks.out = this.outFeature │ │ │ │ - } │ │ │ │ - this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ - this.handlers = { │ │ │ │ - feature: new OpenLayers.Handler.Feature(this, this.layer, this.callbacks, { │ │ │ │ - geometryTypes: this.geometryTypes │ │ │ │ - }) │ │ │ │ - }; │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box = new OpenLayers.Handler.Box(this, { │ │ │ │ - done: this.selectBox │ │ │ │ - }, { │ │ │ │ - boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - initLayer: function(layers) { │ │ │ │ - if (OpenLayers.Util.isArray(layers)) { │ │ │ │ - this.layers = layers; │ │ │ │ - this.layer = new OpenLayers.Layer.Vector.RootContainer(this.id + "_container", { │ │ │ │ - layers: layers │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - this.layer = layers │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.active && this.layers) { │ │ │ │ - this.map.removeLayer(this.layer) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (!this.active) { │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.addLayer(this.layer) │ │ │ │ - } │ │ │ │ - this.handlers.feature.activate(); │ │ │ │ - if (this.box && this.handlers.box) { │ │ │ │ - this.handlers.box.activate() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - this.handlers.feature.deactivate(); │ │ │ │ - if (this.handlers.box) { │ │ │ │ - this.handlers.box.deactivate() │ │ │ │ - } │ │ │ │ - if (this.layers) { │ │ │ │ - this.map.removeLayer(this.layer) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - unselectAll: function(options) { │ │ │ │ - var layers = this.layers || [this.layer], │ │ │ │ - layer, feature, l, numExcept; │ │ │ │ - for (l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - numExcept = 0; │ │ │ │ - if (layer.selectedFeatures != null) { │ │ │ │ - while (layer.selectedFeatures.length > numExcept) { │ │ │ │ - feature = layer.selectedFeatures[numExcept]; │ │ │ │ - if (!options || options.except != feature) { │ │ │ │ - this.unselect(feature) │ │ │ │ - } else { │ │ │ │ - ++numExcept │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clickFeature: function(feature) { │ │ │ │ - if (!this.hover) { │ │ │ │ - var selected = OpenLayers.Util.indexOf(feature.layer.selectedFeatures, feature) > -1; │ │ │ │ - if (selected) { │ │ │ │ - if (this.toggleSelect()) { │ │ │ │ - this.unselect(feature) │ │ │ │ - } else if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll({ │ │ │ │ - except: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - this.select(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - multipleSelect: function() { │ │ │ │ - return this.multiple || this.handlers.feature.evt && this.handlers.feature.evt[this.multipleKey] │ │ │ │ - }, │ │ │ │ - toggleSelect: function() { │ │ │ │ - return this.toggle || this.handlers.feature.evt && this.handlers.feature.evt[this.toggleKey] │ │ │ │ - }, │ │ │ │ - clickoutFeature: function(feature) { │ │ │ │ - if (!this.hover && this.clickout) { │ │ │ │ - this.unselectAll() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - overFeature: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - this.highlight(feature) │ │ │ │ - } else if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - outFeature: function(feature) { │ │ │ │ - if (this.hover) { │ │ │ │ - if (this.highlightOnly) { │ │ │ │ - if (feature._lastHighlighter == this.id) { │ │ │ │ - if (feature._prevHighlighter && feature._prevHighlighter != this.id) { │ │ │ │ - delete feature._lastHighlighter; │ │ │ │ - var control = this.map.getControl(feature._prevHighlighter); │ │ │ │ - if (control) { │ │ │ │ - control.highlight(feature) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unhighlight(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.unselect(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - highlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ - feature._lastHighlighter = this.id; │ │ │ │ - var style = this.selectStyle || this.renderIntent; │ │ │ │ - layer.drawFeature(feature, style); │ │ │ │ - this.events.triggerEvent("featurehighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - unhighlight: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (feature._prevHighlighter == undefined) { │ │ │ │ - delete feature._lastHighlighter │ │ │ │ - } else if (feature._prevHighlighter == this.id) { │ │ │ │ - delete feature._prevHighlighter │ │ │ │ - } else { │ │ │ │ - feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ - delete feature._prevHighlighter │ │ │ │ - } │ │ │ │ - layer.drawFeature(feature, feature.style || feature.layer.style || "default"); │ │ │ │ - this.events.triggerEvent("featureunhighlighted", { │ │ │ │ - feature: feature │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - select: function(feature) { │ │ │ │ - var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ - var layer = feature.layer; │ │ │ │ - if (cont !== false) { │ │ │ │ - cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (cont !== false) { │ │ │ │ - layer.selectedFeatures.push(feature); │ │ │ │ - this.highlight(feature); │ │ │ │ - if (!this.handlers.feature.lastFeature) { │ │ │ │ - this.handlers.feature.lastFeature = layer.selectedFeatures[0] │ │ │ │ - } │ │ │ │ - layer.events.triggerEvent("featureselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onSelect.call(this.scope, feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - unselect: function(feature) { │ │ │ │ - var layer = feature.layer; │ │ │ │ - this.unhighlight(feature); │ │ │ │ - OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ - layer.events.triggerEvent("featureunselected", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - this.onUnselect.call(this.scope, feature) │ │ │ │ - }, │ │ │ │ - selectBox: function(position) { │ │ │ │ - if (position instanceof OpenLayers.Bounds) { │ │ │ │ - var minXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.left, │ │ │ │ - y: position.bottom │ │ │ │ - }); │ │ │ │ - var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ - x: position.right, │ │ │ │ - y: position.top │ │ │ │ - }); │ │ │ │ - var bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat); │ │ │ │ - if (!this.multipleSelect()) { │ │ │ │ - this.unselectAll() │ │ │ │ - } │ │ │ │ - var prevMultiple = this.multiple; │ │ │ │ - this.multiple = true; │ │ │ │ - var layers = this.layers || [this.layer]; │ │ │ │ - this.events.triggerEvent("boxselectionstart", { │ │ │ │ - layers: layers │ │ │ │ - }); │ │ │ │ - var layer; │ │ │ │ - for (var l = 0; l < layers.length; ++l) { │ │ │ │ - layer = layers[l]; │ │ │ │ - for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ - var feature = layer.features[i]; │ │ │ │ - if (!feature.getVisibility()) { │ │ │ │ - continue │ │ │ │ - } │ │ │ │ - if (this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ - if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ - if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ - this.select(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.multiple = prevMultiple; │ │ │ │ - this.events.triggerEvent("boxselectionend", { │ │ │ │ - layers: layers │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.handlers.feature.setMap(map); │ │ │ │ - if (this.box) { │ │ │ │ - this.handlers.box.setMap(map) │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - setLayer: function(layers) { │ │ │ │ - var isActive = this.active; │ │ │ │ - this.unselectAll(); │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.layers) { │ │ │ │ - this.layer.destroy(); │ │ │ │ - this.layers = null │ │ │ │ - } │ │ │ │ - this.initLayer(layers); │ │ │ │ - this.handlers.feature.layer = this.layer; │ │ │ │ - if (isActive) { │ │ │ │ - this.activate() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.MousePosition = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - autoActivate: true, │ │ │ │ - element: null, │ │ │ │ - prefix: "", │ │ │ │ - separator: ", ", │ │ │ │ - suffix: "", │ │ │ │ - numDigits: 5, │ │ │ │ - granularity: 10, │ │ │ │ - emptyString: null, │ │ │ │ - lastXy: null, │ │ │ │ - displayProjection: null, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.map.events.register("mousemove", this, this.redraw); │ │ │ │ - this.map.events.register("mouseout", this, this.reset); │ │ │ │ - this.redraw(); │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.map.events.unregister("mousemove", this, this.redraw); │ │ │ │ - this.map.events.unregister("mouseout", this, this.reset); │ │ │ │ - this.element.innerHTML = ""; │ │ │ │ - return true │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ - if (!this.element) { │ │ │ │ - this.div.left = ""; │ │ │ │ - this.div.top = ""; │ │ │ │ - this.element = this.div │ │ │ │ - } │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - redraw: function(evt) { │ │ │ │ - var lonLat; │ │ │ │ - if (evt == null) { │ │ │ │ - this.reset(); │ │ │ │ - return │ │ │ │ - } 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) { │ │ │ │ - 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 │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - reset: function(evt) { │ │ │ │ - if (this.emptyString != null) { │ │ │ │ - this.element.innerHTML = this.emptyString │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - 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 │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.MousePosition" │ │ │ │ -}); │ │ │ │ -OpenLayers.Control.TouchNavigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - dragPan: null, │ │ │ │ - dragPanOptions: null, │ │ │ │ - pinchZoom: null, │ │ │ │ - pinchZoomOptions: null, │ │ │ │ - clickHandlerOptions: null, │ │ │ │ - documentDrag: false, │ │ │ │ - autoActivate: true, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.handlers = {}; │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.deactivate(); │ │ │ │ - if (this.dragPan) { │ │ │ │ - this.dragPan.destroy() │ │ │ │ - } │ │ │ │ - this.dragPan = null; │ │ │ │ - if (this.pinchZoom) { │ │ │ │ - this.pinchZoom.destroy(); │ │ │ │ - delete this.pinchZoom │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ - this.dragPan.activate(); │ │ │ │ - this.handlers.click.activate(); │ │ │ │ - this.pinchZoom.activate(); │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ - this.dragPan.deactivate(); │ │ │ │ - this.handlers.click.deactivate(); │ │ │ │ - this.pinchZoom.deactivate(); │ │ │ │ - return true │ │ │ │ - } │ │ │ │ - return false │ │ │ │ - }, │ │ │ │ - draw: function() { │ │ │ │ - var clickCallbacks = { │ │ │ │ - click: this.defaultClick, │ │ │ │ - dblclick: this.defaultDblClick │ │ │ │ - }; │ │ │ │ - var clickOptions = OpenLayers.Util.extend({ │ │ │ │ - double: true, │ │ │ │ - stopDouble: true, │ │ │ │ - pixelTolerance: 2 │ │ │ │ - }, this.clickHandlerOptions); │ │ │ │ - this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks, clickOptions); │ │ │ │ - this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend({ │ │ │ │ - map: this.map, │ │ │ │ - documentDrag: this.documentDrag │ │ │ │ - }, this.dragPanOptions)); │ │ │ │ - this.dragPan.draw(); │ │ │ │ - this.pinchZoom = new OpenLayers.Control.PinchZoom(OpenLayers.Util.extend({ │ │ │ │ - map: this.map │ │ │ │ - }, this.pinchZoomOptions)) │ │ │ │ - }, │ │ │ │ - defaultClick: function(evt) { │ │ │ │ - if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ - this.map.zoomOut() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - defaultDblClick: function(evt) { │ │ │ │ - this.map.zoomTo(this.map.zoom + 1, evt.xy) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Control.TouchNavigation" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - distance: 20, │ │ │ │ - threshold: null, │ │ │ │ - features: null, │ │ │ │ - clusters: null, │ │ │ │ - clustering: false, │ │ │ │ - resolution: null, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - beforefeaturesadded: this.cacheFeatures, │ │ │ │ - featuresremoved: this.clearCache, │ │ │ │ - moveend: this.cluster, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.layer.events.un({ │ │ │ │ - beforefeaturesadded: this.cacheFeatures, │ │ │ │ - featuresremoved: this.clearCache, │ │ │ │ - moveend: this.cluster, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - cacheFeatures: function(event) { │ │ │ │ - var propagate = true; │ │ │ │ - if (!this.clustering) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.features = event.features; │ │ │ │ - this.cluster(); │ │ │ │ - propagate = false │ │ │ │ - } │ │ │ │ - return propagate │ │ │ │ - }, │ │ │ │ - clearCache: function() { │ │ │ │ - if (!this.clustering) { │ │ │ │ - this.features = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - cluster: function(event) { │ │ │ │ - if ((!event || event.zoomChanged) && this.features) { │ │ │ │ - var resolution = this.layer.map.getResolution(); │ │ │ │ - if (resolution != this.resolution || !this.clustersExist()) { │ │ │ │ - this.resolution = resolution; │ │ │ │ - var clusters = []; │ │ │ │ - var feature, clustered, cluster; │ │ │ │ - for (var i = 0; i < this.features.length; ++i) { │ │ │ │ - feature = this.features[i]; │ │ │ │ - if (feature.geometry) { │ │ │ │ - clustered = false; │ │ │ │ - for (var j = clusters.length - 1; j >= 0; --j) { │ │ │ │ - cluster = clusters[j]; │ │ │ │ - if (this.shouldCluster(cluster, feature)) { │ │ │ │ - this.addToCluster(cluster, feature); │ │ │ │ - clustered = true; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (!clustered) { │ │ │ │ - clusters.push(this.createCluster(this.features[i])) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.clustering = true; │ │ │ │ - this.layer.removeAllFeatures(); │ │ │ │ - this.clustering = false; │ │ │ │ - if (clusters.length > 0) { │ │ │ │ - if (this.threshold > 1) { │ │ │ │ - var clone = clusters.slice(); │ │ │ │ - clusters = []; │ │ │ │ - var candidate; │ │ │ │ - for (var i = 0, len = clone.length; i < len; ++i) { │ │ │ │ - candidate = clone[i]; │ │ │ │ - if (candidate.attributes.count < this.threshold) { │ │ │ │ - Array.prototype.push.apply(clusters, candidate.cluster) │ │ │ │ - } else { │ │ │ │ - clusters.push(candidate) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.clustering = true; │ │ │ │ - this.layer.addFeatures(clusters); │ │ │ │ - this.clustering = false │ │ │ │ - } │ │ │ │ - this.clusters = clusters │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clustersExist: function() { │ │ │ │ - var exist = false; │ │ │ │ - if (this.clusters && this.clusters.length > 0 && this.clusters.length == this.layer.features.length) { │ │ │ │ - exist = true; │ │ │ │ - for (var i = 0; i < this.clusters.length; ++i) { │ │ │ │ - if (this.clusters[i] != this.layer.features[i]) { │ │ │ │ - exist = false; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return exist │ │ │ │ - }, │ │ │ │ - shouldCluster: function(cluster, feature) { │ │ │ │ - var cc = cluster.geometry.getBounds().getCenterLonLat(); │ │ │ │ - var fc = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ - var distance = Math.sqrt(Math.pow(cc.lon - fc.lon, 2) + Math.pow(cc.lat - fc.lat, 2)) / this.resolution; │ │ │ │ - return distance <= this.distance │ │ │ │ - }, │ │ │ │ - addToCluster: function(cluster, feature) { │ │ │ │ - cluster.cluster.push(feature); │ │ │ │ - cluster.attributes.count += 1 │ │ │ │ - }, │ │ │ │ - createCluster: function(feature) { │ │ │ │ - var center = feature.geometry.getBounds().getCenterLonLat(); │ │ │ │ - var cluster = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(center.lon, center.lat), { │ │ │ │ - count: 1 │ │ │ │ - }); │ │ │ │ - cluster.cluster = [feature]; │ │ │ │ - return cluster │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Cluster" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - bounds: null, │ │ │ │ - resolution: null, │ │ │ │ - ratio: 2, │ │ │ │ - resFactor: null, │ │ │ │ - response: null, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - moveend: this.update, │ │ │ │ - refresh: this.update, │ │ │ │ - visibilitychanged: this.update, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - this.update() │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - moveend: this.update, │ │ │ │ - refresh: this.update, │ │ │ │ - visibilitychanged: this.update, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - update: function(options) { │ │ │ │ - var mapBounds = this.getMapBounds(); │ │ │ │ - if (mapBounds !== null && (options && options.force || this.layer.visibility && this.layer.calculateInRange() && this.invalidBounds(mapBounds))) { │ │ │ │ - this.calculateBounds(mapBounds); │ │ │ │ - this.resolution = this.layer.map.getResolution(); │ │ │ │ - this.triggerRead(options) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getMapBounds: function() { │ │ │ │ - if (this.layer.map === null) { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ - var bounds = this.layer.map.getExtent(); │ │ │ │ - if (bounds && !this.layer.projection.equals(this.layer.map.getProjectionObject())) { │ │ │ │ - bounds = bounds.clone().transform(this.layer.map.getProjectionObject(), this.layer.projection) │ │ │ │ - } │ │ │ │ - return bounds │ │ │ │ - }, │ │ │ │ - invalidBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds() │ │ │ │ - } │ │ │ │ - var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds); │ │ │ │ - if (!invalid && this.resFactor) { │ │ │ │ - var ratio = this.resolution / this.layer.map.getResolution(); │ │ │ │ - invalid = ratio >= this.resFactor || ratio <= 1 / this.resFactor │ │ │ │ - } │ │ │ │ - return invalid │ │ │ │ - }, │ │ │ │ - calculateBounds: function(mapBounds) { │ │ │ │ - if (!mapBounds) { │ │ │ │ - mapBounds = this.getMapBounds() │ │ │ │ - } │ │ │ │ - var center = mapBounds.getCenterLonLat(); │ │ │ │ - var dataWidth = mapBounds.getWidth() * this.ratio; │ │ │ │ - var dataHeight = mapBounds.getHeight() * this.ratio; │ │ │ │ - this.bounds = new OpenLayers.Bounds(center.lon - dataWidth / 2, center.lat - dataHeight / 2, center.lon + dataWidth / 2, center.lat + dataHeight / 2) │ │ │ │ - }, │ │ │ │ - triggerRead: function(options) { │ │ │ │ - if (this.response && !(options && options.noAbort === true)) { │ │ │ │ - this.layer.protocol.abort(this.response); │ │ │ │ - this.layer.events.triggerEvent("loadend") │ │ │ │ - } │ │ │ │ - var evt = { │ │ │ │ - filter: this.createFilter() │ │ │ │ - }; │ │ │ │ - this.layer.events.triggerEvent("loadstart", evt); │ │ │ │ - this.response = this.layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ - filter: evt.filter, │ │ │ │ - callback: this.merge, │ │ │ │ - scope: this │ │ │ │ - }, options)) │ │ │ │ - }, │ │ │ │ - createFilter: function() { │ │ │ │ - var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - value: this.bounds, │ │ │ │ - projection: this.layer.projection │ │ │ │ - }); │ │ │ │ - if (this.layer.filter) { │ │ │ │ - filter = new OpenLayers.Filter.Logical({ │ │ │ │ - type: OpenLayers.Filter.Logical.AND, │ │ │ │ - filters: [this.layer.filter, filter] │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return filter │ │ │ │ - }, │ │ │ │ - merge: function(resp) { │ │ │ │ - this.layer.destroyFeatures(); │ │ │ │ - if (resp.success()) { │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = this.layer.projection; │ │ │ │ - var local = this.layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.layer.addFeatures(features) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.bounds = null │ │ │ │ - } │ │ │ │ - this.response = null; │ │ │ │ - this.layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.BBOX" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Save = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - events: null, │ │ │ │ - auto: false, │ │ │ │ - timer: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Strategy.prototype.initialize.apply(this, [options]); │ │ │ │ - this.events = new OpenLayers.Events(this) │ │ │ │ - }, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (this.auto) { │ │ │ │ - if (typeof this.auto === "number") { │ │ │ │ - this.timer = window.setInterval(OpenLayers.Function.bind(this.save, this), this.auto * 1e3) │ │ │ │ - } else { │ │ │ │ - this.layer.events.on({ │ │ │ │ - featureadded: this.triggerSave, │ │ │ │ - afterfeaturemodified: this.triggerSave, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - if (this.auto) { │ │ │ │ - if (typeof this.auto === "number") { │ │ │ │ - window.clearInterval(this.timer) │ │ │ │ - } else { │ │ │ │ - this.layer.events.un({ │ │ │ │ - featureadded: this.triggerSave, │ │ │ │ - afterfeaturemodified: this.triggerSave, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - triggerSave: function(event) { │ │ │ │ - var feature = event.feature; │ │ │ │ - if (feature.state === OpenLayers.State.INSERT || feature.state === OpenLayers.State.UPDATE || feature.state === OpenLayers.State.DELETE) { │ │ │ │ - this.save([event.feature]) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - save: function(features) { │ │ │ │ - if (!features) { │ │ │ │ - features = this.layer.features │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("start", { │ │ │ │ - features: features │ │ │ │ - }); │ │ │ │ - var remote = this.layer.projection; │ │ │ │ - var local = this.layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var len = features.length; │ │ │ │ - var clones = new Array(len); │ │ │ │ - var orig, clone; │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - orig = features[i]; │ │ │ │ - clone = orig.clone(); │ │ │ │ - clone.fid = orig.fid; │ │ │ │ - clone.state = orig.state; │ │ │ │ - if (orig.url) { │ │ │ │ - clone.url = orig.url │ │ │ │ - } │ │ │ │ - clone._original = orig; │ │ │ │ - clone.geometry.transform(local, remote); │ │ │ │ - clones[i] = clone │ │ │ │ - } │ │ │ │ - features = clones │ │ │ │ - } │ │ │ │ - this.layer.protocol.commit(features, { │ │ │ │ - callback: this.onCommit, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - onCommit: function(response) { │ │ │ │ - var evt = { │ │ │ │ - response: response │ │ │ │ - }; │ │ │ │ - if (response.success()) { │ │ │ │ - var features = response.reqFeatures; │ │ │ │ - var state, feature; │ │ │ │ - var destroys = []; │ │ │ │ - var insertIds = response.insertIds || []; │ │ │ │ - var j = 0; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - feature = feature._original || feature; │ │ │ │ - state = feature.state; │ │ │ │ - if (state) { │ │ │ │ - if (state == OpenLayers.State.DELETE) { │ │ │ │ - destroys.push(feature) │ │ │ │ - } else if (state == OpenLayers.State.INSERT) { │ │ │ │ - feature.fid = insertIds[j]; │ │ │ │ - ++j │ │ │ │ - } │ │ │ │ - feature.state = null │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (destroys.length > 0) { │ │ │ │ - this.layer.destroyFeatures(destroys) │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("success", evt) │ │ │ │ - } else { │ │ │ │ - this.events.triggerEvent("fail", evt) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Save" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - preload: false, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - refresh: this.load, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - if (this.layer.visibility == true || this.preload) { │ │ │ │ - this.load() │ │ │ │ - } else { │ │ │ │ - this.layer.events.on({ │ │ │ │ - visibilitychanged: this.load, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - refresh: this.load, │ │ │ │ - visibilitychanged: this.load, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - load: function(options) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.events.triggerEvent("loadstart", { │ │ │ │ - filter: layer.filter │ │ │ │ - }); │ │ │ │ - layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: this.merge, │ │ │ │ - filter: layer.filter, │ │ │ │ - scope: this │ │ │ │ - }, options)); │ │ │ │ - layer.events.un({ │ │ │ │ - visibilitychanged: this.load, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - merge: function(resp) { │ │ │ │ - var layer = this.layer; │ │ │ │ - layer.destroyFeatures(); │ │ │ │ - var features = resp.features; │ │ │ │ - if (features && features.length > 0) { │ │ │ │ - var remote = layer.projection; │ │ │ │ - var local = layer.map.getProjectionObject(); │ │ │ │ - if (!local.equals(remote)) { │ │ │ │ - var geom; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - geom = features[i].geometry; │ │ │ │ - if (geom) { │ │ │ │ - geom.transform(remote, local) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - layer.addFeatures(features) │ │ │ │ - } │ │ │ │ - layer.events.triggerEvent("loadend", { │ │ │ │ - response: resp │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Refresh = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - force: false, │ │ │ │ - interval: 0, │ │ │ │ - timer: null, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - if (this.layer.visibility === true) { │ │ │ │ - this.start() │ │ │ │ - } │ │ │ │ - this.layer.events.on({ │ │ │ │ - visibilitychanged: this.reset, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.stop(); │ │ │ │ - this.layer.events.un({ │ │ │ │ - visibilitychanged: this.reset, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - reset: function() { │ │ │ │ - if (this.layer.visibility === true) { │ │ │ │ - this.start() │ │ │ │ - } else { │ │ │ │ - this.stop() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - start: function() { │ │ │ │ - if (this.interval && typeof this.interval === "number" && this.interval > 0) { │ │ │ │ - this.timer = window.setInterval(OpenLayers.Function.bind(this.refresh, this), this.interval) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - refresh: function() { │ │ │ │ - if (this.layer && this.layer.refresh && typeof this.layer.refresh == "function") { │ │ │ │ - this.layer.refresh({ │ │ │ │ - force: this.force │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - stop: function() { │ │ │ │ - if (this.timer !== null) { │ │ │ │ - window.clearInterval(this.timer); │ │ │ │ - this.timer = null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Refresh" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - features: null, │ │ │ │ - length: 10, │ │ │ │ - num: null, │ │ │ │ - paging: false, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.call(this); │ │ │ │ - if (activated) { │ │ │ │ - this.layer.events.on({ │ │ │ │ - beforefeaturesadded: this.cacheFeatures, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ - if (deactivated) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.layer.events.un({ │ │ │ │ - beforefeaturesadded: this.cacheFeatures, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return deactivated │ │ │ │ - }, │ │ │ │ - cacheFeatures: function(event) { │ │ │ │ - if (!this.paging) { │ │ │ │ - this.clearCache(); │ │ │ │ - this.features = event.features; │ │ │ │ - this.pageNext(event) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clearCache: function() { │ │ │ │ - if (this.features) { │ │ │ │ - for (var i = 0; i < this.features.length; ++i) { │ │ │ │ - this.features[i].destroy() │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.features = null; │ │ │ │ - this.num = null │ │ │ │ - }, │ │ │ │ - pageCount: function() { │ │ │ │ - var numFeatures = this.features ? this.features.length : 0; │ │ │ │ - return Math.ceil(numFeatures / this.length) │ │ │ │ - }, │ │ │ │ - pageNum: function() { │ │ │ │ - return this.num │ │ │ │ - }, │ │ │ │ - pageLength: function(newLength) { │ │ │ │ - if (newLength && newLength > 0) { │ │ │ │ - this.length = newLength │ │ │ │ - } │ │ │ │ - return this.length │ │ │ │ - }, │ │ │ │ - pageNext: function(event) { │ │ │ │ - var changed = false; │ │ │ │ - if (this.features) { │ │ │ │ - if (this.num === null) { │ │ │ │ - this.num = -1 │ │ │ │ - } │ │ │ │ - var start = (this.num + 1) * this.length; │ │ │ │ - changed = this.page(start, event) │ │ │ │ - } │ │ │ │ - return changed │ │ │ │ - }, │ │ │ │ - pagePrevious: function() { │ │ │ │ - var changed = false; │ │ │ │ - if (this.features) { │ │ │ │ - if (this.num === null) { │ │ │ │ - this.num = this.pageCount() │ │ │ │ - } │ │ │ │ - var start = (this.num - 1) * this.length; │ │ │ │ - changed = this.page(start) │ │ │ │ - } │ │ │ │ - return changed │ │ │ │ - }, │ │ │ │ - page: function(start, event) { │ │ │ │ - var changed = false; │ │ │ │ - if (this.features) { │ │ │ │ - if (start >= 0 && start < this.features.length) { │ │ │ │ - var num = Math.floor(start / this.length); │ │ │ │ - if (num != this.num) { │ │ │ │ - this.paging = true; │ │ │ │ - var features = this.features.slice(start, start + this.length); │ │ │ │ - this.layer.removeFeatures(this.layer.features); │ │ │ │ - this.num = num; │ │ │ │ - if (event && event.features) { │ │ │ │ - event.features = features │ │ │ │ - } else { │ │ │ │ - this.layer.addFeatures(features) │ │ │ │ - } │ │ │ │ - this.paging = false; │ │ │ │ - changed = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return changed │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Paging" │ │ │ │ -}); │ │ │ │ -OpenLayers.Strategy.Filter = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ - filter: null, │ │ │ │ - cache: null, │ │ │ │ - caching: false, │ │ │ │ - activate: function() { │ │ │ │ - var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ - if (activated) { │ │ │ │ - this.cache = []; │ │ │ │ - this.layer.events.on({ │ │ │ │ - beforefeaturesadded: this.handleAdd, │ │ │ │ - beforefeaturesremoved: this.handleRemove, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return activated │ │ │ │ - }, │ │ │ │ - deactivate: function() { │ │ │ │ - this.cache = null; │ │ │ │ - if (this.layer && this.layer.events) { │ │ │ │ - this.layer.events.un({ │ │ │ │ - beforefeaturesadded: this.handleAdd, │ │ │ │ - beforefeaturesremoved: this.handleRemove, │ │ │ │ - scope: this │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - return OpenLayers.Strategy.prototype.deactivate.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - handleAdd: function(event) { │ │ │ │ - if (!this.caching && this.filter) { │ │ │ │ - var features = event.features; │ │ │ │ - event.features = []; │ │ │ │ - var feature; │ │ │ │ - for (var i = 0, ii = features.length; i < ii; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - if (this.filter.evaluate(feature)) { │ │ │ │ - event.features.push(feature) │ │ │ │ - } else { │ │ │ │ - this.cache.push(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - handleRemove: function(event) { │ │ │ │ - if (!this.caching) { │ │ │ │ - this.cache = [] │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setFilter: function(filter) { │ │ │ │ - this.filter = filter; │ │ │ │ - var previousCache = this.cache; │ │ │ │ - this.cache = []; │ │ │ │ - this.handleAdd({ │ │ │ │ - features: this.layer.features │ │ │ │ - }); │ │ │ │ - if (this.cache.length > 0) { │ │ │ │ - this.caching = true; │ │ │ │ - this.layer.removeFeatures(this.cache.slice()); │ │ │ │ - this.caching = false │ │ │ │ - } │ │ │ │ - if (previousCache.length > 0) { │ │ │ │ - var event = { │ │ │ │ - features: previousCache │ │ │ │ - }; │ │ │ │ - this.handleAdd(event); │ │ │ │ - if (event.features.length > 0) { │ │ │ │ - this.caching = true; │ │ │ │ - this.layer.addFeatures(event.features); │ │ │ │ - this.caching = false │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Strategy.Filter" │ │ │ │ -}); │ │ │ │ -OpenLayers.ElementsIndexer = OpenLayers.Class({ │ │ │ │ - maxZIndex: null, │ │ │ │ - order: null, │ │ │ │ - indices: null, │ │ │ │ - compare: null, │ │ │ │ - initialize: function(yOrdering) { │ │ │ │ - this.compare = yOrdering ? OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER : OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER; │ │ │ │ - this.clear() │ │ │ │ - }, │ │ │ │ - insert: function(newNode) { │ │ │ │ - if (this.exists(newNode)) { │ │ │ │ - this.remove(newNode) │ │ │ │ - } │ │ │ │ - var nodeId = newNode.id; │ │ │ │ - this.determineZIndex(newNode); │ │ │ │ - var leftIndex = -1; │ │ │ │ - var rightIndex = this.order.length; │ │ │ │ - var middle; │ │ │ │ - while (rightIndex - leftIndex > 1) { │ │ │ │ - middle = parseInt((leftIndex + rightIndex) / 2); │ │ │ │ - var placement = this.compare(this, newNode, OpenLayers.Util.getElement(this.order[middle])); │ │ │ │ - if (placement > 0) { │ │ │ │ - leftIndex = middle │ │ │ │ - } else { │ │ │ │ - rightIndex = middle │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.order.splice(rightIndex, 0, nodeId); │ │ │ │ - this.indices[nodeId] = this.getZIndex(newNode); │ │ │ │ - return this.getNextElement(rightIndex) │ │ │ │ - }, │ │ │ │ - remove: function(node) { │ │ │ │ - var nodeId = node.id; │ │ │ │ - var arrayIndex = OpenLayers.Util.indexOf(this.order, nodeId); │ │ │ │ - if (arrayIndex >= 0) { │ │ │ │ - this.order.splice(arrayIndex, 1); │ │ │ │ - delete this.indices[nodeId]; │ │ │ │ - if (this.order.length > 0) { │ │ │ │ - var lastId = this.order[this.order.length - 1]; │ │ │ │ - this.maxZIndex = this.indices[lastId] │ │ │ │ - } else { │ │ │ │ - this.maxZIndex = 0 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clear: function() { │ │ │ │ - this.order = []; │ │ │ │ - this.indices = {}; │ │ │ │ - this.maxZIndex = 0 │ │ │ │ - }, │ │ │ │ - exists: function(node) { │ │ │ │ - return this.indices[node.id] != null │ │ │ │ - }, │ │ │ │ - getZIndex: function(node) { │ │ │ │ - return node._style.graphicZIndex │ │ │ │ - }, │ │ │ │ - determineZIndex: function(node) { │ │ │ │ - var zIndex = node._style.graphicZIndex; │ │ │ │ - if (zIndex == null) { │ │ │ │ - zIndex = this.maxZIndex; │ │ │ │ - node._style.graphicZIndex = zIndex │ │ │ │ - } else if (zIndex > this.maxZIndex) { │ │ │ │ - this.maxZIndex = zIndex │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - getNextElement: function(index) { │ │ │ │ - var nextIndex = index + 1; │ │ │ │ - if (nextIndex < this.order.length) { │ │ │ │ - var nextElement = OpenLayers.Util.getElement(this.order[nextIndex]); │ │ │ │ - if (nextElement == undefined) { │ │ │ │ - nextElement = this.getNextElement(nextIndex) │ │ │ │ - } │ │ │ │ - return nextElement │ │ │ │ - } else { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.ElementsIndexer" │ │ │ │ -}); │ │ │ │ -OpenLayers.ElementsIndexer.IndexingMethods = { │ │ │ │ - Z_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ - var newZIndex = indexer.getZIndex(newNode); │ │ │ │ - var returnVal = 0; │ │ │ │ - if (nextNode) { │ │ │ │ - var nextZIndex = indexer.getZIndex(nextNode); │ │ │ │ - returnVal = newZIndex - nextZIndex │ │ │ │ - } │ │ │ │ - return returnVal │ │ │ │ - }, │ │ │ │ - Z_ORDER_DRAWING_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ - var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ - if (nextNode && returnVal == 0) { │ │ │ │ - returnVal = 1 │ │ │ │ - } │ │ │ │ - return returnVal │ │ │ │ - }, │ │ │ │ - Z_ORDER_Y_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ - var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ - if (nextNode && returnVal === 0) { │ │ │ │ - var result = nextNode._boundsBottom - newNode._boundsBottom; │ │ │ │ - returnVal = result === 0 ? 1 : result │ │ │ │ + Z_ORDER_Y_ORDER: function(indexer, newNode, nextNode) { │ │ │ │ + var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(indexer, newNode, nextNode); │ │ │ │ + if (nextNode && returnVal === 0) { │ │ │ │ + var result = nextNode._boundsBottom - newNode._boundsBottom; │ │ │ │ + returnVal = result === 0 ? 1 : result │ │ │ │ } │ │ │ │ return returnVal │ │ │ │ } │ │ │ │ }; │ │ │ │ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, { │ │ │ │ rendererRoot: null, │ │ │ │ root: null, │ │ │ │ @@ -28486,553 +30698,525 @@ │ │ │ │ return this.root.parentNode.parentNode.id │ │ │ │ }, │ │ │ │ isComplexSymbol: function(graphicName) { │ │ │ │ return graphicName != "circle" && !!graphicName │ │ │ │ }, │ │ │ │ CLASS_NAME: "OpenLayers.Renderer.Elements" │ │ │ │ }); │ │ │ │ -OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ - xmlns: "http://www.w3.org/2000/svg", │ │ │ │ - xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ - MAX_PIXEL: 15e3, │ │ │ │ - translationParameters: null, │ │ │ │ - symbolMetrics: null, │ │ │ │ +OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ + xmlns: "urn:schemas-microsoft-com:vml", │ │ │ │ + symbolCache: {}, │ │ │ │ + offset: null, │ │ │ │ initialize: function(containerID) { │ │ │ │ if (!this.supported()) { │ │ │ │ return │ │ │ │ } │ │ │ │ - OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: 0, │ │ │ │ - y: 0 │ │ │ │ - }; │ │ │ │ - this.symbolMetrics = {} │ │ │ │ + if (!document.namespaces.olv) { │ │ │ │ + document.namespaces.add("olv", this.xmlns); │ │ │ │ + var style = document.createStyleSheet(); │ │ │ │ + var shapes = ["shape", "rect", "oval", "fill", "stroke", "imagedata", "group", "textbox"]; │ │ │ │ + for (var i = 0, len = shapes.length; i < len; i++) { │ │ │ │ + style.addRule("olv\\:" + shapes[i], "behavior: url(#default#VML); " + "position: absolute; display: inline-block;") │ │ │ │ + } │ │ │ │ + } │ │ │ │ + OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments) │ │ │ │ }, │ │ │ │ supported: function() { │ │ │ │ - var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ - return document.implementation && (document.implementation.hasFeature("org.w3c.svg", "1.0") || document.implementation.hasFeature(svgFeature + "SVG", "1.1") || document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1")) │ │ │ │ - }, │ │ │ │ - inValidRange: function(x, y, xyOnly) { │ │ │ │ - var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ - var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ - return left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL │ │ │ │ + return !!document.namespaces │ │ │ │ }, │ │ │ │ setExtent: function(extent, resolutionChanged) { │ │ │ │ var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ - var resolution = this.getResolution(), │ │ │ │ - left = -extent.left / resolution, │ │ │ │ - top = extent.top / resolution; │ │ │ │ - if (resolutionChanged) { │ │ │ │ - this.left = left; │ │ │ │ - this.top = top; │ │ │ │ - var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ - this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ - this.translate(this.xOffset, 0); │ │ │ │ - return true │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var left = extent.left / resolution | 0; │ │ │ │ + var top = extent.top / resolution - this.size.h | 0; │ │ │ │ + if (resolutionChanged || !this.offset) { │ │ │ │ + this.offset = { │ │ │ │ + x: left, │ │ │ │ + y: top │ │ │ │ + }; │ │ │ │ + left = 0; │ │ │ │ + top = 0 │ │ │ │ } else { │ │ │ │ - var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ - if (!inRange) { │ │ │ │ - this.setExtent(extent, true) │ │ │ │ - } │ │ │ │ - return coordSysUnchanged && inRange │ │ │ │ + left = left - this.offset.x; │ │ │ │ + top = top - this.offset.y │ │ │ │ } │ │ │ │ - }, │ │ │ │ - translate: function(x, y) { │ │ │ │ - if (!this.inValidRange(x, y, true)) { │ │ │ │ - return false │ │ │ │ - } else { │ │ │ │ - var transformString = ""; │ │ │ │ - if (x || y) { │ │ │ │ - transformString = "translate(" + x + "," + y + ")" │ │ │ │ - } │ │ │ │ - this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ - this.translationParameters = { │ │ │ │ - x: x, │ │ │ │ - y: y │ │ │ │ - }; │ │ │ │ - return true │ │ │ │ + var org = left - this.xOffset + " " + top; │ │ │ │ + this.root.coordorigin = org; │ │ │ │ + var roots = [this.root, this.vectorRoot, this.textRoot]; │ │ │ │ + var root; │ │ │ │ + for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ + root = roots[i]; │ │ │ │ + var size = this.size.w + " " + this.size.h; │ │ │ │ + root.coordsize = size │ │ │ │ } │ │ │ │ + this.root.style.flip = "y"; │ │ │ │ + return coordSysUnchanged │ │ │ │ }, │ │ │ │ setSize: function(size) { │ │ │ │ OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ - this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ - this.rendererRoot.setAttributeNS(null, "height", this.size.h) │ │ │ │ + var roots = [this.rendererRoot, this.root, this.vectorRoot, this.textRoot]; │ │ │ │ + var w = this.size.w + "px"; │ │ │ │ + var h = this.size.h + "px"; │ │ │ │ + var root; │ │ │ │ + for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ + root = roots[i]; │ │ │ │ + root.style.width = w; │ │ │ │ + root.style.height = h │ │ │ │ + } │ │ │ │ }, │ │ │ │ getNodeType: function(geometry, style) { │ │ │ │ var nodeType = null; │ │ │ │ switch (geometry.CLASS_NAME) { │ │ │ │ case "OpenLayers.Geometry.Point": │ │ │ │ if (style.externalGraphic) { │ │ │ │ - nodeType = "image" │ │ │ │ + nodeType = "olv:rect" │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "svg" │ │ │ │ + nodeType = "olv:shape" │ │ │ │ } else { │ │ │ │ - nodeType = "circle" │ │ │ │ + nodeType = "olv:oval" │ │ │ │ } │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "rect"; │ │ │ │ + nodeType = "olv:rect"; │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.LineString": │ │ │ │ - nodeType = "polyline"; │ │ │ │ - break; │ │ │ │ case "OpenLayers.Geometry.LinearRing": │ │ │ │ - nodeType = "polygon"; │ │ │ │ - break; │ │ │ │ case "OpenLayers.Geometry.Polygon": │ │ │ │ case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "path"; │ │ │ │ + nodeType = "olv:shape"; │ │ │ │ break; │ │ │ │ default: │ │ │ │ break │ │ │ │ } │ │ │ │ return nodeType │ │ │ │ }, │ │ │ │ - setStyle: function(node, style, options) { │ │ │ │ + setStyle: function(node, style, options, geometry) { │ │ │ │ style = style || node._style; │ │ │ │ options = options || node._options; │ │ │ │ + var fillColor = style.fillColor; │ │ │ │ var title = style.title || style.graphicTitle; │ │ │ │ if (title) { │ │ │ │ - node.setAttributeNS(null, "title", title); │ │ │ │ - var titleNode = node.getElementsByTagName("title"); │ │ │ │ - if (titleNode.length > 0) { │ │ │ │ - titleNode[0].firstChild.textContent = title │ │ │ │ - } else { │ │ │ │ - var label = this.nodeFactory(null, "title"); │ │ │ │ - label.textContent = title; │ │ │ │ - node.appendChild(label) │ │ │ │ - } │ │ │ │ + node.title = title │ │ │ │ } │ │ │ │ - var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ - var widthFactor = 1; │ │ │ │ - var pos; │ │ │ │ - if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ - node.style.visibility = ""; │ │ │ │ - if (style.graphic === false) { │ │ │ │ - node.style.visibility = "hidden" │ │ │ │ - } else if (style.externalGraphic) { │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - if (style.graphicWidth && style.graphicHeight) { │ │ │ │ - node.setAttributeNS(null, "preserveAspectRatio", "none") │ │ │ │ - } │ │ │ │ + if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + options.isFilled = true; │ │ │ │ var width = style.graphicWidth || style.graphicHeight; │ │ │ │ var height = style.graphicHeight || style.graphicWidth; │ │ │ │ width = width ? width : style.pointRadius * 2; │ │ │ │ height = height ? height : style.pointRadius * 2; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ var xOffset = style.graphicXOffset != undefined ? style.graphicXOffset : -(.5 * width); │ │ │ │ var yOffset = style.graphicYOffset != undefined ? style.graphicYOffset : -(.5 * height); │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ - node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ - node.setAttributeNS(null, "width", width); │ │ │ │ - node.setAttributeNS(null, "height", height); │ │ │ │ - node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ - node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ - node.onclick = OpenLayers.Event.preventDefault │ │ │ │ + node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x + xOffset | 0) + "px"; │ │ │ │ + node.style.top = (geometry.y / resolution - this.offset.y - (yOffset + height) | 0) + "px"; │ │ │ │ + node.style.width = width + "px"; │ │ │ │ + node.style.height = height + "px"; │ │ │ │ + node.style.flip = "y"; │ │ │ │ + fillColor = "none"; │ │ │ │ + options.isStroked = false │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - var offset = style.pointRadius * 3; │ │ │ │ - var size = offset * 2; │ │ │ │ - var src = this.importSymbol(style.graphicName); │ │ │ │ - pos = this.getPosition(node); │ │ │ │ - widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ - var parent = node.parentNode; │ │ │ │ - var nextSibling = node.nextSibling; │ │ │ │ - if (parent) { │ │ │ │ - parent.removeChild(node) │ │ │ │ - } │ │ │ │ - node.firstChild && node.removeChild(node.firstChild); │ │ │ │ - node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ - node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ - node.setAttributeNS(null, "width", size); │ │ │ │ - node.setAttributeNS(null, "height", size); │ │ │ │ - node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ - node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ - if (nextSibling) { │ │ │ │ - parent.insertBefore(node, nextSibling) │ │ │ │ - } else if (parent) { │ │ │ │ - parent.appendChild(node) │ │ │ │ - } │ │ │ │ + var cache = this.importSymbol(style.graphicName); │ │ │ │ + node.path = cache.path; │ │ │ │ + node.coordorigin = cache.left + "," + cache.bottom; │ │ │ │ + var size = cache.size; │ │ │ │ + node.coordsize = size + "," + size; │ │ │ │ + this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ + node.style.flip = "y" │ │ │ │ } else { │ │ │ │ - node.setAttributeNS(null, "r", style.pointRadius) │ │ │ │ - } │ │ │ │ - var rotation = style.rotation; │ │ │ │ - if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - rotation |= 0; │ │ │ │ - if (node.nodeName !== "svg") { │ │ │ │ - node.setAttributeNS(null, "transform", "rotate(" + rotation + " " + pos.x + " " + pos.y + ")") │ │ │ │ - } else { │ │ │ │ - var metrics = this.symbolMetrics[src.id]; │ │ │ │ - node.firstChild.setAttributeNS(null, "transform", "rotate(" + rotation + " " + metrics[1] + " " + metrics[2] + ")") │ │ │ │ - } │ │ │ │ + this.drawCircle(node, geometry, style.pointRadius) │ │ │ │ } │ │ │ │ } │ │ │ │ if (options.isFilled) { │ │ │ │ - node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ - node.setAttributeNS(null, "fill-opacity", style.fillOpacity) │ │ │ │ + node.fillcolor = fillColor │ │ │ │ } else { │ │ │ │ - node.setAttributeNS(null, "fill", "none") │ │ │ │ + node.filled = "false" │ │ │ │ } │ │ │ │ - if (options.isStroked) { │ │ │ │ - node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ - node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ - node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ - node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ - node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ - style.strokeDashstyle && node.setAttributeNS(null, "stroke-dasharray", this.dashStyle(style, widthFactor)) │ │ │ │ + var fills = node.getElementsByTagName("fill"); │ │ │ │ + var fill = fills.length == 0 ? null : fills[0]; │ │ │ │ + if (!options.isFilled) { │ │ │ │ + if (fill) { │ │ │ │ + node.removeChild(fill) │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - node.setAttributeNS(null, "stroke", "none") │ │ │ │ + if (!fill) { │ │ │ │ + fill = this.createNode("olv:fill", node.id + "_fill") │ │ │ │ + } │ │ │ │ + fill.opacity = style.fillOpacity; │ │ │ │ + if (node._geometryClass === "OpenLayers.Geometry.Point" && style.externalGraphic) { │ │ │ │ + if (style.graphicOpacity) { │ │ │ │ + fill.opacity = style.graphicOpacity │ │ │ │ + } │ │ │ │ + fill.src = style.externalGraphic; │ │ │ │ + fill.type = "frame"; │ │ │ │ + if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ + fill.aspect = "atmost" │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (fill.parentNode != node) { │ │ │ │ + node.appendChild(fill) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (style.pointerEvents) { │ │ │ │ - node.setAttributeNS(null, "pointer-events", style.pointerEvents) │ │ │ │ + var rotation = style.rotation; │ │ │ │ + if (rotation !== undefined || node._rotation !== undefined) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + if (style.externalGraphic) { │ │ │ │ + this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ + fill.opacity = 0 │ │ │ │ + } else if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ + node.style.rotation = rotation || 0 │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (style.cursor != null) { │ │ │ │ - node.setAttributeNS(null, "cursor", style.cursor) │ │ │ │ + var strokes = node.getElementsByTagName("stroke"); │ │ │ │ + var stroke = strokes.length == 0 ? null : strokes[0]; │ │ │ │ + if (!options.isStroked) { │ │ │ │ + node.stroked = false; │ │ │ │ + if (stroke) { │ │ │ │ + stroke.on = false │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!stroke) { │ │ │ │ + stroke = this.createNode("olv:stroke", node.id + "_stroke"); │ │ │ │ + node.appendChild(stroke) │ │ │ │ + } │ │ │ │ + stroke.on = true; │ │ │ │ + stroke.color = style.strokeColor; │ │ │ │ + stroke.weight = style.strokeWidth + "px"; │ │ │ │ + stroke.opacity = style.strokeOpacity; │ │ │ │ + stroke.endcap = style.strokeLinecap == "butt" ? "flat" : style.strokeLinecap || "round"; │ │ │ │ + if (style.strokeDashstyle) { │ │ │ │ + stroke.dashstyle = this.dashStyle(style) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ + node.style.cursor = style.cursor │ │ │ │ } │ │ │ │ return node │ │ │ │ }, │ │ │ │ - dashStyle: function(style, widthFactor) { │ │ │ │ - var w = style.strokeWidth * widthFactor; │ │ │ │ - var str = style.strokeDashstyle; │ │ │ │ - switch (str) { │ │ │ │ + graphicRotate: function(node, xOffset, yOffset, style) { │ │ │ │ + var style = style || node._style; │ │ │ │ + var rotation = style.rotation || 0; │ │ │ │ + var aspectRatio, size; │ │ │ │ + if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ + var img = new Image; │ │ │ │ + img.onreadystatechange = OpenLayers.Function.bind(function() { │ │ │ │ + if (img.readyState == "complete" || img.readyState == "interactive") { │ │ │ │ + aspectRatio = img.width / img.height; │ │ │ │ + size = Math.max(style.pointRadius * 2, style.graphicWidth || 0, style.graphicHeight || 0); │ │ │ │ + xOffset = xOffset * aspectRatio; │ │ │ │ + style.graphicWidth = size * aspectRatio; │ │ │ │ + style.graphicHeight = size; │ │ │ │ + this.graphicRotate(node, xOffset, yOffset, style) │ │ │ │ + } │ │ │ │ + }, this); │ │ │ │ + img.src = style.externalGraphic; │ │ │ │ + return │ │ │ │ + } else { │ │ │ │ + size = Math.max(style.graphicWidth, style.graphicHeight); │ │ │ │ + aspectRatio = style.graphicWidth / style.graphicHeight │ │ │ │ + } │ │ │ │ + var width = Math.round(style.graphicWidth || size * aspectRatio); │ │ │ │ + var height = Math.round(style.graphicHeight || size); │ │ │ │ + node.style.width = width + "px"; │ │ │ │ + node.style.height = height + "px"; │ │ │ │ + var image = document.getElementById(node.id + "_image"); │ │ │ │ + if (!image) { │ │ │ │ + image = this.createNode("olv:imagedata", node.id + "_image"); │ │ │ │ + node.appendChild(image) │ │ │ │ + } │ │ │ │ + image.style.width = width + "px"; │ │ │ │ + image.style.height = height + "px"; │ │ │ │ + image.src = style.externalGraphic; │ │ │ │ + image.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + "src='', sizingMethod='scale')"; │ │ │ │ + var rot = rotation * Math.PI / 180; │ │ │ │ + var sintheta = Math.sin(rot); │ │ │ │ + var costheta = Math.cos(rot); │ │ │ │ + var filter = "progid:DXImageTransform.Microsoft.Matrix(M11=" + costheta + ",M12=" + -sintheta + ",M21=" + sintheta + ",M22=" + costheta + ",SizingMethod='auto expand')\n"; │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ + if (opacity && opacity != 1) { │ │ │ │ + filter += "progid:DXImageTransform.Microsoft.BasicImage(opacity=" + opacity + ")\n" │ │ │ │ + } │ │ │ │ + node.style.filter = filter; │ │ │ │ + var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset); │ │ │ │ + var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry(); │ │ │ │ + imgBox.rotate(style.rotation, centerPoint); │ │ │ │ + var imgBounds = imgBox.getBounds(); │ │ │ │ + node.style.left = Math.round(parseInt(node.style.left) + imgBounds.left) + "px"; │ │ │ │ + node.style.top = Math.round(parseInt(node.style.top) - imgBounds.bottom) + "px" │ │ │ │ + }, │ │ │ │ + postDraw: function(node) { │ │ │ │ + node.style.visibility = "visible"; │ │ │ │ + var fillColor = node._style.fillColor; │ │ │ │ + var strokeColor = node._style.strokeColor; │ │ │ │ + if (fillColor == "none" && node.fillcolor != fillColor) { │ │ │ │ + node.fillcolor = fillColor │ │ │ │ + } │ │ │ │ + if (strokeColor == "none" && node.strokecolor != strokeColor) { │ │ │ │ + node.strokecolor = strokeColor │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + setNodeDimension: function(node, geometry) { │ │ │ │ + var bbox = geometry.getBounds(); │ │ │ │ + if (bbox) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var scaledBox = new OpenLayers.Bounds((bbox.left - this.featureDx) / resolution - this.offset.x | 0, bbox.bottom / resolution - this.offset.y | 0, (bbox.right - this.featureDx) / resolution - this.offset.x | 0, bbox.top / resolution - this.offset.y | 0); │ │ │ │ + node.style.left = scaledBox.left + "px"; │ │ │ │ + node.style.top = scaledBox.top + "px"; │ │ │ │ + node.style.width = scaledBox.getWidth() + "px"; │ │ │ │ + node.style.height = scaledBox.getHeight() + "px"; │ │ │ │ + node.coordorigin = scaledBox.left + " " + scaledBox.top; │ │ │ │ + node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + dashStyle: function(style) { │ │ │ │ + var dash = style.strokeDashstyle; │ │ │ │ + switch (dash) { │ │ │ │ case "solid": │ │ │ │ - return "none"; │ │ │ │ case "dot": │ │ │ │ - return [1, 4 * w].join(); │ │ │ │ case "dash": │ │ │ │ - return [4 * w, 4 * w].join(); │ │ │ │ case "dashdot": │ │ │ │ - return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ case "longdash": │ │ │ │ - return [8 * w, 4 * w].join(); │ │ │ │ case "longdashdot": │ │ │ │ - return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ + return dash; │ │ │ │ default: │ │ │ │ - return OpenLayers.String.trim(str).replace(/\s+/g, ",") │ │ │ │ + var parts = dash.split(/[ ,]/); │ │ │ │ + if (parts.length == 2) { │ │ │ │ + if (1 * parts[0] >= 2 * parts[1]) { │ │ │ │ + return "longdash" │ │ │ │ + } │ │ │ │ + return parts[0] == 1 || parts[1] == 1 ? "dot" : "dash" │ │ │ │ + } else if (parts.length == 4) { │ │ │ │ + return 1 * parts[0] >= 2 * parts[1] ? "longdashdot" : "dashdot" │ │ │ │ + } │ │ │ │ + return "solid" │ │ │ │ } │ │ │ │ }, │ │ │ │ createNode: function(type, id) { │ │ │ │ - var node = document.createElementNS(this.xmlns, type); │ │ │ │ + var node = document.createElement(type); │ │ │ │ if (id) { │ │ │ │ - node.setAttributeNS(null, "id", id) │ │ │ │ + node.id = id │ │ │ │ } │ │ │ │ + node.unselectable = "on"; │ │ │ │ + node.onselectstart = OpenLayers.Function.False; │ │ │ │ return node │ │ │ │ }, │ │ │ │ nodeTypeCompare: function(node, type) { │ │ │ │ - return type == node.nodeName │ │ │ │ + var subType = type; │ │ │ │ + var splitIndex = subType.indexOf(":"); │ │ │ │ + if (splitIndex != -1) { │ │ │ │ + subType = subType.substr(splitIndex + 1) │ │ │ │ + } │ │ │ │ + var nodeName = node.nodeName; │ │ │ │ + splitIndex = nodeName.indexOf(":"); │ │ │ │ + if (splitIndex != -1) { │ │ │ │ + nodeName = nodeName.substr(splitIndex + 1) │ │ │ │ + } │ │ │ │ + return subType == nodeName │ │ │ │ }, │ │ │ │ createRenderRoot: function() { │ │ │ │ - var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ - svg.style.display = "block"; │ │ │ │ - return svg │ │ │ │ + return this.nodeFactory(this.container.id + "_vmlRoot", "div") │ │ │ │ }, │ │ │ │ createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "g") │ │ │ │ - }, │ │ │ │ - createDefs: function() { │ │ │ │ - var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ - this.rendererRoot.appendChild(defs); │ │ │ │ - return defs │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "olv:group") │ │ │ │ }, │ │ │ │ drawPoint: function(node, geometry) { │ │ │ │ return this.drawCircle(node, geometry, 1) │ │ │ │ }, │ │ │ │ drawCircle: function(node, geometry, radius) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = this.top - geometry.y / resolution; │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "cx", x); │ │ │ │ - node.setAttributeNS(null, "cy", y); │ │ │ │ - node.setAttributeNS(null, "r", radius); │ │ │ │ + if (!isNaN(geometry.x) && !isNaN(geometry.y)) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) - radius + "px"; │ │ │ │ + node.style.top = (geometry.y / resolution - this.offset.y | 0) - radius + "px"; │ │ │ │ + var diameter = radius * 2; │ │ │ │ + node.style.width = diameter + "px"; │ │ │ │ + node.style.height = diameter + "px"; │ │ │ │ return node │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ drawLineString: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return componentsResult.complete ? node : null │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ + return this.drawLine(node, geometry, false) │ │ │ │ }, │ │ │ │ drawLinearRing: function(node, geometry) { │ │ │ │ - var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ - if (componentsResult.path) { │ │ │ │ - node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ - return componentsResult.complete ? node : null │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + return this.drawLine(node, geometry, true) │ │ │ │ + }, │ │ │ │ + drawLine: function(node, geometry, closeLine) { │ │ │ │ + this.setNodeDimension(node, geometry); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var numComponents = geometry.components.length; │ │ │ │ + var parts = new Array(numComponents); │ │ │ │ + var comp, x, y; │ │ │ │ + for (var i = 0; i < numComponents; i++) { │ │ │ │ + comp = geometry.components[i]; │ │ │ │ + x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ + y = comp.y / resolution - this.offset.y | 0; │ │ │ │ + parts[i] = " " + x + "," + y + " l " │ │ │ │ } │ │ │ │ + var end = closeLine ? " x e" : " e"; │ │ │ │ + node.path = "m" + parts.join("") + end; │ │ │ │ + return node │ │ │ │ }, │ │ │ │ drawPolygon: function(node, geometry) { │ │ │ │ - var d = ""; │ │ │ │ - var draw = true; │ │ │ │ - var complete = true; │ │ │ │ - var linearRingResult, path; │ │ │ │ - for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ - d += " M"; │ │ │ │ - linearRingResult = this.getComponentsString(geometry.components[j].components, " "); │ │ │ │ - path = linearRingResult.path; │ │ │ │ - if (path) { │ │ │ │ - d += " " + path; │ │ │ │ - complete = linearRingResult.complete && complete │ │ │ │ - } else { │ │ │ │ - draw = false │ │ │ │ + this.setNodeDimension(node, geometry); │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var path = []; │ │ │ │ + var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y; │ │ │ │ + for (j = 0, jj = geometry.components.length; j < jj; j++) { │ │ │ │ + path.push("m"); │ │ │ │ + points = geometry.components[j].components; │ │ │ │ + area = j === 0; │ │ │ │ + first = null; │ │ │ │ + second = null; │ │ │ │ + for (i = 0, ii = points.length; i < ii; i++) { │ │ │ │ + comp = points[i]; │ │ │ │ + x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ + y = comp.y / resolution - this.offset.y | 0; │ │ │ │ + pathComp = " " + x + "," + y; │ │ │ │ + path.push(pathComp); │ │ │ │ + if (i == 0) { │ │ │ │ + path.push(" l") │ │ │ │ + } │ │ │ │ + if (!area) { │ │ │ │ + if (!first) { │ │ │ │ + first = pathComp │ │ │ │ + } else if (first != pathComp) { │ │ │ │ + if (!second) { │ │ │ │ + second = pathComp │ │ │ │ + } else if (second != pathComp) { │ │ │ │ + area = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ + path.push(area ? " x " : " ") │ │ │ │ } │ │ │ │ - d += " z"; │ │ │ │ - if (draw) { │ │ │ │ - node.setAttributeNS(null, "d", d); │ │ │ │ - node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ - return complete ? node : null │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ + path.push("e"); │ │ │ │ + node.path = path.join(""); │ │ │ │ + return node │ │ │ │ }, │ │ │ │ drawRectangle: function(node, geometry) { │ │ │ │ var resolution = this.getResolution(); │ │ │ │ - var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = this.top - geometry.y / resolution; │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - node.setAttributeNS(null, "x", x); │ │ │ │ - node.setAttributeNS(null, "y", y); │ │ │ │ - node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ - node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ - return node │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ - } │ │ │ │ + node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ + node.style.top = (geometry.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ + node.style.width = (geometry.width / resolution | 0) + "px"; │ │ │ │ + node.style.height = (geometry.height / resolution | 0) + "px"; │ │ │ │ + return node │ │ │ │ }, │ │ │ │ drawText: function(featureId, style, location) { │ │ │ │ - var drawOutline = !!style.labelOutlineWidth; │ │ │ │ - if (drawOutline) { │ │ │ │ - var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ - outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ - outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ - if (style.labelOutlineOpacity) { │ │ │ │ - outlineStyle.fontOpacity = style.labelOutlineOpacity │ │ │ │ - } │ │ │ │ - delete outlineStyle.labelOutlineWidth; │ │ │ │ - this.drawText(featureId, outlineStyle, location) │ │ │ │ - } │ │ │ │ + var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect"); │ │ │ │ + var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox"); │ │ │ │ var resolution = this.getResolution(); │ │ │ │ - var x = (location.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = location.y / resolution - this.top; │ │ │ │ - var suffix = drawOutline ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ - var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ - label.setAttributeNS(null, "x", x); │ │ │ │ - label.setAttributeNS(null, "y", -y); │ │ │ │ - if (style.fontColor) { │ │ │ │ - label.setAttributeNS(null, "fill", style.fontColor) │ │ │ │ - } │ │ │ │ - if (style.fontStrokeColor) { │ │ │ │ - label.setAttributeNS(null, "stroke", style.fontStrokeColor) │ │ │ │ + label.style.left = ((location.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ + label.style.top = (location.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ + label.style.flip = "y"; │ │ │ │ + textbox.innerText = style.label; │ │ │ │ + if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ + textbox.style.cursor = style.cursor │ │ │ │ } │ │ │ │ - if (style.fontStrokeWidth) { │ │ │ │ - label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth) │ │ │ │ + if (style.fontColor) { │ │ │ │ + textbox.style.color = style.fontColor │ │ │ │ } │ │ │ │ if (style.fontOpacity) { │ │ │ │ - label.setAttributeNS(null, "opacity", style.fontOpacity) │ │ │ │ + textbox.style.filter = "alpha(opacity=" + style.fontOpacity * 100 + ")" │ │ │ │ } │ │ │ │ if (style.fontFamily) { │ │ │ │ - label.setAttributeNS(null, "font-family", style.fontFamily) │ │ │ │ + textbox.style.fontFamily = style.fontFamily │ │ │ │ } │ │ │ │ if (style.fontSize) { │ │ │ │ - label.setAttributeNS(null, "font-size", style.fontSize) │ │ │ │ + textbox.style.fontSize = style.fontSize │ │ │ │ } │ │ │ │ if (style.fontWeight) { │ │ │ │ - label.setAttributeNS(null, "font-weight", style.fontWeight) │ │ │ │ + textbox.style.fontWeight = style.fontWeight │ │ │ │ } │ │ │ │ if (style.fontStyle) { │ │ │ │ - label.setAttributeNS(null, "font-style", style.fontStyle) │ │ │ │ + textbox.style.fontStyle = style.fontStyle │ │ │ │ } │ │ │ │ if (style.labelSelect === true) { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ - label._featureId = featureId │ │ │ │ - } else { │ │ │ │ - label.setAttributeNS(null, "pointer-events", "none") │ │ │ │ - } │ │ │ │ - var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ - label.setAttributeNS(null, "text-anchor", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ - if (OpenLayers.IS_GECKO === true) { │ │ │ │ - label.setAttributeNS(null, "dominant-baseline", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central") │ │ │ │ - } │ │ │ │ - var labelRows = style.label.split("\n"); │ │ │ │ - var numRows = labelRows.length; │ │ │ │ - while (label.childNodes.length > numRows) { │ │ │ │ - label.removeChild(label.lastChild) │ │ │ │ - } │ │ │ │ - for (var i = 0; i < numRows; i++) { │ │ │ │ - var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ - if (style.labelSelect === true) { │ │ │ │ - tspan._featureId = featureId; │ │ │ │ - tspan._geometry = location; │ │ │ │ - tspan._geometryClass = location.CLASS_NAME │ │ │ │ - } │ │ │ │ - if (OpenLayers.IS_GECKO === false) { │ │ │ │ - tspan.setAttributeNS(null, "baseline-shift", OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%") │ │ │ │ - } │ │ │ │ - tspan.setAttribute("x", x); │ │ │ │ - if (i == 0) { │ │ │ │ - var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ - if (vfactor == null) { │ │ │ │ - vfactor = -.5 │ │ │ │ - } │ │ │ │ - tspan.setAttribute("dy", vfactor * (numRows - 1) + "em") │ │ │ │ - } else { │ │ │ │ - tspan.setAttribute("dy", "1em") │ │ │ │ - } │ │ │ │ - tspan.textContent = labelRows[i] === "" ? " " : labelRows[i]; │ │ │ │ - if (!tspan.parentNode) { │ │ │ │ - label.appendChild(tspan) │ │ │ │ - } │ │ │ │ + label._featureId = featureId; │ │ │ │ + textbox._featureId = featureId; │ │ │ │ + textbox._geometry = location; │ │ │ │ + textbox._geometryClass = location.CLASS_NAME │ │ │ │ } │ │ │ │ + textbox.style.whiteSpace = "nowrap"; │ │ │ │ + textbox.inset = "1px,0px,0px,0px"; │ │ │ │ if (!label.parentNode) { │ │ │ │ + label.appendChild(textbox); │ │ │ │ this.textRoot.appendChild(label) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - getComponentsString: function(components, separator) { │ │ │ │ - var renderCmp = []; │ │ │ │ - var complete = true; │ │ │ │ - var len = components.length; │ │ │ │ - var strings = []; │ │ │ │ - var str, component; │ │ │ │ - for (var i = 0; i < len; i++) { │ │ │ │ - component = components[i]; │ │ │ │ - renderCmp.push(component); │ │ │ │ - str = this.getShortString(component); │ │ │ │ - if (str) { │ │ │ │ - strings.push(str) │ │ │ │ - } else { │ │ │ │ - if (i > 0) { │ │ │ │ - if (this.getShortString(components[i - 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], components[i - 1])) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (i < len - 1) { │ │ │ │ - if (this.getShortString(components[i + 1])) { │ │ │ │ - strings.push(this.clipLine(components[i], components[i + 1])) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - complete = false │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return { │ │ │ │ - path: strings.join(separator || ","), │ │ │ │ - complete: complete │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - clipLine: function(badComponent, goodComponent) { │ │ │ │ - if (goodComponent.equals(badComponent)) { │ │ │ │ - return "" │ │ │ │ - } │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ - var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ - var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y1 = this.top - goodComponent.y / resolution; │ │ │ │ - var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y2 = this.top - badComponent.y / resolution; │ │ │ │ - var k; │ │ │ │ - if (x2 < -maxX || x2 > maxX) { │ │ │ │ - k = (y2 - y1) / (x2 - x1); │ │ │ │ - x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ - y2 = y1 + (x2 - x1) * k │ │ │ │ - } │ │ │ │ - if (y2 < -maxY || y2 > maxY) { │ │ │ │ - k = (x2 - x1) / (y2 - y1); │ │ │ │ - y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ - x2 = x1 + (y2 - y1) * k │ │ │ │ - } │ │ │ │ - return x2 + "," + y2 │ │ │ │ - }, │ │ │ │ - getShortString: function(point) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var x = (point.x - this.featureDx) / resolution + this.left; │ │ │ │ - var y = this.top - point.y / resolution; │ │ │ │ - if (this.inValidRange(x, y)) { │ │ │ │ - return x + "," + y │ │ │ │ - } else { │ │ │ │ - return false │ │ │ │ + var align = style.labelAlign || "cm"; │ │ │ │ + if (align.length == 1) { │ │ │ │ + align += "m" │ │ │ │ } │ │ │ │ + var xshift = textbox.clientWidth * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)]; │ │ │ │ + var yshift = textbox.clientHeight * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)]; │ │ │ │ + label.style.left = parseInt(label.style.left) - xshift - 1 + "px"; │ │ │ │ + label.style.top = parseInt(label.style.top) + yshift + "px" │ │ │ │ }, │ │ │ │ - getPosition: function(node) { │ │ │ │ - return { │ │ │ │ - x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ - y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ + moveRoot: function(renderer) { │ │ │ │ + var layer = this.map.getLayer(renderer.container.id); │ │ │ │ + if (layer instanceof OpenLayers.Layer.Vector.RootContainer) { │ │ │ │ + layer = this.map.getLayer(this.container.id) │ │ │ │ } │ │ │ │ + layer && layer.renderer.clear(); │ │ │ │ + OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments); │ │ │ │ + layer && layer.redraw() │ │ │ │ }, │ │ │ │ importSymbol: function(graphicName) { │ │ │ │ - if (!this.defs) { │ │ │ │ - this.defs = this.createDefs() │ │ │ │ - } │ │ │ │ var id = this.container.id + "-" + graphicName; │ │ │ │ - var existing = document.getElementById(id); │ │ │ │ - if (existing != null) { │ │ │ │ - return existing │ │ │ │ + var cache = this.symbolCache[id]; │ │ │ │ + if (cache) { │ │ │ │ + return cache │ │ │ │ } │ │ │ │ var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ if (!symbol) { │ │ │ │ throw new Error(graphicName + " is not a valid symbol name") │ │ │ │ } │ │ │ │ - var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ - var node = this.nodeFactory(null, "polygon"); │ │ │ │ - symbolNode.appendChild(node); │ │ │ │ var symbolExtent = new OpenLayers.Bounds(Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ - var points = []; │ │ │ │ - var x, y; │ │ │ │ + var pathitems = ["m"]; │ │ │ │ for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - x = symbol[i]; │ │ │ │ - y = symbol[i + 1]; │ │ │ │ + var x = symbol[i]; │ │ │ │ + var y = symbol[i + 1]; │ │ │ │ symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - points.push(x, ",", y) │ │ │ │ + pathitems.push(x); │ │ │ │ + pathitems.push(y); │ │ │ │ + if (i == 0) { │ │ │ │ + pathitems.push("l") │ │ │ │ + } │ │ │ │ } │ │ │ │ - node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ - var width = symbolExtent.getWidth(); │ │ │ │ - var height = symbolExtent.getHeight(); │ │ │ │ - var viewBox = [symbolExtent.left - width, symbolExtent.bottom - height, width * 3, height * 3]; │ │ │ │ - symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ - this.symbolMetrics[id] = [Math.max(width, height), symbolExtent.getCenterLonLat().lon, symbolExtent.getCenterLonLat().lat]; │ │ │ │ - this.defs.appendChild(symbolNode); │ │ │ │ - return symbolNode │ │ │ │ - }, │ │ │ │ - getFeatureIdFromEvent: function(evt) { │ │ │ │ - var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ - if (!featureId) { │ │ │ │ - var target = evt.target; │ │ │ │ - featureId = target.parentNode && target != this.rendererRoot ? target.parentNode._featureId : undefined │ │ │ │ + pathitems.push("x e"); │ │ │ │ + var path = pathitems.join(" "); │ │ │ │ + var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2; │ │ │ │ + if (diff > 0) { │ │ │ │ + symbolExtent.bottom = symbolExtent.bottom - diff; │ │ │ │ + symbolExtent.top = symbolExtent.top + diff │ │ │ │ + } else { │ │ │ │ + symbolExtent.left = symbolExtent.left + diff; │ │ │ │ + symbolExtent.right = symbolExtent.right - diff │ │ │ │ } │ │ │ │ - return featureId │ │ │ │ + cache = { │ │ │ │ + path: path, │ │ │ │ + size: symbolExtent.getWidth(), │ │ │ │ + left: symbolExtent.left, │ │ │ │ + bottom: symbolExtent.bottom │ │ │ │ + }; │ │ │ │ + this.symbolCache[id] = cache; │ │ │ │ + return cache │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.VML" │ │ │ │ }); │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ - l: "start", │ │ │ │ - r: "end", │ │ │ │ - b: "bottom", │ │ │ │ - t: "hanging" │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ - t: "-70%", │ │ │ │ - b: "0" │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ +OpenLayers.Renderer.VML.LABEL_SHIFT = { │ │ │ │ + l: 0, │ │ │ │ + c: .5, │ │ │ │ + r: 1, │ │ │ │ t: 0, │ │ │ │ - b: -1 │ │ │ │ -}; │ │ │ │ -OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ - OpenLayers.Event.preventDefault(e) │ │ │ │ + m: .5, │ │ │ │ + b: 1 │ │ │ │ }; │ │ │ │ OpenLayers.Renderer.Canvas = OpenLayers.Class(OpenLayers.Renderer, { │ │ │ │ hitDetection: true, │ │ │ │ hitOverflow: 0, │ │ │ │ canvas: null, │ │ │ │ features: null, │ │ │ │ pendingRedraw: false, │ │ │ │ @@ -29564,8586 +31748,6402 @@ │ │ │ │ OpenLayers.Renderer.Canvas.LABEL_FACTOR = { │ │ │ │ l: 0, │ │ │ │ r: -1, │ │ │ │ t: 0, │ │ │ │ b: -1 │ │ │ │ }; │ │ │ │ OpenLayers.Renderer.Canvas.drawImageScaleFactor = null; │ │ │ │ -OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ - xmlns: "urn:schemas-microsoft-com:vml", │ │ │ │ - symbolCache: {}, │ │ │ │ - offset: null, │ │ │ │ +OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, { │ │ │ │ + xmlns: "http://www.w3.org/2000/svg", │ │ │ │ + xlinkns: "http://www.w3.org/1999/xlink", │ │ │ │ + MAX_PIXEL: 15e3, │ │ │ │ + translationParameters: null, │ │ │ │ + symbolMetrics: null, │ │ │ │ initialize: function(containerID) { │ │ │ │ if (!this.supported()) { │ │ │ │ return │ │ │ │ } │ │ │ │ - if (!document.namespaces.olv) { │ │ │ │ - document.namespaces.add("olv", this.xmlns); │ │ │ │ - var style = document.createStyleSheet(); │ │ │ │ - var shapes = ["shape", "rect", "oval", "fill", "stroke", "imagedata", "group", "textbox"]; │ │ │ │ - for (var i = 0, len = shapes.length; i < len; i++) { │ │ │ │ - style.addRule("olv\\:" + shapes[i], "behavior: url(#default#VML); " + "position: absolute; display: inline-block;") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments) │ │ │ │ + OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: 0, │ │ │ │ + y: 0 │ │ │ │ + }; │ │ │ │ + this.symbolMetrics = {} │ │ │ │ }, │ │ │ │ supported: function() { │ │ │ │ - return !!document.namespaces │ │ │ │ + var svgFeature = "http://www.w3.org/TR/SVG11/feature#"; │ │ │ │ + return document.implementation && (document.implementation.hasFeature("org.w3c.svg", "1.0") || document.implementation.hasFeature(svgFeature + "SVG", "1.1") || document.implementation.hasFeature(svgFeature + "BasicStructure", "1.1")) │ │ │ │ + }, │ │ │ │ + inValidRange: function(x, y, xyOnly) { │ │ │ │ + var left = x + (xyOnly ? 0 : this.translationParameters.x); │ │ │ │ + var top = y + (xyOnly ? 0 : this.translationParameters.y); │ │ │ │ + return left >= -this.MAX_PIXEL && left <= this.MAX_PIXEL && top >= -this.MAX_PIXEL && top <= this.MAX_PIXEL │ │ │ │ }, │ │ │ │ setExtent: function(extent, resolutionChanged) { │ │ │ │ var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(this, arguments); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var left = extent.left / resolution | 0; │ │ │ │ - var top = extent.top / resolution - this.size.h | 0; │ │ │ │ - if (resolutionChanged || !this.offset) { │ │ │ │ - this.offset = { │ │ │ │ - x: left, │ │ │ │ - y: top │ │ │ │ - }; │ │ │ │ - left = 0; │ │ │ │ - top = 0 │ │ │ │ + var resolution = this.getResolution(), │ │ │ │ + left = -extent.left / resolution, │ │ │ │ + top = extent.top / resolution; │ │ │ │ + if (resolutionChanged) { │ │ │ │ + this.left = left; │ │ │ │ + this.top = top; │ │ │ │ + var extentString = "0 0 " + this.size.w + " " + this.size.h; │ │ │ │ + this.rendererRoot.setAttributeNS(null, "viewBox", extentString); │ │ │ │ + this.translate(this.xOffset, 0); │ │ │ │ + return true │ │ │ │ } else { │ │ │ │ - left = left - this.offset.x; │ │ │ │ - top = top - this.offset.y │ │ │ │ + var inRange = this.translate(left - this.left + this.xOffset, top - this.top); │ │ │ │ + if (!inRange) { │ │ │ │ + this.setExtent(extent, true) │ │ │ │ + } │ │ │ │ + return coordSysUnchanged && inRange │ │ │ │ } │ │ │ │ - var org = left - this.xOffset + " " + top; │ │ │ │ - this.root.coordorigin = org; │ │ │ │ - var roots = [this.root, this.vectorRoot, this.textRoot]; │ │ │ │ - var root; │ │ │ │ - for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ - root = roots[i]; │ │ │ │ - var size = this.size.w + " " + this.size.h; │ │ │ │ - root.coordsize = size │ │ │ │ + }, │ │ │ │ + translate: function(x, y) { │ │ │ │ + if (!this.inValidRange(x, y, true)) { │ │ │ │ + return false │ │ │ │ + } else { │ │ │ │ + var transformString = ""; │ │ │ │ + if (x || y) { │ │ │ │ + transformString = "translate(" + x + "," + y + ")" │ │ │ │ + } │ │ │ │ + this.root.setAttributeNS(null, "transform", transformString); │ │ │ │ + this.translationParameters = { │ │ │ │ + x: x, │ │ │ │ + y: y │ │ │ │ + }; │ │ │ │ + return true │ │ │ │ } │ │ │ │ - this.root.style.flip = "y"; │ │ │ │ - return coordSysUnchanged │ │ │ │ }, │ │ │ │ setSize: function(size) { │ │ │ │ OpenLayers.Renderer.prototype.setSize.apply(this, arguments); │ │ │ │ - var roots = [this.rendererRoot, this.root, this.vectorRoot, this.textRoot]; │ │ │ │ - var w = this.size.w + "px"; │ │ │ │ - var h = this.size.h + "px"; │ │ │ │ - var root; │ │ │ │ - for (var i = 0, len = roots.length; i < len; ++i) { │ │ │ │ - root = roots[i]; │ │ │ │ - root.style.width = w; │ │ │ │ - root.style.height = h │ │ │ │ - } │ │ │ │ + this.rendererRoot.setAttributeNS(null, "width", this.size.w); │ │ │ │ + this.rendererRoot.setAttributeNS(null, "height", this.size.h) │ │ │ │ }, │ │ │ │ getNodeType: function(geometry, style) { │ │ │ │ var nodeType = null; │ │ │ │ switch (geometry.CLASS_NAME) { │ │ │ │ case "OpenLayers.Geometry.Point": │ │ │ │ if (style.externalGraphic) { │ │ │ │ - nodeType = "olv:rect" │ │ │ │ + nodeType = "image" │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - nodeType = "olv:shape" │ │ │ │ + nodeType = "svg" │ │ │ │ } else { │ │ │ │ - nodeType = "olv:oval" │ │ │ │ + nodeType = "circle" │ │ │ │ } │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.Rectangle": │ │ │ │ - nodeType = "olv:rect"; │ │ │ │ + nodeType = "rect"; │ │ │ │ break; │ │ │ │ case "OpenLayers.Geometry.LineString": │ │ │ │ + nodeType = "polyline"; │ │ │ │ + break; │ │ │ │ case "OpenLayers.Geometry.LinearRing": │ │ │ │ + nodeType = "polygon"; │ │ │ │ + break; │ │ │ │ case "OpenLayers.Geometry.Polygon": │ │ │ │ case "OpenLayers.Geometry.Curve": │ │ │ │ - nodeType = "olv:shape"; │ │ │ │ + nodeType = "path"; │ │ │ │ break; │ │ │ │ default: │ │ │ │ break │ │ │ │ } │ │ │ │ return nodeType │ │ │ │ }, │ │ │ │ - setStyle: function(node, style, options, geometry) { │ │ │ │ + setStyle: function(node, style, options) { │ │ │ │ style = style || node._style; │ │ │ │ options = options || node._options; │ │ │ │ - var fillColor = style.fillColor; │ │ │ │ var title = style.title || style.graphicTitle; │ │ │ │ if (title) { │ │ │ │ - node.title = title │ │ │ │ + node.setAttributeNS(null, "title", title); │ │ │ │ + var titleNode = node.getElementsByTagName("title"); │ │ │ │ + if (titleNode.length > 0) { │ │ │ │ + titleNode[0].firstChild.textContent = title │ │ │ │ + } else { │ │ │ │ + var label = this.nodeFactory(null, "title"); │ │ │ │ + label.textContent = title; │ │ │ │ + node.appendChild(label) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - options.isFilled = true; │ │ │ │ + var r = parseFloat(node.getAttributeNS(null, "r")); │ │ │ │ + var widthFactor = 1; │ │ │ │ + var pos; │ │ │ │ + if (node._geometryClass == "OpenLayers.Geometry.Point" && r) { │ │ │ │ + node.style.visibility = ""; │ │ │ │ + if (style.graphic === false) { │ │ │ │ + node.style.visibility = "hidden" │ │ │ │ + } else if (style.externalGraphic) { │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + if (style.graphicWidth && style.graphicHeight) { │ │ │ │ + node.setAttributeNS(null, "preserveAspectRatio", "none") │ │ │ │ + } │ │ │ │ var width = style.graphicWidth || style.graphicHeight; │ │ │ │ var height = style.graphicHeight || style.graphicWidth; │ │ │ │ width = width ? width : style.pointRadius * 2; │ │ │ │ height = height ? height : style.pointRadius * 2; │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ var xOffset = style.graphicXOffset != undefined ? style.graphicXOffset : -(.5 * width); │ │ │ │ var yOffset = style.graphicYOffset != undefined ? style.graphicYOffset : -(.5 * height); │ │ │ │ - node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x + xOffset | 0) + "px"; │ │ │ │ - node.style.top = (geometry.y / resolution - this.offset.y - (yOffset + height) | 0) + "px"; │ │ │ │ - node.style.width = width + "px"; │ │ │ │ - node.style.height = height + "px"; │ │ │ │ - node.style.flip = "y"; │ │ │ │ - fillColor = "none"; │ │ │ │ - options.isStroked = false │ │ │ │ + var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ + node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed()); │ │ │ │ + node.setAttributeNS(null, "width", width); │ │ │ │ + node.setAttributeNS(null, "height", height); │ │ │ │ + node.setAttributeNS(this.xlinkns, "xlink:href", style.externalGraphic); │ │ │ │ + node.setAttributeNS(null, "style", "opacity: " + opacity); │ │ │ │ + node.onclick = OpenLayers.Event.preventDefault │ │ │ │ } else if (this.isComplexSymbol(style.graphicName)) { │ │ │ │ - var cache = this.importSymbol(style.graphicName); │ │ │ │ - node.path = cache.path; │ │ │ │ - node.coordorigin = cache.left + "," + cache.bottom; │ │ │ │ - var size = cache.size; │ │ │ │ - node.coordsize = size + "," + size; │ │ │ │ - this.drawCircle(node, geometry, style.pointRadius); │ │ │ │ - node.style.flip = "y" │ │ │ │ - } else { │ │ │ │ - this.drawCircle(node, geometry, style.pointRadius) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (options.isFilled) { │ │ │ │ - node.fillcolor = fillColor │ │ │ │ - } else { │ │ │ │ - node.filled = "false" │ │ │ │ - } │ │ │ │ - var fills = node.getElementsByTagName("fill"); │ │ │ │ - var fill = fills.length == 0 ? null : fills[0]; │ │ │ │ - if (!options.isFilled) { │ │ │ │ - if (fill) { │ │ │ │ - node.removeChild(fill) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - if (!fill) { │ │ │ │ - fill = this.createNode("olv:fill", node.id + "_fill") │ │ │ │ - } │ │ │ │ - fill.opacity = style.fillOpacity; │ │ │ │ - if (node._geometryClass === "OpenLayers.Geometry.Point" && style.externalGraphic) { │ │ │ │ - if (style.graphicOpacity) { │ │ │ │ - fill.opacity = style.graphicOpacity │ │ │ │ + var offset = style.pointRadius * 3; │ │ │ │ + var size = offset * 2; │ │ │ │ + var src = this.importSymbol(style.graphicName); │ │ │ │ + pos = this.getPosition(node); │ │ │ │ + widthFactor = this.symbolMetrics[src.id][0] * 3 / size; │ │ │ │ + var parent = node.parentNode; │ │ │ │ + var nextSibling = node.nextSibling; │ │ │ │ + if (parent) { │ │ │ │ + parent.removeChild(node) │ │ │ │ } │ │ │ │ - fill.src = style.externalGraphic; │ │ │ │ - fill.type = "frame"; │ │ │ │ - if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ - fill.aspect = "atmost" │ │ │ │ + node.firstChild && node.removeChild(node.firstChild); │ │ │ │ + node.appendChild(src.firstChild.cloneNode(true)); │ │ │ │ + node.setAttributeNS(null, "viewBox", src.getAttributeNS(null, "viewBox")); │ │ │ │ + node.setAttributeNS(null, "width", size); │ │ │ │ + node.setAttributeNS(null, "height", size); │ │ │ │ + node.setAttributeNS(null, "x", pos.x - offset); │ │ │ │ + node.setAttributeNS(null, "y", pos.y - offset); │ │ │ │ + if (nextSibling) { │ │ │ │ + parent.insertBefore(node, nextSibling) │ │ │ │ + } else if (parent) { │ │ │ │ + parent.appendChild(node) │ │ │ │ } │ │ │ │ + } else { │ │ │ │ + node.setAttributeNS(null, "r", style.pointRadius) │ │ │ │ } │ │ │ │ - if (fill.parentNode != node) { │ │ │ │ - node.appendChild(fill) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var rotation = style.rotation; │ │ │ │ - if (rotation !== undefined || node._rotation !== undefined) { │ │ │ │ - node._rotation = rotation; │ │ │ │ - if (style.externalGraphic) { │ │ │ │ - this.graphicRotate(node, xOffset, yOffset, style); │ │ │ │ - fill.opacity = 0 │ │ │ │ - } else if (node._geometryClass === "OpenLayers.Geometry.Point") { │ │ │ │ - node.style.rotation = rotation || 0 │ │ │ │ + var rotation = style.rotation; │ │ │ │ + if ((rotation !== undefined || node._rotation !== undefined) && pos) { │ │ │ │ + node._rotation = rotation; │ │ │ │ + rotation |= 0; │ │ │ │ + if (node.nodeName !== "svg") { │ │ │ │ + node.setAttributeNS(null, "transform", "rotate(" + rotation + " " + pos.x + " " + pos.y + ")") │ │ │ │ + } else { │ │ │ │ + var metrics = this.symbolMetrics[src.id]; │ │ │ │ + node.firstChild.setAttributeNS(null, "transform", "rotate(" + rotation + " " + metrics[1] + " " + metrics[2] + ")") │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - var strokes = node.getElementsByTagName("stroke"); │ │ │ │ - var stroke = strokes.length == 0 ? null : strokes[0]; │ │ │ │ - if (!options.isStroked) { │ │ │ │ - node.stroked = false; │ │ │ │ - if (stroke) { │ │ │ │ - stroke.on = false │ │ │ │ - } │ │ │ │ + if (options.isFilled) { │ │ │ │ + node.setAttributeNS(null, "fill", style.fillColor); │ │ │ │ + node.setAttributeNS(null, "fill-opacity", style.fillOpacity) │ │ │ │ } else { │ │ │ │ - if (!stroke) { │ │ │ │ - stroke = this.createNode("olv:stroke", node.id + "_stroke"); │ │ │ │ - node.appendChild(stroke) │ │ │ │ - } │ │ │ │ - stroke.on = true; │ │ │ │ - stroke.color = style.strokeColor; │ │ │ │ - stroke.weight = style.strokeWidth + "px"; │ │ │ │ - stroke.opacity = style.strokeOpacity; │ │ │ │ - stroke.endcap = style.strokeLinecap == "butt" ? "flat" : style.strokeLinecap || "round"; │ │ │ │ - if (style.strokeDashstyle) { │ │ │ │ - stroke.dashstyle = this.dashStyle(style) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ - node.style.cursor = style.cursor │ │ │ │ + node.setAttributeNS(null, "fill", "none") │ │ │ │ } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - graphicRotate: function(node, xOffset, yOffset, style) { │ │ │ │ - var style = style || node._style; │ │ │ │ - var rotation = style.rotation || 0; │ │ │ │ - var aspectRatio, size; │ │ │ │ - if (!(style.graphicWidth && style.graphicHeight)) { │ │ │ │ - var img = new Image; │ │ │ │ - img.onreadystatechange = OpenLayers.Function.bind(function() { │ │ │ │ - if (img.readyState == "complete" || img.readyState == "interactive") { │ │ │ │ - aspectRatio = img.width / img.height; │ │ │ │ - size = Math.max(style.pointRadius * 2, style.graphicWidth || 0, style.graphicHeight || 0); │ │ │ │ - xOffset = xOffset * aspectRatio; │ │ │ │ - style.graphicWidth = size * aspectRatio; │ │ │ │ - style.graphicHeight = size; │ │ │ │ - this.graphicRotate(node, xOffset, yOffset, style) │ │ │ │ - } │ │ │ │ - }, this); │ │ │ │ - img.src = style.externalGraphic; │ │ │ │ - return │ │ │ │ + if (options.isStroked) { │ │ │ │ + node.setAttributeNS(null, "stroke", style.strokeColor); │ │ │ │ + node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity); │ │ │ │ + node.setAttributeNS(null, "stroke-width", style.strokeWidth * widthFactor); │ │ │ │ + node.setAttributeNS(null, "stroke-linecap", style.strokeLinecap || "round"); │ │ │ │ + node.setAttributeNS(null, "stroke-linejoin", "round"); │ │ │ │ + style.strokeDashstyle && node.setAttributeNS(null, "stroke-dasharray", this.dashStyle(style, widthFactor)) │ │ │ │ } else { │ │ │ │ - size = Math.max(style.graphicWidth, style.graphicHeight); │ │ │ │ - aspectRatio = style.graphicWidth / style.graphicHeight │ │ │ │ - } │ │ │ │ - var width = Math.round(style.graphicWidth || size * aspectRatio); │ │ │ │ - var height = Math.round(style.graphicHeight || size); │ │ │ │ - node.style.width = width + "px"; │ │ │ │ - node.style.height = height + "px"; │ │ │ │ - var image = document.getElementById(node.id + "_image"); │ │ │ │ - if (!image) { │ │ │ │ - image = this.createNode("olv:imagedata", node.id + "_image"); │ │ │ │ - node.appendChild(image) │ │ │ │ - } │ │ │ │ - image.style.width = width + "px"; │ │ │ │ - image.style.height = height + "px"; │ │ │ │ - image.src = style.externalGraphic; │ │ │ │ - image.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + "src='', sizingMethod='scale')"; │ │ │ │ - var rot = rotation * Math.PI / 180; │ │ │ │ - var sintheta = Math.sin(rot); │ │ │ │ - var costheta = Math.cos(rot); │ │ │ │ - var filter = "progid:DXImageTransform.Microsoft.Matrix(M11=" + costheta + ",M12=" + -sintheta + ",M21=" + sintheta + ",M22=" + costheta + ",SizingMethod='auto expand')\n"; │ │ │ │ - var opacity = style.graphicOpacity || style.fillOpacity; │ │ │ │ - if (opacity && opacity != 1) { │ │ │ │ - filter += "progid:DXImageTransform.Microsoft.BasicImage(opacity=" + opacity + ")\n" │ │ │ │ - } │ │ │ │ - node.style.filter = filter; │ │ │ │ - var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset); │ │ │ │ - var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry(); │ │ │ │ - imgBox.rotate(style.rotation, centerPoint); │ │ │ │ - var imgBounds = imgBox.getBounds(); │ │ │ │ - node.style.left = Math.round(parseInt(node.style.left) + imgBounds.left) + "px"; │ │ │ │ - node.style.top = Math.round(parseInt(node.style.top) - imgBounds.bottom) + "px" │ │ │ │ - }, │ │ │ │ - postDraw: function(node) { │ │ │ │ - node.style.visibility = "visible"; │ │ │ │ - var fillColor = node._style.fillColor; │ │ │ │ - var strokeColor = node._style.strokeColor; │ │ │ │ - if (fillColor == "none" && node.fillcolor != fillColor) { │ │ │ │ - node.fillcolor = fillColor │ │ │ │ + node.setAttributeNS(null, "stroke", "none") │ │ │ │ } │ │ │ │ - if (strokeColor == "none" && node.strokecolor != strokeColor) { │ │ │ │ - node.strokecolor = strokeColor │ │ │ │ + if (style.pointerEvents) { │ │ │ │ + node.setAttributeNS(null, "pointer-events", style.pointerEvents) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - setNodeDimension: function(node, geometry) { │ │ │ │ - var bbox = geometry.getBounds(); │ │ │ │ - if (bbox) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var scaledBox = new OpenLayers.Bounds((bbox.left - this.featureDx) / resolution - this.offset.x | 0, bbox.bottom / resolution - this.offset.y | 0, (bbox.right - this.featureDx) / resolution - this.offset.x | 0, bbox.top / resolution - this.offset.y | 0); │ │ │ │ - node.style.left = scaledBox.left + "px"; │ │ │ │ - node.style.top = scaledBox.top + "px"; │ │ │ │ - node.style.width = scaledBox.getWidth() + "px"; │ │ │ │ - node.style.height = scaledBox.getHeight() + "px"; │ │ │ │ - node.coordorigin = scaledBox.left + " " + scaledBox.top; │ │ │ │ - node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight() │ │ │ │ + if (style.cursor != null) { │ │ │ │ + node.setAttributeNS(null, "cursor", style.cursor) │ │ │ │ } │ │ │ │ + return node │ │ │ │ }, │ │ │ │ - dashStyle: function(style) { │ │ │ │ - var dash = style.strokeDashstyle; │ │ │ │ - switch (dash) { │ │ │ │ + dashStyle: function(style, widthFactor) { │ │ │ │ + var w = style.strokeWidth * widthFactor; │ │ │ │ + var str = style.strokeDashstyle; │ │ │ │ + switch (str) { │ │ │ │ case "solid": │ │ │ │ + return "none"; │ │ │ │ case "dot": │ │ │ │ + return [1, 4 * w].join(); │ │ │ │ case "dash": │ │ │ │ + return [4 * w, 4 * w].join(); │ │ │ │ case "dashdot": │ │ │ │ + return [4 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ case "longdash": │ │ │ │ + return [8 * w, 4 * w].join(); │ │ │ │ case "longdashdot": │ │ │ │ - return dash; │ │ │ │ + return [8 * w, 4 * w, 1, 4 * w].join(); │ │ │ │ default: │ │ │ │ - var parts = dash.split(/[ ,]/); │ │ │ │ - if (parts.length == 2) { │ │ │ │ - if (1 * parts[0] >= 2 * parts[1]) { │ │ │ │ - return "longdash" │ │ │ │ - } │ │ │ │ - return parts[0] == 1 || parts[1] == 1 ? "dot" : "dash" │ │ │ │ - } else if (parts.length == 4) { │ │ │ │ - return 1 * parts[0] >= 2 * parts[1] ? "longdashdot" : "dashdot" │ │ │ │ - } │ │ │ │ - return "solid" │ │ │ │ + return OpenLayers.String.trim(str).replace(/\s+/g, ",") │ │ │ │ } │ │ │ │ }, │ │ │ │ createNode: function(type, id) { │ │ │ │ - var node = document.createElement(type); │ │ │ │ + var node = document.createElementNS(this.xmlns, type); │ │ │ │ if (id) { │ │ │ │ - node.id = id │ │ │ │ + node.setAttributeNS(null, "id", id) │ │ │ │ } │ │ │ │ - node.unselectable = "on"; │ │ │ │ - node.onselectstart = OpenLayers.Function.False; │ │ │ │ return node │ │ │ │ }, │ │ │ │ nodeTypeCompare: function(node, type) { │ │ │ │ - var subType = type; │ │ │ │ - var splitIndex = subType.indexOf(":"); │ │ │ │ - if (splitIndex != -1) { │ │ │ │ - subType = subType.substr(splitIndex + 1) │ │ │ │ - } │ │ │ │ - var nodeName = node.nodeName; │ │ │ │ - splitIndex = nodeName.indexOf(":"); │ │ │ │ - if (splitIndex != -1) { │ │ │ │ - nodeName = nodeName.substr(splitIndex + 1) │ │ │ │ - } │ │ │ │ - return subType == nodeName │ │ │ │ + return type == node.nodeName │ │ │ │ }, │ │ │ │ createRenderRoot: function() { │ │ │ │ - return this.nodeFactory(this.container.id + "_vmlRoot", "div") │ │ │ │ + var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg"); │ │ │ │ + svg.style.display = "block"; │ │ │ │ + return svg │ │ │ │ }, │ │ │ │ createRoot: function(suffix) { │ │ │ │ - return this.nodeFactory(this.container.id + suffix, "olv:group") │ │ │ │ + return this.nodeFactory(this.container.id + suffix, "g") │ │ │ │ + }, │ │ │ │ + createDefs: function() { │ │ │ │ + var defs = this.nodeFactory(this.container.id + "_defs", "defs"); │ │ │ │ + this.rendererRoot.appendChild(defs); │ │ │ │ + return defs │ │ │ │ }, │ │ │ │ drawPoint: function(node, geometry) { │ │ │ │ return this.drawCircle(node, geometry, 1) │ │ │ │ }, │ │ │ │ drawCircle: function(node, geometry, radius) { │ │ │ │ - if (!isNaN(geometry.x) && !isNaN(geometry.y)) { │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) - radius + "px"; │ │ │ │ - node.style.top = (geometry.y / resolution - this.offset.y | 0) - radius + "px"; │ │ │ │ - var diameter = radius * 2; │ │ │ │ - node.style.width = diameter + "px"; │ │ │ │ - node.style.height = diameter + "px"; │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = this.top - geometry.y / resolution; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "cx", x); │ │ │ │ + node.setAttributeNS(null, "cy", y); │ │ │ │ + node.setAttributeNS(null, "r", radius); │ │ │ │ return node │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - return false │ │ │ │ }, │ │ │ │ drawLineString: function(node, geometry) { │ │ │ │ - return this.drawLine(node, geometry, false) │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return componentsResult.complete ? node : null │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ }, │ │ │ │ drawLinearRing: function(node, geometry) { │ │ │ │ - return this.drawLine(node, geometry, true) │ │ │ │ - }, │ │ │ │ - drawLine: function(node, geometry, closeLine) { │ │ │ │ - this.setNodeDimension(node, geometry); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var numComponents = geometry.components.length; │ │ │ │ - var parts = new Array(numComponents); │ │ │ │ - var comp, x, y; │ │ │ │ - for (var i = 0; i < numComponents; i++) { │ │ │ │ - comp = geometry.components[i]; │ │ │ │ - x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ - y = comp.y / resolution - this.offset.y | 0; │ │ │ │ - parts[i] = " " + x + "," + y + " l " │ │ │ │ + var componentsResult = this.getComponentsString(geometry.components); │ │ │ │ + if (componentsResult.path) { │ │ │ │ + node.setAttributeNS(null, "points", componentsResult.path); │ │ │ │ + return componentsResult.complete ? node : null │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - var end = closeLine ? " x e" : " e"; │ │ │ │ - node.path = "m" + parts.join("") + end; │ │ │ │ - return node │ │ │ │ }, │ │ │ │ drawPolygon: function(node, geometry) { │ │ │ │ - this.setNodeDimension(node, geometry); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - var path = []; │ │ │ │ - var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y; │ │ │ │ - for (j = 0, jj = geometry.components.length; j < jj; j++) { │ │ │ │ - path.push("m"); │ │ │ │ - points = geometry.components[j].components; │ │ │ │ - area = j === 0; │ │ │ │ - first = null; │ │ │ │ - second = null; │ │ │ │ - for (i = 0, ii = points.length; i < ii; i++) { │ │ │ │ - comp = points[i]; │ │ │ │ - x = (comp.x - this.featureDx) / resolution - this.offset.x | 0; │ │ │ │ - y = comp.y / resolution - this.offset.y | 0; │ │ │ │ - pathComp = " " + x + "," + y; │ │ │ │ - path.push(pathComp); │ │ │ │ - if (i == 0) { │ │ │ │ - path.push(" l") │ │ │ │ - } │ │ │ │ - if (!area) { │ │ │ │ - if (!first) { │ │ │ │ - first = pathComp │ │ │ │ - } else if (first != pathComp) { │ │ │ │ - if (!second) { │ │ │ │ - second = pathComp │ │ │ │ - } else if (second != pathComp) { │ │ │ │ - area = true │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var d = ""; │ │ │ │ + var draw = true; │ │ │ │ + var complete = true; │ │ │ │ + var linearRingResult, path; │ │ │ │ + for (var j = 0, len = geometry.components.length; j < len; j++) { │ │ │ │ + d += " M"; │ │ │ │ + linearRingResult = this.getComponentsString(geometry.components[j].components, " "); │ │ │ │ + path = linearRingResult.path; │ │ │ │ + if (path) { │ │ │ │ + d += " " + path; │ │ │ │ + complete = linearRingResult.complete && complete │ │ │ │ + } else { │ │ │ │ + draw = false │ │ │ │ } │ │ │ │ - path.push(area ? " x " : " ") │ │ │ │ } │ │ │ │ - path.push("e"); │ │ │ │ - node.path = path.join(""); │ │ │ │ - return node │ │ │ │ + d += " z"; │ │ │ │ + if (draw) { │ │ │ │ + node.setAttributeNS(null, "d", d); │ │ │ │ + node.setAttributeNS(null, "fill-rule", "evenodd"); │ │ │ │ + return complete ? node : null │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ }, │ │ │ │ drawRectangle: function(node, geometry) { │ │ │ │ var resolution = this.getResolution(); │ │ │ │ - node.style.left = ((geometry.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ - node.style.top = (geometry.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ - node.style.width = (geometry.width / resolution | 0) + "px"; │ │ │ │ - node.style.height = (geometry.height / resolution | 0) + "px"; │ │ │ │ - return node │ │ │ │ + var x = (geometry.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = this.top - geometry.y / resolution; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + node.setAttributeNS(null, "x", x); │ │ │ │ + node.setAttributeNS(null, "y", y); │ │ │ │ + node.setAttributeNS(null, "width", geometry.width / resolution); │ │ │ │ + node.setAttributeNS(null, "height", geometry.height / resolution); │ │ │ │ + return node │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ }, │ │ │ │ drawText: function(featureId, style, location) { │ │ │ │ - var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect"); │ │ │ │ - var textbox = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX + "_textbox", "olv:textbox"); │ │ │ │ - var resolution = this.getResolution(); │ │ │ │ - label.style.left = ((location.x - this.featureDx) / resolution - this.offset.x | 0) + "px"; │ │ │ │ - label.style.top = (location.y / resolution - this.offset.y | 0) + "px"; │ │ │ │ - label.style.flip = "y"; │ │ │ │ - textbox.innerText = style.label; │ │ │ │ - if (style.cursor != "inherit" && style.cursor != null) { │ │ │ │ - textbox.style.cursor = style.cursor │ │ │ │ + var drawOutline = !!style.labelOutlineWidth; │ │ │ │ + if (drawOutline) { │ │ │ │ + var outlineStyle = OpenLayers.Util.extend({}, style); │ │ │ │ + outlineStyle.fontColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor; │ │ │ │ + outlineStyle.fontStrokeWidth = style.labelOutlineWidth; │ │ │ │ + if (style.labelOutlineOpacity) { │ │ │ │ + outlineStyle.fontOpacity = style.labelOutlineOpacity │ │ │ │ + } │ │ │ │ + delete outlineStyle.labelOutlineWidth; │ │ │ │ + this.drawText(featureId, outlineStyle, location) │ │ │ │ } │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (location.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = location.y / resolution - this.top; │ │ │ │ + var suffix = drawOutline ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX; │ │ │ │ + var label = this.nodeFactory(featureId + suffix, "text"); │ │ │ │ + label.setAttributeNS(null, "x", x); │ │ │ │ + label.setAttributeNS(null, "y", -y); │ │ │ │ if (style.fontColor) { │ │ │ │ - textbox.style.color = style.fontColor │ │ │ │ + label.setAttributeNS(null, "fill", style.fontColor) │ │ │ │ + } │ │ │ │ + if (style.fontStrokeColor) { │ │ │ │ + label.setAttributeNS(null, "stroke", style.fontStrokeColor) │ │ │ │ + } │ │ │ │ + if (style.fontStrokeWidth) { │ │ │ │ + label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth) │ │ │ │ } │ │ │ │ if (style.fontOpacity) { │ │ │ │ - textbox.style.filter = "alpha(opacity=" + style.fontOpacity * 100 + ")" │ │ │ │ + label.setAttributeNS(null, "opacity", style.fontOpacity) │ │ │ │ } │ │ │ │ if (style.fontFamily) { │ │ │ │ - textbox.style.fontFamily = style.fontFamily │ │ │ │ + label.setAttributeNS(null, "font-family", style.fontFamily) │ │ │ │ } │ │ │ │ if (style.fontSize) { │ │ │ │ - textbox.style.fontSize = style.fontSize │ │ │ │ + label.setAttributeNS(null, "font-size", style.fontSize) │ │ │ │ } │ │ │ │ if (style.fontWeight) { │ │ │ │ - textbox.style.fontWeight = style.fontWeight │ │ │ │ + label.setAttributeNS(null, "font-weight", style.fontWeight) │ │ │ │ } │ │ │ │ if (style.fontStyle) { │ │ │ │ - textbox.style.fontStyle = style.fontStyle │ │ │ │ + label.setAttributeNS(null, "font-style", style.fontStyle) │ │ │ │ } │ │ │ │ if (style.labelSelect === true) { │ │ │ │ - label._featureId = featureId; │ │ │ │ - textbox._featureId = featureId; │ │ │ │ - textbox._geometry = location; │ │ │ │ - textbox._geometryClass = location.CLASS_NAME │ │ │ │ + label.setAttributeNS(null, "pointer-events", "visible"); │ │ │ │ + label._featureId = featureId │ │ │ │ + } else { │ │ │ │ + label.setAttributeNS(null, "pointer-events", "none") │ │ │ │ + } │ │ │ │ + var align = style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign; │ │ │ │ + label.setAttributeNS(null, "text-anchor", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"); │ │ │ │ + if (OpenLayers.IS_GECKO === true) { │ │ │ │ + label.setAttributeNS(null, "dominant-baseline", OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central") │ │ │ │ + } │ │ │ │ + var labelRows = style.label.split("\n"); │ │ │ │ + var numRows = labelRows.length; │ │ │ │ + while (label.childNodes.length > numRows) { │ │ │ │ + label.removeChild(label.lastChild) │ │ │ │ + } │ │ │ │ + for (var i = 0; i < numRows; i++) { │ │ │ │ + var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan"); │ │ │ │ + if (style.labelSelect === true) { │ │ │ │ + tspan._featureId = featureId; │ │ │ │ + tspan._geometry = location; │ │ │ │ + tspan._geometryClass = location.CLASS_NAME │ │ │ │ + } │ │ │ │ + if (OpenLayers.IS_GECKO === false) { │ │ │ │ + tspan.setAttributeNS(null, "baseline-shift", OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%") │ │ │ │ + } │ │ │ │ + tspan.setAttribute("x", x); │ │ │ │ + if (i == 0) { │ │ │ │ + var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]]; │ │ │ │ + if (vfactor == null) { │ │ │ │ + vfactor = -.5 │ │ │ │ + } │ │ │ │ + tspan.setAttribute("dy", vfactor * (numRows - 1) + "em") │ │ │ │ + } else { │ │ │ │ + tspan.setAttribute("dy", "1em") │ │ │ │ + } │ │ │ │ + tspan.textContent = labelRows[i] === "" ? " " : labelRows[i]; │ │ │ │ + if (!tspan.parentNode) { │ │ │ │ + label.appendChild(tspan) │ │ │ │ + } │ │ │ │ } │ │ │ │ - textbox.style.whiteSpace = "nowrap"; │ │ │ │ - textbox.inset = "1px,0px,0px,0px"; │ │ │ │ if (!label.parentNode) { │ │ │ │ - label.appendChild(textbox); │ │ │ │ this.textRoot.appendChild(label) │ │ │ │ } │ │ │ │ - var align = style.labelAlign || "cm"; │ │ │ │ - if (align.length == 1) { │ │ │ │ - align += "m" │ │ │ │ + }, │ │ │ │ + getComponentsString: function(components, separator) { │ │ │ │ + var renderCmp = []; │ │ │ │ + var complete = true; │ │ │ │ + var len = components.length; │ │ │ │ + var strings = []; │ │ │ │ + var str, component; │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + component = components[i]; │ │ │ │ + renderCmp.push(component); │ │ │ │ + str = this.getShortString(component); │ │ │ │ + if (str) { │ │ │ │ + strings.push(str) │ │ │ │ + } else { │ │ │ │ + if (i > 0) { │ │ │ │ + if (this.getShortString(components[i - 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], components[i - 1])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (i < len - 1) { │ │ │ │ + if (this.getShortString(components[i + 1])) { │ │ │ │ + strings.push(this.clipLine(components[i], components[i + 1])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + complete = false │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + path: strings.join(separator || ","), │ │ │ │ + complete: complete │ │ │ │ } │ │ │ │ - var xshift = textbox.clientWidth * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)]; │ │ │ │ - var yshift = textbox.clientHeight * OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)]; │ │ │ │ - label.style.left = parseInt(label.style.left) - xshift - 1 + "px"; │ │ │ │ - label.style.top = parseInt(label.style.top) + yshift + "px" │ │ │ │ }, │ │ │ │ - moveRoot: function(renderer) { │ │ │ │ - var layer = this.map.getLayer(renderer.container.id); │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector.RootContainer) { │ │ │ │ - layer = this.map.getLayer(this.container.id) │ │ │ │ + clipLine: function(badComponent, goodComponent) { │ │ │ │ + if (goodComponent.equals(badComponent)) { │ │ │ │ + return "" │ │ │ │ + } │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var maxX = this.MAX_PIXEL - this.translationParameters.x; │ │ │ │ + var maxY = this.MAX_PIXEL - this.translationParameters.y; │ │ │ │ + var x1 = (goodComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y1 = this.top - goodComponent.y / resolution; │ │ │ │ + var x2 = (badComponent.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y2 = this.top - badComponent.y / resolution; │ │ │ │ + var k; │ │ │ │ + if (x2 < -maxX || x2 > maxX) { │ │ │ │ + k = (y2 - y1) / (x2 - x1); │ │ │ │ + x2 = x2 < 0 ? -maxX : maxX; │ │ │ │ + y2 = y1 + (x2 - x1) * k │ │ │ │ + } │ │ │ │ + if (y2 < -maxY || y2 > maxY) { │ │ │ │ + k = (x2 - x1) / (y2 - y1); │ │ │ │ + y2 = y2 < 0 ? -maxY : maxY; │ │ │ │ + x2 = x1 + (y2 - y1) * k │ │ │ │ + } │ │ │ │ + return x2 + "," + y2 │ │ │ │ + }, │ │ │ │ + getShortString: function(point) { │ │ │ │ + var resolution = this.getResolution(); │ │ │ │ + var x = (point.x - this.featureDx) / resolution + this.left; │ │ │ │ + var y = this.top - point.y / resolution; │ │ │ │ + if (this.inValidRange(x, y)) { │ │ │ │ + return x + "," + y │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getPosition: function(node) { │ │ │ │ + return { │ │ │ │ + x: parseFloat(node.getAttributeNS(null, "cx")), │ │ │ │ + y: parseFloat(node.getAttributeNS(null, "cy")) │ │ │ │ } │ │ │ │ - layer && layer.renderer.clear(); │ │ │ │ - OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments); │ │ │ │ - layer && layer.redraw() │ │ │ │ }, │ │ │ │ importSymbol: function(graphicName) { │ │ │ │ + if (!this.defs) { │ │ │ │ + this.defs = this.createDefs() │ │ │ │ + } │ │ │ │ var id = this.container.id + "-" + graphicName; │ │ │ │ - var cache = this.symbolCache[id]; │ │ │ │ - if (cache) { │ │ │ │ - return cache │ │ │ │ + var existing = document.getElementById(id); │ │ │ │ + if (existing != null) { │ │ │ │ + return existing │ │ │ │ } │ │ │ │ var symbol = OpenLayers.Renderer.symbol[graphicName]; │ │ │ │ if (!symbol) { │ │ │ │ throw new Error(graphicName + " is not a valid symbol name") │ │ │ │ } │ │ │ │ + var symbolNode = this.nodeFactory(id, "symbol"); │ │ │ │ + var node = this.nodeFactory(null, "polygon"); │ │ │ │ + symbolNode.appendChild(node); │ │ │ │ var symbolExtent = new OpenLayers.Bounds(Number.MAX_VALUE, Number.MAX_VALUE, 0, 0); │ │ │ │ - var pathitems = ["m"]; │ │ │ │ + var points = []; │ │ │ │ + var x, y; │ │ │ │ for (var i = 0; i < symbol.length; i = i + 2) { │ │ │ │ - var x = symbol[i]; │ │ │ │ - var y = symbol[i + 1]; │ │ │ │ + x = symbol[i]; │ │ │ │ + y = symbol[i + 1]; │ │ │ │ symbolExtent.left = Math.min(symbolExtent.left, x); │ │ │ │ symbolExtent.bottom = Math.min(symbolExtent.bottom, y); │ │ │ │ symbolExtent.right = Math.max(symbolExtent.right, x); │ │ │ │ symbolExtent.top = Math.max(symbolExtent.top, y); │ │ │ │ - pathitems.push(x); │ │ │ │ - pathitems.push(y); │ │ │ │ - if (i == 0) { │ │ │ │ - pathitems.push("l") │ │ │ │ - } │ │ │ │ + points.push(x, ",", y) │ │ │ │ } │ │ │ │ - pathitems.push("x e"); │ │ │ │ - var path = pathitems.join(" "); │ │ │ │ - var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2; │ │ │ │ - if (diff > 0) { │ │ │ │ - symbolExtent.bottom = symbolExtent.bottom - diff; │ │ │ │ - symbolExtent.top = symbolExtent.top + diff │ │ │ │ - } else { │ │ │ │ - symbolExtent.left = symbolExtent.left + diff; │ │ │ │ - symbolExtent.right = symbolExtent.right - diff │ │ │ │ + node.setAttributeNS(null, "points", points.join(" ")); │ │ │ │ + var width = symbolExtent.getWidth(); │ │ │ │ + var height = symbolExtent.getHeight(); │ │ │ │ + var viewBox = [symbolExtent.left - width, symbolExtent.bottom - height, width * 3, height * 3]; │ │ │ │ + symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" ")); │ │ │ │ + this.symbolMetrics[id] = [Math.max(width, height), symbolExtent.getCenterLonLat().lon, symbolExtent.getCenterLonLat().lat]; │ │ │ │ + this.defs.appendChild(symbolNode); │ │ │ │ + return symbolNode │ │ │ │ + }, │ │ │ │ + getFeatureIdFromEvent: function(evt) { │ │ │ │ + var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(this, arguments); │ │ │ │ + if (!featureId) { │ │ │ │ + var target = evt.target; │ │ │ │ + featureId = target.parentNode && target != this.rendererRoot ? target.parentNode._featureId : undefined │ │ │ │ } │ │ │ │ - cache = { │ │ │ │ - path: path, │ │ │ │ - size: symbolExtent.getWidth(), │ │ │ │ - left: symbolExtent.left, │ │ │ │ - bottom: symbolExtent.bottom │ │ │ │ - }; │ │ │ │ - this.symbolCache[id] = cache; │ │ │ │ - return cache │ │ │ │ + return featureId │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Renderer.VML" │ │ │ │ + CLASS_NAME: "OpenLayers.Renderer.SVG" │ │ │ │ }); │ │ │ │ -OpenLayers.Renderer.VML.LABEL_SHIFT = { │ │ │ │ - l: 0, │ │ │ │ - c: .5, │ │ │ │ - r: 1, │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_ALIGN = { │ │ │ │ + l: "start", │ │ │ │ + r: "end", │ │ │ │ + b: "bottom", │ │ │ │ + t: "hanging" │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VSHIFT = { │ │ │ │ + t: "-70%", │ │ │ │ + b: "0" │ │ │ │ +}; │ │ │ │ +OpenLayers.Renderer.SVG.LABEL_VFACTOR = { │ │ │ │ t: 0, │ │ │ │ - m: .5, │ │ │ │ - b: 1 │ │ │ │ + b: -1 │ │ │ │ }; │ │ │ │ -OpenLayers.Marker.Box = OpenLayers.Class(OpenLayers.Marker, { │ │ │ │ - bounds: null, │ │ │ │ - div: null, │ │ │ │ - initialize: function(bounds, borderColor, borderWidth) { │ │ │ │ - this.bounds = bounds; │ │ │ │ - this.div = OpenLayers.Util.createDiv(); │ │ │ │ - this.div.style.overflow = "hidden"; │ │ │ │ - this.events = new OpenLayers.Events(this, this.div); │ │ │ │ - this.setBorder(borderColor, borderWidth) │ │ │ │ +OpenLayers.Renderer.SVG.preventDefault = function(e) { │ │ │ │ + OpenLayers.Event.preventDefault(e) │ │ │ │ +}; │ │ │ │ +OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + controls: null, │ │ │ │ + autoActivate: true, │ │ │ │ + defaultControl: null, │ │ │ │ + saveState: false, │ │ │ │ + allowDepress: false, │ │ │ │ + activeState: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.controls = []; │ │ │ │ + this.activeState = {} │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - this.bounds = null; │ │ │ │ - this.div = null; │ │ │ │ - OpenLayers.Marker.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - setBorder: function(color, width) { │ │ │ │ - if (!color) { │ │ │ │ - color = "red" │ │ │ │ - } │ │ │ │ - if (!width) { │ │ │ │ - width = 2 │ │ │ │ - } │ │ │ │ - this.div.style.border = width + "px solid " + color │ │ │ │ - }, │ │ │ │ - draw: function(px, sz) { │ │ │ │ - OpenLayers.Util.modifyDOMElement(this.div, null, px, sz); │ │ │ │ - return this.div │ │ │ │ - }, │ │ │ │ - onScreen: function() { │ │ │ │ - var onScreen = false; │ │ │ │ if (this.map) { │ │ │ │ - var screenBounds = this.map.getExtent(); │ │ │ │ - onScreen = screenBounds.containsBounds(this.bounds, true, true) │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onButtonClick) │ │ │ │ } │ │ │ │ - return onScreen │ │ │ │ - }, │ │ │ │ - display: function(display) { │ │ │ │ - this.div.style.display = display ? "" : "none" │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Marker.Box" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.QueryStringFilter = function() { │ │ │ │ - var cmpToStr = {}; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.EQUAL_TO] = "eq"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.NOT_EQUAL_TO] = "ne"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN] = "lt"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO] = "lte"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN] = "gt"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO] = "gte"; │ │ │ │ - cmpToStr[OpenLayers.Filter.Comparison.LIKE] = "ilike"; │ │ │ │ - │ │ │ │ - function regex2value(value) { │ │ │ │ - value = value.replace(/%/g, "\\%"); │ │ │ │ - value = value.replace(/\\\\\.(\*)?/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "\\\\_" │ │ │ │ - }); │ │ │ │ - value = value.replace(/\\\\\.\*/g, "\\\\%"); │ │ │ │ - value = value.replace(/(\\)?\.(\*)?/g, function($0, $1, $2) { │ │ │ │ - return $1 || $2 ? $0 : "_" │ │ │ │ - }); │ │ │ │ - value = value.replace(/(\\)?\.\*/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "%" │ │ │ │ - }); │ │ │ │ - value = value.replace(/\\\./g, "."); │ │ │ │ - value = value.replace(/(\\)?\\\*/g, function($0, $1) { │ │ │ │ - return $1 ? $0 : "*" │ │ │ │ - }); │ │ │ │ - return value │ │ │ │ - } │ │ │ │ - return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - wildcarded: false, │ │ │ │ - srsInBBOX: false, │ │ │ │ - write: function(filter, params) { │ │ │ │ - params = params || {}; │ │ │ │ - var className = filter.CLASS_NAME; │ │ │ │ - var filterType = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ - switch (filterType) { │ │ │ │ - case "Spatial": │ │ │ │ - switch (filter.type) { │ │ │ │ - case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ - params.bbox = filter.value.toArray(); │ │ │ │ - if (this.srsInBBOX && filter.projection) { │ │ │ │ - params.bbox.push(filter.projection.getCode()) │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ - params.tolerance = filter.distance; │ │ │ │ - case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ - params.lon = filter.value.x; │ │ │ │ - params.lat = filter.value.y; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - OpenLayers.Console.warn("Unknown spatial filter type " + filter.type) │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "Comparison": │ │ │ │ - var op = cmpToStr[filter.type]; │ │ │ │ - if (op !== undefined) { │ │ │ │ - var value = filter.value; │ │ │ │ - if (filter.type == OpenLayers.Filter.Comparison.LIKE) { │ │ │ │ - value = regex2value(value); │ │ │ │ - if (this.wildcarded) { │ │ │ │ - value = "%" + value + "%" │ │ │ │ - } │ │ │ │ - } │ │ │ │ - params[filter.property + "__" + op] = value; │ │ │ │ - params.queryable = params.queryable || []; │ │ │ │ - params.queryable.push(filter.property) │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.warn("Unknown comparison filter type " + filter.type) │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "Logical": │ │ │ │ - if (filter.type === OpenLayers.Filter.Logical.AND) { │ │ │ │ - for (var i = 0, len = filter.filters.length; i < len; i++) { │ │ │ │ - params = this.write(filter.filters[i], params) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Console.warn("Unsupported logical filter type " + filter.type) │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - OpenLayers.Console.warn("Unknown filter type " + filterType) │ │ │ │ - } │ │ │ │ - return params │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.QueryStringFilter" │ │ │ │ - }) │ │ │ │ -}(); │ │ │ │ -OpenLayers.Format.WFSDescribeFeatureType = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g │ │ │ │ - }, │ │ │ │ - namespaces: { │ │ │ │ - xsd: "http://www.w3.org/2001/XMLSchema" │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - xsd: { │ │ │ │ - schema: function(node, obj) { │ │ │ │ - var complexTypes = []; │ │ │ │ - var customTypes = {}; │ │ │ │ - var schema = { │ │ │ │ - complexTypes: complexTypes, │ │ │ │ - customTypes: customTypes │ │ │ │ - }; │ │ │ │ - var i, len; │ │ │ │ - this.readChildNodes(node, schema); │ │ │ │ - var attributes = node.attributes; │ │ │ │ - var attr, name; │ │ │ │ - for (i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ - attr = attributes[i]; │ │ │ │ - name = attr.name; │ │ │ │ - if (name.indexOf("xmlns") === 0) { │ │ │ │ - this.setNamespace(name.split(":")[1] || "", attr.value) │ │ │ │ - } else { │ │ │ │ - obj[name] = attr.value │ │ │ │ - } │ │ │ │ - } │ │ │ │ - obj.featureTypes = complexTypes; │ │ │ │ - obj.targetPrefix = this.namespaceAlias[obj.targetNamespace]; │ │ │ │ - var complexType, customType; │ │ │ │ - for (i = 0, len = complexTypes.length; i < len; ++i) { │ │ │ │ - complexType = complexTypes[i]; │ │ │ │ - customType = customTypes[complexType.typeName]; │ │ │ │ - if (customTypes[complexType.typeName]) { │ │ │ │ - complexType.typeName = customType.name │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - complexType: function(node, obj) { │ │ │ │ - var complexType = { │ │ │ │ - typeName: node.getAttribute("name") │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, complexType); │ │ │ │ - obj.complexTypes.push(complexType) │ │ │ │ - }, │ │ │ │ - complexContent: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - extension: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - sequence: function(node, obj) { │ │ │ │ - var sequence = { │ │ │ │ - elements: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, sequence); │ │ │ │ - obj.properties = sequence.elements │ │ │ │ - }, │ │ │ │ - element: function(node, obj) { │ │ │ │ - var type; │ │ │ │ - if (obj.elements) { │ │ │ │ - var element = {}; │ │ │ │ - var attributes = node.attributes; │ │ │ │ - var attr; │ │ │ │ - for (var i = 0, len = attributes.length; i < len; ++i) { │ │ │ │ - attr = attributes[i]; │ │ │ │ - element[attr.name] = attr.value │ │ │ │ - } │ │ │ │ - type = element.type; │ │ │ │ - if (!type) { │ │ │ │ - type = {}; │ │ │ │ - this.readChildNodes(node, type); │ │ │ │ - element.restriction = type; │ │ │ │ - element.type = type.base │ │ │ │ - } │ │ │ │ - var fullType = type.base || type; │ │ │ │ - element.localType = fullType.split(":").pop(); │ │ │ │ - obj.elements.push(element); │ │ │ │ - this.readChildNodes(node, element) │ │ │ │ - } │ │ │ │ - if (obj.complexTypes) { │ │ │ │ - type = node.getAttribute("type"); │ │ │ │ - var localType = type.split(":").pop(); │ │ │ │ - obj.customTypes[localType] = { │ │ │ │ - name: node.getAttribute("name"), │ │ │ │ - type: type │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - annotation: function(node, obj) { │ │ │ │ - obj.annotation = {}; │ │ │ │ - this.readChildNodes(node, obj.annotation) │ │ │ │ - }, │ │ │ │ - appinfo: function(node, obj) { │ │ │ │ - if (!obj.appinfo) { │ │ │ │ - obj.appinfo = [] │ │ │ │ - } │ │ │ │ - obj.appinfo.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - documentation: function(node, obj) { │ │ │ │ - if (!obj.documentation) { │ │ │ │ - obj.documentation = [] │ │ │ │ - } │ │ │ │ - var value = this.getChildValue(node); │ │ │ │ - obj.documentation.push({ │ │ │ │ - lang: node.getAttribute("xml:lang"), │ │ │ │ - textContent: value.replace(this.regExes.trimSpace, "") │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ + ctl = this.controls[i]; │ │ │ │ + if (ctl.events) { │ │ │ │ + ctl.events.un({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ }) │ │ │ │ - }, │ │ │ │ - simpleType: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - restriction: function(node, obj) { │ │ │ │ - obj.base = node.getAttribute("base"); │ │ │ │ - this.readRestriction(node, obj) │ │ │ │ } │ │ │ │ + ctl.panel_div = null │ │ │ │ } │ │ │ │ + this.activeState = null │ │ │ │ }, │ │ │ │ - readRestriction: function(node, obj) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var child, nodeName, value; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - nodeName = child.nodeName.split(":").pop(); │ │ │ │ - value = child.getAttribute("value"); │ │ │ │ - if (!obj[nodeName]) { │ │ │ │ - obj[nodeName] = value │ │ │ │ - } else { │ │ │ │ - if (typeof obj[nodeName] == "string") { │ │ │ │ - obj[nodeName] = [obj[nodeName]] │ │ │ │ - } │ │ │ │ - obj[nodeName].push(value) │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + if (control === this.defaultControl || this.saveState && this.activeState[control.id]) { │ │ │ │ + control.activate() │ │ │ │ } │ │ │ │ } │ │ │ │ + if (this.saveState === true) { │ │ │ │ + this.defaultControl = null │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + control = this.controls[i]; │ │ │ │ + this.activeState[control.id] = control.deactivate() │ │ │ │ + } │ │ │ │ + this.redraw(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - var schema = {}; │ │ │ │ - if (data.nodeName.split(":").pop() === "ExceptionReport") { │ │ │ │ - var parser = new OpenLayers.Format.OGCExceptionReport; │ │ │ │ - schema.error = parser.read(data) │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ } else { │ │ │ │ - this.readNode(data, schema) │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ } │ │ │ │ - return schema │ │ │ │ + this.addControlsToMap(this.controls); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSDescribeFeatureType" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WFS = OpenLayers.Class(OpenLayers.Format.GML, { │ │ │ │ - layer: null, │ │ │ │ - wfsns: "http://www.opengis.net/wfs", │ │ │ │ - ogcns: "http://www.opengis.net/ogc", │ │ │ │ - initialize: function(options, layer) { │ │ │ │ - OpenLayers.Format.GML.prototype.initialize.apply(this, [options]); │ │ │ │ - this.layer = layer; │ │ │ │ - if (this.layer.featureNS) { │ │ │ │ - this.featureNS = this.layer.featureNS │ │ │ │ - } │ │ │ │ - if (this.layer.options.geometry_column) { │ │ │ │ - this.geometryName = this.layer.options.geometry_column │ │ │ │ + redraw: function() { │ │ │ │ + for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) { │ │ │ │ + this.div.removeChild(this.div.childNodes[i]) │ │ │ │ } │ │ │ │ - if (this.layer.options.typename) { │ │ │ │ - this.featureName = this.layer.options.typename │ │ │ │ + this.div.innerHTML = ""; │ │ │ │ + if (this.active) { │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + this.div.appendChild(this.controls[i].panel_div) │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - write: function(features) { │ │ │ │ - var transaction = this.createElementNS(this.wfsns, "wfs:Transaction"); │ │ │ │ - transaction.setAttribute("version", "1.0.0"); │ │ │ │ - transaction.setAttribute("service", "WFS"); │ │ │ │ - for (var i = 0; i < features.length; i++) { │ │ │ │ - switch (features[i].state) { │ │ │ │ - case OpenLayers.State.INSERT: │ │ │ │ - transaction.appendChild(this.insert(features[i])); │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - transaction.appendChild(this.update(features[i])); │ │ │ │ - break; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - transaction.appendChild(this.remove(features[i])); │ │ │ │ - break │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [transaction]) │ │ │ │ - }, │ │ │ │ - createFeatureXML: function(feature) { │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - var geomContainer = this.createElementNS(this.featureNS, "feature:" + this.geometryName); │ │ │ │ - geomContainer.appendChild(geometryNode); │ │ │ │ - var featureContainer = this.createElementNS(this.featureNS, "feature:" + this.featureName); │ │ │ │ - featureContainer.appendChild(geomContainer); │ │ │ │ - for (var attr in feature.attributes) { │ │ │ │ - var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ - var nodename = attr; │ │ │ │ - if (attr.search(":") != -1) { │ │ │ │ - nodename = attr.split(":")[1] │ │ │ │ + if (this.allowDepress && control.active) { │ │ │ │ + control.deactivate() │ │ │ │ + } else { │ │ │ │ + var c; │ │ │ │ + for (var i = 0, len = this.controls.length; i < len; i++) { │ │ │ │ + c = this.controls[i]; │ │ │ │ + if (c != control && (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) { │ │ │ │ + c.deactivate() │ │ │ │ + } │ │ │ │ } │ │ │ │ - var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ - attrContainer.appendChild(attrText); │ │ │ │ - featureContainer.appendChild(attrContainer) │ │ │ │ + control.activate() │ │ │ │ } │ │ │ │ - return featureContainer │ │ │ │ - }, │ │ │ │ - insert: function(feature) { │ │ │ │ - var insertNode = this.createElementNS(this.wfsns, "wfs:Insert"); │ │ │ │ - insertNode.appendChild(this.createFeatureXML(feature)); │ │ │ │ - return insertNode │ │ │ │ }, │ │ │ │ - update: function(feature) { │ │ │ │ - if (!feature.fid) { │ │ │ │ - OpenLayers.Console.userError(OpenLayers.i18n("noFID")) │ │ │ │ + addControls: function(controls) { │ │ │ │ + if (!OpenLayers.Util.isArray(controls)) { │ │ │ │ + controls = [controls] │ │ │ │ } │ │ │ │ - var updateNode = this.createElementNS(this.wfsns, "wfs:Update"); │ │ │ │ - updateNode.setAttribute("typeName", this.featurePrefix + ":" + this.featureName); │ │ │ │ - updateNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ - var propertyNode = this.createElementNS(this.wfsns, "wfs:Property"); │ │ │ │ - var nameNode = this.createElementNS(this.wfsns, "wfs:Name"); │ │ │ │ - var txtNode = this.createTextNode(this.geometryName); │ │ │ │ - nameNode.appendChild(txtNode); │ │ │ │ - propertyNode.appendChild(nameNode); │ │ │ │ - var valueNode = this.createElementNS(this.wfsns, "wfs:Value"); │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - if (feature.layer) { │ │ │ │ - geometryNode.setAttribute("srsName", feature.layer.projection.getCode()) │ │ │ │ + this.controls = this.controls.concat(controls); │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + var control = controls[i], │ │ │ │ + element = this.createControlMarkup(control); │ │ │ │ + OpenLayers.Element.addClass(element, control.displayClass + "ItemInactive"); │ │ │ │ + OpenLayers.Element.addClass(element, "olButton"); │ │ │ │ + if (control.title != "" && !element.title) { │ │ │ │ + element.title = control.title │ │ │ │ + } │ │ │ │ + control.panel_div = element │ │ │ │ } │ │ │ │ - valueNode.appendChild(geometryNode); │ │ │ │ - propertyNode.appendChild(valueNode); │ │ │ │ - updateNode.appendChild(propertyNode); │ │ │ │ - for (var propName in feature.attributes) { │ │ │ │ - propertyNode = this.createElementNS(this.wfsns, "wfs:Property"); │ │ │ │ - nameNode = this.createElementNS(this.wfsns, "wfs:Name"); │ │ │ │ - nameNode.appendChild(this.createTextNode(propName)); │ │ │ │ - propertyNode.appendChild(nameNode); │ │ │ │ - valueNode = this.createElementNS(this.wfsns, "wfs:Value"); │ │ │ │ - valueNode.appendChild(this.createTextNode(feature.attributes[propName])); │ │ │ │ - propertyNode.appendChild(valueNode); │ │ │ │ - updateNode.appendChild(propertyNode) │ │ │ │ + if (this.map) { │ │ │ │ + this.addControlsToMap(controls); │ │ │ │ + this.redraw() │ │ │ │ } │ │ │ │ - var filterNode = this.createElementNS(this.ogcns, "ogc:Filter"); │ │ │ │ - var filterIdNode = this.createElementNS(this.ogcns, "ogc:FeatureId"); │ │ │ │ - filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ - filterNode.appendChild(filterIdNode); │ │ │ │ - updateNode.appendChild(filterNode); │ │ │ │ - return updateNode │ │ │ │ }, │ │ │ │ - remove: function(feature) { │ │ │ │ - if (!feature.fid) { │ │ │ │ - OpenLayers.Console.userError(OpenLayers.i18n("noFID")); │ │ │ │ - return false │ │ │ │ + createControlMarkup: function(control) { │ │ │ │ + return document.createElement("div") │ │ │ │ + }, │ │ │ │ + addControlsToMap: function(controls) { │ │ │ │ + var control; │ │ │ │ + for (var i = 0, len = controls.length; i < len; i++) { │ │ │ │ + control = controls[i]; │ │ │ │ + if (control.autoActivate === true) { │ │ │ │ + control.autoActivate = false; │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.autoActivate = true │ │ │ │ + } else { │ │ │ │ + this.map.addControl(control); │ │ │ │ + control.deactivate() │ │ │ │ + } │ │ │ │ + control.events.on({ │ │ │ │ + activate: this.iconOn, │ │ │ │ + deactivate: this.iconOff │ │ │ │ + }) │ │ │ │ } │ │ │ │ - var deleteNode = this.createElementNS(this.wfsns, "wfs:Delete"); │ │ │ │ - deleteNode.setAttribute("typeName", this.featurePrefix + ":" + this.featureName); │ │ │ │ - deleteNode.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); │ │ │ │ - var filterNode = this.createElementNS(this.ogcns, "ogc:Filter"); │ │ │ │ - var filterIdNode = this.createElementNS(this.ogcns, "ogc:FeatureId"); │ │ │ │ - filterIdNode.setAttribute("fid", feature.fid); │ │ │ │ - filterNode.appendChild(filterIdNode); │ │ │ │ - deleteNode.appendChild(filterNode); │ │ │ │ - return deleteNode │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.layer = null │ │ │ │ + iconOn: function() { │ │ │ │ + var d = this.panel_div; │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Active") │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFS" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMTSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.0.0", │ │ │ │ - yx: { │ │ │ │ - "urn:ogc:def:crs:EPSG::4326": true │ │ │ │ + iconOff: function() { │ │ │ │ + var d = this.panel_div; │ │ │ │ + var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b"); │ │ │ │ + d.className = d.className.replace(re, "$1Inactive") │ │ │ │ }, │ │ │ │ - createLayer: function(capabilities, config) { │ │ │ │ - var layer; │ │ │ │ - if (!("layer" in config)) { │ │ │ │ - throw new Error("Missing property 'layer' in configuration.") │ │ │ │ - } │ │ │ │ - var contents = capabilities.contents; │ │ │ │ - var layers = contents.layers; │ │ │ │ - var layerDef; │ │ │ │ - for (var i = 0, ii = contents.layers.length; i < ii; ++i) { │ │ │ │ - if (contents.layers[i].identifier === config.layer) { │ │ │ │ - layerDef = contents.layers[i]; │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var controls = this.controls, │ │ │ │ + button = evt.buttonElement; │ │ │ │ + for (var i = controls.length - 1; i >= 0; --i) { │ │ │ │ + if (controls[i].panel_div === button) { │ │ │ │ + this.activateControl(controls[i]); │ │ │ │ break │ │ │ │ } │ │ │ │ } │ │ │ │ - if (!layerDef) { │ │ │ │ - throw new Error("Layer not found") │ │ │ │ - } │ │ │ │ - var format = config.format; │ │ │ │ - if (!format && layerDef.formats && layerDef.formats.length) { │ │ │ │ - format = layerDef.formats[0] │ │ │ │ - } │ │ │ │ - var matrixSet; │ │ │ │ - if (config.matrixSet) { │ │ │ │ - matrixSet = contents.tileMatrixSets[config.matrixSet] │ │ │ │ - } else if (layerDef.tileMatrixSetLinks.length >= 1) { │ │ │ │ - matrixSet = contents.tileMatrixSets[layerDef.tileMatrixSetLinks[0].tileMatrixSet] │ │ │ │ - } │ │ │ │ - if (!matrixSet) { │ │ │ │ - throw new Error("matrixSet not found") │ │ │ │ - } │ │ │ │ - var style; │ │ │ │ - for (var i = 0, ii = layerDef.styles.length; i < ii; ++i) { │ │ │ │ - style = layerDef.styles[i]; │ │ │ │ - if (style.isDefault) { │ │ │ │ - break │ │ │ │ + }, │ │ │ │ + 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 │ │ │ │ + }, │ │ │ │ + getControlsByName: function(match) { │ │ │ │ + return this.getControlsBy("name", match) │ │ │ │ + }, │ │ │ │ + getControlsByClass: function(match) { │ │ │ │ + return this.getControlsBy("CLASS_NAME", match) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Panel" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + out: false, │ │ │ │ + keyMask: null, │ │ │ │ + alwaysZoom: false, │ │ │ │ + zoomOnClick: true, │ │ │ │ + draw: function() { │ │ │ │ + this.handler = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.zoomBox │ │ │ │ + }, { │ │ │ │ + keyMask: this.keyMask │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + zoomBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var bounds, targetCenterPx = position.getCenterPixel(); │ │ │ │ + if (!this.out) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat) │ │ │ │ + } else { │ │ │ │ + var pixWidth = position.right - position.left; │ │ │ │ + var pixHeight = position.bottom - position.top; │ │ │ │ + var zoomFactor = Math.min(this.map.size.h / pixHeight, this.map.size.w / pixWidth); │ │ │ │ + var extent = this.map.getExtent(); │ │ │ │ + var center = this.map.getLonLatFromPixel(targetCenterPx); │ │ │ │ + var xmin = center.lon - extent.getWidth() / 2 * zoomFactor; │ │ │ │ + var xmax = center.lon + extent.getWidth() / 2 * zoomFactor; │ │ │ │ + var ymin = center.lat - extent.getHeight() / 2 * zoomFactor; │ │ │ │ + var ymax = center.lat + extent.getHeight() / 2 * zoomFactor; │ │ │ │ + bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax) │ │ │ │ } │ │ │ │ - } │ │ │ │ - var requestEncoding = config.requestEncoding; │ │ │ │ - if (!requestEncoding) { │ │ │ │ - requestEncoding = "KVP"; │ │ │ │ - if (capabilities.operationsMetadata.GetTile.dcp.http) { │ │ │ │ - var http = capabilities.operationsMetadata.GetTile.dcp.http; │ │ │ │ - if (http.get[0].constraints) { │ │ │ │ - var constraints = http.get[0].constraints; │ │ │ │ - var allowedValues = constraints.GetEncoding.allowedValues; │ │ │ │ - if (!allowedValues.KVP && (allowedValues.REST || allowedValues.RESTful)) { │ │ │ │ - requestEncoding = "REST" │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var lastZoom = this.map.getZoom(), │ │ │ │ + size = this.map.getSize(), │ │ │ │ + centerPx = { │ │ │ │ + x: size.w / 2, │ │ │ │ + y: size.h / 2 │ │ │ │ + }, │ │ │ │ + zoom = this.map.getZoomForExtent(bounds), │ │ │ │ + oldRes = this.map.getResolution(), │ │ │ │ + newRes = this.map.getResolutionForZoom(zoom); │ │ │ │ + if (oldRes == newRes) { │ │ │ │ + this.map.setCenter(this.map.getLonLatFromPixel(targetCenterPx)) │ │ │ │ + } else { │ │ │ │ + var zoomOriginPx = { │ │ │ │ + x: (oldRes * targetCenterPx.x - newRes * centerPx.x) / (oldRes - newRes), │ │ │ │ + y: (oldRes * targetCenterPx.y - newRes * centerPx.y) / (oldRes - newRes) │ │ │ │ + }; │ │ │ │ + this.map.zoomTo(zoom, zoomOriginPx) │ │ │ │ } │ │ │ │ - } │ │ │ │ - var dimensions = []; │ │ │ │ - var params = config.params || {}; │ │ │ │ - delete config.params; │ │ │ │ - for (var id = 0, ld = layerDef.dimensions.length; id < ld; id++) { │ │ │ │ - var dimension = layerDef.dimensions[id]; │ │ │ │ - dimensions.push(dimension.identifier); │ │ │ │ - if (!params.hasOwnProperty(dimension.identifier)) { │ │ │ │ - params[dimension.identifier] = dimension["default"] │ │ │ │ + if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) { │ │ │ │ + this.map.zoomTo(lastZoom + (this.out ? -1 : 1)) │ │ │ │ + } │ │ │ │ + } else if (this.zoomOnClick) { │ │ │ │ + if (!this.out) { │ │ │ │ + this.map.zoomTo(this.map.getZoom() + 1, position) │ │ │ │ + } else { │ │ │ │ + this.map.zoomTo(this.map.getZoom() - 1, position) │ │ │ │ } │ │ │ │ } │ │ │ │ - var projection = config.projection || matrixSet.supportedCRS.replace(/urn:ogc:def:crs:(\w+):(.*:)?(\w+)$/, "$1:$3"); │ │ │ │ - var units = config.units || (projection === "EPSG:4326" ? "degrees" : "m"); │ │ │ │ - var resolutions = []; │ │ │ │ - for (var mid in matrixSet.matrixIds) { │ │ │ │ - if (matrixSet.matrixIds.hasOwnProperty(mid)) { │ │ │ │ - resolutions.push(matrixSet.matrixIds[mid].scaleDenominator * 28e-5 / OpenLayers.METERS_PER_INCH / OpenLayers.INCHES_PER_UNIT[units]) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomBox" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + panned: false, │ │ │ │ + interval: 0, │ │ │ │ + documentDrag: false, │ │ │ │ + kinetic: null, │ │ │ │ + enableKinetic: true, │ │ │ │ + kineticInterval: 10, │ │ │ │ + draw: function() { │ │ │ │ + if (this.enableKinetic && OpenLayers.Kinetic) { │ │ │ │ + var config = { │ │ │ │ + interval: this.kineticInterval │ │ │ │ + }; │ │ │ │ + if (typeof this.enableKinetic === "object") { │ │ │ │ + config = OpenLayers.Util.extend(config, this.enableKinetic) │ │ │ │ } │ │ │ │ + this.kinetic = new OpenLayers.Kinetic(config) │ │ │ │ } │ │ │ │ - var url; │ │ │ │ - if (requestEncoding === "REST" && layerDef.resourceUrls) { │ │ │ │ - url = []; │ │ │ │ - var resourceUrls = layerDef.resourceUrls, │ │ │ │ - resourceUrl; │ │ │ │ - for (var t = 0, tt = layerDef.resourceUrls.length; t < tt; ++t) { │ │ │ │ - resourceUrl = layerDef.resourceUrls[t]; │ │ │ │ - if (resourceUrl.format === format && resourceUrl.resourceType === "tile") { │ │ │ │ - url.push(resourceUrl.template) │ │ │ │ - } │ │ │ │ + this.handler = new OpenLayers.Handler.Drag(this, { │ │ │ │ + move: this.panMap, │ │ │ │ + done: this.panMapDone, │ │ │ │ + down: this.panMapStart │ │ │ │ + }, { │ │ │ │ + interval: this.interval, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + panMapStart: function() { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.begin() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + panMap: function(xy) { │ │ │ │ + if (this.kinetic) { │ │ │ │ + this.kinetic.update(xy) │ │ │ │ + } │ │ │ │ + this.panned = true; │ │ │ │ + this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ + dragging: true, │ │ │ │ + animate: false │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + panMapDone: function(xy) { │ │ │ │ + if (this.panned) { │ │ │ │ + var res = null; │ │ │ │ + if (this.kinetic) { │ │ │ │ + res = this.kinetic.end(xy) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - var httpGet = capabilities.operationsMetadata.GetTile.dcp.http.get; │ │ │ │ - url = []; │ │ │ │ - var constraint; │ │ │ │ - for (var i = 0, ii = httpGet.length; i < ii; i++) { │ │ │ │ - constraint = httpGet[i].constraints; │ │ │ │ - if (!constraint || constraint && constraint.GetEncoding.allowedValues[requestEncoding]) { │ │ │ │ - url.push(httpGet[i].url) │ │ │ │ - } │ │ │ │ + this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, { │ │ │ │ + dragging: !!res, │ │ │ │ + animate: false │ │ │ │ + }); │ │ │ │ + if (res) { │ │ │ │ + var self = this; │ │ │ │ + this.kinetic.move(res, function(x, y, end) { │ │ │ │ + self.map.pan(x, y, { │ │ │ │ + dragging: !end, │ │ │ │ + animate: false │ │ │ │ + }) │ │ │ │ + }) │ │ │ │ } │ │ │ │ + this.panned = false │ │ │ │ } │ │ │ │ - return new OpenLayers.Layer.WMTS(OpenLayers.Util.applyDefaults(config, { │ │ │ │ - url: url, │ │ │ │ - requestEncoding: requestEncoding, │ │ │ │ - name: layerDef.title, │ │ │ │ - style: style.identifier, │ │ │ │ - format: format, │ │ │ │ - matrixIds: matrixSet.matrixIds, │ │ │ │ - matrixSet: matrixSet.identifier, │ │ │ │ - projection: projection, │ │ │ │ - units: units, │ │ │ │ - resolutions: config.isBaseLayer === false ? undefined : resolutions, │ │ │ │ - serverResolutions: resolutions, │ │ │ │ - tileFullExtent: matrixSet.bounds, │ │ │ │ - dimensions: dimensions, │ │ │ │ - params: params │ │ │ │ - })) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMTSCapabilities" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DragPan" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.CSWGetRecords = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, OpenLayers.Format.CSWGetRecords.DEFAULTS); │ │ │ │ - var cls = OpenLayers.Format.CSWGetRecords["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported CSWGetRecords version: " + options.version │ │ │ │ - } │ │ │ │ - return new cls(options) │ │ │ │ -}; │ │ │ │ -OpenLayers.Format.CSWGetRecords.DEFAULTS = { │ │ │ │ - version: "2.0.2" │ │ │ │ -}; │ │ │ │ -OpenLayers.Format.Context = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - layerOptions: null, │ │ │ │ - layerParams: null, │ │ │ │ - read: function(data, options) { │ │ │ │ - var context = OpenLayers.Format.XML.VersionedOGC.prototype.read.apply(this, arguments); │ │ │ │ - var map; │ │ │ │ - if (options && options.map) { │ │ │ │ - this.context = context; │ │ │ │ - if (options.map instanceof OpenLayers.Map) { │ │ │ │ - map = this.mergeContextToMap(context, options.map) │ │ │ │ - } else { │ │ │ │ - var mapOptions = options.map; │ │ │ │ - if (OpenLayers.Util.isElement(mapOptions) || typeof mapOptions == "string") { │ │ │ │ - mapOptions = { │ │ │ │ - div: mapOptions │ │ │ │ - } │ │ │ │ - } │ │ │ │ - map = this.contextToMap(context, mapOptions) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - map = context │ │ │ │ - } │ │ │ │ - return map │ │ │ │ +OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + dragPan: null, │ │ │ │ + dragPanOptions: null, │ │ │ │ + pinchZoom: null, │ │ │ │ + pinchZoomOptions: null, │ │ │ │ + documentDrag: false, │ │ │ │ + zoomBox: null, │ │ │ │ + zoomBoxEnabled: true, │ │ │ │ + zoomWheelEnabled: true, │ │ │ │ + mouseWheelOptions: null, │ │ │ │ + handleRightClicks: false, │ │ │ │ + zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT, │ │ │ │ + autoActivate: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ }, │ │ │ │ - getLayerFromContext: function(layerContext) { │ │ │ │ - var i, len; │ │ │ │ - var options = { │ │ │ │ - queryable: layerContext.queryable, │ │ │ │ - visibility: layerContext.visibility, │ │ │ │ - maxExtent: layerContext.maxExtent, │ │ │ │ - metadata: OpenLayers.Util.applyDefaults(layerContext.metadata, { │ │ │ │ - styles: layerContext.styles, │ │ │ │ - formats: layerContext.formats, │ │ │ │ - abstract: layerContext["abstract"], │ │ │ │ - dataURL: layerContext.dataURL │ │ │ │ - }), │ │ │ │ - numZoomLevels: layerContext.numZoomLevels, │ │ │ │ - units: layerContext.units, │ │ │ │ - isBaseLayer: layerContext.isBaseLayer, │ │ │ │ - opacity: layerContext.opacity, │ │ │ │ - displayInLayerSwitcher: layerContext.displayInLayerSwitcher, │ │ │ │ - singleTile: layerContext.singleTile, │ │ │ │ - tileSize: layerContext.tileSize ? new OpenLayers.Size(layerContext.tileSize.width, layerContext.tileSize.height) : undefined, │ │ │ │ - minScale: layerContext.minScale || layerContext.maxScaleDenominator, │ │ │ │ - maxScale: layerContext.maxScale || layerContext.minScaleDenominator, │ │ │ │ - srs: layerContext.srs, │ │ │ │ - dimensions: layerContext.dimensions, │ │ │ │ - metadataURL: layerContext.metadataURL │ │ │ │ - }; │ │ │ │ - if (this.layerOptions) { │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.layerOptions) │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.dragPan) { │ │ │ │ + this.dragPan.destroy() │ │ │ │ } │ │ │ │ - var params = { │ │ │ │ - layers: layerContext.name, │ │ │ │ - transparent: layerContext.transparent, │ │ │ │ - version: layerContext.version │ │ │ │ - }; │ │ │ │ - if (layerContext.formats && layerContext.formats.length > 0) { │ │ │ │ - params.format = layerContext.formats[0].value; │ │ │ │ - for (i = 0, len = layerContext.formats.length; i < len; i++) { │ │ │ │ - var format = layerContext.formats[i]; │ │ │ │ - if (format.current == true) { │ │ │ │ - params.format = format.value; │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.dragPan = null; │ │ │ │ + if (this.zoomBox) { │ │ │ │ + this.zoomBox.destroy() │ │ │ │ } │ │ │ │ - if (layerContext.styles && layerContext.styles.length > 0) { │ │ │ │ - for (i = 0, len = layerContext.styles.length; i < len; i++) { │ │ │ │ - var style = layerContext.styles[i]; │ │ │ │ - if (style.current == true) { │ │ │ │ - if (style.href) { │ │ │ │ - params.sld = style.href │ │ │ │ - } else if (style.body) { │ │ │ │ - params.sld_body = style.body │ │ │ │ - } else { │ │ │ │ - params.styles = style.name │ │ │ │ - } │ │ │ │ - break │ │ │ │ - } │ │ │ │ - } │ │ │ │ + this.zoomBox = null; │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.destroy() │ │ │ │ } │ │ │ │ - if (this.layerParams) { │ │ │ │ - OpenLayers.Util.applyDefaults(params, this.layerParams) │ │ │ │ + this.pinchZoom = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + this.dragPan.activate(); │ │ │ │ + if (this.zoomWheelEnabled) { │ │ │ │ + this.handlers.wheel.activate() │ │ │ │ } │ │ │ │ - var layer = null; │ │ │ │ - var service = layerContext.service; │ │ │ │ - if (service == OpenLayers.Format.Context.serviceTypes.WFS) { │ │ │ │ - options.strategies = [new OpenLayers.Strategy.BBOX]; │ │ │ │ - options.protocol = new OpenLayers.Protocol.WFS({ │ │ │ │ - url: layerContext.url, │ │ │ │ - featurePrefix: layerContext.name.split(":")[0], │ │ │ │ - featureType: layerContext.name.split(":").pop() │ │ │ │ - }); │ │ │ │ - layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options) │ │ │ │ - } else if (service == OpenLayers.Format.Context.serviceTypes.KML) { │ │ │ │ - options.strategies = [new OpenLayers.Strategy.Fixed]; │ │ │ │ - options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ - url: layerContext.url, │ │ │ │ - format: new OpenLayers.Format.KML │ │ │ │ - }); │ │ │ │ - layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options) │ │ │ │ - } else if (service == OpenLayers.Format.Context.serviceTypes.GML) { │ │ │ │ - options.strategies = [new OpenLayers.Strategy.Fixed]; │ │ │ │ - options.protocol = new OpenLayers.Protocol.HTTP({ │ │ │ │ - url: layerContext.url, │ │ │ │ - format: new OpenLayers.Format.GML │ │ │ │ - }); │ │ │ │ - layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options) │ │ │ │ - } else if (layerContext.features) { │ │ │ │ - layer = new OpenLayers.Layer.Vector(layerContext.title || layerContext.name, options); │ │ │ │ - layer.addFeatures(layerContext.features) │ │ │ │ - } else if (layerContext.categoryLayer !== true) { │ │ │ │ - layer = new OpenLayers.Layer.WMS(layerContext.title || layerContext.name, layerContext.url, params, options) │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + if (this.zoomBoxEnabled) { │ │ │ │ + this.zoomBox.activate() │ │ │ │ } │ │ │ │ - return layer │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.activate() │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ }, │ │ │ │ - getLayersFromContext: function(layersContext) { │ │ │ │ - var layers = []; │ │ │ │ - for (var i = 0, len = layersContext.length; i < len; i++) { │ │ │ │ - var layer = this.getLayerFromContext(layersContext[i]); │ │ │ │ - if (layer !== null) { │ │ │ │ - layers.push(layer) │ │ │ │ - } │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.deactivate() │ │ │ │ } │ │ │ │ - return layers │ │ │ │ + this.zoomBox.deactivate(); │ │ │ │ + this.dragPan.deactivate(); │ │ │ │ + this.handlers.click.deactivate(); │ │ │ │ + this.handlers.wheel.deactivate(); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ }, │ │ │ │ - contextToMap: function(context, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - maxExtent: context.maxExtent, │ │ │ │ - projection: context.projection, │ │ │ │ - units: context.units │ │ │ │ - }, options); │ │ │ │ - if (options.maxExtent) { │ │ │ │ - options.maxResolution = options.maxExtent.getWidth() / OpenLayers.Map.TILE_WIDTH │ │ │ │ + draw: function() { │ │ │ │ + if (this.handleRightClicks) { │ │ │ │ + this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False │ │ │ │ } │ │ │ │ - var metadata = { │ │ │ │ - contactInformation: context.contactInformation, │ │ │ │ - abstract: context["abstract"], │ │ │ │ - keywords: context.keywords, │ │ │ │ - logo: context.logo, │ │ │ │ - descriptionURL: context.descriptionURL │ │ │ │ + var clickCallbacks = { │ │ │ │ + click: this.defaultClick, │ │ │ │ + dblclick: this.defaultDblClick, │ │ │ │ + dblrightclick: this.defaultDblRightClick │ │ │ │ }; │ │ │ │ - options.metadata = metadata; │ │ │ │ - var map = new OpenLayers.Map(options); │ │ │ │ - map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ - map.setCenter(context.bounds.getCenterLonLat(), map.getZoomForExtent(context.bounds, true)); │ │ │ │ - return map │ │ │ │ - }, │ │ │ │ - mergeContextToMap: function(context, map) { │ │ │ │ - map.addLayers(this.getLayersFromContext(context.layersContext)); │ │ │ │ - return map │ │ │ │ + var clickOptions = { │ │ │ │ + double: true, │ │ │ │ + stopDouble: true │ │ │ │ + }; │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks, clickOptions); │ │ │ │ + this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend({ │ │ │ │ + map: this.map, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }, this.dragPanOptions)); │ │ │ │ + this.zoomBox = new OpenLayers.Control.ZoomBox({ │ │ │ │ + map: this.map, │ │ │ │ + keyMask: this.zoomBoxKeyMask │ │ │ │ + }); │ │ │ │ + this.dragPan.draw(); │ │ │ │ + this.zoomBox.draw(); │ │ │ │ + var wheelOptions = this.map.fractionalZoom ? {} : { │ │ │ │ + cumulative: false, │ │ │ │ + interval: 50, │ │ │ │ + maxDelta: 6 │ │ │ │ + }; │ │ │ │ + this.handlers.wheel = new OpenLayers.Handler.MouseWheel(this, { │ │ │ │ + up: this.wheelUp, │ │ │ │ + down: this.wheelDown │ │ │ │ + }, OpenLayers.Util.extend(wheelOptions, this.mouseWheelOptions)); │ │ │ │ + if (OpenLayers.Control.PinchZoom) { │ │ │ │ + this.pinchZoom = new OpenLayers.Control.PinchZoom(OpenLayers.Util.extend({ │ │ │ │ + map: this.map │ │ │ │ + }, this.pinchZoomOptions)) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - write: function(obj, options) { │ │ │ │ - obj = this.toContext(obj); │ │ │ │ - return OpenLayers.Format.XML.VersionedOGC.prototype.write.apply(this, arguments) │ │ │ │ + defaultClick: function(evt) { │ │ │ │ + if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ + this.map.zoomOut() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Context" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.Context.serviceTypes = { │ │ │ │ - WMS: "urn:ogc:serviceType:WMS", │ │ │ │ - WFS: "urn:ogc:serviceType:WFS", │ │ │ │ - WCS: "urn:ogc:serviceType:WCS", │ │ │ │ - GML: "urn:ogc:serviceType:GML", │ │ │ │ - SLD: "urn:ogc:serviceType:SLD", │ │ │ │ - FES: "urn:ogc:serviceType:FES", │ │ │ │ - KML: "urn:ogc:serviceType:KML" │ │ │ │ -}; │ │ │ │ -OpenLayers.Format.SOSGetFeatureOfInterest = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - VERSION: "1.0.0", │ │ │ │ - namespaces: { │ │ │ │ - sos: "http://www.opengis.net/sos/1.0", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ + defaultDblClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom + 1, evt.xy) │ │ │ │ }, │ │ │ │ - schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosAll.xsd", │ │ │ │ - defaultPrefix: "sos", │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ + defaultDblRightClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom - 1, evt.xy) │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + wheelChange: function(evt, deltaZ) { │ │ │ │ + if (!this.map.fractionalZoom) { │ │ │ │ + deltaZ = Math.round(deltaZ) │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + var currentZoom = this.map.getZoom(), │ │ │ │ + newZoom = currentZoom + deltaZ; │ │ │ │ + newZoom = Math.max(newZoom, 0); │ │ │ │ + newZoom = Math.min(newZoom, this.map.getNumZoomLevels()); │ │ │ │ + if (newZoom === currentZoom) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - var info = { │ │ │ │ - features: [] │ │ │ │ - }; │ │ │ │ - this.readNode(data, info); │ │ │ │ - var features = []; │ │ │ │ - for (var i = 0, len = info.features.length; i < len; i++) { │ │ │ │ - var container = info.features[i]; │ │ │ │ - if (this.internalProjection && this.externalProjection && container.components[0]) { │ │ │ │ - container.components[0].transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - var feature = new OpenLayers.Feature.Vector(container.components[0], container.attributes); │ │ │ │ - features.push(feature) │ │ │ │ + this.map.zoomTo(newZoom, evt.xy) │ │ │ │ + }, │ │ │ │ + wheelUp: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || 1) │ │ │ │ + }, │ │ │ │ + wheelDown: function(evt, delta) { │ │ │ │ + this.wheelChange(evt, delta || -1) │ │ │ │ + }, │ │ │ │ + disableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = false; │ │ │ │ + this.zoomBox.deactivate() │ │ │ │ + }, │ │ │ │ + enableZoomBox: function() { │ │ │ │ + this.zoomBoxEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.zoomBox.activate() │ │ │ │ } │ │ │ │ - return features │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - sa: { │ │ │ │ - SamplingPoint: function(node, obj) { │ │ │ │ - if (!obj.attributes) { │ │ │ │ - var feature = { │ │ │ │ - attributes: {} │ │ │ │ - }; │ │ │ │ - obj.features.push(feature); │ │ │ │ - obj = feature │ │ │ │ - } │ │ │ │ - obj.attributes.id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - position: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - gml: OpenLayers.Util.applyDefaults({ │ │ │ │ - FeatureCollection: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - featureMember: function(node, obj) { │ │ │ │ - var feature = { │ │ │ │ - attributes: {} │ │ │ │ - }; │ │ │ │ - obj.features.push(feature); │ │ │ │ - this.readChildNodes(node, feature) │ │ │ │ - }, │ │ │ │ - name: function(node, obj) { │ │ │ │ - obj.attributes.name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - pos: function(node, obj) { │ │ │ │ - if (!this.externalProjection) { │ │ │ │ - this.externalProjection = new OpenLayers.Projection(node.getAttribute("srsName")) │ │ │ │ - } │ │ │ │ - OpenLayers.Format.GML.v3.prototype.readers.gml.pos.apply(this, [node, obj]) │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.v3.prototype.readers.gml) │ │ │ │ + disableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = false; │ │ │ │ + this.handlers.wheel.deactivate() │ │ │ │ }, │ │ │ │ - writers: { │ │ │ │ - sos: { │ │ │ │ - GetFeatureOfInterest: function(options) { │ │ │ │ - var node = this.createElementNSPlus("GetFeatureOfInterest", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - service: "SOS", │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - for (var i = 0, len = options.fois.length; i < len; i++) { │ │ │ │ - this.writeNode("FeatureOfInterestId", { │ │ │ │ - foi: options.fois[i] │ │ │ │ - }, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - FeatureOfInterestId: function(options) { │ │ │ │ - var node = this.createElementNSPlus("FeatureOfInterestId", { │ │ │ │ - value: options.foi │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - } │ │ │ │ + enableZoomWheel: function() { │ │ │ │ + this.zoomWheelEnabled = true; │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.wheel.activate() │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSGetFeatureOfInterest" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Navigation" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.SOSGetObservation = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - sos: "http://www.opengis.net/sos/1.0", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - om: "http://www.opengis.net/om/1.0", │ │ │ │ - sa: "http://www.opengis.net/sampling/1.0", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ +OpenLayers.Control.NavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + this.addControls([new OpenLayers.Control.Navigation, new OpenLayers.Control.ZoomBox]) │ │ │ │ }, │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.defaultControl === null) { │ │ │ │ + this.defaultControl = this.controls[0] │ │ │ │ + } │ │ │ │ + return div │ │ │ │ }, │ │ │ │ - VERSION: "1.0.0", │ │ │ │ - schemaLocation: "http://www.opengis.net/sos/1.0 http://schemas.opengis.net/sos/1.0.0/sosGetObservation.xsd", │ │ │ │ - defaultPrefix: "sos", │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.NavToolbar" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.CacheRead = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + fetchEvent: "tileloadstart", │ │ │ │ + layers: null, │ │ │ │ + autoActivate: true, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + var i, layers = this.layers || map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.addLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }) │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + if (!this.layers) { │ │ │ │ + map.events.on({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - var info = { │ │ │ │ - measurements: [], │ │ │ │ - observations: [] │ │ │ │ - }; │ │ │ │ - this.readNode(data, info); │ │ │ │ - return info │ │ │ │ }, │ │ │ │ - write: function(options) { │ │ │ │ - var node = this.writeNode("sos:GetObservation", options); │ │ │ │ - node.setAttribute("xmlns:om", this.namespaces.om); │ │ │ │ - node.setAttribute("xmlns:ogc", this.namespaces.ogc); │ │ │ │ - this.setAttributeNS(node, this.namespaces.xsi, "xsi:schemaLocation", this.schemaLocation); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [node]) │ │ │ │ + addLayer: function(evt) { │ │ │ │ + evt.layer.events.register(this.fetchEvent, this, this.fetch) │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - om: { │ │ │ │ - ObservationCollection: function(node, obj) { │ │ │ │ - obj.id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - member: function(node, observationCollection) { │ │ │ │ - this.readChildNodes(node, observationCollection) │ │ │ │ - }, │ │ │ │ - Measurement: function(node, observationCollection) { │ │ │ │ - var measurement = {}; │ │ │ │ - observationCollection.measurements.push(measurement); │ │ │ │ - this.readChildNodes(node, measurement) │ │ │ │ - }, │ │ │ │ - Observation: function(node, observationCollection) { │ │ │ │ - var observation = {}; │ │ │ │ - observationCollection.observations.push(observation); │ │ │ │ - this.readChildNodes(node, observation) │ │ │ │ - }, │ │ │ │ - samplingTime: function(node, measurement) { │ │ │ │ - var samplingTime = {}; │ │ │ │ - measurement.samplingTime = samplingTime; │ │ │ │ - this.readChildNodes(node, samplingTime) │ │ │ │ - }, │ │ │ │ - observedProperty: function(node, measurement) { │ │ │ │ - measurement.observedProperty = this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ - this.readChildNodes(node, measurement) │ │ │ │ - }, │ │ │ │ - procedure: function(node, measurement) { │ │ │ │ - measurement.procedure = this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ - this.readChildNodes(node, measurement) │ │ │ │ - }, │ │ │ │ - featureOfInterest: function(node, observation) { │ │ │ │ - var foi = { │ │ │ │ - features: [] │ │ │ │ - }; │ │ │ │ - observation.fois = []; │ │ │ │ - observation.fois.push(foi); │ │ │ │ - this.readChildNodes(node, foi); │ │ │ │ - var features = []; │ │ │ │ - for (var i = 0, len = foi.features.length; i < len; i++) { │ │ │ │ - var feature = foi.features[i]; │ │ │ │ - features.push(new OpenLayers.Feature.Vector(feature.components[0], feature.attributes)) │ │ │ │ - } │ │ │ │ - foi.features = features │ │ │ │ - }, │ │ │ │ - result: function(node, measurement) { │ │ │ │ - var result = {}; │ │ │ │ - measurement.result = result; │ │ │ │ - if (this.getChildValue(node) !== "") { │ │ │ │ - result.value = this.getChildValue(node); │ │ │ │ - result.uom = node.getAttribute("uom") │ │ │ │ - } else { │ │ │ │ - this.readChildNodes(node, result) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - sa: OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.sa, │ │ │ │ - gml: OpenLayers.Util.applyDefaults({ │ │ │ │ - TimeInstant: function(node, samplingTime) { │ │ │ │ - var timeInstant = {}; │ │ │ │ - samplingTime.timeInstant = timeInstant; │ │ │ │ - this.readChildNodes(node, timeInstant) │ │ │ │ - }, │ │ │ │ - timePosition: function(node, timeInstant) { │ │ │ │ - timeInstant.timePosition = this.getChildValue(node) │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.SOSGetFeatureOfInterest.prototype.readers.gml) │ │ │ │ + removeLayer: function(evt) { │ │ │ │ + evt.layer.events.unregister(this.fetchEvent, this, this.fetch) │ │ │ │ }, │ │ │ │ - writers: { │ │ │ │ - sos: { │ │ │ │ - GetObservation: function(options) { │ │ │ │ - var node = this.createElementNSPlus("GetObservation", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - service: "SOS" │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("offering", options, node); │ │ │ │ - if (options.eventTime) { │ │ │ │ - this.writeNode("eventTime", options, node) │ │ │ │ - } │ │ │ │ - for (var procedure in options.procedures) { │ │ │ │ - this.writeNode("procedure", options.procedures[procedure], node) │ │ │ │ - } │ │ │ │ - for (var observedProperty in options.observedProperties) { │ │ │ │ - this.writeNode("observedProperty", options.observedProperties[observedProperty], node) │ │ │ │ - } │ │ │ │ - if (options.foi) { │ │ │ │ - this.writeNode("featureOfInterest", options.foi, node) │ │ │ │ - } │ │ │ │ - this.writeNode("responseFormat", options, node); │ │ │ │ - if (options.resultModel) { │ │ │ │ - this.writeNode("resultModel", options, node) │ │ │ │ - } │ │ │ │ - if (options.responseMode) { │ │ │ │ - this.writeNode("responseMode", options, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - featureOfInterest: function(foi) { │ │ │ │ - var node = this.createElementNSPlus("featureOfInterest"); │ │ │ │ - this.writeNode("ObjectID", foi.objectId, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - ObjectID: function(options) { │ │ │ │ - return this.createElementNSPlus("ObjectID", { │ │ │ │ - value: options │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - responseFormat: function(options) { │ │ │ │ - return this.createElementNSPlus("responseFormat", { │ │ │ │ - value: options.responseFormat │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - procedure: function(procedure) { │ │ │ │ - return this.createElementNSPlus("procedure", { │ │ │ │ - value: procedure │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - offering: function(options) { │ │ │ │ - return this.createElementNSPlus("offering", { │ │ │ │ - value: options.offering │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - observedProperty: function(observedProperty) { │ │ │ │ - return this.createElementNSPlus("observedProperty", { │ │ │ │ - value: observedProperty │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - eventTime: function(options) { │ │ │ │ - var node = this.createElementNSPlus("eventTime"); │ │ │ │ - if (options.eventTime === "latest") { │ │ │ │ - this.writeNode("ogc:TM_Equals", options, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - resultModel: function(options) { │ │ │ │ - return this.createElementNSPlus("resultModel", { │ │ │ │ - value: options.resultModel │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - responseMode: function(options) { │ │ │ │ - return this.createElementNSPlus("responseMode", { │ │ │ │ - value: options.responseMode │ │ │ │ - }) │ │ │ │ + fetch: function(evt) { │ │ │ │ + if (this.active && window.localStorage && evt.tile instanceof OpenLayers.Tile.Image) { │ │ │ │ + var tile = evt.tile, │ │ │ │ + url = tile.url; │ │ │ │ + if (!tile.layer.crossOriginKeyword && OpenLayers.ProxyHost && url.indexOf(OpenLayers.ProxyHost) === 0) { │ │ │ │ + url = OpenLayers.Control.CacheWrite.urlMap[url] │ │ │ │ } │ │ │ │ - }, │ │ │ │ - ogc: { │ │ │ │ - TM_Equals: function(options) { │ │ │ │ - var node = this.createElementNSPlus("ogc:TM_Equals"); │ │ │ │ - this.writeNode("ogc:PropertyName", { │ │ │ │ - property: "urn:ogc:data:time:iso8601" │ │ │ │ - }, node); │ │ │ │ - if (options.eventTime === "latest") { │ │ │ │ - this.writeNode("gml:TimeInstant", { │ │ │ │ - value: "latest" │ │ │ │ - }, node) │ │ │ │ + var dataURI = window.localStorage.getItem("olCache_" + url); │ │ │ │ + if (dataURI) { │ │ │ │ + tile.url = dataURI; │ │ │ │ + if (evt.type === "tileerror") { │ │ │ │ + tile.setImgSrc(dataURI) │ │ │ │ } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - PropertyName: function(options) { │ │ │ │ - return this.createElementNSPlus("ogc:PropertyName", { │ │ │ │ - value: options.property │ │ │ │ - }) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - gml: { │ │ │ │ - TimeInstant: function(options) { │ │ │ │ - var node = this.createElementNSPlus("gml:TimeInstant"); │ │ │ │ - this.writeNode("gml:timePosition", options, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - timePosition: function(options) { │ │ │ │ - var node = this.createElementNSPlus("gml:timePosition", { │ │ │ │ - value: options.value │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layers || this.map) { │ │ │ │ + var i, layers = this.layers || this.map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.un({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSGetObservation" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.1.1", │ │ │ │ - profile: null, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.CacheRead" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.CQL = function() { │ │ │ │ - var tokens = ["PROPERTY", "COMPARISON", "VALUE", "LOGICAL"], │ │ │ │ - patterns = { │ │ │ │ - PROPERTY: /^[_a-zA-Z]\w*/, │ │ │ │ - COMPARISON: /^(=|<>|<=|<|>=|>|LIKE)/i, │ │ │ │ - IS_NULL: /^IS NULL/i, │ │ │ │ - COMMA: /^,/, │ │ │ │ - LOGICAL: /^(AND|OR)/i, │ │ │ │ - VALUE: /^('([^']|'')*'|\d+(\.\d*)?|\.\d+)/, │ │ │ │ - LPAREN: /^\(/, │ │ │ │ - RPAREN: /^\)/, │ │ │ │ - SPATIAL: /^(BBOX|INTERSECTS|DWITHIN|WITHIN|CONTAINS)/i, │ │ │ │ - NOT: /^NOT/i, │ │ │ │ - BETWEEN: /^BETWEEN/i, │ │ │ │ - GEOMETRY: function(text) { │ │ │ │ - var type = /^(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)/.exec(text); │ │ │ │ - if (type) { │ │ │ │ - var len = text.length; │ │ │ │ - var idx = text.indexOf("(", type[0].length); │ │ │ │ - if (idx > -1) { │ │ │ │ - var depth = 1; │ │ │ │ - while (idx < len && depth > 0) { │ │ │ │ - idx++; │ │ │ │ - switch (text.charAt(idx)) { │ │ │ │ - case "(": │ │ │ │ - depth++; │ │ │ │ - break; │ │ │ │ - case ")": │ │ │ │ - depth--; │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return [text.substr(0, idx + 1)] │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - END: /^$/ │ │ │ │ - }, │ │ │ │ - follows = { │ │ │ │ - LPAREN: ["GEOMETRY", "SPATIAL", "PROPERTY", "VALUE", "LPAREN"], │ │ │ │ - RPAREN: ["NOT", "LOGICAL", "END", "RPAREN"], │ │ │ │ - PROPERTY: ["COMPARISON", "BETWEEN", "COMMA", "IS_NULL"], │ │ │ │ - BETWEEN: ["VALUE"], │ │ │ │ - IS_NULL: ["END"], │ │ │ │ - COMPARISON: ["VALUE"], │ │ │ │ - COMMA: ["GEOMETRY", "VALUE", "PROPERTY"], │ │ │ │ - VALUE: ["LOGICAL", "COMMA", "RPAREN", "END"], │ │ │ │ - SPATIAL: ["LPAREN"], │ │ │ │ - LOGICAL: ["NOT", "VALUE", "SPATIAL", "PROPERTY", "LPAREN"], │ │ │ │ - NOT: ["PROPERTY", "LPAREN"], │ │ │ │ - GEOMETRY: ["COMMA", "RPAREN"] │ │ │ │ - }, │ │ │ │ - operators = { │ │ │ │ - "=": OpenLayers.Filter.Comparison.EQUAL_TO, │ │ │ │ - "<>": OpenLayers.Filter.Comparison.NOT_EQUAL_TO, │ │ │ │ - "<": OpenLayers.Filter.Comparison.LESS_THAN, │ │ │ │ - "<=": OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO, │ │ │ │ - ">": OpenLayers.Filter.Comparison.GREATER_THAN, │ │ │ │ - ">=": OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO, │ │ │ │ - LIKE: OpenLayers.Filter.Comparison.LIKE, │ │ │ │ - BETWEEN: OpenLayers.Filter.Comparison.BETWEEN, │ │ │ │ - "IS NULL": OpenLayers.Filter.Comparison.IS_NULL │ │ │ │ - }, │ │ │ │ - operatorReverse = {}, │ │ │ │ - logicals = { │ │ │ │ - AND: OpenLayers.Filter.Logical.AND, │ │ │ │ - OR: OpenLayers.Filter.Logical.OR │ │ │ │ - }, │ │ │ │ - logicalReverse = {}, │ │ │ │ - precedence = { │ │ │ │ - RPAREN: 3, │ │ │ │ - LOGICAL: 2, │ │ │ │ - COMPARISON: 1 │ │ │ │ - }; │ │ │ │ - var i; │ │ │ │ - for (i in operators) { │ │ │ │ - if (operators.hasOwnProperty(i)) { │ │ │ │ - operatorReverse[operators[i]] = i │ │ │ │ - } │ │ │ │ - } │ │ │ │ - for (i in logicals) { │ │ │ │ - if (logicals.hasOwnProperty(i)) { │ │ │ │ - logicalReverse[logicals[i]] = i │ │ │ │ +OpenLayers.Control.Split = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + layer: null, │ │ │ │ + source: null, │ │ │ │ + sourceOptions: null, │ │ │ │ + tolerance: null, │ │ │ │ + edge: true, │ │ │ │ + deferDelete: false, │ │ │ │ + mutual: true, │ │ │ │ + targetFilter: null, │ │ │ │ + sourceFilter: null, │ │ │ │ + handler: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options || {}; │ │ │ │ + if (this.options.source) { │ │ │ │ + this.setSource(this.options.source) │ │ │ │ } │ │ │ │ - } │ │ │ │ - │ │ │ │ - function tryToken(text, pattern) { │ │ │ │ - if (pattern instanceof RegExp) { │ │ │ │ - return pattern.exec(text) │ │ │ │ + }, │ │ │ │ + setSource: function(layer) { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.destroy(); │ │ │ │ + delete this.handler │ │ │ │ + } │ │ │ │ + this.source = layer; │ │ │ │ + this.activate() │ │ │ │ } else { │ │ │ │ - return pattern(text) │ │ │ │ + this.source = layer │ │ │ │ } │ │ │ │ - } │ │ │ │ - │ │ │ │ - function nextToken(text, tokens) { │ │ │ │ - var i, token, len = tokens.length; │ │ │ │ - for (i = 0; i < len; i++) { │ │ │ │ - token = tokens[i]; │ │ │ │ - var pat = patterns[token]; │ │ │ │ - var matches = tryToken(text, pat); │ │ │ │ - if (matches) { │ │ │ │ - var match = matches[0]; │ │ │ │ - var remainder = text.substr(match.length).replace(/^\s*/, ""); │ │ │ │ - return { │ │ │ │ - type: token, │ │ │ │ - text: match, │ │ │ │ - remainder: remainder │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (!this.source) { │ │ │ │ + if (!this.handler) { │ │ │ │ + this.handler = new OpenLayers.Handler.Path(this, { │ │ │ │ + done: function(geometry) { │ │ │ │ + this.onSketchComplete({ │ │ │ │ + feature: new OpenLayers.Feature.Vector(geometry) │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, { │ │ │ │ + layerOptions: this.sourceOptions │ │ │ │ + }) │ │ │ │ } │ │ │ │ + this.handler.activate() │ │ │ │ + } else if (this.source.events) { │ │ │ │ + this.source.events.on({ │ │ │ │ + sketchcomplete: this.onSketchComplete, │ │ │ │ + afterfeaturemodified: this.afterFeatureModified, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ - var msg = "ERROR: In parsing: [" + text + "], expected one of: "; │ │ │ │ - for (i = 0; i < len; i++) { │ │ │ │ - token = tokens[i]; │ │ │ │ - msg += "\n " + token + ": " + patterns[token] │ │ │ │ - } │ │ │ │ - throw new Error(msg) │ │ │ │ - } │ │ │ │ - │ │ │ │ - function tokenize(text) { │ │ │ │ - var results = []; │ │ │ │ - var token, expect = ["NOT", "GEOMETRY", "SPATIAL", "PROPERTY", "LPAREN"]; │ │ │ │ - do { │ │ │ │ - token = nextToken(text, expect); │ │ │ │ - text = token.remainder; │ │ │ │ - expect = follows[token.type]; │ │ │ │ - if (token.type != "END" && !expect) { │ │ │ │ - throw new Error("No follows list for " + token.type) │ │ │ │ - } │ │ │ │ - results.push(token) │ │ │ │ - } while (token.type != "END"); │ │ │ │ - return results │ │ │ │ - } │ │ │ │ - │ │ │ │ - function buildAst(tokens) { │ │ │ │ - var operatorStack = [], │ │ │ │ - postfix = []; │ │ │ │ - while (tokens.length) { │ │ │ │ - var tok = tokens.shift(); │ │ │ │ - switch (tok.type) { │ │ │ │ - case "PROPERTY": │ │ │ │ - case "GEOMETRY": │ │ │ │ - case "VALUE": │ │ │ │ - postfix.push(tok); │ │ │ │ - break; │ │ │ │ - case "COMPARISON": │ │ │ │ - case "BETWEEN": │ │ │ │ - case "IS_NULL": │ │ │ │ - case "LOGICAL": │ │ │ │ - var p = precedence[tok.type]; │ │ │ │ - while (operatorStack.length > 0 && precedence[operatorStack[operatorStack.length - 1].type] <= p) { │ │ │ │ - postfix.push(operatorStack.pop()) │ │ │ │ - } │ │ │ │ - operatorStack.push(tok); │ │ │ │ - break; │ │ │ │ - case "SPATIAL": │ │ │ │ - case "NOT": │ │ │ │ - case "LPAREN": │ │ │ │ - operatorStack.push(tok); │ │ │ │ - break; │ │ │ │ - case "RPAREN": │ │ │ │ - while (operatorStack.length > 0 && operatorStack[operatorStack.length - 1].type != "LPAREN") { │ │ │ │ - postfix.push(operatorStack.pop()) │ │ │ │ - } │ │ │ │ - operatorStack.pop(); │ │ │ │ - if (operatorStack.length > 0 && operatorStack[operatorStack.length - 1].type == "SPATIAL") { │ │ │ │ - postfix.push(operatorStack.pop()) │ │ │ │ - } │ │ │ │ - case "COMMA": │ │ │ │ - case "END": │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - throw new Error("Unknown token type " + tok.type) │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + if (this.source && this.source.events) { │ │ │ │ + this.source.events.un({ │ │ │ │ + sketchcomplete: this.onSketchComplete, │ │ │ │ + afterfeaturemodified: this.afterFeatureModified, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ - while (operatorStack.length > 0) { │ │ │ │ - postfix.push(operatorStack.pop()) │ │ │ │ - } │ │ │ │ - │ │ │ │ - function buildTree() { │ │ │ │ - var tok = postfix.pop(); │ │ │ │ - switch (tok.type) { │ │ │ │ - case "LOGICAL": │ │ │ │ - var rhs = buildTree(), │ │ │ │ - lhs = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Logical({ │ │ │ │ - filters: [lhs, rhs], │ │ │ │ - type: logicals[tok.text.toUpperCase()] │ │ │ │ - }); │ │ │ │ - case "NOT": │ │ │ │ - var operand = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Logical({ │ │ │ │ - filters: [operand], │ │ │ │ - type: OpenLayers.Filter.Logical.NOT │ │ │ │ - }); │ │ │ │ - case "BETWEEN": │ │ │ │ - var min, max, property; │ │ │ │ - postfix.pop(); │ │ │ │ - max = buildTree(); │ │ │ │ - min = buildTree(); │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Comparison({ │ │ │ │ - property: property, │ │ │ │ - lowerBoundary: min, │ │ │ │ - upperBoundary: max, │ │ │ │ - type: OpenLayers.Filter.Comparison.BETWEEN │ │ │ │ - }); │ │ │ │ - case "COMPARISON": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Comparison({ │ │ │ │ - property: property, │ │ │ │ - value: value, │ │ │ │ - type: operators[tok.text.toUpperCase()] │ │ │ │ - }); │ │ │ │ - case "IS_NULL": │ │ │ │ - var property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Comparison({ │ │ │ │ - property: property, │ │ │ │ - type: operators[tok.text.toUpperCase()] │ │ │ │ - }); │ │ │ │ - case "VALUE": │ │ │ │ - var match = tok.text.match(/^'(.*)'$/); │ │ │ │ - if (match) { │ │ │ │ - return match[1].replace(/''/g, "'") │ │ │ │ - } else { │ │ │ │ - return Number(tok.text) │ │ │ │ - } │ │ │ │ - case "SPATIAL": │ │ │ │ - switch (tok.text.toUpperCase()) { │ │ │ │ - case "BBOX": │ │ │ │ - var maxy = buildTree(), │ │ │ │ - maxx = buildTree(), │ │ │ │ - miny = buildTree(), │ │ │ │ - minx = buildTree(), │ │ │ │ - prop = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ - property: prop, │ │ │ │ - value: OpenLayers.Bounds.fromArray([minx, miny, maxx, maxy]) │ │ │ │ - }); │ │ │ │ - case "INTERSECTS": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - case "WITHIN": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.WITHIN, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - case "CONTAINS": │ │ │ │ - var value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.CONTAINS, │ │ │ │ - property: property, │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - case "DWITHIN": │ │ │ │ - var distance = buildTree(), │ │ │ │ - value = buildTree(), │ │ │ │ - property = buildTree(); │ │ │ │ - return new OpenLayers.Filter.Spatial({ │ │ │ │ - type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ - value: value, │ │ │ │ - property: property, │ │ │ │ - distance: Number(distance) │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - case "GEOMETRY": │ │ │ │ - return OpenLayers.Geometry.fromWKT(tok.text); │ │ │ │ - default: │ │ │ │ - return tok.text │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + onSketchComplete: function(event) { │ │ │ │ + this.feature = null; │ │ │ │ + return !this.considerSplit(event.feature) │ │ │ │ + }, │ │ │ │ + afterFeatureModified: function(event) { │ │ │ │ + if (event.modified) { │ │ │ │ + var feature = event.feature; │ │ │ │ + if (typeof feature.geometry.split === "function") { │ │ │ │ + this.feature = event.feature; │ │ │ │ + this.considerSplit(event.feature) │ │ │ │ } │ │ │ │ } │ │ │ │ - var result = buildTree(); │ │ │ │ - if (postfix.length > 0) { │ │ │ │ - var msg = "Remaining tokens after building AST: \n"; │ │ │ │ - for (var i = postfix.length - 1; i >= 0; i--) { │ │ │ │ - msg += postfix[i].type + ": " + postfix[i].text + "\n" │ │ │ │ + }, │ │ │ │ + removeByGeometry: function(features, geometry) { │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + if (features[i].geometry === geometry) { │ │ │ │ + features.splice(i, 1); │ │ │ │ + break │ │ │ │ } │ │ │ │ - throw new Error(msg) │ │ │ │ } │ │ │ │ - return result │ │ │ │ - } │ │ │ │ - return OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - read: function(text) { │ │ │ │ - var result = buildAst(tokenize(text)); │ │ │ │ - if (this.keepData) { │ │ │ │ - this.data = result │ │ │ │ - } │ │ │ │ - return result │ │ │ │ - }, │ │ │ │ - write: function(filter) { │ │ │ │ - if (filter instanceof OpenLayers.Geometry) { │ │ │ │ - return filter.toString() │ │ │ │ - } │ │ │ │ - switch (filter.CLASS_NAME) { │ │ │ │ - case "OpenLayers.Filter.Spatial": │ │ │ │ - switch (filter.type) { │ │ │ │ - case OpenLayers.Filter.Spatial.BBOX: │ │ │ │ - return "BBOX(" + filter.property + "," + filter.value.toBBOX() + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.DWITHIN: │ │ │ │ - return "DWITHIN(" + filter.property + ", " + this.write(filter.value) + ", " + filter.distance + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.WITHIN: │ │ │ │ - return "WITHIN(" + filter.property + ", " + this.write(filter.value) + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.INTERSECTS: │ │ │ │ - return "INTERSECTS(" + filter.property + ", " + this.write(filter.value) + ")"; │ │ │ │ - case OpenLayers.Filter.Spatial.CONTAINS: │ │ │ │ - return "CONTAINS(" + filter.property + ", " + this.write(filter.value) + ")"; │ │ │ │ - default: │ │ │ │ - throw new Error("Unknown spatial filter type: " + filter.type) │ │ │ │ - } │ │ │ │ - case "OpenLayers.Filter.Logical": │ │ │ │ - if (filter.type == OpenLayers.Filter.Logical.NOT) { │ │ │ │ - return "NOT (" + this.write(filter.filters[0]) + ")" │ │ │ │ - } else { │ │ │ │ - var res = "("; │ │ │ │ - var first = true; │ │ │ │ - for (var i = 0; i < filter.filters.length; i++) { │ │ │ │ - if (first) { │ │ │ │ - first = false │ │ │ │ - } else { │ │ │ │ - res += ") " + logicalReverse[filter.type] + " (" │ │ │ │ + }, │ │ │ │ + isEligible: function(target) { │ │ │ │ + if (!target.geometry) { │ │ │ │ + return false │ │ │ │ + } else { │ │ │ │ + return target.state !== OpenLayers.State.DELETE && typeof target.geometry.split === "function" && this.feature !== target && (!this.targetFilter || this.targetFilter.evaluate(target.attributes)) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + considerSplit: function(feature) { │ │ │ │ + var sourceSplit = false; │ │ │ │ + var targetSplit = false; │ │ │ │ + if (!this.sourceFilter || this.sourceFilter.evaluate(feature.attributes)) { │ │ │ │ + var features = this.layer && this.layer.features || []; │ │ │ │ + var target, results, proceed; │ │ │ │ + var additions = [], │ │ │ │ + removals = []; │ │ │ │ + var mutual = this.layer === this.source && this.mutual; │ │ │ │ + var options = { │ │ │ │ + edge: this.edge, │ │ │ │ + tolerance: this.tolerance, │ │ │ │ + mutual: mutual │ │ │ │ + }; │ │ │ │ + var sourceParts = [feature.geometry]; │ │ │ │ + var targetFeature, targetParts; │ │ │ │ + var source, parts; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + targetFeature = features[i]; │ │ │ │ + if (this.isEligible(targetFeature)) { │ │ │ │ + targetParts = [targetFeature.geometry]; │ │ │ │ + for (var j = 0; j < sourceParts.length; ++j) { │ │ │ │ + source = sourceParts[j]; │ │ │ │ + for (var k = 0; k < targetParts.length; ++k) { │ │ │ │ + target = targetParts[k]; │ │ │ │ + if (source.getBounds().intersectsBounds(target.getBounds())) { │ │ │ │ + results = source.split(target, options); │ │ │ │ + if (results) { │ │ │ │ + proceed = this.events.triggerEvent("beforesplit", { │ │ │ │ + source: feature, │ │ │ │ + target: targetFeature │ │ │ │ + }); │ │ │ │ + if (proceed !== false) { │ │ │ │ + if (mutual) { │ │ │ │ + parts = results[0]; │ │ │ │ + if (parts.length > 1) { │ │ │ │ + parts.unshift(j, 1); │ │ │ │ + Array.prototype.splice.apply(sourceParts, parts); │ │ │ │ + j += parts.length - 3 │ │ │ │ + } │ │ │ │ + results = results[1] │ │ │ │ + } │ │ │ │ + if (results.length > 1) { │ │ │ │ + results.unshift(k, 1); │ │ │ │ + Array.prototype.splice.apply(targetParts, results); │ │ │ │ + k += results.length - 3 │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - res += this.write(filter.filters[i]) │ │ │ │ } │ │ │ │ - return res + ")" │ │ │ │ - } │ │ │ │ - case "OpenLayers.Filter.Comparison": │ │ │ │ - if (filter.type == OpenLayers.Filter.Comparison.BETWEEN) { │ │ │ │ - return filter.property + " BETWEEN " + this.write(filter.lowerBoundary) + " AND " + this.write(filter.upperBoundary) │ │ │ │ - } else { │ │ │ │ - return filter.value !== null ? filter.property + " " + operatorReverse[filter.type] + " " + this.write(filter.value) : filter.property + " " + operatorReverse[filter.type] │ │ │ │ } │ │ │ │ - case undefined: │ │ │ │ - if (typeof filter === "string") { │ │ │ │ - return "'" + filter.replace(/'/g, "''") + "'" │ │ │ │ - } else if (typeof filter === "number") { │ │ │ │ - return String(filter) │ │ │ │ + if (targetParts && targetParts.length > 1) { │ │ │ │ + this.geomsToFeatures(targetFeature, targetParts); │ │ │ │ + this.events.triggerEvent("split", { │ │ │ │ + original: targetFeature, │ │ │ │ + features: targetParts │ │ │ │ + }); │ │ │ │ + Array.prototype.push.apply(additions, targetParts); │ │ │ │ + removals.push(targetFeature); │ │ │ │ + targetSplit = true │ │ │ │ } │ │ │ │ - default: │ │ │ │ - throw new Error("Can't encode: " + filter.CLASS_NAME + " " + filter) │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.CQL" │ │ │ │ - }) │ │ │ │ -}(); │ │ │ │ -OpenLayers.Format.WMC = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ - layerToContext: function(layer) { │ │ │ │ - var parser = this.getParser(); │ │ │ │ - var layerContext = { │ │ │ │ - queryable: layer.queryable, │ │ │ │ - visibility: layer.visibility, │ │ │ │ - name: layer.params["LAYERS"], │ │ │ │ - title: layer.name, │ │ │ │ - abstract: layer.metadata["abstract"], │ │ │ │ - dataURL: layer.metadata.dataURL, │ │ │ │ - metadataURL: layer.metadataURL, │ │ │ │ - server: { │ │ │ │ - version: layer.params["VERSION"], │ │ │ │ - url: layer.url │ │ │ │ - }, │ │ │ │ - maxExtent: layer.maxExtent, │ │ │ │ - transparent: layer.params["TRANSPARENT"], │ │ │ │ - numZoomLevels: layer.numZoomLevels, │ │ │ │ - units: layer.units, │ │ │ │ - isBaseLayer: layer.isBaseLayer, │ │ │ │ - opacity: layer.opacity == 1 ? undefined : layer.opacity, │ │ │ │ - displayInLayerSwitcher: layer.displayInLayerSwitcher, │ │ │ │ - singleTile: layer.singleTile, │ │ │ │ - tileSize: layer.singleTile || !layer.tileSize ? undefined : { │ │ │ │ - width: layer.tileSize.w, │ │ │ │ - height: layer.tileSize.h │ │ │ │ - }, │ │ │ │ - minScale: layer.options.resolutions || layer.options.scales || layer.options.maxResolution || layer.options.minScale ? layer.minScale : undefined, │ │ │ │ - maxScale: layer.options.resolutions || layer.options.scales || layer.options.minResolution || layer.options.maxScale ? layer.maxScale : undefined, │ │ │ │ - formats: [], │ │ │ │ - styles: [], │ │ │ │ - srs: layer.srs, │ │ │ │ - dimensions: layer.dimensions │ │ │ │ - }; │ │ │ │ - if (layer.metadata.servertitle) { │ │ │ │ - layerContext.server.title = layer.metadata.servertitle │ │ │ │ - } │ │ │ │ - if (layer.metadata.formats && layer.metadata.formats.length > 0) { │ │ │ │ - for (var i = 0, len = layer.metadata.formats.length; i < len; i++) { │ │ │ │ - var format = layer.metadata.formats[i]; │ │ │ │ - layerContext.formats.push({ │ │ │ │ - value: format.value, │ │ │ │ - current: format.value == layer.params["FORMAT"] │ │ │ │ - }) │ │ │ │ + if (sourceParts && sourceParts.length > 1) { │ │ │ │ + this.geomsToFeatures(feature, sourceParts); │ │ │ │ + this.events.triggerEvent("split", { │ │ │ │ + original: feature, │ │ │ │ + features: sourceParts │ │ │ │ + }); │ │ │ │ + Array.prototype.push.apply(additions, sourceParts); │ │ │ │ + removals.push(feature); │ │ │ │ + sourceSplit = true │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - layerContext.formats.push({ │ │ │ │ - value: layer.params["FORMAT"], │ │ │ │ - current: true │ │ │ │ - }) │ │ │ │ - } │ │ │ │ - if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ - for (var i = 0, len = layer.metadata.styles.length; i < len; i++) { │ │ │ │ - var style = layer.metadata.styles[i]; │ │ │ │ - if (style.href == layer.params["SLD"] || style.body == layer.params["SLD_BODY"] || style.name == layer.params["STYLES"]) { │ │ │ │ - style.current = true │ │ │ │ + if (sourceSplit || targetSplit) { │ │ │ │ + if (this.deferDelete) { │ │ │ │ + var feat, destroys = []; │ │ │ │ + for (var i = 0, len = removals.length; i < len; ++i) { │ │ │ │ + feat = removals[i]; │ │ │ │ + if (feat.state === OpenLayers.State.INSERT) { │ │ │ │ + destroys.push(feat) │ │ │ │ + } else { │ │ │ │ + feat.state = OpenLayers.State.DELETE; │ │ │ │ + this.layer.drawFeature(feat) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.layer.destroyFeatures(destroys, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + for (var i = 0, len = additions.length; i < len; ++i) { │ │ │ │ + additions[i].state = OpenLayers.State.INSERT │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - style.current = false │ │ │ │ + this.layer.destroyFeatures(removals, { │ │ │ │ + silent: true │ │ │ │ + }) │ │ │ │ } │ │ │ │ - layerContext.styles.push(style) │ │ │ │ + this.layer.addFeatures(additions, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.events.triggerEvent("aftersplit", { │ │ │ │ + source: feature, │ │ │ │ + features: additions │ │ │ │ + }) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - layerContext.styles.push({ │ │ │ │ - href: layer.params["SLD"], │ │ │ │ - body: layer.params["SLD_BODY"], │ │ │ │ - name: layer.params["STYLES"] || parser.defaultStyleName, │ │ │ │ - title: parser.defaultStyleTitle, │ │ │ │ - current: true │ │ │ │ - }) │ │ │ │ } │ │ │ │ - return layerContext │ │ │ │ + return sourceSplit │ │ │ │ }, │ │ │ │ - toContext: function(obj) { │ │ │ │ - var context = {}; │ │ │ │ - var layers = obj.layers; │ │ │ │ - if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ - var metadata = obj.metadata || {}; │ │ │ │ - context.size = obj.getSize(); │ │ │ │ - context.bounds = obj.getExtent(); │ │ │ │ - context.projection = obj.projection; │ │ │ │ - context.title = obj.title; │ │ │ │ - context.keywords = metadata.keywords; │ │ │ │ - context["abstract"] = metadata["abstract"]; │ │ │ │ - context.logo = metadata.logo; │ │ │ │ - context.descriptionURL = metadata.descriptionURL; │ │ │ │ - context.contactInformation = metadata.contactInformation; │ │ │ │ - context.maxExtent = obj.maxExtent │ │ │ │ - } else { │ │ │ │ - OpenLayers.Util.applyDefaults(context, obj); │ │ │ │ - if (context.layers != undefined) { │ │ │ │ - delete context.layers │ │ │ │ - } │ │ │ │ + geomsToFeatures: function(feature, geoms) { │ │ │ │ + var clone = feature.clone(); │ │ │ │ + delete clone.geometry; │ │ │ │ + var newFeature; │ │ │ │ + for (var i = 0, len = geoms.length; i < len; ++i) { │ │ │ │ + newFeature = clone.clone(); │ │ │ │ + newFeature.geometry = geoms[i]; │ │ │ │ + newFeature.state = OpenLayers.State.INSERT; │ │ │ │ + geoms[i] = newFeature │ │ │ │ } │ │ │ │ - if (context.layersContext == undefined) { │ │ │ │ - context.layersContext = [] │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate() │ │ │ │ } │ │ │ │ - if (layers != undefined && OpenLayers.Util.isArray(layers)) { │ │ │ │ - for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ - var layer = layers[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ - context.layersContext.push(this.layerToContext(layer)) │ │ │ │ + OpenLayers.Control.prototype.destroy.call(this) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Split" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Attribution = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + separator: ", ", │ │ │ │ + template: "${layers}", │ │ │ │ + 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) │ │ │ │ + }, │ │ │ │ + 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 │ │ │ │ + }, │ │ │ │ + updateAttribution: function() { │ │ │ │ + var attributions = []; │ │ │ │ + if (this.map && this.map.layers) { │ │ │ │ + for (var i = 0, len = this.map.layers.length; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + if (layer.attribution && layer.getVisibility()) { │ │ │ │ + if (OpenLayers.Util.indexOf(attributions, layer.attribution) === -1) { │ │ │ │ + attributions.push(layer.attribution) │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + this.div.innerHTML = OpenLayers.String.format(this.template, { │ │ │ │ + layers: attributions.join(this.separator) │ │ │ │ + }) │ │ │ │ } │ │ │ │ - return context │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WPSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.0.0", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WPSCapabilities" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Attribution" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.EncodedPolyline = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ - geometryType: "linestring", │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.prototype.initialize.apply(this, [options]) │ │ │ │ +OpenLayers.Control.KeyboardDefaults = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + autoActivate: true, │ │ │ │ + slideFactor: 75, │ │ │ │ + observeElement: null, │ │ │ │ + draw: function() { │ │ │ │ + var observeElement = this.observeElement || document; │ │ │ │ + this.handler = new OpenLayers.Handler.Keyboard(this, { │ │ │ │ + keydown: this.defaultKeyPress │ │ │ │ + }, { │ │ │ │ + observeElement: observeElement │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - read: function(encoded) { │ │ │ │ - var geomType; │ │ │ │ - if (this.geometryType == "linestring") geomType = OpenLayers.Geometry.LineString; │ │ │ │ - else if (this.geometryType == "linearring") geomType = OpenLayers.Geometry.LinearRing; │ │ │ │ - else if (this.geometryType == "multipoint") geomType = OpenLayers.Geometry.MultiPoint; │ │ │ │ - else if (this.geometryType != "point" && this.geometryType != "polygon") return null; │ │ │ │ - var flatPoints = this.decodeDeltas(encoded, 2); │ │ │ │ - var flatPointsLength = flatPoints.length; │ │ │ │ - var pointGeometries = []; │ │ │ │ - for (var i = 0; i + 1 < flatPointsLength;) { │ │ │ │ - var y = flatPoints[i++], │ │ │ │ - x = flatPoints[i++]; │ │ │ │ - pointGeometries.push(new OpenLayers.Geometry.Point(x, y)) │ │ │ │ + defaultKeyPress: function(evt) { │ │ │ │ + var size, handled = true; │ │ │ │ + var target = OpenLayers.Event.element(evt); │ │ │ │ + if (target && (target.tagName == "INPUT" || target.tagName == "TEXTAREA" || target.tagName == "SELECT")) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - if (this.geometryType == "point") return new OpenLayers.Feature.Vector(pointGeometries[0]); │ │ │ │ - if (this.geometryType == "polygon") return new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(pointGeometries)])); │ │ │ │ - return new OpenLayers.Feature.Vector(new geomType(pointGeometries)) │ │ │ │ - }, │ │ │ │ - decode: function(encoded, dims, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var flatPoints = this.decodeDeltas(encoded, dims, factor); │ │ │ │ - var flatPointsLength = flatPoints.length; │ │ │ │ - var points = []; │ │ │ │ - for (var i = 0; i + (dims - 1) < flatPointsLength;) { │ │ │ │ - var point = []; │ │ │ │ - for (var dim = 0; dim < dims; ++dim) { │ │ │ │ - point.push(flatPoints[i++]) │ │ │ │ - } │ │ │ │ - points.push(point) │ │ │ │ + switch (evt.keyCode) { │ │ │ │ + case OpenLayers.Event.KEY_LEFT: │ │ │ │ + this.map.pan(-this.slideFactor, 0); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Event.KEY_RIGHT: │ │ │ │ + this.map.pan(this.slideFactor, 0); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Event.KEY_UP: │ │ │ │ + this.map.pan(0, -this.slideFactor); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Event.KEY_DOWN: │ │ │ │ + this.map.pan(0, this.slideFactor); │ │ │ │ + break; │ │ │ │ + case 33: │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(0, -.75 * size.h); │ │ │ │ + break; │ │ │ │ + case 34: │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(0, .75 * size.h); │ │ │ │ + break; │ │ │ │ + case 35: │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(.75 * size.w, 0); │ │ │ │ + break; │ │ │ │ + case 36: │ │ │ │ + size = this.map.getSize(); │ │ │ │ + this.map.pan(-.75 * size.w, 0); │ │ │ │ + break; │ │ │ │ + case 43: │ │ │ │ + case 61: │ │ │ │ + case 187: │ │ │ │ + case 107: │ │ │ │ + this.map.zoomIn(); │ │ │ │ + break; │ │ │ │ + case 45: │ │ │ │ + case 109: │ │ │ │ + case 189: │ │ │ │ + case 95: │ │ │ │ + this.map.zoomOut(); │ │ │ │ + break; │ │ │ │ + default: │ │ │ │ + handled = false │ │ │ │ } │ │ │ │ - return points │ │ │ │ - }, │ │ │ │ - write: function(features) { │ │ │ │ - var feature; │ │ │ │ - if (features.constructor == Array) feature = features[0]; │ │ │ │ - else feature = features; │ │ │ │ - var geometry = feature.geometry; │ │ │ │ - var type = geometry.CLASS_NAME.split(".")[2].toLowerCase(); │ │ │ │ - var pointGeometries; │ │ │ │ - if (type == "point") pointGeometries = new Array(geometry); │ │ │ │ - else if (type == "linestring" || type == "linearring" || type == "multipoint") pointGeometries = geometry.components; │ │ │ │ - else if (type == "polygon") pointGeometries = geometry.components[0].components; │ │ │ │ - else return null; │ │ │ │ - var flatPoints = []; │ │ │ │ - var pointGeometriesLength = pointGeometries.length; │ │ │ │ - for (var i = 0; i < pointGeometriesLength; ++i) { │ │ │ │ - var pointGeometry = pointGeometries[i]; │ │ │ │ - flatPoints.push(pointGeometry.y); │ │ │ │ - flatPoints.push(pointGeometry.x) │ │ │ │ + if (handled) { │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ } │ │ │ │ - return this.encodeDeltas(flatPoints, 2) │ │ │ │ }, │ │ │ │ - encode: function(points, dims, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var flatPoints = []; │ │ │ │ - var pointsLength = points.length; │ │ │ │ - for (var i = 0; i < pointsLength; ++i) { │ │ │ │ - var point = points[i]; │ │ │ │ - for (var dim = 0; dim < dims; ++dim) { │ │ │ │ - flatPoints.push(point[dim]) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.KeyboardDefaults" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Button = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_BUTTON, │ │ │ │ + trigger: function() {}, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Button" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Pan = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + slideFactor: 50, │ │ │ │ + slideRatio: null, │ │ │ │ + direction: null, │ │ │ │ + initialize: function(direction, options) { │ │ │ │ + this.direction = direction; │ │ │ │ + this.CLASS_NAME += this.direction; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]) │ │ │ │ + }, │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + var getSlideFactor = OpenLayers.Function.bind(function(dim) { │ │ │ │ + return this.slideRatio ? this.map.getSize()[dim] * this.slideRatio : this.slideFactor │ │ │ │ + }, this); │ │ │ │ + switch (this.direction) { │ │ │ │ + case OpenLayers.Control.Pan.NORTH: │ │ │ │ + this.map.pan(0, -getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Control.Pan.SOUTH: │ │ │ │ + this.map.pan(0, getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Control.Pan.WEST: │ │ │ │ + this.map.pan(-getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + case OpenLayers.Control.Pan.EAST: │ │ │ │ + this.map.pan(getSlideFactor("w"), 0); │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - return this.encodeDeltas(flatPoints, dims, factor) │ │ │ │ }, │ │ │ │ - encodeDeltas: function(numbers, dimension, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var d; │ │ │ │ - var lastNumbers = new Array(dimension); │ │ │ │ - for (d = 0; d < dimension; ++d) { │ │ │ │ - lastNumbers[d] = 0 │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Pan" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Pan.NORTH = "North"; │ │ │ │ +OpenLayers.Control.Pan.SOUTH = "South"; │ │ │ │ +OpenLayers.Control.Pan.EAST = "East"; │ │ │ │ +OpenLayers.Control.Pan.WEST = "West"; │ │ │ │ +OpenLayers.Control.UTFGrid = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + autoActivate: true, │ │ │ │ + layers: null, │ │ │ │ + defaultHandlerOptions: { │ │ │ │ + delay: 300, │ │ │ │ + pixelTolerance: 4, │ │ │ │ + stopMove: false, │ │ │ │ + single: true, │ │ │ │ + double: false, │ │ │ │ + stopSingle: false, │ │ │ │ + stopDouble: false │ │ │ │ + }, │ │ │ │ + handlerMode: "click", │ │ │ │ + setHandler: function(hm) { │ │ │ │ + this.handlerMode = hm; │ │ │ │ + this.resetHandler() │ │ │ │ + }, │ │ │ │ + resetHandler: function() { │ │ │ │ + if (this.handler) { │ │ │ │ + this.handler.deactivate(); │ │ │ │ + this.handler.destroy(); │ │ │ │ + this.handler = null │ │ │ │ } │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength;) { │ │ │ │ - for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ - var num = numbers[i]; │ │ │ │ - var delta = num - lastNumbers[d]; │ │ │ │ - lastNumbers[d] = num; │ │ │ │ - numbers[i] = delta │ │ │ │ - } │ │ │ │ + if (this.handlerMode == "hover") { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ + pause: this.handleEvent, │ │ │ │ + move: this.reset │ │ │ │ + }, this.handlerOptions) │ │ │ │ + } else if (this.handlerMode == "click") { │ │ │ │ + this.handler = new OpenLayers.Handler.Click(this, { │ │ │ │ + click: this.handleEvent │ │ │ │ + }, this.handlerOptions) │ │ │ │ + } else if (this.handlerMode == "move") { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ + pause: this.handleEvent, │ │ │ │ + move: this.handleEvent │ │ │ │ + }, this.handlerOptions) │ │ │ │ + } │ │ │ │ + if (this.handler) { │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - return this.encodeFloats(numbers, factor) │ │ │ │ }, │ │ │ │ - decodeDeltas: function(encoded, dimension, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var d; │ │ │ │ - var lastNumbers = new Array(dimension); │ │ │ │ - for (d = 0; d < dimension; ++d) { │ │ │ │ - lastNumbers[d] = 0 │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.handlerOptions = options.handlerOptions || this.defaultHandlerOptions; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.resetHandler() │ │ │ │ + }, │ │ │ │ + handleEvent: function(evt) { │ │ │ │ + if (evt == null) { │ │ │ │ + this.reset(); │ │ │ │ + return │ │ │ │ } │ │ │ │ - var numbers = this.decodeFloats(encoded, factor); │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength;) { │ │ │ │ - for (d = 0; d < dimension; ++d, ++i) { │ │ │ │ - lastNumbers[d] += numbers[i]; │ │ │ │ - numbers[i] = lastNumbers[d] │ │ │ │ + var lonLat = this.map.getLonLatFromPixel(evt.xy); │ │ │ │ + if (!lonLat) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var layers = this.findLayers(); │ │ │ │ + if (layers.length > 0) { │ │ │ │ + var infoLookup = {}; │ │ │ │ + var layer, idx; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + layer = layers[i]; │ │ │ │ + idx = OpenLayers.Util.indexOf(this.map.layers, layer); │ │ │ │ + infoLookup[idx] = layer.getFeatureInfo(lonLat) │ │ │ │ } │ │ │ │ + this.callback(infoLookup, lonLat, evt.xy) │ │ │ │ } │ │ │ │ - return numbers │ │ │ │ }, │ │ │ │ - encodeFloats: function(numbers, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - numbers[i] = Math.round(numbers[i] * factor) │ │ │ │ - } │ │ │ │ - return this.encodeSignedIntegers(numbers) │ │ │ │ + callback: function(infoLookup) {}, │ │ │ │ + reset: function(evt) { │ │ │ │ + this.callback(null) │ │ │ │ }, │ │ │ │ - decodeFloats: function(encoded, opt_factor) { │ │ │ │ - var factor = opt_factor || 1e5; │ │ │ │ - var numbers = this.decodeSignedIntegers(encoded); │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - numbers[i] /= factor │ │ │ │ + findLayers: function() { │ │ │ │ + var candidates = this.layers || this.map.layers; │ │ │ │ + var layers = []; │ │ │ │ + var layer; │ │ │ │ + for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ + layer = candidates[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.UTFGrid) { │ │ │ │ + layers.push(layer) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return numbers │ │ │ │ + return layers │ │ │ │ }, │ │ │ │ - encodeSignedIntegers: function(numbers) { │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - var num = numbers[i]; │ │ │ │ - var signedNum = num << 1; │ │ │ │ - if (num < 0) { │ │ │ │ - signedNum = ~signedNum │ │ │ │ - } │ │ │ │ - numbers[i] = signedNum │ │ │ │ + CLASS_NAME: "OpenLayers.Control.UTFGrid" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.DragFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + geometryTypes: null, │ │ │ │ + onStart: function(feature, pixel) {}, │ │ │ │ + onDrag: function(feature, pixel) {}, │ │ │ │ + onComplete: function(feature, pixel) {}, │ │ │ │ + onEnter: function(feature) {}, │ │ │ │ + onLeave: function(feature) {}, │ │ │ │ + documentDrag: false, │ │ │ │ + layer: null, │ │ │ │ + feature: null, │ │ │ │ + dragCallbacks: {}, │ │ │ │ + featureCallbacks: {}, │ │ │ │ + lastPixel: null, │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.layer = layer; │ │ │ │ + this.handlers = { │ │ │ │ + drag: new OpenLayers.Handler.Drag(this, OpenLayers.Util.extend({ │ │ │ │ + down: this.downFeature, │ │ │ │ + move: this.moveFeature, │ │ │ │ + up: this.upFeature, │ │ │ │ + out: this.cancel, │ │ │ │ + done: this.doneDragging │ │ │ │ + }, this.dragCallbacks), { │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }), │ │ │ │ + feature: new OpenLayers.Handler.Feature(this, this.layer, OpenLayers.Util.extend({ │ │ │ │ + click: this.clickFeature, │ │ │ │ + clickout: this.clickoutFeature, │ │ │ │ + over: this.overFeature, │ │ │ │ + out: this.outFeature │ │ │ │ + }, this.featureCallbacks), { │ │ │ │ + geometryTypes: this.geometryTypes │ │ │ │ + }) │ │ │ │ } │ │ │ │ - return this.encodeUnsignedIntegers(numbers) │ │ │ │ }, │ │ │ │ - decodeSignedIntegers: function(encoded) { │ │ │ │ - var numbers = this.decodeUnsignedIntegers(encoded); │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - var num = numbers[i]; │ │ │ │ - numbers[i] = num & 1 ? ~(num >> 1) : num >> 1 │ │ │ │ + clickFeature: function(feature) { │ │ │ │ + if (this.handlers.feature.touch && !this.over && this.overFeature(feature)) { │ │ │ │ + this.handlers.drag.dragstart(this.handlers.feature.evt); │ │ │ │ + this.handlers.drag.stopDown = false │ │ │ │ } │ │ │ │ - return numbers │ │ │ │ }, │ │ │ │ - encodeUnsignedIntegers: function(numbers) { │ │ │ │ - var encoded = ""; │ │ │ │ - var numbersLength = numbers.length; │ │ │ │ - for (var i = 0; i < numbersLength; ++i) { │ │ │ │ - encoded += this.encodeUnsignedInteger(numbers[i]) │ │ │ │ + clickoutFeature: function(feature) { │ │ │ │ + if (this.handlers.feature.touch && this.over) { │ │ │ │ + this.outFeature(feature); │ │ │ │ + this.handlers.drag.stopDown = true │ │ │ │ } │ │ │ │ - return encoded │ │ │ │ }, │ │ │ │ - decodeUnsignedIntegers: function(encoded) { │ │ │ │ - var numbers = []; │ │ │ │ - var current = 0; │ │ │ │ - var shift = 0; │ │ │ │ - var encodedLength = encoded.length; │ │ │ │ - for (var i = 0; i < encodedLength; ++i) { │ │ │ │ - var b = encoded.charCodeAt(i) - 63; │ │ │ │ - current |= (b & 31) << shift; │ │ │ │ - if (b < 32) { │ │ │ │ - numbers.push(current); │ │ │ │ - current = 0; │ │ │ │ - shift = 0 │ │ │ │ + destroy: function() { │ │ │ │ + this.layer = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, []) │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + return this.handlers.feature.activate() && OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + this.handlers.feature.deactivate(); │ │ │ │ + this.feature = null; │ │ │ │ + this.dragging = false; │ │ │ │ + this.lastPixel = null; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + overFeature: function(feature) { │ │ │ │ + var activated = false; │ │ │ │ + if (!this.handlers.drag.dragging) { │ │ │ │ + this.feature = feature; │ │ │ │ + this.handlers.drag.activate(); │ │ │ │ + activated = true; │ │ │ │ + this.over = true; │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ + this.onEnter(feature) │ │ │ │ + } else { │ │ │ │ + if (this.feature.id == feature.id) { │ │ │ │ + this.over = true │ │ │ │ } else { │ │ │ │ - shift += 5 │ │ │ │ + this.over = false │ │ │ │ } │ │ │ │ } │ │ │ │ - return numbers │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - encodeFloat: function(num, opt_factor) { │ │ │ │ - num = Math.round(num * (opt_factor || 1e5)); │ │ │ │ - return this.encodeSignedInteger(num) │ │ │ │ + downFeature: function(pixel) { │ │ │ │ + this.lastPixel = pixel; │ │ │ │ + this.onStart(this.feature, pixel) │ │ │ │ }, │ │ │ │ - decodeFloat: function(encoded, opt_factor) { │ │ │ │ - var result = this.decodeSignedInteger(encoded); │ │ │ │ - return result / (opt_factor || 1e5) │ │ │ │ + moveFeature: function(pixel) { │ │ │ │ + var res = this.map.getResolution(); │ │ │ │ + this.feature.geometry.move(res * (pixel.x - this.lastPixel.x), res * (this.lastPixel.y - pixel.y)); │ │ │ │ + this.layer.drawFeature(this.feature); │ │ │ │ + this.lastPixel = pixel; │ │ │ │ + this.onDrag(this.feature, pixel) │ │ │ │ }, │ │ │ │ - encodeSignedInteger: function(num) { │ │ │ │ - var signedNum = num << 1; │ │ │ │ - if (num < 0) { │ │ │ │ - signedNum = ~signedNum │ │ │ │ + upFeature: function(pixel) { │ │ │ │ + if (!this.over) { │ │ │ │ + this.handlers.drag.deactivate() │ │ │ │ } │ │ │ │ - return this.encodeUnsignedInteger(signedNum) │ │ │ │ }, │ │ │ │ - decodeSignedInteger: function(encoded) { │ │ │ │ - var result = this.decodeUnsignedInteger(encoded); │ │ │ │ - return result & 1 ? ~(result >> 1) : result >> 1 │ │ │ │ + doneDragging: function(pixel) { │ │ │ │ + this.onComplete(this.feature, pixel) │ │ │ │ }, │ │ │ │ - encodeUnsignedInteger: function(num) { │ │ │ │ - var value, encoded = ""; │ │ │ │ - while (num >= 32) { │ │ │ │ - value = (32 | num & 31) + 63; │ │ │ │ - encoded += String.fromCharCode(value); │ │ │ │ - num >>= 5 │ │ │ │ + outFeature: function(feature) { │ │ │ │ + if (!this.handlers.drag.dragging) { │ │ │ │ + this.over = false; │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, this.displayClass + "Over"); │ │ │ │ + this.onLeave(feature); │ │ │ │ + this.feature = null │ │ │ │ + } else { │ │ │ │ + if (this.feature.id == feature.id) { │ │ │ │ + this.over = false │ │ │ │ + } │ │ │ │ } │ │ │ │ - value = num + 63; │ │ │ │ - encoded += String.fromCharCode(value); │ │ │ │ - return encoded │ │ │ │ }, │ │ │ │ - decodeUnsignedInteger: function(encoded) { │ │ │ │ - var result = 0; │ │ │ │ - var shift = 0; │ │ │ │ - var encodedLength = encoded.length; │ │ │ │ - for (var i = 0; i < encodedLength; ++i) { │ │ │ │ - var b = encoded.charCodeAt(i) - 63; │ │ │ │ - result |= (b & 31) << shift; │ │ │ │ - if (b < 32) break; │ │ │ │ - shift += 5 │ │ │ │ - } │ │ │ │ - return result │ │ │ │ + cancel: function() { │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + this.over = false │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.EncodedPolyline" │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.drag.setMap(map); │ │ │ │ + this.handlers.feature.setMap(map); │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DragFeature" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.Atom = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - atom: "http://www.w3.org/2005/Atom", │ │ │ │ - georss: "http://www.georss.org/georss" │ │ │ │ +OpenLayers.Control.PanZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + slideFactor: 50, │ │ │ │ + slideRatio: null, │ │ │ │ + buttons: null, │ │ │ │ + position: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X, OpenLayers.Control.PanZoom.Y); │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ }, │ │ │ │ - feedTitle: "untitled", │ │ │ │ - defaultEntryTitle: "untitled", │ │ │ │ - gmlParser: null, │ │ │ │ - xy: false, │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onButtonClick) │ │ │ │ } │ │ │ │ - return this.parseFeatures(doc) │ │ │ │ + this.removeButtons(); │ │ │ │ + this.buttons = null; │ │ │ │ + this.position = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - write: function(features) { │ │ │ │ - var doc; │ │ │ │ - if (OpenLayers.Util.isArray(features)) { │ │ │ │ - doc = this.createElementNSPlus("atom:feed"); │ │ │ │ - doc.appendChild(this.createElementNSPlus("atom:title", { │ │ │ │ - value: this.feedTitle │ │ │ │ - })); │ │ │ │ - for (var i = 0, ii = features.length; i < ii; i++) { │ │ │ │ - doc.appendChild(this.buildEntryNode(features[i])) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - doc = this.buildEntryNode(features) │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + }, │ │ │ │ + draw: function(px) { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + px = this.position; │ │ │ │ + this.buttons = []; │ │ │ │ + var sz = { │ │ │ │ + w: 18, │ │ │ │ + h: 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 │ │ │ │ + }, │ │ │ │ + _addButton: function(id, img, xy, sz) { │ │ │ │ + var imgLocation = OpenLayers.Util.getImageLocation(img); │ │ │ │ + var btn = OpenLayers.Util.createAlphaImageDiv(this.id + "_" + id, xy, sz, imgLocation, "absolute"); │ │ │ │ + btn.style.cursor = "pointer"; │ │ │ │ + this.div.appendChild(btn); │ │ │ │ + btn.action = id; │ │ │ │ + btn.className = "olButton"; │ │ │ │ + this.buttons.push(btn); │ │ │ │ + return btn │ │ │ │ + }, │ │ │ │ + _removeButton: function(btn) { │ │ │ │ + this.div.removeChild(btn); │ │ │ │ + OpenLayers.Util.removeItem(this.buttons, btn) │ │ │ │ + }, │ │ │ │ + removeButtons: function() { │ │ │ │ + for (var i = this.buttons.length - 1; i >= 0; --i) { │ │ │ │ + this._removeButton(this.buttons[i]) │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [doc]) │ │ │ │ }, │ │ │ │ - buildContentNode: function(content) { │ │ │ │ - var node = this.createElementNSPlus("atom:content", { │ │ │ │ - attributes: { │ │ │ │ - type: content.type || null │ │ │ │ - } │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var btn = evt.buttonElement; │ │ │ │ + switch (btn.action) { │ │ │ │ + case "panup": │ │ │ │ + this.map.pan(0, -this.getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case "pandown": │ │ │ │ + this.map.pan(0, this.getSlideFactor("h")); │ │ │ │ + break; │ │ │ │ + case "panleft": │ │ │ │ + this.map.pan(-this.getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + case "panright": │ │ │ │ + this.map.pan(this.getSlideFactor("w"), 0); │ │ │ │ + break; │ │ │ │ + case "zoomin": │ │ │ │ + this.map.zoomIn(); │ │ │ │ + break; │ │ │ │ + case "zoomout": │ │ │ │ + this.map.zoomOut(); │ │ │ │ + break; │ │ │ │ + case "zoomworld": │ │ │ │ + this.map.zoomToMaxExtent(); │ │ │ │ + break │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + getSlideFactor: function(dim) { │ │ │ │ + return this.slideRatio ? this.map.getSize()[dim] * this.slideRatio : this.slideFactor │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.PanZoom" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.PanZoom.X = 4; │ │ │ │ +OpenLayers.Control.PanZoom.Y = 4; │ │ │ │ +OpenLayers.Control.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoom, { │ │ │ │ + zoomStopWidth: 18, │ │ │ │ + zoomStopHeight: 11, │ │ │ │ + slider: null, │ │ │ │ + sliderEvents: null, │ │ │ │ + zoombarDiv: null, │ │ │ │ + zoomWorldIcon: false, │ │ │ │ + panIcons: true, │ │ │ │ + forceFixedZoomLevel: false, │ │ │ │ + mouseDragStart: null, │ │ │ │ + deltaY: null, │ │ │ │ + zoomStart: null, │ │ │ │ + destroy: function() { │ │ │ │ + this._removeZoomBar(); │ │ │ │ + this.map.events.un({ │ │ │ │ + changebaselayer: this.redraw, │ │ │ │ + updatesize: this.redraw, │ │ │ │ + scope: this │ │ │ │ }); │ │ │ │ - if (content.src) { │ │ │ │ - node.setAttribute("src", content.src) │ │ │ │ - } else { │ │ │ │ - if (content.type == "text" || content.type == null) { │ │ │ │ - node.appendChild(this.createTextNode(content.value)) │ │ │ │ - } else if (content.type == "html") { │ │ │ │ - if (typeof content.value != "string") { │ │ │ │ - throw "HTML content must be in form of an escaped string" │ │ │ │ - } │ │ │ │ - node.appendChild(this.createTextNode(content.value)) │ │ │ │ - } else if (content.type == "xhtml") { │ │ │ │ - node.appendChild(content.value) │ │ │ │ - } else if (content.type == "xhtml" || content.type.match(/(\+|\/)xml$/)) { │ │ │ │ - node.appendChild(content.value) │ │ │ │ - } else { │ │ │ │ - node.appendChild(this.createTextNode(content.value)) │ │ │ │ - } │ │ │ │ + OpenLayers.Control.PanZoom.prototype.destroy.apply(this, arguments); │ │ │ │ + delete this.mouseDragStart; │ │ │ │ + delete this.zoomStart │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.PanZoom.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.on({ │ │ │ │ + changebaselayer: this.redraw, │ │ │ │ + updatesize: this.redraw, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + redraw: function() { │ │ │ │ + if (this.div != null) { │ │ │ │ + this.removeButtons(); │ │ │ │ + this._removeZoomBar() │ │ │ │ } │ │ │ │ - return node │ │ │ │ + this.draw() │ │ │ │ }, │ │ │ │ - buildEntryNode: function(feature) { │ │ │ │ - var attrib = feature.attributes; │ │ │ │ - var atomAttrib = attrib.atom || {}; │ │ │ │ - var entryNode = this.createElementNSPlus("atom:entry"); │ │ │ │ - if (atomAttrib.authors) { │ │ │ │ - var authors = OpenLayers.Util.isArray(atomAttrib.authors) ? atomAttrib.authors : [atomAttrib.authors]; │ │ │ │ - for (var i = 0, ii = authors.length; i < ii; i++) { │ │ │ │ - entryNode.appendChild(this.buildPersonConstructNode("author", authors[i])) │ │ │ │ + draw: function(px) { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + px = this.position.clone(); │ │ │ │ + this.buttons = []; │ │ │ │ + var sz = { │ │ │ │ + w: 18, │ │ │ │ + h: 18 │ │ │ │ + }; │ │ │ │ + if (this.panIcons) { │ │ │ │ + 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) │ │ │ │ } │ │ │ │ - } │ │ │ │ - if (atomAttrib.categories) { │ │ │ │ - var categories = OpenLayers.Util.isArray(atomAttrib.categories) ? atomAttrib.categories : [atomAttrib.categories]; │ │ │ │ - var category; │ │ │ │ - for (var i = 0, ii = categories.length; i < ii; i++) { │ │ │ │ - category = categories[i]; │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:category", { │ │ │ │ - attributes: { │ │ │ │ - term: category.term, │ │ │ │ - scheme: category.scheme || null, │ │ │ │ - label: category.label || null │ │ │ │ - } │ │ │ │ - })) │ │ │ │ + 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 │ │ │ │ } │ │ │ │ - } │ │ │ │ - if (atomAttrib.content) { │ │ │ │ - entryNode.appendChild(this.buildContentNode(atomAttrib.content)) │ │ │ │ - } │ │ │ │ - if (atomAttrib.contributors) { │ │ │ │ - var contributors = OpenLayers.Util.isArray(atomAttrib.contributors) ? atomAttrib.contributors : [atomAttrib.contributors]; │ │ │ │ - for (var i = 0, ii = contributors.length; i < ii; i++) { │ │ │ │ - entryNode.appendChild(this.buildPersonConstructNode("contributor", contributors[i])) │ │ │ │ + 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) │ │ │ │ + } else { │ │ │ │ + this._addButton("zoomin", "zoom-plus-mini.png", px, sz); │ │ │ │ + centered = this._addZoomBar(px.add(0, sz.h)); │ │ │ │ + this._addButton("zoomout", "zoom-minus-mini.png", centered, sz); │ │ │ │ + if (this.zoomWorldIcon) { │ │ │ │ + centered = centered.add(0, sz.h + 3); │ │ │ │ + this._addButton("zoomworld", "zoom-world-mini.png", centered, sz) │ │ │ │ } │ │ │ │ } │ │ │ │ - if (feature.fid) { │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:id", { │ │ │ │ - value: feature.fid │ │ │ │ - })) │ │ │ │ + return this.div │ │ │ │ + }, │ │ │ │ + _addZoomBar: function(centered) { │ │ │ │ + var imgLocation = OpenLayers.Util.getImageLocation("slider.png"); │ │ │ │ + var id = this.id + "_" + this.map.id; │ │ │ │ + var minZoom = this.map.getMinZoom(); │ │ │ │ + var zoomsToEnd = this.map.getNumZoomLevels() - 1 - this.map.getZoom(); │ │ │ │ + var slider = OpenLayers.Util.createAlphaImageDiv(id, centered.add(-1, zoomsToEnd * this.zoomStopHeight), { │ │ │ │ + w: 20, │ │ │ │ + h: 9 │ │ │ │ + }, imgLocation, "absolute"); │ │ │ │ + slider.style.cursor = "move"; │ │ │ │ + this.slider = slider; │ │ │ │ + this.sliderEvents = new OpenLayers.Events(this, slider, null, true, { │ │ │ │ + includeXY: true │ │ │ │ + }); │ │ │ │ + this.sliderEvents.on({ │ │ │ │ + touchstart: this.zoomBarDown, │ │ │ │ + touchmove: this.zoomBarDrag, │ │ │ │ + touchend: this.zoomBarUp, │ │ │ │ + mousedown: this.zoomBarDown, │ │ │ │ + mousemove: this.zoomBarDrag, │ │ │ │ + mouseup: this.zoomBarUp │ │ │ │ + }); │ │ │ │ + var sz = { │ │ │ │ + w: this.zoomStopWidth, │ │ │ │ + h: this.zoomStopHeight * (this.map.getNumZoomLevels() - minZoom) │ │ │ │ + }; │ │ │ │ + var imgLocation = OpenLayers.Util.getImageLocation("zoombar.png"); │ │ │ │ + var div = null; │ │ │ │ + if (OpenLayers.Util.alphaHack()) { │ │ │ │ + var id = this.id + "_" + this.map.id; │ │ │ │ + div = OpenLayers.Util.createAlphaImageDiv(id, centered, { │ │ │ │ + w: sz.w, │ │ │ │ + h: this.zoomStopHeight │ │ │ │ + }, imgLocation, "absolute", null, "crop"); │ │ │ │ + div.style.height = sz.h + "px" │ │ │ │ + } else { │ │ │ │ + div = OpenLayers.Util.createDiv("OpenLayers_Control_PanZoomBar_Zoombar" + this.map.id, centered, sz, imgLocation) │ │ │ │ } │ │ │ │ - if (atomAttrib.links) { │ │ │ │ - var links = OpenLayers.Util.isArray(atomAttrib.links) ? atomAttrib.links : [atomAttrib.links]; │ │ │ │ - var link; │ │ │ │ - for (var i = 0, ii = links.length; i < ii; i++) { │ │ │ │ - link = links[i]; │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:link", { │ │ │ │ - attributes: { │ │ │ │ - href: link.href, │ │ │ │ - rel: link.rel || null, │ │ │ │ - type: link.type || null, │ │ │ │ - hreflang: link.hreflang || null, │ │ │ │ - title: link.title || null, │ │ │ │ - length: link.length || null │ │ │ │ - } │ │ │ │ - })) │ │ │ │ + div.style.cursor = "pointer"; │ │ │ │ + div.className = "olButton"; │ │ │ │ + this.zoombarDiv = div; │ │ │ │ + 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() - minZoom)); │ │ │ │ + return centered │ │ │ │ + }, │ │ │ │ + _removeZoomBar: function() { │ │ │ │ + this.sliderEvents.un({ │ │ │ │ + touchstart: this.zoomBarDown, │ │ │ │ + touchmove: this.zoomBarDrag, │ │ │ │ + touchend: this.zoomBarUp, │ │ │ │ + mousedown: this.zoomBarDown, │ │ │ │ + mousemove: this.zoomBarDrag, │ │ │ │ + mouseup: this.zoomBarUp │ │ │ │ + }); │ │ │ │ + this.sliderEvents.destroy(); │ │ │ │ + this.div.removeChild(this.zoombarDiv); │ │ │ │ + this.zoombarDiv = null; │ │ │ │ + this.div.removeChild(this.slider); │ │ │ │ + this.slider = null; │ │ │ │ + this.map.events.unregister("zoomend", this, this.moveZoomBar) │ │ │ │ + }, │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + OpenLayers.Control.PanZoom.prototype.onButtonClick.apply(this, arguments); │ │ │ │ + if (evt.buttonElement === this.zoombarDiv) { │ │ │ │ + var levels = evt.buttonXY.y / this.zoomStopHeight; │ │ │ │ + if (this.forceFixedZoomLevel || !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) │ │ │ │ } │ │ │ │ - if (atomAttrib.published) { │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:published", { │ │ │ │ - value: atomAttrib.published │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - if (atomAttrib.rights) { │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:rights", { │ │ │ │ - value: atomAttrib.rights │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - if (atomAttrib.summary || attrib.description) { │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:summary", { │ │ │ │ - value: atomAttrib.summary || attrib.description │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:title", { │ │ │ │ - value: atomAttrib.title || attrib.title || this.defaultEntryTitle │ │ │ │ - })); │ │ │ │ - if (atomAttrib.updated) { │ │ │ │ - entryNode.appendChild(this.createElementNSPlus("atom:updated", { │ │ │ │ - value: atomAttrib.updated │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - if (feature.geometry) { │ │ │ │ - var whereNode = this.createElementNSPlus("georss:where"); │ │ │ │ - whereNode.appendChild(this.buildGeometryNode(feature.geometry)); │ │ │ │ - entryNode.appendChild(whereNode) │ │ │ │ - } │ │ │ │ - return entryNode │ │ │ │ }, │ │ │ │ - initGmlParser: function() { │ │ │ │ - this.gmlParser = new OpenLayers.Format.GML.v3({ │ │ │ │ - xy: this.xy, │ │ │ │ - featureNS: "http://example.com#feature", │ │ │ │ - internalProjection: this.internalProjection, │ │ │ │ - externalProjection: this.externalProjection │ │ │ │ - }) │ │ │ │ + passEventToSlider: function(evt) { │ │ │ │ + this.sliderEvents.handleBrowserEvent(evt) │ │ │ │ }, │ │ │ │ - buildGeometryNode: function(geometry) { │ │ │ │ - if (!this.gmlParser) { │ │ │ │ - this.initGmlParser() │ │ │ │ + zoomBarDown: function(evt) { │ │ │ │ + if (!OpenLayers.Event.isLeftClick(evt) && !OpenLayers.Event.isSingleTouch(evt)) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - var node = this.gmlParser.writeNode("feature:_geometry", geometry); │ │ │ │ - return node.firstChild │ │ │ │ + this.map.events.on({ │ │ │ │ + touchmove: this.passEventToSlider, │ │ │ │ + mousemove: this.passEventToSlider, │ │ │ │ + mouseup: this.passEventToSlider, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.mouseDragStart = evt.xy.clone(); │ │ │ │ + this.zoomStart = evt.xy.clone(); │ │ │ │ + this.div.style.cursor = "move"; │ │ │ │ + this.zoombarDiv.offsets = null; │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ }, │ │ │ │ - buildPersonConstructNode: function(name, value) { │ │ │ │ - var oNames = ["uri", "email"]; │ │ │ │ - var personNode = this.createElementNSPlus("atom:" + name); │ │ │ │ - personNode.appendChild(this.createElementNSPlus("atom:name", { │ │ │ │ - value: value.name │ │ │ │ - })); │ │ │ │ - for (var i = 0, ii = oNames.length; i < ii; i++) { │ │ │ │ - if (value[oNames[i]]) { │ │ │ │ - personNode.appendChild(this.createElementNSPlus("atom:" + oNames[i], { │ │ │ │ - value: value[oNames[i]] │ │ │ │ - })) │ │ │ │ + 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() │ │ │ │ } │ │ │ │ + this.deltaY = this.zoomStart.y - evt.xy.y; │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ } │ │ │ │ - return personNode │ │ │ │ - }, │ │ │ │ - getFirstChildValue: function(node, nsuri, name, def) { │ │ │ │ - var value; │ │ │ │ - var nodes = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ - if (nodes && nodes.length > 0) { │ │ │ │ - value = this.getChildValue(nodes[0], def) │ │ │ │ - } else { │ │ │ │ - value = def │ │ │ │ - } │ │ │ │ - return value │ │ │ │ }, │ │ │ │ - parseFeature: function(node) { │ │ │ │ - var atomAttrib = {}; │ │ │ │ - var value = null; │ │ │ │ - var nodes = null; │ │ │ │ - var attval = null; │ │ │ │ - var atomns = this.namespaces.atom; │ │ │ │ - this.parsePersonConstructs(node, "author", atomAttrib); │ │ │ │ - nodes = this.getElementsByTagNameNS(node, atomns, "category"); │ │ │ │ - if (nodes.length > 0) { │ │ │ │ - atomAttrib.categories = [] │ │ │ │ - } │ │ │ │ - for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ - value = {}; │ │ │ │ - value.term = nodes[i].getAttribute("term"); │ │ │ │ - attval = nodes[i].getAttribute("scheme"); │ │ │ │ - if (attval) { │ │ │ │ - value.scheme = attval │ │ │ │ - } │ │ │ │ - attval = nodes[i].getAttribute("label"); │ │ │ │ - if (attval) { │ │ │ │ - value.label = attval │ │ │ │ - } │ │ │ │ - atomAttrib.categories.push(value) │ │ │ │ + zoomBarUp: function(evt) { │ │ │ │ + if (!OpenLayers.Event.isLeftClick(evt) && evt.type !== "touchend") { │ │ │ │ + return │ │ │ │ } │ │ │ │ - nodes = this.getElementsByTagNameNS(node, atomns, "content"); │ │ │ │ - if (nodes.length > 0) { │ │ │ │ - value = {}; │ │ │ │ - attval = nodes[0].getAttribute("type"); │ │ │ │ - if (attval) { │ │ │ │ - value.type = attval │ │ │ │ - } │ │ │ │ - attval = nodes[0].getAttribute("src"); │ │ │ │ - if (attval) { │ │ │ │ - value.src = attval │ │ │ │ + if (this.mouseDragStart) { │ │ │ │ + this.div.style.cursor = ""; │ │ │ │ + this.map.events.un({ │ │ │ │ + touchmove: this.passEventToSlider, │ │ │ │ + mouseup: this.passEventToSlider, │ │ │ │ + mousemove: this.passEventToSlider, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + var zoomLevel = this.map.zoom; │ │ │ │ + if (!this.forceFixedZoomLevel && this.map.fractionalZoom) { │ │ │ │ + zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ + zoomLevel = Math.min(Math.max(zoomLevel, 0), this.map.getNumZoomLevels() - 1) │ │ │ │ } else { │ │ │ │ - if (value.type == "text" || value.type == "html" || value.type == null) { │ │ │ │ - value.value = this.getFirstChildValue(node, atomns, "content", null) │ │ │ │ - } else if (value.type == "xhtml" || value.type.match(/(\+|\/)xml$/)) { │ │ │ │ - value.value = this.getChildEl(nodes[0]) │ │ │ │ - } else { │ │ │ │ - value.value = this.getFirstChildValue(node, atomns, "content", null) │ │ │ │ - } │ │ │ │ - atomAttrib.content = value │ │ │ │ + zoomLevel += this.deltaY / this.zoomStopHeight; │ │ │ │ + zoomLevel = Math.max(Math.round(zoomLevel), 0) │ │ │ │ } │ │ │ │ + this.map.zoomTo(zoomLevel); │ │ │ │ + this.mouseDragStart = null; │ │ │ │ + this.zoomStart = null; │ │ │ │ + this.deltaY = 0; │ │ │ │ + OpenLayers.Event.stop(evt) │ │ │ │ } │ │ │ │ - this.parsePersonConstructs(node, "contributor", atomAttrib); │ │ │ │ - atomAttrib.id = this.getFirstChildValue(node, atomns, "id", null); │ │ │ │ - nodes = this.getElementsByTagNameNS(node, atomns, "link"); │ │ │ │ - if (nodes.length > 0) { │ │ │ │ - atomAttrib.links = new Array(nodes.length) │ │ │ │ + }, │ │ │ │ + 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.Control.ZoomIn = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.zoomIn() │ │ │ │ } │ │ │ │ - var oAtts = ["rel", "type", "hreflang", "title", "length"]; │ │ │ │ - for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ - value = {}; │ │ │ │ - value.href = nodes[i].getAttribute("href"); │ │ │ │ - for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ - attval = nodes[i].getAttribute(oAtts[j]); │ │ │ │ - if (attval) { │ │ │ │ - value[oAtts[j]] = attval │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomIn" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + documentDrag: false, │ │ │ │ + geometryTypes: null, │ │ │ │ + clickout: true, │ │ │ │ + toggle: true, │ │ │ │ + standalone: false, │ │ │ │ + layer: null, │ │ │ │ + feature: null, │ │ │ │ + vertex: null, │ │ │ │ + vertices: null, │ │ │ │ + virtualVertices: null, │ │ │ │ + handlers: null, │ │ │ │ + deleteCodes: null, │ │ │ │ + virtualStyle: null, │ │ │ │ + vertexRenderIntent: null, │ │ │ │ + mode: null, │ │ │ │ + createVertices: true, │ │ │ │ + modified: false, │ │ │ │ + radiusHandle: null, │ │ │ │ + dragHandle: null, │ │ │ │ + onModificationStart: function() {}, │ │ │ │ + onModification: function() {}, │ │ │ │ + onModificationEnd: function() {}, │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + options = options || {}; │ │ │ │ + this.layer = layer; │ │ │ │ + this.vertices = []; │ │ │ │ + this.virtualVertices = []; │ │ │ │ + this.virtualStyle = OpenLayers.Util.extend({}, this.layer.style || this.layer.styleMap.createSymbolizer(null, options.vertexRenderIntent)); │ │ │ │ + this.virtualStyle.fillOpacity = .3; │ │ │ │ + this.virtualStyle.strokeOpacity = .3; │ │ │ │ + this.deleteCodes = [46, 68]; │ │ │ │ + this.mode = OpenLayers.Control.ModifyFeature.RESHAPE; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!OpenLayers.Util.isArray(this.deleteCodes)) { │ │ │ │ + this.deleteCodes = [this.deleteCodes] │ │ │ │ + } │ │ │ │ + var dragCallbacks = { │ │ │ │ + down: function(pixel) { │ │ │ │ + this.vertex = null; │ │ │ │ + var feature = this.layer.getFeatureFromEvent(this.handlers.drag.evt); │ │ │ │ + if (feature) { │ │ │ │ + this.dragStart(feature) │ │ │ │ + } else if (this.clickout) { │ │ │ │ + this._unselect = this.feature │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + move: function(pixel) { │ │ │ │ + delete this._unselect; │ │ │ │ + if (this.vertex) { │ │ │ │ + this.dragVertex(this.vertex, pixel) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + up: function() { │ │ │ │ + this.handlers.drag.stopDown = false; │ │ │ │ + if (this._unselect) { │ │ │ │ + this.unselectFeature(this._unselect); │ │ │ │ + delete this._unselect │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + done: function(pixel) { │ │ │ │ + if (this.vertex) { │ │ │ │ + this.dragComplete(this.vertex) │ │ │ │ } │ │ │ │ } │ │ │ │ - atomAttrib.links[i] = value │ │ │ │ - } │ │ │ │ - value = this.getFirstChildValue(node, atomns, "published", null); │ │ │ │ - if (value) { │ │ │ │ - atomAttrib.published = value │ │ │ │ - } │ │ │ │ - value = this.getFirstChildValue(node, atomns, "rights", null); │ │ │ │ - if (value) { │ │ │ │ - atomAttrib.rights = value │ │ │ │ - } │ │ │ │ - value = this.getFirstChildValue(node, atomns, "summary", null); │ │ │ │ - if (value) { │ │ │ │ - atomAttrib.summary = value │ │ │ │ - } │ │ │ │ - atomAttrib.title = this.getFirstChildValue(node, atomns, "title", null); │ │ │ │ - atomAttrib.updated = this.getFirstChildValue(node, atomns, "updated", null); │ │ │ │ - var featureAttrib = { │ │ │ │ - title: atomAttrib.title, │ │ │ │ - description: atomAttrib.summary, │ │ │ │ - atom: atomAttrib │ │ │ │ }; │ │ │ │ - var geometry = this.parseLocations(node)[0]; │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, featureAttrib); │ │ │ │ - feature.fid = atomAttrib.id; │ │ │ │ - return feature │ │ │ │ - }, │ │ │ │ - parseFeatures: function(node) { │ │ │ │ - var features = []; │ │ │ │ - var entries = this.getElementsByTagNameNS(node, this.namespaces.atom, "entry"); │ │ │ │ - if (entries.length == 0) { │ │ │ │ - entries = [node] │ │ │ │ + var dragOptions = { │ │ │ │ + documentDrag: this.documentDrag, │ │ │ │ + stopDown: false │ │ │ │ + }; │ │ │ │ + var keyboardOptions = { │ │ │ │ + keydown: this.handleKeypress │ │ │ │ + }; │ │ │ │ + this.handlers = { │ │ │ │ + keyboard: new OpenLayers.Handler.Keyboard(this, keyboardOptions), │ │ │ │ + drag: new OpenLayers.Handler.Drag(this, dragCallbacks, dragOptions) │ │ │ │ } │ │ │ │ - for (var i = 0, ii = entries.length; i < ii; i++) { │ │ │ │ - features.push(this.parseFeature(entries[i])) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.un({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ - return features │ │ │ │ + this.layer = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, []) │ │ │ │ }, │ │ │ │ - parseLocations: function(node) { │ │ │ │ - var georssns = this.namespaces.georss; │ │ │ │ - var locations = { │ │ │ │ - components: [] │ │ │ │ - }; │ │ │ │ - var where = this.getElementsByTagNameNS(node, georssns, "where"); │ │ │ │ - if (where && where.length > 0) { │ │ │ │ - if (!this.gmlParser) { │ │ │ │ - this.initGmlParser() │ │ │ │ - } │ │ │ │ - for (var i = 0, ii = where.length; i < ii; i++) { │ │ │ │ - this.gmlParser.readChildNodes(where[i], locations) │ │ │ │ + activate: function() { │ │ │ │ + this.moveLayerToTop(); │ │ │ │ + this.map.events.on({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + return this.handlers.keyboard.activate() && this.handlers.drag.activate() && OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.moveLayerBack(); │ │ │ │ + this.map.events.un({ │ │ │ │ + removelayer: this.handleMapEvents, │ │ │ │ + changelayer: this.handleMapEvents, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + this.handlers.drag.deactivate(); │ │ │ │ + this.handlers.keyboard.deactivate(); │ │ │ │ + var feature = this.feature; │ │ │ │ + if (feature && feature.geometry && feature.layer) { │ │ │ │ + this.unselectFeature(feature) │ │ │ │ } │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ - var components = locations.components; │ │ │ │ - var point = this.getElementsByTagNameNS(node, georssns, "point"); │ │ │ │ - if (point && point.length > 0) { │ │ │ │ - for (var i = 0, ii = point.length; i < ii; i++) { │ │ │ │ - var xy = OpenLayers.String.trim(point[i].firstChild.nodeValue).split(/\s+/); │ │ │ │ - if (xy.length != 2) { │ │ │ │ - xy = OpenLayers.String.trim(point[i].firstChild.nodeValue).split(/\s*,\s*/) │ │ │ │ - } │ │ │ │ - components.push(new OpenLayers.Geometry.Point(xy[1], xy[0])) │ │ │ │ - } │ │ │ │ + return deactivated │ │ │ │ + }, │ │ │ │ + beforeSelectFeature: function(feature) { │ │ │ │ + return this.layer.events.triggerEvent("beforefeaturemodified", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + selectFeature: function(feature) { │ │ │ │ + if (this.feature === feature || this.geometryTypes && OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) == -1) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - var line = this.getElementsByTagNameNS(node, georssns, "line"); │ │ │ │ - if (line && line.length > 0) { │ │ │ │ - var coords; │ │ │ │ - var p; │ │ │ │ - var points; │ │ │ │ - for (var i = 0, ii = line.length; i < ii; i++) { │ │ │ │ - coords = OpenLayers.String.trim(line[i].firstChild.nodeValue).split(/\s+/); │ │ │ │ - points = []; │ │ │ │ - for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ - p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ - points.push(p) │ │ │ │ - } │ │ │ │ - components.push(new OpenLayers.Geometry.LineString(points)) │ │ │ │ + if (this.beforeSelectFeature(feature) !== false) { │ │ │ │ + if (this.feature) { │ │ │ │ + this.unselectFeature(this.feature) │ │ │ │ } │ │ │ │ + this.feature = feature; │ │ │ │ + this.layer.selectedFeatures.push(feature); │ │ │ │ + this.layer.drawFeature(feature, "select"); │ │ │ │ + this.modified = false; │ │ │ │ + this.resetVertices(); │ │ │ │ + this.onModificationStart(this.feature) │ │ │ │ } │ │ │ │ - var polygon = this.getElementsByTagNameNS(node, georssns, "polygon"); │ │ │ │ - if (polygon && polygon.length > 0) { │ │ │ │ - var coords; │ │ │ │ - var p; │ │ │ │ - var points; │ │ │ │ - for (var i = 0, ii = polygon.length; i < ii; i++) { │ │ │ │ - coords = OpenLayers.String.trim(polygon[i].firstChild.nodeValue).split(/\s+/); │ │ │ │ - points = []; │ │ │ │ - for (var j = 0, jj = coords.length; j < jj; j += 2) { │ │ │ │ - p = new OpenLayers.Geometry.Point(coords[j + 1], coords[j]); │ │ │ │ - points.push(p) │ │ │ │ - } │ │ │ │ - components.push(new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(points)])) │ │ │ │ - } │ │ │ │ + var modified = feature.modified; │ │ │ │ + if (feature.geometry && !(modified && modified.geometry)) { │ │ │ │ + this._originalGeometry = feature.geometry.clone() │ │ │ │ } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - for (var i = 0, ii = components.length; i < ii; i++) { │ │ │ │ - if (components[i]) { │ │ │ │ - components[i].transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + unselectFeature: function(feature) { │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.virtualVertices = []; │ │ │ │ + if (this.dragHandle) { │ │ │ │ + this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + delete this.dragHandle │ │ │ │ } │ │ │ │ - return components │ │ │ │ + if (this.radiusHandle) { │ │ │ │ + this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + delete this.radiusHandle │ │ │ │ + } │ │ │ │ + this.layer.drawFeature(this.feature, "default"); │ │ │ │ + this.feature = null; │ │ │ │ + OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); │ │ │ │ + this.onModificationEnd(feature); │ │ │ │ + this.layer.events.triggerEvent("afterfeaturemodified", { │ │ │ │ + feature: feature, │ │ │ │ + modified: this.modified │ │ │ │ + }); │ │ │ │ + this.modified = false │ │ │ │ }, │ │ │ │ - parsePersonConstructs: function(node, name, data) { │ │ │ │ - var persons = []; │ │ │ │ - var atomns = this.namespaces.atom; │ │ │ │ - var nodes = this.getElementsByTagNameNS(node, atomns, name); │ │ │ │ - var oAtts = ["uri", "email"]; │ │ │ │ - for (var i = 0, ii = nodes.length; i < ii; i++) { │ │ │ │ - var value = {}; │ │ │ │ - value.name = this.getFirstChildValue(nodes[i], atomns, "name", null); │ │ │ │ - for (var j = 0, jj = oAtts.length; j < jj; j++) { │ │ │ │ - var attval = this.getFirstChildValue(nodes[i], atomns, oAtts[j], null); │ │ │ │ - if (attval) { │ │ │ │ - value[oAtts[j]] = attval │ │ │ │ - } │ │ │ │ + dragStart: function(feature) { │ │ │ │ + var isPoint = feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point"; │ │ │ │ + if (!this.standalone && (!feature._sketch && isPoint || !feature._sketch)) { │ │ │ │ + if (this.toggle && this.feature === feature) { │ │ │ │ + this._unselect = feature │ │ │ │ } │ │ │ │ - persons.push(value) │ │ │ │ + this.selectFeature(feature) │ │ │ │ } │ │ │ │ - if (persons.length > 0) { │ │ │ │ - data[name + "s"] = persons │ │ │ │ + if (feature._sketch || isPoint) { │ │ │ │ + this.vertex = feature; │ │ │ │ + this.handlers.drag.stopDown = true │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.Atom" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.GeoRSS = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - rssns: "http://backend.userland.com/rss2", │ │ │ │ - featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ - georssns: "http://www.georss.org/georss", │ │ │ │ - geons: "http://www.w3.org/2003/01/geo/wgs84_pos#", │ │ │ │ - featureTitle: "Untitled", │ │ │ │ - featureDescription: "No Description", │ │ │ │ - gmlParser: null, │ │ │ │ - xy: false, │ │ │ │ - createGeometryFromItem: function(item) { │ │ │ │ - var point = this.getElementsByTagNameNS(item, this.georssns, "point"); │ │ │ │ - var lat = this.getElementsByTagNameNS(item, this.geons, "lat"); │ │ │ │ - var lon = this.getElementsByTagNameNS(item, this.geons, "long"); │ │ │ │ - var line = this.getElementsByTagNameNS(item, this.georssns, "line"); │ │ │ │ - var polygon = this.getElementsByTagNameNS(item, this.georssns, "polygon"); │ │ │ │ - var where = this.getElementsByTagNameNS(item, this.georssns, "where"); │ │ │ │ - var box = this.getElementsByTagNameNS(item, this.georssns, "box"); │ │ │ │ - if (point.length > 0 || lat.length > 0 && lon.length > 0) { │ │ │ │ - var location; │ │ │ │ - if (point.length > 0) { │ │ │ │ - location = OpenLayers.String.trim(point[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ - if (location.length != 2) { │ │ │ │ - location = OpenLayers.String.trim(point[0].firstChild.nodeValue).split(/\s*,\s*/) │ │ │ │ + dragVertex: function(vertex, pixel) { │ │ │ │ + var pos = this.map.getLonLatFromViewPortPx(pixel); │ │ │ │ + var geom = vertex.geometry; │ │ │ │ + geom.move(pos.lon - geom.x, pos.lat - geom.y); │ │ │ │ + this.modified = true; │ │ │ │ + if (this.feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ + vertex: vertex.geometry, │ │ │ │ + feature: this.feature, │ │ │ │ + pixel: pixel │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + if (vertex._index) { │ │ │ │ + vertex.geometry.parent.addComponent(vertex.geometry, vertex._index); │ │ │ │ + delete vertex._index; │ │ │ │ + OpenLayers.Util.removeItem(this.virtualVertices, vertex); │ │ │ │ + this.vertices.push(vertex) │ │ │ │ + } else if (vertex == this.dragHandle) { │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = []; │ │ │ │ + if (this.radiusHandle) { │ │ │ │ + this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.radiusHandle = null │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - location = [parseFloat(lat[0].firstChild.nodeValue), parseFloat(lon[0].firstChild.nodeValue)] │ │ │ │ - } │ │ │ │ - var geometry = new OpenLayers.Geometry.Point(location[1], location[0]) │ │ │ │ - } else if (line.length > 0) { │ │ │ │ - var coords = OpenLayers.String.trim(this.getChildValue(line[0])).split(/\s+/); │ │ │ │ - var components = []; │ │ │ │ - var point; │ │ │ │ - for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ - components.push(point) │ │ │ │ - } │ │ │ │ - geometry = new OpenLayers.Geometry.LineString(components) │ │ │ │ - } else if (polygon.length > 0) { │ │ │ │ - var coords = OpenLayers.String.trim(this.getChildValue(polygon[0])).split(/\s+/); │ │ │ │ - var components = []; │ │ │ │ - var point; │ │ │ │ - for (var i = 0, len = coords.length; i < len; i += 2) { │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[i + 1], coords[i]); │ │ │ │ - components.push(point) │ │ │ │ - } │ │ │ │ - geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]) │ │ │ │ - } else if (where.length > 0) { │ │ │ │ - if (!this.gmlParser) { │ │ │ │ - this.gmlParser = new OpenLayers.Format.GML({ │ │ │ │ - xy: this.xy │ │ │ │ + } else if (vertex !== this.radiusHandle) { │ │ │ │ + this.layer.events.triggerEvent("vertexmodified", { │ │ │ │ + vertex: vertex.geometry, │ │ │ │ + feature: this.feature, │ │ │ │ + pixel: pixel │ │ │ │ }) │ │ │ │ } │ │ │ │ - var feature = this.gmlParser.parseFeature(where[0]); │ │ │ │ - geometry = feature.geometry │ │ │ │ - } else if (box.length > 0) { │ │ │ │ - var coords = OpenLayers.String.trim(box[0].firstChild.nodeValue).split(/\s+/); │ │ │ │ - var components = []; │ │ │ │ - var point; │ │ │ │ - if (coords.length > 3) { │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[1], coords[2]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[3], coords[2]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[3], coords[0]); │ │ │ │ - components.push(point); │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[1], coords[0]); │ │ │ │ - components.push(point) │ │ │ │ + if (this.virtualVertices.length > 0) { │ │ │ │ + this.layer.destroyFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.virtualVertices = [] │ │ │ │ } │ │ │ │ - geometry = new OpenLayers.Geometry.Polygon([new OpenLayers.Geometry.LinearRing(components)]) │ │ │ │ - } │ │ │ │ - if (geometry && this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ + this.layer.drawFeature(this.feature, this.standalone ? undefined : "select") │ │ │ │ } │ │ │ │ - return geometry │ │ │ │ + this.layer.drawFeature(vertex) │ │ │ │ }, │ │ │ │ - createFeatureFromItem: function(item) { │ │ │ │ - var geometry = this.createGeometryFromItem(item); │ │ │ │ - var title = this._getChildValue(item, "*", "title", this.featureTitle); │ │ │ │ - var description = this._getChildValue(item, "*", "description", this._getChildValue(item, "*", "content", this._getChildValue(item, "*", "summary", this.featureDescription))); │ │ │ │ - var link = this._getChildValue(item, "*", "link"); │ │ │ │ - if (!link) { │ │ │ │ - try { │ │ │ │ - link = this.getElementsByTagNameNS(item, "*", "link")[0].getAttribute("href") │ │ │ │ - } catch (e) { │ │ │ │ - link = null │ │ │ │ + dragComplete: function(vertex) { │ │ │ │ + this.resetVertices(); │ │ │ │ + this.setFeatureState(); │ │ │ │ + this.onModification(this.feature); │ │ │ │ + this.layer.events.triggerEvent("featuremodified", { │ │ │ │ + feature: this.feature │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + setFeatureState: function() { │ │ │ │ + if (this.feature.state != OpenLayers.State.INSERT && this.feature.state != OpenLayers.State.DELETE) { │ │ │ │ + this.feature.state = OpenLayers.State.UPDATE; │ │ │ │ + if (this.modified && this._originalGeometry) { │ │ │ │ + var feature = this.feature; │ │ │ │ + feature.modified = OpenLayers.Util.extend(feature.modified, { │ │ │ │ + geometry: this._originalGeometry │ │ │ │ + }); │ │ │ │ + delete this._originalGeometry │ │ │ │ } │ │ │ │ } │ │ │ │ - var id = this._getChildValue(item, "*", "id", null); │ │ │ │ - var data = { │ │ │ │ - title: title, │ │ │ │ - description: description, │ │ │ │ - link: link │ │ │ │ - }; │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, data); │ │ │ │ - feature.fid = id; │ │ │ │ - return feature │ │ │ │ }, │ │ │ │ - _getChildValue: function(node, nsuri, name, def) { │ │ │ │ - var value; │ │ │ │ - var eles = this.getElementsByTagNameNS(node, nsuri, name); │ │ │ │ - if (eles && eles[0] && eles[0].firstChild && eles[0].firstChild.nodeValue) { │ │ │ │ - value = this.getChildValue(eles[0]) │ │ │ │ - } else { │ │ │ │ - value = def == undefined ? "" : def │ │ │ │ + resetVertices: function() { │ │ │ │ + if (this.vertices.length > 0) { │ │ │ │ + this.layer.removeFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.vertices = [] │ │ │ │ } │ │ │ │ - return value │ │ │ │ - }, │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + if (this.virtualVertices.length > 0) { │ │ │ │ + this.layer.removeFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.virtualVertices = [] │ │ │ │ } │ │ │ │ - var itemlist = null; │ │ │ │ - itemlist = this.getElementsByTagNameNS(doc, "*", "item"); │ │ │ │ - if (itemlist.length == 0) { │ │ │ │ - itemlist = this.getElementsByTagNameNS(doc, "*", "entry") │ │ │ │ + if (this.dragHandle) { │ │ │ │ + this.layer.destroyFeatures([this.dragHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.dragHandle = null │ │ │ │ } │ │ │ │ - var numItems = itemlist.length; │ │ │ │ - var features = new Array(numItems); │ │ │ │ - for (var i = 0; i < numItems; i++) { │ │ │ │ - features[i] = this.createFeatureFromItem(itemlist[i]) │ │ │ │ + if (this.radiusHandle) { │ │ │ │ + this.layer.destroyFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.radiusHandle = null │ │ │ │ + } │ │ │ │ + if (this.feature && this.feature.geometry.CLASS_NAME != "OpenLayers.Geometry.Point") { │ │ │ │ + if (this.mode & OpenLayers.Control.ModifyFeature.DRAG) { │ │ │ │ + this.collectDragHandle() │ │ │ │ + } │ │ │ │ + if (this.mode & (OpenLayers.Control.ModifyFeature.ROTATE | OpenLayers.Control.ModifyFeature.RESIZE)) { │ │ │ │ + this.collectRadiusHandle() │ │ │ │ + } │ │ │ │ + if (this.mode & OpenLayers.Control.ModifyFeature.RESHAPE) { │ │ │ │ + if (!(this.mode & OpenLayers.Control.ModifyFeature.RESIZE)) { │ │ │ │ + this.collectVertices() │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - return features │ │ │ │ }, │ │ │ │ - write: function(features) { │ │ │ │ - var georss; │ │ │ │ - if (OpenLayers.Util.isArray(features)) { │ │ │ │ - georss = this.createElementNS(this.rssns, "rss"); │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - georss.appendChild(this.createFeatureXML(features[i])) │ │ │ │ + handleKeypress: function(evt) { │ │ │ │ + var code = evt.keyCode; │ │ │ │ + if (this.feature && OpenLayers.Util.indexOf(this.deleteCodes, code) != -1) { │ │ │ │ + var vertex = this.layer.getFeatureFromEvent(this.handlers.drag.evt); │ │ │ │ + if (vertex && OpenLayers.Util.indexOf(this.vertices, vertex) != -1 && !this.handlers.drag.dragging && vertex.geometry.parent) { │ │ │ │ + vertex.geometry.parent.removeComponent(vertex.geometry); │ │ │ │ + this.layer.events.triggerEvent("vertexremoved", { │ │ │ │ + vertex: vertex.geometry, │ │ │ │ + feature: this.feature, │ │ │ │ + pixel: evt.xy │ │ │ │ + }); │ │ │ │ + this.layer.drawFeature(this.feature, this.standalone ? undefined : "select"); │ │ │ │ + this.modified = true; │ │ │ │ + this.resetVertices(); │ │ │ │ + this.setFeatureState(); │ │ │ │ + this.onModification(this.feature); │ │ │ │ + this.layer.events.triggerEvent("featuremodified", { │ │ │ │ + feature: this.feature │ │ │ │ + }) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - georss = this.createFeatureXML(features) │ │ │ │ } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [georss]) │ │ │ │ }, │ │ │ │ - createFeatureXML: function(feature) { │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - var featureNode = this.createElementNS(this.rssns, "item"); │ │ │ │ - var titleNode = this.createElementNS(this.rssns, "title"); │ │ │ │ - titleNode.appendChild(this.createTextNode(feature.attributes.title ? feature.attributes.title : "")); │ │ │ │ - var descNode = this.createElementNS(this.rssns, "description"); │ │ │ │ - descNode.appendChild(this.createTextNode(feature.attributes.description ? feature.attributes.description : "")); │ │ │ │ - featureNode.appendChild(titleNode); │ │ │ │ - featureNode.appendChild(descNode); │ │ │ │ - if (feature.attributes.link) { │ │ │ │ - var linkNode = this.createElementNS(this.rssns, "link"); │ │ │ │ - linkNode.appendChild(this.createTextNode(feature.attributes.link)); │ │ │ │ - featureNode.appendChild(linkNode) │ │ │ │ + collectVertices: function() { │ │ │ │ + this.vertices = []; │ │ │ │ + this.virtualVertices = []; │ │ │ │ + var control = this; │ │ │ │ + │ │ │ │ + function collectComponentVertices(geometry) { │ │ │ │ + var i, vertex, component, len; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + vertex = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + vertex._sketch = true; │ │ │ │ + vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ + control.vertices.push(vertex) │ │ │ │ + } else { │ │ │ │ + var numVert = geometry.components.length; │ │ │ │ + if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ + numVert -= 1 │ │ │ │ + } │ │ │ │ + for (i = 0; i < numVert; ++i) { │ │ │ │ + component = geometry.components[i]; │ │ │ │ + if (component.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + vertex = new OpenLayers.Feature.Vector(component); │ │ │ │ + vertex._sketch = true; │ │ │ │ + vertex.renderIntent = control.vertexRenderIntent; │ │ │ │ + control.vertices.push(vertex) │ │ │ │ + } else { │ │ │ │ + collectComponentVertices(component) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (control.createVertices && geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") { │ │ │ │ + for (i = 0, len = geometry.components.length; i < len - 1; ++i) { │ │ │ │ + var prevVertex = geometry.components[i]; │ │ │ │ + var nextVertex = geometry.components[i + 1]; │ │ │ │ + if (prevVertex.CLASS_NAME == "OpenLayers.Geometry.Point" && nextVertex.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ + var x = (prevVertex.x + nextVertex.x) / 2; │ │ │ │ + var y = (prevVertex.y + nextVertex.y) / 2; │ │ │ │ + var point = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(x, y), null, control.virtualStyle); │ │ │ │ + point.geometry.parent = geometry; │ │ │ │ + point._index = i + 1; │ │ │ │ + point._sketch = true; │ │ │ │ + control.virtualVertices.push(point) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - for (var attr in feature.attributes) { │ │ │ │ - if (attr == "link" || attr == "title" || attr == "description") { │ │ │ │ - continue │ │ │ │ + collectComponentVertices.call(this, this.feature.geometry); │ │ │ │ + this.layer.addFeatures(this.virtualVertices, { │ │ │ │ + silent: true │ │ │ │ + }); │ │ │ │ + this.layer.addFeatures(this.vertices, { │ │ │ │ + silent: true │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + collectDragHandle: function() { │ │ │ │ + var geometry = this.feature.geometry; │ │ │ │ + var center = geometry.getBounds().getCenterLonLat(); │ │ │ │ + var originGeometry = new OpenLayers.Geometry.Point(center.lon, center.lat); │ │ │ │ + var origin = new OpenLayers.Feature.Vector(originGeometry); │ │ │ │ + originGeometry.move = function(x, y) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + geometry.move(x, y) │ │ │ │ + }; │ │ │ │ + origin._sketch = true; │ │ │ │ + this.dragHandle = origin; │ │ │ │ + this.dragHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ + this.layer.addFeatures([this.dragHandle], { │ │ │ │ + silent: true │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + collectRadiusHandle: function() { │ │ │ │ + var geometry = this.feature.geometry; │ │ │ │ + var bounds = geometry.getBounds(); │ │ │ │ + var center = bounds.getCenterLonLat(); │ │ │ │ + var originGeometry = new OpenLayers.Geometry.Point(center.lon, center.lat); │ │ │ │ + var radiusGeometry = new OpenLayers.Geometry.Point(bounds.right, bounds.bottom); │ │ │ │ + var radius = new OpenLayers.Feature.Vector(radiusGeometry); │ │ │ │ + var resize = this.mode & OpenLayers.Control.ModifyFeature.RESIZE; │ │ │ │ + var reshape = this.mode & OpenLayers.Control.ModifyFeature.RESHAPE; │ │ │ │ + var rotate = this.mode & OpenLayers.Control.ModifyFeature.ROTATE; │ │ │ │ + radiusGeometry.move = function(x, y) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + var dx1 = this.x - originGeometry.x; │ │ │ │ + var dy1 = this.y - originGeometry.y; │ │ │ │ + var dx0 = dx1 - x; │ │ │ │ + var dy0 = dy1 - y; │ │ │ │ + if (rotate) { │ │ │ │ + var a0 = Math.atan2(dy0, dx0); │ │ │ │ + var a1 = Math.atan2(dy1, dx1); │ │ │ │ + var angle = a1 - a0; │ │ │ │ + angle *= 180 / Math.PI; │ │ │ │ + geometry.rotate(angle, originGeometry) │ │ │ │ } │ │ │ │ - var attrText = this.createTextNode(feature.attributes[attr]); │ │ │ │ - var nodename = attr; │ │ │ │ - if (attr.search(":") != -1) { │ │ │ │ - nodename = attr.split(":")[1] │ │ │ │ + if (resize) { │ │ │ │ + var scale, ratio; │ │ │ │ + if (reshape) { │ │ │ │ + scale = dy1 / dy0; │ │ │ │ + ratio = dx1 / dx0 / scale │ │ │ │ + } else { │ │ │ │ + var l0 = Math.sqrt(dx0 * dx0 + dy0 * dy0); │ │ │ │ + var l1 = Math.sqrt(dx1 * dx1 + dy1 * dy1); │ │ │ │ + scale = l1 / l0 │ │ │ │ + } │ │ │ │ + geometry.resize(scale, originGeometry, ratio) │ │ │ │ } │ │ │ │ - var attrContainer = this.createElementNS(this.featureNS, "feature:" + nodename); │ │ │ │ - attrContainer.appendChild(attrText); │ │ │ │ - featureNode.appendChild(attrContainer) │ │ │ │ - } │ │ │ │ - featureNode.appendChild(geometryNode); │ │ │ │ - return featureNode │ │ │ │ + }; │ │ │ │ + radius._sketch = true; │ │ │ │ + this.radiusHandle = radius; │ │ │ │ + this.radiusHandle.renderIntent = this.vertexRenderIntent; │ │ │ │ + this.layer.addFeatures([this.radiusHandle], { │ │ │ │ + silent: true │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - buildGeometryNode: function(geometry) { │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - geometry.transform(this.internalProjection, this.externalProjection) │ │ │ │ - } │ │ │ │ - var node; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") { │ │ │ │ - node = this.createElementNS(this.georssns, "georss:polygon"); │ │ │ │ - node.appendChild(this.buildCoordinatesNode(geometry.components[0])) │ │ │ │ - } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") { │ │ │ │ - node = this.createElementNS(this.georssns, "georss:line"); │ │ │ │ - node.appendChild(this.buildCoordinatesNode(geometry)) │ │ │ │ - } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - node = this.createElementNS(this.georssns, "georss:point"); │ │ │ │ - node.appendChild(this.buildCoordinatesNode(geometry)) │ │ │ │ - } else { │ │ │ │ - throw "Couldn't parse " + geometry.CLASS_NAME │ │ │ │ - } │ │ │ │ - return node │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.drag.setMap(map); │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ }, │ │ │ │ - buildCoordinatesNode: function(geometry) { │ │ │ │ - var points = null; │ │ │ │ - if (geometry.components) { │ │ │ │ - points = geometry.components │ │ │ │ + handleMapEvents: function(evt) { │ │ │ │ + if (evt.type == "removelayer" || evt.property == "order") { │ │ │ │ + this.moveLayerToTop() │ │ │ │ } │ │ │ │ - var path; │ │ │ │ - if (points) { │ │ │ │ - var numPoints = points.length; │ │ │ │ - var parts = new Array(numPoints); │ │ │ │ - for (var i = 0; i < numPoints; i++) { │ │ │ │ - parts[i] = points[i].y + " " + points[i].x │ │ │ │ - } │ │ │ │ - path = parts.join(" ") │ │ │ │ + }, │ │ │ │ + moveLayerToTop: function() { │ │ │ │ + var index = Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) + 1; │ │ │ │ + this.layer.setZIndex(index) │ │ │ │ + }, │ │ │ │ + moveLayerBack: function() { │ │ │ │ + var index = this.layer.getZIndex() - 1; │ │ │ │ + if (index >= this.map.Z_INDEX_BASE["Feature"]) { │ │ │ │ + this.layer.setZIndex(index) │ │ │ │ } else { │ │ │ │ - path = geometry.y + " " + geometry.x │ │ │ │ + this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer)) │ │ │ │ } │ │ │ │ - return this.createTextNode(path) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.GeoRSS" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ModifyFeature" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.CSWGetDomain = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, OpenLayers.Format.CSWGetDomain.DEFAULTS); │ │ │ │ - var cls = OpenLayers.Format.CSWGetDomain["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported CSWGetDomain version: " + options.version │ │ │ │ - } │ │ │ │ - return new cls(options) │ │ │ │ -}; │ │ │ │ -OpenLayers.Format.CSWGetDomain.DEFAULTS = { │ │ │ │ - version: "2.0.2" │ │ │ │ -}; │ │ │ │ -OpenLayers.Format.OSM = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - checkTags: false, │ │ │ │ - interestingTagsExclude: null, │ │ │ │ - areaTags: null, │ │ │ │ +OpenLayers.Control.ModifyFeature.RESHAPE = 1; │ │ │ │ +OpenLayers.Control.ModifyFeature.RESIZE = 2; │ │ │ │ +OpenLayers.Control.ModifyFeature.ROTATE = 4; │ │ │ │ +OpenLayers.Control.ModifyFeature.DRAG = 8; │ │ │ │ +OpenLayers.Control.NavigationHistory = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_TOGGLE, │ │ │ │ + previous: null, │ │ │ │ + previousOptions: null, │ │ │ │ + next: null, │ │ │ │ + nextOptions: null, │ │ │ │ + limit: 50, │ │ │ │ + autoActivate: true, │ │ │ │ + clearOnDeactivate: false, │ │ │ │ + registry: null, │ │ │ │ + nextStack: null, │ │ │ │ + previousStack: null, │ │ │ │ + listeners: null, │ │ │ │ + restoring: false, │ │ │ │ initialize: function(options) { │ │ │ │ - var layer_defaults = { │ │ │ │ - interestingTagsExclude: ["source", "source_ref", "source:ref", "history", "attribution", "created_by"], │ │ │ │ - areaTags: ["area", "building", "leisure", "tourism", "ruins", "historic", "landuse", "military", "natural", "sport"] │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.registry = OpenLayers.Util.extend({ │ │ │ │ + moveend: this.getState │ │ │ │ + }, this.registry); │ │ │ │ + var previousOptions = { │ │ │ │ + trigger: OpenLayers.Function.bind(this.previousTrigger, this), │ │ │ │ + displayClass: this.displayClass + " " + this.displayClass + "Previous" │ │ │ │ }; │ │ │ │ - layer_defaults = OpenLayers.Util.extend(layer_defaults, options); │ │ │ │ - var interesting = {}; │ │ │ │ - for (var i = 0; i < layer_defaults.interestingTagsExclude.length; i++) { │ │ │ │ - interesting[layer_defaults.interestingTagsExclude[i]] = true │ │ │ │ + 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 + " " + this.displayClass + "Next" │ │ │ │ + }; │ │ │ │ + OpenLayers.Util.extend(nextOptions, this.nextOptions); │ │ │ │ + this.next = new OpenLayers.Control.Button(nextOptions); │ │ │ │ + this.clear() │ │ │ │ + }, │ │ │ │ + onPreviousChange: function(state, length) { │ │ │ │ + if (state && !this.previous.active) { │ │ │ │ + this.previous.activate() │ │ │ │ + } else if (!state && this.previous.active) { │ │ │ │ + this.previous.deactivate() │ │ │ │ } │ │ │ │ - layer_defaults.interestingTagsExclude = interesting; │ │ │ │ - var area = {}; │ │ │ │ - for (var i = 0; i < layer_defaults.areaTags.length; i++) { │ │ │ │ - area[layer_defaults.areaTags[i]] = true │ │ │ │ + }, │ │ │ │ + onNextChange: function(state, length) { │ │ │ │ + if (state && !this.next.active) { │ │ │ │ + this.next.activate() │ │ │ │ + } else if (!state && this.next.active) { │ │ │ │ + this.next.deactivate() │ │ │ │ } │ │ │ │ - layer_defaults.areaTags = area; │ │ │ │ - this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [layer_defaults]) │ │ │ │ }, │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + destroy: function() { │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this); │ │ │ │ + this.previous.destroy(); │ │ │ │ + this.next.destroy(); │ │ │ │ + this.deactivate(); │ │ │ │ + for (var prop in this) { │ │ │ │ + this[prop] = null │ │ │ │ } │ │ │ │ - var nodes = this.getNodes(doc); │ │ │ │ - var ways = this.getWays(doc); │ │ │ │ - var feat_list = new Array(ways.length); │ │ │ │ - for (var i = 0; i < ways.length; i++) { │ │ │ │ - var point_list = new Array(ways[i].nodes.length); │ │ │ │ - var poly = this.isWayArea(ways[i]) ? 1 : 0; │ │ │ │ - for (var j = 0; j < ways[i].nodes.length; j++) { │ │ │ │ - var node = nodes[ways[i].nodes[j]]; │ │ │ │ - var point = new OpenLayers.Geometry.Point(node.lon, node.lat); │ │ │ │ - point.osm_id = parseInt(ways[i].nodes[j]); │ │ │ │ - point_list[j] = point; │ │ │ │ - node.used = true │ │ │ │ - } │ │ │ │ - var geometry = null; │ │ │ │ - if (poly) { │ │ │ │ - geometry = new OpenLayers.Geometry.Polygon(new OpenLayers.Geometry.LinearRing(point_list)) │ │ │ │ - } else { │ │ │ │ - geometry = new OpenLayers.Geometry.LineString(point_list) │ │ │ │ - } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - var feat = new OpenLayers.Feature.Vector(geometry, ways[i].tags); │ │ │ │ - feat.osm_id = parseInt(ways[i].id); │ │ │ │ - feat.fid = "way." + feat.osm_id; │ │ │ │ - feat_list[i] = feat │ │ │ │ + }, │ │ │ │ + setMap: function(map) { │ │ │ │ + this.map = map; │ │ │ │ + this.next.setMap(map); │ │ │ │ + this.previous.setMap(map) │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + this.next.draw(); │ │ │ │ + this.previous.draw() │ │ │ │ + }, │ │ │ │ + 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) │ │ │ │ } │ │ │ │ - for (var node_id in nodes) { │ │ │ │ - var node = nodes[node_id]; │ │ │ │ - if (!node.used || this.checkTags) { │ │ │ │ - var tags = null; │ │ │ │ - if (this.checkTags) { │ │ │ │ - var result = this.getTags(node.node, true); │ │ │ │ - if (node.used && !result[1]) { │ │ │ │ - continue │ │ │ │ - } │ │ │ │ - tags = result[0] │ │ │ │ - } else { │ │ │ │ - tags = this.getTags(node.node) │ │ │ │ - } │ │ │ │ - var feat = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(node["lon"], node["lat"]), tags); │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - feat.geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - feat.osm_id = parseInt(node_id); │ │ │ │ - feat.fid = "node." + feat.osm_id; │ │ │ │ - feat_list.push(feat) │ │ │ │ - } │ │ │ │ - node.node = null │ │ │ │ + return state │ │ │ │ + }, │ │ │ │ + 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 feat_list │ │ │ │ + return state │ │ │ │ }, │ │ │ │ - getNodes: function(doc) { │ │ │ │ - var node_list = doc.getElementsByTagName("node"); │ │ │ │ - var nodes = {}; │ │ │ │ - for (var i = 0; i < node_list.length; i++) { │ │ │ │ - var node = node_list[i]; │ │ │ │ - var id = node.getAttribute("id"); │ │ │ │ - nodes[id] = { │ │ │ │ - lat: node.getAttribute("lat"), │ │ │ │ - lon: node.getAttribute("lon"), │ │ │ │ - node: node │ │ │ │ - } │ │ │ │ + clear: function() { │ │ │ │ + this.previousStack = []; │ │ │ │ + this.previous.deactivate(); │ │ │ │ + this.nextStack = []; │ │ │ │ + this.next.deactivate() │ │ │ │ + }, │ │ │ │ + getState: function() { │ │ │ │ + return { │ │ │ │ + center: this.map.getCenter(), │ │ │ │ + resolution: this.map.getResolution(), │ │ │ │ + projection: this.map.getProjectionObject(), │ │ │ │ + units: this.map.getProjectionObject().getUnits() || this.map.units || this.map.baseLayer.units │ │ │ │ } │ │ │ │ - return nodes │ │ │ │ }, │ │ │ │ - getWays: function(doc) { │ │ │ │ - var way_list = doc.getElementsByTagName("way"); │ │ │ │ - var return_ways = []; │ │ │ │ - for (var i = 0; i < way_list.length; i++) { │ │ │ │ - var way = way_list[i]; │ │ │ │ - var way_object = { │ │ │ │ - id: way.getAttribute("id") │ │ │ │ - }; │ │ │ │ - way_object.tags = this.getTags(way); │ │ │ │ - var node_list = way.getElementsByTagName("nd"); │ │ │ │ - way_object.nodes = new Array(node_list.length); │ │ │ │ - for (var j = 0; j < node_list.length; j++) { │ │ │ │ - way_object.nodes[j] = node_list[j].getAttribute("ref") │ │ │ │ - } │ │ │ │ - return_ways.push(way_object) │ │ │ │ + restore: function(state) { │ │ │ │ + var center, zoom; │ │ │ │ + if (this.map.getProjectionObject() == state.projection) { │ │ │ │ + zoom = this.map.getZoomForResolution(state.resolution); │ │ │ │ + center = state.center │ │ │ │ + } else { │ │ │ │ + center = state.center.clone(); │ │ │ │ + center.transform(state.projection, this.map.getProjectionObject()); │ │ │ │ + var sourceUnits = state.units; │ │ │ │ + var targetUnits = this.map.getProjectionObject().getUnits() || this.map.units || this.map.baseLayer.units; │ │ │ │ + var resolutionFactor = sourceUnits && targetUnits ? OpenLayers.INCHES_PER_UNIT[sourceUnits] / OpenLayers.INCHES_PER_UNIT[targetUnits] : 1; │ │ │ │ + zoom = this.map.getZoomForResolution(resolutionFactor * state.resolution) │ │ │ │ } │ │ │ │ - return return_ways │ │ │ │ + this.map.setCenter(center, zoom) │ │ │ │ }, │ │ │ │ - getTags: function(dom_node, interesting_tags) { │ │ │ │ - var tag_list = dom_node.getElementsByTagName("tag"); │ │ │ │ - var tags = {}; │ │ │ │ - var interesting = false; │ │ │ │ - for (var j = 0; j < tag_list.length; j++) { │ │ │ │ - var key = tag_list[j].getAttribute("k"); │ │ │ │ - tags[key] = tag_list[j].getAttribute("v"); │ │ │ │ - if (interesting_tags) { │ │ │ │ - if (!this.interestingTagsExclude[key]) { │ │ │ │ - interesting = true │ │ │ │ + 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) │ │ │ │ } │ │ │ │ - return interesting_tags ? [tags, interesting] : tags │ │ │ │ }, │ │ │ │ - isWayArea: function(way) { │ │ │ │ - var poly_shaped = false; │ │ │ │ - var poly_tags = false; │ │ │ │ - if (way.nodes[0] == way.nodes[way.nodes.length - 1]) { │ │ │ │ - poly_shaped = true │ │ │ │ - } │ │ │ │ - if (this.checkTags) { │ │ │ │ - for (var key in way.tags) { │ │ │ │ - if (this.areaTags[key]) { │ │ │ │ - poly_tags = true; │ │ │ │ - break │ │ │ │ + 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 poly_shaped && (this.checkTags ? poly_tags : true) │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - write: function(features) { │ │ │ │ - if (!OpenLayers.Util.isArray(features)) { │ │ │ │ - features = [features] │ │ │ │ + initStack: function() { │ │ │ │ + if (this.map.getCenter()) { │ │ │ │ + this.listeners.moveend() │ │ │ │ } │ │ │ │ - this.osm_id = 1; │ │ │ │ - this.created_nodes = {}; │ │ │ │ - var root_node = this.createElementNS(null, "osm"); │ │ │ │ - root_node.setAttribute("version", "0.5"); │ │ │ │ - root_node.setAttribute("generator", "OpenLayers " + OpenLayers.VERSION_NUMBER); │ │ │ │ - for (var i = features.length - 1; i >= 0; i--) { │ │ │ │ - var nodes = this.createFeatureNodes(features[i]); │ │ │ │ - for (var j = 0; j < nodes.length; j++) { │ │ │ │ - root_node.appendChild(nodes[j]) │ │ │ │ + }, │ │ │ │ + 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 OpenLayers.Format.XML.prototype.write.apply(this, [root_node]) │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - createFeatureNodes: function(feature) { │ │ │ │ - var nodes = []; │ │ │ │ - var className = feature.geometry.CLASS_NAME; │ │ │ │ - var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ - type = type.toLowerCase(); │ │ │ │ - var builder = this.createXML[type]; │ │ │ │ - if (builder) { │ │ │ │ - nodes = builder.apply(this, [feature]) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.NavigationHistory" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ArgParser = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + center: null, │ │ │ │ + zoom: null, │ │ │ │ + layers: null, │ │ │ │ + displayProjection: null, │ │ │ │ + getParameters: function(url) { │ │ │ │ + url = url || window.location.href; │ │ │ │ + var parameters = OpenLayers.Util.getParameters(url); │ │ │ │ + var index = url.indexOf("#"); │ │ │ │ + if (index > 0) { │ │ │ │ + url = "?" + url.substring(index + 1, url.length); │ │ │ │ + OpenLayers.Util.extend(parameters, OpenLayers.Util.getParameters(url)) │ │ │ │ } │ │ │ │ - return nodes │ │ │ │ + return parameters │ │ │ │ }, │ │ │ │ - createXML: { │ │ │ │ - point: function(point) { │ │ │ │ - var id = null; │ │ │ │ - var geometry = point.geometry ? point.geometry : point; │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - geometry.transform(this.internalProjection, this.externalProjection) │ │ │ │ - } │ │ │ │ - var already_exists = false; │ │ │ │ - if (point.osm_id) { │ │ │ │ - id = point.osm_id; │ │ │ │ - if (this.created_nodes[id]) { │ │ │ │ - already_exists = true │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ + var control = this.map.controls[i]; │ │ │ │ + if (control != this && control.CLASS_NAME == "OpenLayers.Control.ArgParser") { │ │ │ │ + if (control.displayProjection != this.displayProjection) { │ │ │ │ + this.displayProjection = control.displayProjection │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - id = -this.osm_id; │ │ │ │ - this.osm_id++ │ │ │ │ - } │ │ │ │ - if (already_exists) { │ │ │ │ - node = this.created_nodes[id] │ │ │ │ - } else { │ │ │ │ - var node = this.createElementNS(null, "node") │ │ │ │ - } │ │ │ │ - this.created_nodes[id] = node; │ │ │ │ - node.setAttribute("id", id); │ │ │ │ - node.setAttribute("lon", geometry.x); │ │ │ │ - node.setAttribute("lat", geometry.y); │ │ │ │ - if (point.attributes) { │ │ │ │ - this.serializeTags(point, node) │ │ │ │ + break │ │ │ │ } │ │ │ │ - this.setState(point, node); │ │ │ │ - return already_exists ? [] : [node] │ │ │ │ - }, │ │ │ │ - linestring: function(feature) { │ │ │ │ - var id; │ │ │ │ - var nodes = []; │ │ │ │ - var geometry = feature.geometry; │ │ │ │ - if (feature.osm_id) { │ │ │ │ - id = feature.osm_id │ │ │ │ - } else { │ │ │ │ - id = -this.osm_id; │ │ │ │ - this.osm_id++ │ │ │ │ + } │ │ │ │ + if (i == this.map.controls.length) { │ │ │ │ + var args = this.getParameters(); │ │ │ │ + if (args.layers) { │ │ │ │ + this.layers = args.layers; │ │ │ │ + this.map.events.register("addlayer", this, this.configureLayers); │ │ │ │ + this.configureLayers() │ │ │ │ } │ │ │ │ - var way = this.createElementNS(null, "way"); │ │ │ │ - way.setAttribute("id", id); │ │ │ │ - for (var i = 0; i < geometry.components.length; i++) { │ │ │ │ - var node = this.createXML["point"].apply(this, [geometry.components[i]]); │ │ │ │ - if (node.length) { │ │ │ │ - node = node[0]; │ │ │ │ - var node_ref = node.getAttribute("id"); │ │ │ │ - nodes.push(node) │ │ │ │ - } else { │ │ │ │ - node_ref = geometry.components[i].osm_id; │ │ │ │ - node = this.created_nodes[node_ref] │ │ │ │ + if (args.lat && args.lon) { │ │ │ │ + this.center = new OpenLayers.LonLat(parseFloat(args.lon), parseFloat(args.lat)); │ │ │ │ + if (args.zoom) { │ │ │ │ + this.zoom = parseFloat(args.zoom) │ │ │ │ } │ │ │ │ - this.setState(feature, node); │ │ │ │ - var nd_dom = this.createElementNS(null, "nd"); │ │ │ │ - nd_dom.setAttribute("ref", node_ref); │ │ │ │ - way.appendChild(nd_dom) │ │ │ │ + this.map.events.register("changebaselayer", this, this.setCenter); │ │ │ │ + this.setCenter() │ │ │ │ } │ │ │ │ - this.serializeTags(feature, way); │ │ │ │ - nodes.push(way); │ │ │ │ - return nodes │ │ │ │ - }, │ │ │ │ - polygon: function(feature) { │ │ │ │ - var attrs = OpenLayers.Util.extend({ │ │ │ │ - area: "yes" │ │ │ │ - }, feature.attributes); │ │ │ │ - var feat = new OpenLayers.Feature.Vector(feature.geometry.components[0], attrs); │ │ │ │ - feat.osm_id = feature.osm_id; │ │ │ │ - return this.createXML["linestring"].apply(this, [feat]) │ │ │ │ } │ │ │ │ }, │ │ │ │ - serializeTags: function(feature, node) { │ │ │ │ - for (var key in feature.attributes) { │ │ │ │ - var tag = this.createElementNS(null, "tag"); │ │ │ │ - tag.setAttribute("k", key); │ │ │ │ - tag.setAttribute("v", feature.attributes[key]); │ │ │ │ - node.appendChild(tag) │ │ │ │ + setCenter: function() { │ │ │ │ + if (this.map.baseLayer) { │ │ │ │ + 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) │ │ │ │ } │ │ │ │ }, │ │ │ │ - setState: function(feature, node) { │ │ │ │ - if (feature.state) { │ │ │ │ - var state = null; │ │ │ │ - switch (feature.state) { │ │ │ │ - case OpenLayers.State.UPDATE: │ │ │ │ - state = "modify"; │ │ │ │ - case OpenLayers.State.DELETE: │ │ │ │ - state = "delete" │ │ │ │ - } │ │ │ │ - if (state) { │ │ │ │ - node.setAttribute("action", state) │ │ │ │ + configureLayers: function() { │ │ │ │ + if (this.layers.length == this.map.layers.length) { │ │ │ │ + this.map.events.unregister("addlayer", this, this.configureLayers); │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; 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.Format.OSM" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ArgParser" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - defaultDesc: "No description available", │ │ │ │ - extractWaypoints: true, │ │ │ │ - extractTracks: true, │ │ │ │ - extractRoutes: true, │ │ │ │ - extractAttributes: true, │ │ │ │ - namespaces: { │ │ │ │ - gpx: "http://www.topografix.com/GPX/1/1", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ +OpenLayers.Control.OverviewMap = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + element: null, │ │ │ │ + ovmap: null, │ │ │ │ + size: { │ │ │ │ + w: 180, │ │ │ │ + h: 90 │ │ │ │ }, │ │ │ │ - schemaLocation: "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd", │ │ │ │ - creator: "OpenLayers", │ │ │ │ + layers: null, │ │ │ │ + minRectSize: 15, │ │ │ │ + minRectDisplayClass: "RectReplacement", │ │ │ │ + minRatio: 8, │ │ │ │ + maxRatio: 32, │ │ │ │ + mapOptions: null, │ │ │ │ + autoPan: false, │ │ │ │ + handlers: null, │ │ │ │ + resolutionFactor: 1, │ │ │ │ + maximized: false, │ │ │ │ + maximizeTitle: "", │ │ │ │ + minimizeTitle: "", │ │ │ │ initialize: function(options) { │ │ │ │ - this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + this.layers = []; │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - read: function(doc) { │ │ │ │ - if (typeof doc == "string") { │ │ │ │ - doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]) │ │ │ │ + destroy: function() { │ │ │ │ + if (!this.mapDiv) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - var features = []; │ │ │ │ - if (this.extractTracks) { │ │ │ │ - var tracks = doc.getElementsByTagName("trk"); │ │ │ │ - for (var i = 0, len = tracks.length; i < len; i++) { │ │ │ │ - var attrs = {}; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attrs = this.parseAttributes(tracks[i]) │ │ │ │ - } │ │ │ │ - var segs = this.getElementsByTagNameNS(tracks[i], tracks[i].namespaceURI, "trkseg"); │ │ │ │ - for (var j = 0, seglen = segs.length; j < seglen; j++) { │ │ │ │ - var track = this.extractSegment(segs[j], "trkpt"); │ │ │ │ - features.push(new OpenLayers.Feature.Vector(track, attrs)) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (this.handlers.click) { │ │ │ │ + this.handlers.click.destroy() │ │ │ │ } │ │ │ │ - if (this.extractRoutes) { │ │ │ │ - var routes = doc.getElementsByTagName("rte"); │ │ │ │ - for (var k = 0, klen = routes.length; k < klen; k++) { │ │ │ │ - var attrs = {}; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attrs = this.parseAttributes(routes[k]) │ │ │ │ - } │ │ │ │ - var route = this.extractSegment(routes[k], "rtept"); │ │ │ │ - features.push(new OpenLayers.Feature.Vector(route, attrs)) │ │ │ │ - } │ │ │ │ + if (this.handlers.drag) { │ │ │ │ + this.handlers.drag.destroy() │ │ │ │ } │ │ │ │ - if (this.extractWaypoints) { │ │ │ │ - var waypoints = doc.getElementsByTagName("wpt"); │ │ │ │ - for (var l = 0, len = waypoints.length; l < len; l++) { │ │ │ │ - var attrs = {}; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attrs = this.parseAttributes(waypoints[l]) │ │ │ │ - } │ │ │ │ - var wpt = new OpenLayers.Geometry.Point(waypoints[l].getAttribute("lon"), waypoints[l].getAttribute("lat")); │ │ │ │ - features.push(new OpenLayers.Feature.Vector(wpt, attrs)) │ │ │ │ - } │ │ │ │ + this.ovmap && this.ovmap.viewPortDiv.removeChild(this.extentRectangle); │ │ │ │ + this.extentRectangle = null; │ │ │ │ + if (this.rectEvents) { │ │ │ │ + this.rectEvents.destroy(); │ │ │ │ + this.rectEvents = null │ │ │ │ } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - for (var g = 0, featLength = features.length; g < featLength; g++) { │ │ │ │ - features[g].geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ + if (this.ovmap) { │ │ │ │ + this.ovmap.destroy(); │ │ │ │ + this.ovmap = null │ │ │ │ } │ │ │ │ - return features │ │ │ │ - }, │ │ │ │ - extractSegment: function(segment, segmentType) { │ │ │ │ - var points = this.getElementsByTagNameNS(segment, segment.namespaceURI, segmentType); │ │ │ │ - var point_features = []; │ │ │ │ - for (var i = 0, len = points.length; i < len; i++) { │ │ │ │ - point_features.push(new OpenLayers.Geometry.Point(points[i].getAttribute("lon"), points[i].getAttribute("lat"))) │ │ │ │ + this.element.removeChild(this.mapDiv); │ │ │ │ + this.mapDiv = null; │ │ │ │ + this.div.removeChild(this.element); │ │ │ │ + this.element = null; │ │ │ │ + if (this.maximizeDiv) { │ │ │ │ + this.div.removeChild(this.maximizeDiv); │ │ │ │ + this.maximizeDiv = null │ │ │ │ } │ │ │ │ - return new OpenLayers.Geometry.LineString(point_features) │ │ │ │ - }, │ │ │ │ - parseAttributes: function(node) { │ │ │ │ - var attributes = {}; │ │ │ │ - var attrNode = node.firstChild, │ │ │ │ - value, name; │ │ │ │ - while (attrNode) { │ │ │ │ - if (attrNode.nodeType == 1 && attrNode.firstChild) { │ │ │ │ - value = attrNode.firstChild; │ │ │ │ - if (value.nodeType == 3 || value.nodeType == 4) { │ │ │ │ - name = attrNode.prefix ? attrNode.nodeName.split(":")[1] : attrNode.nodeName; │ │ │ │ - if (name != "trkseg" && name != "rtept") { │ │ │ │ - attributes[name] = value.nodeValue │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - attrNode = attrNode.nextSibling │ │ │ │ + if (this.minimizeDiv) { │ │ │ │ + this.div.removeChild(this.minimizeDiv); │ │ │ │ + this.minimizeDiv = null │ │ │ │ } │ │ │ │ - return attributes │ │ │ │ - }, │ │ │ │ - write: function(features, metadata) { │ │ │ │ - features = OpenLayers.Util.isArray(features) ? features : [features]; │ │ │ │ - var gpx = this.createElementNS(this.namespaces.gpx, "gpx"); │ │ │ │ - gpx.setAttribute("version", "1.1"); │ │ │ │ - gpx.setAttribute("creator", this.creator); │ │ │ │ - this.setAttributes(gpx, { │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ + this.map.events.un({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + moveend: this.update, │ │ │ │ + changebaselayer: this.baseLayerDraw, │ │ │ │ + scope: this │ │ │ │ }); │ │ │ │ - if (metadata && typeof metadata == "object") { │ │ │ │ - gpx.appendChild(this.buildMetadataNode(metadata)) │ │ │ │ - } │ │ │ │ - for (var i = 0, len = features.length; i < len; i++) { │ │ │ │ - gpx.appendChild(this.buildFeatureNode(features[i])) │ │ │ │ - } │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [gpx]) │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - buildMetadataNode: function(metadata) { │ │ │ │ - var types = ["name", "desc", "author"], │ │ │ │ - node = this.createElementNS(this.namespaces.gpx, "metadata"); │ │ │ │ - for (var i = 0; i < types.length; i++) { │ │ │ │ - var type = types[i]; │ │ │ │ - if (metadata[type]) { │ │ │ │ - var n = this.createElementNS(this.namespaces.gpx, type); │ │ │ │ - n.appendChild(this.createTextNode(metadata[type])); │ │ │ │ - node.appendChild(n) │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.layers.length === 0) { │ │ │ │ + if (this.map.baseLayer) { │ │ │ │ + var layer = this.map.baseLayer.clone(); │ │ │ │ + this.layers = [layer] │ │ │ │ + } else { │ │ │ │ + this.map.events.register("changebaselayer", this, this.baseLayerDraw); │ │ │ │ + return this.div │ │ │ │ } │ │ │ │ } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - buildFeatureNode: function(feature) { │ │ │ │ - var geometry = feature.geometry; │ │ │ │ - geometry = geometry.clone(); │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.internalProjection, this.externalProjection) │ │ │ │ - } │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { │ │ │ │ - var wpt = this.buildWptNode(geometry); │ │ │ │ - this.appendAttributesNode(wpt, feature); │ │ │ │ - return wpt │ │ │ │ - } else { │ │ │ │ - var trkNode = this.createElementNS(this.namespaces.gpx, "trk"); │ │ │ │ - this.appendAttributesNode(trkNode, feature); │ │ │ │ - var trkSegNodes = this.buildTrkSegNode(geometry); │ │ │ │ - trkSegNodes = OpenLayers.Util.isArray(trkSegNodes) ? trkSegNodes : [trkSegNodes]; │ │ │ │ - for (var i = 0, len = trkSegNodes.length; i < len; i++) { │ │ │ │ - trkNode.appendChild(trkSegNodes[i]) │ │ │ │ + this.element = document.createElement("div"); │ │ │ │ + this.element.className = this.displayClass + "Element"; │ │ │ │ + this.element.style.display = "none"; │ │ │ │ + this.mapDiv = document.createElement("div"); │ │ │ │ + this.mapDiv.style.width = this.size.w + "px"; │ │ │ │ + this.mapDiv.style.height = this.size.h + "px"; │ │ │ │ + this.mapDiv.style.position = "relative"; │ │ │ │ + this.mapDiv.style.overflow = "hidden"; │ │ │ │ + this.mapDiv.id = OpenLayers.Util.createUniqueID("overviewMap"); │ │ │ │ + this.extentRectangle = document.createElement("div"); │ │ │ │ + this.extentRectangle.style.position = "absolute"; │ │ │ │ + this.extentRectangle.style.zIndex = 1e3; │ │ │ │ + this.extentRectangle.className = this.displayClass + "ExtentRectangle"; │ │ │ │ + this.element.appendChild(this.mapDiv); │ │ │ │ + this.div.appendChild(this.element); │ │ │ │ + if (!this.outsideViewport) { │ │ │ │ + this.div.className += " " + this.displayClass + "Container"; │ │ │ │ + var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png"); │ │ │ │ + this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv(this.displayClass + "MaximizeButton", null, null, img, "absolute"); │ │ │ │ + this.maximizeDiv.style.display = "none"; │ │ │ │ + this.maximizeDiv.className = this.displayClass + "MaximizeButton olButton"; │ │ │ │ + if (this.maximizeTitle) { │ │ │ │ + this.maximizeDiv.title = this.maximizeTitle │ │ │ │ } │ │ │ │ - return trkNode │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - buildTrkSegNode: function(geometry) { │ │ │ │ - var node, i, len, point, nodes; │ │ │ │ - if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" || geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") { │ │ │ │ - node = this.createElementNS(this.namespaces.gpx, "trkseg"); │ │ │ │ - for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ - point = geometry.components[i]; │ │ │ │ - node.appendChild(this.buildTrkPtNode(point)) │ │ │ │ + this.div.appendChild(this.maximizeDiv); │ │ │ │ + var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png"); │ │ │ │ + this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_minimizeDiv", null, null, img, "absolute"); │ │ │ │ + this.minimizeDiv.style.display = "none"; │ │ │ │ + this.minimizeDiv.className = this.displayClass + "MinimizeButton olButton"; │ │ │ │ + if (this.minimizeTitle) { │ │ │ │ + this.minimizeDiv.title = this.minimizeTitle │ │ │ │ } │ │ │ │ - return node │ │ │ │ + this.div.appendChild(this.minimizeDiv); │ │ │ │ + this.minimizeControl() │ │ │ │ } else { │ │ │ │ - nodes = []; │ │ │ │ - for (i = 0, len = geometry.components.length; i < len; i++) { │ │ │ │ - nodes.push(this.buildTrkSegNode(geometry.components[i])) │ │ │ │ - } │ │ │ │ - return nodes │ │ │ │ + this.element.style.display = "" │ │ │ │ + } │ │ │ │ + if (this.map.getExtent()) { │ │ │ │ + this.update() │ │ │ │ + } │ │ │ │ + this.map.events.on({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + moveend: this.update, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (this.maximized) { │ │ │ │ + this.maximizeControl() │ │ │ │ } │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - buildTrkPtNode: function(point) { │ │ │ │ - var node = this.createElementNS(this.namespaces.gpx, "trkpt"); │ │ │ │ - node.setAttribute("lon", point.x); │ │ │ │ - node.setAttribute("lat", point.y); │ │ │ │ - return node │ │ │ │ + baseLayerDraw: function() { │ │ │ │ + this.draw(); │ │ │ │ + this.map.events.unregister("changebaselayer", this, this.baseLayerDraw) │ │ │ │ }, │ │ │ │ - buildWptNode: function(geometry) { │ │ │ │ - var node = this.createElementNS(this.namespaces.gpx, "wpt"); │ │ │ │ - node.setAttribute("lon", geometry.x); │ │ │ │ - node.setAttribute("lat", geometry.y); │ │ │ │ - return node │ │ │ │ + rectDrag: function(px) { │ │ │ │ + var deltaX = this.handlers.drag.last.x - px.x; │ │ │ │ + var deltaY = this.handlers.drag.last.y - px.y; │ │ │ │ + if (deltaX != 0 || deltaY != 0) { │ │ │ │ + var rectTop = this.rectPxBounds.top; │ │ │ │ + var rectLeft = this.rectPxBounds.left; │ │ │ │ + var rectHeight = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ + var rectWidth = this.rectPxBounds.getWidth(); │ │ │ │ + var newTop = Math.max(0, rectTop - deltaY); │ │ │ │ + newTop = Math.min(newTop, this.ovmap.size.h - this.hComp - rectHeight); │ │ │ │ + var newLeft = Math.max(0, rectLeft - deltaX); │ │ │ │ + newLeft = Math.min(newLeft, this.ovmap.size.w - this.wComp - rectWidth); │ │ │ │ + this.setRectPxBounds(new OpenLayers.Bounds(newLeft, newTop + rectHeight, newLeft + rectWidth, newTop)) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - appendAttributesNode: function(node, feature) { │ │ │ │ - var name = this.createElementNS(this.namespaces.gpx, "name"); │ │ │ │ - name.appendChild(this.createTextNode(feature.attributes.name || feature.id)); │ │ │ │ - node.appendChild(name); │ │ │ │ - var desc = this.createElementNS(this.namespaces.gpx, "desc"); │ │ │ │ - desc.appendChild(this.createTextNode(feature.attributes.description || this.defaultDesc)); │ │ │ │ - node.appendChild(desc) │ │ │ │ + mapDivClick: function(evt) { │ │ │ │ + var pxCenter = this.rectPxBounds.getCenterPixel(); │ │ │ │ + var deltaX = evt.xy.x - pxCenter.x; │ │ │ │ + var deltaY = evt.xy.y - pxCenter.y; │ │ │ │ + var top = this.rectPxBounds.top; │ │ │ │ + var left = this.rectPxBounds.left; │ │ │ │ + var height = Math.abs(this.rectPxBounds.getHeight()); │ │ │ │ + var width = this.rectPxBounds.getWidth(); │ │ │ │ + var newTop = Math.max(0, top + deltaY); │ │ │ │ + newTop = Math.min(newTop, this.ovmap.size.h - height); │ │ │ │ + var newLeft = Math.max(0, left + deltaX); │ │ │ │ + newLeft = Math.min(newLeft, this.ovmap.size.w - width); │ │ │ │ + this.setRectPxBounds(new OpenLayers.Bounds(newLeft, newTop + height, newLeft + width, newTop)); │ │ │ │ + this.updateMapToRect() │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.GPX" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WCSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.OWSContext = OpenLayers.Class(OpenLayers.Format.Context, { │ │ │ │ - defaultVersion: "0.3.1", │ │ │ │ - getVersion: function(root, options) { │ │ │ │ - var version = OpenLayers.Format.XML.VersionedOGC.prototype.getVersion.apply(this, arguments); │ │ │ │ - if (version === "0.3.0") { │ │ │ │ - version = this.defaultVersion │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + if (evt.buttonElement === this.minimizeDiv) { │ │ │ │ + this.minimizeControl() │ │ │ │ + } else if (evt.buttonElement === this.maximizeDiv) { │ │ │ │ + this.maximizeControl() │ │ │ │ } │ │ │ │ - return version │ │ │ │ }, │ │ │ │ - toContext: function(obj) { │ │ │ │ - var context = {}; │ │ │ │ - if (obj.CLASS_NAME == "OpenLayers.Map") { │ │ │ │ - context.bounds = obj.getExtent(); │ │ │ │ - context.maxExtent = obj.maxExtent; │ │ │ │ - context.projection = obj.projection; │ │ │ │ - context.size = obj.getSize(); │ │ │ │ - context.layers = obj.layers │ │ │ │ + maximizeControl: function(e) { │ │ │ │ + this.element.style.display = ""; │ │ │ │ + this.showToggle(false); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ } │ │ │ │ - return context │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.OWSContext" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WFSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.KML = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - kml: "http://www.opengis.net/kml/2.2", │ │ │ │ - gx: "http://www.google.com/kml/ext/2.2" │ │ │ │ + minimizeControl: function(e) { │ │ │ │ + this.element.style.display = "none"; │ │ │ │ + this.showToggle(true); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - kmlns: "http://earth.google.com/kml/2.0", │ │ │ │ - placemarksDesc: "No description available", │ │ │ │ - foldersName: "OpenLayers export", │ │ │ │ - foldersDesc: "Exported on " + new Date, │ │ │ │ - extractAttributes: true, │ │ │ │ - kvpAttributes: false, │ │ │ │ - extractStyles: false, │ │ │ │ - extractTracks: false, │ │ │ │ - trackAttributes: null, │ │ │ │ - internalns: null, │ │ │ │ - features: null, │ │ │ │ - styles: null, │ │ │ │ - styleBaseUrl: "", │ │ │ │ - fetched: null, │ │ │ │ - maxDepth: 0, │ │ │ │ - initialize: function(options) { │ │ │ │ - this.regExes = { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g, │ │ │ │ - kmlColor: /(\w{2})(\w{2})(\w{2})(\w{2})/, │ │ │ │ - kmlIconPalette: /root:\/\/icons\/palette-(\d+)(\.\w+)/, │ │ │ │ - straightBracket: /\$\[(.*?)\]/g │ │ │ │ - }; │ │ │ │ - this.externalProjection = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + showToggle: function(minimize) { │ │ │ │ + if (this.maximizeDiv) { │ │ │ │ + this.maximizeDiv.style.display = minimize ? "" : "none" │ │ │ │ + } │ │ │ │ + if (this.minimizeDiv) { │ │ │ │ + this.minimizeDiv.style.display = minimize ? "none" : "" │ │ │ │ + } │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - this.features = []; │ │ │ │ - this.styles = {}; │ │ │ │ - this.fetched = {}; │ │ │ │ - var options = { │ │ │ │ - depth: 0, │ │ │ │ - styleBaseUrl: this.styleBaseUrl │ │ │ │ - }; │ │ │ │ - return this.parseData(data, options) │ │ │ │ + update: function() { │ │ │ │ + if (this.ovmap == null) { │ │ │ │ + this.createMap() │ │ │ │ + } │ │ │ │ + if (this.autoPan || !this.isSuitableOverview()) { │ │ │ │ + this.updateOverview() │ │ │ │ + } │ │ │ │ + this.updateRectToMap() │ │ │ │ }, │ │ │ │ - parseData: function(data, options) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + isSuitableOverview: function() { │ │ │ │ + var mapExtent = this.map.getExtent(); │ │ │ │ + var maxExtent = this.map.getMaxExtent(); │ │ │ │ + var testExtent = new OpenLayers.Bounds(Math.max(mapExtent.left, maxExtent.left), Math.max(mapExtent.bottom, maxExtent.bottom), Math.min(mapExtent.right, maxExtent.right), Math.min(mapExtent.top, maxExtent.top)); │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + testExtent = testExtent.transform(this.map.getProjectionObject(), this.ovmap.getProjectionObject()) │ │ │ │ } │ │ │ │ - var types = ["Link", "NetworkLink", "Style", "StyleMap", "Placemark"]; │ │ │ │ - for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ - var type = types[i]; │ │ │ │ - var nodes = this.getElementsByTagNameNS(data, "*", type); │ │ │ │ - if (nodes.length == 0) { │ │ │ │ - continue │ │ │ │ + var resRatio = this.ovmap.getResolution() / this.map.getResolution(); │ │ │ │ + return resRatio > this.minRatio && resRatio <= this.maxRatio && this.ovmap.getExtent().containsBounds(testExtent) │ │ │ │ + }, │ │ │ │ + updateOverview: function() { │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + var targetRes = this.ovmap.getResolution(); │ │ │ │ + var resRatio = targetRes / mapRes; │ │ │ │ + if (resRatio > this.maxRatio) { │ │ │ │ + targetRes = this.minRatio * mapRes │ │ │ │ + } else if (resRatio <= this.minRatio) { │ │ │ │ + targetRes = this.maxRatio * mapRes │ │ │ │ + } │ │ │ │ + var center; │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + center = this.map.center.clone(); │ │ │ │ + center.transform(this.map.getProjectionObject(), this.ovmap.getProjectionObject()) │ │ │ │ + } else { │ │ │ │ + center = this.map.center │ │ │ │ + } │ │ │ │ + this.ovmap.setCenter(center, this.ovmap.getZoomForResolution(targetRes * this.resolutionFactor)); │ │ │ │ + this.updateRectToMap() │ │ │ │ + }, │ │ │ │ + createMap: function() { │ │ │ │ + var options = OpenLayers.Util.extend({ │ │ │ │ + controls: [], │ │ │ │ + maxResolution: "auto", │ │ │ │ + fallThrough: false │ │ │ │ + }, this.mapOptions); │ │ │ │ + this.ovmap = new OpenLayers.Map(this.mapDiv, options); │ │ │ │ + this.ovmap.viewPortDiv.appendChild(this.extentRectangle); │ │ │ │ + OpenLayers.Event.stopObserving(window, "unload", this.ovmap.unloadDestroy); │ │ │ │ + this.ovmap.addLayers(this.layers); │ │ │ │ + this.ovmap.zoomToMaxExtent(); │ │ │ │ + this.wComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-left-width")) + parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-right-width")); │ │ │ │ + this.wComp = this.wComp ? this.wComp : 2; │ │ │ │ + this.hComp = parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-top-width")) + parseInt(OpenLayers.Element.getStyle(this.extentRectangle, "border-bottom-width")); │ │ │ │ + this.hComp = this.hComp ? this.hComp : 2; │ │ │ │ + this.handlers.drag = new OpenLayers.Handler.Drag(this, { │ │ │ │ + move: this.rectDrag, │ │ │ │ + done: this.updateMapToRect │ │ │ │ + }, { │ │ │ │ + map: this.ovmap │ │ │ │ + }); │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click(this, { │ │ │ │ + click: this.mapDivClick │ │ │ │ + }, { │ │ │ │ + single: true, │ │ │ │ + double: false, │ │ │ │ + stopSingle: true, │ │ │ │ + stopDouble: true, │ │ │ │ + pixelTolerance: 1, │ │ │ │ + map: this.ovmap │ │ │ │ + }); │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, null, true); │ │ │ │ + this.rectEvents.register("mouseover", this, function(e) { │ │ │ │ + if (!this.handlers.drag.active && !this.map.dragging) { │ │ │ │ + this.handlers.drag.activate() │ │ │ │ } │ │ │ │ - switch (type.toLowerCase()) { │ │ │ │ - case "link": │ │ │ │ - case "networklink": │ │ │ │ - this.parseLinks(nodes, options); │ │ │ │ - break; │ │ │ │ - case "style": │ │ │ │ - if (this.extractStyles) { │ │ │ │ - this.parseStyles(nodes, options) │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "stylemap": │ │ │ │ - if (this.extractStyles) { │ │ │ │ - this.parseStyleMaps(nodes, options) │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "placemark": │ │ │ │ - this.parseFeatures(nodes, options); │ │ │ │ - break │ │ │ │ + }); │ │ │ │ + this.rectEvents.register("mouseout", this, function(e) { │ │ │ │ + if (!this.handlers.drag.dragging) { │ │ │ │ + this.handlers.drag.deactivate() │ │ │ │ } │ │ │ │ + }); │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + var sourceUnits = this.map.getProjectionObject().getUnits() || this.map.units || this.map.baseLayer.units; │ │ │ │ + var targetUnits = this.ovmap.getProjectionObject().getUnits() || this.ovmap.units || this.ovmap.baseLayer.units; │ │ │ │ + this.resolutionFactor = sourceUnits && targetUnits ? OpenLayers.INCHES_PER_UNIT[sourceUnits] / OpenLayers.INCHES_PER_UNIT[targetUnits] : 1 │ │ │ │ } │ │ │ │ - return this.features │ │ │ │ }, │ │ │ │ - parseLinks: function(nodes, options) { │ │ │ │ - if (options.depth >= this.maxDepth) { │ │ │ │ - return false │ │ │ │ + updateRectToMap: function() { │ │ │ │ + var bounds; │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + bounds = this.map.getExtent().transform(this.map.getProjectionObject(), this.ovmap.getProjectionObject()) │ │ │ │ + } else { │ │ │ │ + bounds = this.map.getExtent() │ │ │ │ } │ │ │ │ - var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ - newOptions.depth++; │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var href = this.parseProperty(nodes[i], "*", "href"); │ │ │ │ - if (href && !this.fetched[href]) { │ │ │ │ - this.fetched[href] = true; │ │ │ │ - var data = this.fetchLink(href); │ │ │ │ - if (data) { │ │ │ │ - this.parseData(data, newOptions) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + var pxBounds = this.getRectBoundsFromMapBounds(bounds); │ │ │ │ + if (pxBounds) { │ │ │ │ + this.setRectPxBounds(pxBounds) │ │ │ │ } │ │ │ │ }, │ │ │ │ - fetchLink: function(href) { │ │ │ │ - var request = OpenLayers.Request.GET({ │ │ │ │ - url: href, │ │ │ │ - async: false │ │ │ │ + updateMapToRect: function() { │ │ │ │ + var lonLatBounds = this.getMapBoundsFromRectBounds(this.rectPxBounds); │ │ │ │ + if (this.ovmap.getProjection() != this.map.getProjection()) { │ │ │ │ + lonLatBounds = lonLatBounds.transform(this.ovmap.getProjectionObject(), this.map.getProjectionObject()) │ │ │ │ + } │ │ │ │ + this.map.panTo(lonLatBounds.getCenterLonLat()) │ │ │ │ + }, │ │ │ │ + setRectPxBounds: function(pxBounds) { │ │ │ │ + var top = Math.max(pxBounds.top, 0); │ │ │ │ + var left = Math.max(pxBounds.left, 0); │ │ │ │ + var bottom = Math.min(pxBounds.top + Math.abs(pxBounds.getHeight()), this.ovmap.size.h - this.hComp); │ │ │ │ + var right = Math.min(pxBounds.left + pxBounds.getWidth(), this.ovmap.size.w - this.wComp); │ │ │ │ + var width = Math.max(right - left, 0); │ │ │ │ + var height = Math.max(bottom - top, 0); │ │ │ │ + if (width < this.minRectSize || height < this.minRectSize) { │ │ │ │ + this.extentRectangle.className = this.displayClass + this.minRectDisplayClass; │ │ │ │ + var rLeft = left + width / 2 - this.minRectSize / 2; │ │ │ │ + var rTop = top + height / 2 - this.minRectSize / 2; │ │ │ │ + this.extentRectangle.style.top = Math.round(rTop) + "px"; │ │ │ │ + this.extentRectangle.style.left = Math.round(rLeft) + "px"; │ │ │ │ + this.extentRectangle.style.height = this.minRectSize + "px"; │ │ │ │ + this.extentRectangle.style.width = this.minRectSize + "px" │ │ │ │ + } else { │ │ │ │ + this.extentRectangle.className = this.displayClass + "ExtentRectangle"; │ │ │ │ + this.extentRectangle.style.top = Math.round(top) + "px"; │ │ │ │ + this.extentRectangle.style.left = Math.round(left) + "px"; │ │ │ │ + this.extentRectangle.style.height = Math.round(height) + "px"; │ │ │ │ + this.extentRectangle.style.width = Math.round(width) + "px" │ │ │ │ + } │ │ │ │ + this.rectPxBounds = new OpenLayers.Bounds(Math.round(left), Math.round(bottom), Math.round(right), Math.round(top)) │ │ │ │ + }, │ │ │ │ + getRectBoundsFromMapBounds: function(lonLatBounds) { │ │ │ │ + var leftBottomPx = this.getOverviewPxFromLonLat({ │ │ │ │ + lon: lonLatBounds.left, │ │ │ │ + lat: lonLatBounds.bottom │ │ │ │ }); │ │ │ │ - if (request) { │ │ │ │ - return request.responseText │ │ │ │ + var rightTopPx = this.getOverviewPxFromLonLat({ │ │ │ │ + lon: lonLatBounds.right, │ │ │ │ + lat: lonLatBounds.top │ │ │ │ + }); │ │ │ │ + var bounds = null; │ │ │ │ + if (leftBottomPx && rightTopPx) { │ │ │ │ + bounds = new OpenLayers.Bounds(leftBottomPx.x, leftBottomPx.y, rightTopPx.x, rightTopPx.y) │ │ │ │ } │ │ │ │ + return bounds │ │ │ │ }, │ │ │ │ - parseStyles: function(nodes, options) { │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var style = this.parseStyle(nodes[i]); │ │ │ │ - if (style) { │ │ │ │ - var styleName = (options.styleBaseUrl || "") + "#" + style.id; │ │ │ │ - this.styles[styleName] = style │ │ │ │ - } │ │ │ │ + getMapBoundsFromRectBounds: function(pxBounds) { │ │ │ │ + var leftBottomLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ + x: pxBounds.left, │ │ │ │ + y: pxBounds.bottom │ │ │ │ + }); │ │ │ │ + var rightTopLonLat = this.getLonLatFromOverviewPx({ │ │ │ │ + x: pxBounds.right, │ │ │ │ + y: pxBounds.top │ │ │ │ + }); │ │ │ │ + return new OpenLayers.Bounds(leftBottomLonLat.lon, leftBottomLonLat.lat, rightTopLonLat.lon, rightTopLonLat.lat) │ │ │ │ + }, │ │ │ │ + getLonLatFromOverviewPx: function(overviewMapPx) { │ │ │ │ + var size = this.ovmap.size; │ │ │ │ + var res = this.ovmap.getResolution(); │ │ │ │ + var center = this.ovmap.getExtent().getCenterLonLat(); │ │ │ │ + var deltaX = overviewMapPx.x - size.w / 2; │ │ │ │ + var deltaY = overviewMapPx.y - size.h / 2; │ │ │ │ + return { │ │ │ │ + lon: center.lon + deltaX * res, │ │ │ │ + lat: center.lat - deltaY * res │ │ │ │ } │ │ │ │ }, │ │ │ │ - parseKmlColor: function(kmlColor) { │ │ │ │ - var color = null; │ │ │ │ - if (kmlColor) { │ │ │ │ - var matches = kmlColor.match(this.regExes.kmlColor); │ │ │ │ - if (matches) { │ │ │ │ - color = { │ │ │ │ - color: "#" + matches[4] + matches[3] + matches[2], │ │ │ │ - opacity: parseInt(matches[1], 16) / 255 │ │ │ │ - } │ │ │ │ + getOverviewPxFromLonLat: function(lonlat) { │ │ │ │ + var res = this.ovmap.getResolution(); │ │ │ │ + var extent = this.ovmap.getExtent(); │ │ │ │ + if (extent) { │ │ │ │ + return { │ │ │ │ + x: Math.round(1 / res * (lonlat.lon - extent.left)), │ │ │ │ + y: Math.round(1 / res * (extent.top - lonlat.lat)) │ │ │ │ } │ │ │ │ } │ │ │ │ - return color │ │ │ │ }, │ │ │ │ - parseStyle: function(node) { │ │ │ │ - var style = {}; │ │ │ │ - var types = ["LineStyle", "PolyStyle", "IconStyle", "BalloonStyle", "LabelStyle"]; │ │ │ │ - var type, styleTypeNode, nodeList, geometry, parser; │ │ │ │ - for (var i = 0, len = types.length; i < len; ++i) { │ │ │ │ - type = types[i]; │ │ │ │ - styleTypeNode = this.getElementsByTagNameNS(node, "*", type)[0]; │ │ │ │ - if (!styleTypeNode) { │ │ │ │ - continue │ │ │ │ - } │ │ │ │ - switch (type.toLowerCase()) { │ │ │ │ - case "linestyle": │ │ │ │ - var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ - var color = this.parseKmlColor(kmlColor); │ │ │ │ - if (color) { │ │ │ │ - style["strokeColor"] = color.color; │ │ │ │ - style["strokeOpacity"] = color.opacity │ │ │ │ - } │ │ │ │ - var width = this.parseProperty(styleTypeNode, "*", "width"); │ │ │ │ - if (width) { │ │ │ │ - style["strokeWidth"] = width │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "polystyle": │ │ │ │ - var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ - var color = this.parseKmlColor(kmlColor); │ │ │ │ - if (color) { │ │ │ │ - style["fillOpacity"] = color.opacity; │ │ │ │ - style["fillColor"] = color.color │ │ │ │ - } │ │ │ │ - var fill = this.parseProperty(styleTypeNode, "*", "fill"); │ │ │ │ - if (fill == "0") { │ │ │ │ - style["fillColor"] = "none" │ │ │ │ - } │ │ │ │ - var outline = this.parseProperty(styleTypeNode, "*", "outline"); │ │ │ │ - if (outline == "0") { │ │ │ │ - style["strokeWidth"] = "0" │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "iconstyle": │ │ │ │ - var scale = parseFloat(this.parseProperty(styleTypeNode, "*", "scale") || 1); │ │ │ │ - var width = 32 * scale; │ │ │ │ - var height = 32 * scale; │ │ │ │ - var iconNode = this.getElementsByTagNameNS(styleTypeNode, "*", "Icon")[0]; │ │ │ │ - if (iconNode) { │ │ │ │ - var href = this.parseProperty(iconNode, "*", "href"); │ │ │ │ - if (href) { │ │ │ │ - var w = this.parseProperty(iconNode, "*", "w"); │ │ │ │ - var h = this.parseProperty(iconNode, "*", "h"); │ │ │ │ - var google = "http://maps.google.com/mapfiles/kml"; │ │ │ │ - if (OpenLayers.String.startsWith(href, google) && !w && !h) { │ │ │ │ - w = 64; │ │ │ │ - h = 64; │ │ │ │ - scale = scale / 2 │ │ │ │ - } │ │ │ │ - w = w || h; │ │ │ │ - h = h || w; │ │ │ │ - if (w) { │ │ │ │ - width = parseInt(w) * scale │ │ │ │ - } │ │ │ │ - if (h) { │ │ │ │ - height = parseInt(h) * scale │ │ │ │ - } │ │ │ │ - var matches = href.match(this.regExes.kmlIconPalette); │ │ │ │ - if (matches) { │ │ │ │ - var palette = matches[1]; │ │ │ │ - var file_extension = matches[2]; │ │ │ │ - var x = this.parseProperty(iconNode, "*", "x"); │ │ │ │ - var y = this.parseProperty(iconNode, "*", "y"); │ │ │ │ - var posX = x ? x / 32 : 0; │ │ │ │ - var posY = y ? 7 - y / 32 : 7; │ │ │ │ - var pos = posY * 8 + posX; │ │ │ │ - href = "http://maps.google.com/mapfiles/kml/pal" + palette + "/icon" + pos + file_extension │ │ │ │ - } │ │ │ │ - style["graphicOpacity"] = 1; │ │ │ │ - style["externalGraphic"] = href │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var hotSpotNode = this.getElementsByTagNameNS(styleTypeNode, "*", "hotSpot")[0]; │ │ │ │ - if (hotSpotNode) { │ │ │ │ - var x = parseFloat(hotSpotNode.getAttribute("x")); │ │ │ │ - var y = parseFloat(hotSpotNode.getAttribute("y")); │ │ │ │ - var xUnits = hotSpotNode.getAttribute("xunits"); │ │ │ │ - if (xUnits == "pixels") { │ │ │ │ - style["graphicXOffset"] = -x * scale │ │ │ │ - } else if (xUnits == "insetPixels") { │ │ │ │ - style["graphicXOffset"] = -width + x * scale │ │ │ │ - } else if (xUnits == "fraction") { │ │ │ │ - style["graphicXOffset"] = -width * x │ │ │ │ - } │ │ │ │ - var yUnits = hotSpotNode.getAttribute("yunits"); │ │ │ │ - if (yUnits == "pixels") { │ │ │ │ - style["graphicYOffset"] = -height + y * scale + 1 │ │ │ │ - } else if (yUnits == "insetPixels") { │ │ │ │ - style["graphicYOffset"] = -(y * scale) + 1 │ │ │ │ - } else if (yUnits == "fraction") { │ │ │ │ - style["graphicYOffset"] = -height * (1 - y) + 1 │ │ │ │ - } │ │ │ │ - } │ │ │ │ - style["graphicWidth"] = width; │ │ │ │ - style["graphicHeight"] = height; │ │ │ │ - break; │ │ │ │ - case "balloonstyle": │ │ │ │ - var balloonStyle = OpenLayers.Util.getXmlNodeValue(styleTypeNode); │ │ │ │ - if (balloonStyle) { │ │ │ │ - style["balloonStyle"] = balloonStyle.replace(this.regExes.straightBracket, "${$1}") │ │ │ │ - } │ │ │ │ - break; │ │ │ │ - case "labelstyle": │ │ │ │ - var kmlColor = this.parseProperty(styleTypeNode, "*", "color"); │ │ │ │ - var color = this.parseKmlColor(kmlColor); │ │ │ │ - if (color) { │ │ │ │ - style["fontColor"] = color.color; │ │ │ │ - style["fontOpacity"] = color.opacity │ │ │ │ + CLASS_NAME: "OpenLayers.Control.OverviewMap" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Graticule = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + autoActivate: true, │ │ │ │ + intervals: [45, 30, 20, 10, 5, 2, 1, .5, .2, .1, .05, .01, .005, .002, .001], │ │ │ │ + displayInLayerSwitcher: true, │ │ │ │ + visible: true, │ │ │ │ + numPoints: 50, │ │ │ │ + targetSize: 200, │ │ │ │ + layerName: null, │ │ │ │ + labelled: true, │ │ │ │ + labelFormat: "dm", │ │ │ │ + lineSymbolizer: { │ │ │ │ + strokeColor: "#333", │ │ │ │ + strokeWidth: 1, │ │ │ │ + strokeOpacity: .5 │ │ │ │ + }, │ │ │ │ + labelSymbolizer: {}, │ │ │ │ + gratLayer: null, │ │ │ │ + initialize: function(options) { │ │ │ │ + options = options || {}; │ │ │ │ + options.layerName = options.layerName || OpenLayers.i18n("Graticule"); │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.labelSymbolizer.stroke = false; │ │ │ │ + this.labelSymbolizer.fill = false; │ │ │ │ + this.labelSymbolizer.label = "${label}"; │ │ │ │ + this.labelSymbolizer.labelAlign = "${labelAlign}"; │ │ │ │ + this.labelSymbolizer.labelXOffset = "${xOffset}"; │ │ │ │ + this.labelSymbolizer.labelYOffset = "${yOffset}" │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.gratLayer) { │ │ │ │ + this.gratLayer.destroy(); │ │ │ │ + this.gratLayer = null │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.gratLayer) { │ │ │ │ + var gratStyle = new OpenLayers.Style({}, { │ │ │ │ + rules: [new OpenLayers.Rule({ │ │ │ │ + symbolizer: { │ │ │ │ + Point: this.labelSymbolizer, │ │ │ │ + Line: this.lineSymbolizer │ │ │ │ } │ │ │ │ - break; │ │ │ │ - default: │ │ │ │ - } │ │ │ │ + })] │ │ │ │ + }); │ │ │ │ + this.gratLayer = new OpenLayers.Layer.Vector(this.layerName, { │ │ │ │ + styleMap: new OpenLayers.StyleMap({ │ │ │ │ + default: gratStyle │ │ │ │ + }), │ │ │ │ + visibility: this.visible, │ │ │ │ + displayInLayerSwitcher: this.displayInLayerSwitcher │ │ │ │ + }) │ │ │ │ } │ │ │ │ - if (!style["strokeColor"] && style["fillColor"]) { │ │ │ │ - style["strokeColor"] = style["fillColor"] │ │ │ │ + return this.div │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.map.addLayer(this.gratLayer); │ │ │ │ + this.map.events.register("moveend", this, this.update); │ │ │ │ + this.update(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - var id = node.getAttribute("id"); │ │ │ │ - if (id && style) { │ │ │ │ - style.id = id │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.map.events.unregister("moveend", this, this.update); │ │ │ │ + this.map.removeLayer(this.gratLayer); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - return style │ │ │ │ }, │ │ │ │ - parseStyleMaps: function(nodes, options) { │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var node = nodes[i]; │ │ │ │ - var pairs = this.getElementsByTagNameNS(node, "*", "Pair"); │ │ │ │ - var id = node.getAttribute("id"); │ │ │ │ - for (var j = 0, jlen = pairs.length; j < jlen; j++) { │ │ │ │ - var pair = pairs[j]; │ │ │ │ - var key = this.parseProperty(pair, "*", "key"); │ │ │ │ - var styleUrl = this.parseProperty(pair, "*", "styleUrl"); │ │ │ │ - if (styleUrl && key == "normal") { │ │ │ │ - this.styles[(options.styleBaseUrl || "") + "#" + id] = this.styles[(options.styleBaseUrl || "") + styleUrl] │ │ │ │ - } │ │ │ │ + update: function() { │ │ │ │ + var mapBounds = this.map.getExtent(); │ │ │ │ + if (!mapBounds) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + this.gratLayer.destroyFeatures(); │ │ │ │ + var llProj = new OpenLayers.Projection("EPSG:4326"); │ │ │ │ + var mapProj = this.map.getProjectionObject(); │ │ │ │ + var mapRes = this.map.getResolution(); │ │ │ │ + if (mapProj.proj && mapProj.proj.projName == "longlat") { │ │ │ │ + this.numPoints = 1 │ │ │ │ + } │ │ │ │ + var mapCenter = this.map.getCenter(); │ │ │ │ + var mapCenterLL = new OpenLayers.Pixel(mapCenter.lon, mapCenter.lat); │ │ │ │ + OpenLayers.Projection.transform(mapCenterLL, mapProj, llProj); │ │ │ │ + var testSq = this.targetSize * mapRes; │ │ │ │ + testSq *= testSq; │ │ │ │ + var llInterval; │ │ │ │ + for (var i = 0; i < this.intervals.length; ++i) { │ │ │ │ + llInterval = this.intervals[i]; │ │ │ │ + var delta = llInterval / 2; │ │ │ │ + var p1 = mapCenterLL.offset({ │ │ │ │ + x: -delta, │ │ │ │ + y: -delta │ │ │ │ + }); │ │ │ │ + var p2 = mapCenterLL.offset({ │ │ │ │ + x: delta, │ │ │ │ + y: delta │ │ │ │ + }); │ │ │ │ + OpenLayers.Projection.transform(p1, llProj, mapProj); │ │ │ │ + OpenLayers.Projection.transform(p2, llProj, mapProj); │ │ │ │ + var distSq = (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y); │ │ │ │ + if (distSq <= testSq) { │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - parseFeatures: function(nodes, options) { │ │ │ │ - var features = []; │ │ │ │ - for (var i = 0, len = nodes.length; i < len; i++) { │ │ │ │ - var featureNode = nodes[i]; │ │ │ │ - var feature = this.parseFeature.apply(this, [featureNode]); │ │ │ │ - if (feature) { │ │ │ │ - if (this.extractStyles && feature.attributes && feature.attributes.styleUrl) { │ │ │ │ - feature.style = this.getStyle(feature.attributes.styleUrl, options) │ │ │ │ - } │ │ │ │ - if (this.extractStyles) { │ │ │ │ - var inlineStyleNode = this.getElementsByTagNameNS(featureNode, "*", "Style")[0]; │ │ │ │ - if (inlineStyleNode) { │ │ │ │ - var inlineStyle = this.parseStyle(inlineStyleNode); │ │ │ │ - if (inlineStyle) { │ │ │ │ - feature.style = OpenLayers.Util.extend(feature.style, inlineStyle) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (this.extractTracks) { │ │ │ │ - var tracks = this.getElementsByTagNameNS(featureNode, this.namespaces.gx, "Track"); │ │ │ │ - if (tracks && tracks.length > 0) { │ │ │ │ - var track = tracks[0]; │ │ │ │ - var container = { │ │ │ │ - features: [], │ │ │ │ - feature: feature │ │ │ │ - }; │ │ │ │ - this.readNode(track, container); │ │ │ │ - if (container.features.length > 0) { │ │ │ │ - features.push.apply(features, container.features) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - features.push(feature) │ │ │ │ + mapCenterLL.x = Math.floor(mapCenterLL.x / llInterval) * llInterval; │ │ │ │ + mapCenterLL.y = Math.floor(mapCenterLL.y / llInterval) * llInterval; │ │ │ │ + var iter = 0; │ │ │ │ + var centerLonPoints = [mapCenterLL.clone()]; │ │ │ │ + var newPoint = mapCenterLL.clone(); │ │ │ │ + var mapXY; │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: 0, │ │ │ │ + y: llInterval │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLonPoints.unshift(newPoint) │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ + newPoint = mapCenterLL.clone(); │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: 0, │ │ │ │ + y: -llInterval │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLonPoints.push(newPoint) │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ + iter = 0; │ │ │ │ + var centerLatPoints = [mapCenterLL.clone()]; │ │ │ │ + newPoint = mapCenterLL.clone(); │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: -llInterval, │ │ │ │ + y: 0 │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLatPoints.unshift(newPoint) │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ + newPoint = mapCenterLL.clone(); │ │ │ │ + do { │ │ │ │ + newPoint = newPoint.offset({ │ │ │ │ + x: llInterval, │ │ │ │ + y: 0 │ │ │ │ + }); │ │ │ │ + mapXY = OpenLayers.Projection.transform(newPoint.clone(), llProj, mapProj); │ │ │ │ + centerLatPoints.push(newPoint) │ │ │ │ + } while (mapBounds.containsPixel(mapXY) && ++iter < 1e3); │ │ │ │ + var lines = []; │ │ │ │ + for (var i = 0; i < centerLatPoints.length; ++i) { │ │ │ │ + var lon = centerLatPoints[i].x; │ │ │ │ + var pointList = []; │ │ │ │ + var labelPoint = null; │ │ │ │ + var latEnd = Math.min(centerLonPoints[0].y, 90); │ │ │ │ + var latStart = Math.max(centerLonPoints[centerLonPoints.length - 1].y, -90); │ │ │ │ + var latDelta = (latEnd - latStart) / this.numPoints; │ │ │ │ + var lat = latStart; │ │ │ │ + for (var j = 0; j <= this.numPoints; ++j) { │ │ │ │ + var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ + gridPoint.transform(llProj, mapProj); │ │ │ │ + pointList.push(gridPoint); │ │ │ │ + lat += latDelta; │ │ │ │ + if (gridPoint.y >= mapBounds.bottom && !labelPoint) { │ │ │ │ + labelPoint = gridPoint │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - throw "Bad Placemark: " + i │ │ │ │ } │ │ │ │ + if (this.labelled) { │ │ │ │ + var labelPos = new OpenLayers.Geometry.Point(labelPoint.x, mapBounds.bottom); │ │ │ │ + var labelAttrs = { │ │ │ │ + value: lon, │ │ │ │ + label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lon, "lon", this.labelFormat) : "", │ │ │ │ + labelAlign: "cb", │ │ │ │ + xOffset: 0, │ │ │ │ + yOffset: 2 │ │ │ │ + }; │ │ │ │ + this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)) │ │ │ │ + } │ │ │ │ + var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ + lines.push(new OpenLayers.Feature.Vector(geom)) │ │ │ │ } │ │ │ │ - this.features = this.features.concat(features) │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - kml: { │ │ │ │ - when: function(node, container) { │ │ │ │ - container.whens.push(OpenLayers.Date.parse(this.getChildValue(node))) │ │ │ │ - }, │ │ │ │ - _trackPointAttribute: function(node, container) { │ │ │ │ - var name = node.nodeName.split(":").pop(); │ │ │ │ - container.attributes[name].push(this.getChildValue(node)) │ │ │ │ + for (var j = 0; j < centerLonPoints.length; ++j) { │ │ │ │ + lat = centerLonPoints[j].y; │ │ │ │ + if (lat < -90 || lat > 90) { │ │ │ │ + continue │ │ │ │ } │ │ │ │ - }, │ │ │ │ - gx: { │ │ │ │ - Track: function(node, container) { │ │ │ │ - var obj = { │ │ │ │ - whens: [], │ │ │ │ - points: [], │ │ │ │ - angles: [] │ │ │ │ - }; │ │ │ │ - if (this.trackAttributes) { │ │ │ │ - var name; │ │ │ │ - obj.attributes = {}; │ │ │ │ - for (var i = 0, ii = this.trackAttributes.length; i < ii; ++i) { │ │ │ │ - name = this.trackAttributes[i]; │ │ │ │ - obj.attributes[name] = []; │ │ │ │ - if (!(name in this.readers.kml)) { │ │ │ │ - this.readers.kml[name] = this.readers.kml._trackPointAttribute │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - if (obj.whens.length !== obj.points.length) { │ │ │ │ - throw new Error("gx:Track with unequal number of when (" + obj.whens.length + ") and gx:coord (" + obj.points.length + ") elements.") │ │ │ │ - } │ │ │ │ - var hasAngles = obj.angles.length > 0; │ │ │ │ - if (hasAngles && obj.whens.length !== obj.angles.length) { │ │ │ │ - throw new Error("gx:Track with unequal number of when (" + obj.whens.length + ") and gx:angles (" + obj.angles.length + ") elements.") │ │ │ │ - } │ │ │ │ - var feature, point, angles; │ │ │ │ - for (var i = 0, ii = obj.whens.length; i < ii; ++i) { │ │ │ │ - feature = container.feature.clone(); │ │ │ │ - feature.fid = container.feature.fid || container.feature.id; │ │ │ │ - point = obj.points[i]; │ │ │ │ - feature.geometry = point; │ │ │ │ - if ("z" in point) { │ │ │ │ - feature.attributes.altitude = point.z │ │ │ │ - } │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - feature.geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - if (this.trackAttributes) { │ │ │ │ - for (var j = 0, jj = this.trackAttributes.length; j < jj; ++j) { │ │ │ │ - var name = this.trackAttributes[j]; │ │ │ │ - feature.attributes[name] = obj.attributes[name][i] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - feature.attributes.when = obj.whens[i]; │ │ │ │ - feature.attributes.trackId = container.feature.id; │ │ │ │ - if (hasAngles) { │ │ │ │ - angles = obj.angles[i]; │ │ │ │ - feature.attributes.heading = parseFloat(angles[0]); │ │ │ │ - feature.attributes.tilt = parseFloat(angles[1]); │ │ │ │ - feature.attributes.roll = parseFloat(angles[2]) │ │ │ │ - } │ │ │ │ - container.features.push(feature) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - coord: function(node, container) { │ │ │ │ - var str = this.getChildValue(node); │ │ │ │ - var coords = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ - var point = new OpenLayers.Geometry.Point(coords[0], coords[1]); │ │ │ │ - if (coords.length > 2) { │ │ │ │ - point.z = parseFloat(coords[2]) │ │ │ │ + var pointList = []; │ │ │ │ + var lonStart = centerLatPoints[0].x; │ │ │ │ + var lonEnd = centerLatPoints[centerLatPoints.length - 1].x; │ │ │ │ + var lonDelta = (lonEnd - lonStart) / this.numPoints; │ │ │ │ + var lon = lonStart; │ │ │ │ + var labelPoint = null; │ │ │ │ + for (var i = 0; i <= this.numPoints; ++i) { │ │ │ │ + var gridPoint = new OpenLayers.Geometry.Point(lon, lat); │ │ │ │ + gridPoint.transform(llProj, mapProj); │ │ │ │ + pointList.push(gridPoint); │ │ │ │ + lon += lonDelta; │ │ │ │ + if (gridPoint.x < mapBounds.right) { │ │ │ │ + labelPoint = gridPoint │ │ │ │ } │ │ │ │ - container.points.push(point) │ │ │ │ - }, │ │ │ │ - angles: function(node, container) { │ │ │ │ - var str = this.getChildValue(node); │ │ │ │ - var parts = str.replace(this.regExes.trimSpace, "").split(/\s+/); │ │ │ │ - container.angles.push(parts) │ │ │ │ } │ │ │ │ + if (this.labelled) { │ │ │ │ + var labelPos = new OpenLayers.Geometry.Point(mapBounds.right, labelPoint.y); │ │ │ │ + var labelAttrs = { │ │ │ │ + value: lat, │ │ │ │ + label: this.labelled ? OpenLayers.Util.getFormattedLonLat(lat, "lat", this.labelFormat) : "", │ │ │ │ + labelAlign: "rb", │ │ │ │ + xOffset: -2, │ │ │ │ + yOffset: 2 │ │ │ │ + }; │ │ │ │ + this.gratLayer.addFeatures(new OpenLayers.Feature.Vector(labelPos, labelAttrs)) │ │ │ │ + } │ │ │ │ + var geom = new OpenLayers.Geometry.LineString(pointList); │ │ │ │ + lines.push(new OpenLayers.Feature.Vector(geom)) │ │ │ │ } │ │ │ │ + this.gratLayer.addFeatures(lines) │ │ │ │ }, │ │ │ │ - parseFeature: function(node) { │ │ │ │ - var order = ["MultiGeometry", "Polygon", "LineString", "Point"]; │ │ │ │ - var type, nodeList, geometry, parser; │ │ │ │ - for (var i = 0, len = order.length; i < len; ++i) { │ │ │ │ - type = order[i]; │ │ │ │ - this.internalns = node.namespaceURI ? node.namespaceURI : this.kmlns; │ │ │ │ - nodeList = this.getElementsByTagNameNS(node, this.internalns, type); │ │ │ │ - if (nodeList.length > 0) { │ │ │ │ - var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ - if (parser) { │ │ │ │ - geometry = parser.apply(this, [nodeList[0]]); │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - geometry.transform(this.externalProjection, this.internalProjection) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - throw new TypeError("Unsupported geometry type: " + type) │ │ │ │ - } │ │ │ │ - break │ │ │ │ - } │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Graticule" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.GetFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + protocol: null, │ │ │ │ + multipleKey: null, │ │ │ │ + toggleKey: null, │ │ │ │ + modifiers: null, │ │ │ │ + multiple: false, │ │ │ │ + click: true, │ │ │ │ + single: true, │ │ │ │ + clickout: true, │ │ │ │ + toggle: false, │ │ │ │ + clickTolerance: 5, │ │ │ │ + hover: false, │ │ │ │ + box: false, │ │ │ │ + maxFeatures: 10, │ │ │ │ + features: null, │ │ │ │ + hoverFeature: null, │ │ │ │ + handlers: null, │ │ │ │ + hoverResponse: null, │ │ │ │ + filterType: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + initialize: function(options) { │ │ │ │ + options.handlerOptions = options.handlerOptions || {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.features = {}; │ │ │ │ + this.handlers = {}; │ │ │ │ + if (this.click) { │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click(this, { │ │ │ │ + click: this.selectClick │ │ │ │ + }, this.handlerOptions.click || {}) │ │ │ │ } │ │ │ │ - var attributes; │ │ │ │ - if (this.extractAttributes) { │ │ │ │ - attributes = this.parseAttributes(node) │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.selectBox │ │ │ │ + }, OpenLayers.Util.extend(this.handlerOptions.box, { │ │ │ │ + boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ + })) │ │ │ │ } │ │ │ │ - var feature = new OpenLayers.Feature.Vector(geometry, attributes); │ │ │ │ - var fid = node.getAttribute("id") || node.getAttribute("name"); │ │ │ │ - if (fid != null) { │ │ │ │ - feature.fid = fid │ │ │ │ + if (this.hover) { │ │ │ │ + this.handlers.hover = new OpenLayers.Handler.Hover(this, { │ │ │ │ + move: this.cancelHover, │ │ │ │ + pause: this.selectHover │ │ │ │ + }, OpenLayers.Util.extend(this.handlerOptions.hover, { │ │ │ │ + delay: 250, │ │ │ │ + pixelTolerance: 2 │ │ │ │ + })) │ │ │ │ } │ │ │ │ - return feature │ │ │ │ }, │ │ │ │ - getStyle: function(styleUrl, options) { │ │ │ │ - var styleBaseUrl = OpenLayers.Util.removeTail(styleUrl); │ │ │ │ - var newOptions = OpenLayers.Util.extend({}, options); │ │ │ │ - newOptions.depth++; │ │ │ │ - newOptions.styleBaseUrl = styleBaseUrl; │ │ │ │ - if (!this.styles[styleUrl] && !OpenLayers.String.startsWith(styleUrl, "#") && newOptions.depth <= this.maxDepth && !this.fetched[styleBaseUrl]) { │ │ │ │ - var data = this.fetchLink(styleBaseUrl); │ │ │ │ - if (data) { │ │ │ │ - this.parseData(data, newOptions) │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + for (var i in this.handlers) { │ │ │ │ + this.handlers[i].activate() │ │ │ │ } │ │ │ │ } │ │ │ │ - var style = OpenLayers.Util.extend({}, this.styles[styleUrl]); │ │ │ │ - return style │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ }, │ │ │ │ - parseGeometry: { │ │ │ │ - point: function(node) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, this.internalns, "coordinates"); │ │ │ │ - var coords = []; │ │ │ │ - if (nodeList.length > 0) { │ │ │ │ - var coordString = nodeList[0].firstChild.nodeValue; │ │ │ │ - coordString = coordString.replace(this.regExes.removeSpace, ""); │ │ │ │ - coords = coordString.split(",") │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + for (var i in this.handlers) { │ │ │ │ + this.handlers[i].deactivate() │ │ │ │ } │ │ │ │ - var point = null; │ │ │ │ - if (coords.length > 1) { │ │ │ │ - if (coords.length == 2) { │ │ │ │ - coords[2] = null │ │ │ │ - } │ │ │ │ - point = new OpenLayers.Geometry.Point(coords[0], coords[1], coords[2]) │ │ │ │ - } else { │ │ │ │ - throw "Bad coordinate string: " + coordString │ │ │ │ + } │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + selectClick: function(evt) { │ │ │ │ + var bounds = this.pixelToBounds(evt.xy); │ │ │ │ + this.setModifiers(evt); │ │ │ │ + this.request(bounds, { │ │ │ │ + single: this.single │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + selectBox: function(position) { │ │ │ │ + var bounds; │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat) │ │ │ │ + } else { │ │ │ │ + if (this.click) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - return point │ │ │ │ - }, │ │ │ │ - linestring: function(node, ring) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, this.internalns, "coordinates"); │ │ │ │ - var line = null; │ │ │ │ - if (nodeList.length > 0) { │ │ │ │ - var coordString = this.getChildValue(nodeList[0]); │ │ │ │ - coordString = coordString.replace(this.regExes.trimSpace, ""); │ │ │ │ - coordString = coordString.replace(this.regExes.trimComma, ","); │ │ │ │ - var pointList = coordString.split(this.regExes.splitSpace); │ │ │ │ - var numPoints = pointList.length; │ │ │ │ - var points = new Array(numPoints); │ │ │ │ - var coords, numCoords; │ │ │ │ - for (var i = 0; i < numPoints; ++i) { │ │ │ │ - coords = pointList[i].split(","); │ │ │ │ - numCoords = coords.length; │ │ │ │ - if (numCoords > 1) { │ │ │ │ - if (coords.length == 2) { │ │ │ │ - coords[2] = null │ │ │ │ + bounds = this.pixelToBounds(position) │ │ │ │ + } │ │ │ │ + this.setModifiers(this.handlers.box.dragHandler.evt); │ │ │ │ + this.request(bounds) │ │ │ │ + }, │ │ │ │ + selectHover: function(evt) { │ │ │ │ + var bounds = this.pixelToBounds(evt.xy); │ │ │ │ + this.request(bounds, { │ │ │ │ + single: true, │ │ │ │ + hover: true │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + cancelHover: function() { │ │ │ │ + if (this.hoverResponse) { │ │ │ │ + this.protocol.abort(this.hoverResponse); │ │ │ │ + this.hoverResponse = null; │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + request: function(bounds, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: this.filterType, │ │ │ │ + value: bounds │ │ │ │ + }); │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + var response = this.protocol.read({ │ │ │ │ + maxFeatures: options.single == true ? this.maxFeatures : undefined, │ │ │ │ + filter: filter, │ │ │ │ + callback: function(result) { │ │ │ │ + if (result.success()) { │ │ │ │ + if (result.features.length) { │ │ │ │ + if (options.single == true) { │ │ │ │ + this.selectBestFeature(result.features, bounds.getCenterLonLat(), options) │ │ │ │ + } else { │ │ │ │ + this.select(result.features) │ │ │ │ } │ │ │ │ - points[i] = new OpenLayers.Geometry.Point(coords[0], coords[1], coords[2]) │ │ │ │ - } else { │ │ │ │ - throw "Bad LineString point coordinates: " + pointList[i] │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (numPoints) { │ │ │ │ - if (ring) { │ │ │ │ - line = new OpenLayers.Geometry.LinearRing(points) │ │ │ │ + } else if (options.hover) { │ │ │ │ + this.hoverSelect() │ │ │ │ } else { │ │ │ │ - line = new OpenLayers.Geometry.LineString(points) │ │ │ │ + this.events.triggerEvent("clickout"); │ │ │ │ + if (this.clickout) { │ │ │ │ + this.unselectAll() │ │ │ │ + } │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - throw "Bad LineString coordinates: " + coordString │ │ │ │ } │ │ │ │ - } │ │ │ │ - return line │ │ │ │ - }, │ │ │ │ - polygon: function(node) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, this.internalns, "LinearRing"); │ │ │ │ - var numRings = nodeList.length; │ │ │ │ - var components = new Array(numRings); │ │ │ │ - if (numRings > 0) { │ │ │ │ - var ring; │ │ │ │ - for (var i = 0, len = nodeList.length; i < len; ++i) { │ │ │ │ - ring = this.parseGeometry.linestring.apply(this, [nodeList[i], true]); │ │ │ │ - if (ring) { │ │ │ │ - components[i] = ring │ │ │ │ - } else { │ │ │ │ - throw "Bad LinearRing geometry: " + i │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (options.hover == true) { │ │ │ │ + this.hoverResponse = response │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + selectBestFeature: function(features, clickPosition, options) { │ │ │ │ + options = options || {}; │ │ │ │ + if (features.length) { │ │ │ │ + var point = new OpenLayers.Geometry.Point(clickPosition.lon, clickPosition.lat); │ │ │ │ + var feature, resultFeature, dist; │ │ │ │ + var minDist = Number.MAX_VALUE; │ │ │ │ + for (var i = 0; i < features.length; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (feature.geometry) { │ │ │ │ + dist = point.distanceTo(feature.geometry, { │ │ │ │ + edge: false │ │ │ │ + }); │ │ │ │ + if (dist < minDist) { │ │ │ │ + minDist = dist; │ │ │ │ + resultFeature = feature; │ │ │ │ + if (minDist == 0) { │ │ │ │ + break │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - return new OpenLayers.Geometry.Polygon(components) │ │ │ │ - }, │ │ │ │ - multigeometry: function(node) { │ │ │ │ - var child, parser; │ │ │ │ - var parts = []; │ │ │ │ - var children = node.childNodes; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - var type = child.prefix ? child.nodeName.split(":")[1] : child.nodeName; │ │ │ │ - var parser = this.parseGeometry[type.toLowerCase()]; │ │ │ │ - if (parser) { │ │ │ │ - parts.push(parser.apply(this, [child])) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + if (options.hover == true) { │ │ │ │ + this.hoverSelect(resultFeature) │ │ │ │ + } else { │ │ │ │ + this.select(resultFeature || features) │ │ │ │ } │ │ │ │ - return new OpenLayers.Geometry.Collection(parts) │ │ │ │ } │ │ │ │ }, │ │ │ │ - parseAttributes: function(node) { │ │ │ │ - var attributes = {}; │ │ │ │ - var edNodes = node.getElementsByTagName("ExtendedData"); │ │ │ │ - if (edNodes.length) { │ │ │ │ - attributes = this.parseExtendedData(edNodes[0]) │ │ │ │ + setModifiers: function(evt) { │ │ │ │ + this.modifiers = { │ │ │ │ + multiple: this.multiple || this.multipleKey && evt[this.multipleKey], │ │ │ │ + toggle: this.toggle || this.toggleKey && evt[this.toggleKey] │ │ │ │ } │ │ │ │ - var child, grandchildren, grandchild; │ │ │ │ - var children = node.childNodes; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - child = children[i]; │ │ │ │ - if (child.nodeType == 1) { │ │ │ │ - grandchildren = child.childNodes; │ │ │ │ - if (grandchildren.length >= 1 && grandchildren.length <= 3) { │ │ │ │ - var grandchild; │ │ │ │ - switch (grandchildren.length) { │ │ │ │ - case 1: │ │ │ │ - grandchild = grandchildren[0]; │ │ │ │ - break; │ │ │ │ - case 2: │ │ │ │ - var c1 = grandchildren[0]; │ │ │ │ - var c2 = grandchildren[1]; │ │ │ │ - grandchild = c1.nodeType == 3 || c1.nodeType == 4 ? c1 : c2; │ │ │ │ - break; │ │ │ │ - case 3: │ │ │ │ - default: │ │ │ │ - grandchild = grandchildren[1]; │ │ │ │ - break │ │ │ │ + }, │ │ │ │ + select: function(features) { │ │ │ │ + if (!this.modifiers.multiple && !this.modifiers.toggle) { │ │ │ │ + this.unselectAll() │ │ │ │ + } │ │ │ │ + if (!OpenLayers.Util.isArray(features)) { │ │ │ │ + features = [features] │ │ │ │ + } │ │ │ │ + var cont = this.events.triggerEvent("beforefeaturesselected", { │ │ │ │ + features: features │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + var selectedFeatures = []; │ │ │ │ + var feature; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (this.features[feature.fid || feature.id]) { │ │ │ │ + if (this.modifiers.toggle) { │ │ │ │ + this.unselect(this.features[feature.fid || feature.id]) │ │ │ │ } │ │ │ │ - if (grandchild.nodeType == 3 || grandchild.nodeType == 4) { │ │ │ │ - var name = child.prefix ? child.nodeName.split(":")[1] : child.nodeName; │ │ │ │ - var value = OpenLayers.Util.getXmlNodeValue(grandchild); │ │ │ │ - if (value) { │ │ │ │ - value = value.replace(this.regExes.trimSpace, ""); │ │ │ │ - attributes[name] = value │ │ │ │ - } │ │ │ │ + } else { │ │ │ │ + cont = this.events.triggerEvent("beforefeatureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + this.features[feature.fid || feature.id] = feature; │ │ │ │ + selectedFeatures.push(feature); │ │ │ │ + this.events.triggerEvent("featureselected", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ + this.events.triggerEvent("featuresselected", { │ │ │ │ + features: selectedFeatures │ │ │ │ + }) │ │ │ │ } │ │ │ │ - return attributes │ │ │ │ }, │ │ │ │ - parseExtendedData: function(node) { │ │ │ │ - var attributes = {}; │ │ │ │ - var i, len, data, key; │ │ │ │ - var dataNodes = node.getElementsByTagName("Data"); │ │ │ │ - for (i = 0, len = dataNodes.length; i < len; i++) { │ │ │ │ - data = dataNodes[i]; │ │ │ │ - key = data.getAttribute("name"); │ │ │ │ - var ed = {}; │ │ │ │ - var valueNode = data.getElementsByTagName("value"); │ │ │ │ - if (valueNode.length) { │ │ │ │ - ed["value"] = this.getChildValue(valueNode[0]) │ │ │ │ - } │ │ │ │ - if (this.kvpAttributes) { │ │ │ │ - attributes[key] = ed["value"] │ │ │ │ - } else { │ │ │ │ - var nameNode = data.getElementsByTagName("displayName"); │ │ │ │ - if (nameNode.length) { │ │ │ │ - ed["displayName"] = this.getChildValue(nameNode[0]) │ │ │ │ - } │ │ │ │ - attributes[key] = ed │ │ │ │ - } │ │ │ │ + hoverSelect: function(feature) { │ │ │ │ + var fid = feature ? feature.fid || feature.id : null; │ │ │ │ + var hfid = this.hoverFeature ? this.hoverFeature.fid || this.hoverFeature.id : null; │ │ │ │ + if (hfid && hfid != fid) { │ │ │ │ + this.events.triggerEvent("outfeature", { │ │ │ │ + feature: this.hoverFeature │ │ │ │ + }); │ │ │ │ + this.hoverFeature = null │ │ │ │ } │ │ │ │ - var simpleDataNodes = node.getElementsByTagName("SimpleData"); │ │ │ │ - for (i = 0, len = simpleDataNodes.length; i < len; i++) { │ │ │ │ - var ed = {}; │ │ │ │ - data = simpleDataNodes[i]; │ │ │ │ - key = data.getAttribute("name"); │ │ │ │ - ed["value"] = this.getChildValue(data); │ │ │ │ - if (this.kvpAttributes) { │ │ │ │ - attributes[key] = ed["value"] │ │ │ │ - } else { │ │ │ │ - ed["displayName"] = key; │ │ │ │ - attributes[key] = ed │ │ │ │ - } │ │ │ │ + if (fid && fid != hfid) { │ │ │ │ + this.events.triggerEvent("hoverfeature", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.hoverFeature = feature │ │ │ │ } │ │ │ │ - return attributes │ │ │ │ }, │ │ │ │ - parseProperty: function(xmlNode, namespace, tagName) { │ │ │ │ - var value; │ │ │ │ - var nodeList = this.getElementsByTagNameNS(xmlNode, namespace, tagName); │ │ │ │ - try { │ │ │ │ - value = OpenLayers.Util.getXmlNodeValue(nodeList[0]) │ │ │ │ - } catch (e) { │ │ │ │ - value = null │ │ │ │ + unselect: function(feature) { │ │ │ │ + delete this.features[feature.fid || feature.id]; │ │ │ │ + this.events.triggerEvent("featureunselected", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + unselectAll: function() { │ │ │ │ + for (var fid in this.features) { │ │ │ │ + this.unselect(this.features[fid]) │ │ │ │ } │ │ │ │ - return value │ │ │ │ }, │ │ │ │ - write: function(features) { │ │ │ │ - if (!OpenLayers.Util.isArray(features)) { │ │ │ │ - features = [features] │ │ │ │ + setMap: function(map) { │ │ │ │ + for (var i in this.handlers) { │ │ │ │ + this.handlers[i].setMap(map) │ │ │ │ } │ │ │ │ - var kml = this.createElementNS(this.kmlns, "kml"); │ │ │ │ - var folder = this.createFolderXML(); │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - folder.appendChild(this.createPlacemarkXML(features[i])) │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + pixelToBounds: function(pixel) { │ │ │ │ + var llPx = pixel.add(-this.clickTolerance / 2, this.clickTolerance / 2); │ │ │ │ + var urPx = pixel.add(this.clickTolerance / 2, -this.clickTolerance / 2); │ │ │ │ + var ll = this.map.getLonLatFromPixel(llPx); │ │ │ │ + var ur = this.map.getLonLatFromPixel(urPx); │ │ │ │ + return new OpenLayers.Bounds(ll.lon, ll.lat, ur.lon, ur.lat) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.GetFeature" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Measure = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + callbacks: null, │ │ │ │ + displaySystem: "metric", │ │ │ │ + geodesic: false, │ │ │ │ + displaySystemUnits: { │ │ │ │ + geographic: ["dd"], │ │ │ │ + english: ["mi", "ft", "in"], │ │ │ │ + metric: ["km", "m"] │ │ │ │ + }, │ │ │ │ + partialDelay: 300, │ │ │ │ + delayedTrigger: null, │ │ │ │ + persist: false, │ │ │ │ + immediate: false, │ │ │ │ + initialize: function(handler, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + var callbacks = { │ │ │ │ + done: this.measureComplete, │ │ │ │ + point: this.measurePartial │ │ │ │ + }; │ │ │ │ + if (this.immediate) { │ │ │ │ + callbacks.modify = this.measureImmediate │ │ │ │ } │ │ │ │ - kml.appendChild(folder); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [kml]) │ │ │ │ + this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ + this.handlerOptions = OpenLayers.Util.extend({ │ │ │ │ + persist: this.persist │ │ │ │ + }, this.handlerOptions); │ │ │ │ + this.handler = new handler(this, this.callbacks, this.handlerOptions) │ │ │ │ }, │ │ │ │ - createFolderXML: function() { │ │ │ │ - var folder = this.createElementNS(this.kmlns, "Folder"); │ │ │ │ - if (this.foldersName) { │ │ │ │ - var folderName = this.createElementNS(this.kmlns, "name"); │ │ │ │ - var folderNameText = this.createTextNode(this.foldersName); │ │ │ │ - folderName.appendChild(folderNameText); │ │ │ │ - folder.appendChild(folderName) │ │ │ │ + deactivate: function() { │ │ │ │ + this.cancelDelay(); │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + cancel: function() { │ │ │ │ + this.cancelDelay(); │ │ │ │ + this.handler.cancel() │ │ │ │ + }, │ │ │ │ + setImmediate: function(immediate) { │ │ │ │ + this.immediate = immediate; │ │ │ │ + if (this.immediate) { │ │ │ │ + this.callbacks.modify = this.measureImmediate │ │ │ │ + } else { │ │ │ │ + delete this.callbacks.modify │ │ │ │ } │ │ │ │ - if (this.foldersDesc) { │ │ │ │ - var folderDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ - var folderDescText = this.createTextNode(this.foldersDesc); │ │ │ │ - folderDesc.appendChild(folderDescText); │ │ │ │ - folder.appendChild(folderDesc) │ │ │ │ + }, │ │ │ │ + updateHandler: function(handler, options) { │ │ │ │ + var active = this.active; │ │ │ │ + if (active) { │ │ │ │ + this.deactivate() │ │ │ │ + } │ │ │ │ + this.handler = new handler(this, this.callbacks, options); │ │ │ │ + if (active) { │ │ │ │ + this.activate() │ │ │ │ } │ │ │ │ - return folder │ │ │ │ }, │ │ │ │ - createPlacemarkXML: function(feature) { │ │ │ │ - var placemarkName = this.createElementNS(this.kmlns, "name"); │ │ │ │ - var label = feature.style && feature.style.label ? feature.style.label : feature.id; │ │ │ │ - var name = feature.attributes.name || label; │ │ │ │ - placemarkName.appendChild(this.createTextNode(name)); │ │ │ │ - var placemarkDesc = this.createElementNS(this.kmlns, "description"); │ │ │ │ - var desc = feature.attributes.description || this.placemarksDesc; │ │ │ │ - placemarkDesc.appendChild(this.createTextNode(desc)); │ │ │ │ - var placemarkNode = this.createElementNS(this.kmlns, "Placemark"); │ │ │ │ - if (feature.fid != null) { │ │ │ │ - placemarkNode.setAttribute("id", feature.fid) │ │ │ │ + measureComplete: function(geometry) { │ │ │ │ + this.cancelDelay(); │ │ │ │ + this.measure(geometry, "measure") │ │ │ │ + }, │ │ │ │ + measurePartial: function(point, geometry) { │ │ │ │ + this.cancelDelay(); │ │ │ │ + geometry = geometry.clone(); │ │ │ │ + if (this.handler.freehandMode(this.handler.evt)) { │ │ │ │ + this.measure(geometry, "measurepartial") │ │ │ │ + } else { │ │ │ │ + this.delayedTrigger = window.setTimeout(OpenLayers.Function.bind(function() { │ │ │ │ + this.delayedTrigger = null; │ │ │ │ + this.measure(geometry, "measurepartial") │ │ │ │ + }, this), this.partialDelay) │ │ │ │ } │ │ │ │ - placemarkNode.appendChild(placemarkName); │ │ │ │ - placemarkNode.appendChild(placemarkDesc); │ │ │ │ - var geometryNode = this.buildGeometryNode(feature.geometry); │ │ │ │ - placemarkNode.appendChild(geometryNode); │ │ │ │ - if (feature.attributes) { │ │ │ │ - var edNode = this.buildExtendedData(feature.attributes); │ │ │ │ - if (edNode) { │ │ │ │ - placemarkNode.appendChild(edNode) │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + measureImmediate: function(point, feature, drawing) { │ │ │ │ + if (drawing && !this.handler.freehandMode(this.handler.evt)) { │ │ │ │ + this.cancelDelay(); │ │ │ │ + this.measure(feature.geometry, "measurepartial") │ │ │ │ } │ │ │ │ - return placemarkNode │ │ │ │ }, │ │ │ │ - buildGeometryNode: function(geometry) { │ │ │ │ - var className = geometry.CLASS_NAME; │ │ │ │ - var type = className.substring(className.lastIndexOf(".") + 1); │ │ │ │ - var builder = this.buildGeometry[type.toLowerCase()]; │ │ │ │ - var node = null; │ │ │ │ - if (builder) { │ │ │ │ - node = builder.apply(this, [geometry]) │ │ │ │ + cancelDelay: function() { │ │ │ │ + if (this.delayedTrigger !== null) { │ │ │ │ + window.clearTimeout(this.delayedTrigger); │ │ │ │ + this.delayedTrigger = null │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - buildGeometry: { │ │ │ │ - point: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "Point"); │ │ │ │ - kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - return kml │ │ │ │ - }, │ │ │ │ - multipoint: function(geometry) { │ │ │ │ - return this.buildGeometry.collection.apply(this, [geometry]) │ │ │ │ - }, │ │ │ │ - linestring: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "LineString"); │ │ │ │ - kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - return kml │ │ │ │ - }, │ │ │ │ - multilinestring: function(geometry) { │ │ │ │ - return this.buildGeometry.collection.apply(this, [geometry]) │ │ │ │ - }, │ │ │ │ - linearring: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "LinearRing"); │ │ │ │ - kml.appendChild(this.buildCoordinatesNode(geometry)); │ │ │ │ - return kml │ │ │ │ - }, │ │ │ │ - polygon: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "Polygon"); │ │ │ │ - var rings = geometry.components; │ │ │ │ - var ringMember, ringGeom, type; │ │ │ │ - for (var i = 0, len = rings.length; i < len; ++i) { │ │ │ │ - type = i == 0 ? "outerBoundaryIs" : "innerBoundaryIs"; │ │ │ │ - ringMember = this.createElementNS(this.kmlns, type); │ │ │ │ - ringGeom = this.buildGeometry.linearring.apply(this, [rings[i]]); │ │ │ │ - ringMember.appendChild(ringGeom); │ │ │ │ - kml.appendChild(ringMember) │ │ │ │ - } │ │ │ │ - return kml │ │ │ │ - }, │ │ │ │ - multipolygon: function(geometry) { │ │ │ │ - return this.buildGeometry.collection.apply(this, [geometry]) │ │ │ │ - }, │ │ │ │ - collection: function(geometry) { │ │ │ │ - var kml = this.createElementNS(this.kmlns, "MultiGeometry"); │ │ │ │ - var child; │ │ │ │ - for (var i = 0, len = geometry.components.length; i < len; ++i) { │ │ │ │ - child = this.buildGeometryNode.apply(this, [geometry.components[i]]); │ │ │ │ - if (child) { │ │ │ │ - kml.appendChild(child) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return kml │ │ │ │ + measure: function(geometry, eventType) { │ │ │ │ + var stat, order; │ │ │ │ + if (geometry.CLASS_NAME.indexOf("LineString") > -1) { │ │ │ │ + stat = this.getBestLength(geometry); │ │ │ │ + order = 1 │ │ │ │ + } else { │ │ │ │ + stat = this.getBestArea(geometry); │ │ │ │ + order = 2 │ │ │ │ } │ │ │ │ + this.events.triggerEvent(eventType, { │ │ │ │ + measure: stat[0], │ │ │ │ + units: stat[1], │ │ │ │ + order: order, │ │ │ │ + geometry: geometry │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - buildCoordinatesNode: function(geometry) { │ │ │ │ - var coordinatesNode = this.createElementNS(this.kmlns, "coordinates"); │ │ │ │ - var path; │ │ │ │ - var points = geometry.components; │ │ │ │ - if (points) { │ │ │ │ - var point; │ │ │ │ - var numPoints = points.length; │ │ │ │ - var parts = new Array(numPoints); │ │ │ │ - for (var i = 0; i < numPoints; ++i) { │ │ │ │ - point = points[i]; │ │ │ │ - parts[i] = this.buildCoordinates(point) │ │ │ │ + getBestArea: function(geometry) { │ │ │ │ + var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ + var unit, area; │ │ │ │ + for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ + unit = units[i]; │ │ │ │ + area = this.getArea(geometry, unit); │ │ │ │ + if (area > 1) { │ │ │ │ + break │ │ │ │ } │ │ │ │ - path = parts.join(" ") │ │ │ │ - } else { │ │ │ │ - path = this.buildCoordinates(geometry) │ │ │ │ } │ │ │ │ - var txtNode = this.createTextNode(path); │ │ │ │ - coordinatesNode.appendChild(txtNode); │ │ │ │ - return coordinatesNode │ │ │ │ + return [area, unit] │ │ │ │ }, │ │ │ │ - buildCoordinates: function(point) { │ │ │ │ - if (this.internalProjection && this.externalProjection) { │ │ │ │ - point = point.clone(); │ │ │ │ - point.transform(this.internalProjection, this.externalProjection) │ │ │ │ + getArea: function(geometry, units) { │ │ │ │ + var area, geomUnits; │ │ │ │ + if (this.geodesic) { │ │ │ │ + area = geometry.getGeodesicArea(this.map.getProjectionObject()); │ │ │ │ + geomUnits = "m" │ │ │ │ + } else { │ │ │ │ + area = geometry.getArea(); │ │ │ │ + geomUnits = this.map.getUnits() │ │ │ │ } │ │ │ │ - return point.x + "," + point.y │ │ │ │ + var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ + if (inPerDisplayUnit) { │ │ │ │ + var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ + area *= Math.pow(inPerMapUnit / inPerDisplayUnit, 2) │ │ │ │ + } │ │ │ │ + return area │ │ │ │ }, │ │ │ │ - buildExtendedData: function(attributes) { │ │ │ │ - var extendedData = this.createElementNS(this.kmlns, "ExtendedData"); │ │ │ │ - for (var attributeName in attributes) { │ │ │ │ - if (attributes[attributeName] && attributeName != "name" && attributeName != "description" && attributeName != "styleUrl") { │ │ │ │ - var data = this.createElementNS(this.kmlns, "Data"); │ │ │ │ - data.setAttribute("name", attributeName); │ │ │ │ - var value = this.createElementNS(this.kmlns, "value"); │ │ │ │ - if (typeof attributes[attributeName] == "object") { │ │ │ │ - if (attributes[attributeName].value) { │ │ │ │ - value.appendChild(this.createTextNode(attributes[attributeName].value)) │ │ │ │ - } │ │ │ │ - if (attributes[attributeName].displayName) { │ │ │ │ - var displayName = this.createElementNS(this.kmlns, "displayName"); │ │ │ │ - displayName.appendChild(this.getXMLDoc().createCDATASection(attributes[attributeName].displayName)); │ │ │ │ - data.appendChild(displayName) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - value.appendChild(this.createTextNode(attributes[attributeName])) │ │ │ │ - } │ │ │ │ - data.appendChild(value); │ │ │ │ - extendedData.appendChild(data) │ │ │ │ + getBestLength: function(geometry) { │ │ │ │ + var units = this.displaySystemUnits[this.displaySystem]; │ │ │ │ + var unit, length; │ │ │ │ + for (var i = 0, len = units.length; i < len; ++i) { │ │ │ │ + unit = units[i]; │ │ │ │ + length = this.getLength(geometry, unit); │ │ │ │ + if (length > 1) { │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - if (this.isSimpleContent(extendedData)) { │ │ │ │ - return null │ │ │ │ + return [length, unit] │ │ │ │ + }, │ │ │ │ + getLength: function(geometry, units) { │ │ │ │ + var length, geomUnits; │ │ │ │ + if (this.geodesic) { │ │ │ │ + length = geometry.getGeodesicLength(this.map.getProjectionObject()); │ │ │ │ + geomUnits = "m" │ │ │ │ } else { │ │ │ │ - return extendedData │ │ │ │ + length = geometry.getLength(); │ │ │ │ + geomUnits = this.map.getUnits() │ │ │ │ + } │ │ │ │ + var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT[units]; │ │ │ │ + if (inPerDisplayUnit) { │ │ │ │ + var inPerMapUnit = OpenLayers.INCHES_PER_UNIT[geomUnits]; │ │ │ │ + length *= inPerMapUnit / inPerDisplayUnit │ │ │ │ } │ │ │ │ + return length │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.KML" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSDescribeLayer = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.1.1", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.XLS = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.1.0", │ │ │ │ - stringifyOutput: true, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.XLS" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.SOSCapabilities = OpenLayers.Class(OpenLayers.Format.XML.VersionedOGC, { │ │ │ │ - defaultVersion: "1.0.0", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSCapabilities" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Measure" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WFST.v1_0_0 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, OpenLayers.Format.WFST.v1, { │ │ │ │ - version: "1.0.0", │ │ │ │ - srsNameInQuery: false, │ │ │ │ - schemaLocations: { │ │ │ │ - wfs: "http://schemas.opengis.net/wfs/1.0.0/WFS-transaction.xsd" │ │ │ │ - }, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.Filter.v1_0_0.prototype.initialize.apply(this, [options]); │ │ │ │ - OpenLayers.Format.WFST.v1.prototype.initialize.apply(this, [options]) │ │ │ │ - }, │ │ │ │ - readNode: function(node, obj, first) { │ │ │ │ - return OpenLayers.Format.GML.v2.prototype.readNode.apply(this, arguments) │ │ │ │ +OpenLayers.Control.ZoomOut = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.zoomOut() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ - WFS_TransactionResponse: function(node, obj) { │ │ │ │ - obj.insertIds = []; │ │ │ │ - obj.success = false; │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - InsertResult: function(node, container) { │ │ │ │ - var obj = { │ │ │ │ - fids: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - container.insertIds = container.insertIds.concat(obj.fids) │ │ │ │ - }, │ │ │ │ - TransactionResult: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Status: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomOut" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.DrawFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + layer: null, │ │ │ │ + callbacks: null, │ │ │ │ + multi: false, │ │ │ │ + featureAdded: function() {}, │ │ │ │ + initialize: function(layer, handler, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.callbacks = OpenLayers.Util.extend({ │ │ │ │ + done: this.drawFeature, │ │ │ │ + modify: function(vertex, feature) { │ │ │ │ + this.layer.events.triggerEvent("sketchmodified", { │ │ │ │ + vertex: vertex, │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - SUCCESS: function(node, obj) { │ │ │ │ - obj.success = true │ │ │ │ + create: function(vertex, feature) { │ │ │ │ + this.layer.events.triggerEvent("sketchstarted", { │ │ │ │ + vertex: vertex, │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WFST.v1.prototype.readers["wfs"]), │ │ │ │ - gml: OpenLayers.Format.GML.v2.prototype.readers["gml"], │ │ │ │ - feature: OpenLayers.Format.GML.v2.prototype.readers["feature"], │ │ │ │ - ogc: OpenLayers.Format.Filter.v1_0_0.prototype.readers["ogc"] │ │ │ │ + }, this.callbacks); │ │ │ │ + this.layer = layer; │ │ │ │ + this.handlerOptions = this.handlerOptions || {}; │ │ │ │ + this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(this.handlerOptions.layerOptions, { │ │ │ │ + renderers: layer.renderers, │ │ │ │ + rendererOptions: layer.rendererOptions │ │ │ │ + }); │ │ │ │ + if (!("multi" in this.handlerOptions)) { │ │ │ │ + this.handlerOptions.multi = this.multi │ │ │ │ + } │ │ │ │ + var sketchStyle = this.layer.styleMap && this.layer.styleMap.styles.temporary; │ │ │ │ + if (sketchStyle) { │ │ │ │ + this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(this.handlerOptions.layerOptions, { │ │ │ │ + styleMap: new OpenLayers.StyleMap({ │ │ │ │ + default: sketchStyle │ │ │ │ + }) │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + this.handler = new handler(this, this.callbacks, this.handlerOptions) │ │ │ │ }, │ │ │ │ - writers: { │ │ │ │ - wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ - Query: function(options) { │ │ │ │ - options = OpenLayers.Util.extend({ │ │ │ │ - featureNS: this.featureNS, │ │ │ │ - featurePrefix: this.featurePrefix, │ │ │ │ - featureType: this.featureType, │ │ │ │ - srsName: this.srsName, │ │ │ │ - srsNameInQuery: this.srsNameInQuery │ │ │ │ - }, options); │ │ │ │ - var prefix = options.featurePrefix; │ │ │ │ - var node = this.createElementNSPlus("wfs:Query", { │ │ │ │ - attributes: { │ │ │ │ - typeName: (prefix ? prefix + ":" : "") + options.featureType │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.srsNameInQuery && options.srsName) { │ │ │ │ - node.setAttribute("srsName", options.srsName) │ │ │ │ - } │ │ │ │ - if (options.featureNS) { │ │ │ │ - node.setAttribute("xmlns:" + prefix, options.featureNS) │ │ │ │ - } │ │ │ │ - if (options.propertyNames) { │ │ │ │ - for (var i = 0, len = options.propertyNames.length; i < len; i++) { │ │ │ │ - this.writeNode("ogc:PropertyName", { │ │ │ │ - property: options.propertyNames[i] │ │ │ │ - }, node) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (options.filter) { │ │ │ │ - this.setFilterProperty(options.filter); │ │ │ │ - this.writeNode("ogc:Filter", options.filter, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WFST.v1.prototype.writers["wfs"]), │ │ │ │ - gml: OpenLayers.Format.GML.v2.prototype.writers["gml"], │ │ │ │ - feature: OpenLayers.Format.GML.v2.prototype.writers["feature"], │ │ │ │ - ogc: OpenLayers.Format.Filter.v1_0_0.prototype.writers["ogc"] │ │ │ │ + drawFeature: function(geometry) { │ │ │ │ + var feature = new OpenLayers.Feature.Vector(geometry); │ │ │ │ + var proceed = this.layer.events.triggerEvent("sketchcomplete", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (proceed !== false) { │ │ │ │ + feature.state = OpenLayers.State.INSERT; │ │ │ │ + this.layer.addFeatures([feature]); │ │ │ │ + this.featureAdded(feature); │ │ │ │ + this.events.triggerEvent("featureadded", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFST.v1_0_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.ArcXML.Features = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - read: function(data) { │ │ │ │ - var axl = new OpenLayers.Format.ArcXML; │ │ │ │ - var parsed = axl.read(data); │ │ │ │ - return parsed.features.feature │ │ │ │ - } │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSDescribeLayer.v1_1_1 = OpenLayers.Class(OpenLayers.Format.WMSDescribeLayer, { │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.WMSDescribeLayer.prototype.initialize.apply(this, [options]) │ │ │ │ + insertXY: function(x, y) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertXY(x, y) │ │ │ │ + } │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + insertDeltaXY: function(dx, dy) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertDeltaXY(dx, dy) │ │ │ │ } │ │ │ │ - var root = data.documentElement; │ │ │ │ - var children = root.childNodes; │ │ │ │ - var describelayer = { │ │ │ │ - layerDescriptions: [] │ │ │ │ - }; │ │ │ │ - var childNode, nodeName; │ │ │ │ - for (var i = 0; i < children.length; ++i) { │ │ │ │ - childNode = children[i]; │ │ │ │ - nodeName = childNode.nodeName; │ │ │ │ - if (nodeName == "LayerDescription") { │ │ │ │ - var layerName = childNode.getAttribute("name"); │ │ │ │ - var owsType = ""; │ │ │ │ - var owsURL = ""; │ │ │ │ - var typeName = ""; │ │ │ │ - if (childNode.getAttribute("owsType")) { │ │ │ │ - owsType = childNode.getAttribute("owsType"); │ │ │ │ - owsURL = childNode.getAttribute("owsURL") │ │ │ │ - } else { │ │ │ │ - if (childNode.getAttribute("wfs") != "") { │ │ │ │ - owsType = "WFS"; │ │ │ │ - owsURL = childNode.getAttribute("wfs") │ │ │ │ - } else if (childNode.getAttribute("wcs") != "") { │ │ │ │ - owsType = "WCS"; │ │ │ │ - owsURL = childNode.getAttribute("wcs") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var query = childNode.getElementsByTagName("Query"); │ │ │ │ - if (query.length > 0) { │ │ │ │ - typeName = query[0].getAttribute("typeName"); │ │ │ │ - if (!typeName) { │ │ │ │ - typeName = query[0].getAttribute("typename") │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var layerDescription = { │ │ │ │ - layerName: layerName, │ │ │ │ - owsType: owsType, │ │ │ │ - owsURL: owsURL, │ │ │ │ - typeName: typeName │ │ │ │ - }; │ │ │ │ - describelayer.layerDescriptions.push(layerDescription); │ │ │ │ - describelayer.length = describelayer.layerDescriptions.length; │ │ │ │ - describelayer[describelayer.length - 1] = layerDescription │ │ │ │ - } else if (nodeName == "ServiceException") { │ │ │ │ - var parser = new OpenLayers.Format.OGCExceptionReport; │ │ │ │ - return { │ │ │ │ - error: parser.read(data) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + }, │ │ │ │ + insertDirectionLength: function(direction, length) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertDirectionLength(direction, length) │ │ │ │ } │ │ │ │ - return describelayer │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSDescribeLayer.v1_1_1" │ │ │ │ + insertDeflectionLength: function(deflection, length) { │ │ │ │ + if (this.handler && this.handler.line) { │ │ │ │ + this.handler.insertDeflectionLength(deflection, length) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + undo: function() { │ │ │ │ + return this.handler.undo && this.handler.undo() │ │ │ │ + }, │ │ │ │ + redo: function() { │ │ │ │ + return this.handler.redo && this.handler.redo() │ │ │ │ + }, │ │ │ │ + finishSketch: function() { │ │ │ │ + this.handler.finishGeometry() │ │ │ │ + }, │ │ │ │ + cancel: function() { │ │ │ │ + this.handler.cancel() │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.DrawFeature" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WMSDescribeLayer.v1_1_0 = OpenLayers.Format.WMSDescribeLayer.v1_1_1; │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - wms: "http://www.opengis.net/wms", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ +OpenLayers.Control.SLDSelect = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + clearOnDeactivate: false, │ │ │ │ + layers: null, │ │ │ │ + callbacks: null, │ │ │ │ + selectionSymbolizer: { │ │ │ │ + Polygon: { │ │ │ │ + fillColor: "#FF0000", │ │ │ │ + stroke: false │ │ │ │ + }, │ │ │ │ + Line: { │ │ │ │ + strokeColor: "#FF0000", │ │ │ │ + strokeWidth: 2 │ │ │ │ + }, │ │ │ │ + Point: { │ │ │ │ + graphicName: "square", │ │ │ │ + fillColor: "#FF0000", │ │ │ │ + pointRadius: 5 │ │ │ │ + } │ │ │ │ }, │ │ │ │ - defaultPrefix: "wms", │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + layerOptions: null, │ │ │ │ + sketchStyle: null, │ │ │ │ + wfsCache: {}, │ │ │ │ + layerCache: {}, │ │ │ │ + initialize: function(handler, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.callbacks = OpenLayers.Util.extend({ │ │ │ │ + done: this.select, │ │ │ │ + click: this.select │ │ │ │ + }, this.callbacks); │ │ │ │ + this.handlerOptions = this.handlerOptions || {}; │ │ │ │ + this.layerOptions = OpenLayers.Util.applyDefaults(this.layerOptions, { │ │ │ │ + displayInLayerSwitcher: false, │ │ │ │ + tileOptions: { │ │ │ │ + maxGetUrlLength: 2048 │ │ │ │ + } │ │ │ │ + }); │ │ │ │ + if (this.sketchStyle) { │ │ │ │ + this.handlerOptions.layerOptions = OpenLayers.Util.applyDefaults(this.handlerOptions.layerOptions, { │ │ │ │ + styleMap: new OpenLayers.StyleMap({ │ │ │ │ + default: this.sketchStyle │ │ │ │ + }) │ │ │ │ + }) │ │ │ │ } │ │ │ │ - var raw = data; │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + this.handler = new handler(this, this.callbacks, this.handlerOptions) │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + for (var key in this.layerCache) { │ │ │ │ + delete this.layerCache[key] │ │ │ │ } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - if (capabilities.service === undefined) { │ │ │ │ - var parser = new OpenLayers.Format.OGCExceptionReport; │ │ │ │ - capabilities.error = parser.read(raw) │ │ │ │ + for (var key in this.wfsCache) { │ │ │ │ + delete this.wfsCache[key] │ │ │ │ } │ │ │ │ - return capabilities │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - wms: { │ │ │ │ - Service: function(node, obj) { │ │ │ │ - obj.service = {}; │ │ │ │ - this.readChildNodes(node, obj.service) │ │ │ │ - }, │ │ │ │ - Name: function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Title: function(node, obj) { │ │ │ │ - obj.title = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Abstract: function(node, obj) { │ │ │ │ - obj["abstract"] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - BoundingBox: function(node, obj) { │ │ │ │ - var bbox = {}; │ │ │ │ - bbox.bbox = [parseFloat(node.getAttribute("minx")), parseFloat(node.getAttribute("miny")), parseFloat(node.getAttribute("maxx")), parseFloat(node.getAttribute("maxy"))]; │ │ │ │ - var res = { │ │ │ │ - x: parseFloat(node.getAttribute("resx")), │ │ │ │ - y: parseFloat(node.getAttribute("resy")) │ │ │ │ - }; │ │ │ │ - if (!(isNaN(res.x) && isNaN(res.y))) { │ │ │ │ - bbox.res = res │ │ │ │ - } │ │ │ │ - return bbox │ │ │ │ - }, │ │ │ │ - OnlineResource: function(node, obj) { │ │ │ │ - obj.href = this.getAttributeNS(node, this.namespaces.xlink, "href") │ │ │ │ - }, │ │ │ │ - ContactInformation: function(node, obj) { │ │ │ │ - obj.contactInformation = {}; │ │ │ │ - this.readChildNodes(node, obj.contactInformation) │ │ │ │ - }, │ │ │ │ - ContactPersonPrimary: function(node, obj) { │ │ │ │ - obj.personPrimary = {}; │ │ │ │ - this.readChildNodes(node, obj.personPrimary) │ │ │ │ - }, │ │ │ │ - ContactPerson: function(node, obj) { │ │ │ │ - obj.person = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContactOrganization: function(node, obj) { │ │ │ │ - obj.organization = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContactPosition: function(node, obj) { │ │ │ │ - obj.position = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContactAddress: function(node, obj) { │ │ │ │ - obj.contactAddress = {}; │ │ │ │ - this.readChildNodes(node, obj.contactAddress) │ │ │ │ - }, │ │ │ │ - AddressType: function(node, obj) { │ │ │ │ - obj.type = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Address: function(node, obj) { │ │ │ │ - obj.address = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - City: function(node, obj) { │ │ │ │ - obj.city = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - StateOrProvince: function(node, obj) { │ │ │ │ - obj.stateOrProvince = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - PostCode: function(node, obj) { │ │ │ │ - obj.postcode = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Country: function(node, obj) { │ │ │ │ - obj.country = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContactVoiceTelephone: function(node, obj) { │ │ │ │ - obj.phone = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContactFacsimileTelephone: function(node, obj) { │ │ │ │ - obj.fax = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContactElectronicMailAddress: function(node, obj) { │ │ │ │ - obj.email = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Fees: function(node, obj) { │ │ │ │ - var fees = this.getChildValue(node); │ │ │ │ - if (fees && fees.toLowerCase() != "none") { │ │ │ │ - obj.fees = fees │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - AccessConstraints: function(node, obj) { │ │ │ │ - var constraints = this.getChildValue(node); │ │ │ │ - if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ - obj.accessConstraints = constraints │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Capability: function(node, obj) { │ │ │ │ - obj.capability = { │ │ │ │ - nestedLayers: [], │ │ │ │ - layers: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.capability) │ │ │ │ - }, │ │ │ │ - Request: function(node, obj) { │ │ │ │ - obj.request = {}; │ │ │ │ - this.readChildNodes(node, obj.request) │ │ │ │ - }, │ │ │ │ - GetCapabilities: function(node, obj) { │ │ │ │ - obj.getcapabilities = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getcapabilities) │ │ │ │ - }, │ │ │ │ - Format: function(node, obj) { │ │ │ │ - if (OpenLayers.Util.isArray(obj.formats)) { │ │ │ │ - obj.formats.push(this.getChildValue(node)) │ │ │ │ - } else { │ │ │ │ - obj.format = this.getChildValue(node) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - DCPType: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - HTTP: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Get: function(node, obj) { │ │ │ │ - obj.get = {}; │ │ │ │ - this.readChildNodes(node, obj.get); │ │ │ │ - if (!obj.href) { │ │ │ │ - obj.href = obj.get.href │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Post: function(node, obj) { │ │ │ │ - obj.post = {}; │ │ │ │ - this.readChildNodes(node, obj.post); │ │ │ │ - if (!obj.href) { │ │ │ │ - obj.href = obj.get.href │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - GetMap: function(node, obj) { │ │ │ │ - obj.getmap = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getmap) │ │ │ │ - }, │ │ │ │ - GetFeatureInfo: function(node, obj) { │ │ │ │ - obj.getfeatureinfo = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getfeatureinfo) │ │ │ │ - }, │ │ │ │ - Exception: function(node, obj) { │ │ │ │ - obj.exception = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.exception) │ │ │ │ - }, │ │ │ │ - Layer: function(node, obj) { │ │ │ │ - var parentLayer, capability; │ │ │ │ - if (obj.capability) { │ │ │ │ - capability = obj.capability; │ │ │ │ - parentLayer = obj │ │ │ │ - } else { │ │ │ │ - capability = obj │ │ │ │ - } │ │ │ │ - var attrNode = node.getAttributeNode("queryable"); │ │ │ │ - var queryable = attrNode && attrNode.specified ? node.getAttribute("queryable") : null; │ │ │ │ - attrNode = node.getAttributeNode("cascaded"); │ │ │ │ - var cascaded = attrNode && attrNode.specified ? node.getAttribute("cascaded") : null; │ │ │ │ - attrNode = node.getAttributeNode("opaque"); │ │ │ │ - var opaque = attrNode && attrNode.specified ? node.getAttribute("opaque") : null; │ │ │ │ - var noSubsets = node.getAttribute("noSubsets"); │ │ │ │ - var fixedWidth = node.getAttribute("fixedWidth"); │ │ │ │ - var fixedHeight = node.getAttribute("fixedHeight"); │ │ │ │ - var parent = parentLayer || {}, │ │ │ │ - extend = OpenLayers.Util.extend; │ │ │ │ - var layer = { │ │ │ │ - nestedLayers: [], │ │ │ │ - styles: parentLayer ? [].concat(parentLayer.styles) : [], │ │ │ │ - srs: parentLayer ? extend({}, parent.srs) : {}, │ │ │ │ - metadataURLs: [], │ │ │ │ - bbox: parentLayer ? extend({}, parent.bbox) : {}, │ │ │ │ - llbbox: parent.llbbox, │ │ │ │ - dimensions: parentLayer ? extend({}, parent.dimensions) : {}, │ │ │ │ - authorityURLs: parentLayer ? extend({}, parent.authorityURLs) : {}, │ │ │ │ - identifiers: {}, │ │ │ │ - keywords: [], │ │ │ │ - queryable: queryable && queryable !== "" ? queryable === "1" || queryable === "true" : parent.queryable || false, │ │ │ │ - cascaded: cascaded !== null ? parseInt(cascaded) : parent.cascaded || 0, │ │ │ │ - opaque: opaque ? opaque === "1" || opaque === "true" : parent.opaque || false, │ │ │ │ - noSubsets: noSubsets !== null ? noSubsets === "1" || noSubsets === "true" : parent.noSubsets || false, │ │ │ │ - fixedWidth: fixedWidth != null ? parseInt(fixedWidth) : parent.fixedWidth || 0, │ │ │ │ - fixedHeight: fixedHeight != null ? parseInt(fixedHeight) : parent.fixedHeight || 0, │ │ │ │ - minScale: parent.minScale, │ │ │ │ - maxScale: parent.maxScale, │ │ │ │ - attribution: parent.attribution │ │ │ │ - }; │ │ │ │ - obj.nestedLayers.push(layer); │ │ │ │ - layer.capability = capability; │ │ │ │ - this.readChildNodes(node, layer); │ │ │ │ - delete layer.capability; │ │ │ │ - if (layer.name) { │ │ │ │ - var parts = layer.name.split(":"), │ │ │ │ - request = capability.request, │ │ │ │ - gfi = request.getfeatureinfo; │ │ │ │ - if (parts.length > 0) { │ │ │ │ - layer.prefix = parts[0] │ │ │ │ - } │ │ │ │ - capability.layers.push(layer); │ │ │ │ - if (layer.formats === undefined) { │ │ │ │ - layer.formats = request.getmap.formats │ │ │ │ - } │ │ │ │ - if (layer.infoFormats === undefined && gfi) { │ │ │ │ - layer.infoFormats = gfi.formats │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Attribution: function(node, obj) { │ │ │ │ - obj.attribution = {}; │ │ │ │ - this.readChildNodes(node, obj.attribution) │ │ │ │ - }, │ │ │ │ - LogoURL: function(node, obj) { │ │ │ │ - obj.logo = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height") │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.logo) │ │ │ │ - }, │ │ │ │ - Style: function(node, obj) { │ │ │ │ - var style = {}; │ │ │ │ - obj.styles.push(style); │ │ │ │ - this.readChildNodes(node, style) │ │ │ │ - }, │ │ │ │ - LegendURL: function(node, obj) { │ │ │ │ - var legend = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height") │ │ │ │ - }; │ │ │ │ - obj.legend = legend; │ │ │ │ - this.readChildNodes(node, legend) │ │ │ │ - }, │ │ │ │ - MetadataURL: function(node, obj) { │ │ │ │ - var metadataURL = { │ │ │ │ - type: node.getAttribute("type") │ │ │ │ - }; │ │ │ │ - obj.metadataURLs.push(metadataURL); │ │ │ │ - this.readChildNodes(node, metadataURL) │ │ │ │ - }, │ │ │ │ - DataURL: function(node, obj) { │ │ │ │ - obj.dataURL = {}; │ │ │ │ - this.readChildNodes(node, obj.dataURL) │ │ │ │ - }, │ │ │ │ - FeatureListURL: function(node, obj) { │ │ │ │ - obj.featureListURL = {}; │ │ │ │ - this.readChildNodes(node, obj.featureListURL) │ │ │ │ - }, │ │ │ │ - AuthorityURL: function(node, obj) { │ │ │ │ - var name = node.getAttribute("name"); │ │ │ │ - var authority = {}; │ │ │ │ - this.readChildNodes(node, authority); │ │ │ │ - obj.authorityURLs[name] = authority.href │ │ │ │ - }, │ │ │ │ - Identifier: function(node, obj) { │ │ │ │ - var authority = node.getAttribute("authority"); │ │ │ │ - obj.identifiers[authority] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - KeywordList: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - SRS: function(node, obj) { │ │ │ │ - obj.srs[this.getChildValue(node)] = true │ │ │ │ + coupleLayerVisiblity: function(evt) { │ │ │ │ + this.setVisibility(evt.object.getVisibility()) │ │ │ │ + }, │ │ │ │ + createSelectionLayer: function(source) { │ │ │ │ + var selectionLayer; │ │ │ │ + if (!this.layerCache[source.id]) { │ │ │ │ + selectionLayer = new OpenLayers.Layer.WMS(source.name, source.url, source.params, OpenLayers.Util.applyDefaults(this.layerOptions, source.getOptions())); │ │ │ │ + this.layerCache[source.id] = selectionLayer; │ │ │ │ + if (this.layerOptions.displayInLayerSwitcher === false) { │ │ │ │ + source.events.on({ │ │ │ │ + visibilitychanged: this.coupleLayerVisiblity, │ │ │ │ + scope: selectionLayer │ │ │ │ + }) │ │ │ │ } │ │ │ │ + this.map.addLayer(selectionLayer) │ │ │ │ + } else { │ │ │ │ + selectionLayer = this.layerCache[source.id] │ │ │ │ } │ │ │ │ + return selectionLayer │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ - readers: { │ │ │ │ - wms: OpenLayers.Util.applyDefaults({ │ │ │ │ - WMT_MS_Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Keyword: function(node, obj) { │ │ │ │ - if (obj.keywords) { │ │ │ │ - obj.keywords.push(this.getChildValue(node)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - DescribeLayer: function(node, obj) { │ │ │ │ - obj.describelayer = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.describelayer) │ │ │ │ - }, │ │ │ │ - GetLegendGraphic: function(node, obj) { │ │ │ │ - obj.getlegendgraphic = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getlegendgraphic) │ │ │ │ - }, │ │ │ │ - GetStyles: function(node, obj) { │ │ │ │ - obj.getstyles = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.getstyles) │ │ │ │ - }, │ │ │ │ - PutStyles: function(node, obj) { │ │ │ │ - obj.putstyles = { │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.putstyles) │ │ │ │ - }, │ │ │ │ - UserDefinedSymbolization: function(node, obj) { │ │ │ │ - var userSymbols = { │ │ │ │ - supportSLD: parseInt(node.getAttribute("SupportSLD")) == 1, │ │ │ │ - userLayer: parseInt(node.getAttribute("UserLayer")) == 1, │ │ │ │ - userStyle: parseInt(node.getAttribute("UserStyle")) == 1, │ │ │ │ - remoteWFS: parseInt(node.getAttribute("RemoteWFS")) == 1 │ │ │ │ - }; │ │ │ │ - obj.userSymbols = userSymbols │ │ │ │ - }, │ │ │ │ - LatLonBoundingBox: function(node, obj) { │ │ │ │ - obj.llbbox = [parseFloat(node.getAttribute("minx")), parseFloat(node.getAttribute("miny")), parseFloat(node.getAttribute("maxx")), parseFloat(node.getAttribute("maxy"))] │ │ │ │ - }, │ │ │ │ - BoundingBox: function(node, obj) { │ │ │ │ - var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ - bbox.srs = node.getAttribute("SRS"); │ │ │ │ - obj.bbox[bbox.srs] = bbox │ │ │ │ - }, │ │ │ │ - ScaleHint: function(node, obj) { │ │ │ │ - var min = node.getAttribute("min"); │ │ │ │ - var max = node.getAttribute("max"); │ │ │ │ - var rad2 = Math.pow(2, .5); │ │ │ │ - var ipm = OpenLayers.INCHES_PER_UNIT["m"]; │ │ │ │ - if (min != 0) { │ │ │ │ - obj.maxScale = parseFloat((min / rad2 * ipm * OpenLayers.DOTS_PER_INCH).toPrecision(13)) │ │ │ │ + createSLD: function(layer, filters, geometryAttributes) { │ │ │ │ + var sld = { │ │ │ │ + version: "1.0.0", │ │ │ │ + namedLayers: {} │ │ │ │ + }; │ │ │ │ + var layerNames = [layer.params.LAYERS].join(",").split(","); │ │ │ │ + for (var i = 0, len = layerNames.length; i < len; i++) { │ │ │ │ + var name = layerNames[i]; │ │ │ │ + sld.namedLayers[name] = { │ │ │ │ + name: name, │ │ │ │ + userStyles: [] │ │ │ │ + }; │ │ │ │ + var symbolizer = this.selectionSymbolizer; │ │ │ │ + var geometryAttribute = geometryAttributes[i]; │ │ │ │ + if (geometryAttribute.type.indexOf("Polygon") >= 0) { │ │ │ │ + symbolizer = { │ │ │ │ + Polygon: this.selectionSymbolizer["Polygon"] │ │ │ │ } │ │ │ │ - if (max != Number.POSITIVE_INFINITY) { │ │ │ │ - obj.minScale = parseFloat((max / rad2 * ipm * OpenLayers.DOTS_PER_INCH).toPrecision(13)) │ │ │ │ + } else if (geometryAttribute.type.indexOf("LineString") >= 0) { │ │ │ │ + symbolizer = { │ │ │ │ + Line: this.selectionSymbolizer["Line"] │ │ │ │ } │ │ │ │ - }, │ │ │ │ - Dimension: function(node, obj) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - var dim = { │ │ │ │ - name: name, │ │ │ │ - units: node.getAttribute("units"), │ │ │ │ - unitsymbol: node.getAttribute("unitSymbol") │ │ │ │ - }; │ │ │ │ - obj.dimensions[dim.name] = dim │ │ │ │ - }, │ │ │ │ - Extent: function(node, obj) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - if (name in obj["dimensions"]) { │ │ │ │ - var extent = obj.dimensions[name]; │ │ │ │ - extent.nearestVal = node.getAttribute("nearestValue") === "1"; │ │ │ │ - extent.multipleVal = node.getAttribute("multipleValues") === "1"; │ │ │ │ - extent.current = node.getAttribute("current") === "1"; │ │ │ │ - extent["default"] = node.getAttribute("default") || ""; │ │ │ │ - var values = this.getChildValue(node); │ │ │ │ - extent.values = values.split(",") │ │ │ │ + } else if (geometryAttribute.type.indexOf("Point") >= 0) { │ │ │ │ + symbolizer = { │ │ │ │ + Point: this.selectionSymbolizer["Point"] │ │ │ │ } │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]) │ │ │ │ + var filter = filters[i]; │ │ │ │ + sld.namedLayers[name].userStyles.push({ │ │ │ │ + name: "default", │ │ │ │ + rules: [new OpenLayers.Rule({ │ │ │ │ + symbolizer: symbolizer, │ │ │ │ + filter: filter, │ │ │ │ + maxScaleDenominator: layer.options.minScale │ │ │ │ + })] │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + return new OpenLayers.Format.SLD({ │ │ │ │ + srsName: this.map.getProjection() │ │ │ │ + }).write(sld) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_3 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1, { │ │ │ │ - readers: { │ │ │ │ - wms: OpenLayers.Util.applyDefaults({ │ │ │ │ - WMS_Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - LayerLimit: function(node, obj) { │ │ │ │ - obj.layerLimit = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - MaxWidth: function(node, obj) { │ │ │ │ - obj.maxWidth = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - MaxHeight: function(node, obj) { │ │ │ │ - obj.maxHeight = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - BoundingBox: function(node, obj) { │ │ │ │ - var bbox = OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"].BoundingBox.apply(this, [node, obj]); │ │ │ │ - bbox.srs = node.getAttribute("CRS"); │ │ │ │ - obj.bbox[bbox.srs] = bbox │ │ │ │ - }, │ │ │ │ - CRS: function(node, obj) { │ │ │ │ - this.readers.wms.SRS.apply(this, [node, obj]) │ │ │ │ - }, │ │ │ │ - EX_GeographicBoundingBox: function(node, obj) { │ │ │ │ - obj.llbbox = []; │ │ │ │ - this.readChildNodes(node, obj.llbbox) │ │ │ │ - }, │ │ │ │ - westBoundLongitude: function(node, obj) { │ │ │ │ - obj[0] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - eastBoundLongitude: function(node, obj) { │ │ │ │ - obj[2] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - southBoundLatitude: function(node, obj) { │ │ │ │ - obj[1] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - northBoundLatitude: function(node, obj) { │ │ │ │ - obj[3] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - MinScaleDenominator: function(node, obj) { │ │ │ │ - obj.maxScale = parseFloat(this.getChildValue(node)).toPrecision(16) │ │ │ │ - }, │ │ │ │ - MaxScaleDenominator: function(node, obj) { │ │ │ │ - obj.minScale = parseFloat(this.getChildValue(node)).toPrecision(16) │ │ │ │ - }, │ │ │ │ - Dimension: function(node, obj) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - var dim = { │ │ │ │ - name: name, │ │ │ │ - units: node.getAttribute("units"), │ │ │ │ - unitsymbol: node.getAttribute("unitSymbol"), │ │ │ │ - nearestVal: node.getAttribute("nearestValue") === "1", │ │ │ │ - multipleVal: node.getAttribute("multipleValues") === "1", │ │ │ │ - default: node.getAttribute("default") || "", │ │ │ │ - current: node.getAttribute("current") === "1", │ │ │ │ - values: this.getChildValue(node).split(",") │ │ │ │ - }; │ │ │ │ - obj.dimensions[dim.name] = dim │ │ │ │ - }, │ │ │ │ - Keyword: function(node, obj) { │ │ │ │ - var keyword = { │ │ │ │ - value: this.getChildValue(node), │ │ │ │ - vocabulary: node.getAttribute("vocabulary") │ │ │ │ - }; │ │ │ │ - if (obj.keywords) { │ │ │ │ - obj.keywords.push(keyword) │ │ │ │ - } │ │ │ │ + parseDescribeLayer: function(request) { │ │ │ │ + var format = new OpenLayers.Format.WMSDescribeLayer; │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ + } │ │ │ │ + var describeLayer = format.read(doc); │ │ │ │ + var typeNames = []; │ │ │ │ + var url = null; │ │ │ │ + for (var i = 0, len = describeLayer.length; i < len; i++) { │ │ │ │ + if (describeLayer[i].owsType == "WFS") { │ │ │ │ + typeNames.push(describeLayer[i].typeName); │ │ │ │ + url = describeLayer[i].owsURL │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1.prototype.readers["wms"]), │ │ │ │ - sld: { │ │ │ │ - UserDefinedSymbolization: function(node, obj) { │ │ │ │ - this.readers.wms.UserDefinedSymbolization.apply(this, [node, obj]); │ │ │ │ - obj.userSymbols.inlineFeature = parseInt(node.getAttribute("InlineFeature")) == 1; │ │ │ │ - obj.userSymbols.remoteWCS = parseInt(node.getAttribute("RemoteWCS")) == 1 │ │ │ │ + } │ │ │ │ + var options = { │ │ │ │ + url: url, │ │ │ │ + params: { │ │ │ │ + SERVICE: "WFS", │ │ │ │ + TYPENAME: typeNames.toString(), │ │ │ │ + REQUEST: "DescribeFeatureType", │ │ │ │ + VERSION: "1.0.0" │ │ │ │ }, │ │ │ │ - DescribeLayer: function(node, obj) { │ │ │ │ - this.readers.wms.DescribeLayer.apply(this, [node, obj]) │ │ │ │ + callback: function(request) { │ │ │ │ + var format = new OpenLayers.Format.WFSDescribeFeatureType; │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ + } │ │ │ │ + var describeFeatureType = format.read(doc); │ │ │ │ + this.control.wfsCache[this.layer.id] = describeFeatureType; │ │ │ │ + this.control._queue && this.control.applySelection() │ │ │ │ }, │ │ │ │ - GetLegendGraphic: function(node, obj) { │ │ │ │ - this.readers.wms.GetLegendGraphic.apply(this, [node, obj]) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + scope: this │ │ │ │ + }; │ │ │ │ + OpenLayers.Request.GET(options) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_3_0 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_3, { │ │ │ │ - version: "1.3.0", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_3_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ - version: "1.1.0", │ │ │ │ - readers: { │ │ │ │ - wms: OpenLayers.Util.applyDefaults({ │ │ │ │ - SRS: function(node, obj) { │ │ │ │ - var srs = this.getChildValue(node); │ │ │ │ - var values = srs.split(/ +/); │ │ │ │ - for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ - obj.srs[values[i]] = true │ │ │ │ + getGeometryAttributes: function(layer) { │ │ │ │ + var result = []; │ │ │ │ + var cache = this.wfsCache[layer.id]; │ │ │ │ + for (var i = 0, len = cache.featureTypes.length; i < len; i++) { │ │ │ │ + var typeName = cache.featureTypes[i]; │ │ │ │ + var properties = typeName.properties; │ │ │ │ + for (var j = 0, lenj = properties.length; j < lenj; j++) { │ │ │ │ + var property = properties[j]; │ │ │ │ + var type = property.type; │ │ │ │ + if (type.indexOf("LineString") >= 0 || type.indexOf("GeometryAssociationType") >= 0 || type.indexOf("GeometryPropertyType") >= 0 || type.indexOf("Point") >= 0 || type.indexOf("Polygon") >= 0) { │ │ │ │ + result.push(property) │ │ │ │ } │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ + } │ │ │ │ + return result │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1_1 = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_1, { │ │ │ │ - version: "1.1.1", │ │ │ │ - readers: { │ │ │ │ - wms: OpenLayers.Util.applyDefaults({ │ │ │ │ - SRS: function(node, obj) { │ │ │ │ - obj.srs[this.getChildValue(node)] = true │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + var layer = this.layers[i]; │ │ │ │ + if (layer && !this.wfsCache[layer.id]) { │ │ │ │ + var options = { │ │ │ │ + url: layer.url, │ │ │ │ + params: { │ │ │ │ + SERVICE: "WMS", │ │ │ │ + VERSION: layer.params.VERSION, │ │ │ │ + LAYERS: layer.params.LAYERS, │ │ │ │ + REQUEST: "DescribeLayer" │ │ │ │ + }, │ │ │ │ + callback: this.parseDescribeLayer, │ │ │ │ + scope: { │ │ │ │ + layer: layer, │ │ │ │ + control: this │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + OpenLayers.Request.GET(options) │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1_1.prototype.readers["wms"]) │ │ │ │ + } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC = OpenLayers.Class(OpenLayers.Format.WMSCapabilities.v1_1_1, { │ │ │ │ - version: "1.1.1", │ │ │ │ - profile: "WMSC", │ │ │ │ - readers: { │ │ │ │ - wms: OpenLayers.Util.applyDefaults({ │ │ │ │ - VendorSpecificCapabilities: function(node, obj) { │ │ │ │ - obj.vendorSpecific = { │ │ │ │ - tileSets: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, obj.vendorSpecific) │ │ │ │ - }, │ │ │ │ - TileSet: function(node, vendorSpecific) { │ │ │ │ - var tileset = { │ │ │ │ - srs: {}, │ │ │ │ - bbox: {}, │ │ │ │ - resolutions: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, tileset); │ │ │ │ - vendorSpecific.tileSets.push(tileset) │ │ │ │ - }, │ │ │ │ - Resolutions: function(node, tileset) { │ │ │ │ - var res = this.getChildValue(node).split(" "); │ │ │ │ - for (var i = 0, len = res.length; i < len; i++) { │ │ │ │ - if (res[i] != "") { │ │ │ │ - tileset.resolutions.push(parseFloat(res[i])) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + var layer = this.layers[i]; │ │ │ │ + if (layer && this.clearOnDeactivate === true) { │ │ │ │ + var layerCache = this.layerCache; │ │ │ │ + var selectionLayer = layerCache[layer.id]; │ │ │ │ + if (selectionLayer) { │ │ │ │ + layer.events.un({ │ │ │ │ + visibilitychanged: this.coupleLayerVisiblity, │ │ │ │ + scope: selectionLayer │ │ │ │ + }); │ │ │ │ + selectionLayer.destroy(); │ │ │ │ + delete layerCache[layer.id] │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - Width: function(node, tileset) { │ │ │ │ - tileset.width = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - Height: function(node, tileset) { │ │ │ │ - tileset.height = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - Layers: function(node, tileset) { │ │ │ │ - tileset.layers = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Styles: function(node, tileset) { │ │ │ │ - tileset.styles = this.getChildValue(node) │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.WMSCapabilities.v1_1_1.prototype.readers["wms"]) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMSCapabilities.v1_1_1_WMSC" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WPSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - wps: "http://www.opengis.net/wps/1.0.0", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink" │ │ │ │ - }, │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ - }, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ - }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ - } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - wps: { │ │ │ │ - Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - ProcessOfferings: function(node, obj) { │ │ │ │ - obj.processOfferings = {}; │ │ │ │ - this.readChildNodes(node, obj.processOfferings) │ │ │ │ - }, │ │ │ │ - Process: function(node, processOfferings) { │ │ │ │ - var processVersion = this.getAttributeNS(node, this.namespaces.wps, "processVersion"); │ │ │ │ - var process = { │ │ │ │ - processVersion: processVersion │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, process); │ │ │ │ - processOfferings[process.identifier] = process │ │ │ │ - }, │ │ │ │ - Languages: function(node, obj) { │ │ │ │ - obj.languages = []; │ │ │ │ - this.readChildNodes(node, obj.languages) │ │ │ │ - }, │ │ │ │ - Default: function(node, languages) { │ │ │ │ - var language = { │ │ │ │ - isDefault: true │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, language); │ │ │ │ - languages.push(language) │ │ │ │ - }, │ │ │ │ - Supported: function(node, languages) { │ │ │ │ - var language = {}; │ │ │ │ - this.readChildNodes(node, language); │ │ │ │ - languages.push(language) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WPSCapabilities.v1_0_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.CSWGetRecords.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - csw: "http://www.opengis.net/cat/csw/2.0.2", │ │ │ │ - dc: "http://purl.org/dc/elements/1.1/", │ │ │ │ - dct: "http://purl.org/dc/terms/", │ │ │ │ - gmd: "http://www.isotc211.org/2005/gmd", │ │ │ │ - geonet: "http://www.fao.org/geonetwork", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - ows: "http://www.opengis.net/ows", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - defaultPrefix: "csw", │ │ │ │ - version: "2.0.2", │ │ │ │ - schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ - requestId: null, │ │ │ │ - resultType: null, │ │ │ │ - outputFormat: null, │ │ │ │ - outputSchema: null, │ │ │ │ - startPosition: null, │ │ │ │ - maxRecords: null, │ │ │ │ - DistributedSearch: null, │ │ │ │ - ResponseHandler: null, │ │ │ │ - Query: null, │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ - }, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + setLayers: function(layers) { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layers = layers; │ │ │ │ + this.activate() │ │ │ │ + } else { │ │ │ │ + this.layers = layers │ │ │ │ } │ │ │ │ - var obj = {}; │ │ │ │ - this.readNode(data, obj); │ │ │ │ - return obj │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - csw: { │ │ │ │ - GetRecordsResponse: function(node, obj) { │ │ │ │ - obj.records = []; │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - var version = this.getAttributeNS(node, "", "version"); │ │ │ │ - if (version != "") { │ │ │ │ - obj.version = version │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - RequestId: function(node, obj) { │ │ │ │ - obj.RequestId = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - SearchStatus: function(node, obj) { │ │ │ │ - obj.SearchStatus = {}; │ │ │ │ - var timestamp = this.getAttributeNS(node, "", "timestamp"); │ │ │ │ - if (timestamp != "") { │ │ │ │ - obj.SearchStatus.timestamp = timestamp │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - SearchResults: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj); │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var SearchResults = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - if (attrs[i].name == "numberOfRecordsMatched" || attrs[i].name == "numberOfRecordsReturned" || attrs[i].name == "nextRecord") { │ │ │ │ - SearchResults[attrs[i].name] = parseInt(attrs[i].nodeValue) │ │ │ │ - } else { │ │ │ │ - SearchResults[attrs[i].name] = attrs[i].nodeValue │ │ │ │ - } │ │ │ │ - } │ │ │ │ - obj.SearchResults = SearchResults │ │ │ │ - }, │ │ │ │ - SummaryRecord: function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "SummaryRecord" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record) │ │ │ │ - }, │ │ │ │ - BriefRecord: function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "BriefRecord" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record) │ │ │ │ - }, │ │ │ │ - DCMIRecord: function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "DCMIRecord" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record) │ │ │ │ - }, │ │ │ │ - Record: function(node, obj) { │ │ │ │ - var record = { │ │ │ │ - type: "Record" │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, record); │ │ │ │ - obj.records.push(record) │ │ │ │ - }, │ │ │ │ - "*": function(node, obj) { │ │ │ │ - var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ - obj[name] = this.getChildValue(node) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - geonet: { │ │ │ │ - info: function(node, obj) { │ │ │ │ - var gninfo = {}; │ │ │ │ - this.readChildNodes(node, gninfo); │ │ │ │ - obj.gninfo = gninfo │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - dc: { │ │ │ │ - "*": function(node, obj) { │ │ │ │ - var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ - if (!OpenLayers.Util.isArray(obj[name])) { │ │ │ │ - obj[name] = [] │ │ │ │ - } │ │ │ │ - var dc_element = {}; │ │ │ │ - var attrs = node.attributes; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - dc_element[attrs[i].name] = attrs[i].nodeValue │ │ │ │ - } │ │ │ │ - dc_element.value = this.getChildValue(node); │ │ │ │ - if (dc_element.value != "") { │ │ │ │ - obj[name].push(dc_element) │ │ │ │ - } │ │ │ │ + createFilter: function(geometryAttribute, geometry) { │ │ │ │ + var filter = null; │ │ │ │ + if (this.handler instanceof OpenLayers.Handler.RegularPolygon) { │ │ │ │ + if (this.handler.irregular === true) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.BBOX, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry.getBounds() │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - dct: { │ │ │ │ - "*": function(node, obj) { │ │ │ │ - var name = node.localName || node.nodeName.split(":").pop(); │ │ │ │ - if (!OpenLayers.Util.isArray(obj[name])) { │ │ │ │ - obj[name] = [] │ │ │ │ - } │ │ │ │ - obj[name].push(this.getChildValue(node)) │ │ │ │ + } else if (this.handler instanceof OpenLayers.Handler.Polygon) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }) │ │ │ │ + } else if (this.handler instanceof OpenLayers.Handler.Path) { │ │ │ │ + if (geometryAttribute.type.indexOf("Point") >= 0) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + distance: this.map.getExtent().getWidth() * .01, │ │ │ │ + distanceUnits: this.map.getUnits(), │ │ │ │ + value: geometry │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - ows: OpenLayers.Util.applyDefaults({ │ │ │ │ - BoundingBox: function(node, obj) { │ │ │ │ - if (obj.bounds) { │ │ │ │ - obj.BoundingBox = [{ │ │ │ │ - crs: obj.projection, │ │ │ │ - value: [obj.bounds.left, obj.bounds.bottom, obj.bounds.right, obj.bounds.top] │ │ │ │ - }]; │ │ │ │ - delete obj.projection; │ │ │ │ - delete obj.bounds │ │ │ │ - } │ │ │ │ - OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]["BoundingBox"].apply(this, arguments) │ │ │ │ + } else if (this.handler instanceof OpenLayers.Handler.Click) { │ │ │ │ + if (geometryAttribute.type.indexOf("Polygon") >= 0) { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.INTERSECTS, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + value: geometry │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + filter = new OpenLayers.Filter.Spatial({ │ │ │ │ + type: OpenLayers.Filter.Spatial.DWITHIN, │ │ │ │ + property: geometryAttribute.name, │ │ │ │ + distance: this.map.getExtent().getWidth() * .01, │ │ │ │ + distanceUnits: this.map.getUnits(), │ │ │ │ + value: geometry │ │ │ │ + }) │ │ │ │ } │ │ │ │ - }, OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers["ows"]) │ │ │ │ - }, │ │ │ │ - write: function(options) { │ │ │ │ - var node = this.writeNode("csw:GetRecords", options); │ │ │ │ - node.setAttribute("xmlns:gmd", this.namespaces.gmd); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [node]) │ │ │ │ + } │ │ │ │ + return filter │ │ │ │ }, │ │ │ │ - writers: { │ │ │ │ - csw: { │ │ │ │ - GetRecords: function(options) { │ │ │ │ - if (!options) { │ │ │ │ - options = {} │ │ │ │ - } │ │ │ │ - var node = this.createElementNSPlus("csw:GetRecords", { │ │ │ │ - attributes: { │ │ │ │ - service: "CSW", │ │ │ │ - version: this.version, │ │ │ │ - requestId: options.requestId || this.requestId, │ │ │ │ - resultType: options.resultType || this.resultType, │ │ │ │ - outputFormat: options.outputFormat || this.outputFormat, │ │ │ │ - outputSchema: options.outputSchema || this.outputSchema, │ │ │ │ - startPosition: options.startPosition || this.startPosition, │ │ │ │ - maxRecords: options.maxRecords || this.maxRecords │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.DistributedSearch || this.DistributedSearch) { │ │ │ │ - this.writeNode("csw:DistributedSearch", options.DistributedSearch || this.DistributedSearch, node) │ │ │ │ - } │ │ │ │ - var ResponseHandler = options.ResponseHandler || this.ResponseHandler; │ │ │ │ - if (OpenLayers.Util.isArray(ResponseHandler) && ResponseHandler.length > 0) { │ │ │ │ - for (var i = 0, len = ResponseHandler.length; i < len; i++) { │ │ │ │ - this.writeNode("csw:ResponseHandler", ResponseHandler[i], node) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.writeNode("Query", options.Query || this.Query, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - DistributedSearch: function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:DistributedSearch", { │ │ │ │ - attributes: { │ │ │ │ - hopCount: options.hopCount │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - ResponseHandler: function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:ResponseHandler", { │ │ │ │ - value: options.value │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Query: function(options) { │ │ │ │ - if (!options) { │ │ │ │ - options = {} │ │ │ │ - } │ │ │ │ - var node = this.createElementNSPlus("csw:Query", { │ │ │ │ - attributes: { │ │ │ │ - typeNames: options.typeNames || "csw:Record" │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - var ElementName = options.ElementName; │ │ │ │ - if (OpenLayers.Util.isArray(ElementName) && ElementName.length > 0) { │ │ │ │ - for (var i = 0, len = ElementName.length; i < len; i++) { │ │ │ │ - this.writeNode("csw:ElementName", ElementName[i], node) │ │ │ │ + select: function(geometry) { │ │ │ │ + this._queue = function() { │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + var layer = this.layers[i]; │ │ │ │ + var geometryAttributes = this.getGeometryAttributes(layer); │ │ │ │ + var filters = []; │ │ │ │ + for (var j = 0, lenj = geometryAttributes.length; j < lenj; j++) { │ │ │ │ + var geometryAttribute = geometryAttributes[j]; │ │ │ │ + if (geometryAttribute !== null) { │ │ │ │ + if (!(geometry instanceof OpenLayers.Geometry)) { │ │ │ │ + var point = this.map.getLonLatFromPixel(geometry.xy); │ │ │ │ + geometry = new OpenLayers.Geometry.Point(point.lon, point.lat) │ │ │ │ + } │ │ │ │ + var filter = this.createFilter(geometryAttribute, geometry); │ │ │ │ + if (filter !== null) { │ │ │ │ + filters.push(filter) │ │ │ │ + } │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - this.writeNode("csw:ElementSetName", options.ElementSetName || { │ │ │ │ - value: "summary" │ │ │ │ - }, node) │ │ │ │ - } │ │ │ │ - if (options.Constraint) { │ │ │ │ - this.writeNode("csw:Constraint", options.Constraint, node) │ │ │ │ } │ │ │ │ - if (options.SortBy) { │ │ │ │ - this.writeNode("ogc:SortBy", options.SortBy, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - ElementName: function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:ElementName", { │ │ │ │ - value: options.value │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - ElementSetName: function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:ElementSetName", { │ │ │ │ - attributes: { │ │ │ │ - typeNames: options.typeNames │ │ │ │ - }, │ │ │ │ - value: options.value │ │ │ │ + var selectionLayer = this.createSelectionLayer(layer); │ │ │ │ + this.events.triggerEvent("selected", { │ │ │ │ + layer: layer, │ │ │ │ + filters: filters │ │ │ │ }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Constraint: function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:Constraint", { │ │ │ │ - attributes: { │ │ │ │ - version: options.version │ │ │ │ - } │ │ │ │ + var sld = this.createSLD(layer, filters, geometryAttributes); │ │ │ │ + selectionLayer.mergeNewParams({ │ │ │ │ + SLD_BODY: sld │ │ │ │ }); │ │ │ │ - if (options.Filter) { │ │ │ │ - var format = new OpenLayers.Format.Filter({ │ │ │ │ - version: options.version │ │ │ │ - }); │ │ │ │ - node.appendChild(format.write(options.Filter)) │ │ │ │ - } else if (options.CqlText) { │ │ │ │ - var child = this.createElementNSPlus("CqlText", { │ │ │ │ - value: options.CqlText.value │ │ │ │ - }); │ │ │ │ - node.appendChild(child) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ + delete this._queue │ │ │ │ } │ │ │ │ - }, │ │ │ │ - ogc: OpenLayers.Format.Filter.v1_1_0.prototype.writers["ogc"] │ │ │ │ + }; │ │ │ │ + this.applySelection() │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.CSWGetRecords.v2_0_2" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.SLD.v1_0_0_GeoServer = OpenLayers.Class(OpenLayers.Format.SLD.v1_0_0, { │ │ │ │ - version: "1.0.0", │ │ │ │ - profile: "GeoServer", │ │ │ │ - readers: OpenLayers.Util.applyDefaults({ │ │ │ │ - sld: OpenLayers.Util.applyDefaults({ │ │ │ │ - Priority: function(node, obj) { │ │ │ │ - var value = this.readers.ogc._expression.call(this, node); │ │ │ │ - if (value) { │ │ │ │ - obj.priority = value │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - VendorOption: function(node, obj) { │ │ │ │ - if (!obj.vendorOptions) { │ │ │ │ - obj.vendorOptions = {} │ │ │ │ - } │ │ │ │ - obj.vendorOptions[node.getAttribute("name")] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - TextSymbolizer: function(node, rule) { │ │ │ │ - OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld.TextSymbolizer.apply(this, arguments); │ │ │ │ - var symbolizer = this.multipleSymbolizers ? rule.symbolizers[rule.symbolizers.length - 1] : rule.symbolizer["Text"]; │ │ │ │ - if (symbolizer.graphic === undefined) { │ │ │ │ - symbolizer.graphic = false │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.readers["sld"]) │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.readers), │ │ │ │ - writers: OpenLayers.Util.applyDefaults({ │ │ │ │ - sld: OpenLayers.Util.applyDefaults({ │ │ │ │ - Priority: function(priority) { │ │ │ │ - return this.writers.sld._OGCExpression.call(this, "sld:Priority", priority) │ │ │ │ - }, │ │ │ │ - VendorOption: function(option) { │ │ │ │ - return this.createElementNSPlus("sld:VendorOption", { │ │ │ │ - attributes: { │ │ │ │ - name: option.name │ │ │ │ - }, │ │ │ │ - value: option.value │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - TextSymbolizer: function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["TextSymbolizer"].apply(this, arguments); │ │ │ │ - if (symbolizer.graphic !== false && (symbolizer.externalGraphic || symbolizer.graphicName)) { │ │ │ │ - this.writeNode("Graphic", symbolizer, node) │ │ │ │ - } │ │ │ │ - if ("priority" in symbolizer) { │ │ │ │ - this.writeNode("Priority", symbolizer.priority, node) │ │ │ │ - } │ │ │ │ - return this.addVendorOptions(node, symbolizer) │ │ │ │ - }, │ │ │ │ - PointSymbolizer: function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["PointSymbolizer"].apply(this, arguments); │ │ │ │ - return this.addVendorOptions(node, symbolizer) │ │ │ │ - }, │ │ │ │ - LineSymbolizer: function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["LineSymbolizer"].apply(this, arguments); │ │ │ │ - return this.addVendorOptions(node, symbolizer) │ │ │ │ - }, │ │ │ │ - PolygonSymbolizer: function(symbolizer) { │ │ │ │ - var writers = OpenLayers.Format.SLD.v1_0_0.prototype.writers; │ │ │ │ - var node = writers["sld"]["PolygonSymbolizer"].apply(this, arguments); │ │ │ │ - return this.addVendorOptions(node, symbolizer) │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.writers["sld"]) │ │ │ │ - }, OpenLayers.Format.SLD.v1_0_0.prototype.writers), │ │ │ │ - addVendorOptions: function(node, symbolizer) { │ │ │ │ - var options = symbolizer.vendorOptions; │ │ │ │ - if (options) { │ │ │ │ - for (var key in symbolizer.vendorOptions) { │ │ │ │ - this.writeNode("VendorOption", { │ │ │ │ - name: key, │ │ │ │ - value: symbolizer.vendorOptions[key] │ │ │ │ - }, node) │ │ │ │ + applySelection: function() { │ │ │ │ + var canApply = true; │ │ │ │ + for (var i = 0, len = this.layers.length; i < len; i++) { │ │ │ │ + if (!this.wfsCache[this.layers[i].id]) { │ │ │ │ + canApply = false; │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - return node │ │ │ │ + canApply && this._queue.call(this) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SLD.v1_0_0_GeoServer" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.SLDSelect" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.CSWGetDomain.v2_0_2 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - csw: "http://www.opengis.net/cat/csw/2.0.2" │ │ │ │ +OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + argParserClass: OpenLayers.Control.ArgParser, │ │ │ │ + element: null, │ │ │ │ + anchor: false, │ │ │ │ + base: "", │ │ │ │ + displayProjection: null, │ │ │ │ + initialize: function(element, base, options) { │ │ │ │ + if (element !== null && typeof element == "object" && !OpenLayers.Util.isElement(element)) { │ │ │ │ + options = element; │ │ │ │ + this.base = document.location.href; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (this.element != null) { │ │ │ │ + this.element = OpenLayers.Util.getElement(this.element) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.element = OpenLayers.Util.getElement(element); │ │ │ │ + this.base = base || document.location.href │ │ │ │ + } │ │ │ │ }, │ │ │ │ - defaultPrefix: "csw", │ │ │ │ - version: "2.0.2", │ │ │ │ - schemaLocation: "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", │ │ │ │ - PropertyName: null, │ │ │ │ - ParameterName: null, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + destroy: function() { │ │ │ │ + if (this.element && this.element.parentNode == this.div) { │ │ │ │ + this.div.removeChild(this.element); │ │ │ │ + this.element = null │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("moveend", this, this.updateLink) │ │ │ │ } │ │ │ │ - var obj = {}; │ │ │ │ - this.readNode(data, obj); │ │ │ │ - return obj │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - csw: { │ │ │ │ - GetDomainResponse: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - DomainValues: function(node, obj) { │ │ │ │ - if (!OpenLayers.Util.isArray(obj.DomainValues)) { │ │ │ │ - obj.DomainValues = [] │ │ │ │ - } │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var domainValue = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - domainValue[attrs[i].name] = attrs[i].nodeValue │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, domainValue); │ │ │ │ - obj.DomainValues.push(domainValue) │ │ │ │ - }, │ │ │ │ - PropertyName: function(node, obj) { │ │ │ │ - obj.PropertyName = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ParameterName: function(node, obj) { │ │ │ │ - obj.ParameterName = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ListOfValues: function(node, obj) { │ │ │ │ - if (!OpenLayers.Util.isArray(obj.ListOfValues)) { │ │ │ │ - obj.ListOfValues = [] │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, obj.ListOfValues) │ │ │ │ - }, │ │ │ │ - Value: function(node, obj) { │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var value = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - value[attrs[i].name] = attrs[i].nodeValue │ │ │ │ - } │ │ │ │ - value.value = this.getChildValue(node); │ │ │ │ - obj.push({ │ │ │ │ - Value: value │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - ConceptualScheme: function(node, obj) { │ │ │ │ - obj.ConceptualScheme = {}; │ │ │ │ - this.readChildNodes(node, obj.ConceptualScheme) │ │ │ │ - }, │ │ │ │ - Name: function(node, obj) { │ │ │ │ - obj.Name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Document: function(node, obj) { │ │ │ │ - obj.Document = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Authority: function(node, obj) { │ │ │ │ - obj.Authority = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - RangeOfValues: function(node, obj) { │ │ │ │ - obj.RangeOfValues = {}; │ │ │ │ - this.readChildNodes(node, obj.RangeOfValues) │ │ │ │ - }, │ │ │ │ - MinValue: function(node, obj) { │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var value = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - value[attrs[i].name] = attrs[i].nodeValue │ │ │ │ - } │ │ │ │ - value.value = this.getChildValue(node); │ │ │ │ - obj.MinValue = value │ │ │ │ - }, │ │ │ │ - MaxValue: function(node, obj) { │ │ │ │ - var attrs = node.attributes; │ │ │ │ - var value = {}; │ │ │ │ - for (var i = 0, len = attrs.length; i < len; ++i) { │ │ │ │ - value[attrs[i].name] = attrs[i].nodeValue │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + for (var i = 0, len = this.map.controls.length; i < len; i++) { │ │ │ │ + var control = this.map.controls[i]; │ │ │ │ + if (control.CLASS_NAME == this.argParserClass.CLASS_NAME) { │ │ │ │ + if (control.displayProjection != this.displayProjection) { │ │ │ │ + this.displayProjection = control.displayProjection │ │ │ │ } │ │ │ │ - value.value = this.getChildValue(node); │ │ │ │ - obj.MaxValue = value │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - write: function(options) { │ │ │ │ - var node = this.writeNode("csw:GetDomain", options); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [node]) │ │ │ │ - }, │ │ │ │ - writers: { │ │ │ │ - csw: { │ │ │ │ - GetDomain: function(options) { │ │ │ │ - var node = this.createElementNSPlus("csw:GetDomain", { │ │ │ │ - attributes: { │ │ │ │ - service: "CSW", │ │ │ │ - version: this.version │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (options.PropertyName || this.PropertyName) { │ │ │ │ - this.writeNode("csw:PropertyName", options.PropertyName || this.PropertyName, node) │ │ │ │ - } else if (options.ParameterName || this.ParameterName) { │ │ │ │ - this.writeNode("csw:ParameterName", options.ParameterName || this.ParameterName, node) │ │ │ │ - } │ │ │ │ - this.readChildNodes(node, options); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - PropertyName: function(value) { │ │ │ │ - var node = this.createElementNSPlus("csw:PropertyName", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - ParameterName: function(value) { │ │ │ │ - var node = this.createElementNSPlus("csw:ParameterName", { │ │ │ │ - value: value │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - } │ │ │ │ + if (i == this.map.controls.length) { │ │ │ │ + this.map.addControl(new this.argParserClass({ │ │ │ │ + displayProjection: this.displayProjection │ │ │ │ + })) │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.CSWGetDomain.v2_0_2" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMTSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.OWSCommon.v1_1_0, { │ │ │ │ - version: "1.0.0", │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - wmts: "http://www.opengis.net/wmts/1.0", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink" │ │ │ │ - }, │ │ │ │ - yx: null, │ │ │ │ - defaultPrefix: "wmts", │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options; │ │ │ │ - var yx = OpenLayers.Util.extend({}, OpenLayers.Format.WMTSCapabilities.prototype.yx); │ │ │ │ - this.yx = OpenLayers.Util.extend(yx, this.yx) │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.element && !this.anchor) { │ │ │ │ + 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 │ │ │ │ + }); │ │ │ │ + this.updateLink(); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + updateLink: function() { │ │ │ │ + var separator = this.anchor ? "#" : "?"; │ │ │ │ + var href = this.base; │ │ │ │ + var anchor = null; │ │ │ │ + if (href.indexOf("#") != -1 && this.anchor == false) { │ │ │ │ + anchor = href.substring(href.indexOf("#"), href.length) │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + if (href.indexOf(separator) != -1) { │ │ │ │ + href = href.substring(0, href.indexOf(separator)) │ │ │ │ + } │ │ │ │ + var splits = href.split("#"); │ │ │ │ + href = splits[0] + separator + OpenLayers.Util.getParameterString(this.createParams()); │ │ │ │ + if (anchor) { │ │ │ │ + href += anchor │ │ │ │ + } │ │ │ │ + if (this.anchor && !this.element) { │ │ │ │ + window.location.href = href │ │ │ │ + } else { │ │ │ │ + this.element.href = href │ │ │ │ } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - capabilities.version = this.version; │ │ │ │ - return capabilities │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - wmts: { │ │ │ │ - Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Contents: function(node, obj) { │ │ │ │ - obj.contents = {}; │ │ │ │ - obj.contents.layers = []; │ │ │ │ - obj.contents.tileMatrixSets = {}; │ │ │ │ - this.readChildNodes(node, obj.contents) │ │ │ │ - }, │ │ │ │ - Layer: function(node, obj) { │ │ │ │ - var layer = { │ │ │ │ - styles: [], │ │ │ │ - formats: [], │ │ │ │ - dimensions: [], │ │ │ │ - tileMatrixSetLinks: [] │ │ │ │ - }; │ │ │ │ - layer.layers = []; │ │ │ │ - this.readChildNodes(node, layer); │ │ │ │ - obj.layers.push(layer) │ │ │ │ - }, │ │ │ │ - Style: function(node, obj) { │ │ │ │ - var style = {}; │ │ │ │ - style.isDefault = node.getAttribute("isDefault") === "true"; │ │ │ │ - this.readChildNodes(node, style); │ │ │ │ - obj.styles.push(style) │ │ │ │ - }, │ │ │ │ - Format: function(node, obj) { │ │ │ │ - obj.formats.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - TileMatrixSetLink: function(node, obj) { │ │ │ │ - var tileMatrixSetLink = {}; │ │ │ │ - this.readChildNodes(node, tileMatrixSetLink); │ │ │ │ - obj.tileMatrixSetLinks.push(tileMatrixSetLink) │ │ │ │ - }, │ │ │ │ - TileMatrixSet: function(node, obj) { │ │ │ │ - if (obj.layers) { │ │ │ │ - var tileMatrixSet = { │ │ │ │ - matrixIds: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, tileMatrixSet); │ │ │ │ - obj.tileMatrixSets[tileMatrixSet.identifier] = tileMatrixSet │ │ │ │ - } else { │ │ │ │ - obj.tileMatrixSet = this.getChildValue(node) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - TileMatrix: function(node, obj) { │ │ │ │ - var tileMatrix = { │ │ │ │ - supportedCRS: obj.supportedCRS │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, tileMatrix); │ │ │ │ - obj.matrixIds.push(tileMatrix) │ │ │ │ - }, │ │ │ │ - ScaleDenominator: function(node, obj) { │ │ │ │ - obj.scaleDenominator = parseFloat(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - TopLeftCorner: function(node, obj) { │ │ │ │ - var topLeftCorner = this.getChildValue(node); │ │ │ │ - var coords = topLeftCorner.split(" "); │ │ │ │ - var yx; │ │ │ │ - if (obj.supportedCRS) { │ │ │ │ - var crs = obj.supportedCRS.replace(/urn:ogc:def:crs:(\w+):.+:(\w+)$/, "urn:ogc:def:crs:$1::$2"); │ │ │ │ - yx = !!this.yx[crs] │ │ │ │ - } │ │ │ │ - if (yx) { │ │ │ │ - obj.topLeftCorner = new OpenLayers.LonLat(coords[1], coords[0]) │ │ │ │ + createParams: function(center, zoom, layers) { │ │ │ │ + center = center || this.map.getCenter(); │ │ │ │ + var params = OpenLayers.Util.getParameters(this.base); │ │ │ │ + if (center) { │ │ │ │ + params.zoom = 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 * 1e5) / 1e5; │ │ │ │ + params.lon = Math.round(lon * 1e5) / 1e5; │ │ │ │ + layers = layers || this.map.layers; │ │ │ │ + params.layers = ""; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + if (layer.isBaseLayer) { │ │ │ │ + params.layers += layer == this.map.baseLayer ? "B" : "0" │ │ │ │ } else { │ │ │ │ - obj.topLeftCorner = new OpenLayers.LonLat(coords[0], coords[1]) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - TileWidth: function(node, obj) { │ │ │ │ - obj.tileWidth = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - TileHeight: function(node, obj) { │ │ │ │ - obj.tileHeight = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - MatrixWidth: function(node, obj) { │ │ │ │ - obj.matrixWidth = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - MatrixHeight: function(node, obj) { │ │ │ │ - obj.matrixHeight = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - ResourceURL: function(node, obj) { │ │ │ │ - obj.resourceUrl = obj.resourceUrl || {}; │ │ │ │ - var resourceType = node.getAttribute("resourceType"); │ │ │ │ - if (!obj.resourceUrls) { │ │ │ │ - obj.resourceUrls = [] │ │ │ │ + params.layers += layer.getVisibility() ? "T" : "F" │ │ │ │ } │ │ │ │ - var resourceUrl = obj.resourceUrl[resourceType] = { │ │ │ │ - format: node.getAttribute("format"), │ │ │ │ - template: node.getAttribute("template"), │ │ │ │ - resourceType: resourceType │ │ │ │ - }; │ │ │ │ - obj.resourceUrls.push(resourceUrl) │ │ │ │ - }, │ │ │ │ - WSDL: function(node, obj) { │ │ │ │ - obj.wsdl = {}; │ │ │ │ - obj.wsdl.href = node.getAttribute("xlink:href") │ │ │ │ - }, │ │ │ │ - ServiceMetadataURL: function(node, obj) { │ │ │ │ - obj.serviceMetadataUrl = {}; │ │ │ │ - obj.serviceMetadataUrl.href = node.getAttribute("xlink:href") │ │ │ │ - }, │ │ │ │ - LegendURL: function(node, obj) { │ │ │ │ - obj.legend = {}; │ │ │ │ - obj.legend.href = node.getAttribute("xlink:href"); │ │ │ │ - obj.legend.format = node.getAttribute("format") │ │ │ │ - }, │ │ │ │ - Dimension: function(node, obj) { │ │ │ │ - var dimension = { │ │ │ │ - values: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, dimension); │ │ │ │ - obj.dimensions.push(dimension) │ │ │ │ - }, │ │ │ │ - Default: function(node, obj) { │ │ │ │ - obj["default"] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Value: function(node, obj) { │ │ │ │ - obj.values.push(this.getChildValue(node)) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + } │ │ │ │ + return params │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMTSCapabilities.v1_0_0" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Permalink" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - ol: "http://openlayers.org/context", │ │ │ │ - wmc: "http://www.opengis.net/context", │ │ │ │ - sld: "http://www.opengis.net/sld", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - schemaLocation: "", │ │ │ │ - getNamespacePrefix: function(uri) { │ │ │ │ - var prefix = null; │ │ │ │ - if (uri == null) { │ │ │ │ - prefix = this.namespaces[this.defaultPrefix] │ │ │ │ - } else { │ │ │ │ - for (prefix in this.namespaces) { │ │ │ │ - if (this.namespaces[prefix] == uri) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ +OpenLayers.Control.EditingToolbar = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ + citeCompliant: false, │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + this.addControls([new OpenLayers.Control.Navigation]); │ │ │ │ + var controls = [new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Point, { │ │ │ │ + displayClass: "olControlDrawFeaturePoint", │ │ │ │ + handlerOptions: { │ │ │ │ + citeCompliant: this.citeCompliant │ │ │ │ + } │ │ │ │ + }), new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Path, { │ │ │ │ + displayClass: "olControlDrawFeaturePath", │ │ │ │ + handlerOptions: { │ │ │ │ + citeCompliant: this.citeCompliant │ │ │ │ + } │ │ │ │ + }), new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Polygon, { │ │ │ │ + displayClass: "olControlDrawFeaturePolygon", │ │ │ │ + handlerOptions: { │ │ │ │ + citeCompliant: this.citeCompliant │ │ │ │ } │ │ │ │ + })]; │ │ │ │ + this.addControls(controls) │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments); │ │ │ │ + if (this.defaultControl === null) { │ │ │ │ + this.defaultControl = this.controls[0] │ │ │ │ } │ │ │ │ - return prefix │ │ │ │ + return div │ │ │ │ }, │ │ │ │ - defaultPrefix: "wmc", │ │ │ │ - rootPrefix: null, │ │ │ │ - defaultStyleName: "", │ │ │ │ - defaultStyleTitle: "Default", │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.EditingToolbar" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Scale = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + element: null, │ │ │ │ + geodesic: false, │ │ │ │ + initialize: function(element, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.element = OpenLayers.Util.getElement(element) │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.element) { │ │ │ │ + this.element = document.createElement("div"); │ │ │ │ + this.div.appendChild(this.element) │ │ │ │ } │ │ │ │ - var root = data.documentElement; │ │ │ │ - this.rootPrefix = root.prefix; │ │ │ │ - var context = { │ │ │ │ - version: root.getAttribute("version") │ │ │ │ - }; │ │ │ │ - this.runChildNodes(context, root); │ │ │ │ - return context │ │ │ │ + this.map.events.register("moveend", this, this.updateScale); │ │ │ │ + this.updateScale(); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - runChildNodes: function(obj, node) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var childNode, processor, prefix, local; │ │ │ │ - for (var i = 0, len = children.length; i < len; ++i) { │ │ │ │ - childNode = children[i]; │ │ │ │ - if (childNode.nodeType == 1) { │ │ │ │ - prefix = this.getNamespacePrefix(childNode.namespaceURI); │ │ │ │ - local = childNode.nodeName.split(":").pop(); │ │ │ │ - processor = this["read_" + prefix + "_" + local]; │ │ │ │ - if (processor) { │ │ │ │ - processor.apply(this, [obj, childNode]) │ │ │ │ - } │ │ │ │ + updateScale: function() { │ │ │ │ + var scale; │ │ │ │ + if (this.geodesic === true) { │ │ │ │ + var units = this.map.getUnits(); │ │ │ │ + if (!units) { │ │ │ │ + return │ │ │ │ } │ │ │ │ + var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ + scale = (this.map.getGeodesicPixelSize().w || 1e-6) * inches["km"] * OpenLayers.DOTS_PER_INCH │ │ │ │ + } else { │ │ │ │ + scale = this.map.getScale() │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_General: function(context, node) { │ │ │ │ - this.runChildNodes(context, node) │ │ │ │ - }, │ │ │ │ - read_wmc_BoundingBox: function(context, node) { │ │ │ │ - context.projection = node.getAttribute("SRS"); │ │ │ │ - context.bounds = new OpenLayers.Bounds(node.getAttribute("minx"), node.getAttribute("miny"), node.getAttribute("maxx"), node.getAttribute("maxy")) │ │ │ │ - }, │ │ │ │ - read_wmc_LayerList: function(context, node) { │ │ │ │ - context.layersContext = []; │ │ │ │ - this.runChildNodes(context, node) │ │ │ │ - }, │ │ │ │ - read_wmc_Layer: function(context, node) { │ │ │ │ - var layerContext = { │ │ │ │ - visibility: node.getAttribute("hidden") != "1", │ │ │ │ - queryable: node.getAttribute("queryable") == "1", │ │ │ │ - formats: [], │ │ │ │ - styles: [], │ │ │ │ - metadata: {} │ │ │ │ - }; │ │ │ │ - this.runChildNodes(layerContext, node); │ │ │ │ - context.layersContext.push(layerContext) │ │ │ │ - }, │ │ │ │ - read_wmc_Extension: function(obj, node) { │ │ │ │ - this.runChildNodes(obj, node) │ │ │ │ - }, │ │ │ │ - read_ol_units: function(layerContext, node) { │ │ │ │ - layerContext.units = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - read_ol_maxExtent: function(obj, node) { │ │ │ │ - var bounds = new OpenLayers.Bounds(node.getAttribute("minx"), node.getAttribute("miny"), node.getAttribute("maxx"), node.getAttribute("maxy")); │ │ │ │ - obj.maxExtent = bounds │ │ │ │ - }, │ │ │ │ - read_ol_transparent: function(layerContext, node) { │ │ │ │ - layerContext.transparent = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - read_ol_numZoomLevels: function(layerContext, node) { │ │ │ │ - layerContext.numZoomLevels = parseInt(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - read_ol_opacity: function(layerContext, node) { │ │ │ │ - layerContext.opacity = parseFloat(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - read_ol_singleTile: function(layerContext, node) { │ │ │ │ - layerContext.singleTile = this.getChildValue(node) == "true" │ │ │ │ - }, │ │ │ │ - read_ol_tileSize: function(layerContext, node) { │ │ │ │ - var obj = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height") │ │ │ │ - }; │ │ │ │ - layerContext.tileSize = obj │ │ │ │ - }, │ │ │ │ - read_ol_isBaseLayer: function(layerContext, node) { │ │ │ │ - layerContext.isBaseLayer = this.getChildValue(node) == "true" │ │ │ │ - }, │ │ │ │ - read_ol_displayInLayerSwitcher: function(layerContext, node) { │ │ │ │ - layerContext.displayInLayerSwitcher = this.getChildValue(node) == "true" │ │ │ │ - }, │ │ │ │ - read_wmc_Server: function(layerContext, node) { │ │ │ │ - layerContext.version = node.getAttribute("version"); │ │ │ │ - layerContext.url = this.getOnlineResource_href(node); │ │ │ │ - layerContext.metadata.servertitle = node.getAttribute("title") │ │ │ │ - }, │ │ │ │ - read_wmc_FormatList: function(layerContext, node) { │ │ │ │ - this.runChildNodes(layerContext, node) │ │ │ │ - }, │ │ │ │ - read_wmc_Format: function(layerContext, node) { │ │ │ │ - var format = { │ │ │ │ - value: this.getChildValue(node) │ │ │ │ - }; │ │ │ │ - if (node.getAttribute("current") == "1") { │ │ │ │ - format.current = true │ │ │ │ + if (!scale) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - layerContext.formats.push(format) │ │ │ │ - }, │ │ │ │ - read_wmc_StyleList: function(layerContext, node) { │ │ │ │ - this.runChildNodes(layerContext, node) │ │ │ │ - }, │ │ │ │ - read_wmc_Style: function(layerContext, node) { │ │ │ │ - var style = {}; │ │ │ │ - this.runChildNodes(style, node); │ │ │ │ - if (node.getAttribute("current") == "1") { │ │ │ │ - style.current = true │ │ │ │ + if (scale >= 9500 && scale <= 95e4) { │ │ │ │ + scale = Math.round(scale / 1e3) + "K" │ │ │ │ + } else if (scale >= 95e4) { │ │ │ │ + scale = Math.round(scale / 1e6) + "M" │ │ │ │ + } else { │ │ │ │ + scale = Math.round(scale) │ │ │ │ } │ │ │ │ - layerContext.styles.push(style) │ │ │ │ - }, │ │ │ │ - read_wmc_SLD: function(style, node) { │ │ │ │ - this.runChildNodes(style, node) │ │ │ │ - }, │ │ │ │ - read_sld_StyledLayerDescriptor: function(sld, node) { │ │ │ │ - var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ - sld.body = xml │ │ │ │ + this.element.innerHTML = OpenLayers.i18n("Scale = 1 : ${scaleDenom}", { │ │ │ │ + scaleDenom: scale │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - read_sld_FeatureTypeStyle: function(sld, node) { │ │ │ │ - var xml = OpenLayers.Format.XML.prototype.write.apply(this, [node]); │ │ │ │ - sld.body = xml │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Scale" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ZoomToMaxExtent = OpenLayers.Class(OpenLayers.Control.Button, { │ │ │ │ + trigger: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.zoomToMaxExtent() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - read_wmc_OnlineResource: function(obj, node) { │ │ │ │ - obj.href = this.getAttributeNS(node, this.namespaces.xlink, "href") │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomToMaxExtent" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ZoomPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + this.addControls([new OpenLayers.Control.ZoomIn, new OpenLayers.Control.ZoomToMaxExtent, new OpenLayers.Control.ZoomOut]) │ │ │ │ }, │ │ │ │ - read_wmc_Name: function(obj, node) { │ │ │ │ - var name = this.getChildValue(node); │ │ │ │ - if (name) { │ │ │ │ - obj.name = name │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ZoomPanel" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.ScaleLine = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + maxWidth: 100, │ │ │ │ + topOutUnits: "km", │ │ │ │ + topInUnits: "m", │ │ │ │ + bottomOutUnits: "mi", │ │ │ │ + bottomInUnits: "ft", │ │ │ │ + eTop: null, │ │ │ │ + eBottom: null, │ │ │ │ + geodesic: false, │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.eTop) { │ │ │ │ + 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" │ │ │ │ + } │ │ │ │ + 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 │ │ │ │ }, │ │ │ │ - read_wmc_Title: function(obj, node) { │ │ │ │ - var title = this.getChildValue(node); │ │ │ │ - if (title) { │ │ │ │ - obj.title = title │ │ │ │ + getBarLen: function(maxLen) { │ │ │ │ + var digits = parseInt(Math.log(maxLen) / Math.log(10)); │ │ │ │ + var pow10 = Math.pow(10, digits); │ │ │ │ + var firstChar = parseInt(maxLen / pow10); │ │ │ │ + var barLen; │ │ │ │ + if (firstChar > 5) { │ │ │ │ + barLen = 5 │ │ │ │ + } else if (firstChar > 2) { │ │ │ │ + barLen = 2 │ │ │ │ + } else { │ │ │ │ + barLen = 1 │ │ │ │ } │ │ │ │ + return barLen * pow10 │ │ │ │ }, │ │ │ │ - read_wmc_MetadataURL: function(layerContext, node) { │ │ │ │ - layerContext.metadataURL = this.getOnlineResource_href(node) │ │ │ │ - }, │ │ │ │ - read_wmc_KeywordList: function(context, node) { │ │ │ │ - context.keywords = []; │ │ │ │ - this.runChildNodes(context.keywords, node) │ │ │ │ - }, │ │ │ │ - read_wmc_Keyword: function(keywords, node) { │ │ │ │ - keywords.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - read_wmc_Abstract: function(obj, node) { │ │ │ │ - var abst = this.getChildValue(node); │ │ │ │ - if (abst) { │ │ │ │ - obj["abstract"] = abst │ │ │ │ + update: function() { │ │ │ │ + var res = this.map.getResolution(); │ │ │ │ + if (!res) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_LogoURL: function(context, node) { │ │ │ │ - context.logo = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height"), │ │ │ │ - format: node.getAttribute("format"), │ │ │ │ - href: this.getOnlineResource_href(node) │ │ │ │ + var curMapUnits = this.map.getUnits(); │ │ │ │ + var inches = OpenLayers.INCHES_PER_UNIT; │ │ │ │ + var maxSizeData = this.maxWidth * res * inches[curMapUnits]; │ │ │ │ + var geodesicRatio = 1; │ │ │ │ + if (this.geodesic === true) { │ │ │ │ + var maxSizeGeodesic = (this.map.getGeodesicPixelSize().w || 1e-6) * this.maxWidth; │ │ │ │ + var maxSizeKilometers = maxSizeData / inches["km"]; │ │ │ │ + geodesicRatio = maxSizeGeodesic / maxSizeKilometers; │ │ │ │ + maxSizeData *= geodesicRatio │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_DescriptionURL: function(context, node) { │ │ │ │ - context.descriptionURL = this.getOnlineResource_href(node) │ │ │ │ - }, │ │ │ │ - read_wmc_ContactInformation: function(obj, node) { │ │ │ │ - var contact = {}; │ │ │ │ - this.runChildNodes(contact, node); │ │ │ │ - obj.contactInformation = contact │ │ │ │ - }, │ │ │ │ - read_wmc_ContactPersonPrimary: function(contact, node) { │ │ │ │ - var personPrimary = {}; │ │ │ │ - this.runChildNodes(personPrimary, node); │ │ │ │ - contact.personPrimary = personPrimary │ │ │ │ - }, │ │ │ │ - read_wmc_ContactPerson: function(primaryPerson, node) { │ │ │ │ - var person = this.getChildValue(node); │ │ │ │ - if (person) { │ │ │ │ - primaryPerson.person = person │ │ │ │ + var topUnits; │ │ │ │ + var bottomUnits; │ │ │ │ + if (maxSizeData > 1e5) { │ │ │ │ + topUnits = this.topOutUnits; │ │ │ │ + bottomUnits = this.bottomOutUnits │ │ │ │ + } else { │ │ │ │ + topUnits = this.topInUnits; │ │ │ │ + bottomUnits = this.bottomInUnits │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_ContactOrganization: function(primaryPerson, node) { │ │ │ │ - var organization = this.getChildValue(node); │ │ │ │ - if (organization) { │ │ │ │ - primaryPerson.organization = organization │ │ │ │ + var topMax = maxSizeData / inches[topUnits]; │ │ │ │ + var bottomMax = maxSizeData / inches[bottomUnits]; │ │ │ │ + var topRounded = this.getBarLen(topMax); │ │ │ │ + var bottomRounded = this.getBarLen(bottomMax); │ │ │ │ + topMax = topRounded / inches[curMapUnits] * inches[topUnits]; │ │ │ │ + bottomMax = bottomRounded / inches[curMapUnits] * inches[bottomUnits]; │ │ │ │ + var topPx = topMax / res / geodesicRatio; │ │ │ │ + var bottomPx = bottomMax / res / geodesicRatio; │ │ │ │ + if (this.eBottom.style.visibility == "visible") { │ │ │ │ + this.eBottom.style.width = Math.round(bottomPx) + "px"; │ │ │ │ + this.eBottom.innerHTML = bottomRounded + " " + bottomUnits │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_ContactPosition: function(contact, node) { │ │ │ │ - var position = this.getChildValue(node); │ │ │ │ - if (position) { │ │ │ │ - contact.position = position │ │ │ │ + if (this.eTop.style.visibility == "visible") { │ │ │ │ + this.eTop.style.width = Math.round(topPx) + "px"; │ │ │ │ + this.eTop.innerHTML = topRounded + " " + topUnits │ │ │ │ } │ │ │ │ }, │ │ │ │ - read_wmc_ContactAddress: function(contact, node) { │ │ │ │ - var contactAddress = {}; │ │ │ │ - this.runChildNodes(contactAddress, node); │ │ │ │ - contact.contactAddress = contactAddress │ │ │ │ - }, │ │ │ │ - read_wmc_AddressType: function(contactAddress, node) { │ │ │ │ - var type = this.getChildValue(node); │ │ │ │ - if (type) { │ │ │ │ - contactAddress.type = type │ │ │ │ + CLASS_NAME: "OpenLayers.Control.ScaleLine" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.CacheWrite = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + layers: null, │ │ │ │ + imageFormat: "image/png", │ │ │ │ + quotaRegEx: /quota/i, │ │ │ │ + setMap: function(map) { │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments); │ │ │ │ + var i, layers = this.layers || map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.addLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_Address: function(contactAddress, node) { │ │ │ │ - var address = this.getChildValue(node); │ │ │ │ - if (address) { │ │ │ │ - contactAddress.address = address │ │ │ │ + if (!this.layers) { │ │ │ │ + map.events.on({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - read_wmc_City: function(contactAddress, node) { │ │ │ │ - var city = this.getChildValue(node); │ │ │ │ - if (city) { │ │ │ │ - contactAddress.city = city │ │ │ │ - } │ │ │ │ + addLayer: function(evt) { │ │ │ │ + evt.layer.events.on({ │ │ │ │ + tileloadstart: this.makeSameOrigin, │ │ │ │ + tileloaded: this.onTileLoaded, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - read_wmc_StateOrProvince: function(contactAddress, node) { │ │ │ │ - var stateOrProvince = this.getChildValue(node); │ │ │ │ - if (stateOrProvince) { │ │ │ │ - contactAddress.stateOrProvince = stateOrProvince │ │ │ │ - } │ │ │ │ + removeLayer: function(evt) { │ │ │ │ + evt.layer.events.un({ │ │ │ │ + tileloadstart: this.makeSameOrigin, │ │ │ │ + tileloaded: this.onTileLoaded, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - read_wmc_PostCode: function(contactAddress, node) { │ │ │ │ - var postcode = this.getChildValue(node); │ │ │ │ - if (postcode) { │ │ │ │ - contactAddress.postcode = postcode │ │ │ │ + makeSameOrigin: function(evt) { │ │ │ │ + if (this.active) { │ │ │ │ + var tile = evt.tile; │ │ │ │ + if (tile instanceof OpenLayers.Tile.Image && !tile.crossOriginKeyword && tile.url.substr(0, 5) !== "data:") { │ │ │ │ + var sameOriginUrl = OpenLayers.Request.makeSameOrigin(tile.url, OpenLayers.ProxyHost); │ │ │ │ + OpenLayers.Control.CacheWrite.urlMap[sameOriginUrl] = tile.url; │ │ │ │ + tile.url = sameOriginUrl │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - read_wmc_Country: function(contactAddress, node) { │ │ │ │ - var country = this.getChildValue(node); │ │ │ │ - if (country) { │ │ │ │ - contactAddress.country = country │ │ │ │ + onTileLoaded: function(evt) { │ │ │ │ + if (this.active && !evt.aborted && evt.tile instanceof OpenLayers.Tile.Image && evt.tile.url.substr(0, 5) !== "data:") { │ │ │ │ + this.cache({ │ │ │ │ + tile: evt.tile │ │ │ │ + }); │ │ │ │ + delete OpenLayers.Control.CacheWrite.urlMap[evt.tile.url] │ │ │ │ } │ │ │ │ }, │ │ │ │ - read_wmc_ContactVoiceTelephone: function(contact, node) { │ │ │ │ - var phone = this.getChildValue(node); │ │ │ │ - if (phone) { │ │ │ │ - contact.phone = phone │ │ │ │ + cache: function(obj) { │ │ │ │ + if (window.localStorage) { │ │ │ │ + var tile = obj.tile; │ │ │ │ + try { │ │ │ │ + var canvasContext = tile.getCanvasContext(); │ │ │ │ + if (canvasContext) { │ │ │ │ + var urlMap = OpenLayers.Control.CacheWrite.urlMap; │ │ │ │ + var url = urlMap[tile.url] || tile.url; │ │ │ │ + window.localStorage.setItem("olCache_" + url, canvasContext.canvas.toDataURL(this.imageFormat)) │ │ │ │ + } │ │ │ │ + } catch (e) { │ │ │ │ + var reason = e.name || e.message; │ │ │ │ + if (reason && this.quotaRegEx.test(reason)) { │ │ │ │ + this.events.triggerEvent("cachefull", { │ │ │ │ + tile: tile │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + OpenLayers.Console.error(e.toString()) │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ }, │ │ │ │ - read_wmc_ContactFacsimileTelephone: function(contact, node) { │ │ │ │ - var fax = this.getChildValue(node); │ │ │ │ - if (fax) { │ │ │ │ - contact.fax = fax │ │ │ │ + destroy: function() { │ │ │ │ + if (this.layers || this.map) { │ │ │ │ + var i, layers = this.layers || this.map.layers; │ │ │ │ + for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ + this.removeLayer({ │ │ │ │ + layer: layers[i] │ │ │ │ + }) │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read_wmc_ContactElectronicMailAddress: function(contact, node) { │ │ │ │ - var email = this.getChildValue(node); │ │ │ │ - if (email) { │ │ │ │ - contact.email = email │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.un({ │ │ │ │ + addlayer: this.addLayer, │ │ │ │ + removeLayer: this.removeLayer, │ │ │ │ + scope: this │ │ │ │ + }) │ │ │ │ } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - read_wmc_DataURL: function(layerContext, node) { │ │ │ │ - layerContext.dataURL = this.getOnlineResource_href(node) │ │ │ │ - }, │ │ │ │ - read_wmc_LegendURL: function(style, node) { │ │ │ │ - var legend = { │ │ │ │ - width: node.getAttribute("width"), │ │ │ │ - height: node.getAttribute("height"), │ │ │ │ - format: node.getAttribute("format"), │ │ │ │ - href: this.getOnlineResource_href(node) │ │ │ │ - }; │ │ │ │ - style.legend = legend │ │ │ │ - }, │ │ │ │ - read_wmc_DimensionList: function(layerContext, node) { │ │ │ │ - layerContext.dimensions = {}; │ │ │ │ - this.runChildNodes(layerContext.dimensions, node) │ │ │ │ - }, │ │ │ │ - read_wmc_Dimension: function(dimensions, node) { │ │ │ │ - var name = node.getAttribute("name").toLowerCase(); │ │ │ │ - var dim = { │ │ │ │ - name: name, │ │ │ │ - units: node.getAttribute("units") || "", │ │ │ │ - unitSymbol: node.getAttribute("unitSymbol") || "", │ │ │ │ - userValue: node.getAttribute("userValue") || "", │ │ │ │ - nearestValue: node.getAttribute("nearestValue") === "1", │ │ │ │ - multipleValues: node.getAttribute("multipleValues") === "1", │ │ │ │ - current: node.getAttribute("current") === "1", │ │ │ │ - default: node.getAttribute("default") || "" │ │ │ │ - }; │ │ │ │ - var values = this.getChildValue(node); │ │ │ │ - dim.values = values.split(","); │ │ │ │ - dimensions[dim.name] = dim │ │ │ │ + CLASS_NAME: "OpenLayers.Control.CacheWrite" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.CacheWrite.clearCache = function() { │ │ │ │ + if (!window.localStorage) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var i, key; │ │ │ │ + for (i = window.localStorage.length - 1; i >= 0; --i) { │ │ │ │ + key = window.localStorage.key(i); │ │ │ │ + if (key.substr(0, 8) === "olCache_") { │ │ │ │ + window.localStorage.removeItem(key) │ │ │ │ + } │ │ │ │ + } │ │ │ │ +}; │ │ │ │ +OpenLayers.Control.CacheWrite.urlMap = {}; │ │ │ │ +OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + layerStates: null, │ │ │ │ + layersDiv: null, │ │ │ │ + baseLayersDiv: null, │ │ │ │ + baseLayers: null, │ │ │ │ + dataLbl: null, │ │ │ │ + dataLayersDiv: null, │ │ │ │ + dataLayers: null, │ │ │ │ + minimizeDiv: null, │ │ │ │ + maximizeDiv: null, │ │ │ │ + ascending: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + this.layerStates = [] │ │ │ │ }, │ │ │ │ - write: function(context, options) { │ │ │ │ - var root = this.createElementDefaultNS("ViewContext"); │ │ │ │ - this.setAttributes(root, { │ │ │ │ - version: this.VERSION, │ │ │ │ - id: options && typeof options.id == "string" ? options.id : OpenLayers.Util.createUniqueID("OpenLayers_Context_") │ │ │ │ + destroy: function() { │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ + this.map.events.un({ │ │ │ │ + buttonclick: this.onButtonClick, │ │ │ │ + addlayer: this.redraw, │ │ │ │ + changelayer: this.redraw, │ │ │ │ + removelayer: this.redraw, │ │ │ │ + changebaselayer: this.redraw, │ │ │ │ + scope: this │ │ │ │ }); │ │ │ │ - this.setAttributeNS(root, this.namespaces.xsi, "xsi:schemaLocation", this.schemaLocation); │ │ │ │ - root.appendChild(this.write_wmc_General(context)); │ │ │ │ - root.appendChild(this.write_wmc_LayerList(context)); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [root]) │ │ │ │ + this.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - createElementDefaultNS: function(name, childValue, attributes) { │ │ │ │ - var node = this.createElementNS(this.namespaces[this.defaultPrefix], name); │ │ │ │ - if (childValue) { │ │ │ │ - node.appendChild(this.createTextNode(childValue)) │ │ │ │ - } │ │ │ │ - if (attributes) { │ │ │ │ - this.setAttributes(node, attributes) │ │ │ │ + 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 │ │ │ │ + }); │ │ │ │ + if (this.outsideViewport) { │ │ │ │ + this.events.attachToElement(this.div); │ │ │ │ + this.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ + } else { │ │ │ │ + this.map.events.register("buttonclick", this, this.onButtonClick) │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - setAttributes: function(node, obj) { │ │ │ │ - var value; │ │ │ │ - for (var name in obj) { │ │ │ │ - value = obj[name].toString(); │ │ │ │ - if (value.match(/[A-Z]/)) { │ │ │ │ - this.setAttributeNS(node, null, name, value) │ │ │ │ - } else { │ │ │ │ - node.setAttribute(name, value) │ │ │ │ - } │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this); │ │ │ │ + this.loadContents(); │ │ │ │ + if (!this.outsideViewport) { │ │ │ │ + this.minimizeControl() │ │ │ │ } │ │ │ │ + this.redraw(); │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - write_wmc_General: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("General"); │ │ │ │ - if (context.size) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("Window", null, { │ │ │ │ - width: context.size.w, │ │ │ │ - height: context.size.h │ │ │ │ - })) │ │ │ │ - } │ │ │ │ - var bounds = context.bounds; │ │ │ │ - node.appendChild(this.createElementDefaultNS("BoundingBox", null, { │ │ │ │ - minx: bounds.left.toPrecision(18), │ │ │ │ - miny: bounds.bottom.toPrecision(18), │ │ │ │ - maxx: bounds.right.toPrecision(18), │ │ │ │ - maxy: bounds.top.toPrecision(18), │ │ │ │ - SRS: context.projection │ │ │ │ - })); │ │ │ │ - node.appendChild(this.createElementDefaultNS("Title", context.title)); │ │ │ │ - if (context.keywords) { │ │ │ │ - node.appendChild(this.write_wmc_KeywordList(context.keywords)) │ │ │ │ - } │ │ │ │ - if (context["abstract"]) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("Abstract", context["abstract"])) │ │ │ │ - } │ │ │ │ - if (context.logo) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("LogoURL", context.logo.href, context.logo)) │ │ │ │ - } │ │ │ │ - if (context.descriptionURL) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("DescriptionURL", context.descriptionURL)) │ │ │ │ - } │ │ │ │ - if (context.contactInformation) { │ │ │ │ - node.appendChild(this.write_wmc_ContactInformation(context.contactInformation)) │ │ │ │ + onButtonClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.minimizeDiv) { │ │ │ │ + this.minimizeControl() │ │ │ │ + } else if (button === this.maximizeDiv) { │ │ │ │ + this.maximizeControl() │ │ │ │ + } else if (button._layerSwitcher === this.id) { │ │ │ │ + if (button["for"]) { │ │ │ │ + button = document.getElementById(button["for"]) │ │ │ │ + } │ │ │ │ + if (!button.disabled) { │ │ │ │ + if (button.type == "radio") { │ │ │ │ + button.checked = true; │ │ │ │ + this.map.setBaseLayer(this.map.getLayer(button._layer)) │ │ │ │ + } else { │ │ │ │ + button.checked = !button.checked; │ │ │ │ + this.updateMap() │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - node.appendChild(this.write_ol_MapExtension(context)); │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - write_wmc_KeywordList: function(keywords) { │ │ │ │ - var node = this.createElementDefaultNS("KeywordList"); │ │ │ │ - for (var i = 0, len = keywords.length; i < len; i++) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("Keyword", keywords[i])) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ + clearLayersArray: function(layersType) { │ │ │ │ + this[layersType + "LayersDiv"].innerHTML = ""; │ │ │ │ + this[layersType + "Layers"] = [] │ │ │ │ }, │ │ │ │ - write_wmc_ContactInformation: function(contact) { │ │ │ │ - var node = this.createElementDefaultNS("ContactInformation"); │ │ │ │ - if (contact.personPrimary) { │ │ │ │ - node.appendChild(this.write_wmc_ContactPersonPrimary(contact.personPrimary)) │ │ │ │ + checkRedraw: function() { │ │ │ │ + if (!this.layerStates.length || this.map.layers.length != this.layerStates.length) { │ │ │ │ + return true │ │ │ │ } │ │ │ │ - if (contact.position) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("ContactPosition", contact.position)) │ │ │ │ + for (var i = 0, len = this.layerStates.length; i < len; 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) { │ │ │ │ + return true │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (contact.contactAddress) { │ │ │ │ - node.appendChild(this.write_wmc_ContactAddress(contact.contactAddress)) │ │ │ │ + return false │ │ │ │ + }, │ │ │ │ + redraw: function() { │ │ │ │ + if (!this.checkRedraw()) { │ │ │ │ + return this.div │ │ │ │ } │ │ │ │ - if (contact.phone) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("ContactVoiceTelephone", contact.phone)) │ │ │ │ + this.clearLayersArray("base"); │ │ │ │ + this.clearLayersArray("data"); │ │ │ │ + var containsOverlays = false; │ │ │ │ + var containsBaseLayers = false; │ │ │ │ + var len = this.map.layers.length; │ │ │ │ + this.layerStates = new Array(len); │ │ │ │ + for (var i = 0; i < len; i++) { │ │ │ │ + var layer = this.map.layers[i]; │ │ │ │ + this.layerStates[i] = { │ │ │ │ + name: layer.name, │ │ │ │ + visibility: layer.visibility, │ │ │ │ + inRange: layer.inRange, │ │ │ │ + id: layer.id │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (contact.fax) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("ContactFacsimileTelephone", contact.fax)) │ │ │ │ + var layers = this.map.layers.slice(); │ │ │ │ + if (!this.ascending) { │ │ │ │ + layers.reverse() │ │ │ │ } │ │ │ │ - if (contact.email) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("ContactElectronicMailAddress", contact.email)) │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + var baseLayer = layer.isBaseLayer; │ │ │ │ + if (layer.displayInLayerSwitcher) { │ │ │ │ + if (baseLayer) { │ │ │ │ + containsBaseLayers = true │ │ │ │ + } else { │ │ │ │ + containsOverlays = true │ │ │ │ + } │ │ │ │ + var checked = baseLayer ? layer == this.map.baseLayer : layer.getVisibility(); │ │ │ │ + var inputElem = document.createElement("input"), │ │ │ │ + inputId = OpenLayers.Util.createUniqueID(this.id + "_input_"); │ │ │ │ + inputElem.id = inputId; │ │ │ │ + inputElem.name = baseLayer ? this.id + "_baseLayers" : layer.name; │ │ │ │ + inputElem.type = baseLayer ? "radio" : "checkbox"; │ │ │ │ + inputElem.value = layer.name; │ │ │ │ + inputElem.checked = checked; │ │ │ │ + inputElem.defaultChecked = checked; │ │ │ │ + inputElem.className = "olButton"; │ │ │ │ + inputElem._layer = layer.id; │ │ │ │ + inputElem._layerSwitcher = this.id; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + inputElem.disabled = true │ │ │ │ + } │ │ │ │ + var labelSpan = document.createElement("label"); │ │ │ │ + labelSpan["for"] = inputElem.id; │ │ │ │ + OpenLayers.Element.addClass(labelSpan, "labelSpan olButton"); │ │ │ │ + labelSpan._layer = layer.id; │ │ │ │ + labelSpan._layerSwitcher = this.id; │ │ │ │ + if (!baseLayer && !layer.inRange) { │ │ │ │ + labelSpan.style.color = "gray" │ │ │ │ + } │ │ │ │ + labelSpan.innerHTML = layer.name; │ │ │ │ + labelSpan.style.verticalAlign = baseLayer ? "bottom" : "baseline"; │ │ │ │ + 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) │ │ │ │ + } │ │ │ │ } │ │ │ │ - return node │ │ │ │ + this.dataLbl.style.display = containsOverlays ? "" : "none"; │ │ │ │ + this.baseLbl.style.display = containsBaseLayers ? "" : "none"; │ │ │ │ + return this.div │ │ │ │ }, │ │ │ │ - write_wmc_ContactPersonPrimary: function(personPrimary) { │ │ │ │ - var node = this.createElementDefaultNS("ContactPersonPrimary"); │ │ │ │ - if (personPrimary.person) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("ContactPerson", personPrimary.person)) │ │ │ │ + updateMap: function() { │ │ │ │ + for (var i = 0, len = this.baseLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.baseLayers[i]; │ │ │ │ + if (layerEntry.inputElem.checked) { │ │ │ │ + this.map.setBaseLayer(layerEntry.layer, false) │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (personPrimary.organization) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("ContactOrganization", personPrimary.organization)) │ │ │ │ + for (var i = 0, len = this.dataLayers.length; i < len; i++) { │ │ │ │ + var layerEntry = this.dataLayers[i]; │ │ │ │ + layerEntry.layer.setVisibility(layerEntry.inputElem.checked) │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - write_wmc_ContactAddress: function(contactAddress) { │ │ │ │ - var node = this.createElementDefaultNS("ContactAddress"); │ │ │ │ - if (contactAddress.type) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("AddressType", contactAddress.type)) │ │ │ │ - } │ │ │ │ - if (contactAddress.address) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("Address", contactAddress.address)) │ │ │ │ - } │ │ │ │ - if (contactAddress.city) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("City", contactAddress.city)) │ │ │ │ - } │ │ │ │ - if (contactAddress.stateOrProvince) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("StateOrProvince", contactAddress.stateOrProvince)) │ │ │ │ - } │ │ │ │ - if (contactAddress.postcode) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("PostCode", contactAddress.postcode)) │ │ │ │ - } │ │ │ │ - if (contactAddress.country) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("Country", contactAddress.country)) │ │ │ │ + maximizeControl: function(e) { │ │ │ │ + this.div.style.width = ""; │ │ │ │ + this.div.style.height = ""; │ │ │ │ + this.showControls(false); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - write_ol_MapExtension: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("Extension"); │ │ │ │ - var bounds = context.maxExtent; │ │ │ │ - if (bounds) { │ │ │ │ - var maxExtent = this.createElementNS(this.namespaces.ol, "ol:maxExtent"); │ │ │ │ - this.setAttributes(maxExtent, { │ │ │ │ - minx: bounds.left.toPrecision(18), │ │ │ │ - miny: bounds.bottom.toPrecision(18), │ │ │ │ - maxx: bounds.right.toPrecision(18), │ │ │ │ - maxy: bounds.top.toPrecision(18) │ │ │ │ - }); │ │ │ │ - node.appendChild(maxExtent) │ │ │ │ + minimizeControl: function(e) { │ │ │ │ + this.div.style.width = "0px"; │ │ │ │ + this.div.style.height = "0px"; │ │ │ │ + this.showControls(true); │ │ │ │ + if (e != null) { │ │ │ │ + OpenLayers.Event.stop(e) │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - write_wmc_LayerList: function(context) { │ │ │ │ - var list = this.createElementDefaultNS("LayerList"); │ │ │ │ - for (var i = 0, len = context.layersContext.length; i < len; ++i) { │ │ │ │ - list.appendChild(this.write_wmc_Layer(context.layersContext[i])) │ │ │ │ + showControls: function(minimize) { │ │ │ │ + this.maximizeDiv.style.display = minimize ? "" : "none"; │ │ │ │ + this.minimizeDiv.style.display = minimize ? "none" : ""; │ │ │ │ + this.layersDiv.style.display = minimize ? "none" : "" │ │ │ │ + }, │ │ │ │ + loadContents: function() { │ │ │ │ + this.layersDiv = document.createElement("div"); │ │ │ │ + this.layersDiv.id = this.id + "_layersDiv"; │ │ │ │ + OpenLayers.Element.addClass(this.layersDiv, "layersDiv"); │ │ │ │ + this.baseLbl = document.createElement("div"); │ │ │ │ + this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLbl, "baseLbl"); │ │ │ │ + this.baseLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv"); │ │ │ │ + this.dataLbl = document.createElement("div"); │ │ │ │ + this.dataLbl.innerHTML = OpenLayers.i18n("Overlays"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLbl, "dataLbl"); │ │ │ │ + this.dataLayersDiv = document.createElement("div"); │ │ │ │ + OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv"); │ │ │ │ + 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) │ │ │ │ } │ │ │ │ - return list │ │ │ │ + this.div.appendChild(this.layersDiv); │ │ │ │ + var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png"); │ │ │ │ + this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MaximizeDiv", null, null, img, "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton"); │ │ │ │ + this.maximizeDiv.style.display = "none"; │ │ │ │ + this.div.appendChild(this.maximizeDiv); │ │ │ │ + var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png"); │ │ │ │ + this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_MinimizeDiv", null, null, img, "absolute"); │ │ │ │ + OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton"); │ │ │ │ + this.minimizeDiv.style.display = "none"; │ │ │ │ + this.div.appendChild(this.minimizeDiv) │ │ │ │ }, │ │ │ │ - write_wmc_Layer: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("Layer", null, { │ │ │ │ - queryable: context.queryable ? "1" : "0", │ │ │ │ - hidden: context.visibility ? "0" : "1" │ │ │ │ - }); │ │ │ │ - node.appendChild(this.write_wmc_Server(context)); │ │ │ │ - node.appendChild(this.createElementDefaultNS("Name", context.name)); │ │ │ │ - node.appendChild(this.createElementDefaultNS("Title", context.title)); │ │ │ │ - if (context["abstract"]) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("Abstract", context["abstract"])) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.LayerSwitcher" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.TransformFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + geometryTypes: null, │ │ │ │ + layer: null, │ │ │ │ + preserveAspectRatio: false, │ │ │ │ + rotate: true, │ │ │ │ + feature: null, │ │ │ │ + renderIntent: "temporary", │ │ │ │ + rotationHandleSymbolizer: null, │ │ │ │ + box: null, │ │ │ │ + center: null, │ │ │ │ + scale: 1, │ │ │ │ + ratio: 1, │ │ │ │ + rotation: 0, │ │ │ │ + handles: null, │ │ │ │ + rotationHandles: null, │ │ │ │ + dragControl: null, │ │ │ │ + irregular: false, │ │ │ │ + initialize: function(layer, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.layer = layer; │ │ │ │ + if (!this.rotationHandleSymbolizer) { │ │ │ │ + this.rotationHandleSymbolizer = { │ │ │ │ + stroke: false, │ │ │ │ + pointRadius: 10, │ │ │ │ + fillOpacity: 0, │ │ │ │ + cursor: "pointer" │ │ │ │ + } │ │ │ │ } │ │ │ │ - if (context.dataURL) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("DataURL", context.dataURL)) │ │ │ │ + this.createBox(); │ │ │ │ + this.createControl() │ │ │ │ + }, │ │ │ │ + activate: function() { │ │ │ │ + var activated = false; │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragControl.activate(); │ │ │ │ + this.layer.addFeatures([this.box]); │ │ │ │ + this.rotate && this.layer.addFeatures(this.rotationHandles); │ │ │ │ + this.layer.addFeatures(this.handles); │ │ │ │ + activated = true │ │ │ │ } │ │ │ │ - if (context.metadataURL) { │ │ │ │ - node.appendChild(this.write_wmc_URLType("MetadataURL", context.metadataURL)) │ │ │ │ + return activated │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = false; │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.layer.removeFeatures(this.handles); │ │ │ │ + this.rotate && this.layer.removeFeatures(this.rotationHandles); │ │ │ │ + this.layer.removeFeatures([this.box]); │ │ │ │ + this.dragControl.deactivate(); │ │ │ │ + deactivated = true │ │ │ │ } │ │ │ │ - return node │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - write_wmc_LayerExtension: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("Extension"); │ │ │ │ - var bounds = context.maxExtent; │ │ │ │ - var maxExtent = this.createElementNS(this.namespaces.ol, "ol:maxExtent"); │ │ │ │ - this.setAttributes(maxExtent, { │ │ │ │ - minx: bounds.left.toPrecision(18), │ │ │ │ - miny: bounds.bottom.toPrecision(18), │ │ │ │ - maxx: bounds.right.toPrecision(18), │ │ │ │ - maxy: bounds.top.toPrecision(18) │ │ │ │ + setMap: function(map) { │ │ │ │ + this.dragControl.setMap(map); │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + setFeature: function(feature, initialParams) { │ │ │ │ + initialParams = OpenLayers.Util.applyDefaults(initialParams, { │ │ │ │ + rotation: 0, │ │ │ │ + scale: 1, │ │ │ │ + ratio: 1 │ │ │ │ }); │ │ │ │ - node.appendChild(maxExtent); │ │ │ │ - if (context.tileSize && !context.singleTile) { │ │ │ │ - var size = this.createElementNS(this.namespaces.ol, "ol:tileSize"); │ │ │ │ - this.setAttributes(size, context.tileSize); │ │ │ │ - node.appendChild(size) │ │ │ │ + var oldRotation = this.rotation; │ │ │ │ + var oldCenter = this.center; │ │ │ │ + OpenLayers.Util.extend(this, initialParams); │ │ │ │ + var cont = this.events.triggerEvent("beforesetfeature", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont === false) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - var properties = ["transparent", "numZoomLevels", "units", "isBaseLayer", "opacity", "displayInLayerSwitcher", "singleTile"]; │ │ │ │ - var child; │ │ │ │ - for (var i = 0, len = properties.length; i < len; ++i) { │ │ │ │ - child = this.createOLPropertyNode(context, properties[i]); │ │ │ │ - if (child) { │ │ │ │ - node.appendChild(child) │ │ │ │ - } │ │ │ │ + this.feature = feature; │ │ │ │ + this.activate(); │ │ │ │ + this._setfeature = true; │ │ │ │ + var featureBounds = this.feature.geometry.getBounds(); │ │ │ │ + this.box.move(featureBounds.getCenterLonLat()); │ │ │ │ + this.box.geometry.rotate(-oldRotation, oldCenter); │ │ │ │ + this._angle = 0; │ │ │ │ + var ll; │ │ │ │ + if (this.rotation) { │ │ │ │ + var geom = feature.geometry.clone(); │ │ │ │ + geom.rotate(-this.rotation, this.center); │ │ │ │ + var box = new OpenLayers.Feature.Vector(geom.getBounds().toGeometry()); │ │ │ │ + box.geometry.rotate(this.rotation, this.center); │ │ │ │ + this.box.geometry.rotate(this.rotation, this.center); │ │ │ │ + this.box.move(box.geometry.getBounds().getCenterLonLat()); │ │ │ │ + var llGeom = box.geometry.components[0].components[0]; │ │ │ │ + ll = llGeom.getBounds().getCenterLonLat() │ │ │ │ + } else { │ │ │ │ + ll = new OpenLayers.LonLat(featureBounds.left, featureBounds.bottom) │ │ │ │ } │ │ │ │ - return node │ │ │ │ + this.handles[0].move(ll); │ │ │ │ + delete this._setfeature; │ │ │ │ + this.events.triggerEvent("setfeature", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - createOLPropertyNode: function(obj, prop) { │ │ │ │ - var node = null; │ │ │ │ - if (obj[prop] != null) { │ │ │ │ - node = this.createElementNS(this.namespaces.ol, "ol:" + prop); │ │ │ │ - node.appendChild(this.createTextNode(obj[prop].toString())) │ │ │ │ + unsetFeature: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate() │ │ │ │ + } else { │ │ │ │ + this.feature = null; │ │ │ │ + this.rotation = 0; │ │ │ │ + this.scale = 1; │ │ │ │ + this.ratio = 1 │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - write_wmc_Server: function(context) { │ │ │ │ - var server = context.server; │ │ │ │ - var node = this.createElementDefaultNS("Server"); │ │ │ │ - var attributes = { │ │ │ │ - service: "OGC:WMS", │ │ │ │ - version: server.version │ │ │ │ + createBox: function() { │ │ │ │ + var control = this; │ │ │ │ + this.center = new OpenLayers.Geometry.Point(0, 0); │ │ │ │ + this.box = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString([new OpenLayers.Geometry.Point(-1, -1), new OpenLayers.Geometry.Point(0, -1), new OpenLayers.Geometry.Point(1, -1), new OpenLayers.Geometry.Point(1, 0), new OpenLayers.Geometry.Point(1, 1), new OpenLayers.Geometry.Point(0, 1), new OpenLayers.Geometry.Point(-1, 1), new OpenLayers.Geometry.Point(-1, 0), new OpenLayers.Geometry.Point(-1, -1)]), null, typeof this.renderIntent == "string" ? null : this.renderIntent); │ │ │ │ + this.box.geometry.move = function(x, y) { │ │ │ │ + control._moving = true; │ │ │ │ + OpenLayers.Geometry.LineString.prototype.move.apply(this, arguments); │ │ │ │ + control.center.move(x, y); │ │ │ │ + delete control._moving │ │ │ │ }; │ │ │ │ - if (server.title) { │ │ │ │ - attributes.title = server.title │ │ │ │ - } │ │ │ │ - this.setAttributes(node, attributes); │ │ │ │ - node.appendChild(this.write_wmc_OnlineResource(server.url)); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - write_wmc_URLType: function(elName, url, attr) { │ │ │ │ - var node = this.createElementDefaultNS(elName); │ │ │ │ - node.appendChild(this.write_wmc_OnlineResource(url)); │ │ │ │ - if (attr) { │ │ │ │ - var optionalAttributes = ["width", "height", "format"]; │ │ │ │ - for (var i = 0; i < optionalAttributes.length; i++) { │ │ │ │ - if (optionalAttributes[i] in attr) { │ │ │ │ - node.setAttribute(optionalAttributes[i], attr[optionalAttributes[i]]) │ │ │ │ - } │ │ │ │ + var vertexMoveFn = function(x, y) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.apply(this, arguments); │ │ │ │ + this._rotationHandle && this._rotationHandle.geometry.move(x, y); │ │ │ │ + this._handle.geometry.move(x, y) │ │ │ │ + }; │ │ │ │ + var vertexResizeFn = function(scale, center, ratio) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.resize.apply(this, arguments); │ │ │ │ + this._rotationHandle && this._rotationHandle.geometry.resize(scale, center, ratio); │ │ │ │ + this._handle.geometry.resize(scale, center, ratio) │ │ │ │ + }; │ │ │ │ + var vertexRotateFn = function(angle, center) { │ │ │ │ + OpenLayers.Geometry.Point.prototype.rotate.apply(this, arguments); │ │ │ │ + this._rotationHandle && this._rotationHandle.geometry.rotate(angle, center); │ │ │ │ + this._handle.geometry.rotate(angle, center) │ │ │ │ + }; │ │ │ │ + var handleMoveFn = function(x, y) { │ │ │ │ + var oldX = this.x, │ │ │ │ + oldY = this.y; │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + if (control._moving) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + var evt = control.dragControl.handlers.drag.evt; │ │ │ │ + var preserveAspectRatio = !control._setfeature && control.preserveAspectRatio; │ │ │ │ + var reshape = !preserveAspectRatio && !(evt && evt.shiftKey); │ │ │ │ + var oldGeom = new OpenLayers.Geometry.Point(oldX, oldY); │ │ │ │ + var centerGeometry = control.center; │ │ │ │ + this.rotate(-control.rotation, centerGeometry); │ │ │ │ + oldGeom.rotate(-control.rotation, centerGeometry); │ │ │ │ + var dx1 = this.x - centerGeometry.x; │ │ │ │ + var dy1 = this.y - centerGeometry.y; │ │ │ │ + var dx0 = dx1 - (this.x - oldGeom.x); │ │ │ │ + var dy0 = dy1 - (this.y - oldGeom.y); │ │ │ │ + if (control.irregular && !control._setfeature) { │ │ │ │ + dx1 -= (this.x - oldGeom.x) / 2; │ │ │ │ + dy1 -= (this.y - oldGeom.y) / 2 │ │ │ │ + } │ │ │ │ + this.x = oldX; │ │ │ │ + this.y = oldY; │ │ │ │ + var scale, ratio = 1; │ │ │ │ + if (reshape) { │ │ │ │ + scale = Math.abs(dy0) < 1e-5 ? 1 : dy1 / dy0; │ │ │ │ + ratio = (Math.abs(dx0) < 1e-5 ? 1 : dx1 / dx0) / scale │ │ │ │ + } else { │ │ │ │ + var l0 = Math.sqrt(dx0 * dx0 + dy0 * dy0); │ │ │ │ + var l1 = Math.sqrt(dx1 * dx1 + dy1 * dy1); │ │ │ │ + scale = l1 / l0 │ │ │ │ + } │ │ │ │ + control._moving = true; │ │ │ │ + control.box.geometry.rotate(-control.rotation, centerGeometry); │ │ │ │ + delete control._moving; │ │ │ │ + control.box.geometry.resize(scale, centerGeometry, ratio); │ │ │ │ + control.box.geometry.rotate(control.rotation, centerGeometry); │ │ │ │ + control.transformFeature({ │ │ │ │ + scale: scale, │ │ │ │ + ratio: ratio │ │ │ │ + }); │ │ │ │ + if (control.irregular && !control._setfeature) { │ │ │ │ + var newCenter = centerGeometry.clone(); │ │ │ │ + newCenter.x += Math.abs(oldX - centerGeometry.x) < 1e-5 ? 0 : this.x - oldX; │ │ │ │ + newCenter.y += Math.abs(oldY - centerGeometry.y) < 1e-5 ? 0 : this.y - oldY; │ │ │ │ + control.box.geometry.move(this.x - oldX, this.y - oldY); │ │ │ │ + control.transformFeature({ │ │ │ │ + center: newCenter │ │ │ │ + }) │ │ │ │ } │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - write_wmc_DimensionList: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("DimensionList"); │ │ │ │ - var required_attributes = { │ │ │ │ - name: true, │ │ │ │ - units: true, │ │ │ │ - unitSymbol: true, │ │ │ │ - userValue: true │ │ │ │ }; │ │ │ │ - for (var dim in context.dimensions) { │ │ │ │ - var attributes = {}; │ │ │ │ - var dimension = context.dimensions[dim]; │ │ │ │ - for (var name in dimension) { │ │ │ │ - if (typeof dimension[name] == "boolean") { │ │ │ │ - attributes[name] = Number(dimension[name]) │ │ │ │ - } else { │ │ │ │ - attributes[name] = dimension[name] │ │ │ │ - } │ │ │ │ + var rotationHandleMoveFn = function(x, y) { │ │ │ │ + var oldX = this.x, │ │ │ │ + oldY = this.y; │ │ │ │ + OpenLayers.Geometry.Point.prototype.move.call(this, x, y); │ │ │ │ + if (control._moving) { │ │ │ │ + return │ │ │ │ } │ │ │ │ - var values = ""; │ │ │ │ - if (attributes.values) { │ │ │ │ - values = attributes.values.join(","); │ │ │ │ - delete attributes.values │ │ │ │ + var evt = control.dragControl.handlers.drag.evt; │ │ │ │ + var constrain = evt && evt.shiftKey ? 45 : 1; │ │ │ │ + var centerGeometry = control.center; │ │ │ │ + var dx1 = this.x - centerGeometry.x; │ │ │ │ + var dy1 = this.y - centerGeometry.y; │ │ │ │ + var dx0 = dx1 - x; │ │ │ │ + var dy0 = dy1 - y; │ │ │ │ + this.x = oldX; │ │ │ │ + this.y = oldY; │ │ │ │ + var a0 = Math.atan2(dy0, dx0); │ │ │ │ + var a1 = Math.atan2(dy1, dx1); │ │ │ │ + var angle = a1 - a0; │ │ │ │ + angle *= 180 / Math.PI; │ │ │ │ + control._angle = (control._angle + angle) % 360; │ │ │ │ + var diff = control.rotation % constrain; │ │ │ │ + if (Math.abs(control._angle) >= constrain || diff !== 0) { │ │ │ │ + angle = Math.round(control._angle / constrain) * constrain - diff; │ │ │ │ + control._angle = 0; │ │ │ │ + control.box.geometry.rotate(angle, centerGeometry); │ │ │ │ + control.transformFeature({ │ │ │ │ + rotation: angle │ │ │ │ + }) │ │ │ │ } │ │ │ │ - node.appendChild(this.createElementDefaultNS("Dimension", values, attributes)) │ │ │ │ + }; │ │ │ │ + var handles = new Array(8); │ │ │ │ + var rotationHandles = new Array(4); │ │ │ │ + var geom, handle, rotationHandle; │ │ │ │ + var positions = ["sw", "s", "se", "e", "ne", "n", "nw", "w"]; │ │ │ │ + for (var i = 0; i < 8; ++i) { │ │ │ │ + geom = this.box.geometry.components[i]; │ │ │ │ + handle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ + role: positions[i] + "-resize" │ │ │ │ + }, typeof this.renderIntent == "string" ? null : this.renderIntent); │ │ │ │ + if (i % 2 == 0) { │ │ │ │ + rotationHandle = new OpenLayers.Feature.Vector(geom.clone(), { │ │ │ │ + role: positions[i] + "-rotate" │ │ │ │ + }, typeof this.rotationHandleSymbolizer == "string" ? null : this.rotationHandleSymbolizer); │ │ │ │ + rotationHandle.geometry.move = rotationHandleMoveFn; │ │ │ │ + geom._rotationHandle = rotationHandle; │ │ │ │ + rotationHandles[i / 2] = rotationHandle │ │ │ │ + } │ │ │ │ + geom.move = vertexMoveFn; │ │ │ │ + geom.resize = vertexResizeFn; │ │ │ │ + geom.rotate = vertexRotateFn; │ │ │ │ + handle.geometry.move = handleMoveFn; │ │ │ │ + geom._handle = handle; │ │ │ │ + handles[i] = handle │ │ │ │ } │ │ │ │ - return node │ │ │ │ + this.rotationHandles = rotationHandles; │ │ │ │ + this.handles = handles │ │ │ │ }, │ │ │ │ - write_wmc_FormatList: function(context) { │ │ │ │ - var node = this.createElementDefaultNS("FormatList"); │ │ │ │ - for (var i = 0, len = context.formats.length; i < len; i++) { │ │ │ │ - var format = context.formats[i]; │ │ │ │ - node.appendChild(this.createElementDefaultNS("Format", format.value, format.current && format.current == true ? { │ │ │ │ - current: "1" │ │ │ │ - } : null)) │ │ │ │ + createControl: function() { │ │ │ │ + var control = this; │ │ │ │ + this.dragControl = new OpenLayers.Control.DragFeature(this.layer, { │ │ │ │ + documentDrag: true, │ │ │ │ + moveFeature: function(pixel) { │ │ │ │ + if (this.feature === control.feature) { │ │ │ │ + this.feature = control.box │ │ │ │ + } │ │ │ │ + OpenLayers.Control.DragFeature.prototype.moveFeature.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + onDrag: function(feature, pixel) { │ │ │ │ + if (feature === control.box) { │ │ │ │ + control.transformFeature({ │ │ │ │ + center: control.center │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + onStart: function(feature, pixel) { │ │ │ │ + var eligible = !control.geometryTypes || OpenLayers.Util.indexOf(control.geometryTypes, feature.geometry.CLASS_NAME) !== -1; │ │ │ │ + var i = OpenLayers.Util.indexOf(control.handles, feature); │ │ │ │ + i += OpenLayers.Util.indexOf(control.rotationHandles, feature); │ │ │ │ + if (feature !== control.feature && feature !== control.box && i == -2 && eligible) { │ │ │ │ + control.setFeature(feature) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + onComplete: function(feature, pixel) { │ │ │ │ + control.events.triggerEvent("transformcomplete", { │ │ │ │ + feature: control.feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + drawHandles: function() { │ │ │ │ + var layer = this.layer; │ │ │ │ + for (var i = 0; i < 8; ++i) { │ │ │ │ + if (this.rotate && i % 2 === 0) { │ │ │ │ + layer.drawFeature(this.rotationHandles[i / 2], this.rotationHandleSymbolizer) │ │ │ │ + } │ │ │ │ + layer.drawFeature(this.handles[i], this.renderIntent) │ │ │ │ } │ │ │ │ - return node │ │ │ │ }, │ │ │ │ - write_wmc_StyleList: function(layer) { │ │ │ │ - var node = this.createElementDefaultNS("StyleList"); │ │ │ │ - var styles = layer.styles; │ │ │ │ - if (styles && OpenLayers.Util.isArray(styles)) { │ │ │ │ - var sld; │ │ │ │ - for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ - var s = styles[i]; │ │ │ │ - var style = this.createElementDefaultNS("Style", null, s.current && s.current == true ? { │ │ │ │ - current: "1" │ │ │ │ - } : null); │ │ │ │ - if (s.href) { │ │ │ │ - sld = this.createElementDefaultNS("SLD"); │ │ │ │ - if (s.name) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Name", s.name)) │ │ │ │ - } │ │ │ │ - if (s.title) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Title", s.title)) │ │ │ │ - } │ │ │ │ - if (s.legend) { │ │ │ │ - sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)) │ │ │ │ - } │ │ │ │ - var link = this.write_wmc_OnlineResource(s.href); │ │ │ │ - sld.appendChild(link); │ │ │ │ - style.appendChild(sld) │ │ │ │ - } else if (s.body) { │ │ │ │ - sld = this.createElementDefaultNS("SLD"); │ │ │ │ - if (s.name) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Name", s.name)) │ │ │ │ - } │ │ │ │ - if (s.title) { │ │ │ │ - sld.appendChild(this.createElementDefaultNS("Title", s.title)) │ │ │ │ - } │ │ │ │ - if (s.legend) { │ │ │ │ - sld.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)) │ │ │ │ - } │ │ │ │ - var doc = OpenLayers.Format.XML.prototype.read.apply(this, [s.body]); │ │ │ │ - var imported = doc.documentElement; │ │ │ │ - if (sld.ownerDocument && sld.ownerDocument.importNode) { │ │ │ │ - imported = sld.ownerDocument.importNode(imported, true) │ │ │ │ - } │ │ │ │ - sld.appendChild(imported); │ │ │ │ - style.appendChild(sld) │ │ │ │ - } else { │ │ │ │ - style.appendChild(this.createElementDefaultNS("Name", s.name)); │ │ │ │ - style.appendChild(this.createElementDefaultNS("Title", s.title)); │ │ │ │ - if (s["abstract"]) { │ │ │ │ - style.appendChild(this.createElementDefaultNS("Abstract", s["abstract"])) │ │ │ │ - } │ │ │ │ - if (s.legend) { │ │ │ │ - style.appendChild(this.write_wmc_URLType("LegendURL", s.legend.href, s.legend)) │ │ │ │ - } │ │ │ │ + transformFeature: function(mods) { │ │ │ │ + if (!this._setfeature) { │ │ │ │ + this.scale *= mods.scale || 1; │ │ │ │ + this.ratio *= mods.ratio || 1; │ │ │ │ + var oldRotation = this.rotation; │ │ │ │ + this.rotation = (this.rotation + (mods.rotation || 0)) % 360; │ │ │ │ + if (this.events.triggerEvent("beforetransform", mods) !== false) { │ │ │ │ + var feature = this.feature; │ │ │ │ + var geom = feature.geometry; │ │ │ │ + var center = this.center; │ │ │ │ + geom.rotate(-oldRotation, center); │ │ │ │ + if (mods.scale || mods.ratio) { │ │ │ │ + geom.resize(mods.scale, center, mods.ratio) │ │ │ │ + } else if (mods.center) { │ │ │ │ + feature.move(mods.center.getBounds().getCenterLonLat()) │ │ │ │ } │ │ │ │ - node.appendChild(style) │ │ │ │ + geom.rotate(this.rotation, center); │ │ │ │ + this.layer.drawFeature(feature); │ │ │ │ + feature.toState(OpenLayers.State.UPDATE); │ │ │ │ + this.events.triggerEvent("transform", mods) │ │ │ │ } │ │ │ │ } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - write_wmc_OnlineResource: function(href) { │ │ │ │ - var node = this.createElementDefaultNS("OnlineResource"); │ │ │ │ - this.setAttributeNS(node, this.namespaces.xlink, "xlink:type", "simple"); │ │ │ │ - this.setAttributeNS(node, this.namespaces.xlink, "xlink:href", href); │ │ │ │ - return node │ │ │ │ + this.layer.drawFeature(this.box, this.renderIntent); │ │ │ │ + this.drawHandles() │ │ │ │ }, │ │ │ │ - getOnlineResource_href: function(node) { │ │ │ │ - var object = {}; │ │ │ │ - var links = node.getElementsByTagName("OnlineResource"); │ │ │ │ - if (links.length > 0) { │ │ │ │ - this.read_wmc_OnlineResource(object, links[0]) │ │ │ │ + destroy: function() { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0; i < 8; ++i) { │ │ │ │ + geom = this.box.geometry.components[i]; │ │ │ │ + geom._handle.destroy(); │ │ │ │ + geom._handle = null; │ │ │ │ + geom._rotationHandle && geom._rotationHandle.destroy(); │ │ │ │ + geom._rotationHandle = null │ │ │ │ } │ │ │ │ - return object.href │ │ │ │ + this.center = null; │ │ │ │ + this.feature = null; │ │ │ │ + this.handles = null; │ │ │ │ + this.rotationHandleSymbolizer = null; │ │ │ │ + this.rotationHandles = null; │ │ │ │ + this.box.destroy(); │ │ │ │ + this.box = null; │ │ │ │ + this.layer = null; │ │ │ │ + this.dragControl.destroy(); │ │ │ │ + this.dragControl = null; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC.v1" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.TransformFeature" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WMC.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WMC.v1, { │ │ │ │ - VERSION: "1.1.0", │ │ │ │ - schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.1.0/context.xsd", │ │ │ │ +OpenLayers.Control.PanPanel = OpenLayers.Class(OpenLayers.Control.Panel, { │ │ │ │ + slideFactor: 50, │ │ │ │ + slideRatio: null, │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Format.WMC.v1.prototype.initialize.apply(this, [options]) │ │ │ │ - }, │ │ │ │ - read_sld_MinScaleDenominator: function(layerContext, node) { │ │ │ │ - var minScaleDenominator = parseFloat(this.getChildValue(node)); │ │ │ │ - if (minScaleDenominator > 0) { │ │ │ │ - layerContext.maxScale = minScaleDenominator │ │ │ │ - } │ │ │ │ + OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]); │ │ │ │ + var options = { │ │ │ │ + slideFactor: this.slideFactor, │ │ │ │ + slideRatio: this.slideRatio │ │ │ │ + }; │ │ │ │ + this.addControls([new OpenLayers.Control.Pan(OpenLayers.Control.Pan.NORTH, options), new OpenLayers.Control.Pan(OpenLayers.Control.Pan.SOUTH, options), new OpenLayers.Control.Pan(OpenLayers.Control.Pan.EAST, options), new OpenLayers.Control.Pan(OpenLayers.Control.Pan.WEST, options)]) │ │ │ │ }, │ │ │ │ - read_sld_MaxScaleDenominator: function(layerContext, node) { │ │ │ │ - layerContext.minScale = parseFloat(this.getChildValue(node)) │ │ │ │ + CLASS_NAME: "OpenLayers.Control.PanPanel" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.MousePosition = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + autoActivate: true, │ │ │ │ + element: null, │ │ │ │ + prefix: "", │ │ │ │ + separator: ", ", │ │ │ │ + suffix: "", │ │ │ │ + numDigits: 5, │ │ │ │ + granularity: 10, │ │ │ │ + emptyString: null, │ │ │ │ + lastXy: null, │ │ │ │ + displayProjection: null, │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - read_wmc_SRS: function(layerContext, node) { │ │ │ │ - if (!("srs" in layerContext)) { │ │ │ │ - layerContext.srs = {} │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.map.events.register("mousemove", this, this.redraw); │ │ │ │ + this.map.events.register("mouseout", this, this.reset); │ │ │ │ + this.redraw(); │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - layerContext.srs[this.getChildValue(node)] = true │ │ │ │ }, │ │ │ │ - write_wmc_Layer: function(context) { │ │ │ │ - var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply(this, [context]); │ │ │ │ - if (context.maxScale) { │ │ │ │ - var minSD = this.createElementNS(this.namespaces.sld, "sld:MinScaleDenominator"); │ │ │ │ - minSD.appendChild(this.createTextNode(context.maxScale.toPrecision(16))); │ │ │ │ - node.appendChild(minSD) │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.map.events.unregister("mousemove", this, this.redraw); │ │ │ │ + this.map.events.unregister("mouseout", this, this.reset); │ │ │ │ + this.element.innerHTML = ""; │ │ │ │ + return true │ │ │ │ + } else { │ │ │ │ + return false │ │ │ │ } │ │ │ │ - if (context.minScale) { │ │ │ │ - var maxSD = this.createElementNS(this.namespaces.sld, "sld:MaxScaleDenominator"); │ │ │ │ - maxSD.appendChild(this.createTextNode(context.minScale.toPrecision(16))); │ │ │ │ - node.appendChild(maxSD) │ │ │ │ + }, │ │ │ │ + draw: function() { │ │ │ │ + OpenLayers.Control.prototype.draw.apply(this, arguments); │ │ │ │ + if (!this.element) { │ │ │ │ + this.div.left = ""; │ │ │ │ + this.div.top = ""; │ │ │ │ + this.element = this.div │ │ │ │ } │ │ │ │ - if (context.srs) { │ │ │ │ - for (var name in context.srs) { │ │ │ │ - node.appendChild(this.createElementDefaultNS("SRS", name)) │ │ │ │ + return this.div │ │ │ │ + }, │ │ │ │ + redraw: function(evt) { │ │ │ │ + var lonLat; │ │ │ │ + if (evt == null) { │ │ │ │ + this.reset(); │ │ │ │ + return │ │ │ │ + } 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) { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if (this.displayProjection) { │ │ │ │ + lonLat.transform(this.map.getProjectionObject(), this.displayProjection) │ │ │ │ } │ │ │ │ + this.lastXy = evt.xy │ │ │ │ } │ │ │ │ - node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ - node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ - if (context.dimensions) { │ │ │ │ - node.appendChild(this.write_wmc_DimensionList(context)) │ │ │ │ + var newHtml = this.formatOutput(lonLat); │ │ │ │ + if (newHtml != this.element.innerHTML) { │ │ │ │ + this.element.innerHTML = newHtml │ │ │ │ } │ │ │ │ - node.appendChild(this.write_wmc_LayerExtension(context)); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC.v1_1_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WMC.v1_0_0 = OpenLayers.Class(OpenLayers.Format.WMC.v1, { │ │ │ │ - VERSION: "1.0.0", │ │ │ │ - schemaLocation: "http://www.opengis.net/context http://schemas.opengis.net/context/1.0.0/context.xsd", │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.WMC.v1.prototype.initialize.apply(this, [options]) │ │ │ │ }, │ │ │ │ - read_wmc_SRS: function(layerContext, node) { │ │ │ │ - var srs = this.getChildValue(node); │ │ │ │ - if (typeof layerContext.projections != "object") { │ │ │ │ - layerContext.projections = {} │ │ │ │ + reset: function(evt) { │ │ │ │ + if (this.emptyString != null) { │ │ │ │ + this.element.innerHTML = this.emptyString │ │ │ │ } │ │ │ │ - var values = srs.split(/ +/); │ │ │ │ - for (var i = 0, len = values.length; i < len; i++) { │ │ │ │ - layerContext.projections[values[i]] = true │ │ │ │ + }, │ │ │ │ + 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 │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.MousePosition" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + zoomInText: "+", │ │ │ │ + zoomInId: "olZoomInLink", │ │ │ │ + zoomOutText: "−", │ │ │ │ + zoomOutId: "olZoomOutLink", │ │ │ │ + draw: function() { │ │ │ │ + var div = OpenLayers.Control.prototype.draw.apply(this), │ │ │ │ + links = this.getOrCreateLinks(div), │ │ │ │ + zoomIn = links.zoomIn, │ │ │ │ + zoomOut = links.zoomOut, │ │ │ │ + eventsInstance = this.map.events; │ │ │ │ + if (zoomOut.parentNode !== div) { │ │ │ │ + eventsInstance = this.events; │ │ │ │ + eventsInstance.attachToElement(zoomOut.parentNode) │ │ │ │ } │ │ │ │ + eventsInstance.register("buttonclick", this, this.onZoomClick); │ │ │ │ + this.zoomInLink = zoomIn; │ │ │ │ + this.zoomOutLink = zoomOut; │ │ │ │ + return div │ │ │ │ }, │ │ │ │ - write_wmc_Layer: function(context) { │ │ │ │ - var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply(this, [context]); │ │ │ │ - if (context.srs) { │ │ │ │ - var projections = []; │ │ │ │ - for (var name in context.srs) { │ │ │ │ - projections.push(name) │ │ │ │ - } │ │ │ │ - node.appendChild(this.createElementDefaultNS("SRS", projections.join(" "))) │ │ │ │ + getOrCreateLinks: function(el) { │ │ │ │ + var zoomIn = document.getElementById(this.zoomInId), │ │ │ │ + zoomOut = document.getElementById(this.zoomOutId); │ │ │ │ + if (!zoomIn) { │ │ │ │ + zoomIn = document.createElement("a"); │ │ │ │ + zoomIn.href = "#zoomIn"; │ │ │ │ + zoomIn.appendChild(document.createTextNode(this.zoomInText)); │ │ │ │ + zoomIn.className = "olControlZoomIn"; │ │ │ │ + el.appendChild(zoomIn) │ │ │ │ } │ │ │ │ - node.appendChild(this.write_wmc_FormatList(context)); │ │ │ │ - node.appendChild(this.write_wmc_StyleList(context)); │ │ │ │ - if (context.dimensions) { │ │ │ │ - node.appendChild(this.write_wmc_DimensionList(context)) │ │ │ │ + OpenLayers.Element.addClass(zoomIn, "olButton"); │ │ │ │ + if (!zoomOut) { │ │ │ │ + zoomOut = document.createElement("a"); │ │ │ │ + zoomOut.href = "#zoomOut"; │ │ │ │ + zoomOut.appendChild(document.createTextNode(this.zoomOutText)); │ │ │ │ + zoomOut.className = "olControlZoomOut"; │ │ │ │ + el.appendChild(zoomOut) │ │ │ │ + } │ │ │ │ + OpenLayers.Element.addClass(zoomOut, "olButton"); │ │ │ │ + return { │ │ │ │ + zoomIn: zoomIn, │ │ │ │ + zoomOut: zoomOut │ │ │ │ } │ │ │ │ - node.appendChild(this.write_wmc_LayerExtension(context)) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WMC.v1_0_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WCSCapabilities.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - splitSpace: /\s+/ │ │ │ │ }, │ │ │ │ - defaultPrefix: "wcs", │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + onZoomClick: function(evt) { │ │ │ │ + var button = evt.buttonElement; │ │ │ │ + if (button === this.zoomInLink) { │ │ │ │ + this.map.zoomIn() │ │ │ │ + } else if (button === this.zoomOutLink) { │ │ │ │ + this.map.zoomOut() │ │ │ │ } │ │ │ │ - var raw = data; │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + }, │ │ │ │ + destroy: function() { │ │ │ │ + if (this.map) { │ │ │ │ + this.map.events.unregister("buttonclick", this, this.onZoomClick) │ │ │ │ } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities │ │ │ │ + delete this.zoomInLink; │ │ │ │ + delete this.zoomOutLink; │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Zoom" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WCSCapabilities.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ - namespaces: { │ │ │ │ - wcs: "http://www.opengis.net/wcs/1.1", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - ows: "http://www.opengis.net/ows/1.1" │ │ │ │ +OpenLayers.Control.PinchZoom = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + type: OpenLayers.Control.TYPE_TOOL, │ │ │ │ + pinchOrigin: null, │ │ │ │ + currentCenter: null, │ │ │ │ + autoActivate: true, │ │ │ │ + preserveCenter: false, │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments); │ │ │ │ + this.handler = new OpenLayers.Handler.Pinch(this, { │ │ │ │ + start: this.pinchStart, │ │ │ │ + move: this.pinchMove, │ │ │ │ + done: this.pinchDone │ │ │ │ + }, this.handlerOptions) │ │ │ │ }, │ │ │ │ - errorProperty: "operationsMetadata", │ │ │ │ - readers: { │ │ │ │ - wcs: OpenLayers.Util.applyDefaults({ │ │ │ │ - Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Contents: function(node, request) { │ │ │ │ - request.contentMetadata = []; │ │ │ │ - this.readChildNodes(node, request.contentMetadata) │ │ │ │ - }, │ │ │ │ - CoverageSummary: function(node, contentMetadata) { │ │ │ │ - var coverageSummary = {}; │ │ │ │ - this.readChildNodes(node, coverageSummary); │ │ │ │ - contentMetadata.push(coverageSummary) │ │ │ │ - }, │ │ │ │ - Identifier: function(node, coverageSummary) { │ │ │ │ - coverageSummary.identifier = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Title: function(node, coverageSummary) { │ │ │ │ - coverageSummary.title = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - Abstract: function(node, coverageSummary) { │ │ │ │ - coverageSummary["abstract"] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - SupportedCRS: function(node, coverageSummary) { │ │ │ │ - var crs = this.getChildValue(node); │ │ │ │ - if (crs) { │ │ │ │ - if (!coverageSummary.supportedCRS) { │ │ │ │ - coverageSummary.supportedCRS = [] │ │ │ │ - } │ │ │ │ - coverageSummary.supportedCRS.push(crs) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - SupportedFormat: function(node, coverageSummary) { │ │ │ │ - var format = this.getChildValue(node); │ │ │ │ - if (format) { │ │ │ │ - if (!coverageSummary.supportedFormat) { │ │ │ │ - coverageSummary.supportedFormat = [] │ │ │ │ - } │ │ │ │ - coverageSummary.supportedFormat.push(format) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WCSCapabilities.v1.prototype.readers["wcs"]), │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ + pinchStart: function(evt, pinchData) { │ │ │ │ + var xy = this.preserveCenter ? this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ + this.pinchOrigin = xy; │ │ │ │ + this.currentCenter = xy │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_1_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WCSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.WCSCapabilities.v1, { │ │ │ │ - namespaces: { │ │ │ │ - wcs: "http://www.opengis.net/wcs", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - ows: "http://www.opengis.net/ows" │ │ │ │ + pinchMove: function(evt, pinchData) { │ │ │ │ + var scale = pinchData.scale; │ │ │ │ + var containerOrigin = this.map.layerContainerOriginPx; │ │ │ │ + var pinchOrigin = this.pinchOrigin; │ │ │ │ + var current = this.preserveCenter ? this.map.getPixelFromLonLat(this.map.getCenter()) : evt.xy; │ │ │ │ + var dx = Math.round(containerOrigin.x + current.x - pinchOrigin.x + (scale - 1) * (containerOrigin.x - pinchOrigin.x)); │ │ │ │ + var dy = Math.round(containerOrigin.y + current.y - pinchOrigin.y + (scale - 1) * (containerOrigin.y - pinchOrigin.y)); │ │ │ │ + this.map.applyTransform(dx, dy, scale); │ │ │ │ + this.currentCenter = current │ │ │ │ }, │ │ │ │ - errorProperty: "service", │ │ │ │ - readers: { │ │ │ │ - wcs: { │ │ │ │ - WCS_Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Service: function(node, obj) { │ │ │ │ - obj.service = {}; │ │ │ │ - this.readChildNodes(node, obj.service) │ │ │ │ - }, │ │ │ │ - name: function(node, service) { │ │ │ │ - service.name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - label: function(node, service) { │ │ │ │ - service.label = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - keywords: function(node, service) { │ │ │ │ - service.keywords = []; │ │ │ │ - this.readChildNodes(node, service.keywords) │ │ │ │ - }, │ │ │ │ - keyword: function(node, keywords) { │ │ │ │ - keywords.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - responsibleParty: function(node, service) { │ │ │ │ - service.responsibleParty = {}; │ │ │ │ - this.readChildNodes(node, service.responsibleParty) │ │ │ │ - }, │ │ │ │ - individualName: function(node, responsibleParty) { │ │ │ │ - responsibleParty.individualName = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - organisationName: function(node, responsibleParty) { │ │ │ │ - responsibleParty.organisationName = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - positionName: function(node, responsibleParty) { │ │ │ │ - responsibleParty.positionName = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - contactInfo: function(node, responsibleParty) { │ │ │ │ - responsibleParty.contactInfo = {}; │ │ │ │ - this.readChildNodes(node, responsibleParty.contactInfo) │ │ │ │ - }, │ │ │ │ - phone: function(node, contactInfo) { │ │ │ │ - contactInfo.phone = {}; │ │ │ │ - this.readChildNodes(node, contactInfo.phone) │ │ │ │ - }, │ │ │ │ - voice: function(node, phone) { │ │ │ │ - phone.voice = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - facsimile: function(node, phone) { │ │ │ │ - phone.facsimile = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - address: function(node, contactInfo) { │ │ │ │ - contactInfo.address = {}; │ │ │ │ - this.readChildNodes(node, contactInfo.address) │ │ │ │ - }, │ │ │ │ - deliveryPoint: function(node, address) { │ │ │ │ - address.deliveryPoint = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - city: function(node, address) { │ │ │ │ - address.city = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - postalCode: function(node, address) { │ │ │ │ - address.postalCode = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - country: function(node, address) { │ │ │ │ - address.country = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - electronicMailAddress: function(node, address) { │ │ │ │ - address.electronicMailAddress = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - fees: function(node, service) { │ │ │ │ - service.fees = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - accessConstraints: function(node, service) { │ │ │ │ - service.accessConstraints = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - ContentMetadata: function(node, obj) { │ │ │ │ - obj.contentMetadata = []; │ │ │ │ - this.readChildNodes(node, obj.contentMetadata) │ │ │ │ - }, │ │ │ │ - CoverageOfferingBrief: function(node, contentMetadata) { │ │ │ │ - var coverageOfferingBrief = {}; │ │ │ │ - this.readChildNodes(node, coverageOfferingBrief); │ │ │ │ - contentMetadata.push(coverageOfferingBrief) │ │ │ │ - }, │ │ │ │ - name: function(node, coverageOfferingBrief) { │ │ │ │ - coverageOfferingBrief.name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - label: function(node, coverageOfferingBrief) { │ │ │ │ - coverageOfferingBrief.label = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - lonLatEnvelope: function(node, coverageOfferingBrief) { │ │ │ │ - var nodeList = this.getElementsByTagNameNS(node, "http://www.opengis.net/gml", "pos"); │ │ │ │ - if (nodeList.length == 2) { │ │ │ │ - var min = {}; │ │ │ │ - var max = {}; │ │ │ │ - OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[0], min]); │ │ │ │ - OpenLayers.Format.GML.v3.prototype.readers["gml"].pos.apply(this, [nodeList[1], max]); │ │ │ │ - coverageOfferingBrief.lonLatEnvelope = {}; │ │ │ │ - coverageOfferingBrief.lonLatEnvelope.srsName = node.getAttribute("srsName"); │ │ │ │ - coverageOfferingBrief.lonLatEnvelope.min = min.points[0]; │ │ │ │ - coverageOfferingBrief.lonLatEnvelope.max = max.points[0] │ │ │ │ - } │ │ │ │ - } │ │ │ │ + pinchDone: function(evt, start, last) { │ │ │ │ + this.map.applyTransform(); │ │ │ │ + var zoom = this.map.getZoomForResolution(this.map.getResolution() / last.scale, true); │ │ │ │ + if (zoom !== this.map.getZoom() || !this.currentCenter.equals(this.pinchOrigin)) { │ │ │ │ + var resolution = this.map.getResolutionForZoom(zoom); │ │ │ │ + var location = this.map.getLonLatFromPixel(this.pinchOrigin); │ │ │ │ + var zoomPixel = this.currentCenter; │ │ │ │ + var size = this.map.getSize(); │ │ │ │ + location.lon += resolution * (size.w / 2 - zoomPixel.x); │ │ │ │ + location.lat -= resolution * (size.h / 2 - zoomPixel.y); │ │ │ │ + this.map.div.clientWidth = this.map.div.clientWidth; │ │ │ │ + this.map.setCenter(location, zoom) │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WCSCapabilities.v1_0_0" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.PinchZoom" │ │ │ │ }); │ │ │ │ -OpenLayers.Format.WFSCapabilities.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - wfs: "http://www.opengis.net/wfs", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance", │ │ │ │ - ows: "http://www.opengis.net/ows" │ │ │ │ +OpenLayers.Control.TouchNavigation = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + dragPan: null, │ │ │ │ + dragPanOptions: null, │ │ │ │ + pinchZoom: null, │ │ │ │ + pinchZoomOptions: null, │ │ │ │ + clickHandlerOptions: null, │ │ │ │ + documentDrag: false, │ │ │ │ + autoActivate: true, │ │ │ │ + initialize: function(options) { │ │ │ │ + this.handlers = {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, arguments) │ │ │ │ }, │ │ │ │ - errorProperty: "featureTypeList", │ │ │ │ - defaultPrefix: "wfs", │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.dragPan) { │ │ │ │ + this.dragPan.destroy() │ │ │ │ } │ │ │ │ - var raw = data; │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + this.dragPan = null; │ │ │ │ + if (this.pinchZoom) { │ │ │ │ + this.pinchZoom.destroy(); │ │ │ │ + delete this.pinchZoom │ │ │ │ } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - readers: { │ │ │ │ - wfs: { │ │ │ │ - WFS_Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - FeatureTypeList: function(node, request) { │ │ │ │ - request.featureTypeList = { │ │ │ │ - featureTypes: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, request.featureTypeList) │ │ │ │ - }, │ │ │ │ - FeatureType: function(node, featureTypeList) { │ │ │ │ - var featureType = {}; │ │ │ │ - this.readChildNodes(node, featureType); │ │ │ │ - featureTypeList.featureTypes.push(featureType) │ │ │ │ - }, │ │ │ │ - Name: function(node, obj) { │ │ │ │ - var name = this.getChildValue(node); │ │ │ │ - if (name) { │ │ │ │ - var parts = name.split(":"); │ │ │ │ - obj.name = parts.pop(); │ │ │ │ - if (parts.length > 0) { │ │ │ │ - obj.featureNS = this.lookupNamespaceURI(node, parts[0]) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Title: function(node, obj) { │ │ │ │ - var title = this.getChildValue(node); │ │ │ │ - if (title) { │ │ │ │ - obj.title = title │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Abstract: function(node, obj) { │ │ │ │ - var abst = this.getChildValue(node); │ │ │ │ - if (abst) { │ │ │ │ - obj["abstract"] = abst │ │ │ │ - } │ │ │ │ - } │ │ │ │ + activate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + this.dragPan.activate(); │ │ │ │ + this.handlers.click.activate(); │ │ │ │ + this.pinchZoom.activate(); │ │ │ │ + return true │ │ │ │ } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WFSCapabilities.v1_1_0 = OpenLayers.Class(OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ - DefaultSRS: function(node, obj) { │ │ │ │ - var defaultSRS = this.getChildValue(node); │ │ │ │ - if (defaultSRS) { │ │ │ │ - obj.srs = defaultSRS │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]), │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1.prototype.readers.ows │ │ │ │ + deactivate: function() { │ │ │ │ + if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { │ │ │ │ + this.dragPan.deactivate(); │ │ │ │ + this.handlers.click.deactivate(); │ │ │ │ + this.pinchZoom.deactivate(); │ │ │ │ + return true │ │ │ │ + } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_1_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.WFSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.WFSCapabilities.v1, { │ │ │ │ - readers: { │ │ │ │ - wfs: OpenLayers.Util.applyDefaults({ │ │ │ │ - Service: function(node, capabilities) { │ │ │ │ - capabilities.service = {}; │ │ │ │ - this.readChildNodes(node, capabilities.service) │ │ │ │ - }, │ │ │ │ - Fees: function(node, service) { │ │ │ │ - var fees = this.getChildValue(node); │ │ │ │ - if (fees && fees.toLowerCase() != "none") { │ │ │ │ - service.fees = fees │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - AccessConstraints: function(node, service) { │ │ │ │ - var constraints = this.getChildValue(node); │ │ │ │ - if (constraints && constraints.toLowerCase() != "none") { │ │ │ │ - service.accessConstraints = constraints │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - OnlineResource: function(node, service) { │ │ │ │ - var onlineResource = this.getChildValue(node); │ │ │ │ - if (onlineResource && onlineResource.toLowerCase() != "none") { │ │ │ │ - service.onlineResource = onlineResource │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Keywords: function(node, service) { │ │ │ │ - var keywords = this.getChildValue(node); │ │ │ │ - if (keywords && keywords.toLowerCase() != "none") { │ │ │ │ - service.keywords = keywords.split(", ") │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Capability: function(node, capabilities) { │ │ │ │ - capabilities.capability = {}; │ │ │ │ - this.readChildNodes(node, capabilities.capability) │ │ │ │ - }, │ │ │ │ - Request: function(node, obj) { │ │ │ │ - obj.request = {}; │ │ │ │ - this.readChildNodes(node, obj.request) │ │ │ │ - }, │ │ │ │ - GetFeature: function(node, request) { │ │ │ │ - request.getfeature = { │ │ │ │ - href: {}, │ │ │ │ - formats: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, request.getfeature) │ │ │ │ - }, │ │ │ │ - ResultFormat: function(node, obj) { │ │ │ │ - var children = node.childNodes; │ │ │ │ - var childNode; │ │ │ │ - for (var i = 0; i < children.length; i++) { │ │ │ │ - childNode = children[i]; │ │ │ │ - if (childNode.nodeType == 1) { │ │ │ │ - obj.formats.push(childNode.nodeName) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - DCPType: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - HTTP: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj.href) │ │ │ │ - }, │ │ │ │ - Get: function(node, obj) { │ │ │ │ - obj.get = node.getAttribute("onlineResource") │ │ │ │ - }, │ │ │ │ - Post: function(node, obj) { │ │ │ │ - obj.post = node.getAttribute("onlineResource") │ │ │ │ - }, │ │ │ │ - SRS: function(node, obj) { │ │ │ │ - var srs = this.getChildValue(node); │ │ │ │ - if (srs) { │ │ │ │ - obj.srs = srs │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.WFSCapabilities.v1.prototype.readers["wfs"]) │ │ │ │ + draw: function() { │ │ │ │ + var clickCallbacks = { │ │ │ │ + click: this.defaultClick, │ │ │ │ + dblclick: this.defaultDblClick │ │ │ │ + }; │ │ │ │ + var clickOptions = OpenLayers.Util.extend({ │ │ │ │ + double: true, │ │ │ │ + stopDouble: true, │ │ │ │ + pixelTolerance: 2 │ │ │ │ + }, this.clickHandlerOptions); │ │ │ │ + this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks, clickOptions); │ │ │ │ + this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend({ │ │ │ │ + map: this.map, │ │ │ │ + documentDrag: this.documentDrag │ │ │ │ + }, this.dragPanOptions)); │ │ │ │ + this.dragPan.draw(); │ │ │ │ + this.pinchZoom = new OpenLayers.Control.PinchZoom(OpenLayers.Util.extend({ │ │ │ │ + map: this.map │ │ │ │ + }, this.pinchZoomOptions)) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.WFSCapabilities.v1_0_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.SOSCapabilities.v1_0_0 = OpenLayers.Class(OpenLayers.Format.SOSCapabilities, { │ │ │ │ - namespaces: { │ │ │ │ - ows: "http://www.opengis.net/ows/1.1", │ │ │ │ - sos: "http://www.opengis.net/sos/1.0", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink" │ │ │ │ + defaultClick: function(evt) { │ │ │ │ + if (evt.lastTouches && evt.lastTouches.length == 2) { │ │ │ │ + this.map.zoomOut() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ + defaultDblClick: function(evt) { │ │ │ │ + this.map.zoomTo(this.map.zoom + 1, evt.xy) │ │ │ │ }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.TouchNavigation" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.WMTSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + hover: false, │ │ │ │ + requestEncoding: "KVP", │ │ │ │ + drillDown: false, │ │ │ │ + maxFeatures: 10, │ │ │ │ + clickCallback: "click", │ │ │ │ + layers: null, │ │ │ │ + queryVisible: true, │ │ │ │ + infoFormat: "text/html", │ │ │ │ + vendorParams: {}, │ │ │ │ + format: null, │ │ │ │ + formatOptions: null, │ │ │ │ + handler: null, │ │ │ │ + hoverRequest: null, │ │ │ │ + pending: 0, │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - this.options = options │ │ │ │ - }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ + options = options || {}; │ │ │ │ + options.handlerOptions = options.handlerOptions || {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (!this.format) { │ │ │ │ + this.format = new OpenLayers.Format.WMSGetFeatureInfo(options.formatOptions) │ │ │ │ } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ + if (this.drillDown === true) { │ │ │ │ + this.hover = false │ │ │ │ + } │ │ │ │ + if (this.hover) { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ + move: this.cancelHover, │ │ │ │ + pause: this.getInfoForHover │ │ │ │ + }, OpenLayers.Util.extend(this.handlerOptions.hover || {}, { │ │ │ │ + delay: 250 │ │ │ │ + })) │ │ │ │ + } else { │ │ │ │ + var callbacks = {}; │ │ │ │ + callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ + this.handler = new OpenLayers.Handler.Click(this, callbacks, this.handlerOptions.click || {}) │ │ │ │ } │ │ │ │ - var capabilities = {}; │ │ │ │ - this.readNode(data, capabilities); │ │ │ │ - return capabilities │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - gml: OpenLayers.Util.applyDefaults({ │ │ │ │ - name: function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - TimePeriod: function(node, obj) { │ │ │ │ - obj.timePeriod = {}; │ │ │ │ - this.readChildNodes(node, obj.timePeriod) │ │ │ │ - }, │ │ │ │ - beginPosition: function(node, timePeriod) { │ │ │ │ - timePeriod.beginPosition = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - endPosition: function(node, timePeriod) { │ │ │ │ - timePeriod.endPosition = this.getChildValue(node) │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.v3.prototype.readers["gml"]), │ │ │ │ - sos: { │ │ │ │ - Capabilities: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Contents: function(node, obj) { │ │ │ │ - obj.contents = {}; │ │ │ │ - this.readChildNodes(node, obj.contents) │ │ │ │ - }, │ │ │ │ - ObservationOfferingList: function(node, contents) { │ │ │ │ - contents.offeringList = {}; │ │ │ │ - this.readChildNodes(node, contents.offeringList) │ │ │ │ - }, │ │ │ │ - ObservationOffering: function(node, offeringList) { │ │ │ │ - var id = this.getAttributeNS(node, this.namespaces.gml, "id"); │ │ │ │ - offeringList[id] = { │ │ │ │ - procedures: [], │ │ │ │ - observedProperties: [], │ │ │ │ - featureOfInterestIds: [], │ │ │ │ - responseFormats: [], │ │ │ │ - resultModels: [], │ │ │ │ - responseModes: [] │ │ │ │ - }; │ │ │ │ - this.readChildNodes(node, offeringList[id]) │ │ │ │ - }, │ │ │ │ - time: function(node, offering) { │ │ │ │ - offering.time = {}; │ │ │ │ - this.readChildNodes(node, offering.time) │ │ │ │ - }, │ │ │ │ - procedure: function(node, offering) { │ │ │ │ - offering.procedures.push(this.getAttributeNS(node, this.namespaces.xlink, "href")) │ │ │ │ - }, │ │ │ │ - observedProperty: function(node, offering) { │ │ │ │ - offering.observedProperties.push(this.getAttributeNS(node, this.namespaces.xlink, "href")) │ │ │ │ - }, │ │ │ │ - featureOfInterest: function(node, offering) { │ │ │ │ - offering.featureOfInterestIds.push(this.getAttributeNS(node, this.namespaces.xlink, "href")) │ │ │ │ - }, │ │ │ │ - responseFormat: function(node, offering) { │ │ │ │ - offering.responseFormats.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - resultModel: function(node, offering) { │ │ │ │ - offering.resultModels.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - responseMode: function(node, offering) { │ │ │ │ - offering.responseModes.push(this.getChildValue(node)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1_1_0.prototype.readers["ows"] │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.SOSCapabilities.v1_0_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.OWSContext.v0_3_1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - owc: "http://www.opengis.net/ows-context", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - kml: "http://www.opengis.net/kml/2.2", │ │ │ │ - ogc: "http://www.opengis.net/ogc", │ │ │ │ - ows: "http://www.opengis.net/ows", │ │ │ │ - sld: "http://www.opengis.net/sld", │ │ │ │ - xlink: "http://www.w3.org/1999/xlink", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - VERSION: "0.3.1", │ │ │ │ - schemaLocation: "http://www.opengis.net/ows-context http://www.ogcnetwork.net/schemas/owc/0.3.1/owsContext.xsd", │ │ │ │ - defaultPrefix: "owc", │ │ │ │ - extractAttributes: true, │ │ │ │ - xy: true, │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ }, │ │ │ │ - featureNS: "http://mapserver.gis.umn.edu/mapserver", │ │ │ │ - featureType: "vector", │ │ │ │ - geometryName: "geometry", │ │ │ │ - nestingLayerLookup: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); │ │ │ │ - OpenLayers.Format.GML.v2.prototype.setGeometryTypes.call(this) │ │ │ │ + getInfoForClick: function(evt) { │ │ │ │ + this.request(evt.xy, {}) │ │ │ │ }, │ │ │ │ - setNestingPath: function(l) { │ │ │ │ - if (l.layersContext) { │ │ │ │ - for (var i = 0, len = l.layersContext.length; i < len; i++) { │ │ │ │ - var layerContext = l.layersContext[i]; │ │ │ │ - var nPath = []; │ │ │ │ - var nTitle = l.title || ""; │ │ │ │ - if (l.metadata && l.metadata.nestingPath) { │ │ │ │ - nPath = l.metadata.nestingPath.slice() │ │ │ │ - } │ │ │ │ - if (nTitle != "") { │ │ │ │ - nPath.push(nTitle) │ │ │ │ - } │ │ │ │ - layerContext.metadata.nestingPath = nPath; │ │ │ │ - if (layerContext.layersContext) { │ │ │ │ - this.setNestingPath(layerContext) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ + getInfoForHover: function(evt) { │ │ │ │ + this.request(evt.xy, { │ │ │ │ + hover: true │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - decomposeNestingPath: function(nPath) { │ │ │ │ - var a = []; │ │ │ │ - if (OpenLayers.Util.isArray(nPath)) { │ │ │ │ - var path = nPath.slice(); │ │ │ │ - while (path.length > 0) { │ │ │ │ - a.push(path.slice()); │ │ │ │ - path.pop() │ │ │ │ + cancelHover: function() { │ │ │ │ + if (this.hoverRequest) { │ │ │ │ + --this.pending; │ │ │ │ + if (this.pending <= 0) { │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + this.pending = 0 │ │ │ │ } │ │ │ │ - a.reverse() │ │ │ │ + this.hoverRequest.abort(); │ │ │ │ + this.hoverRequest = null │ │ │ │ } │ │ │ │ - return a │ │ │ │ }, │ │ │ │ - read: function(data) { │ │ │ │ - if (typeof data == "string") { │ │ │ │ - data = OpenLayers.Format.XML.prototype.read.apply(this, [data]) │ │ │ │ - } │ │ │ │ - if (data && data.nodeType == 9) { │ │ │ │ - data = data.documentElement │ │ │ │ - } │ │ │ │ - var context = {}; │ │ │ │ - this.readNode(data, context); │ │ │ │ - this.setNestingPath({ │ │ │ │ - layersContext: context.layersContext │ │ │ │ - }); │ │ │ │ + findLayers: function() { │ │ │ │ + var candidates = this.layers || this.map.layers; │ │ │ │ var layers = []; │ │ │ │ - this.processLayer(layers, context); │ │ │ │ - delete context.layersContext; │ │ │ │ - context.layersContext = layers; │ │ │ │ - return context │ │ │ │ - }, │ │ │ │ - processLayer: function(layerArray, layer) { │ │ │ │ - if (layer.layersContext) { │ │ │ │ - for (var i = 0, len = layer.layersContext.length; i < len; i++) { │ │ │ │ - var l = layer.layersContext[i]; │ │ │ │ - layerArray.push(l); │ │ │ │ - if (l.layersContext) { │ │ │ │ - this.processLayer(layerArray, l) │ │ │ │ + var layer; │ │ │ │ + for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ + layer = candidates[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMTS && layer.requestEncoding === this.requestEncoding && (!this.queryVisible || layer.getVisibility())) { │ │ │ │ + layers.push(layer); │ │ │ │ + if (!this.drillDown || this.hover) { │ │ │ │ + break │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ + return layers │ │ │ │ }, │ │ │ │ - write: function(context, options) { │ │ │ │ - var name = "OWSContext"; │ │ │ │ - this.nestingLayerLookup = {}; │ │ │ │ - options = options || {}; │ │ │ │ - OpenLayers.Util.applyDefaults(options, context); │ │ │ │ - var root = this.writeNode(name, options); │ │ │ │ - this.nestingLayerLookup = null; │ │ │ │ - this.setAttributeNS(root, this.namespaces["xsi"], "xsi:schemaLocation", this.schemaLocation); │ │ │ │ - return OpenLayers.Format.XML.prototype.write.apply(this, [root]) │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - kml: { │ │ │ │ - Document: function(node, obj) { │ │ │ │ - obj.features = new OpenLayers.Format.KML({ │ │ │ │ - kmlns: this.namespaces.kml, │ │ │ │ - extractStyles: true │ │ │ │ - }).read(node) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - owc: { │ │ │ │ - OWSContext: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - General: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - ResourceList: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Layer: function(node, obj) { │ │ │ │ - var layerContext = { │ │ │ │ - metadata: {}, │ │ │ │ - visibility: node.getAttribute("hidden") != "1", │ │ │ │ - queryable: node.getAttribute("queryable") == "1", │ │ │ │ - opacity: node.getAttribute("opacity") != null ? parseFloat(node.getAttribute("opacity")) : null, │ │ │ │ - name: node.getAttribute("name"), │ │ │ │ - categoryLayer: node.getAttribute("name") == null, │ │ │ │ - formats: [], │ │ │ │ - styles: [] │ │ │ │ - }; │ │ │ │ - if (!obj.layersContext) { │ │ │ │ - obj.layersContext = [] │ │ │ │ - } │ │ │ │ - obj.layersContext.push(layerContext); │ │ │ │ - this.readChildNodes(node, layerContext) │ │ │ │ - }, │ │ │ │ - InlineGeometry: function(node, obj) { │ │ │ │ - obj.features = []; │ │ │ │ - var elements = this.getElementsByTagNameNS(node, this.namespaces.gml, "featureMember"); │ │ │ │ - var el; │ │ │ │ - if (elements.length >= 1) { │ │ │ │ - el = elements[0] │ │ │ │ - } │ │ │ │ - if (el && el.firstChild) { │ │ │ │ - var featurenode = el.firstChild.nextSibling ? el.firstChild.nextSibling : el.firstChild; │ │ │ │ - this.setNamespace("feature", featurenode.namespaceURI); │ │ │ │ - this.featureType = featurenode.localName || featurenode.nodeName.split(":").pop(); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Server: function(node, obj) { │ │ │ │ - if (!obj.service && !obj.version || obj.service != OpenLayers.Format.Context.serviceTypes.WMS) { │ │ │ │ - obj.service = node.getAttribute("service"); │ │ │ │ - obj.version = node.getAttribute("version"); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Name: function(node, obj) { │ │ │ │ - obj.name = this.getChildValue(node); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - Title: function(node, obj) { │ │ │ │ - obj.title = this.getChildValue(node); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - }, │ │ │ │ - StyleList: function(node, obj) { │ │ │ │ - this.readChildNodes(node, obj.styles) │ │ │ │ - }, │ │ │ │ - Style: function(node, obj) { │ │ │ │ - var style = {}; │ │ │ │ - obj.push(style); │ │ │ │ - this.readChildNodes(node, style) │ │ │ │ - }, │ │ │ │ - LegendURL: function(node, obj) { │ │ │ │ - var legend = {}; │ │ │ │ - obj.legend = legend; │ │ │ │ - this.readChildNodes(node, legend) │ │ │ │ + buildRequestOptions: function(layer, xy) { │ │ │ │ + var loc = this.map.getLonLatFromPixel(xy); │ │ │ │ + var getTileUrl = layer.getURL(new OpenLayers.Bounds(loc.lon, loc.lat, loc.lon, loc.lat)); │ │ │ │ + var params = OpenLayers.Util.getParameters(getTileUrl); │ │ │ │ + var tileInfo = layer.getTileInfo(loc); │ │ │ │ + OpenLayers.Util.extend(params, { │ │ │ │ + service: "WMTS", │ │ │ │ + version: layer.version, │ │ │ │ + request: "GetFeatureInfo", │ │ │ │ + infoFormat: this.infoFormat, │ │ │ │ + i: tileInfo.i, │ │ │ │ + j: tileInfo.j │ │ │ │ + }); │ │ │ │ + OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ + return { │ │ │ │ + url: OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url, │ │ │ │ + params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ + callback: function(request) { │ │ │ │ + this.handleResponse(xy, request, layer) │ │ │ │ }, │ │ │ │ - OnlineResource: function(node, obj) { │ │ │ │ - obj.url = this.getAttributeNS(node, this.namespaces.xlink, "href"); │ │ │ │ - this.readChildNodes(node, obj) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1_0_0.prototype.readers.ows, │ │ │ │ - gml: OpenLayers.Format.GML.v2.prototype.readers.gml, │ │ │ │ - sld: OpenLayers.Format.SLD.v1_0_0.prototype.readers.sld, │ │ │ │ - feature: OpenLayers.Format.GML.v2.prototype.readers.feature │ │ │ │ + scope: this │ │ │ │ + } │ │ │ │ }, │ │ │ │ - writers: { │ │ │ │ - owc: { │ │ │ │ - OWSContext: function(options) { │ │ │ │ - var node = this.createElementNSPlus("OWSContext", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - id: options.id || OpenLayers.Util.createUniqueID("OpenLayers_OWSContext_") │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("General", options, node); │ │ │ │ - this.writeNode("ResourceList", options, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - General: function(options) { │ │ │ │ - var node = this.createElementNSPlus("General"); │ │ │ │ - this.writeNode("ows:BoundingBox", options, node); │ │ │ │ - this.writeNode("ows:Title", options.title || "OpenLayers OWSContext", node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - ResourceList: function(options) { │ │ │ │ - var node = this.createElementNSPlus("ResourceList"); │ │ │ │ - for (var i = 0, len = options.layers.length; i < len; i++) { │ │ │ │ - var layer = options.layers[i]; │ │ │ │ - var decomposedPath = this.decomposeNestingPath(layer.metadata.nestingPath); │ │ │ │ - this.writeNode("_Layer", { │ │ │ │ - layer: layer, │ │ │ │ - subPaths: decomposedPath │ │ │ │ - }, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Server: function(options) { │ │ │ │ - var node = this.createElementNSPlus("Server", { │ │ │ │ - attributes: { │ │ │ │ - version: options.version, │ │ │ │ - service: options.service │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("OnlineResource", options, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - OnlineResource: function(options) { │ │ │ │ - var node = this.createElementNSPlus("OnlineResource", { │ │ │ │ - attributes: { │ │ │ │ - "xlink:href": options.url │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - InlineGeometry: function(layer) { │ │ │ │ - var node = this.createElementNSPlus("InlineGeometry"), │ │ │ │ - dataExtent = layer.getDataExtent(); │ │ │ │ - if (dataExtent !== null) { │ │ │ │ - this.writeNode("gml:boundedBy", dataExtent, node) │ │ │ │ - } │ │ │ │ - for (var i = 0, len = layer.features.length; i < len; i++) { │ │ │ │ - this.writeNode("gml:featureMember", layer.features[i], node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - StyleList: function(styles) { │ │ │ │ - var node = this.createElementNSPlus("StyleList"); │ │ │ │ - for (var i = 0, len = styles.length; i < len; i++) { │ │ │ │ - this.writeNode("Style", styles[i], node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Style: function(style) { │ │ │ │ - var node = this.createElementNSPlus("Style"); │ │ │ │ - this.writeNode("Name", style, node); │ │ │ │ - this.writeNode("Title", style, node); │ │ │ │ - if (style.legend) { │ │ │ │ - this.writeNode("LegendURL", style, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Name: function(obj) { │ │ │ │ - var node = this.createElementNSPlus("Name", { │ │ │ │ - value: obj.name │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Title: function(obj) { │ │ │ │ - var node = this.createElementNSPlus("Title", { │ │ │ │ - value: obj.title │ │ │ │ - }); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - LegendURL: function(style) { │ │ │ │ - var node = this.createElementNSPlus("LegendURL"); │ │ │ │ - this.writeNode("OnlineResource", style.legend, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - _WMS: function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer", { │ │ │ │ - attributes: { │ │ │ │ - name: layer.params.LAYERS, │ │ │ │ - queryable: layer.queryable ? "1" : "0", │ │ │ │ - hidden: layer.visibility ? "0" : "1", │ │ │ │ - opacity: layer.hasOwnProperty("opacity") ? layer.opacity : null │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("ows:OutputFormat", layer.params.FORMAT, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.WMS, │ │ │ │ - version: layer.params.VERSION, │ │ │ │ - url: layer.url │ │ │ │ - }, node); │ │ │ │ - if (layer.metadata.styles && layer.metadata.styles.length > 0) { │ │ │ │ - this.writeNode("StyleList", layer.metadata.styles, node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - _Layer: function(options) { │ │ │ │ - var layer, subPaths, node, title; │ │ │ │ - layer = options.layer; │ │ │ │ - subPaths = options.subPaths; │ │ │ │ - node = null; │ │ │ │ - title = null; │ │ │ │ - if (subPaths.length > 0) { │ │ │ │ - var path = subPaths[0].join("/"); │ │ │ │ - var index = path.lastIndexOf("/"); │ │ │ │ - node = this.nestingLayerLookup[path]; │ │ │ │ - title = index > 0 ? path.substring(index + 1, path.length) : path; │ │ │ │ - if (!node) { │ │ │ │ - node = this.createElementNSPlus("Layer"); │ │ │ │ - this.writeNode("ows:Title", title, node); │ │ │ │ - this.nestingLayerLookup[path] = node │ │ │ │ - } │ │ │ │ - options.subPaths.shift(); │ │ │ │ - this.writeNode("_Layer", options, node); │ │ │ │ - return node │ │ │ │ - } else { │ │ │ │ - if (layer instanceof OpenLayers.Layer.WMS) { │ │ │ │ - node = this.writeNode("_WMS", layer) │ │ │ │ - } else if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ - if (layer.protocol instanceof OpenLayers.Protocol.WFS.v1) { │ │ │ │ - node = this.writeNode("_WFS", layer) │ │ │ │ - } else if (layer.protocol instanceof OpenLayers.Protocol.HTTP) { │ │ │ │ - if (layer.protocol.format instanceof OpenLayers.Format.GML) { │ │ │ │ - layer.protocol.format.version = "2.1.2"; │ │ │ │ - node = this.writeNode("_GML", layer) │ │ │ │ - } else if (layer.protocol.format instanceof OpenLayers.Format.KML) { │ │ │ │ - layer.protocol.format.version = "2.2"; │ │ │ │ - node = this.writeNode("_KML", layer) │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - this.setNamespace("feature", this.featureNS); │ │ │ │ - node = this.writeNode("_InlineGeometry", layer) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (layer.options.maxScale) { │ │ │ │ - this.writeNode("sld:MinScaleDenominator", layer.options.maxScale, node) │ │ │ │ - } │ │ │ │ - if (layer.options.minScale) { │ │ │ │ - this.writeNode("sld:MaxScaleDenominator", layer.options.minScale, node) │ │ │ │ - } │ │ │ │ - this.nestingLayerLookup[layer.name] = node; │ │ │ │ - return node │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - _WFS: function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer", { │ │ │ │ - attributes: { │ │ │ │ - name: layer.protocol.featurePrefix + ":" + layer.protocol.featureType, │ │ │ │ - hidden: layer.visibility ? "0" : "1" │ │ │ │ - } │ │ │ │ + request: function(xy, options) { │ │ │ │ + options = options || {}; │ │ │ │ + var layers = this.findLayers(); │ │ │ │ + if (layers.length > 0) { │ │ │ │ + var issue, layer; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + layer = layers[i]; │ │ │ │ + issue = this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ + xy: xy, │ │ │ │ + layer: layer │ │ │ │ }); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.WFS, │ │ │ │ - version: layer.protocol.version, │ │ │ │ - url: layer.protocol.url │ │ │ │ - }, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - _InlineGeometry: function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer", { │ │ │ │ - attributes: { │ │ │ │ - name: this.featureType, │ │ │ │ - hidden: layer.visibility ? "0" : "1" │ │ │ │ + if (issue !== false) { │ │ │ │ + ++this.pending; │ │ │ │ + var requestOptions = this.buildRequestOptions(layer, xy); │ │ │ │ + var request = OpenLayers.Request.GET(requestOptions); │ │ │ │ + if (options.hover === true) { │ │ │ │ + this.hoverRequest = request │ │ │ │ } │ │ │ │ - }); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("InlineGeometry", layer, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - _GML: function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer"); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.GML, │ │ │ │ - url: layer.protocol.url, │ │ │ │ - version: layer.protocol.format.version │ │ │ │ - }, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - _KML: function(layer) { │ │ │ │ - var node = this.createElementNSPlus("Layer"); │ │ │ │ - this.writeNode("ows:Title", layer.name, node); │ │ │ │ - this.writeNode("Server", { │ │ │ │ - service: OpenLayers.Format.Context.serviceTypes.KML, │ │ │ │ - version: layer.protocol.format.version, │ │ │ │ - url: layer.protocol.url │ │ │ │ - }, node); │ │ │ │ - return node │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - gml: OpenLayers.Util.applyDefaults({ │ │ │ │ - boundedBy: function(bounds) { │ │ │ │ - var node = this.createElementNSPlus("gml:boundedBy"); │ │ │ │ - this.writeNode("gml:Box", bounds, node); │ │ │ │ - return node │ │ │ │ - } │ │ │ │ - }, OpenLayers.Format.GML.v2.prototype.writers.gml), │ │ │ │ - ows: OpenLayers.Format.OWSCommon.v1_0_0.prototype.writers.ows, │ │ │ │ - sld: OpenLayers.Format.SLD.v1_0_0.prototype.writers.sld, │ │ │ │ - feature: OpenLayers.Format.GML.v2.prototype.writers.feature │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.OWSContext.v0_3_1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.XLS.v1 = OpenLayers.Class(OpenLayers.Format.XML, { │ │ │ │ - namespaces: { │ │ │ │ - xls: "http://www.opengis.net/xls", │ │ │ │ - gml: "http://www.opengis.net/gml", │ │ │ │ - xsi: "http://www.w3.org/2001/XMLSchema-instance" │ │ │ │ - }, │ │ │ │ - regExes: { │ │ │ │ - trimSpace: /^\s*|\s*$/g, │ │ │ │ - removeSpace: /\s*/g, │ │ │ │ - splitSpace: /\s+/, │ │ │ │ - trimComma: /\s*,\s*/g │ │ │ │ - }, │ │ │ │ - xy: true, │ │ │ │ - defaultPrefix: "xls", │ │ │ │ - schemaLocation: null, │ │ │ │ - read: function(data, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var xls = {}; │ │ │ │ - this.readChildNodes(data, xls); │ │ │ │ - return xls │ │ │ │ - }, │ │ │ │ - readers: { │ │ │ │ - xls: { │ │ │ │ - XLS: function(node, xls) { │ │ │ │ - xls.version = node.getAttribute("version"); │ │ │ │ - this.readChildNodes(node, xls) │ │ │ │ - }, │ │ │ │ - Response: function(node, xls) { │ │ │ │ - this.readChildNodes(node, xls) │ │ │ │ - }, │ │ │ │ - GeocodeResponse: function(node, xls) { │ │ │ │ - xls.responseLists = []; │ │ │ │ - this.readChildNodes(node, xls) │ │ │ │ - }, │ │ │ │ - GeocodeResponseList: function(node, xls) { │ │ │ │ - var responseList = { │ │ │ │ - features: [], │ │ │ │ - numberOfGeocodedAddresses: parseInt(node.getAttribute("numberOfGeocodedAddresses")) │ │ │ │ - }; │ │ │ │ - xls.responseLists.push(responseList); │ │ │ │ - this.readChildNodes(node, responseList) │ │ │ │ - }, │ │ │ │ - GeocodedAddress: function(node, responseList) { │ │ │ │ - var feature = new OpenLayers.Feature.Vector; │ │ │ │ - responseList.features.push(feature); │ │ │ │ - this.readChildNodes(node, feature); │ │ │ │ - feature.geometry = feature.components[0] │ │ │ │ - }, │ │ │ │ - GeocodeMatchCode: function(node, feature) { │ │ │ │ - feature.attributes.matchCode = { │ │ │ │ - accuracy: parseFloat(node.getAttribute("accuracy")), │ │ │ │ - matchType: node.getAttribute("matchType") │ │ │ │ } │ │ │ │ - }, │ │ │ │ - Address: function(node, feature) { │ │ │ │ - var address = { │ │ │ │ - countryCode: node.getAttribute("countryCode"), │ │ │ │ - addressee: node.getAttribute("addressee"), │ │ │ │ - street: [], │ │ │ │ - place: [] │ │ │ │ - }; │ │ │ │ - feature.attributes.address = address; │ │ │ │ - this.readChildNodes(node, address) │ │ │ │ - }, │ │ │ │ - freeFormAddress: function(node, address) { │ │ │ │ - address.freeFormAddress = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - StreetAddress: function(node, address) { │ │ │ │ - this.readChildNodes(node, address) │ │ │ │ - }, │ │ │ │ - Building: function(node, address) { │ │ │ │ - address.building = { │ │ │ │ - number: node.getAttribute("number"), │ │ │ │ - subdivision: node.getAttribute("subdivision"), │ │ │ │ - buildingName: node.getAttribute("buildingName") │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - Street: function(node, address) { │ │ │ │ - address.street.push(this.getChildValue(node)) │ │ │ │ - }, │ │ │ │ - Place: function(node, address) { │ │ │ │ - address.place[node.getAttribute("type")] = this.getChildValue(node) │ │ │ │ - }, │ │ │ │ - PostalCode: function(node, address) { │ │ │ │ - address.postalCode = this.getChildValue(node) │ │ │ │ } │ │ │ │ - }, │ │ │ │ - gml: OpenLayers.Format.GML.v3.prototype.readers.gml │ │ │ │ - }, │ │ │ │ - write: function(request) { │ │ │ │ - return this.writers.xls.XLS.apply(this, [request]) │ │ │ │ - }, │ │ │ │ - writers: { │ │ │ │ - xls: { │ │ │ │ - XLS: function(request) { │ │ │ │ - var root = this.createElementNSPlus("xls:XLS", { │ │ │ │ - attributes: { │ │ │ │ - version: this.VERSION, │ │ │ │ - "xsi:schemaLocation": this.schemaLocation │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("RequestHeader", request.header, root); │ │ │ │ - this.writeNode("Request", request, root); │ │ │ │ - return root │ │ │ │ - }, │ │ │ │ - RequestHeader: function(header) { │ │ │ │ - return this.createElementNSPlus("xls:RequestHeader") │ │ │ │ - }, │ │ │ │ - Request: function(request) { │ │ │ │ - var node = this.createElementNSPlus("xls:Request", { │ │ │ │ - attributes: { │ │ │ │ - methodName: "GeocodeRequest", │ │ │ │ - requestID: request.requestID || "", │ │ │ │ - version: this.VERSION │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - this.writeNode("GeocodeRequest", request.addresses, node); │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - GeocodeRequest: function(addresses) { │ │ │ │ - var node = this.createElementNSPlus("xls:GeocodeRequest"); │ │ │ │ - for (var i = 0, len = addresses.length; i < len; i++) { │ │ │ │ - this.writeNode("Address", addresses[i], node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Address: function(address) { │ │ │ │ - var node = this.createElementNSPlus("xls:Address", { │ │ │ │ - attributes: { │ │ │ │ - countryCode: address.countryCode │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - if (address.freeFormAddress) { │ │ │ │ - this.writeNode("freeFormAddress", address.freeFormAddress, node) │ │ │ │ - } else { │ │ │ │ - if (address.street) { │ │ │ │ - this.writeNode("StreetAddress", address, node) │ │ │ │ - } │ │ │ │ - if (address.municipality) { │ │ │ │ - this.writeNode("Municipality", address.municipality, node) │ │ │ │ - } │ │ │ │ - if (address.countrySubdivision) { │ │ │ │ - this.writeNode("CountrySubdivision", address.countrySubdivision, node) │ │ │ │ - } │ │ │ │ - if (address.postalCode) { │ │ │ │ - this.writeNode("PostalCode", address.postalCode, node) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - freeFormAddress: function(freeFormAddress) { │ │ │ │ - return this.createElementNSPlus("freeFormAddress", { │ │ │ │ - value: freeFormAddress │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - StreetAddress: function(address) { │ │ │ │ - var node = this.createElementNSPlus("xls:StreetAddress"); │ │ │ │ - if (address.building) { │ │ │ │ - this.writeNode(node, "Building", address.building) │ │ │ │ - } │ │ │ │ - var street = address.street; │ │ │ │ - if (!OpenLayers.Util.isArray(street)) { │ │ │ │ - street = [street] │ │ │ │ - } │ │ │ │ - for (var i = 0, len = street.length; i < len; i++) { │ │ │ │ - this.writeNode("Street", street[i], node) │ │ │ │ - } │ │ │ │ - return node │ │ │ │ - }, │ │ │ │ - Building: function(building) { │ │ │ │ - return this.createElementNSPlus("xls:Building", { │ │ │ │ - attributes: { │ │ │ │ - number: building["number"], │ │ │ │ - subdivision: building.subdivision, │ │ │ │ - buildingName: building.buildingName │ │ │ │ - } │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - Street: function(street) { │ │ │ │ - return this.createElementNSPlus("xls:Street", { │ │ │ │ - value: street │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - Municipality: function(municipality) { │ │ │ │ - return this.createElementNSPlus("xls:Place", { │ │ │ │ - attributes: { │ │ │ │ - type: "Municipality" │ │ │ │ - }, │ │ │ │ - value: municipality │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - CountrySubdivision: function(countrySubdivision) { │ │ │ │ - return this.createElementNSPlus("xls:Place", { │ │ │ │ - attributes: { │ │ │ │ - type: "CountrySubdivision" │ │ │ │ - }, │ │ │ │ - value: countrySubdivision │ │ │ │ - }) │ │ │ │ - }, │ │ │ │ - PostalCode: function(postalCode) { │ │ │ │ - return this.createElementNSPlus("xls:PostalCode", { │ │ │ │ - value: postalCode │ │ │ │ - }) │ │ │ │ + if (this.pending > 0) { │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ } │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Format.XLS.v1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.XLS.v1_1_0 = OpenLayers.Class(OpenLayers.Format.XLS.v1, { │ │ │ │ - VERSION: "1.1", │ │ │ │ - schemaLocation: "http://www.opengis.net/xls http://schemas.opengis.net/ols/1.1.0/LocationUtilityService.xsd", │ │ │ │ - CLASS_NAME: "OpenLayers.Format.XLS.v1_1_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Format.XLS.v1_1 = OpenLayers.Format.XLS.v1_1_0; │ │ │ │ -OpenLayers.Tile.Image.IFrame = { │ │ │ │ - useIFrame: null, │ │ │ │ - blankImageUrl: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAQAIBRAA7", │ │ │ │ - draw: function() { │ │ │ │ - var draw = OpenLayers.Tile.Image.prototype.shouldDraw.call(this); │ │ │ │ - if (draw) { │ │ │ │ - var url = this.layer.getURL(this.bounds); │ │ │ │ - var usedIFrame = this.useIFrame; │ │ │ │ - this.useIFrame = this.maxGetUrlLength !== null && !this.layer.async && url.length > this.maxGetUrlLength; │ │ │ │ - var fromIFrame = usedIFrame && !this.useIFrame; │ │ │ │ - var toIFrame = !usedIFrame && this.useIFrame; │ │ │ │ - if (fromIFrame || toIFrame) { │ │ │ │ - if (this.imgDiv && this.imgDiv.parentNode === this.frame) { │ │ │ │ - this.frame.removeChild(this.imgDiv) │ │ │ │ - } │ │ │ │ - this.imgDiv = null; │ │ │ │ - if (fromIFrame) { │ │ │ │ - this.frame.removeChild(this.frame.firstChild) │ │ │ │ - } │ │ │ │ - } │ │ │ │ + handleResponse: function(xy, request, layer) { │ │ │ │ + --this.pending; │ │ │ │ + if (this.pending <= 0) { │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + this.pending = 0 │ │ │ │ } │ │ │ │ - return OpenLayers.Tile.Image.prototype.draw.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - getImage: function() { │ │ │ │ - if (this.useIFrame === true) { │ │ │ │ - if (!this.frame.childNodes.length) { │ │ │ │ - var eventPane = document.createElement("div"), │ │ │ │ - style = eventPane.style; │ │ │ │ - style.position = "absolute"; │ │ │ │ - style.width = "100%"; │ │ │ │ - style.height = "100%"; │ │ │ │ - style.zIndex = 1; │ │ │ │ - style.backgroundImage = "url(" + this.blankImageUrl + ")"; │ │ │ │ - this.frame.appendChild(eventPane) │ │ │ │ - } │ │ │ │ - var id = this.id + "_iFrame", │ │ │ │ - iframe; │ │ │ │ - if (parseFloat(navigator.appVersion.split("MSIE")[1]) < 9) { │ │ │ │ - iframe = document.createElement('<iframe name="' + id + '">'); │ │ │ │ - iframe.style.backgroundColor = "#FFFFFF"; │ │ │ │ - iframe.style.filter = "chroma(color=#FFFFFF)" │ │ │ │ - } else { │ │ │ │ - iframe = document.createElement("iframe"); │ │ │ │ - iframe.style.backgroundColor = "transparent"; │ │ │ │ - iframe.name = id │ │ │ │ + if (request.status && (request.status < 200 || request.status >= 300)) { │ │ │ │ + this.events.triggerEvent("exception", { │ │ │ │ + xy: xy, │ │ │ │ + request: request, │ │ │ │ + layer: layer │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + var doc = request.responseXML; │ │ │ │ + if (!doc || !doc.documentElement) { │ │ │ │ + doc = request.responseText │ │ │ │ } │ │ │ │ - iframe.scrolling = "no"; │ │ │ │ - iframe.marginWidth = "0px"; │ │ │ │ - iframe.marginHeight = "0px"; │ │ │ │ - iframe.frameBorder = "0"; │ │ │ │ - iframe.style.position = "absolute"; │ │ │ │ - iframe.style.width = "100%"; │ │ │ │ - iframe.style.height = "100%"; │ │ │ │ - if (this.layer.opacity < 1) { │ │ │ │ - OpenLayers.Util.modifyDOMElement(iframe, null, null, null, null, null, null, this.layer.opacity) │ │ │ │ + var features, except; │ │ │ │ + try { │ │ │ │ + features = this.format.read(doc) │ │ │ │ + } catch (error) { │ │ │ │ + except = true; │ │ │ │ + this.events.triggerEvent("exception", { │ │ │ │ + xy: xy, │ │ │ │ + request: request, │ │ │ │ + error: error, │ │ │ │ + layer: layer │ │ │ │ + }) │ │ │ │ } │ │ │ │ - this.frame.appendChild(iframe); │ │ │ │ - this.imgDiv = iframe; │ │ │ │ - return iframe │ │ │ │ - } else { │ │ │ │ - return OpenLayers.Tile.Image.prototype.getImage.apply(this, arguments) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - createRequestForm: function() { │ │ │ │ - var form = document.createElement("form"); │ │ │ │ - form.method = "POST"; │ │ │ │ - var cacheId = this.layer.params["_OLSALT"]; │ │ │ │ - cacheId = (cacheId ? cacheId + "_" : "") + this.bounds.toBBOX(); │ │ │ │ - form.action = OpenLayers.Util.urlAppend(this.layer.url, cacheId); │ │ │ │ - form.target = this.id + "_iFrame"; │ │ │ │ - var imageSize = this.layer.getImageSize(), │ │ │ │ - params = OpenLayers.Util.getParameters(this.url), │ │ │ │ - field; │ │ │ │ - for (var par in params) { │ │ │ │ - field = document.createElement("input"); │ │ │ │ - field.type = "hidden"; │ │ │ │ - field.name = par; │ │ │ │ - field.value = params[par]; │ │ │ │ - form.appendChild(field) │ │ │ │ - } │ │ │ │ - return form │ │ │ │ - }, │ │ │ │ - setImgSrc: function(url) { │ │ │ │ - if (this.useIFrame === true) { │ │ │ │ - if (url) { │ │ │ │ - var form = this.createRequestForm(); │ │ │ │ - this.frame.appendChild(form); │ │ │ │ - form.submit(); │ │ │ │ - this.frame.removeChild(form) │ │ │ │ - } else if (this.imgDiv.parentNode === this.frame) { │ │ │ │ - this.frame.removeChild(this.imgDiv); │ │ │ │ - this.imgDiv = null │ │ │ │ + if (!except) { │ │ │ │ + this.events.triggerEvent("getfeatureinfo", { │ │ │ │ + text: request.responseText, │ │ │ │ + features: features, │ │ │ │ + request: request, │ │ │ │ + xy: xy, │ │ │ │ + layer: layer │ │ │ │ + }) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - OpenLayers.Tile.Image.prototype.setImgSrc.apply(this, arguments) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - onImageLoad: function() { │ │ │ │ - OpenLayers.Tile.Image.prototype.onImageLoad.apply(this, arguments); │ │ │ │ - if (this.useIFrame === true) { │ │ │ │ - this.imgDiv.style.opacity = 1; │ │ │ │ - this.frame.style.opacity = this.layer.opacity │ │ │ │ } │ │ │ │ }, │ │ │ │ - createBackBuffer: function() { │ │ │ │ - var backBuffer; │ │ │ │ - if (this.useIFrame === false) { │ │ │ │ - backBuffer = OpenLayers.Tile.Image.prototype.createBackBuffer.call(this) │ │ │ │ - } │ │ │ │ - return backBuffer │ │ │ │ - } │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.WFS = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, OpenLayers.Protocol.WFS.DEFAULTS); │ │ │ │ - var cls = OpenLayers.Protocol.WFS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported WFS version: " + options.version │ │ │ │ - } │ │ │ │ - return new cls(options) │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.WFS.fromWMSLayer = function(layer, options) { │ │ │ │ - var typeName, featurePrefix; │ │ │ │ - var param = layer.params["LAYERS"]; │ │ │ │ - var parts = (OpenLayers.Util.isArray(param) ? param[0] : param).split(":"); │ │ │ │ - if (parts.length > 1) { │ │ │ │ - featurePrefix = parts[0] │ │ │ │ - } │ │ │ │ - typeName = parts.pop(); │ │ │ │ - var protocolOptions = { │ │ │ │ - url: layer.url, │ │ │ │ - featureType: typeName, │ │ │ │ - featurePrefix: featurePrefix, │ │ │ │ - srsName: layer.projection && layer.projection.getCode() || layer.map && layer.map.getProjectionObject().getCode(), │ │ │ │ - version: "1.1.0" │ │ │ │ - }; │ │ │ │ - return new OpenLayers.Protocol.WFS(OpenLayers.Util.applyDefaults(options, protocolOptions)) │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.WFS.DEFAULTS = { │ │ │ │ - version: "1.0.0" │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ + CLASS_NAME: "OpenLayers.Control.WMTSGetFeatureInfo" │ │ │ │ +}); │ │ │ │ +OpenLayers.Control.WMSGetFeatureInfo = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + hover: false, │ │ │ │ + drillDown: false, │ │ │ │ + maxFeatures: 10, │ │ │ │ + clickCallback: "click", │ │ │ │ + output: "features", │ │ │ │ + layers: null, │ │ │ │ + queryVisible: false, │ │ │ │ url: null, │ │ │ │ - params: null, │ │ │ │ - callback: null, │ │ │ │ - callbackTemplate: "OpenLayers.Protocol.Script.registry.${id}", │ │ │ │ - callbackKey: "callback", │ │ │ │ - callbackPrefix: "", │ │ │ │ - scope: null, │ │ │ │ + layerUrls: null, │ │ │ │ + infoFormat: "text/html", │ │ │ │ + vendorParams: {}, │ │ │ │ format: null, │ │ │ │ - pendingRequests: null, │ │ │ │ - srsInBBOX: false, │ │ │ │ + formatOptions: null, │ │ │ │ + handler: null, │ │ │ │ + hoverRequest: null, │ │ │ │ initialize: function(options) { │ │ │ │ options = options || {}; │ │ │ │ - this.params = {}; │ │ │ │ - this.pendingRequests = {}; │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ + options.handlerOptions = options.handlerOptions || {}; │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ if (!this.format) { │ │ │ │ - this.format = new OpenLayers.Format.GeoJSON │ │ │ │ + this.format = new OpenLayers.Format.WMSGetFeatureInfo(options.formatOptions) │ │ │ │ } │ │ │ │ - if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ - var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ - srsInBBOX: this.srsInBBOX │ │ │ │ - }); │ │ │ │ - this.filterToParams = function(filter, params) { │ │ │ │ - return format.write(filter, params) │ │ │ │ - } │ │ │ │ + if (this.drillDown === true) { │ │ │ │ + this.hover = false │ │ │ │ } │ │ │ │ - }, │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - options.params = OpenLayers.Util.applyDefaults(options.params, this.options.params); │ │ │ │ - if (options.filter && this.filterToParams) { │ │ │ │ - options.params = this.filterToParams(options.filter, options.params) │ │ │ │ + if (this.hover) { │ │ │ │ + this.handler = new OpenLayers.Handler.Hover(this, { │ │ │ │ + move: this.cancelHover, │ │ │ │ + pause: this.getInfoForHover │ │ │ │ + }, OpenLayers.Util.extend(this.handlerOptions.hover || {}, { │ │ │ │ + delay: 250 │ │ │ │ + })) │ │ │ │ + } else { │ │ │ │ + var callbacks = {}; │ │ │ │ + callbacks[this.clickCallback] = this.getInfoForClick; │ │ │ │ + this.handler = new OpenLayers.Handler.Click(this, callbacks, this.handlerOptions.click || {}) │ │ │ │ } │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ + }, │ │ │ │ + getInfoForClick: function(evt) { │ │ │ │ + this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ + xy: evt.xy │ │ │ │ }); │ │ │ │ - var request = this.createRequest(options.url, options.params, OpenLayers.Function.bind(function(data) { │ │ │ │ - response.data = data; │ │ │ │ - this.handleRead(response, options) │ │ │ │ - }, this)); │ │ │ │ - response.priv = request; │ │ │ │ - return response │ │ │ │ + OpenLayers.Element.addClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + this.request(evt.xy, {}) │ │ │ │ }, │ │ │ │ - createRequest: function(url, params, callback) { │ │ │ │ - var id = OpenLayers.Protocol.Script.register(callback); │ │ │ │ - var name = OpenLayers.String.format(this.callbackTemplate, { │ │ │ │ - id: id │ │ │ │ + getInfoForHover: function(evt) { │ │ │ │ + this.events.triggerEvent("beforegetfeatureinfo", { │ │ │ │ + xy: evt.xy │ │ │ │ }); │ │ │ │ - params = OpenLayers.Util.extend({}, params); │ │ │ │ - params[this.callbackKey] = this.callbackPrefix + name; │ │ │ │ - url = OpenLayers.Util.urlAppend(url, OpenLayers.Util.getParameterString(params)); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = "OpenLayers_Protocol_Script_" + id; │ │ │ │ - this.pendingRequests[script.id] = script; │ │ │ │ - var head = document.getElementsByTagName("head")[0]; │ │ │ │ - head.appendChild(script); │ │ │ │ - return script │ │ │ │ + this.request(evt.xy, { │ │ │ │ + hover: true │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - destroyRequest: function(script) { │ │ │ │ - OpenLayers.Protocol.Script.unregister(script.id.split("_").pop()); │ │ │ │ - delete this.pendingRequests[script.id]; │ │ │ │ - if (script.parentNode) { │ │ │ │ - script.parentNode.removeChild(script) │ │ │ │ + cancelHover: function() { │ │ │ │ + if (this.hoverRequest) { │ │ │ │ + this.hoverRequest.abort(); │ │ │ │ + this.hoverRequest = null │ │ │ │ } │ │ │ │ }, │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - this.handleResponse(response, options) │ │ │ │ - }, │ │ │ │ - handleResponse: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - if (response.data) { │ │ │ │ - response.features = this.parseFeatures(response.data); │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ - } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ + findLayers: function() { │ │ │ │ + var candidates = this.layers || this.map.layers; │ │ │ │ + var layers = []; │ │ │ │ + var layer, url; │ │ │ │ + for (var i = candidates.length - 1; i >= 0; --i) { │ │ │ │ + layer = candidates[i]; │ │ │ │ + if (layer instanceof OpenLayers.Layer.WMS && (!this.queryVisible || layer.getVisibility())) { │ │ │ │ + url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ + if (this.drillDown === false && !this.url) { │ │ │ │ + this.url = url │ │ │ │ + } │ │ │ │ + if (this.drillDown === true || this.urlMatches(url)) { │ │ │ │ + layers.push(layer) │ │ │ │ + } │ │ │ │ } │ │ │ │ - this.destroyRequest(response.priv); │ │ │ │ - options.callback.call(options.scope, response) │ │ │ │ } │ │ │ │ + return layers │ │ │ │ }, │ │ │ │ - parseFeatures: function(data) { │ │ │ │ - return this.format.read(data) │ │ │ │ - }, │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - this.destroyRequest(response.priv) │ │ │ │ - } else { │ │ │ │ - for (var key in this.pendingRequests) { │ │ │ │ - this.destroyRequest(this.pendingRequests[key]) │ │ │ │ + urlMatches: function(url) { │ │ │ │ + var matches = OpenLayers.Util.isEquivalentUrl(this.url, url); │ │ │ │ + if (!matches && this.layerUrls) { │ │ │ │ + for (var i = 0, len = this.layerUrls.length; i < len; ++i) { │ │ │ │ + if (OpenLayers.Util.isEquivalentUrl(this.layerUrls[i], url)) { │ │ │ │ + matches = true; │ │ │ │ + break │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ + return matches │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.abort(); │ │ │ │ - delete this.params; │ │ │ │ - delete this.format; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.Script" │ │ │ │ -}); │ │ │ │ -(function() { │ │ │ │ - var o = OpenLayers.Protocol.Script; │ │ │ │ - var counter = 0; │ │ │ │ - o.registry = {}; │ │ │ │ - o.register = function(callback) { │ │ │ │ - var id = "c" + ++counter; │ │ │ │ - o.registry[id] = function() { │ │ │ │ - callback.apply(this, arguments) │ │ │ │ - }; │ │ │ │ - return id │ │ │ │ - }; │ │ │ │ - o.unregister = function(id) { │ │ │ │ - delete o.registry[id] │ │ │ │ - } │ │ │ │ -})(); │ │ │ │ -OpenLayers.Protocol.CSW = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, OpenLayers.Protocol.CSW.DEFAULTS); │ │ │ │ - var cls = OpenLayers.Protocol.CSW["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported CSW version: " + options.version │ │ │ │ - } │ │ │ │ - return new cls(options) │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.CSW.DEFAULTS = { │ │ │ │ - version: "2.0.2" │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.SOS = function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, OpenLayers.Protocol.SOS.DEFAULTS); │ │ │ │ - var cls = OpenLayers.Protocol.SOS["v" + options.version.replace(/\./g, "_")]; │ │ │ │ - if (!cls) { │ │ │ │ - throw "Unsupported SOS version: " + options.version │ │ │ │ - } │ │ │ │ - return new cls(options) │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.SOS.DEFAULTS = { │ │ │ │ - version: "1.0.0" │ │ │ │ -}; │ │ │ │ -OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ - url: null, │ │ │ │ - headers: null, │ │ │ │ - params: null, │ │ │ │ - callback: null, │ │ │ │ - scope: null, │ │ │ │ - readWithPOST: false, │ │ │ │ - updateWithPOST: false, │ │ │ │ - deleteWithPOST: false, │ │ │ │ - wildcarded: false, │ │ │ │ - srsInBBOX: false, │ │ │ │ - initialize: function(options) { │ │ │ │ - options = options || {}; │ │ │ │ - this.params = {}; │ │ │ │ - this.headers = {}; │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, arguments); │ │ │ │ - if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) { │ │ │ │ - var format = new OpenLayers.Format.QueryStringFilter({ │ │ │ │ - wildcarded: this.wildcarded, │ │ │ │ - srsInBBOX: this.srsInBBOX │ │ │ │ - }); │ │ │ │ - this.filterToParams = function(filter, params) { │ │ │ │ - return format.write(filter, params) │ │ │ │ + buildWMSOptions: function(url, layers, clickPosition, format) { │ │ │ │ + var layerNames = [], │ │ │ │ + styleNames = []; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + if (layers[i].params.LAYERS != null) { │ │ │ │ + layerNames = layerNames.concat(layers[i].params.LAYERS); │ │ │ │ + styleNames = styleNames.concat(this.getStyleNames(layers[i])) │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.params = null; │ │ │ │ - this.headers = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ - }, │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ - options = options || {}; │ │ │ │ - options.params = OpenLayers.Util.applyDefaults(options.params, this.options.params); │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - if (options.filter && this.filterToParams) { │ │ │ │ - options.params = this.filterToParams(options.filter, options.params) │ │ │ │ + var firstLayer = layers[0]; │ │ │ │ + var projection = this.map.getProjection(); │ │ │ │ + var layerProj = firstLayer.projection; │ │ │ │ + if (layerProj && layerProj.equals(this.map.getProjectionObject())) { │ │ │ │ + projection = layerProj.getCode() │ │ │ │ } │ │ │ │ - var readWithPOST = options.readWithPOST !== undefined ? options.readWithPOST : this.readWithPOST; │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ + var params = OpenLayers.Util.extend({ │ │ │ │ + service: "WMS", │ │ │ │ + version: firstLayer.params.VERSION, │ │ │ │ + request: "GetFeatureInfo", │ │ │ │ + exceptions: firstLayer.params.EXCEPTIONS, │ │ │ │ + bbox: this.map.getExtent().toBBOX(null, firstLayer.reverseAxisOrder()), │ │ │ │ + feature_count: this.maxFeatures, │ │ │ │ + height: this.map.getSize().h, │ │ │ │ + width: this.map.getSize().w, │ │ │ │ + format: format, │ │ │ │ + info_format: firstLayer.params.INFO_FORMAT || this.infoFormat │ │ │ │ + }, parseFloat(firstLayer.params.VERSION) >= 1.3 ? { │ │ │ │ + crs: projection, │ │ │ │ + i: parseInt(clickPosition.x), │ │ │ │ + j: parseInt(clickPosition.y) │ │ │ │ + } : { │ │ │ │ + srs: projection, │ │ │ │ + x: parseInt(clickPosition.x), │ │ │ │ + y: parseInt(clickPosition.y) │ │ │ │ }); │ │ │ │ - if (readWithPOST) { │ │ │ │ - var headers = options.headers || {}; │ │ │ │ - headers["Content-Type"] = "application/x-www-form-urlencoded"; │ │ │ │ - resp.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ - data: OpenLayers.Util.getParameterString(options.params), │ │ │ │ - headers: headers │ │ │ │ - }) │ │ │ │ - } else { │ │ │ │ - resp.priv = OpenLayers.Request.GET({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, resp, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers │ │ │ │ - }) │ │ │ │ + if (layerNames.length != 0) { │ │ │ │ + params = OpenLayers.Util.extend({ │ │ │ │ + layers: layerNames, │ │ │ │ + query_layers: layerNames, │ │ │ │ + styles: styleNames │ │ │ │ + }, params) │ │ │ │ } │ │ │ │ - return resp │ │ │ │ - }, │ │ │ │ - handleRead: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options) │ │ │ │ - }, │ │ │ │ - create: function(features, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: features, │ │ │ │ - requestType: "create" │ │ │ │ - }); │ │ │ │ - resp.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleCreate, resp, options), │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(features) │ │ │ │ - }); │ │ │ │ - return resp │ │ │ │ - }, │ │ │ │ - handleCreate: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options) │ │ │ │ - }, │ │ │ │ - update: function(feature, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var url = options.url || feature.url || this.options.url + "/" + feature.fid; │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: feature, │ │ │ │ - requestType: "update" │ │ │ │ - }); │ │ │ │ - var method = this.updateWithPOST ? "POST" : "PUT"; │ │ │ │ - resp.priv = OpenLayers.Request[method]({ │ │ │ │ - url: url, │ │ │ │ - callback: this.createCallback(this.handleUpdate, resp, options), │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(feature) │ │ │ │ - }); │ │ │ │ - return resp │ │ │ │ - }, │ │ │ │ - handleUpdate: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options) │ │ │ │ - }, │ │ │ │ - delete: function(feature, options) { │ │ │ │ - options = options || {}; │ │ │ │ - var url = options.url || feature.url || this.options.url + "/" + feature.fid; │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var resp = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: feature, │ │ │ │ - requestType: "delete" │ │ │ │ - }); │ │ │ │ - var method = this.deleteWithPOST ? "POST" : "DELETE"; │ │ │ │ - var requestOptions = { │ │ │ │ + OpenLayers.Util.applyDefaults(params, this.vendorParams); │ │ │ │ + return { │ │ │ │ url: url, │ │ │ │ - callback: this.createCallback(this.handleDelete, resp, options), │ │ │ │ - headers: options.headers │ │ │ │ - }; │ │ │ │ - if (this.deleteWithPOST) { │ │ │ │ - requestOptions.data = this.format.write(feature) │ │ │ │ + params: OpenLayers.Util.upperCaseObject(params), │ │ │ │ + callback: function(request) { │ │ │ │ + this.handleResponse(clickPosition, request, url) │ │ │ │ + }, │ │ │ │ + scope: this │ │ │ │ } │ │ │ │ - resp.priv = OpenLayers.Request[method](requestOptions); │ │ │ │ - return resp │ │ │ │ - }, │ │ │ │ - handleDelete: function(resp, options) { │ │ │ │ - this.handleResponse(resp, options) │ │ │ │ }, │ │ │ │ - handleResponse: function(resp, options) { │ │ │ │ - var request = resp.priv; │ │ │ │ - if (options.callback) { │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - if (resp.requestType != "delete") { │ │ │ │ - resp.features = this.parseFeatures(request) │ │ │ │ - } │ │ │ │ - resp.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + getStyleNames: function(layer) { │ │ │ │ + var styleNames; │ │ │ │ + if (layer.params.STYLES) { │ │ │ │ + styleNames = layer.params.STYLES │ │ │ │ + } else { │ │ │ │ + if (OpenLayers.Util.isArray(layer.params.LAYERS)) { │ │ │ │ + styleNames = new Array(layer.params.LAYERS.length) │ │ │ │ } else { │ │ │ │ - resp.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ + styleNames = layer.params.LAYERS.replace(/[^,]/g, "") │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, resp) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - parseFeatures: function(request) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null │ │ │ │ } │ │ │ │ - return this.format.read(doc) │ │ │ │ + return styleNames │ │ │ │ }, │ │ │ │ - commit: function(features, options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var resp = [], │ │ │ │ - nResponses = 0; │ │ │ │ - var types = {}; │ │ │ │ - types[OpenLayers.State.INSERT] = []; │ │ │ │ - types[OpenLayers.State.UPDATE] = []; │ │ │ │ - types[OpenLayers.State.DELETE] = []; │ │ │ │ - var feature, list, requestFeatures = []; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - list = types[feature.state]; │ │ │ │ - if (list) { │ │ │ │ - list.push(feature); │ │ │ │ - requestFeatures.push(feature) │ │ │ │ - } │ │ │ │ + request: function(clickPosition, options) { │ │ │ │ + var layers = this.findLayers(); │ │ │ │ + if (layers.length == 0) { │ │ │ │ + this.events.triggerEvent("nogetfeatureinfo"); │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait"); │ │ │ │ + return │ │ │ │ } │ │ │ │ - var nRequests = (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) + types[OpenLayers.State.UPDATE].length + types[OpenLayers.State.DELETE].length; │ │ │ │ - var success = true; │ │ │ │ - var finalResponse = new OpenLayers.Protocol.Response({ │ │ │ │ - reqFeatures: requestFeatures │ │ │ │ - }); │ │ │ │ - │ │ │ │ - function insertCallback(response) { │ │ │ │ - var len = response.features ? response.features.length : 0; │ │ │ │ - var fids = new Array(len); │ │ │ │ - for (var i = 0; i < len; ++i) { │ │ │ │ - fids[i] = response.features[i].fid │ │ │ │ + options = options || {}; │ │ │ │ + if (this.drillDown === false) { │ │ │ │ + var wmsOptions = this.buildWMSOptions(this.url, layers, clickPosition, layers[0].params.FORMAT); │ │ │ │ + var request = OpenLayers.Request.GET(wmsOptions); │ │ │ │ + if (options.hover === true) { │ │ │ │ + this.hoverRequest = request │ │ │ │ } │ │ │ │ - finalResponse.insertIds = fids; │ │ │ │ - callback.apply(this, [response]) │ │ │ │ - } │ │ │ │ - │ │ │ │ - function callback(response) { │ │ │ │ - this.callUserCallback(response, options); │ │ │ │ - success = success && response.success(); │ │ │ │ - nResponses++; │ │ │ │ - if (nResponses >= nRequests) { │ │ │ │ - if (options.callback) { │ │ │ │ - finalResponse.code = success ? OpenLayers.Protocol.Response.SUCCESS : OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - options.callback.apply(options.scope, [finalResponse]) │ │ │ │ + } else { │ │ │ │ + this._requestCount = 0; │ │ │ │ + this._numRequests = 0; │ │ │ │ + this.features = []; │ │ │ │ + var services = {}, │ │ │ │ + url; │ │ │ │ + for (var i = 0, len = layers.length; i < len; i++) { │ │ │ │ + var layer = layers[i]; │ │ │ │ + var service, found = false; │ │ │ │ + url = OpenLayers.Util.isArray(layer.url) ? layer.url[0] : layer.url; │ │ │ │ + if (url in services) { │ │ │ │ + services[url].push(layer) │ │ │ │ + } else { │ │ │ │ + this._numRequests++; │ │ │ │ + services[url] = [layer] │ │ │ │ } │ │ │ │ } │ │ │ │ + var layers; │ │ │ │ + for (var url in services) { │ │ │ │ + layers = services[url]; │ │ │ │ + var wmsOptions = this.buildWMSOptions(url, layers, clickPosition, layers[0].params.FORMAT); │ │ │ │ + OpenLayers.Request.GET(wmsOptions) │ │ │ │ + } │ │ │ │ } │ │ │ │ - var queue = types[OpenLayers.State.INSERT]; │ │ │ │ - if (queue.length > 0) { │ │ │ │ - resp.push(this.create(queue, OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: insertCallback, │ │ │ │ - scope: this │ │ │ │ - }, options.create))) │ │ │ │ - } │ │ │ │ - queue = types[OpenLayers.State.UPDATE]; │ │ │ │ - for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ - resp.push(this.update(queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: callback, │ │ │ │ - scope: this │ │ │ │ - }, options.update))) │ │ │ │ - } │ │ │ │ - queue = types[OpenLayers.State.DELETE]; │ │ │ │ - for (var i = queue.length - 1; i >= 0; --i) { │ │ │ │ - resp.push(this["delete"](queue[i], OpenLayers.Util.applyDefaults({ │ │ │ │ - callback: callback, │ │ │ │ - scope: this │ │ │ │ - }, options["delete"]))) │ │ │ │ - } │ │ │ │ - return resp │ │ │ │ - }, │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - response.priv.abort() │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - callUserCallback: function(resp, options) { │ │ │ │ - var opt = options[resp.requestType]; │ │ │ │ - if (opt && opt.callback) { │ │ │ │ - opt.callback.call(opt.scope, resp) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.HTTP" │ │ │ │ -}); │ │ │ │ -OpenLayers.Protocol.CSW.v2_0_2 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ - formatOptions: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!options.format) { │ │ │ │ - this.format = new OpenLayers.Format.CSWGetRecords.v2_0_2(OpenLayers.Util.extend({}, this.formatOptions)) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.options && !this.options.format) { │ │ │ │ - this.format.destroy() │ │ │ │ - } │ │ │ │ - this.format = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - read: function(options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - var data = this.format.write(options.params || options); │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, response, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers, │ │ │ │ - data: data │ │ │ │ + triggerGetFeatureInfo: function(request, xy, features) { │ │ │ │ + this.events.triggerEvent("getfeatureinfo", { │ │ │ │ + text: request.responseText, │ │ │ │ + features: features, │ │ │ │ + request: request, │ │ │ │ + xy: xy │ │ │ │ }); │ │ │ │ - return response │ │ │ │ - }, │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - response.data = this.parseData(request); │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ - } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ - } │ │ │ │ - options.callback.call(options.scope, response) │ │ │ │ - } │ │ │ │ + OpenLayers.Element.removeClass(this.map.viewPortDiv, "olCursorWait") │ │ │ │ }, │ │ │ │ - parseData: function(request) { │ │ │ │ + handleResponse: function(xy, request, url) { │ │ │ │ var doc = request.responseXML; │ │ │ │ if (!doc || !doc.documentElement) { │ │ │ │ doc = request.responseText │ │ │ │ } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null │ │ │ │ + var features = this.format.read(doc); │ │ │ │ + if (this.drillDown === false) { │ │ │ │ + this.triggerGetFeatureInfo(request, xy, features) │ │ │ │ + } else { │ │ │ │ + this._requestCount++; │ │ │ │ + if (this.output === "object") { │ │ │ │ + this._features = (this._features || []).concat({ │ │ │ │ + url: url, │ │ │ │ + features: features │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + this._features = (this._features || []).concat(features) │ │ │ │ + } │ │ │ │ + if (this._requestCount === this._numRequests) { │ │ │ │ + this.triggerGetFeatureInfo(request, xy, this._features.concat()); │ │ │ │ + delete this._features; │ │ │ │ + delete this._requestCount; │ │ │ │ + delete this._numRequests │ │ │ │ + } │ │ │ │ } │ │ │ │ - return this.format.read(doc) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.CSW.v2_0_2" │ │ │ │ + CLASS_NAME: "OpenLayers.Control.WMSGetFeatureInfo" │ │ │ │ }); │ │ │ │ -OpenLayers.Protocol.SOS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ - fois: null, │ │ │ │ - formatOptions: null, │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!options.format) { │ │ │ │ - this.format = new OpenLayers.Format.SOSGetFeatureOfInterest(this.formatOptions) │ │ │ │ - } │ │ │ │ - }, │ │ │ │ +OpenLayers.Control.Geolocate = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + geolocation: null, │ │ │ │ + available: "geolocation" in navigator, │ │ │ │ + bind: true, │ │ │ │ + watch: false, │ │ │ │ + geolocationOptions: null, │ │ │ │ destroy: function() { │ │ │ │ - if (this.options && !this.options.format) { │ │ │ │ - this.format.destroy() │ │ │ │ - } │ │ │ │ - this.format = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ - }, │ │ │ │ - read: function(options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - var format = this.format; │ │ │ │ - var data = OpenLayers.Format.XML.prototype.write.apply(format, [format.writeNode("sos:GetFeatureOfInterest", { │ │ │ │ - fois: this.fois │ │ │ │ - })]); │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, response, options), │ │ │ │ - data: data │ │ │ │ - }); │ │ │ │ - return response │ │ │ │ + this.deactivate(); │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - response.features = this.parseFeatures(request); │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + activate: function() { │ │ │ │ + if (this.available && !this.geolocation) { │ │ │ │ + this.geolocation = navigator.geolocation │ │ │ │ + } │ │ │ │ + if (!this.geolocation) { │ │ │ │ + this.events.triggerEvent("locationuncapable"); │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { │ │ │ │ + if (this.watch) { │ │ │ │ + this.watchId = this.geolocation.watchPosition(OpenLayers.Function.bind(this.geolocate, this), OpenLayers.Function.bind(this.failure, this), this.geolocationOptions) │ │ │ │ } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ + this.getCurrentLocation() │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, response) │ │ │ │ + return true │ │ │ │ } │ │ │ │ + return false │ │ │ │ }, │ │ │ │ - parseFeatures: function(request) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active && this.watchId !== null) { │ │ │ │ + this.geolocation.clearWatch(this.watchId) │ │ │ │ } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + geolocate: function(position) { │ │ │ │ + var center = new OpenLayers.LonLat(position.coords.longitude, position.coords.latitude).transform(new OpenLayers.Projection("EPSG:4326"), this.map.getProjectionObject()); │ │ │ │ + if (this.bind) { │ │ │ │ + this.map.setCenter(center) │ │ │ │ } │ │ │ │ - return this.format.read(doc) │ │ │ │ + this.events.triggerEvent("locationupdated", { │ │ │ │ + position: position, │ │ │ │ + point: new OpenLayers.Geometry.Point(center.lon, center.lat) │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.SOS.v1_0_0" │ │ │ │ + getCurrentLocation: function() { │ │ │ │ + if (!this.active || this.watch) { │ │ │ │ + return false │ │ │ │ + } │ │ │ │ + this.geolocation.getCurrentPosition(OpenLayers.Function.bind(this.geolocate, this), OpenLayers.Function.bind(this.failure, this), this.geolocationOptions); │ │ │ │ + return true │ │ │ │ + }, │ │ │ │ + failure: function(error) { │ │ │ │ + this.events.triggerEvent("locationfailed", { │ │ │ │ + error: error │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Geolocate" │ │ │ │ }); │ │ │ │ -OpenLayers.Protocol.WFS.v1 = OpenLayers.Class(OpenLayers.Protocol, { │ │ │ │ - version: null, │ │ │ │ - srsName: "EPSG:4326", │ │ │ │ - featureType: null, │ │ │ │ - featureNS: null, │ │ │ │ - geometryName: "the_geom", │ │ │ │ - schema: null, │ │ │ │ - featurePrefix: "feature", │ │ │ │ - formatOptions: null, │ │ │ │ - readFormat: null, │ │ │ │ - readOptions: null, │ │ │ │ +OpenLayers.Control.Snapping = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + DEFAULTS: { │ │ │ │ + tolerance: 10, │ │ │ │ + node: true, │ │ │ │ + edge: true, │ │ │ │ + vertex: true │ │ │ │ + }, │ │ │ │ + greedy: true, │ │ │ │ + precedence: ["node", "vertex", "edge"], │ │ │ │ + resolution: null, │ │ │ │ + geoToleranceCache: null, │ │ │ │ + layer: null, │ │ │ │ + feature: null, │ │ │ │ + point: null, │ │ │ │ initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.initialize.apply(this, [options]); │ │ │ │ - if (!options.format) { │ │ │ │ - this.format = OpenLayers.Format.WFST(OpenLayers.Util.extend({ │ │ │ │ - version: this.version, │ │ │ │ - featureType: this.featureType, │ │ │ │ - featureNS: this.featureNS, │ │ │ │ - featurePrefix: this.featurePrefix, │ │ │ │ - geometryName: this.geometryName, │ │ │ │ - srsName: this.srsName, │ │ │ │ - schema: this.schema │ │ │ │ - }, this.formatOptions)) │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + this.options = options || {}; │ │ │ │ + if (this.options.layer) { │ │ │ │ + this.setLayer(this.options.layer) │ │ │ │ } │ │ │ │ - if (!options.geometryName && parseFloat(this.format.version) > 1) { │ │ │ │ - this.setGeometryName(null) │ │ │ │ + var defaults = OpenLayers.Util.extend({}, this.options.defaults); │ │ │ │ + this.defaults = OpenLayers.Util.applyDefaults(defaults, this.DEFAULTS); │ │ │ │ + this.setTargets(this.options.targets); │ │ │ │ + if (this.targets.length === 0 && this.layer) { │ │ │ │ + this.addTargetLayer(this.layer) │ │ │ │ } │ │ │ │ + this.geoToleranceCache = {} │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - if (this.options && !this.options.format) { │ │ │ │ - this.format.destroy() │ │ │ │ + setLayer: function(layer) { │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = layer; │ │ │ │ + this.activate() │ │ │ │ + } else { │ │ │ │ + this.layer = layer │ │ │ │ } │ │ │ │ - this.format = null; │ │ │ │ - OpenLayers.Protocol.prototype.destroy.apply(this) │ │ │ │ }, │ │ │ │ - read: function(options) { │ │ │ │ - OpenLayers.Protocol.prototype.read.apply(this, arguments); │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options || {}); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "read" │ │ │ │ - }); │ │ │ │ - var data = OpenLayers.Format.XML.prototype.write.apply(this.format, [this.format.writeNode("wfs:GetFeature", options)]); │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - callback: this.createCallback(this.handleRead, response, options), │ │ │ │ - params: options.params, │ │ │ │ - headers: options.headers, │ │ │ │ - data: data │ │ │ │ - }); │ │ │ │ - return response │ │ │ │ - }, │ │ │ │ - setFeatureType: function(featureType) { │ │ │ │ - this.featureType = featureType; │ │ │ │ - this.format.featureType = featureType │ │ │ │ - }, │ │ │ │ - setGeometryName: function(geometryName) { │ │ │ │ - this.geometryName = geometryName; │ │ │ │ - this.format.geometryName = geometryName │ │ │ │ - }, │ │ │ │ - handleRead: function(response, options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - if (request.status >= 200 && request.status < 300) { │ │ │ │ - var result = this.parseResponse(request, options.readOptions); │ │ │ │ - if (result && result.success !== false) { │ │ │ │ - if (options.readOptions && options.readOptions.output == "object") { │ │ │ │ - OpenLayers.Util.extend(response, result) │ │ │ │ - } else { │ │ │ │ - response.features = result │ │ │ │ - } │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ + setTargets: function(targets) { │ │ │ │ + this.targets = []; │ │ │ │ + if (targets && targets.length) { │ │ │ │ + var target; │ │ │ │ + for (var i = 0, len = targets.length; i < len; ++i) { │ │ │ │ + target = targets[i]; │ │ │ │ + if (target instanceof OpenLayers.Layer.Vector) { │ │ │ │ + this.addTargetLayer(target) │ │ │ │ } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - response.error = result │ │ │ │ + this.addTarget(target) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE │ │ │ │ } │ │ │ │ - options.callback.call(options.scope, response) │ │ │ │ } │ │ │ │ }, │ │ │ │ - parseResponse: function(request, options) { │ │ │ │ - var doc = request.responseXML; │ │ │ │ - if (!doc || !doc.documentElement) { │ │ │ │ - doc = request.responseText │ │ │ │ - } │ │ │ │ - if (!doc || doc.length <= 0) { │ │ │ │ - return null │ │ │ │ - } │ │ │ │ - var result = this.readFormat !== null ? this.readFormat.read(doc) : this.format.read(doc, options); │ │ │ │ - if (!this.featureNS) { │ │ │ │ - var format = this.readFormat || this.format; │ │ │ │ - this.featureNS = format.featureNS; │ │ │ │ - format.autoConfig = false; │ │ │ │ - if (!this.geometryName) { │ │ │ │ - this.setGeometryName(format.geometryName) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return result │ │ │ │ - }, │ │ │ │ - commit: function(features, options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "commit", │ │ │ │ - reqFeatures: features │ │ │ │ - }); │ │ │ │ - response.priv = OpenLayers.Request.POST({ │ │ │ │ - url: options.url, │ │ │ │ - headers: options.headers, │ │ │ │ - data: this.format.write(features, options), │ │ │ │ - callback: this.createCallback(this.handleCommit, response, options) │ │ │ │ - }); │ │ │ │ - return response │ │ │ │ + addTargetLayer: function(layer) { │ │ │ │ + this.addTarget({ │ │ │ │ + layer: layer │ │ │ │ + }) │ │ │ │ }, │ │ │ │ - handleCommit: function(response, options) { │ │ │ │ - if (options.callback) { │ │ │ │ - var request = response.priv; │ │ │ │ - var data = request.responseXML; │ │ │ │ - if (!data || !data.documentElement) { │ │ │ │ - data = request.responseText │ │ │ │ - } │ │ │ │ - var obj = this.format.read(data) || {}; │ │ │ │ - response.insertIds = obj.insertIds || []; │ │ │ │ - if (obj.success) { │ │ │ │ - response.code = OpenLayers.Protocol.Response.SUCCESS │ │ │ │ - } else { │ │ │ │ - response.code = OpenLayers.Protocol.Response.FAILURE; │ │ │ │ - response.error = obj │ │ │ │ - } │ │ │ │ - options.callback.call(options.scope, response) │ │ │ │ - } │ │ │ │ + addTarget: function(target) { │ │ │ │ + target = OpenLayers.Util.applyDefaults(target, this.defaults); │ │ │ │ + target.nodeTolerance = target.nodeTolerance || target.tolerance; │ │ │ │ + target.vertexTolerance = target.vertexTolerance || target.tolerance; │ │ │ │ + target.edgeTolerance = target.edgeTolerance || target.tolerance; │ │ │ │ + this.targets.push(target) │ │ │ │ }, │ │ │ │ - filterDelete: function(filter, options) { │ │ │ │ - options = OpenLayers.Util.extend({}, options); │ │ │ │ - OpenLayers.Util.applyDefaults(options, this.options); │ │ │ │ - var response = new OpenLayers.Protocol.Response({ │ │ │ │ - requestType: "commit" │ │ │ │ - }); │ │ │ │ - var root = this.format.createElementNSPlus("wfs:Transaction", { │ │ │ │ - attributes: { │ │ │ │ - service: "WFS", │ │ │ │ - version: this.version │ │ │ │ - } │ │ │ │ - }); │ │ │ │ - var deleteNode = this.format.createElementNSPlus("wfs:Delete", { │ │ │ │ - attributes: { │ │ │ │ - typeName: (options.featureNS ? this.featurePrefix + ":" : "") + options.featureType │ │ │ │ + removeTargetLayer: function(layer) { │ │ │ │ + var target; │ │ │ │ + for (var i = this.targets.length - 1; i >= 0; --i) { │ │ │ │ + target = this.targets[i]; │ │ │ │ + if (target.layer === layer) { │ │ │ │ + this.removeTarget(target) │ │ │ │ } │ │ │ │ - }); │ │ │ │ - if (options.featureNS) { │ │ │ │ - deleteNode.setAttribute("xmlns:" + this.featurePrefix, options.featureNS) │ │ │ │ } │ │ │ │ - var filterNode = this.format.writeNode("ogc:Filter", filter); │ │ │ │ - deleteNode.appendChild(filterNode); │ │ │ │ - root.appendChild(deleteNode); │ │ │ │ - var data = OpenLayers.Format.XML.prototype.write.apply(this.format, [root]); │ │ │ │ - return OpenLayers.Request.POST({ │ │ │ │ - url: this.url, │ │ │ │ - callback: options.callback || function() {}, │ │ │ │ - data: data │ │ │ │ - }) │ │ │ │ }, │ │ │ │ - abort: function(response) { │ │ │ │ - if (response) { │ │ │ │ - response.priv.abort() │ │ │ │ - } │ │ │ │ + removeTarget: function(target) { │ │ │ │ + return OpenLayers.Util.removeItem(this.targets, target) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.WFS.v1" │ │ │ │ -}); │ │ │ │ -OpenLayers.Protocol.WFS.v1_1_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ - version: "1.1.0", │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Protocol.WFS.v1.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.outputFormat && !this.readFormat) { │ │ │ │ - if (this.outputFormat.toLowerCase() == "gml2") { │ │ │ │ - this.readFormat = new OpenLayers.Format.GML.v2({ │ │ │ │ - featureType: this.featureType, │ │ │ │ - featureNS: this.featureNS, │ │ │ │ - geometryName: this.geometryName │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Control.prototype.activate.call(this); │ │ │ │ + if (activated) { │ │ │ │ + if (this.layer && this.layer.events) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + sketchstarted: this.onSketchModified, │ │ │ │ + sketchmodified: this.onSketchModified, │ │ │ │ + vertexmodified: this.onVertexModified, │ │ │ │ + scope: this │ │ │ │ }) │ │ │ │ - } else if (this.outputFormat.toLowerCase() == "json") { │ │ │ │ - this.readFormat = new OpenLayers.Format.GeoJSON │ │ │ │ } │ │ │ │ } │ │ │ │ + return activated │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.WFS.v1_1_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Protocol.WFS.v1_0_0 = OpenLayers.Class(OpenLayers.Protocol.WFS.v1, { │ │ │ │ - version: "1.0.0", │ │ │ │ - CLASS_NAME: "OpenLayers.Protocol.WFS.v1_0_0" │ │ │ │ -}); │ │ │ │ -OpenLayers.Events.featureclick = OpenLayers.Class({ │ │ │ │ - cache: null, │ │ │ │ - map: null, │ │ │ │ - provides: ["featureclick", "nofeatureclick", "featureover", "featureout"], │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - if (target.object instanceof OpenLayers.Map) { │ │ │ │ - this.setMap(target.object) │ │ │ │ - } else if (target.object instanceof OpenLayers.Layer.Vector) { │ │ │ │ - if (target.object.map) { │ │ │ │ - this.setMap(target.object.map) │ │ │ │ - } else { │ │ │ │ - target.object.events.register("added", this, function(evt) { │ │ │ │ - this.setMap(target.object.map) │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Control.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + if (this.layer && this.layer.events) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + sketchstarted: this.onSketchModified, │ │ │ │ + sketchmodified: this.onSketchModified, │ │ │ │ + vertexmodified: this.onVertexModified, │ │ │ │ + scope: this │ │ │ │ }) │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - throw "Listeners for '" + this.provides.join("', '") + "' events can only be registered for OpenLayers.Layer.Vector " + "or OpenLayers.Map instances" │ │ │ │ } │ │ │ │ - for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ - target.extensions[this.provides[i]] = true │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - this.cache = {}; │ │ │ │ - map.events.register("mousedown", this, this.start, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("mouseup", this, this.onClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("touchstart", this, this.start, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("touchmove", this, this.cancel, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("touchend", this, this.onClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - map.events.register("mousemove", this, this.onMousemove, { │ │ │ │ - extension: true │ │ │ │ - }) │ │ │ │ + this.feature = null; │ │ │ │ + this.point = null; │ │ │ │ + return deactivated │ │ │ │ }, │ │ │ │ - start: function(evt) { │ │ │ │ - this.startEvt = evt │ │ │ │ + onSketchModified: function(event) { │ │ │ │ + this.feature = event.feature; │ │ │ │ + this.considerSnapping(event.vertex, event.vertex) │ │ │ │ }, │ │ │ │ - cancel: function(evt) { │ │ │ │ - delete this.startEvt │ │ │ │ + onVertexModified: function(event) { │ │ │ │ + this.feature = event.feature; │ │ │ │ + var loc = this.layer.map.getLonLatFromViewPortPx(event.pixel); │ │ │ │ + this.considerSnapping(event.vertex, new OpenLayers.Geometry.Point(loc.lon, loc.lat)) │ │ │ │ }, │ │ │ │ - onClick: function(evt) { │ │ │ │ - if (!this.startEvt || evt.type !== "touchend" && !OpenLayers.Event.isLeftClick(evt)) { │ │ │ │ - return │ │ │ │ - } │ │ │ │ - var features = this.getFeatures(this.startEvt); │ │ │ │ - delete this.startEvt; │ │ │ │ - var feature, layer, more, clicked = {}; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - layer = feature.layer; │ │ │ │ - clicked[layer.id] = true; │ │ │ │ - more = this.triggerEvent("featureclick", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (more === false) { │ │ │ │ - break │ │ │ │ + considerSnapping: function(point, loc) { │ │ │ │ + var best = { │ │ │ │ + rank: Number.POSITIVE_INFINITY, │ │ │ │ + dist: Number.POSITIVE_INFINITY, │ │ │ │ + x: null, │ │ │ │ + y: null │ │ │ │ + }; │ │ │ │ + var snapped = false; │ │ │ │ + var result, target; │ │ │ │ + for (var i = 0, len = this.targets.length; i < len; ++i) { │ │ │ │ + target = this.targets[i]; │ │ │ │ + result = this.testTarget(target, loc); │ │ │ │ + if (result) { │ │ │ │ + if (this.greedy) { │ │ │ │ + best = result; │ │ │ │ + best.target = target; │ │ │ │ + snapped = true; │ │ │ │ + break │ │ │ │ + } else { │ │ │ │ + if (result.rank < best.rank || result.rank === best.rank && result.dist < best.dist) { │ │ │ │ + best = result; │ │ │ │ + best.target = target; │ │ │ │ + snapped = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ - for (i = 0, len = this.map.layers.length; i < len; ++i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector && !clicked[layer.id]) { │ │ │ │ - this.triggerEvent("nofeatureclick", { │ │ │ │ - layer: layer │ │ │ │ + if (snapped) { │ │ │ │ + var proceed = this.events.triggerEvent("beforesnap", { │ │ │ │ + point: point, │ │ │ │ + x: best.x, │ │ │ │ + y: best.y, │ │ │ │ + distance: best.dist, │ │ │ │ + layer: best.target.layer, │ │ │ │ + snapType: this.precedence[best.rank] │ │ │ │ + }); │ │ │ │ + if (proceed !== false) { │ │ │ │ + point.x = best.x; │ │ │ │ + point.y = best.y; │ │ │ │ + this.point = point; │ │ │ │ + this.events.triggerEvent("snap", { │ │ │ │ + point: point, │ │ │ │ + snapType: this.precedence[best.rank], │ │ │ │ + layer: best.target.layer, │ │ │ │ + distance: best.dist │ │ │ │ }) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - onMousemove: function(evt) { │ │ │ │ - delete this.startEvt; │ │ │ │ - var features = this.getFeatures(evt); │ │ │ │ - var over = {}, │ │ │ │ - newly = [], │ │ │ │ - feature; │ │ │ │ - for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ - feature = features[i]; │ │ │ │ - over[feature.id] = feature; │ │ │ │ - if (!this.cache[feature.id]) { │ │ │ │ - newly.push(feature) │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var out = []; │ │ │ │ - for (var id in this.cache) { │ │ │ │ - feature = this.cache[id]; │ │ │ │ - if (feature.layer && feature.layer.map) { │ │ │ │ - if (!over[feature.id]) { │ │ │ │ - out.push(feature) │ │ │ │ - } │ │ │ │ } else { │ │ │ │ - delete this.cache[id] │ │ │ │ + snapped = false │ │ │ │ } │ │ │ │ } │ │ │ │ - var more; │ │ │ │ - for (i = 0, len = newly.length; i < len; ++i) { │ │ │ │ - feature = newly[i]; │ │ │ │ - this.cache[feature.id] = feature; │ │ │ │ - more = this.triggerEvent("featureover", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (more === false) { │ │ │ │ - break │ │ │ │ - } │ │ │ │ + if (this.point && !snapped) { │ │ │ │ + point.x = loc.x; │ │ │ │ + point.y = loc.y; │ │ │ │ + this.point = null; │ │ │ │ + this.events.triggerEvent("unsnap", { │ │ │ │ + point: point │ │ │ │ + }) │ │ │ │ } │ │ │ │ - for (i = 0, len = out.length; i < len; ++i) { │ │ │ │ - feature = out[i]; │ │ │ │ - delete this.cache[feature.id]; │ │ │ │ - more = this.triggerEvent("featureout", { │ │ │ │ - feature: feature │ │ │ │ - }); │ │ │ │ - if (more === false) { │ │ │ │ - break │ │ │ │ + }, │ │ │ │ + testTarget: function(target, loc) { │ │ │ │ + var resolution = this.layer.map.getResolution(); │ │ │ │ + if ("minResolution" in target) { │ │ │ │ + if (resolution < target.minResolution) { │ │ │ │ + return null │ │ │ │ } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - triggerEvent: function(type, evt) { │ │ │ │ - var layer = evt.feature ? evt.feature.layer : evt.layer, │ │ │ │ - object = this.target.object; │ │ │ │ - if (object instanceof OpenLayers.Map || object === layer) { │ │ │ │ - return this.target.triggerEvent(type, evt) │ │ │ │ + if ("maxResolution" in target) { │ │ │ │ + if (resolution >= target.maxResolution) { │ │ │ │ + return null │ │ │ │ + } │ │ │ │ } │ │ │ │ - }, │ │ │ │ - getFeatures: function(evt) { │ │ │ │ - var x = evt.clientX, │ │ │ │ - y = evt.clientY, │ │ │ │ - features = [], │ │ │ │ - targets = [], │ │ │ │ - layers = [], │ │ │ │ - layer, target, feature, i, len; │ │ │ │ - for (i = this.map.layers.length - 1; i >= 0; --i) { │ │ │ │ - layer = this.map.layers[i]; │ │ │ │ - if (layer.div.style.display !== "none") { │ │ │ │ - if (layer.renderer instanceof OpenLayers.Renderer.Elements) { │ │ │ │ - if (layer instanceof OpenLayers.Layer.Vector) { │ │ │ │ - target = document.elementFromPoint(x, y); │ │ │ │ - while (target && target._featureId) { │ │ │ │ - feature = layer.getFeatureById(target._featureId); │ │ │ │ - if (feature) { │ │ │ │ - features.push(feature); │ │ │ │ - target.style.display = "none"; │ │ │ │ - targets.push(target); │ │ │ │ - target = document.elementFromPoint(x, y) │ │ │ │ + var tolerance = { │ │ │ │ + node: this.getGeoTolerance(target.nodeTolerance, resolution), │ │ │ │ + vertex: this.getGeoTolerance(target.vertexTolerance, resolution), │ │ │ │ + edge: this.getGeoTolerance(target.edgeTolerance, resolution) │ │ │ │ + }; │ │ │ │ + var maxTolerance = Math.max(tolerance.node, tolerance.vertex, tolerance.edge); │ │ │ │ + var result = { │ │ │ │ + rank: Number.POSITIVE_INFINITY, │ │ │ │ + dist: Number.POSITIVE_INFINITY │ │ │ │ + }; │ │ │ │ + var eligible = false; │ │ │ │ + var features = target.layer.features; │ │ │ │ + var feature, type, vertices, vertex, closest, dist, found; │ │ │ │ + var numTypes = this.precedence.length; │ │ │ │ + var ll = new OpenLayers.LonLat(loc.x, loc.y); │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + feature = features[i]; │ │ │ │ + if (feature !== this.feature && !feature._sketch && feature.state !== OpenLayers.State.DELETE && (!target.filter || target.filter.evaluate(feature))) { │ │ │ │ + if (feature.atPoint(ll, maxTolerance, maxTolerance)) { │ │ │ │ + for (var j = 0, stop = Math.min(result.rank + 1, numTypes); j < stop; ++j) { │ │ │ │ + type = this.precedence[j]; │ │ │ │ + if (target[type]) { │ │ │ │ + if (type === "edge") { │ │ │ │ + closest = feature.geometry.distanceTo(loc, { │ │ │ │ + details: true │ │ │ │ + }); │ │ │ │ + dist = closest.distance; │ │ │ │ + if (dist <= tolerance[type] && dist < result.dist) { │ │ │ │ + result = { │ │ │ │ + rank: j, │ │ │ │ + dist: dist, │ │ │ │ + x: closest.x0, │ │ │ │ + y: closest.y0 │ │ │ │ + }; │ │ │ │ + eligible = true; │ │ │ │ + break │ │ │ │ + } │ │ │ │ } else { │ │ │ │ - target = false │ │ │ │ + vertices = feature.geometry.getVertices(type === "node"); │ │ │ │ + found = false; │ │ │ │ + for (var k = 0, klen = vertices.length; k < klen; ++k) { │ │ │ │ + vertex = vertices[k]; │ │ │ │ + dist = vertex.distanceTo(loc); │ │ │ │ + if (dist <= tolerance[type] && (j < result.rank || j === result.rank && dist < result.dist)) { │ │ │ │ + result = { │ │ │ │ + rank: j, │ │ │ │ + dist: dist, │ │ │ │ + x: vertex.x, │ │ │ │ + y: vertex.y │ │ │ │ + }; │ │ │ │ + eligible = true; │ │ │ │ + found = true │ │ │ │ + } │ │ │ │ + } │ │ │ │ + if (found) { │ │ │ │ + break │ │ │ │ + } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - layers.push(layer); │ │ │ │ - layer.div.style.display = "none" │ │ │ │ - } else if (layer.renderer instanceof OpenLayers.Renderer.Canvas) { │ │ │ │ - feature = layer.renderer.getFeatureIdFromEvent(evt); │ │ │ │ - if (feature) { │ │ │ │ - features.push(feature); │ │ │ │ - layers.push(layer) │ │ │ │ - } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - for (i = 0, len = targets.length; i < len; ++i) { │ │ │ │ - targets[i].style.display = "" │ │ │ │ + return eligible ? result : null │ │ │ │ + }, │ │ │ │ + getGeoTolerance: function(tolerance, resolution) { │ │ │ │ + if (resolution !== this.resolution) { │ │ │ │ + this.resolution = resolution; │ │ │ │ + this.geoToleranceCache = {} │ │ │ │ } │ │ │ │ - for (i = layers.length - 1; i >= 0; --i) { │ │ │ │ - layers[i].div.style.display = "block" │ │ │ │ + var geoTolerance = this.geoToleranceCache[tolerance]; │ │ │ │ + if (geoTolerance === undefined) { │ │ │ │ + geoTolerance = tolerance * resolution; │ │ │ │ + this.geoToleranceCache[tolerance] = geoTolerance │ │ │ │ } │ │ │ │ - return features │ │ │ │ + return geoTolerance │ │ │ │ }, │ │ │ │ destroy: function() { │ │ │ │ - for (var i = this.provides.length - 1; i >= 0; --i) { │ │ │ │ - delete this.target.extensions[this.provides[i]] │ │ │ │ + if (this.active) { │ │ │ │ + this.deactivate() │ │ │ │ } │ │ │ │ - this.map.events.un({ │ │ │ │ - mousemove: this.onMousemove, │ │ │ │ - mousedown: this.start, │ │ │ │ - mouseup: this.onClick, │ │ │ │ - touchstart: this.start, │ │ │ │ - touchmove: this.cancel, │ │ │ │ - touchend: this.onClick, │ │ │ │ - scope: this │ │ │ │ - }); │ │ │ │ - delete this.cache; │ │ │ │ - delete this.map; │ │ │ │ - delete this.target │ │ │ │ - } │ │ │ │ + delete this.layer; │ │ │ │ + delete this.targets; │ │ │ │ + OpenLayers.Control.prototype.destroy.call(this) │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.Snapping" │ │ │ │ }); │ │ │ │ -OpenLayers.Events.nofeatureclick = OpenLayers.Events.featureclick; │ │ │ │ -OpenLayers.Events.featureover = OpenLayers.Events.featureclick; │ │ │ │ -OpenLayers.Events.featureout = OpenLayers.Events.featureclick; │ │ │ │ -OpenLayers.Popup.Anchored = OpenLayers.Class(OpenLayers.Popup, { │ │ │ │ - relativePosition: null, │ │ │ │ - keepInMap: true, │ │ │ │ - anchor: null, │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ - var newArguments = [id, lonlat, contentSize, 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) │ │ │ │ +OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ + multipleKey: null, │ │ │ │ + toggleKey: null, │ │ │ │ + multiple: false, │ │ │ │ + clickout: true, │ │ │ │ + toggle: false, │ │ │ │ + hover: false, │ │ │ │ + highlightOnly: false, │ │ │ │ + box: false, │ │ │ │ + onBeforeSelect: function() {}, │ │ │ │ + onSelect: function() {}, │ │ │ │ + onUnselect: function() {}, │ │ │ │ + scope: null, │ │ │ │ + geometryTypes: null, │ │ │ │ + layer: null, │ │ │ │ + layers: null, │ │ │ │ + callbacks: null, │ │ │ │ + selectStyle: null, │ │ │ │ + renderIntent: "select", │ │ │ │ + handlers: null, │ │ │ │ + initialize: function(layers, options) { │ │ │ │ + OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ + if (this.scope === null) { │ │ │ │ + this.scope = this │ │ │ │ } │ │ │ │ - }, │ │ │ │ - destroy: function() { │ │ │ │ - this.anchor = null; │ │ │ │ - this.relativePosition = null; │ │ │ │ - OpenLayers.Popup.prototype.destroy.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - show: function() { │ │ │ │ - this.updatePosition(); │ │ │ │ - OpenLayers.Popup.prototype.show.apply(this, arguments) │ │ │ │ - }, │ │ │ │ - moveTo: function(px) { │ │ │ │ - var oldRelativePosition = this.relativePosition; │ │ │ │ - this.relativePosition = this.calculateRelativePosition(px); │ │ │ │ - OpenLayers.Popup.prototype.moveTo.call(this, this.calculateNewPx(px)); │ │ │ │ - if (this.relativePosition != oldRelativePosition) { │ │ │ │ - this.updateRelativePosition() │ │ │ │ + this.initLayer(layers); │ │ │ │ + var callbacks = { │ │ │ │ + click: this.clickFeature, │ │ │ │ + clickout: this.clickoutFeature │ │ │ │ + }; │ │ │ │ + if (this.hover) { │ │ │ │ + callbacks.over = this.overFeature; │ │ │ │ + callbacks.out = this.outFeature │ │ │ │ } │ │ │ │ - }, │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.prototype.setSize.apply(this, arguments); │ │ │ │ - if (this.lonlat && this.map) { │ │ │ │ - var px = this.map.getLayerPxFromLonLat(this.lonlat); │ │ │ │ - this.moveTo(px) │ │ │ │ + this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks); │ │ │ │ + this.handlers = { │ │ │ │ + feature: new OpenLayers.Handler.Feature(this, this.layer, this.callbacks, { │ │ │ │ + geometryTypes: this.geometryTypes │ │ │ │ + }) │ │ │ │ + }; │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box = new OpenLayers.Handler.Box(this, { │ │ │ │ + done: this.selectBox │ │ │ │ + }, { │ │ │ │ + boxDivClassName: "olHandlerBoxSelectFeature" │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - calculateRelativePosition: function(px) { │ │ │ │ - var lonlat = this.map.getLonLatFromLayerPx(px); │ │ │ │ - var extent = this.map.getExtent(); │ │ │ │ - var quadrant = extent.determineQuadrant(lonlat); │ │ │ │ - return OpenLayers.Bounds.oppositeQuadrant(quadrant) │ │ │ │ + initLayer: function(layers) { │ │ │ │ + if (OpenLayers.Util.isArray(layers)) { │ │ │ │ + this.layers = layers; │ │ │ │ + this.layer = new OpenLayers.Layer.Vector.RootContainer(this.id + "_container", { │ │ │ │ + layers: layers │ │ │ │ + }) │ │ │ │ + } else { │ │ │ │ + this.layer = layers │ │ │ │ + } │ │ │ │ }, │ │ │ │ - updateRelativePosition: function() {}, │ │ │ │ - calculateNewPx: function(px) { │ │ │ │ - var newPx = px.offset(this.anchor.offset); │ │ │ │ - var size = this.size || this.contentSize; │ │ │ │ - var top = this.relativePosition.charAt(0) == "t"; │ │ │ │ - newPx.y += top ? -size.h : this.anchor.size.h; │ │ │ │ - var left = this.relativePosition.charAt(1) == "l"; │ │ │ │ - newPx.x += left ? -size.w : this.anchor.size.w; │ │ │ │ - return newPx │ │ │ │ + destroy: function() { │ │ │ │ + if (this.active && this.layers) { │ │ │ │ + this.map.removeLayer(this.layer) │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy() │ │ │ │ + } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Anchored" │ │ │ │ -}); │ │ │ │ -OpenLayers.Popup.Framed = OpenLayers.Class(OpenLayers.Popup.Anchored, { │ │ │ │ - imageSrc: null, │ │ │ │ - imageSize: null, │ │ │ │ - isAlphaImage: false, │ │ │ │ - positionBlocks: null, │ │ │ │ - blocks: null, │ │ │ │ - fixedRelativePosition: false, │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ - OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); │ │ │ │ - if (this.fixedRelativePosition) { │ │ │ │ - this.updateRelativePosition(); │ │ │ │ - this.calculateRelativePosition = function(px) { │ │ │ │ - return this.relativePosition │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.addLayer(this.layer) │ │ │ │ + } │ │ │ │ + this.handlers.feature.activate(); │ │ │ │ + if (this.box && this.handlers.box) { │ │ │ │ + this.handlers.box.activate() │ │ │ │ } │ │ │ │ } │ │ │ │ - this.contentDiv.style.position = "absolute"; │ │ │ │ - this.contentDiv.style.zIndex = 1; │ │ │ │ - if (closeBox) { │ │ │ │ - this.closeDiv.style.zIndex = 1 │ │ │ │ + return OpenLayers.Control.prototype.activate.apply(this, arguments) │ │ │ │ + }, │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.handlers.feature.deactivate(); │ │ │ │ + if (this.handlers.box) { │ │ │ │ + this.handlers.box.deactivate() │ │ │ │ + } │ │ │ │ + if (this.layers) { │ │ │ │ + this.map.removeLayer(this.layer) │ │ │ │ + } │ │ │ │ } │ │ │ │ - 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%" │ │ │ │ + return OpenLayers.Control.prototype.deactivate.apply(this, arguments) │ │ │ │ }, │ │ │ │ - destroy: function() { │ │ │ │ - this.imageSrc = null; │ │ │ │ - this.imageSize = null; │ │ │ │ - this.isAlphaImage = null; │ │ │ │ - this.fixedRelativePosition = false; │ │ │ │ - this.positionBlocks = null; │ │ │ │ - for (var i = 0; i < this.blocks.length; i++) { │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - if (block.image) { │ │ │ │ - block.div.removeChild(block.image) │ │ │ │ + unselectAll: function(options) { │ │ │ │ + var layers = this.layers || [this.layer], │ │ │ │ + layer, feature, l, numExcept; │ │ │ │ + for (l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + numExcept = 0; │ │ │ │ + if (layer.selectedFeatures != null) { │ │ │ │ + while (layer.selectedFeatures.length > numExcept) { │ │ │ │ + feature = layer.selectedFeatures[numExcept]; │ │ │ │ + if (!options || options.except != feature) { │ │ │ │ + this.unselect(feature) │ │ │ │ + } else { │ │ │ │ + ++numExcept │ │ │ │ + } │ │ │ │ + } │ │ │ │ } │ │ │ │ - block.image = null; │ │ │ │ - if (block.div) { │ │ │ │ - this.groupDiv.removeChild(block.div) │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + clickFeature: function(feature) { │ │ │ │ + if (!this.hover) { │ │ │ │ + var selected = OpenLayers.Util.indexOf(feature.layer.selectedFeatures, feature) > -1; │ │ │ │ + if (selected) { │ │ │ │ + if (this.toggleSelect()) { │ │ │ │ + this.unselect(feature) │ │ │ │ + } else if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll({ │ │ │ │ + except: feature │ │ │ │ + }) │ │ │ │ + } │ │ │ │ + this.select(feature) │ │ │ │ } │ │ │ │ - block.div = null │ │ │ │ } │ │ │ │ - this.blocks = null; │ │ │ │ - OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments) │ │ │ │ }, │ │ │ │ - setBackgroundColor: function(color) {}, │ │ │ │ - setBorder: function() {}, │ │ │ │ - setOpacity: function(opacity) {}, │ │ │ │ - setSize: function(contentSize) { │ │ │ │ - OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); │ │ │ │ - this.updateBlocks() │ │ │ │ + multipleSelect: function() { │ │ │ │ + return this.multiple || this.handlers.feature.evt && this.handlers.feature.evt[this.multipleKey] │ │ │ │ }, │ │ │ │ - updateRelativePosition: function() { │ │ │ │ - this.padding = this.positionBlocks[this.relativePosition].padding; │ │ │ │ - if (this.closeDiv) { │ │ │ │ - var contentDivPadding = this.getContentDivPadding(); │ │ │ │ - this.closeDiv.style.right = contentDivPadding.right + this.padding.right + "px"; │ │ │ │ - this.closeDiv.style.top = contentDivPadding.top + this.padding.top + "px" │ │ │ │ + toggleSelect: function() { │ │ │ │ + return this.toggle || this.handlers.feature.evt && this.handlers.feature.evt[this.toggleKey] │ │ │ │ + }, │ │ │ │ + clickoutFeature: function(feature) { │ │ │ │ + if (!this.hover && this.clickout) { │ │ │ │ + this.unselectAll() │ │ │ │ } │ │ │ │ - this.updateBlocks() │ │ │ │ }, │ │ │ │ - calculateNewPx: function(px) { │ │ │ │ - var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply(this, arguments); │ │ │ │ - newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset); │ │ │ │ - return newPx │ │ │ │ + overFeature: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + this.highlight(feature) │ │ │ │ + } else if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ }, │ │ │ │ - createBlocks: function() { │ │ │ │ - this.blocks = []; │ │ │ │ - var firstPosition = null; │ │ │ │ - for (var key in this.positionBlocks) { │ │ │ │ - firstPosition = key; │ │ │ │ - break │ │ │ │ + outFeature: function(feature) { │ │ │ │ + if (this.hover) { │ │ │ │ + if (this.highlightOnly) { │ │ │ │ + if (feature._lastHighlighter == this.id) { │ │ │ │ + if (feature._prevHighlighter && feature._prevHighlighter != this.id) { │ │ │ │ + delete feature._lastHighlighter; │ │ │ │ + var control = this.map.getControl(feature._prevHighlighter); │ │ │ │ + if (control) { │ │ │ │ + control.highlight(feature) │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unhighlight(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + this.unselect(feature) │ │ │ │ + } │ │ │ │ } │ │ │ │ - var position = this.positionBlocks[firstPosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - var block = {}; │ │ │ │ - this.blocks.push(block); │ │ │ │ - var divId = this.id + "_FrameDecorationDiv_" + i; │ │ │ │ - block.div = OpenLayers.Util.createDiv(divId, null, null, null, "absolute", null, "hidden", null); │ │ │ │ - var imgId = this.id + "_FrameDecorationImg_" + i; │ │ │ │ - var imageCreator = this.isAlphaImage ? OpenLayers.Util.createAlphaImageDiv : OpenLayers.Util.createImage; │ │ │ │ - block.image = imageCreator(imgId, null, this.imageSize, this.imageSrc, "absolute", null, null, null); │ │ │ │ - block.div.appendChild(block.image); │ │ │ │ - this.groupDiv.appendChild(block.div) │ │ │ │ + }, │ │ │ │ + highlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + var cont = this.events.triggerEvent("beforefeaturehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + feature._prevHighlighter = feature._lastHighlighter; │ │ │ │ + feature._lastHighlighter = this.id; │ │ │ │ + var style = this.selectStyle || this.renderIntent; │ │ │ │ + layer.drawFeature(feature, style); │ │ │ │ + this.events.triggerEvent("featurehighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - updateBlocks: function() { │ │ │ │ - if (!this.blocks) { │ │ │ │ - this.createBlocks() │ │ │ │ + unhighlight: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (feature._prevHighlighter == undefined) { │ │ │ │ + delete feature._lastHighlighter │ │ │ │ + } else if (feature._prevHighlighter == this.id) { │ │ │ │ + delete feature._prevHighlighter │ │ │ │ + } else { │ │ │ │ + feature._lastHighlighter = feature._prevHighlighter; │ │ │ │ + delete feature._prevHighlighter │ │ │ │ } │ │ │ │ - if (this.size && this.relativePosition) { │ │ │ │ - var position = this.positionBlocks[this.relativePosition]; │ │ │ │ - for (var i = 0; i < position.blocks.length; i++) { │ │ │ │ - var positionBlock = position.blocks[i]; │ │ │ │ - var block = this.blocks[i]; │ │ │ │ - var l = positionBlock.anchor.left; │ │ │ │ - var b = positionBlock.anchor.bottom; │ │ │ │ - var r = positionBlock.anchor.right; │ │ │ │ - var t = positionBlock.anchor.top; │ │ │ │ - var w = isNaN(positionBlock.size.w) ? this.size.w - (r + l) : positionBlock.size.w; │ │ │ │ - var h = isNaN(positionBlock.size.h) ? this.size.h - (b + t) : positionBlock.size.h; │ │ │ │ - block.div.style.width = (w < 0 ? 0 : w) + "px"; │ │ │ │ - block.div.style.height = (h < 0 ? 0 : h) + "px"; │ │ │ │ - block.div.style.left = l != null ? l + "px" : ""; │ │ │ │ - block.div.style.bottom = b != null ? b + "px" : ""; │ │ │ │ - block.div.style.right = r != null ? r + "px" : ""; │ │ │ │ - block.div.style.top = t != null ? t + "px" : ""; │ │ │ │ - block.image.style.left = positionBlock.position.x + "px"; │ │ │ │ - block.image.style.top = positionBlock.position.y + "px" │ │ │ │ + layer.drawFeature(feature, feature.style || feature.layer.style || "default"); │ │ │ │ + this.events.triggerEvent("featureunhighlighted", { │ │ │ │ + feature: feature │ │ │ │ + }) │ │ │ │ + }, │ │ │ │ + select: function(feature) { │ │ │ │ + var cont = this.onBeforeSelect.call(this.scope, feature); │ │ │ │ + var layer = feature.layer; │ │ │ │ + if (cont !== false) { │ │ │ │ + cont = layer.events.triggerEvent("beforefeatureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + if (cont !== false) { │ │ │ │ + layer.selectedFeatures.push(feature); │ │ │ │ + this.highlight(feature); │ │ │ │ + if (!this.handlers.feature.lastFeature) { │ │ │ │ + this.handlers.feature.lastFeature = layer.selectedFeatures[0] │ │ │ │ + } │ │ │ │ + layer.events.triggerEvent("featureselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onSelect.call(this.scope, feature) │ │ │ │ } │ │ │ │ - this.contentDiv.style.left = this.padding.left + "px"; │ │ │ │ - this.contentDiv.style.top = this.padding.top + "px" │ │ │ │ } │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.Framed" │ │ │ │ -}); │ │ │ │ -OpenLayers.Popup.FramedCloud = OpenLayers.Class(OpenLayers.Popup.Framed, { │ │ │ │ - contentDisplayClass: "olFramedCloudPopupContent", │ │ │ │ - autoSize: true, │ │ │ │ - panMapIfOutOfView: true, │ │ │ │ - imageSize: new OpenLayers.Size(1276, 736), │ │ │ │ - isAlphaImage: false, │ │ │ │ - fixedRelativePosition: false, │ │ │ │ - positionBlocks: { │ │ │ │ - tl: { │ │ │ │ - offset: new OpenLayers.Pixel(44, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 18), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -632) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -688) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - tr: { │ │ │ │ - offset: new OpenLayers.Pixel(-45, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 40, 8, 9), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 51, 22, 0), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 50, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 19), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 32, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -631) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 19), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 32, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -631) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 35), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, null, null), │ │ │ │ - position: new OpenLayers.Pixel(-215, -687) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - bl: { │ │ │ │ - offset: new OpenLayers.Pixel(45, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(null, null, 0, 0), │ │ │ │ - position: new OpenLayers.Pixel(-101, -674) │ │ │ │ - }] │ │ │ │ - }, │ │ │ │ - br: { │ │ │ │ - offset: new OpenLayers.Pixel(-44, 0), │ │ │ │ - padding: new OpenLayers.Bounds(8, 9, 8, 40), │ │ │ │ - blocks: [{ │ │ │ │ - size: new OpenLayers.Size("auto", "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 21, 22, 32), │ │ │ │ - position: new OpenLayers.Pixel(0, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, "auto"), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 21, 0, 32), │ │ │ │ - position: new OpenLayers.Pixel(-1238, 0) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size("auto", 21), │ │ │ │ - anchor: new OpenLayers.Bounds(0, 0, 22, null), │ │ │ │ - position: new OpenLayers.Pixel(0, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(22, 21), │ │ │ │ - anchor: new OpenLayers.Bounds(null, 0, 0, null), │ │ │ │ - position: new OpenLayers.Pixel(-1238, -629) │ │ │ │ - }, { │ │ │ │ - size: new OpenLayers.Size(81, 33), │ │ │ │ - anchor: new OpenLayers.Bounds(0, null, null, 0), │ │ │ │ - position: new OpenLayers.Pixel(-311, -674) │ │ │ │ - }] │ │ │ │ + unselect: function(feature) { │ │ │ │ + var layer = feature.layer; │ │ │ │ + this.unhighlight(feature); │ │ │ │ + OpenLayers.Util.removeItem(layer.selectedFeatures, feature); │ │ │ │ + layer.events.triggerEvent("featureunselected", { │ │ │ │ + feature: feature │ │ │ │ + }); │ │ │ │ + this.onUnselect.call(this.scope, feature) │ │ │ │ + }, │ │ │ │ + selectBox: function(position) { │ │ │ │ + if (position instanceof OpenLayers.Bounds) { │ │ │ │ + var minXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.left, │ │ │ │ + y: position.bottom │ │ │ │ + }); │ │ │ │ + var maxXY = this.map.getLonLatFromPixel({ │ │ │ │ + x: position.right, │ │ │ │ + y: position.top │ │ │ │ + }); │ │ │ │ + var bounds = new OpenLayers.Bounds(minXY.lon, minXY.lat, maxXY.lon, maxXY.lat); │ │ │ │ + if (!this.multipleSelect()) { │ │ │ │ + this.unselectAll() │ │ │ │ + } │ │ │ │ + var prevMultiple = this.multiple; │ │ │ │ + this.multiple = true; │ │ │ │ + var layers = this.layers || [this.layer]; │ │ │ │ + this.events.triggerEvent("boxselectionstart", { │ │ │ │ + layers: layers │ │ │ │ + }); │ │ │ │ + var layer; │ │ │ │ + for (var l = 0; l < layers.length; ++l) { │ │ │ │ + layer = layers[l]; │ │ │ │ + for (var i = 0, len = layer.features.length; i < len; ++i) { │ │ │ │ + var feature = layer.features[i]; │ │ │ │ + if (!feature.getVisibility()) { │ │ │ │ + continue │ │ │ │ + } │ │ │ │ + if (this.geometryTypes == null || OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) > -1) { │ │ │ │ + if (bounds.toGeometry().intersects(feature.geometry)) { │ │ │ │ + if (OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1) { │ │ │ │ + this.select(feature) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + this.multiple = prevMultiple; │ │ │ │ + this.events.triggerEvent("boxselectionend", { │ │ │ │ + layers: layers │ │ │ │ + }) │ │ │ │ } │ │ │ │ }, │ │ │ │ - minSize: new OpenLayers.Size(105, 10), │ │ │ │ - maxSize: new OpenLayers.Size(1200, 660), │ │ │ │ - initialize: function(id, lonlat, contentSize, contentHTML, anchor, closeBox, closeBoxCallback) { │ │ │ │ - this.imageSrc = OpenLayers.Util.getImageLocation("cloud-popup-relative.png"); │ │ │ │ - OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments); │ │ │ │ - this.contentDiv.className = this.contentDisplayClass │ │ │ │ + setMap: function(map) { │ │ │ │ + this.handlers.feature.setMap(map); │ │ │ │ + if (this.box) { │ │ │ │ + this.handlers.box.setMap(map) │ │ │ │ + } │ │ │ │ + OpenLayers.Control.prototype.setMap.apply(this, arguments) │ │ │ │ }, │ │ │ │ - CLASS_NAME: "OpenLayers.Popup.FramedCloud" │ │ │ │ + setLayer: function(layers) { │ │ │ │ + var isActive = this.active; │ │ │ │ + this.unselectAll(); │ │ │ │ + this.deactivate(); │ │ │ │ + if (this.layers) { │ │ │ │ + this.layer.destroy(); │ │ │ │ + this.layers = null │ │ │ │ + } │ │ │ │ + this.initLayer(layers); │ │ │ │ + this.handlers.feature.layer = this.layer; │ │ │ │ + if (isActive) { │ │ │ │ + this.activate() │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + CLASS_NAME: "OpenLayers.Control.SelectFeature" │ │ │ │ }); │ │ ├── ./usr/share/javascript/openlayers/OpenLayers.mobile.js │ │ │ ├── js-beautify {} │ │ │ │ @@ -136,14 +136,576 @@ │ │ │ │ * (code) │ │ │ │ * <link rel="stylesheet" href="/path/to/default/style.css" type="text/css"> │ │ │ │ * (end code) │ │ │ │ */ │ │ │ │ ImgPath: '' │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ + OpenLayers/BaseTypes/Class.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Constructor: OpenLayers.Class │ │ │ │ + * Base class used to construct all other classes. Includes support for │ │ │ │ + * multiple inheritance. │ │ │ │ + * │ │ │ │ + * This constructor is new in OpenLayers 2.5. At OpenLayers 3.0, the old │ │ │ │ + * syntax for creating classes and dealing with inheritance │ │ │ │ + * will be removed. │ │ │ │ + * │ │ │ │ + * To create a new OpenLayers-style class, use the following syntax: │ │ │ │ + * (code) │ │ │ │ + * var MyClass = OpenLayers.Class(prototype); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * To create a new OpenLayers-style class with multiple inheritance, use the │ │ │ │ + * following syntax: │ │ │ │ + * (code) │ │ │ │ + * var MyClass = OpenLayers.Class(Class1, Class2, prototype); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Note that instanceof reflection will only reveal Class1 as superclass. │ │ │ │ + * │ │ │ │ + */ │ │ │ │ +OpenLayers.Class = function() { │ │ │ │ + var len = arguments.length; │ │ │ │ + var P = arguments[0]; │ │ │ │ + var F = arguments[len - 1]; │ │ │ │ + │ │ │ │ + var C = typeof F.initialize == "function" ? │ │ │ │ + F.initialize : │ │ │ │ + function() { │ │ │ │ + P.prototype.initialize.apply(this, arguments); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + if (len > 1) { │ │ │ │ + var newArgs = [C, P].concat( │ │ │ │ + Array.prototype.slice.call(arguments).slice(1, len - 1), F); │ │ │ │ + OpenLayers.inherit.apply(null, newArgs); │ │ │ │ + } else { │ │ │ │ + C.prototype = F; │ │ │ │ + } │ │ │ │ + return C; │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.inherit │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * C - {Object} the class that inherits │ │ │ │ + * P - {Object} the superclass to inherit from │ │ │ │ + * │ │ │ │ + * In addition to the mandatory C and P parameters, an arbitrary number of │ │ │ │ + * objects can be passed, which will extend C. │ │ │ │ + */ │ │ │ │ +OpenLayers.inherit = function(C, P) { │ │ │ │ + var F = function() {}; │ │ │ │ + F.prototype = P.prototype; │ │ │ │ + C.prototype = new F; │ │ │ │ + var i, l, o; │ │ │ │ + for (i = 2, l = arguments.length; i < l; i++) { │ │ │ │ + o = arguments[i]; │ │ │ │ + if (typeof o === "function") { │ │ │ │ + o = o.prototype; │ │ │ │ + } │ │ │ │ + OpenLayers.Util.extend(C.prototype, o); │ │ │ │ + } │ │ │ │ +}; │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * APIFunction: extend │ │ │ │ + * Copy all properties of a source object to a destination object. Modifies │ │ │ │ + * the passed in destination object. Any properties on the source object │ │ │ │ + * that are set to undefined will not be (re)set on the destination object. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * destination - {Object} The object that will be modified │ │ │ │ + * source - {Object} The object with properties to be set on the destination │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} The destination object. │ │ │ │ + */ │ │ │ │ +OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ +OpenLayers.Util.extend = function(destination, source) { │ │ │ │ + destination = destination || {}; │ │ │ │ + if (source) { │ │ │ │ + for (var property in source) { │ │ │ │ + var value = source[property]; │ │ │ │ + if (value !== undefined) { │ │ │ │ + destination[property] = value; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * IE doesn't include the toString property when iterating over an object's │ │ │ │ + * properties with the for(property in object) syntax. Explicitly check if │ │ │ │ + * the source has its own toString property. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + /* │ │ │ │ + * FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative │ │ │ │ + * prototype object" when calling hawOwnProperty if the source object │ │ │ │ + * is an instance of window.Event. │ │ │ │ + */ │ │ │ │ + │ │ │ │ + var sourceIsEvt = typeof window.Event == "function" && │ │ │ │ + source instanceof window.Event; │ │ │ │ + │ │ │ │ + if (!sourceIsEvt && │ │ │ │ + source.hasOwnProperty && source.hasOwnProperty("toString")) { │ │ │ │ + destination.toString = source.toString; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return destination; │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Util/vendorPrefix.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Util.vendorPrefix │ │ │ │ + * A collection of utility functions to detect vendor prefixed features │ │ │ │ + */ │ │ │ │ +OpenLayers.Util.vendorPrefix = (function() { │ │ │ │ + "use strict"; │ │ │ │ + │ │ │ │ + var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ + divStyle = document.createElement("div").style, │ │ │ │ + cssCache = {}, │ │ │ │ + jsCache = {}; │ │ │ │ + │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: domToCss │ │ │ │ + * Converts a upper camel case DOM style property name to a CSS property │ │ │ │ + * i.e. transformOrigin -> transform-origin │ │ │ │ + * or WebkitTransformOrigin -> -webkit-transform-origin │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * prefixedDom - {String} The property to convert │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The CSS property │ │ │ │ + */ │ │ │ │ + function domToCss(prefixedDom) { │ │ │ │ + if (!prefixedDom) { │ │ │ │ + return null; │ │ │ │ + } │ │ │ │ + return prefixedDom. │ │ │ │ + replace(/([A-Z])/g, function(c) { │ │ │ │ + return "-" + c.toLowerCase(); │ │ │ │ + }). │ │ │ │ + replace(/^ms-/, "-ms-"); │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: css │ │ │ │ + * Detect which property is used for a CSS property │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * property - {String} The standard (unprefixed) CSS property name │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The standard CSS property, prefixed property or null if not │ │ │ │ + * supported │ │ │ │ + */ │ │ │ │ + function css(property) { │ │ │ │ + if (cssCache[property] === undefined) { │ │ │ │ + var domProperty = property. │ │ │ │ + replace(/(-[\s\S])/g, function(c) { │ │ │ │ + return c.charAt(1).toUpperCase(); │ │ │ │ + }); │ │ │ │ + var prefixedDom = style(domProperty); │ │ │ │ + cssCache[property] = domToCss(prefixedDom); │ │ │ │ + } │ │ │ │ + return cssCache[property]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: js │ │ │ │ + * Detect which property is used for a JS property/method │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} The object to test on │ │ │ │ + * property - {String} The standard (unprefixed) JS property name │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The standard JS property, prefixed property or null if not │ │ │ │ + * supported │ │ │ │ + */ │ │ │ │ + function js(obj, property) { │ │ │ │ + if (jsCache[property] === undefined) { │ │ │ │ + var tmpProp, │ │ │ │ + i = 0, │ │ │ │ + l = VENDOR_PREFIXES.length, │ │ │ │ + prefix, │ │ │ │ + isStyleObj = (typeof obj.cssText !== "undefined"); │ │ │ │ + │ │ │ │ + jsCache[property] = null; │ │ │ │ + for (; i < l; i++) { │ │ │ │ + prefix = VENDOR_PREFIXES[i]; │ │ │ │ + if (prefix) { │ │ │ │ + if (!isStyleObj) { │ │ │ │ + // js prefix should be lower-case, while style │ │ │ │ + // properties have upper case on first character │ │ │ │ + prefix = prefix.toLowerCase(); │ │ │ │ + } │ │ │ │ + tmpProp = prefix + property.charAt(0).toUpperCase() + property.slice(1); │ │ │ │ + } else { │ │ │ │ + tmpProp = property; │ │ │ │ + } │ │ │ │ + │ │ │ │ + if (obj[tmpProp] !== undefined) { │ │ │ │ + jsCache[property] = tmpProp; │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + return jsCache[property]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: style │ │ │ │ + * Detect which property is used for a DOM style property │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * property - {String} The standard (unprefixed) style property name │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {String} The standard style property, prefixed property or null if not │ │ │ │ + * supported │ │ │ │ + */ │ │ │ │ + function style(property) { │ │ │ │ + return js(divStyle, property); │ │ │ │ + } │ │ │ │ + │ │ │ │ + return { │ │ │ │ + css: css, │ │ │ │ + js: js, │ │ │ │ + style: style, │ │ │ │ + │ │ │ │ + // used for testing │ │ │ │ + cssCache: cssCache, │ │ │ │ + jsCache: jsCache │ │ │ │ + }; │ │ │ │ +}()); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Animation.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/SingleFile.js │ │ │ │ + * @requires OpenLayers/Util/vendorPrefix.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Namespace: OpenLayers.Animation │ │ │ │ + * A collection of utility functions for executing methods that repaint a │ │ │ │ + * portion of the browser window. These methods take advantage of the │ │ │ │ + * browser's scheduled repaints where requestAnimationFrame is available. │ │ │ │ + */ │ │ │ │ +OpenLayers.Animation = (function(window) { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: isNative │ │ │ │ + * {Boolean} true if a native requestAnimationFrame function is available │ │ │ │ + */ │ │ │ │ + var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ + var isNative = !!(requestAnimationFrame); │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: requestFrame │ │ │ │ + * Schedule a function to be called at the next available animation frame. │ │ │ │ + * Uses the native method where available. Where requestAnimationFrame is │ │ │ │ + * not available, setTimeout will be called with a 16ms delay. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The function to be called at the next animation frame. │ │ │ │ + * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ + */ │ │ │ │ + var requestFrame = (function() { │ │ │ │ + var request = window[requestAnimationFrame] || │ │ │ │ + function(callback, element) { │ │ │ │ + window.setTimeout(callback, 16); │ │ │ │ + }; │ │ │ │ + // bind to window to avoid illegal invocation of native function │ │ │ │ + return function(callback, element) { │ │ │ │ + request.apply(window, [callback, element]); │ │ │ │ + }; │ │ │ │ + })(); │ │ │ │ + │ │ │ │ + // private variables for animation loops │ │ │ │ + var counter = 0; │ │ │ │ + var loops = {}; │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: start │ │ │ │ + * Executes a method with <requestFrame> in series for some │ │ │ │ + * duration. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * callback - {Function} The function to be called at the next animation frame. │ │ │ │ + * duration - {Number} Optional duration for the loop. If not provided, the │ │ │ │ + * animation loop will execute indefinitely. │ │ │ │ + * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Number} Identifier for the animation loop. Used to stop animations with │ │ │ │ + * <stop>. │ │ │ │ + */ │ │ │ │ + function start(callback, duration, element) { │ │ │ │ + duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ + var id = ++counter; │ │ │ │ + var start = +new Date; │ │ │ │ + loops[id] = function() { │ │ │ │ + if (loops[id] && +new Date - start <= duration) { │ │ │ │ + callback(); │ │ │ │ + if (loops[id]) { │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + delete loops[id]; │ │ │ │ + } │ │ │ │ + }; │ │ │ │ + requestFrame(loops[id], element); │ │ │ │ + return id; │ │ │ │ + } │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Function: stop │ │ │ │ + * Terminates an animation loop started with <start>. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * id - {Number} Identifier returned from <start>. │ │ │ │ + */ │ │ │ │ + function stop(id) { │ │ │ │ + delete loops[id]; │ │ │ │ + } │ │ │ │ + │ │ │ │ + return { │ │ │ │ + isNative: isNative, │ │ │ │ + requestFrame: requestFrame, │ │ │ │ + start: start, │ │ │ │ + stop: stop │ │ │ │ + }; │ │ │ │ + │ │ │ │ +})(window); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Kinetic.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Animation.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: threshold │ │ │ │ + * In most cases changing the threshold isn't needed. │ │ │ │ + * In px/ms, default to 0. │ │ │ │ + */ │ │ │ │ + threshold: 0, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: deceleration │ │ │ │ + * {Float} the deseleration in px/ms², default to 0.0035. │ │ │ │ + */ │ │ │ │ + deceleration: 0.0035, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: nbPoints │ │ │ │ + * {Integer} the number of points we use to calculate the kinetic │ │ │ │ + * initial values. │ │ │ │ + */ │ │ │ │ + nbPoints: 100, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: delay │ │ │ │ + * {Float} time to consider to calculate the kinetic initial values. │ │ │ │ + * In ms, default to 200. │ │ │ │ + */ │ │ │ │ + delay: 200, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: points │ │ │ │ + * List of points use to calculate the kinetic initial values. │ │ │ │ + */ │ │ │ │ + points: undefined, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: timerId │ │ │ │ + * ID of the timer. │ │ │ │ + */ │ │ │ │ + timerId: undefined, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Kinetic │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + OpenLayers.Util.extend(this, options); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: begin │ │ │ │ + * Begins the dragging. │ │ │ │ + */ │ │ │ │ + begin: function() { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = undefined; │ │ │ │ + this.points = []; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: update │ │ │ │ + * Updates during the dragging. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} The new position. │ │ │ │ + */ │ │ │ │ + update: function(xy) { │ │ │ │ + this.points.unshift({ │ │ │ │ + xy: xy, │ │ │ │ + tick: new Date().getTime() │ │ │ │ + }); │ │ │ │ + if (this.points.length > this.nbPoints) { │ │ │ │ + this.points.pop(); │ │ │ │ + } │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: end │ │ │ │ + * Ends the dragging, start the kinetic. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * xy - {<OpenLayers.Pixel>} The last position. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Object} An object with two properties: "speed", and "theta". The │ │ │ │ + * "speed" and "theta" values are to be passed to the move │ │ │ │ + * function when starting the animation. │ │ │ │ + */ │ │ │ │ + end: function(xy) { │ │ │ │ + var last, now = new Date().getTime(); │ │ │ │ + for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ + point = this.points[i]; │ │ │ │ + if (now - point.tick > this.delay) { │ │ │ │ + break; │ │ │ │ + } │ │ │ │ + last = point; │ │ │ │ + } │ │ │ │ + if (!last) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var time = new Date().getTime() - last.tick; │ │ │ │ + var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + │ │ │ │ + Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ + var speed = dist / time; │ │ │ │ + if (speed == 0 || speed < this.threshold) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ + if (last.xy.x <= xy.x) { │ │ │ │ + theta = Math.PI - theta; │ │ │ │ + } │ │ │ │ + return { │ │ │ │ + speed: speed, │ │ │ │ + theta: theta │ │ │ │ + }; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: move │ │ │ │ + * Launch the kinetic move pan. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * info - {Object} An object with two properties, "speed", and "theta". │ │ │ │ + * These values are those returned from the "end" call. │ │ │ │ + * callback - {Function} Function called on every step of the animation, │ │ │ │ + * receives x, y (values to pan), end (is the last point). │ │ │ │ + */ │ │ │ │ + move: function(info, callback) { │ │ │ │ + var v0 = info.speed; │ │ │ │ + var fx = Math.cos(info.theta); │ │ │ │ + var fy = -Math.sin(info.theta); │ │ │ │ + │ │ │ │ + var initialTime = new Date().getTime(); │ │ │ │ + │ │ │ │ + var lastX = 0; │ │ │ │ + var lastY = 0; │ │ │ │ + │ │ │ │ + var timerCallback = function() { │ │ │ │ + if (this.timerId == null) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + │ │ │ │ + var t = new Date().getTime() - initialTime; │ │ │ │ + │ │ │ │ + var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t; │ │ │ │ + var x = p * fx; │ │ │ │ + var y = p * fy; │ │ │ │ + │ │ │ │ + var args = {}; │ │ │ │ + args.end = false; │ │ │ │ + var v = -this.deceleration * t + v0; │ │ │ │ + │ │ │ │ + if (v <= 0) { │ │ │ │ + OpenLayers.Animation.stop(this.timerId); │ │ │ │ + this.timerId = null; │ │ │ │ + args.end = true; │ │ │ │ + } │ │ │ │ + │ │ │ │ + args.x = x - lastX; │ │ │ │ + args.y = y - lastY; │ │ │ │ + lastX = x; │ │ │ │ + lastY = y; │ │ │ │ + callback(args.x, args.y, args.end); │ │ │ │ + }; │ │ │ │ + │ │ │ │ + this.timerId = OpenLayers.Animation.start( │ │ │ │ + OpenLayers.Function.bind(timerCallback, this) │ │ │ │ + ); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ OpenLayers/BaseTypes.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -603,141 +1165,14 @@ │ │ │ │ } │ │ │ │ } │ │ │ │ return selected; │ │ │ │ } │ │ │ │ │ │ │ │ }; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/BaseTypes/Class.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constructor: OpenLayers.Class │ │ │ │ - * Base class used to construct all other classes. Includes support for │ │ │ │ - * multiple inheritance. │ │ │ │ - * │ │ │ │ - * This constructor is new in OpenLayers 2.5. At OpenLayers 3.0, the old │ │ │ │ - * syntax for creating classes and dealing with inheritance │ │ │ │ - * will be removed. │ │ │ │ - * │ │ │ │ - * To create a new OpenLayers-style class, use the following syntax: │ │ │ │ - * (code) │ │ │ │ - * var MyClass = OpenLayers.Class(prototype); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * To create a new OpenLayers-style class with multiple inheritance, use the │ │ │ │ - * following syntax: │ │ │ │ - * (code) │ │ │ │ - * var MyClass = OpenLayers.Class(Class1, Class2, prototype); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Note that instanceof reflection will only reveal Class1 as superclass. │ │ │ │ - * │ │ │ │ - */ │ │ │ │ -OpenLayers.Class = function() { │ │ │ │ - var len = arguments.length; │ │ │ │ - var P = arguments[0]; │ │ │ │ - var F = arguments[len - 1]; │ │ │ │ - │ │ │ │ - var C = typeof F.initialize == "function" ? │ │ │ │ - F.initialize : │ │ │ │ - function() { │ │ │ │ - P.prototype.initialize.apply(this, arguments); │ │ │ │ - }; │ │ │ │ - │ │ │ │ - if (len > 1) { │ │ │ │ - var newArgs = [C, P].concat( │ │ │ │ - Array.prototype.slice.call(arguments).slice(1, len - 1), F); │ │ │ │ - OpenLayers.inherit.apply(null, newArgs); │ │ │ │ - } else { │ │ │ │ - C.prototype = F; │ │ │ │ - } │ │ │ │ - return C; │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.inherit │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * C - {Object} the class that inherits │ │ │ │ - * P - {Object} the superclass to inherit from │ │ │ │ - * │ │ │ │ - * In addition to the mandatory C and P parameters, an arbitrary number of │ │ │ │ - * objects can be passed, which will extend C. │ │ │ │ - */ │ │ │ │ -OpenLayers.inherit = function(C, P) { │ │ │ │ - var F = function() {}; │ │ │ │ - F.prototype = P.prototype; │ │ │ │ - C.prototype = new F; │ │ │ │ - var i, l, o; │ │ │ │ - for (i = 2, l = arguments.length; i < l; i++) { │ │ │ │ - o = arguments[i]; │ │ │ │ - if (typeof o === "function") { │ │ │ │ - o = o.prototype; │ │ │ │ - } │ │ │ │ - OpenLayers.Util.extend(C.prototype, o); │ │ │ │ - } │ │ │ │ -}; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * APIFunction: extend │ │ │ │ - * Copy all properties of a source object to a destination object. Modifies │ │ │ │ - * the passed in destination object. Any properties on the source object │ │ │ │ - * that are set to undefined will not be (re)set on the destination object. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * destination - {Object} The object that will be modified │ │ │ │ - * source - {Object} The object with properties to be set on the destination │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Object} The destination object. │ │ │ │ - */ │ │ │ │ -OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ -OpenLayers.Util.extend = function(destination, source) { │ │ │ │ - destination = destination || {}; │ │ │ │ - if (source) { │ │ │ │ - for (var property in source) { │ │ │ │ - var value = source[property]; │ │ │ │ - if (value !== undefined) { │ │ │ │ - destination[property] = value; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * IE doesn't include the toString property when iterating over an object's │ │ │ │ - * properties with the for(property in object) syntax. Explicitly check if │ │ │ │ - * the source has its own toString property. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - /* │ │ │ │ - * FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative │ │ │ │ - * prototype object" when calling hawOwnProperty if the source object │ │ │ │ - * is an instance of window.Event. │ │ │ │ - */ │ │ │ │ - │ │ │ │ - var sourceIsEvt = typeof window.Event == "function" && │ │ │ │ - source instanceof window.Event; │ │ │ │ - │ │ │ │ - if (!sourceIsEvt && │ │ │ │ - source.hasOwnProperty && source.hasOwnProperty("toString")) { │ │ │ │ - destination.toString = source.toString; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return destination; │ │ │ │ -}; │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/BaseTypes/Bounds.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -4426,155 +4861,14 @@ │ │ │ │ } else { │ │ │ │ str += coordinate < 0 ? OpenLayers.i18n("S") : OpenLayers.i18n("N"); │ │ │ │ } │ │ │ │ return str; │ │ │ │ }; │ │ │ │ │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Util/vendorPrefix.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -OpenLayers.Util = OpenLayers.Util || {}; │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Util.vendorPrefix │ │ │ │ - * A collection of utility functions to detect vendor prefixed features │ │ │ │ - */ │ │ │ │ -OpenLayers.Util.vendorPrefix = (function() { │ │ │ │ - "use strict"; │ │ │ │ - │ │ │ │ - var VENDOR_PREFIXES = ["", "O", "ms", "Moz", "Webkit"], │ │ │ │ - divStyle = document.createElement("div").style, │ │ │ │ - cssCache = {}, │ │ │ │ - jsCache = {}; │ │ │ │ - │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: domToCss │ │ │ │ - * Converts a upper camel case DOM style property name to a CSS property │ │ │ │ - * i.e. transformOrigin -> transform-origin │ │ │ │ - * or WebkitTransformOrigin -> -webkit-transform-origin │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * prefixedDom - {String} The property to convert │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The CSS property │ │ │ │ - */ │ │ │ │ - function domToCss(prefixedDom) { │ │ │ │ - if (!prefixedDom) { │ │ │ │ - return null; │ │ │ │ - } │ │ │ │ - return prefixedDom. │ │ │ │ - replace(/([A-Z])/g, function(c) { │ │ │ │ - return "-" + c.toLowerCase(); │ │ │ │ - }). │ │ │ │ - replace(/^ms-/, "-ms-"); │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: css │ │ │ │ - * Detect which property is used for a CSS property │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * property - {String} The standard (unprefixed) CSS property name │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The standard CSS property, prefixed property or null if not │ │ │ │ - * supported │ │ │ │ - */ │ │ │ │ - function css(property) { │ │ │ │ - if (cssCache[property] === undefined) { │ │ │ │ - var domProperty = property. │ │ │ │ - replace(/(-[\s\S])/g, function(c) { │ │ │ │ - return c.charAt(1).toUpperCase(); │ │ │ │ - }); │ │ │ │ - var prefixedDom = style(domProperty); │ │ │ │ - cssCache[property] = domToCss(prefixedDom); │ │ │ │ - } │ │ │ │ - return cssCache[property]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: js │ │ │ │ - * Detect which property is used for a JS property/method │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} The object to test on │ │ │ │ - * property - {String} The standard (unprefixed) JS property name │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The standard JS property, prefixed property or null if not │ │ │ │ - * supported │ │ │ │ - */ │ │ │ │ - function js(obj, property) { │ │ │ │ - if (jsCache[property] === undefined) { │ │ │ │ - var tmpProp, │ │ │ │ - i = 0, │ │ │ │ - l = VENDOR_PREFIXES.length, │ │ │ │ - prefix, │ │ │ │ - isStyleObj = (typeof obj.cssText !== "undefined"); │ │ │ │ - │ │ │ │ - jsCache[property] = null; │ │ │ │ - for (; i < l; i++) { │ │ │ │ - prefix = VENDOR_PREFIXES[i]; │ │ │ │ - if (prefix) { │ │ │ │ - if (!isStyleObj) { │ │ │ │ - // js prefix should be lower-case, while style │ │ │ │ - // properties have upper case on first character │ │ │ │ - prefix = prefix.toLowerCase(); │ │ │ │ - } │ │ │ │ - tmpProp = prefix + property.charAt(0).toUpperCase() + property.slice(1); │ │ │ │ - } else { │ │ │ │ - tmpProp = property; │ │ │ │ - } │ │ │ │ - │ │ │ │ - if (obj[tmpProp] !== undefined) { │ │ │ │ - jsCache[property] = tmpProp; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - return jsCache[property]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: style │ │ │ │ - * Detect which property is used for a DOM style property │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * property - {String} The standard (unprefixed) style property name │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {String} The standard style property, prefixed property or null if not │ │ │ │ - * supported │ │ │ │ - */ │ │ │ │ - function style(property) { │ │ │ │ - return js(divStyle, property); │ │ │ │ - } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - css: css, │ │ │ │ - js: js, │ │ │ │ - style: style, │ │ │ │ - │ │ │ │ - // used for testing │ │ │ │ - cssCache: cssCache, │ │ │ │ - jsCache: jsCache │ │ │ │ - }; │ │ │ │ -}()); │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Events.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -5743,120 +6037,14 @@ │ │ │ │ │ │ │ │ OpenLayers.Event.observe(element, 'MSPointerUp', cb); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Events" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Animation.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/SingleFile.js │ │ │ │ - * @requires OpenLayers/Util/vendorPrefix.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Namespace: OpenLayers.Animation │ │ │ │ - * A collection of utility functions for executing methods that repaint a │ │ │ │ - * portion of the browser window. These methods take advantage of the │ │ │ │ - * browser's scheduled repaints where requestAnimationFrame is available. │ │ │ │ - */ │ │ │ │ -OpenLayers.Animation = (function(window) { │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: isNative │ │ │ │ - * {Boolean} true if a native requestAnimationFrame function is available │ │ │ │ - */ │ │ │ │ - var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame"); │ │ │ │ - var isNative = !!(requestAnimationFrame); │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: requestFrame │ │ │ │ - * Schedule a function to be called at the next available animation frame. │ │ │ │ - * Uses the native method where available. Where requestAnimationFrame is │ │ │ │ - * not available, setTimeout will be called with a 16ms delay. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The function to be called at the next animation frame. │ │ │ │ - * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ - */ │ │ │ │ - var requestFrame = (function() { │ │ │ │ - var request = window[requestAnimationFrame] || │ │ │ │ - function(callback, element) { │ │ │ │ - window.setTimeout(callback, 16); │ │ │ │ - }; │ │ │ │ - // bind to window to avoid illegal invocation of native function │ │ │ │ - return function(callback, element) { │ │ │ │ - request.apply(window, [callback, element]); │ │ │ │ - }; │ │ │ │ - })(); │ │ │ │ - │ │ │ │ - // private variables for animation loops │ │ │ │ - var counter = 0; │ │ │ │ - var loops = {}; │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: start │ │ │ │ - * Executes a method with <requestFrame> in series for some │ │ │ │ - * duration. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * callback - {Function} The function to be called at the next animation frame. │ │ │ │ - * duration - {Number} Optional duration for the loop. If not provided, the │ │ │ │ - * animation loop will execute indefinitely. │ │ │ │ - * element - {DOMElement} Optional element that visually bounds the animation. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Number} Identifier for the animation loop. Used to stop animations with │ │ │ │ - * <stop>. │ │ │ │ - */ │ │ │ │ - function start(callback, duration, element) { │ │ │ │ - duration = duration > 0 ? duration : Number.POSITIVE_INFINITY; │ │ │ │ - var id = ++counter; │ │ │ │ - var start = +new Date; │ │ │ │ - loops[id] = function() { │ │ │ │ - if (loops[id] && +new Date - start <= duration) { │ │ │ │ - callback(); │ │ │ │ - if (loops[id]) { │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - } │ │ │ │ - } else { │ │ │ │ - delete loops[id]; │ │ │ │ - } │ │ │ │ - }; │ │ │ │ - requestFrame(loops[id], element); │ │ │ │ - return id; │ │ │ │ - } │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Function: stop │ │ │ │ - * Terminates an animation loop started with <start>. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * id - {Number} Identifier returned from <start>. │ │ │ │ - */ │ │ │ │ - function stop(id) { │ │ │ │ - delete loops[id]; │ │ │ │ - } │ │ │ │ - │ │ │ │ - return { │ │ │ │ - isNative: isNative, │ │ │ │ - requestFrame: requestFrame, │ │ │ │ - start: start, │ │ │ │ - stop: stop │ │ │ │ - }; │ │ │ │ - │ │ │ │ -})(window); │ │ │ │ -/* ====================================================================== │ │ │ │ OpenLayers/Tween.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -13727,200 +13915,280 @@ │ │ │ │ this.tileCache = null; │ │ │ │ this.tileCacheIndex = null; │ │ │ │ this._destroyed = true; │ │ │ │ } │ │ │ │ │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Kinetic.js │ │ │ │ + OpenLayers/Strategy.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - * @requires OpenLayers/Animation.js │ │ │ │ */ │ │ │ │ │ │ │ │ -OpenLayers.Kinetic = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: threshold │ │ │ │ - * In most cases changing the threshold isn't needed. │ │ │ │ - * In px/ms, default to 0. │ │ │ │ - */ │ │ │ │ - threshold: 0, │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy │ │ │ │ + * Abstract vector layer strategy class. Not to be instantiated directly. Use │ │ │ │ + * one of the strategy subclasses instead. │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: deceleration │ │ │ │ - * {Float} the deseleration in px/ms², default to 0.0035. │ │ │ │ + * Property: layer │ │ │ │ + * {<OpenLayers.Layer.Vector>} The layer this strategy belongs to. │ │ │ │ */ │ │ │ │ - deceleration: 0.0035, │ │ │ │ + layer: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: nbPoints │ │ │ │ - * {Integer} the number of points we use to calculate the kinetic │ │ │ │ - * initial values. │ │ │ │ + * Property: options │ │ │ │ + * {Object} Any options sent to the constructor. │ │ │ │ */ │ │ │ │ - nbPoints: 100, │ │ │ │ + options: null, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: delay │ │ │ │ - * {Float} time to consider to calculate the kinetic initial values. │ │ │ │ - * In ms, default to 200. │ │ │ │ + /** │ │ │ │ + * Property: active │ │ │ │ + * {Boolean} The control is active. │ │ │ │ */ │ │ │ │ - delay: 200, │ │ │ │ + active: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: points │ │ │ │ - * List of points use to calculate the kinetic initial values. │ │ │ │ + * Property: autoActivate │ │ │ │ + * {Boolean} The creator of the strategy can set autoActivate to false │ │ │ │ + * to fully control when the protocol is activated and deactivated. │ │ │ │ + * Defaults to true. │ │ │ │ */ │ │ │ │ - points: undefined, │ │ │ │ + autoActivate: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: timerId │ │ │ │ - * ID of the timer. │ │ │ │ + * Property: autoDestroy │ │ │ │ + * {Boolean} The creator of the strategy can set autoDestroy to false │ │ │ │ + * to fully control when the strategy is destroyed. Defaults to │ │ │ │ + * true. │ │ │ │ */ │ │ │ │ - timerId: undefined, │ │ │ │ + autoDestroy: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Kinetic │ │ │ │ + * Constructor: OpenLayers.Strategy │ │ │ │ + * Abstract class for vector strategies. Create instances of a subclass. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ */ │ │ │ │ initialize: function(options) { │ │ │ │ OpenLayers.Util.extend(this, options); │ │ │ │ + this.options = options; │ │ │ │ + // set the active property here, so that user cannot override it │ │ │ │ + this.active = false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: begin │ │ │ │ - * Begins the dragging. │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up the strategy. │ │ │ │ */ │ │ │ │ - begin: function() { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = undefined; │ │ │ │ - this.points = []; │ │ │ │ + destroy: function() { │ │ │ │ + this.deactivate(); │ │ │ │ + this.layer = null; │ │ │ │ + this.options = null; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: update │ │ │ │ - * Updates during the dragging. │ │ │ │ + * Method: setLayer │ │ │ │ + * Called to set the <layer> property. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The new position. │ │ │ │ + * layer - {<OpenLayers.Layer.Vector>} │ │ │ │ */ │ │ │ │ - update: function(xy) { │ │ │ │ - this.points.unshift({ │ │ │ │ - xy: xy, │ │ │ │ - tick: new Date().getTime() │ │ │ │ - }); │ │ │ │ - if (this.points.length > this.nbPoints) { │ │ │ │ - this.points.pop(); │ │ │ │ - } │ │ │ │ + setLayer: function(layer) { │ │ │ │ + this.layer = layer; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: end │ │ │ │ - * Ends the dragging, start the kinetic. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * xy - {<OpenLayers.Pixel>} The last position. │ │ │ │ + * Method: activate │ │ │ │ + * Activate the strategy. Register any listeners, do appropriate setup. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {Object} An object with two properties: "speed", and "theta". The │ │ │ │ - * "speed" and "theta" values are to be passed to the move │ │ │ │ - * function when starting the animation. │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ */ │ │ │ │ - end: function(xy) { │ │ │ │ - var last, now = new Date().getTime(); │ │ │ │ - for (var i = 0, l = this.points.length, point; i < l; i++) { │ │ │ │ - point = this.points[i]; │ │ │ │ - if (now - point.tick > this.delay) { │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - last = point; │ │ │ │ - } │ │ │ │ - if (!last) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var time = new Date().getTime() - last.tick; │ │ │ │ - var dist = Math.sqrt(Math.pow(xy.x - last.xy.x, 2) + │ │ │ │ - Math.pow(xy.y - last.xy.y, 2)); │ │ │ │ - var speed = dist / time; │ │ │ │ - if (speed == 0 || speed < this.threshold) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var theta = Math.asin((xy.y - last.xy.y) / dist); │ │ │ │ - if (last.xy.x <= xy.x) { │ │ │ │ - theta = Math.PI - theta; │ │ │ │ + activate: function() { │ │ │ │ + if (!this.active) { │ │ │ │ + this.active = true; │ │ │ │ + return true; │ │ │ │ } │ │ │ │ - return { │ │ │ │ - speed: speed, │ │ │ │ - theta: theta │ │ │ │ - }; │ │ │ │ + return false; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: move │ │ │ │ - * Launch the kinetic move pan. │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the strategy. Unregister any listeners, do appropriate │ │ │ │ + * tear-down. │ │ │ │ * │ │ │ │ - * Parameters: │ │ │ │ - * info - {Object} An object with two properties, "speed", and "theta". │ │ │ │ - * These values are those returned from the "end" call. │ │ │ │ - * callback - {Function} Function called on every step of the animation, │ │ │ │ - * receives x, y (values to pan), end (is the last point). │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully deactivated or false if │ │ │ │ + * the strategy was already inactive. │ │ │ │ */ │ │ │ │ - move: function(info, callback) { │ │ │ │ - var v0 = info.speed; │ │ │ │ - var fx = Math.cos(info.theta); │ │ │ │ - var fy = -Math.sin(info.theta); │ │ │ │ + deactivate: function() { │ │ │ │ + if (this.active) { │ │ │ │ + this.active = false; │ │ │ │ + return true; │ │ │ │ + } │ │ │ │ + return false; │ │ │ │ + }, │ │ │ │ │ │ │ │ - var initialTime = new Date().getTime(); │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy" │ │ │ │ +}); │ │ │ │ +/* ====================================================================== │ │ │ │ + OpenLayers/Strategy/Fixed.js │ │ │ │ + ====================================================================== */ │ │ │ │ │ │ │ │ - var lastX = 0; │ │ │ │ - var lastY = 0; │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ │ │ │ │ - var timerCallback = function() { │ │ │ │ - if (this.timerId == null) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Strategy.js │ │ │ │ + */ │ │ │ │ │ │ │ │ - var t = new Date().getTime() - initialTime; │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Strategy.Fixed │ │ │ │ + * A simple strategy that requests features once and never requests new data. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Strategy> │ │ │ │ + */ │ │ │ │ +OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, { │ │ │ │ │ │ │ │ - var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t; │ │ │ │ - var x = p * fx; │ │ │ │ - var y = p * fy; │ │ │ │ + /** │ │ │ │ + * APIProperty: preload │ │ │ │ + * {Boolean} Load data before layer made visible. Enabling this may result │ │ │ │ + * in considerable overhead if your application loads many data layers │ │ │ │ + * that are not visible by default. Default is false. │ │ │ │ + */ │ │ │ │ + preload: false, │ │ │ │ │ │ │ │ - var args = {}; │ │ │ │ - args.end = false; │ │ │ │ - var v = -this.deceleration * t + v0; │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Strategy.Fixed │ │ │ │ + * Create a new Fixed strategy. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Optional object whose properties will be set on the │ │ │ │ + * instance. │ │ │ │ + */ │ │ │ │ │ │ │ │ - if (v <= 0) { │ │ │ │ - OpenLayers.Animation.stop(this.timerId); │ │ │ │ - this.timerId = null; │ │ │ │ - args.end = true; │ │ │ │ + /** │ │ │ │ + * Method: activate │ │ │ │ + * Activate the strategy: load data or add listener to load when visible │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} True if the strategy was successfully activated or false if │ │ │ │ + * the strategy was already active. │ │ │ │ + */ │ │ │ │ + activate: function() { │ │ │ │ + var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments); │ │ │ │ + if (activated) { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "refresh": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + if (this.layer.visibility == true || this.preload) { │ │ │ │ + this.load(); │ │ │ │ + } else { │ │ │ │ + this.layer.events.on({ │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ } │ │ │ │ + } │ │ │ │ + return activated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - args.x = x - lastX; │ │ │ │ - args.y = y - lastY; │ │ │ │ - lastX = x; │ │ │ │ - lastY = y; │ │ │ │ - callback(args.x, args.y, args.end); │ │ │ │ - }; │ │ │ │ + /** │ │ │ │ + * Method: deactivate │ │ │ │ + * Deactivate the strategy. Undo what is done in <activate>. │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {Boolean} The strategy was successfully deactivated. │ │ │ │ + */ │ │ │ │ + deactivate: function() { │ │ │ │ + var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this); │ │ │ │ + if (deactivated) { │ │ │ │ + this.layer.events.un({ │ │ │ │ + "refresh": this.load, │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ + } │ │ │ │ + return deactivated; │ │ │ │ + }, │ │ │ │ │ │ │ │ - this.timerId = OpenLayers.Animation.start( │ │ │ │ - OpenLayers.Function.bind(timerCallback, this) │ │ │ │ - ); │ │ │ │ + /** │ │ │ │ + * Method: load │ │ │ │ + * Tells protocol to load data and unhooks the visibilitychanged event │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} options to pass to protocol read. │ │ │ │ + */ │ │ │ │ + load: function(options) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.events.triggerEvent("loadstart", { │ │ │ │ + filter: layer.filter │ │ │ │ + }); │ │ │ │ + layer.protocol.read(OpenLayers.Util.applyDefaults({ │ │ │ │ + callback: this.merge, │ │ │ │ + filter: layer.filter, │ │ │ │ + scope: this │ │ │ │ + }, options)); │ │ │ │ + layer.events.un({ │ │ │ │ + "visibilitychanged": this.load, │ │ │ │ + scope: this │ │ │ │ + }); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Kinetic" │ │ │ │ + /** │ │ │ │ + * Method: merge │ │ │ │ + * Add all features to the layer. │ │ │ │ + * If the layer projection differs from the map projection, features │ │ │ │ + * will be transformed from the layer projection to the map projection. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * resp - {<OpenLayers.Protocol.Response>} The response object passed │ │ │ │ + * by the protocol. │ │ │ │ + */ │ │ │ │ + merge: function(resp) { │ │ │ │ + var layer = this.layer; │ │ │ │ + layer.destroyFeatures(); │ │ │ │ + var features = resp.features; │ │ │ │ + if (features && features.length > 0) { │ │ │ │ + var remote = layer.projection; │ │ │ │ + var local = layer.map.getProjectionObject(); │ │ │ │ + if (!local.equals(remote)) { │ │ │ │ + var geom; │ │ │ │ + for (var i = 0, len = features.length; i < len; ++i) { │ │ │ │ + geom = features[i].geometry; │ │ │ │ + if (geom) { │ │ │ │ + geom.transform(remote, local); │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + layer.addFeatures(features); │ │ │ │ + } │ │ │ │ + layer.events.triggerEvent("loadend", { │ │ │ │ + response: resp │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Strategy.Fixed" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Layer/XYZ.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ @@ -14096,356 +14364,140 @@ │ │ │ │ this.maxExtent.bottom); │ │ │ │ } │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.XYZ" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/Bing.js │ │ │ │ + OpenLayers/Layer/OSM.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ * @requires OpenLayers/Layer/XYZ.js │ │ │ │ */ │ │ │ │ │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Layer.Bing │ │ │ │ - * Bing layer using direct tile access as provided by Bing Maps REST Services. │ │ │ │ - * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more │ │ │ │ - * information. Note: Terms of Service compliant use requires the map to be │ │ │ │ - * configured with an <OpenLayers.Control.Attribution> control and the │ │ │ │ - * attribution placed on or near the map. │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.OSM │ │ │ │ + * This layer allows accessing OpenStreetMap tiles. By default the OpenStreetMap │ │ │ │ + * hosted tile.openstreetmap.org Mapnik tileset is used. If you wish to use │ │ │ │ + * a different layer instead, you need to provide a different │ │ │ │ + * URL to the constructor. Here's an example for using OpenCycleMap: │ │ │ │ * │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ * Inherits from: │ │ │ │ * - <OpenLayers.Layer.XYZ> │ │ │ │ */ │ │ │ │ -OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ +OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: key │ │ │ │ - * {String} API key for Bing maps, get your own key │ │ │ │ - * at http://bingmapsportal.com/ . │ │ │ │ + * APIProperty: name │ │ │ │ + * {String} The layer name. Defaults to "OpenStreetMap" if the first │ │ │ │ + * argument to the constructor is null or undefined. │ │ │ │ */ │ │ │ │ - key: null, │ │ │ │ + name: "OpenStreetMap", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: serverResolutions │ │ │ │ - * {Array} the resolutions provided by the Bing servers. │ │ │ │ + * APIProperty: url │ │ │ │ + * {String} The tileset URL scheme. Defaults to │ │ │ │ + * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png │ │ │ │ + * (the official OSM tileset) if the second argument to the constructor │ │ │ │ + * is null or undefined. To use another tileset you can have something │ │ │ │ + * like this: │ │ │ │ + * (code) │ │ │ │ + * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ + * (end) │ │ │ │ */ │ │ │ │ - serverResolutions: [ │ │ │ │ - 156543.03390625, 78271.516953125, 39135.7584765625, │ │ │ │ - 19567.87923828125, 9783.939619140625, 4891.9698095703125, │ │ │ │ - 2445.9849047851562, 1222.9924523925781, 611.4962261962891, │ │ │ │ - 305.74811309814453, 152.87405654907226, 76.43702827453613, │ │ │ │ - 38.218514137268066, 19.109257068634033, 9.554628534317017, │ │ │ │ - 4.777314267158508, 2.388657133579254, 1.194328566789627, │ │ │ │ - 0.5971642833948135, 0.29858214169740677, 0.14929107084870338, │ │ │ │ - 0.07464553542435169 │ │ │ │ + url: [ │ │ │ │ + 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ + 'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ + 'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png' │ │ │ │ ], │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: attributionTemplate │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - attributionTemplate: '<span class="olBingAttribution ${type}">' + │ │ │ │ - '<div><a target="_blank" href="http://www.bing.com/maps/">' + │ │ │ │ - '<img src="${logo}" /></a></div>${copyrights}' + │ │ │ │ - '<a style="white-space: nowrap" target="_blank" ' + │ │ │ │ - 'href="http://www.microsoft.com/maps/product/terms.html">' + │ │ │ │ - 'Terms of Use</a></span>', │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: metadata │ │ │ │ - * {Object} Metadata for this layer, as returned by the callback script │ │ │ │ - */ │ │ │ │ - metadata: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: protocolRegex │ │ │ │ - * {RegExp} Regular expression to match and replace http: in bing urls │ │ │ │ - */ │ │ │ │ - protocolRegex: /^http:/i, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ - * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ - * used. Default is "Road". │ │ │ │ + * Property: attribution │ │ │ │ + * {String} The layer attribution. │ │ │ │ */ │ │ │ │ - type: "Road", │ │ │ │ + attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: culture │ │ │ │ - * {String} The culture identifier. See http://msdn.microsoft.com/en-us/library/ff701709.aspx │ │ │ │ - * for the definition and the possible values. Default is "en-US". │ │ │ │ + * Property: sphericalMercator │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - culture: "en-US", │ │ │ │ + sphericalMercator: true, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: metadataParams │ │ │ │ - * {Object} Optional url parameters for the Get Imagery Metadata request │ │ │ │ - * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx │ │ │ │ + * Property: wrapDateLine │ │ │ │ + * {Boolean} │ │ │ │ */ │ │ │ │ - metadataParams: null, │ │ │ │ + wrapDateLine: true, │ │ │ │ │ │ │ │ /** APIProperty: tileOptions │ │ │ │ * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ * created by this Layer. Default is │ │ │ │ * │ │ │ │ * (code) │ │ │ │ * {crossOriginKeyword: 'anonymous'} │ │ │ │ * (end) │ │ │ │ - */ │ │ │ │ - tileOptions: null, │ │ │ │ - │ │ │ │ - /** APIProperty: protocol │ │ │ │ - * {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo │ │ │ │ - * Can be 'http:' 'https:' or '' │ │ │ │ * │ │ │ │ - * Warning: tiles may not be available under both HTTP and HTTPS protocols. │ │ │ │ - * Microsoft approved use of both HTTP and HTTPS urls for tiles. However │ │ │ │ - * this is undocumented and the Imagery Metadata API always returns HTTP │ │ │ │ - * urls. │ │ │ │ + * When using OSM tilesets other than the default ones, it may be │ │ │ │ + * necessary to set this to │ │ │ │ * │ │ │ │ - * Default is '', unless when executed from a file:/// uri, in which case │ │ │ │ - * it is 'http:'. │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: null} │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * if the server does not send Access-Control-Allow-Origin headers. │ │ │ │ */ │ │ │ │ - protocol: ~window.location.href.indexOf('http') ? '' : 'http:', │ │ │ │ + tileOptions: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.Bing │ │ │ │ - * Create a new Bing layer. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * (code) │ │ │ │ - * var road = new OpenLayers.Layer.Bing({ │ │ │ │ - * name: "My Bing Aerial Layer", │ │ │ │ - * type: "Aerial", │ │ │ │ - * key: "my-api-key-here", │ │ │ │ - * }); │ │ │ │ - * (end) │ │ │ │ + * Constructor: OpenLayers.Layer.OSM │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} Configuration properties for the layer. │ │ │ │ - * │ │ │ │ - * Required configuration properties: │ │ │ │ - * key - {String} Bing Maps API key for your application. Get one at │ │ │ │ - * http://bingmapsportal.com/. │ │ │ │ - * type - {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ - * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ - * used. │ │ │ │ - * │ │ │ │ - * Any other documented layer properties can be provided in the config object. │ │ │ │ + * name - {String} The layer name. │ │ │ │ + * url - {String} The tileset URL scheme. │ │ │ │ + * options - {Object} Configuration options for the layer. Any inherited │ │ │ │ + * layer option can be set in this object (e.g. │ │ │ │ + * <OpenLayers.Layer.Grid.buffer>). │ │ │ │ */ │ │ │ │ - initialize: function(options) { │ │ │ │ - options = OpenLayers.Util.applyDefaults({ │ │ │ │ - sphericalMercator: true │ │ │ │ - }, options); │ │ │ │ - var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ - │ │ │ │ - var newArgs = [name, null, options]; │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + initialize: function(name, url, options) { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ crossOriginKeyword: 'anonymous' │ │ │ │ - }, this.options.tileOptions); │ │ │ │ - this.loadMetadata(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: loadMetadata │ │ │ │ - */ │ │ │ │ - loadMetadata: function() { │ │ │ │ - this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ - // link the processMetadata method to the global scope and bind it │ │ │ │ - // to this instance │ │ │ │ - window[this._callbackId] = OpenLayers.Function.bind( │ │ │ │ - OpenLayers.Layer.Bing.processMetadata, this │ │ │ │ - ); │ │ │ │ - var params = OpenLayers.Util.applyDefaults({ │ │ │ │ - key: this.key, │ │ │ │ - jsonp: this._callbackId, │ │ │ │ - include: "ImageryProviders" │ │ │ │ - }, this.metadataParams); │ │ │ │ - var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + │ │ │ │ - this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ - var script = document.createElement("script"); │ │ │ │ - script.type = "text/javascript"; │ │ │ │ - script.src = url; │ │ │ │ - script.id = this._callbackId; │ │ │ │ - document.getElementsByTagName("head")[0].appendChild(script); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: initLayer │ │ │ │ - * │ │ │ │ - * Sets layer properties according to the metadata provided by the API │ │ │ │ - */ │ │ │ │ - initLayer: function() { │ │ │ │ - var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ - var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ - url = url.replace("{culture}", this.culture); │ │ │ │ - url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.url = []; │ │ │ │ - for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ - this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])); │ │ │ │ - } │ │ │ │ - this.addOptions({ │ │ │ │ - maxResolution: Math.min( │ │ │ │ - this.serverResolutions[res.zoomMin], │ │ │ │ - this.maxResolution || Number.POSITIVE_INFINITY │ │ │ │ - ), │ │ │ │ - numZoomLevels: Math.min( │ │ │ │ - res.zoomMax + 1 - res.zoomMin, this.numZoomLevels │ │ │ │ - ) │ │ │ │ - }, true); │ │ │ │ - if (!this.isBaseLayer) { │ │ │ │ - this.redraw(); │ │ │ │ - } │ │ │ │ - this.updateAttribution(); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getURL │ │ │ │ - * │ │ │ │ - * Paramters: │ │ │ │ - * bounds - {<OpenLayers.Bounds>} │ │ │ │ - */ │ │ │ │ - getURL: function(bounds) { │ │ │ │ - if (!this.url) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var xyz = this.getXYZ(bounds), │ │ │ │ - x = xyz.x, │ │ │ │ - y = xyz.y, │ │ │ │ - z = xyz.z; │ │ │ │ - var quadDigits = []; │ │ │ │ - for (var i = z; i > 0; --i) { │ │ │ │ - var digit = '0'; │ │ │ │ - var mask = 1 << (i - 1); │ │ │ │ - if ((x & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - } │ │ │ │ - if ((y & mask) != 0) { │ │ │ │ - digit++; │ │ │ │ - digit++; │ │ │ │ - } │ │ │ │ - quadDigits.push(digit); │ │ │ │ - } │ │ │ │ - var quadKey = quadDigits.join(""); │ │ │ │ - var url = this.selectUrl('' + x + y + z, this.url); │ │ │ │ - │ │ │ │ - return OpenLayers.String.format(url, { │ │ │ │ - 'quadkey': quadKey │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: updateAttribution │ │ │ │ - * Updates the attribution according to the requirements outlined in │ │ │ │ - * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html │ │ │ │ - */ │ │ │ │ - updateAttribution: function() { │ │ │ │ - var metadata = this.metadata; │ │ │ │ - if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ - return; │ │ │ │ - } │ │ │ │ - var res = metadata.resourceSets[0].resources[0]; │ │ │ │ - var extent = this.map.getExtent().transform( │ │ │ │ - this.map.getProjectionObject(), │ │ │ │ - new OpenLayers.Projection("EPSG:4326") │ │ │ │ - ); │ │ │ │ - var providers = res.imageryProviders || [], │ │ │ │ - zoom = OpenLayers.Util.indexOf(this.serverResolutions, │ │ │ │ - this.getServerResolution()), │ │ │ │ - copyrights = "", │ │ │ │ - provider, i, ii, j, jj, bbox, coverage; │ │ │ │ - for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ - provider = providers[i]; │ │ │ │ - for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ - coverage = provider.coverageAreas[j]; │ │ │ │ - // axis order provided is Y,X │ │ │ │ - bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ - if (extent.intersectsBounds(bbox) && │ │ │ │ - zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ - copyrights += provider.attribution + " "; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - } │ │ │ │ - var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ - this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ - type: this.type.toLowerCase(), │ │ │ │ - logo: logo, │ │ │ │ - copyrights: copyrights │ │ │ │ - }); │ │ │ │ - this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ - layer: this, │ │ │ │ - property: "attribution" │ │ │ │ - }); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - */ │ │ │ │ - setMap: function() { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ - this.map.events.register("moveend", this, this.updateAttribution); │ │ │ │ + }, this.options && this.options.tileOptions); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMethod: clone │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * obj - {Object} │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing> │ │ │ │ + * Method: clone │ │ │ │ */ │ │ │ │ clone: function(obj) { │ │ │ │ if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.Bing(this.options); │ │ │ │ + obj = new OpenLayers.Layer.OSM( │ │ │ │ + this.name, this.url, this.getOptions()); │ │ │ │ } │ │ │ │ - //get all additions from superclasses │ │ │ │ obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - // copy/set any non-init, non-simple values here │ │ │ │ return obj; │ │ │ │ }, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - this.map && │ │ │ │ - this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ - OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Function: OpenLayers.Layer.Bing.processMetadata │ │ │ │ - * This function will be bound to an instance, linked to the global scope with │ │ │ │ - * an id, and called by the JSONP script returned by the API. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * metadata - {Object} metadata as returned by the API │ │ │ │ - */ │ │ │ │ -OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ - this.metadata = metadata; │ │ │ │ - this.initLayer(); │ │ │ │ - var script = document.getElementById(this._callbackId); │ │ │ │ - script.parentNode.removeChild(script); │ │ │ │ - window[this._callbackId] = undefined; // cannot delete from window in IE │ │ │ │ - delete this._callbackId; │ │ │ │ -}; │ │ │ │ /* ====================================================================== │ │ │ │ OpenLayers/Renderer.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ @@ -17265,14 +17317,357 @@ │ │ │ │ } │ │ │ │ return maxExtent; │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.Vector" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ + OpenLayers/Layer/Bing.js │ │ │ │ + ====================================================================== */ │ │ │ │ + │ │ │ │ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ + * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ + * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ + * full text of the license. */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * @requires OpenLayers/Layer/XYZ.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Layer.Bing │ │ │ │ + * Bing layer using direct tile access as provided by Bing Maps REST Services. │ │ │ │ + * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more │ │ │ │ + * information. Note: Terms of Service compliant use requires the map to be │ │ │ │ + * configured with an <OpenLayers.Control.Attribution> control and the │ │ │ │ + * attribution placed on or near the map. │ │ │ │ + * │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Layer.XYZ> │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: key │ │ │ │ + * {String} API key for Bing maps, get your own key │ │ │ │ + * at http://bingmapsportal.com/ . │ │ │ │ + */ │ │ │ │ + key: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: serverResolutions │ │ │ │ + * {Array} the resolutions provided by the Bing servers. │ │ │ │ + */ │ │ │ │ + serverResolutions: [ │ │ │ │ + 156543.03390625, 78271.516953125, 39135.7584765625, │ │ │ │ + 19567.87923828125, 9783.939619140625, 4891.9698095703125, │ │ │ │ + 2445.9849047851562, 1222.9924523925781, 611.4962261962891, │ │ │ │ + 305.74811309814453, 152.87405654907226, 76.43702827453613, │ │ │ │ + 38.218514137268066, 19.109257068634033, 9.554628534317017, │ │ │ │ + 4.777314267158508, 2.388657133579254, 1.194328566789627, │ │ │ │ + 0.5971642833948135, 0.29858214169740677, 0.14929107084870338, │ │ │ │ + 0.07464553542435169 │ │ │ │ + ], │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: attributionTemplate │ │ │ │ + * {String} │ │ │ │ + */ │ │ │ │ + attributionTemplate: '<span class="olBingAttribution ${type}">' + │ │ │ │ + '<div><a target="_blank" href="http://www.bing.com/maps/">' + │ │ │ │ + '<img src="${logo}" /></a></div>${copyrights}' + │ │ │ │ + '<a style="white-space: nowrap" target="_blank" ' + │ │ │ │ + 'href="http://www.microsoft.com/maps/product/terms.html">' + │ │ │ │ + 'Terms of Use</a></span>', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: metadata │ │ │ │ + * {Object} Metadata for this layer, as returned by the callback script │ │ │ │ + */ │ │ │ │ + metadata: null, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Property: protocolRegex │ │ │ │ + * {RegExp} Regular expression to match and replace http: in bing urls │ │ │ │ + */ │ │ │ │ + protocolRegex: /^http:/i, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: type │ │ │ │ + * {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ + * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ + * used. Default is "Road". │ │ │ │ + */ │ │ │ │ + type: "Road", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: culture │ │ │ │ + * {String} The culture identifier. See http://msdn.microsoft.com/en-us/library/ff701709.aspx │ │ │ │ + * for the definition and the possible values. Default is "en-US". │ │ │ │ + */ │ │ │ │ + culture: "en-US", │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIProperty: metadataParams │ │ │ │ + * {Object} Optional url parameters for the Get Imagery Metadata request │ │ │ │ + * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx │ │ │ │ + */ │ │ │ │ + metadataParams: null, │ │ │ │ + │ │ │ │ + /** APIProperty: tileOptions │ │ │ │ + * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ + * created by this Layer. Default is │ │ │ │ + * │ │ │ │ + * (code) │ │ │ │ + * {crossOriginKeyword: 'anonymous'} │ │ │ │ + * (end) │ │ │ │ + */ │ │ │ │ + tileOptions: null, │ │ │ │ + │ │ │ │ + /** APIProperty: protocol │ │ │ │ + * {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo │ │ │ │ + * Can be 'http:' 'https:' or '' │ │ │ │ + * │ │ │ │ + * Warning: tiles may not be available under both HTTP and HTTPS protocols. │ │ │ │ + * Microsoft approved use of both HTTP and HTTPS urls for tiles. However │ │ │ │ + * this is undocumented and the Imagery Metadata API always returns HTTP │ │ │ │ + * urls. │ │ │ │ + * │ │ │ │ + * Default is '', unless when executed from a file:/// uri, in which case │ │ │ │ + * it is 'http:'. │ │ │ │ + */ │ │ │ │ + protocol: ~window.location.href.indexOf('http') ? '' : 'http:', │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Constructor: OpenLayers.Layer.Bing │ │ │ │ + * Create a new Bing layer. │ │ │ │ + * │ │ │ │ + * Example: │ │ │ │ + * (code) │ │ │ │ + * var road = new OpenLayers.Layer.Bing({ │ │ │ │ + * name: "My Bing Aerial Layer", │ │ │ │ + * type: "Aerial", │ │ │ │ + * key: "my-api-key-here", │ │ │ │ + * }); │ │ │ │ + * (end) │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * options - {Object} Configuration properties for the layer. │ │ │ │ + * │ │ │ │ + * Required configuration properties: │ │ │ │ + * key - {String} Bing Maps API key for your application. Get one at │ │ │ │ + * http://bingmapsportal.com/. │ │ │ │ + * type - {String} The layer identifier. Any non-birdseye imageryType │ │ │ │ + * from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be │ │ │ │ + * used. │ │ │ │ + * │ │ │ │ + * Any other documented layer properties can be provided in the config object. │ │ │ │ + */ │ │ │ │ + initialize: function(options) { │ │ │ │ + options = OpenLayers.Util.applyDefaults({ │ │ │ │ + sphericalMercator: true │ │ │ │ + }, options); │ │ │ │ + var name = options.name || "Bing " + (options.type || this.type); │ │ │ │ + │ │ │ │ + var newArgs = [name, null, options]; │ │ │ │ + OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs); │ │ │ │ + this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ + crossOriginKeyword: 'anonymous' │ │ │ │ + }, this.options.tileOptions); │ │ │ │ + this.loadMetadata(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: loadMetadata │ │ │ │ + */ │ │ │ │ + loadMetadata: function() { │ │ │ │ + this._callbackId = "_callback_" + this.id.replace(/\./g, "_"); │ │ │ │ + // link the processMetadata method to the global scope and bind it │ │ │ │ + // to this instance │ │ │ │ + window[this._callbackId] = OpenLayers.Function.bind( │ │ │ │ + OpenLayers.Layer.Bing.processMetadata, this │ │ │ │ + ); │ │ │ │ + var params = OpenLayers.Util.applyDefaults({ │ │ │ │ + key: this.key, │ │ │ │ + jsonp: this._callbackId, │ │ │ │ + include: "ImageryProviders" │ │ │ │ + }, this.metadataParams); │ │ │ │ + var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" + │ │ │ │ + this.type + "?" + OpenLayers.Util.getParameterString(params); │ │ │ │ + var script = document.createElement("script"); │ │ │ │ + script.type = "text/javascript"; │ │ │ │ + script.src = url; │ │ │ │ + script.id = this._callbackId; │ │ │ │ + document.getElementsByTagName("head")[0].appendChild(script); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: initLayer │ │ │ │ + * │ │ │ │ + * Sets layer properties according to the metadata provided by the API │ │ │ │ + */ │ │ │ │ + initLayer: function() { │ │ │ │ + var res = this.metadata.resourceSets[0].resources[0]; │ │ │ │ + var url = res.imageUrl.replace("{quadkey}", "${quadkey}"); │ │ │ │ + url = url.replace("{culture}", this.culture); │ │ │ │ + url = url.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.url = []; │ │ │ │ + for (var i = 0; i < res.imageUrlSubdomains.length; ++i) { │ │ │ │ + this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i])); │ │ │ │ + } │ │ │ │ + this.addOptions({ │ │ │ │ + maxResolution: Math.min( │ │ │ │ + this.serverResolutions[res.zoomMin], │ │ │ │ + this.maxResolution || Number.POSITIVE_INFINITY │ │ │ │ + ), │ │ │ │ + numZoomLevels: Math.min( │ │ │ │ + res.zoomMax + 1 - res.zoomMin, this.numZoomLevels │ │ │ │ + ) │ │ │ │ + }, true); │ │ │ │ + if (!this.isBaseLayer) { │ │ │ │ + this.redraw(); │ │ │ │ + } │ │ │ │ + this.updateAttribution(); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: getURL │ │ │ │ + * │ │ │ │ + * Paramters: │ │ │ │ + * bounds - {<OpenLayers.Bounds>} │ │ │ │ + */ │ │ │ │ + getURL: function(bounds) { │ │ │ │ + if (!this.url) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var xyz = this.getXYZ(bounds), │ │ │ │ + x = xyz.x, │ │ │ │ + y = xyz.y, │ │ │ │ + z = xyz.z; │ │ │ │ + var quadDigits = []; │ │ │ │ + for (var i = z; i > 0; --i) { │ │ │ │ + var digit = '0'; │ │ │ │ + var mask = 1 << (i - 1); │ │ │ │ + if ((x & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + } │ │ │ │ + if ((y & mask) != 0) { │ │ │ │ + digit++; │ │ │ │ + digit++; │ │ │ │ + } │ │ │ │ + quadDigits.push(digit); │ │ │ │ + } │ │ │ │ + var quadKey = quadDigits.join(""); │ │ │ │ + var url = this.selectUrl('' + x + y + z, this.url); │ │ │ │ + │ │ │ │ + return OpenLayers.String.format(url, { │ │ │ │ + 'quadkey': quadKey │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: updateAttribution │ │ │ │ + * Updates the attribution according to the requirements outlined in │ │ │ │ + * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html │ │ │ │ + */ │ │ │ │ + updateAttribution: function() { │ │ │ │ + var metadata = this.metadata; │ │ │ │ + if (!metadata.resourceSets || !this.map || !this.map.center) { │ │ │ │ + return; │ │ │ │ + } │ │ │ │ + var res = metadata.resourceSets[0].resources[0]; │ │ │ │ + var extent = this.map.getExtent().transform( │ │ │ │ + this.map.getProjectionObject(), │ │ │ │ + new OpenLayers.Projection("EPSG:4326") │ │ │ │ + ); │ │ │ │ + var providers = res.imageryProviders || [], │ │ │ │ + zoom = OpenLayers.Util.indexOf(this.serverResolutions, │ │ │ │ + this.getServerResolution()), │ │ │ │ + copyrights = "", │ │ │ │ + provider, i, ii, j, jj, bbox, coverage; │ │ │ │ + for (i = 0, ii = providers.length; i < ii; ++i) { │ │ │ │ + provider = providers[i]; │ │ │ │ + for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) { │ │ │ │ + coverage = provider.coverageAreas[j]; │ │ │ │ + // axis order provided is Y,X │ │ │ │ + bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true); │ │ │ │ + if (extent.intersectsBounds(bbox) && │ │ │ │ + zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) { │ │ │ │ + copyrights += provider.attribution + " "; │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol); │ │ │ │ + this.attribution = OpenLayers.String.format(this.attributionTemplate, { │ │ │ │ + type: this.type.toLowerCase(), │ │ │ │ + logo: logo, │ │ │ │ + copyrights: copyrights │ │ │ │ + }); │ │ │ │ + this.map && this.map.events.triggerEvent("changelayer", { │ │ │ │ + layer: this, │ │ │ │ + property: "attribution" │ │ │ │ + }); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: setMap │ │ │ │ + */ │ │ │ │ + setMap: function() { │ │ │ │ + OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments); │ │ │ │ + this.map.events.register("moveend", this, this.updateAttribution); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * APIMethod: clone │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * obj - {Object} │ │ │ │ + * │ │ │ │ + * Returns: │ │ │ │ + * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing> │ │ │ │ + */ │ │ │ │ + clone: function(obj) { │ │ │ │ + if (obj == null) { │ │ │ │ + obj = new OpenLayers.Layer.Bing(this.options); │ │ │ │ + } │ │ │ │ + //get all additions from superclasses │ │ │ │ + obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ + // copy/set any non-init, non-simple values here │ │ │ │ + return obj; │ │ │ │ + }, │ │ │ │ + │ │ │ │ + /** │ │ │ │ + * Method: destroy │ │ │ │ + */ │ │ │ │ + destroy: function() { │ │ │ │ + this.map && │ │ │ │ + this.map.events.unregister("moveend", this, this.updateAttribution); │ │ │ │ + OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments); │ │ │ │ + }, │ │ │ │ + │ │ │ │ + CLASS_NAME: "OpenLayers.Layer.Bing" │ │ │ │ +}); │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Function: OpenLayers.Layer.Bing.processMetadata │ │ │ │ + * This function will be bound to an instance, linked to the global scope with │ │ │ │ + * an id, and called by the JSONP script returned by the API. │ │ │ │ + * │ │ │ │ + * Parameters: │ │ │ │ + * metadata - {Object} metadata as returned by the API │ │ │ │ + */ │ │ │ │ +OpenLayers.Layer.Bing.processMetadata = function(metadata) { │ │ │ │ + this.metadata = metadata; │ │ │ │ + this.initLayer(); │ │ │ │ + var script = document.getElementById(this._callbackId); │ │ │ │ + script.parentNode.removeChild(script); │ │ │ │ + window[this._callbackId] = undefined; // cannot delete from window in IE │ │ │ │ + delete this._callbackId; │ │ │ │ +}; │ │ │ │ +/* ====================================================================== │ │ │ │ OpenLayers/Layer/WMS.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ @@ -17537,1162 +17932,539 @@ │ │ │ │ return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply( │ │ │ │ this, arguments); │ │ │ │ }, │ │ │ │ │ │ │ │ CLASS_NAME: "OpenLayers.Layer.WMS" │ │ │ │ }); │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Layer/OSM.js │ │ │ │ + OpenLayers/Format.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Layer/XYZ.js │ │ │ │ + * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ + * @requires OpenLayers/Util.js │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Layer.OSM │ │ │ │ - * This layer allows accessing OpenStreetMap tiles. By default the OpenStreetMap │ │ │ │ - * hosted tile.openstreetmap.org Mapnik tileset is used. If you wish to use │ │ │ │ - * a different layer instead, you need to provide a different │ │ │ │ - * URL to the constructor. Here's an example for using OpenCycleMap: │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ - * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Layer.XYZ> │ │ │ │ + * 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.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, { │ │ │ │ +OpenLayers.Format = OpenLayers.Class({ │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: name │ │ │ │ - * {String} The layer name. Defaults to "OpenStreetMap" if the first │ │ │ │ - * argument to the constructor is null or undefined. │ │ │ │ + * Property: options │ │ │ │ + * {Object} A reference to options passed to the constructor. │ │ │ │ */ │ │ │ │ - name: "OpenStreetMap", │ │ │ │ + options: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIProperty: url │ │ │ │ - * {String} The tileset URL scheme. Defaults to │ │ │ │ - * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png │ │ │ │ - * (the official OSM tileset) if the second argument to the constructor │ │ │ │ - * is null or undefined. To use another tileset you can have something │ │ │ │ - * like this: │ │ │ │ - * (code) │ │ │ │ - * new OpenLayers.Layer.OSM("OpenCycleMap", │ │ │ │ - * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", │ │ │ │ - * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); │ │ │ │ - * (end) │ │ │ │ + * APIProperty: externalProjection │ │ │ │ + * {<OpenLayers.Projection>} 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 │ │ │ │ + * {<OpenLayers.Projection.addTransform>} for more information on │ │ │ │ + * custom transformations. │ │ │ │ */ │ │ │ │ - url: [ │ │ │ │ - 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ - 'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png', │ │ │ │ - 'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png' │ │ │ │ - ], │ │ │ │ + externalProjection: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: attribution │ │ │ │ - * {String} The layer attribution. │ │ │ │ + * APIProperty: internalProjection │ │ │ │ + * {<OpenLayers.Projection>} 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 │ │ │ │ + * {<OpenLayers.Projection.addTransform>} for more information on │ │ │ │ + * custom transformations. │ │ │ │ */ │ │ │ │ - attribution: "© <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> contributors", │ │ │ │ + internalProjection: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: sphericalMercator │ │ │ │ - * {Boolean} │ │ │ │ + * APIProperty: data │ │ │ │ + * {Object} When <keepData> is true, this is the parsed string sent to │ │ │ │ + * <read>. │ │ │ │ */ │ │ │ │ - sphericalMercator: true, │ │ │ │ + data: null, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: wrapDateLine │ │ │ │ - * {Boolean} │ │ │ │ - */ │ │ │ │ - wrapDateLine: true, │ │ │ │ - │ │ │ │ - /** APIProperty: tileOptions │ │ │ │ - * {Object} optional configuration options for <OpenLayers.Tile> instances │ │ │ │ - * created by this Layer. Default is │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: 'anonymous'} │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * When using OSM tilesets other than the default ones, it may be │ │ │ │ - * necessary to set this to │ │ │ │ - * │ │ │ │ - * (code) │ │ │ │ - * {crossOriginKeyword: null} │ │ │ │ - * (end) │ │ │ │ - * │ │ │ │ - * if the server does not send Access-Control-Allow-Origin headers. │ │ │ │ + * APIProperty: keepData │ │ │ │ + * {Object} Maintain a reference (<data>) to the most recently read data. │ │ │ │ + * Default is false. │ │ │ │ */ │ │ │ │ - tileOptions: null, │ │ │ │ + keepData: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Layer.OSM │ │ │ │ + * Constructor: OpenLayers.Format │ │ │ │ + * Instances of this class are not useful. See one of the subclasses. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * name - {String} The layer name. │ │ │ │ - * url - {String} The tileset URL scheme. │ │ │ │ - * options - {Object} Configuration options for the layer. Any inherited │ │ │ │ - * layer option can be set in this object (e.g. │ │ │ │ - * <OpenLayers.Layer.Grid.buffer>). │ │ │ │ - */ │ │ │ │ - initialize: function(name, url, options) { │ │ │ │ - OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments); │ │ │ │ - this.tileOptions = OpenLayers.Util.extend({ │ │ │ │ - crossOriginKeyword: 'anonymous' │ │ │ │ - }, this.options && this.options.tileOptions); │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: clone │ │ │ │ - */ │ │ │ │ - clone: function(obj) { │ │ │ │ - if (obj == null) { │ │ │ │ - obj = new OpenLayers.Layer.OSM( │ │ │ │ - this.name, this.url, this.getOptions()); │ │ │ │ - } │ │ │ │ - obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]); │ │ │ │ - return obj; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - CLASS_NAME: "OpenLayers.Layer.OSM" │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/BaseTypes/Class.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control │ │ │ │ - * Controls affect the display or behavior of the map. They allow everything │ │ │ │ - * from panning and zooming to displaying a scale indicator. Controls by │ │ │ │ - * default are added to the map they are contained within however it is │ │ │ │ - * possible to add a control to an external div by passing the div in the │ │ │ │ - * options parameter. │ │ │ │ - * │ │ │ │ - * Example: │ │ │ │ - * The following example shows how to add many of the common controls │ │ │ │ - * to a map. │ │ │ │ - * │ │ │ │ - * > var map = new OpenLayers.Map('map', { controls: [] }); │ │ │ │ - * > │ │ │ │ - * > map.addControl(new OpenLayers.Control.PanZoomBar()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false})); │ │ │ │ - * > map.addControl(new OpenLayers.Control.Permalink()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.Permalink('permalink')); │ │ │ │ - * > map.addControl(new OpenLayers.Control.MousePosition()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.OverviewMap()); │ │ │ │ - * > map.addControl(new OpenLayers.Control.KeyboardDefaults()); │ │ │ │ - * │ │ │ │ - * The next code fragment is a quick example of how to intercept │ │ │ │ - * shift-mouse click to display the extent of the bounding box │ │ │ │ - * dragged out by the user. Usually controls are not created │ │ │ │ - * in exactly this manner. See the source for a more complete │ │ │ │ - * example: │ │ │ │ - * │ │ │ │ - * > var control = new OpenLayers.Control(); │ │ │ │ - * > OpenLayers.Util.extend(control, { │ │ │ │ - * > draw: function () { │ │ │ │ - * > // this Handler.Box will intercept the shift-mousedown │ │ │ │ - * > // before Control.MouseDefault gets to see it │ │ │ │ - * > this.box = new OpenLayers.Handler.Box( control, │ │ │ │ - * > {"done": this.notice}, │ │ │ │ - * > {keyMask: OpenLayers.Handler.MOD_SHIFT}); │ │ │ │ - * > this.box.activate(); │ │ │ │ - * > }, │ │ │ │ - * > │ │ │ │ - * > notice: function (bounds) { │ │ │ │ - * > OpenLayers.Console.userError(bounds); │ │ │ │ - * > } │ │ │ │ - * > }); │ │ │ │ - * > map.addControl(control); │ │ │ │ - * │ │ │ │ - */ │ │ │ │ -OpenLayers.Control = OpenLayers.Class({ │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: id │ │ │ │ - * {String} │ │ │ │ - */ │ │ │ │ - id: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: map │ │ │ │ - * {<OpenLayers.Map>} this gets set in the addControl() function in │ │ │ │ - * OpenLayers.Map │ │ │ │ - */ │ │ │ │ - map: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: div │ │ │ │ - * {DOMElement} The element that contains the control, if not present the │ │ │ │ - * control is placed inside the map. │ │ │ │ - */ │ │ │ │ - div: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: type │ │ │ │ - * {Number} Controls can have a 'type'. The type determines the type of │ │ │ │ - * interactions which are possible with them when they are placed in an │ │ │ │ - * <OpenLayers.Control.Panel>. │ │ │ │ - */ │ │ │ │ - type: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: allowSelection │ │ │ │ - * {Boolean} By default, controls do not allow selection, because │ │ │ │ - * it may interfere with map dragging. If this is true, OpenLayers │ │ │ │ - * will not prevent selection of the control. │ │ │ │ - * Default is false. │ │ │ │ - */ │ │ │ │ - allowSelection: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: displayClass │ │ │ │ - * {string} This property is used for CSS related to the drawing of the │ │ │ │ - * Control. │ │ │ │ - */ │ │ │ │ - displayClass: "", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: title │ │ │ │ - * {string} This property is used for showing a tooltip over the │ │ │ │ - * Control. │ │ │ │ - */ │ │ │ │ - title: "", │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * false. │ │ │ │ - */ │ │ │ │ - autoActivate: false, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: active │ │ │ │ - * {Boolean} The control is active (read-only). Use <activate> and │ │ │ │ - * <deactivate> to change control state. │ │ │ │ - */ │ │ │ │ - active: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: handlerOptions │ │ │ │ - * {Object} Used to set non-default properties on the control's handler │ │ │ │ - */ │ │ │ │ - handlerOptions: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Property: handler │ │ │ │ - * {<OpenLayers.Handler>} null │ │ │ │ - */ │ │ │ │ - handler: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: eventListeners │ │ │ │ - * {Object} If set as an option at construction, the eventListeners │ │ │ │ - * object will be registered with <OpenLayers.Events.on>. Object │ │ │ │ - * structure must be a listeners object as shown in the example for │ │ │ │ - * the events.on method. │ │ │ │ - */ │ │ │ │ - eventListeners: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: events │ │ │ │ - * {<OpenLayers.Events>} Events instance for listeners and triggering │ │ │ │ - * control specific events. │ │ │ │ - * │ │ │ │ - * 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). │ │ │ │ + * options - {Object} An optional object with properties to set on the │ │ │ │ + * format │ │ │ │ * │ │ │ │ - * Supported map event types: │ │ │ │ - * activate - Triggered when activated. │ │ │ │ - * deactivate - Triggered when deactivated. │ │ │ │ - */ │ │ │ │ - events: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * 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}); │ │ │ │ + * Valid options: │ │ │ │ + * keepData - {Boolean} If true, upon <read>, the data property will be │ │ │ │ + * set to the parsed object (e.g. the json or xml object). │ │ │ │ * │ │ │ │ - * Overrides the default div attribute value of null. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * options - {Object} │ │ │ │ + * Returns: │ │ │ │ + * An instance of OpenLayers.Format │ │ │ │ */ │ │ │ │ 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); │ │ │ │ - if (this.eventListeners instanceof Object) { │ │ │ │ - this.events.on(this.eventListeners); │ │ │ │ - } │ │ │ │ - if (this.id == null) { │ │ │ │ - this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); │ │ │ │ - } │ │ │ │ + this.options = options; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: destroy │ │ │ │ - * The destroy method is used to perform any clean up before the control │ │ │ │ - * is dereferenced. Typically this is where event listeners are removed │ │ │ │ - * to prevent memory leaks. │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.events) { │ │ │ │ - if (this.eventListeners) { │ │ │ │ - this.events.un(this.eventListeners); │ │ │ │ - } │ │ │ │ - this.events.destroy(); │ │ │ │ - this.events = null; │ │ │ │ - } │ │ │ │ - this.eventListeners = null; │ │ │ │ - │ │ │ │ - // eliminate circular references │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.destroy(); │ │ │ │ - this.handler = null; │ │ │ │ - } │ │ │ │ - if (this.handlers) { │ │ │ │ - for (var key in this.handlers) { │ │ │ │ - if (this.handlers.hasOwnProperty(key) && │ │ │ │ - typeof this.handlers[key].destroy == "function") { │ │ │ │ - this.handlers[key].destroy(); │ │ │ │ - } │ │ │ │ - } │ │ │ │ - this.handlers = null; │ │ │ │ - } │ │ │ │ - if (this.map) { │ │ │ │ - this.map.removeControl(this); │ │ │ │ - this.map = null; │ │ │ │ - } │ │ │ │ - this.div = null; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: setMap │ │ │ │ - * Set the map property for the control. This is done through an accessor │ │ │ │ - * so that subclasses can override this and take special action once │ │ │ │ - * they have their map variable set. │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * map - {<OpenLayers.Map>} │ │ │ │ + * APIMethod: destroy │ │ │ │ + * Clean up. │ │ │ │ */ │ │ │ │ - setMap: function(map) { │ │ │ │ - this.map = map; │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.setMap(map); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ + destroy: function() {}, │ │ │ │ │ │ │ │ /** │ │ │ │ - * 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. │ │ │ │ - * │ │ │ │ + * Method: read │ │ │ │ + * Read data from a string, and return an object whose type depends on the │ │ │ │ + * subclass. │ │ │ │ + * │ │ │ │ * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} The top-left pixel position of the control │ │ │ │ - * or null. │ │ │ │ + * data - {string} Data to read/parse. │ │ │ │ * │ │ │ │ * Returns: │ │ │ │ - * {DOMElement} A reference to the DIV DOMElement containing the control │ │ │ │ + * Depends on the subclass │ │ │ │ */ │ │ │ │ - draw: function(px) { │ │ │ │ - if (this.div == null) { │ │ │ │ - this.div = OpenLayers.Util.createDiv(this.id); │ │ │ │ - this.div.className = this.displayClass; │ │ │ │ - if (!this.allowSelection) { │ │ │ │ - this.div.className += " olControlNoSelect"; │ │ │ │ - this.div.setAttribute("unselectable", "on", 0); │ │ │ │ - this.div.onselectstart = OpenLayers.Function.False; │ │ │ │ - } │ │ │ │ - if (this.title != "") { │ │ │ │ - this.div.title = this.title; │ │ │ │ - } │ │ │ │ - } │ │ │ │ - if (px != null) { │ │ │ │ - this.position = px.clone(); │ │ │ │ - } │ │ │ │ - this.moveTo(this.position); │ │ │ │ - return this.div; │ │ │ │ + read: function(data) { │ │ │ │ + throw new Error('Read not implemented.'); │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: moveTo │ │ │ │ - * Sets the left and top style attributes to the passed in pixel │ │ │ │ - * coordinates. │ │ │ │ + * Method: write │ │ │ │ + * Accept an object, and return a string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * px - {<OpenLayers.Pixel>} │ │ │ │ - */ │ │ │ │ - moveTo: function(px) { │ │ │ │ - if ((px != null) && (this.div != null)) { │ │ │ │ - this.div.style.left = px.x + "px"; │ │ │ │ - this.div.style.top = px.y + "px"; │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: activate │ │ │ │ - * Explicitly activates a control and it's associated │ │ │ │ - * handler if one has been set. Controls can be │ │ │ │ - * deactivated by calling the deactivate() method. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {Boolean} True if the control was successfully activated or │ │ │ │ - * false if the control was already active. │ │ │ │ - */ │ │ │ │ - activate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - return false; │ │ │ │ - } │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.activate(); │ │ │ │ - } │ │ │ │ - this.active = true; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.addClass( │ │ │ │ - this.map.viewPortDiv, │ │ │ │ - this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("activate"); │ │ │ │ - return true; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: deactivate │ │ │ │ - * Deactivates a control and it's associated handler if any. The exact │ │ │ │ - * effect of this depends on the control itself. │ │ │ │ - * │ │ │ │ + * object - {Object} Object to be serialized │ │ │ │ + * │ │ │ │ * Returns: │ │ │ │ - * {Boolean} True if the control was effectively deactivated or false │ │ │ │ - * if the control was already inactive. │ │ │ │ + * {String} A string representation of the object. │ │ │ │ */ │ │ │ │ - deactivate: function() { │ │ │ │ - if (this.active) { │ │ │ │ - if (this.handler) { │ │ │ │ - this.handler.deactivate(); │ │ │ │ - } │ │ │ │ - this.active = false; │ │ │ │ - if (this.map) { │ │ │ │ - OpenLayers.Element.removeClass( │ │ │ │ - this.map.viewPortDiv, │ │ │ │ - this.displayClass.replace(/ /g, "") + "Active" │ │ │ │ - ); │ │ │ │ - } │ │ │ │ - this.events.triggerEvent("deactivate"); │ │ │ │ - return true; │ │ │ │ - } │ │ │ │ - return false; │ │ │ │ + write: function(object) { │ │ │ │ + throw new Error('Write not implemented.'); │ │ │ │ }, │ │ │ │ │ │ │ │ - CLASS_NAME: "OpenLayers.Control" │ │ │ │ + CLASS_NAME: "OpenLayers.Format" │ │ │ │ }); │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_BUTTON │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_BUTTON = 1; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_TOGGLE │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_TOGGLE = 2; │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Constant: OpenLayers.Control.TYPE_TOOL │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.TYPE_TOOL = 3; │ │ │ │ /* ====================================================================== │ │ │ │ - OpenLayers/Events/buttonclick.js │ │ │ │ + OpenLayers/Format/JSON.js │ │ │ │ ====================================================================== */ │ │ │ │ │ │ │ │ /* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ * full text of the license. */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * @requires OpenLayers/Events.js │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ │ │ │ │ /** │ │ │ │ - * Class: OpenLayers.Events.buttonclick │ │ │ │ - * Extension event type for handling buttons on top of a dom element. This │ │ │ │ - * event type fires "buttonclick" on its <target> when a button was │ │ │ │ - * clicked. Buttons are detected by the "olButton" class. │ │ │ │ - * │ │ │ │ - * This event type makes sure that button clicks do not interfere with other │ │ │ │ - * events that are registered on the same <element>. │ │ │ │ + * @requires OpenLayers/Format.js │ │ │ │ + */ │ │ │ │ + │ │ │ │ +/** │ │ │ │ + * Class: OpenLayers.Format.JSON │ │ │ │ + * A parser to read/write JSON safely. Create a new instance with the │ │ │ │ + * <OpenLayers.Format.JSON> constructor. │ │ │ │ * │ │ │ │ - * Event types provided by this extension: │ │ │ │ - * - *buttonclick* Triggered when a button is clicked. Listeners receive an │ │ │ │ - * object with a *buttonElement* property referencing the dom element of │ │ │ │ - * the clicked button, and an *buttonXY* property with the click position │ │ │ │ - * relative to the button. │ │ │ │ + * Inherits from: │ │ │ │ + * - <OpenLayers.Format> │ │ │ │ */ │ │ │ │ -OpenLayers.Events.buttonclick = OpenLayers.Class({ │ │ │ │ +OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, { │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: target │ │ │ │ - * {<OpenLayers.Events>} The events instance that the buttonclick event will │ │ │ │ - * be triggered on. │ │ │ │ + * APIProperty: indent │ │ │ │ + * {String} For "pretty" printing, the indent string will be used once for │ │ │ │ + * each indentation level. │ │ │ │ */ │ │ │ │ - target: null, │ │ │ │ + indent: " ", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: events │ │ │ │ - * {Array} Events to observe and conditionally stop from propagating when │ │ │ │ - * an element with the olButton class (or its olAlphaImg child) is │ │ │ │ - * clicked. │ │ │ │ + * APIProperty: space │ │ │ │ + * {String} For "pretty" printing, the space string will be used after │ │ │ │ + * the ":" separating a name/value pair. │ │ │ │ */ │ │ │ │ - events: [ │ │ │ │ - 'mousedown', 'mouseup', 'click', 'dblclick', │ │ │ │ - 'touchstart', 'touchmove', 'touchend', 'keydown' │ │ │ │ - ], │ │ │ │ + space: " ", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: startRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that start │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * APIProperty: newline │ │ │ │ + * {String} For "pretty" printing, the newline string will be used at the │ │ │ │ + * end of each name/value pair or array item. │ │ │ │ */ │ │ │ │ - startRegEx: /^mousedown|touchstart$/, │ │ │ │ + newline: "\n", │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: cancelRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that cancel │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * Property: level │ │ │ │ + * {Integer} For "pretty" printing, this is incremented/decremented during │ │ │ │ + * serialization. │ │ │ │ */ │ │ │ │ - cancelRegEx: /^touchmove$/, │ │ │ │ + level: 0, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: completeRegEx │ │ │ │ - * {RegExp} Regular expression to test Event.type for events that complete │ │ │ │ - * a buttonclick sequence. │ │ │ │ + * Property: pretty │ │ │ │ + * {Boolean} Serialize with extra whitespace for structure. This is set │ │ │ │ + * by the <write> method. │ │ │ │ */ │ │ │ │ - completeRegEx: /^mouseup|touchend$/, │ │ │ │ + pretty: false, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Property: startEvt │ │ │ │ - * {Event} The event that started the click sequence │ │ │ │ + * Property: nativeJSON │ │ │ │ + * {Boolean} Does the browser support native json? │ │ │ │ */ │ │ │ │ + nativeJSON: (function() { │ │ │ │ + return !!(window.JSON && typeof JSON.parse == "function" && typeof JSON.stringify == "function"); │ │ │ │ + })(), │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Events.buttonclick │ │ │ │ - * Construct a buttonclick event type. Applications are not supposed to │ │ │ │ - * create instances of this class - they are created on demand by │ │ │ │ - * <OpenLayers.Events> instances. │ │ │ │ + * Constructor: OpenLayers.Format.JSON │ │ │ │ + * Create a new parser for JSON. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * target - {<OpenLayers.Events>} The events instance that the buttonclick │ │ │ │ - * event will be triggered on. │ │ │ │ - */ │ │ │ │ - initialize: function(target) { │ │ │ │ - this.target = target; │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.register(this.events[i], this, this.buttonClick, { │ │ │ │ - extension: true │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: destroy │ │ │ │ - */ │ │ │ │ - destroy: function() { │ │ │ │ - for (var i = this.events.length - 1; i >= 0; --i) { │ │ │ │ - this.target.unregister(this.events[i], this, this.buttonClick); │ │ │ │ - } │ │ │ │ - delete this.target; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * Method: getPressedButton │ │ │ │ - * Get the pressed button, if any. Returns undefined if no button │ │ │ │ - * was pressed. │ │ │ │ - * │ │ │ │ - * Arguments: │ │ │ │ - * element - {DOMElement} The event target. │ │ │ │ - * │ │ │ │ - * Returns: │ │ │ │ - * {DOMElement} The button element, or undefined. │ │ │ │ + * options - {Object} An optional object whose properties will be set on │ │ │ │ + * this instance. │ │ │ │ */ │ │ │ │ - getPressedButton: function(element) { │ │ │ │ - var depth = 3, // limit the search depth │ │ │ │ - button; │ │ │ │ - do { │ │ │ │ - if (OpenLayers.Element.hasClass(element, "olButton")) { │ │ │ │ - // hit! │ │ │ │ - button = element; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - element = element.parentNode; │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return button; │ │ │ │ - }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Method: ignore │ │ │ │ - * Check for event target elements that should be ignored by OpenLayers. │ │ │ │ + * APIMethod: read │ │ │ │ + * Deserialize a json string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * element - {DOMElement} The event target. │ │ │ │ + * 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 . │ │ │ │ */ │ │ │ │ - ignore: function(element) { │ │ │ │ - var depth = 3, │ │ │ │ - ignore = false; │ │ │ │ - do { │ │ │ │ - if (element.nodeName.toLowerCase() === 'a') { │ │ │ │ - ignore = true; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - element = element.parentNode; │ │ │ │ - } while (--depth > 0 && element); │ │ │ │ - return ignore; │ │ │ │ - }, │ │ │ │ + read: function(json, filter) { │ │ │ │ + var object; │ │ │ │ + if (this.nativeJSON) { │ │ │ │ + object = JSON.parse(json, filter); │ │ │ │ + } else try { │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ + */ │ │ │ │ + if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, '@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Method: buttonClick │ │ │ │ - * Check if a button was clicked, and fire the buttonclick event │ │ │ │ - * │ │ │ │ - * Parameters: │ │ │ │ - * evt - {Event} │ │ │ │ - */ │ │ │ │ - buttonClick: function(evt) { │ │ │ │ - var propagate = true, │ │ │ │ - element = OpenLayers.Event.element(evt); │ │ │ │ - if (element && (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))) { │ │ │ │ - // was a button pressed? │ │ │ │ - var button = this.getPressedButton(element); │ │ │ │ - if (button) { │ │ │ │ - if (evt.type === "keydown") { │ │ │ │ - switch (evt.keyCode) { │ │ │ │ - case OpenLayers.Event.KEY_RETURN: │ │ │ │ - case OpenLayers.Event.KEY_SPACE: │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button │ │ │ │ - }); │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - break; │ │ │ │ - } │ │ │ │ - } else if (this.startEvt) { │ │ │ │ - if (this.completeRegEx.test(evt.type)) { │ │ │ │ - var pos = OpenLayers.Util.pagePosition(button); │ │ │ │ - var viewportElement = OpenLayers.Util.getViewportElement(); │ │ │ │ - var scrollTop = window.pageYOffset || viewportElement.scrollTop; │ │ │ │ - var scrollLeft = window.pageXOffset || viewportElement.scrollLeft; │ │ │ │ - pos[0] = pos[0] - scrollLeft; │ │ │ │ - pos[1] = pos[1] - scrollTop; │ │ │ │ + /** │ │ │ │ + * 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. │ │ │ │ + */ │ │ │ │ + object = eval('(' + json + ')'); │ │ │ │ │ │ │ │ - this.target.triggerEvent("buttonclick", { │ │ │ │ - buttonElement: button, │ │ │ │ - buttonXY: { │ │ │ │ - x: this.startEvt.clientX - pos[0], │ │ │ │ - y: this.startEvt.clientY - pos[1] │ │ │ │ + /** │ │ │ │ + * 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]); │ │ │ │ + } │ │ │ │ } │ │ │ │ - }); │ │ │ │ - } │ │ │ │ - if (this.cancelRegEx.test(evt.type)) { │ │ │ │ - delete this.startEvt; │ │ │ │ + } │ │ │ │ + return filter(k, v); │ │ │ │ } │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ - } │ │ │ │ - if (this.startRegEx.test(evt.type)) { │ │ │ │ - this.startEvt = evt; │ │ │ │ - OpenLayers.Event.stop(evt); │ │ │ │ - propagate = false; │ │ │ │ + object = walk('', object); │ │ │ │ } │ │ │ │ - } else { │ │ │ │ - propagate = !this.ignore(OpenLayers.Event.element(evt)); │ │ │ │ - delete this.startEvt; │ │ │ │ } │ │ │ │ + } catch (e) { │ │ │ │ + // Fall through if the regexp test fails. │ │ │ │ } │ │ │ │ - return propagate; │ │ │ │ - } │ │ │ │ - │ │ │ │ -}); │ │ │ │ -/* ====================================================================== │ │ │ │ - OpenLayers/Control/Panel.js │ │ │ │ - ====================================================================== */ │ │ │ │ - │ │ │ │ -/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for │ │ │ │ - * full list of contributors). Published under the 2-clause BSD license. │ │ │ │ - * See license.txt in the OpenLayers distribution or repository for the │ │ │ │ - * full text of the license. */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * @requires OpenLayers/Control.js │ │ │ │ - * @requires OpenLayers/Events/buttonclick.js │ │ │ │ - */ │ │ │ │ - │ │ │ │ -/** │ │ │ │ - * Class: OpenLayers.Control.Panel │ │ │ │ - * The Panel control is a container for other controls. With it toolbars │ │ │ │ - * may be composed. │ │ │ │ - * │ │ │ │ - * Inherits from: │ │ │ │ - * - <OpenLayers.Control> │ │ │ │ - */ │ │ │ │ -OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { │ │ │ │ - /** │ │ │ │ - * Property: controls │ │ │ │ - * {Array(<OpenLayers.Control>)} │ │ │ │ - */ │ │ │ │ - controls: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: autoActivate │ │ │ │ - * {Boolean} Activate the control when it is added to a map. Default is │ │ │ │ - * true. │ │ │ │ - */ │ │ │ │ - autoActivate: true, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: defaultControl │ │ │ │ - * {<OpenLayers.Control>} The control which is activated when the control is │ │ │ │ - * activated (turned on), which also happens at instantiation. │ │ │ │ - * If <saveState> is true, <defaultControl> will be nullified after the │ │ │ │ - * first activation of the panel. │ │ │ │ - */ │ │ │ │ - defaultControl: null, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIProperty: saveState │ │ │ │ - * {Boolean} If set to true, the active state of this panel's controls will │ │ │ │ - * be stored on panel deactivation, and restored on reactivation. Default │ │ │ │ - * is false. │ │ │ │ - */ │ │ │ │ - saveState: false, │ │ │ │ │ │ │ │ - /** │ │ │ │ - * APIProperty: allowDepress │ │ │ │ - * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can │ │ │ │ - * be deactivated by clicking the icon that represents them. Default │ │ │ │ - * is false. │ │ │ │ - */ │ │ │ │ - allowDepress: false, │ │ │ │ + if (this.keepData) { │ │ │ │ + this.data = object; │ │ │ │ + } │ │ │ │ │ │ │ │ - /** │ │ │ │ - * Property: activeState │ │ │ │ - * {Object} stores the active state of this panel's controls. │ │ │ │ - */ │ │ │ │ - activeState: null, │ │ │ │ + return object; │ │ │ │ + }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * Constructor: OpenLayers.Control.Panel │ │ │ │ - * Create a new control panel. │ │ │ │ - * │ │ │ │ - * Each control in the panel is represented by an icon. When clicking │ │ │ │ - * on an icon, the <activateControl> method is called. │ │ │ │ - * │ │ │ │ - * Specific properties for controls on a panel: │ │ │ │ - * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>, │ │ │ │ - * <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>. │ │ │ │ - * If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed. │ │ │ │ - * title - {string} Text displayed when mouse is over the icon that │ │ │ │ - * represents the control. │ │ │ │ - * │ │ │ │ - * The <OpenLayers.Control.type> of a control determines the behavior when │ │ │ │ - * clicking its icon: │ │ │ │ - * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other │ │ │ │ - * controls of this type in the same panel are deactivated. This is │ │ │ │ - * the default type. │ │ │ │ - * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is │ │ │ │ - * toggled. │ │ │ │ - * <OpenLayers.Control.TYPE_BUTTON> - The │ │ │ │ - * <OpenLayers.Control.Button.trigger> method of the control is called, │ │ │ │ - * but its active state is not changed. │ │ │ │ - * │ │ │ │ - * If a control is <OpenLayers.Control.active>, it will be drawn with the │ │ │ │ - * olControl[Name]ItemActive class, otherwise with the │ │ │ │ - * olControl[Name]ItemInactive class. │ │ │ │ + * APIMethod: write │ │ │ │ + * Serialize an object into a JSON string. │ │ │ │ * │ │ │ │ * Parameters: │ │ │ │ - * options - {Object} An optional object whose properties will be used │ │ │ │ - * to extend the control. │ │ │ │ - */ │ │ │ │ - initialize: function(options) { │ │ │ │ - OpenLayers.Control.prototype.initialize.apply(this, [options]); │ │ │ │ - this.controls = []; │ │ │ │ - this.activeState = {}; │ │ │ │ - }, │ │ │ │ - │ │ │ │ - /** │ │ │ │ - * APIMethod: destroy │ │ │ │ + * 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. │ │ │ │ */ │ │ │ │ - destroy: function() { │ │ │ │ - if (this.map) { │ │ │ │ - this.map.events.unregister("buttonclick", this, this.onButtonClick); │ │ │ │ - } │ │ │ │ - OpenLayers.Control.prototype.destroy.apply(this, arguments); │ │ │ │ - for (var ctl, i = this.controls.length - 1; i >= 0; i--) { │ │ │ │ - ctl = this.controls[i]; │ │ │ │ - if (ctl.events) { │ │ │ │ - ctl.events.un({ │ │ │ │ - activate: this.iconOn, │ │ │ │ - deactivate: this.iconOff │ │ │ │ - }); │ │ │ │ + write: function(value, pretty) { │ │ │ │ + this.pretty = !!pretty; │ │ │ │ + var json = null; │ │ │ │ + var type = typeof value; │ │ │ │ + if (this.serialize[type]) { │ │ │ │ + try { │ │ │ │ + json = (!this.pretty && this.nativeJSON) ? │ │ │ │ + JSON.stringify(value) : │ │ │ │ + this.serialize[type].apply(this, [value]); │ │ │ │ + } catch (err) { │ │ │ │ + OpenLayers.Console.error("Trouble serializing: " + err); │ │ │ │ } │ │ │ │ - ctl.panel_div = null; │ │ │ │ } │ │ │ │ - this.activeState = null; │ │ │ │ + return json; │ │ │ │ }, │ │ │ │ │ │ │ │ /** │ │ │ │ - * APIMet TRUNCATED DUE TO SIZE LIMIT: 10485760 bytes