ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Adding some serious enhancements to the WMC format. With this, OL map and layer objects can be created from WMC context objects and vice versa. Thanks for the great patch bbinet. r=me (closes #2251)

Browse Source 
git-svn-id: http://svn.openlayers.org/trunk/openlayers@9733 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
This commit is contained in:
Tim Schaub
2009-10-08 17:24:54 +00:00
parent 039618366f
commit 6dabe0646e
6 changed files with 444 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

261
lib/OpenLayers/Format/WMC.js
View File

@@ -86,23 +86,11 @@ OpenLayers.Format.WMC = OpenLayers.Class({
var version = this.version;
if(!version) {
version = root.getAttribute("version");
if(!version) {
version = this.defaultVersion;
}
}
if(!this.parser || this.parser.VERSION != version) {
var format = OpenLayers.Format.WMC[
"v" + version.replace(/\./g, "_")
];
if(!format) {
throw "Can't find a WMC parser for version " +
version;
}
this.parser = new format(this.options);
}
var context = this.parser.read(data, options);
var parser = this.getParser(version);
var context = parser.read(data, options);
var map;
if(options.map) {
if(options && options.map) {
this.context = context;
if(options.map instanceof OpenLayers.Map) {
map = this.mergeContextToMap(context, options.map);
@@ -115,6 +103,127 @@ OpenLayers.Format.WMC = OpenLayers.Class({
}
return map;
},
/**
* Method: getParser
* Get the WMC parser given a version. Create a new parser if it does not
* already exist.
*
* Parameters:
* version - {String} The version of the parser.
*
* Returns:
* {<OpenLayers.Format.WMC.v1>} A WMC parser.
*/
getParser: function(version) {
var v = version || this.version || this.defaultVersion;
if(!this.parser || this.parser.VERSION != v) {
var format = OpenLayers.Format.WMC[
"v" + v.replace(/\./g, "_")
];
if(!format) {
throw "Can't find a WMC parser for version " + v;
}
this.parser = new format(this.options);
}
return this.parser;
},
/**
* 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,
numZoomLevels: layerContext.numZoomLevels,
units: layerContext.units,
isBaseLayer: layerContext.isBaseLayer,
opacity: layerContext.opacity,
displayInLayerSwitcher: layerContext.displayInLayerSwitcher,
singleTile: layerContext.singleTile,
minScale: layerContext.minScale,
maxScale: layerContext.maxScale
};
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 = new OpenLayers.Layer.WMS(
layerContext.title || layerContext.name,
layerContext.url,
params,
options
);
return layer;
},
/**
* Method: getLayersFromContext
* Create an array of WMS layers from an array of layerContext objects.
*
* Parameters:
* layersContext - {Array(Object)} An array of objects representing WMS layers.
*
* Returns:
* {Array(<OpenLayers.Layer.WMS>)} An array of WMS layers.
*/
getLayersFromContext: function(layersContext) {
var layers = [];
for (var i=0, len=layersContext.length; i<len; i++) {
layers.push(this.getLayerFromContext(layersContext[i]));
}
return layers;
},
/**
* Method: contextToMap
@@ -133,7 +242,7 @@ OpenLayers.Format.WMC = OpenLayers.Class({
maxExtent: context.maxExtent,
projection: context.projection
});
map.addLayers(context.layers);
map.addLayers(this.getLayersFromContext(context.layersContext));
map.setCenter(
context.bounds.getCenterLonLat(),
map.getZoomForExtent(context.bounds, true)
@@ -153,7 +262,7 @@ OpenLayers.Format.WMC = OpenLayers.Class({
* {<OpenLayers.Map>} The same map with layers added.
*/
mergeContextToMap: function(context, map) {
map.addLayers(context.layers);
map.addLayers(this.getLayersFromContext(context.layersContext));
return map;
},
@@ -169,43 +278,107 @@ OpenLayers.Format.WMC = OpenLayers.Class({
* {String} A WMC document string.
*/
write: function(obj, options) {
if(obj.CLASS_NAME == "OpenLayers.Map") {
obj = this.mapToContext(obj);
}
var version = (options && options.version) ||
this.version || this.defaultVersion;
if(!this.parser || this.parser.VERSION != version) {
var format = OpenLayers.Format.WMC[
"v" + version.replace(/\./g, "_")
];
if(!format) {
throw "Can't find a WMS capabilities parser for version " +
version;
}
this.parser = new format(this.options);
}
var wmc = this.parser.write(obj, options);
obj = this.toContext(obj);
var version = options && options.version;
var parser = this.getParser(version);
var wmc = parser.write(obj, options);
return wmc;
},
/**
* Method: mapToContext
* Create a context object given a map.
* Method: layerToContext
* Create a layer context object given a wms layer object.
*
* Parameters:
* map - {<OpenLayers.Map>} The map.
* obj - {<OpenLayers.Layer.WMS>} The layer.
*
* Returns:
* {Object} A layer context object.
*/
layerToContext: function(layer) {
var parser = this.getParser();
var layerContext = {
queryable: layer.queryable,
visibility: layer.visibility,
name: layer.params["LAYERS"],
title: layer.name,
metadataURL: layer.metadataURL,
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,
displayInLayerSwitcher: layer.displayInLayerSwitcher,
singleTile: layer.singleTile,
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: [{
value: layer.params["FORMAT"],
current: true
}],
styles: [{
href: layer.params["SLD"],
body: layer.params["SLD_BODY"],
name: layer.params["STYLES"] || parser.defaultStyleName,
title: parser.defaultStyleTitle,
current: true
}]
};
return layerContext;
},
/**
* 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.
*/
mapToContext: function(map) {
var context = {
bounds: map.getExtent(),
maxExtent: map.maxExtent,
projection: map.projection,
layers: map.layers,
size: map.getSize()
};
toContext: function(obj) {
var context = {};
var layers = obj.layers;
if(obj.CLASS_NAME == "OpenLayers.Map") {
context.bounds = obj.getExtent();
context.maxExtent = obj.maxExtent;
context.projection = obj.projection;
context.size = obj.getSize();
}
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 && layers instanceof Array) {
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;
},