summaryrefslogtreecommitdiff
path: root/misc/openlayers/lib/OpenLayers/Format/Context.js
diff options
context:
space:
mode:
authorChris Schlaeger <chris@linux.com>2014-08-12 21:56:44 +0200
committerChris Schlaeger <chris@linux.com>2014-08-12 21:56:44 +0200
commitea346a785dc1b3f7c156f6fc33da634e1f1a627b (patch)
treeaf67530553d20b6e82ad60fd79593e9c4abf5565 /misc/openlayers/lib/OpenLayers/Format/Context.js
parent59741cd535c47f25971bf8c32b25da25ceadc6d5 (diff)
downloadpostrunner-ea346a785dc1b3f7c156f6fc33da634e1f1a627b.zip
Adding jquery, flot and openlayers to be included with the GEM.v0.0.4
Diffstat (limited to 'misc/openlayers/lib/OpenLayers/Format/Context.js')
-rw-r--r--misc/openlayers/lib/OpenLayers/Format/Context.js334
1 files changed, 334 insertions, 0 deletions
diff --git a/misc/openlayers/lib/OpenLayers/Format/Context.js b/misc/openlayers/lib/OpenLayers/Format/Context.js
new file mode 100644
index 0000000..73d6203
--- /dev/null
+++ b/misc/openlayers/lib/OpenLayers/Format/Context.js
@@ -0,0 +1,334 @@
+/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
+ * full list of contributors). Published 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.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: layerOptions
+ * {Object} Default options for layers created by the parser. These
+ * options are overridden by the options which are read from the
+ * capabilities document.
+ */
+ layerOptions: null,
+
+ /**
+ * 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.
+ */
+ layerParams: 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.
+ */
+
+ /**
+ * APIMethod: read
+ * Read Context data from a string, and return an object with map
+ * properties and a list of layers.
+ *
+ * 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.
+ */
+ 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.
+ *
+ * Parameters:
+ * layerContext - {Object} An object representing a WMS layer.
+ *
+ * Returns:
+ * {<OpenLayers.Layer.WMS>} A WMS layer.
+ */
+ 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()
+ });
+ 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: getLayersFromContext
+ * Create an array of layers from an array of layerContext objects.
+ *
+ * Parameters:
+ * layersContext - {Array(Object)} An array of objects representing layers.
+ *
+ * Returns:
+ * {Array(<OpenLayers.Layer>)} An array of layers.
+ */
+ 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;
+ },
+
+ /**
+ * Method: contextToMap
+ * Create a map given a context object.
+ *
+ * Parameters:
+ * context - {Object} The context object.
+ * options - {Object} Default map options.
+ *
+ * Returns:
+ * {<OpenLayers.Map>} A map based on the context object.
+ */
+ 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;
+ },
+
+ /**
+ * Method: mergeContextToMap
+ * Add layers from a context object to a map.
+ *
+ * Parameters:
+ * context - {Object} The context object.
+ * map - {<OpenLayers.Map>} The map.
+ *
+ * Returns:
+ * {<OpenLayers.Map>} The same map with layers added.
+ */
+ mergeContextToMap: function(context, map) {
+ map.addLayers(this.getLayersFromContext(context.layersContext));
+ return map;
+ },
+
+ /**
+ * 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.
+ */
+ 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"
+};