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)

git-svn-id: http://svn.openlayers.org/trunk/openlayers@9733 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers/Format/WMC.js

@@ -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 parser = this.getParser(version);
-            var format = OpenLayers.Format.WMC[
+        var context = parser.read(data, options);
-                "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 map;
-        if(options.map) {
+        if(options && options.map) {
             this.context = context;
             if(options.map instanceof OpenLayers.Map) {
                 map = this.mergeContextToMap(context, options.map);
@@ -116,6 +104,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
      * Create a map given a context object.
@@ -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.toContext(obj);
-            obj = this.mapToContext(obj);
+        var version = options && options.version;
-        }
+        var parser = this.getParser(version);
-        var version = (options && options.version) ||
+        var wmc = parser.write(obj, options);
-                      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);
         return wmc;
     },
     
     /**
-     * Method: mapToContext
+     * Method: layerToContext
-     * Create a context object given a map.
+     * 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) {
+    toContext: function(obj) {
-        var context = {
+        var context = {};
-            bounds: map.getExtent(),
+        var layers = obj.layers;
-            maxExtent: map.maxExtent,
+        if(obj.CLASS_NAME == "OpenLayers.Map") {
-            projection: map.projection,
+            context.bounds = obj.getExtent();
-            layers: map.layers,
+            context.maxExtent = obj.maxExtent;
-            size: map.getSize()
+            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;
     },
 

lib/OpenLayers/Format/WMC/v1.js

@@ -157,7 +157,8 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
      * Method: read_wmc_LayerList
      */
     read_wmc_LayerList: function(context, node) {
-        context.layers = [];
+        // layersContext is an array containing info for each layer
+        context.layersContext = [];
         this.runChildNodes(context, node);
     },
     
@@ -165,47 +166,16 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
      * Method: read_wmc_Layer
      */
     read_wmc_Layer: function(context, node) {
-        var layerInfo = {
+        var layerContext = {
-            params: this.layerParams || {},
+            visibility: (node.getAttribute("hidden") != "1"),
-            options: {
+            queryable: (node.getAttribute("queryable") == "1"),
-                visibility: (node.getAttribute("hidden") != "1"),
-                queryable: (node.getAttribute("queryable") == "1")
-                
-            },
             formats: [],
             styles: []
         };
-        this.runChildNodes(layerInfo, node);
-        // set properties common to multiple objects on layer options/params
-        layerInfo.params.layers = layerInfo.name;
-        layerInfo.options.maxExtent = layerInfo.maxExtent;
-        // create the layer
-        var layer = this.getLayerFromInfo(layerInfo);
-        context.layers.push(layer);
-    },
 
-    /**
+        this.runChildNodes(layerContext, node);
-     * Method: getLayerFromInfo
+        // set properties common to multiple objects on layer options/params
-     * Create a WMS layer from a layerInfo object.
+        context.layersContext.push(layerContext);
-     *
-     * Parameters:
-     * layerInfo - {Object} An object representing a WMS layer.
-     *
-     * Returns:
-     * {<OpenLayers.Layer.WMS>} A WMS layer.
-     */
-    getLayerFromInfo: function(layerInfo) {
-        var options = layerInfo.options;
-        if (this.layerOptions) {
-            OpenLayers.Util.applyDefaults(options, this.layerOptions);
-        }
-        var layer = new OpenLayers.Layer.WMS(
-            layerInfo.title,
-            layerInfo.href,
-            layerInfo.params,
-            options
-        );
-        return layer;
     },
     
     /**
@@ -218,8 +188,8 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     /**
      * Method: read_ol_units
      */
-    read_ol_units: function(layerInfo, node) {
+    read_ol_units: function(layerContext, node) {
-        layerInfo.options.units = this.getChildValue(node);
+        layerContext.units = this.getChildValue(node);
     },
     
     /**
@@ -236,100 +206,95 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     /**
      * Method: read_ol_transparent
      */
-    read_ol_transparent: function(layerInfo, node) {
+    read_ol_transparent: function(layerContext, node) {
-        layerInfo.params.transparent = this.getChildValue(node);
+        layerContext.transparent = this.getChildValue(node);
     },
 
     /**
      * Method: read_ol_numZoomLevels
      */
-    read_ol_numZoomLevels: function(layerInfo, node) {
+    read_ol_numZoomLevels: function(layerContext, node) {
-        layerInfo.options.numZoomLevels = parseInt(this.getChildValue(node));
+        layerContext.numZoomLevels = parseInt(this.getChildValue(node));
     },
 
     /**
      * Method: read_ol_opacity
      */
-    read_ol_opacity: function(layerInfo, node) {
+    read_ol_opacity: function(layerContext, node) {
-        layerInfo.options.opacity = parseFloat(this.getChildValue(node));
+        layerContext.opacity = parseFloat(this.getChildValue(node));
     },
 
     /**
      * Method: read_ol_singleTile
      */
-    read_ol_singleTile: function(layerInfo, node) {
+    read_ol_singleTile: function(layerContext, node) {
-        layerInfo.options.singleTile = (this.getChildValue(node) == "true");
+        layerContext.singleTile = (this.getChildValue(node) == "true");
     },
 
     /**
      * Method: read_ol_isBaseLayer
      */
-    read_ol_isBaseLayer: function(layerInfo, node) {
+    read_ol_isBaseLayer: function(layerContext, node) {
-        layerInfo.options.isBaseLayer = (this.getChildValue(node) == "true");
+        layerContext.isBaseLayer = (this.getChildValue(node) == "true");
     },
 
     /**
      * Method: read_ol_displayInLayerSwitcher
      */
-    read_ol_displayInLayerSwitcher: function(layerInfo, node) {
+    read_ol_displayInLayerSwitcher: function(layerContext, node) {
-        layerInfo.options.displayInLayerSwitcher =
+        layerContext.displayInLayerSwitcher = (this.getChildValue(node) == "true");
-            (this.getChildValue(node) == "true");
     },
 
     /**
      * Method: read_wmc_Server
      */
-    read_wmc_Server: function(layerInfo, node) {
+    read_wmc_Server: function(layerContext, node) {
-        layerInfo.params.version = node.getAttribute("version");
+        layerContext.version = node.getAttribute("version");
-        this.runChildNodes(layerInfo, node);
+        var server = {};
+        var links = node.getElementsByTagName("OnlineResource");
+        if(links.length > 0) {
+            this.read_wmc_OnlineResource(server, links[0]);
+        }
+        layerContext.url = server.href;
     },
 
     /**
      * Method: read_wmc_FormatList
      */
-    read_wmc_FormatList: function(layerInfo, node) {
+    read_wmc_FormatList: function(layerContext, node) {
-        this.runChildNodes(layerInfo, node);
+        this.runChildNodes(layerContext, node);
     },
 
     /**
      * Method: read_wmc_Format
      */
-    read_wmc_Format: function(layerInfo, node) {
+    read_wmc_Format: function(layerContext, node) {
-        var format = this.getChildValue(node);
+        var format = {
-        layerInfo.formats.push(format);
+            value: this.getChildValue(node)
+        };
         if(node.getAttribute("current") == "1") {
-            layerInfo.params.format = format;
+            format.current = true;
         }
+        layerContext.formats.push(format);
     },
     
     /**
      * Method: read_wmc_StyleList
      */
-    read_wmc_StyleList: function(layerInfo, node) {
+    read_wmc_StyleList: function(layerContext, node) {
-        this.runChildNodes(layerInfo, node);
+        this.runChildNodes(layerContext, node);
     },
 
     /**
      * Method: read_wmc_Style
      */
-    read_wmc_Style: function(layerInfo, node) {
+    read_wmc_Style: function(layerContext, node) {
         var style = {};
         this.runChildNodes(style, node);
         if(node.getAttribute("current") == "1") {
-            // three style types to consider
+            style.current = true;
-            // 1) linked SLD
-            // 2) inline SLD
-            // 3) named style
-            // running child nodes always gets name, optionally gets href or body
-            if(style.href) {
-                layerInfo.params.sld = style.href;
-            } else if(style.body) {
-                layerInfo.params.sld_body = style.body;
-            } else {
-                layerInfo.params.styles = style.name;
-            }
         }
-        layerInfo.styles.push(style);
+        layerContext.styles.push(style);
     },
     
     /**
@@ -380,13 +345,13 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     /**
      * Method: read_wmc_MetadataURL
      */
-    read_wmc_MetadataURL: function(layerInfo, node) {
+    read_wmc_MetadataURL: function(layerContext, node) {
         var metadataURL = {};
         var links = node.getElementsByTagName("OnlineResource");
         if(links.length > 0) {
             this.read_wmc_OnlineResource(metadataURL, links[0]);
         }
-        layerInfo.options.metadataURL = metadataURL.href;
+        layerContext.metadataURL = metadataURL.href;
 
     },
 
@@ -400,17 +365,18 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
         }
     },
     
+    //FIXME: LatLonBoundingBox is not in spec
     /**
      * Method: read_wmc_LatLonBoundingBox
      */
-    read_wmc_LatLonBoundingBox: function(layer, node) {
+    //read_wmc_LatLonBoundingBox: function(layer, node) {
-        layer.llbbox = [
+        //layer.llbbox = [
-            parseFloat(node.getAttribute("minx")),
+            //parseFloat(node.getAttribute("minx")),
-            parseFloat(node.getAttribute("miny")),
+            //parseFloat(node.getAttribute("miny")),
-            parseFloat(node.getAttribute("maxx")),
+            //parseFloat(node.getAttribute("maxx")),
-            parseFloat(node.getAttribute("maxy"))
+            //parseFloat(node.getAttribute("maxy"))
-        ];
+        //];
-    },
+    //},
 
     /**
      * Method: read_wmc_LegendURL
@@ -594,12 +560,8 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     write_wmc_LayerList: function(context) {
         var list = this.createElementDefaultNS("LayerList");
         
-        var layer;
+        for(var i=0, len=context.layersContext.length; i<len; ++i) {
-        for(var i=0, len=context.layers.length; i<len; ++i) {
+            list.appendChild(this.write_wmc_Layer(context.layersContext[i]));
-            layer = context.layers[i];
-            if(layer instanceof OpenLayers.Layer.WMS) {
-                list.appendChild(this.write_wmc_Layer(layer));
-            }
         }
         
         return list;
@@ -607,38 +569,38 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
 
     /**
      * Method: write_wmc_Layer
-     * Create a Layer node given a layer object.
+     * Create a Layer node given a layer context object.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * context - {Object} A layer context object.}
      *
      * Returns:
      * {Element} A WMC Layer element node.
      */
-    write_wmc_Layer: function(layer) {
+    write_wmc_Layer: function(context) {
         var node = this.createElementDefaultNS(
             "Layer", null, {
-                queryable: layer.queryable ? "1" : "0",
+                queryable: context.queryable ? "1" : "0",
-                hidden: layer.visibility ? "0" : "1"
+                hidden: context.visibility ? "0" : "1"
             }
         );
         
         // required Server element
-        node.appendChild(this.write_wmc_Server(layer));
+        node.appendChild(this.write_wmc_Server(context));
 
         // required Name element
         node.appendChild(this.createElementDefaultNS(
-            "Name", layer.params["LAYERS"]
+            "Name", context.name
         ));
         
         // required Title element
         node.appendChild(this.createElementDefaultNS(
-            "Title", layer.name
+            "Title", context.title
         ));
 
         // optional MetadataURL element
-        if (layer.metadataURL) {
+        if (context.metadataURL) {
-            node.appendChild(this.write_wmc_MetadataURL(layer));
+            node.appendChild(this.write_wmc_MetadataURL(context.metadataURL));
         }
         
         return node;
@@ -649,15 +611,15 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
      * Add OpenLayers specific layer parameters to an Extension element.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} A WMS layer.
+     * context - {Object} A layer context object.
      *
      * Returns:
      * {Element} A WMC Extension element (for a layer).
      */
-    write_wmc_LayerExtension: function(layer) {
+    write_wmc_LayerExtension: function(context) {
         var node = this.createElementDefaultNS("Extension");
         
-        var bounds = layer.maxExtent;
+        var bounds = context.maxExtent;
         var maxExtent = this.createElementNS(
             this.namespaces.ol, "ol:maxExtent"
         );
@@ -669,22 +631,13 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
         });
         node.appendChild(maxExtent);
         
-        var param = layer.params["TRANSPARENT"];
-        if(param) {
-            var trans = this.createElementNS(
-                this.namespaces.ol, "ol:transparent"
-            );
-            trans.appendChild(this.createTextNode(param));
-            node.appendChild(trans);
-        }
-        
         var properties = [
-            "numZoomLevels", "units", "isBaseLayer",
+            "transparent", "numZoomLevels", "units", "isBaseLayer",
             "opacity", "displayInLayerSwitcher", "singleTile"
         ];
         var child;
         for(var i=0, len=properties.length; i<len; ++i) {
-            child = this.createOLPropertyNode(layer, properties[i]);
+            child = this.createOLPropertyNode(context, properties[i]);
             if(child) {
                 node.appendChild(child);
             }
@@ -716,116 +669,143 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
 
     /**
      * Method: write_wmc_Server
-     * Create a Server node given a layer object.
+     * Create a Server node given a layer context object.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * context - {Object} Layer context object.
      *
      * Returns:
      * {Element} A WMC Server element node.
      */
-    write_wmc_Server: function(layer) {
+    write_wmc_Server: function(context) {
         var node = this.createElementDefaultNS("Server");
         this.setAttributes(node, {
             service: "OGC:WMS",
-            version: layer.params["VERSION"]
+            version: context.version
         });
         
         // required OnlineResource element
-        node.appendChild(this.write_wmc_OnlineResource(layer.url));
+        node.appendChild(this.write_wmc_OnlineResource(context.url));
         
         return node;
     },
 
     /**
      * Method: write_wmc_MetadataURL
-     * Create a MetadataURL node given a layer object.
+     * Create a MetadataURL node given a metadataURL string.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * metadataURL - {String} MetadataURL string value.
      *
      * Returns:
      * {Element} A WMC metadataURL element node.
      */
-    write_wmc_MetadataURL: function(layer) {
+    write_wmc_MetadataURL: function(metadataURL) {
         var node = this.createElementDefaultNS("MetadataURL");
 
         // required OnlineResource element
-        node.appendChild(this.write_wmc_OnlineResource(layer.metadataURL));
+        node.appendChild(this.write_wmc_OnlineResource(metadataURL));
 
         return node;
     },
 
     /**
      * Method: write_wmc_FormatList
-     * Create a FormatList node given a layer.
+     * Create a FormatList node given a layer context.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * context - {Object} Layer context object.
      *
      * Returns:
      * {Element} A WMC FormatList element node.
      */
-    write_wmc_FormatList: function(layer) {
+    write_wmc_FormatList: function(context) {
         var node = this.createElementDefaultNS("FormatList");
-        node.appendChild(this.createElementDefaultNS(
+        for (var i=0, len=context.formats.length; i<len; i++) {
-            "Format", layer.params["FORMAT"], {current: "1"}
+            var format = context.formats[i];
-        ));
+            node.appendChild(this.createElementDefaultNS(
+                "Format",
+                format.value,
+                (format.current && format.current == true) ?
+                    {current: "1"} : null
+            ));
+        }
 
         return node;
     },
 
     /**
      * Method: write_wmc_StyleList
-     * Create a StyleList node given a layer.
+     * Create a StyleList node given a layer context.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * context - {Object} Layer context object.
      *
      * Returns:
      * {Element} A WMC StyleList element node.
      */
     write_wmc_StyleList: function(layer) {
         var node = this.createElementDefaultNS("StyleList");
-        var style = this.createElementDefaultNS(
-            "Style", null, {current: "1"}
-        );
 
-        // Style can come from one of three places (prioritized as below):
+        var styles = layer.styles;
-        // 1) an SLD parameter
+        if (styles && styles instanceof Array) {
-        // 2) and SLD_BODY parameter
+            var sld;
-        // 3) the STYLES parameter
+            for (var i=0, len=styles.length; i<len; i++) {
-        
+                var s = styles[i];
-        if(layer.params["SLD"]) {
+                // three style types to consider
-            // create link from SLD parameter
+                // [1] linked SLD
-            var sld = this.createElementDefaultNS("SLD");
+                // [2] inline SLD
-            var link = this.write_wmc_OnlineResource(layer.params["SLD"]);
+                // [3] named style
-            sld.appendChild(link);
+                // running child nodes always gets name, optionally gets href or body
-            style.appendChild(sld);
+                var style = this.createElementDefaultNS(
-        } else if(layer.params["SLD_BODY"]) {
+                    "Style",
-            // include sld fragment from SLD_BODY parameter
+                    null,
-            var sld = this.createElementDefaultNS("SLD");
+                    (s.current && s.current == true) ?
-            var body = layer.params["SLD_BODY"];
+                    {current: "1"} : null
-            // read in body as xml doc - assume proper namespace declarations
+                );
-            var doc = OpenLayers.Format.XML.prototype.read.apply(this, [body]);
+                if(s.href) { // [1]
-            // append to StyledLayerDescriptor node
+                    sld = this.createElementDefaultNS("SLD");
-            var imported = doc.documentElement;
+                    var link = this.write_wmc_OnlineResource(s.href);
-            if(sld.ownerDocument && sld.ownerDocument.importNode) {
+                    sld.appendChild(link);
-                imported = sld.ownerDocument.importNode(imported, true);
+                    // Name is required.
+                    sld.appendChild(this.createElementDefaultNS("Name", s.name));
+                    // Title is optionnal.
+                    if (s.title) {
+                        sld.appendChild(this.createElementDefaultNS("Title", s.title));
+                    }
+                    style.appendChild(sld);
+                } else if(s.body) { // [2]
+                    sld = this.createElementDefaultNS("SLD");
+                    // 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);
+                    // Name is required.
+                    sld.appendChild(this.createElementDefaultNS("Name", s.name));
+                    // Title is optionnal.
+                    if (s.title) {
+                        sld.appendChild(this.createElementDefaultNS("Title", s.title));
+                    }
+                    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 optionnal
+                    if (s['abstract']) { // abstract is a js keyword
+                        style.appendChild(this.createElementDefaultNS(
+                            "Abstract", s['abstract']
+                        ));
+                    }
+                }
+                node.appendChild(style);
             }
-            sld.appendChild(imported);
-            style.appendChild(sld);            
-        } else {
-            // use name(s) from STYLES parameter
-            var name = layer.params["STYLES"] ?
-                layer.params["STYLES"] : this.defaultStyleName;
-            
-            style.appendChild(this.createElementDefaultNS("Name", name));
-            style.appendChild(this.createElementDefaultNS(
-                "Title", this.defaultStyleTitle
-            ));
         }
-        node.appendChild(style);
+
         return node;
     },
 

lib/OpenLayers/Format/WMC/v1_0_0.js

@@ -46,27 +46,28 @@ OpenLayers.Format.WMC.v1_0_0 = OpenLayers.Class(
 
     /**
      * Method: write_wmc_Layer
-     * Create a Layer node given a layer object.
+     * Create a Layer node given a layer context object. This method adds
+     *     elements specific to version 1.0.0.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * context - {Object} A layer context object.}
      *
      * Returns:
      * {Element} A WMC Layer element node.
      */
-    write_wmc_Layer: function(layer) {
+    write_wmc_Layer: function(context) {
         var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply(
-            this, [layer]
+            this, [context]
         );
     
         // optional FormatList element
-        node.appendChild(this.write_wmc_FormatList(layer));
+        node.appendChild(this.write_wmc_FormatList(context));
 
         // optional StyleList element
-        node.appendChild(this.write_wmc_StyleList(layer));
+        node.appendChild(this.write_wmc_StyleList(context));
         
         // OpenLayers specific properties go in an Extension element
-        node.appendChild(this.write_wmc_LayerExtension(layer));
+        node.appendChild(this.write_wmc_LayerExtension(context));
     },    
 
     CLASS_NAME: "OpenLayers.Format.WMC.v1_0_0" 

lib/OpenLayers/Format/WMC/v1_1_0.js

@@ -53,11 +53,11 @@ OpenLayers.Format.WMC.v1_1_0 = OpenLayers.Class(
      * Read a sld:MinScaleDenominator node.
      *
      * Parameters:
-     * layerInfo - {Object} An object representing a layer.
+     * layerContext - {Object} An object representing a layer.
      * node - {Element} An element node.
      */
-    read_sld_MinScaleDenominator: function(layerInfo, node) {
+    read_sld_MinScaleDenominator: function(layerContext, node) {
-        layerInfo.options.maxScale = this.getChildValue(node);
+        layerContext.maxScale = this.getChildValue(node);
     },
 
     /**
@@ -65,56 +65,54 @@ OpenLayers.Format.WMC.v1_1_0 = OpenLayers.Class(
      * Read a sld:MaxScaleDenominator node.
      *
      * Parameters:
-     * layerInfo - {Object} An object representing a layer.
+     * layerContext - {Object} An object representing a layer.
      * node - {Element} An element node.
      */
-    read_sld_MaxScaleDenominator: function(layerInfo, node) {
+    read_sld_MaxScaleDenominator: function(layerContext, node) {
-        layerInfo.options.minScale = this.getChildValue(node);
+        layerContext.minScale = this.getChildValue(node);
     },
 
     /**
      * Method: write_wmc_Layer
-     * Create a Layer node given a layer object.  This method adds elements
+     * Create a Layer node given a layer context object. This method adds
-     *     specific to version 1.1.0.
+     *     elements specific to version 1.1.0.
      *
      * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * context - {Object} A layer context object.}
      *
      * Returns:
      * {Element} A WMC Layer element node.
      */
-    write_wmc_Layer: function(layer) {
+    write_wmc_Layer: function(context) {
         var node = OpenLayers.Format.WMC.v1.prototype.write_wmc_Layer.apply(
-            this, [layer]
+            this, [context]
         );
         
         // min/max scale denominator elements go before the 4th element in v1
-        if(layer.options.resolutions || layer.options.scales ||
+        if(context.maxScale) {
-           layer.options.minResolution || layer.options.maxScale) {
             var minSD = this.createElementNS(
                 this.namespaces.sld, "sld:MinScaleDenominator"
             );
-            minSD.appendChild(this.createTextNode(layer.maxScale.toPrecision(16)));
+            minSD.appendChild(this.createTextNode(context.maxScale.toPrecision(16)));
             node.appendChild(minSD);
         }
         
-        if(layer.options.resolutions || layer.options.scales ||
+        if(context.minScale) {
-           layer.options.maxResolution || layer.options.minScale) {
             var maxSD = this.createElementNS(
                 this.namespaces.sld, "sld:MaxScaleDenominator"
             );
-            maxSD.appendChild(this.createTextNode(layer.minScale.toPrecision(16)));
+            maxSD.appendChild(this.createTextNode(context.minScale.toPrecision(16)));
             node.appendChild(maxSD);
         }
 
         // optional FormatList element
-        node.appendChild(this.write_wmc_FormatList(layer));
+        node.appendChild(this.write_wmc_FormatList(context));
 
         // optional StyleList element
-        node.appendChild(this.write_wmc_StyleList(layer));
+        node.appendChild(this.write_wmc_StyleList(context));
         
         // OpenLayers specific properties go in an Extension element
-        node.appendChild(this.write_wmc_LayerExtension(layer));
+        node.appendChild(this.write_wmc_LayerExtension(context));
         
         return node;
         

tests/Format/WMC/v1.html

@@ -6,9 +6,10 @@
     function test_write_wmc_StyleList(t) {
         t.plan(3);
         
-        var layer, got, expected;
+        var layer, layerContext, got, expected;
         
-        var parser = new OpenLayers.Format.WMC.v1();
+        var format = new OpenLayers.Format.WMC();
+        var parser = format.getParser("1");
         var name = "test";
         var url = "http://foo";
 
@@ -16,7 +17,8 @@
         layer = new OpenLayers.Layer.WMS(name, url, {
             styles: "mystyle"
         });
-        got = parser.write_wmc_StyleList(layer);
+        layerContext = format.layerToContext(layer);
+        got = parser.write_wmc_StyleList(layerContext);
         expected = 
             "<StyleList xmlns='http://www.opengis.net/context'>" +
                 "<Style current='1'>" +
@@ -31,7 +33,8 @@
         layer = new OpenLayers.Layer.WMS(name, url, {
             sld: "http://linked.sld"
         });
-        got = parser.write_wmc_StyleList(layer);
+        layerContext = format.layerToContext(layer);
+        got = parser.write_wmc_StyleList(layerContext);
         expected = 
             "<StyleList xmlns='http://www.opengis.net/context'>" +
                 "<Style current='1'>" +
@@ -39,6 +42,7 @@
                         "<OnlineResource xmlns:xlink='http://www.w3.org/1999/xlink' "+
                                         "xlink:type='simple' " +
                                         "xlink:href='http://linked.sld' />" +
+                        "<Name></Name><Title>Default</Title>" +
                     "</SLD>" + 
                 "</Style>" +
             "</StyleList>";
@@ -78,7 +82,8 @@
                 "</sld:StyledLayerDescriptor>"
         });
         
-        got = parser.write_wmc_StyleList(layer);
+        layerContext = format.layerToContext(layer);
+        got = parser.write_wmc_StyleList(layerContext);
         expected =
             "<StyleList xmlns='http://www.opengis.net/context'>" +
                 "<Style current='1'>" +
@@ -110,6 +115,7 @@
                                 "</sld:UserStyle>" +
                             "</sld:NamedLayer>" +
                         "</sld:StyledLayerDescriptor>" +
+                        "<Name></Name><Title>Default</Title>" +
                     "</SLD>" +
                 "</Style>" + 
             "</StyleList>";
@@ -122,8 +128,9 @@
         t.plan(3);
         
         var xml = new OpenLayers.Format.XML();
-        var parser = new OpenLayers.Format.WMC.v1();
+        var format = new OpenLayers.Format.WMC();
-        var node, text, layerInfo;
+        var parser = format.getParser("1");
+        var node, text, layerContext, layer;
 
         // test named style
         text = 
@@ -133,12 +140,12 @@
                 "</Style>" +
             "</StyleList>";
         node = xml.read(text).documentElement;
-        layerInfo = {
+        layerContext = {
-            params: {},
             styles: []
         };
-        parser.read_wmc_StyleList(layerInfo, node);
+        parser.read_wmc_StyleList(layerContext, node);
-        t.eq(layerInfo.params.styles, "mystyle", "named style correctly read");
+        layer = format.getLayerFromContext(layerContext);
+        t.eq(layer.params.STYLES, "mystyle", "named style correctly read");
         
         // test linked style
         text = 
@@ -152,12 +159,12 @@
                 "</Style>" +
             "</StyleList>";
         node = xml.read(text).documentElement;
-        layerInfo = {
+        layerContext = {
-            params: {},
             styles: []
         };
-        parser.read_wmc_StyleList(layerInfo, node);
+        parser.read_wmc_StyleList(layerContext, node);
-        t.eq(layerInfo.params.sld, "http://linked.sld", "linked style correctly read");        
+        layer = format.getLayerFromContext(layerContext);
+        t.eq(layer.params.SLD, "http://linked.sld", "linked style correctly read");        
         
         // test inline style
         // any valid xml under the StyledLayerDescriptor node should make the
@@ -176,11 +183,11 @@
                 "</Style>" +
             "</StyleList>";
         node = xml.read(text).documentElement;
-        layerInfo = {
+        layerContext = {
-            params: {},
             styles: []
         };
-        parser.read_wmc_StyleList(layerInfo, node);        
+        parser.read_wmc_StyleList(layerContext, node);        
+        layer = format.getLayerFromContext(layerContext);
         var expected = 
             "<sld:StyledLayerDescriptor version='1.0.0' " +
                 "xmlns:sld='http://www.opengis.net/sld' " +
@@ -188,7 +195,7 @@
                 "xsi:schemaLocation='http://www.opengis.net/sld http://schemas.opengeospatial.net/sld/1.0.0/StyledLayerDescriptor.xsd'>" +
                 "<foo xmlns='http://www.opengis.net/context'>bar<more/></foo>" + 
             "</sld:StyledLayerDescriptor>";
-        t.xml_eq(layerInfo.params.sld_body, expected, "inline style correctly read");
+        t.xml_eq(layer.params.SLD_BODY, expected, "inline style correctly read");
 
     }
     

tests/Format/WMC/v1_1_0.html

@@ -12,8 +12,9 @@
         t.plan(12);
 
         // direct construction of a parser for a unit test
-        var wmc = new OpenLayers.Format.WMC.v1_1_0();
+        var format = new OpenLayers.Format.WMC();
-        var sldNS = wmc.namespaces["sld"];
+        var parser = format.getParser("1_1_0");
+        var sldNS = parser.namespaces["sld"];
 
         // test that Min/MaxScaleDenominator is not written out when no
         // resolution related options are set
@@ -21,10 +22,11 @@
             "test", "http://foo", {},
             {maxExtent: new OpenLayers.Bounds(1, 2, 3, 4)}
         );
-        var node = wmc.write_wmc_Layer(layer);
+        var layerContext = format.layerToContext(layer);
-        var minList = wmc.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
+        var node = parser.write_wmc_Layer(layerContext);
+        var minList = parser.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
         t.eq(minList.length, 0, "(none) node not written with MinScaleDenominator");
-        var maxList = wmc.getElementsByTagNameNS(node, sldNS, "MaxScaleDenominator");
+        var maxList = parser.getElementsByTagNameNS(node, sldNS, "MaxScaleDenominator");
         t.eq(maxList.length, 0, "(none) node not written with MaxScaleDenominator");
 
         // test that Min/MaxScaleDenominator is written out for explicit
@@ -35,15 +37,16 @@
         );
         layer.minScale = Math.random();
         layer.maxScale = Math.random();
-        sldNS = wmc.namespaces["sld"];
+        sldNS = parser.namespaces["sld"];
-        node = wmc.write_wmc_Layer(layer);
+        layerContext = format.layerToContext(layer);
-        minList = wmc.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
+        node = parser.write_wmc_Layer(layerContext);
+        minList = parser.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
         t.eq(minList.length, 1, "(resolutions) node written with MinScaleDenominator");
-        t.eq(layer.maxScale.toPrecision(16), wmc.getChildValue(minList[0]),
+        t.eq(layer.maxScale.toPrecision(16), parser.getChildValue(minList[0]),
              "(resolutions) node written with correct MinScaleDenominator value");
-        maxList = wmc.getElementsByTagNameNS(node, sldNS, "MaxScaleDenominator");
+        maxList = parser.getElementsByTagNameNS(node, sldNS, "MaxScaleDenominator");
         t.eq(maxList.length, 1, "(resolutions) node written with MaxScaleDenominator");
-        t.eq(layer.minScale.toPrecision(16), wmc.getChildValue(maxList[0]),
+        t.eq(layer.minScale.toPrecision(16), parser.getChildValue(maxList[0]),
              "(resolutions) node written with correct MaxScaleDenominator value");
 
         layer = new OpenLayers.Layer.WMS(
@@ -52,19 +55,21 @@
         );
         layer.minScale = Math.random();
         layer.maxScale = Math.random();
-        node = wmc.write_wmc_Layer(layer);
+        layerContext = format.layerToContext(layer);
-        minList = wmc.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
+        node = parser.write_wmc_Layer(layerContext);
+        minList = parser.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
         var f = new OpenLayers.Format.XML();
         t.eq(minList.length, 1, "(scales) node written with MinScaleDenominator");
-        t.eq(layer.maxScale.toPrecision(16), wmc.getChildValue(minList[0]),
+        t.eq(layer.maxScale.toPrecision(16), parser.getChildValue(minList[0]),
              "(scales) node written with correct MinScaleDenominator value");
-        maxList = wmc.getElementsByTagNameNS(node, sldNS, "MaxScaleDenominator");
+        maxList = parser.getElementsByTagNameNS(node, sldNS, "MaxScaleDenominator");
         t.eq(maxList.length, 1, "(scales) node written with MaxScaleDenominator");
-        t.eq(layer.minScale.toPrecision(16), wmc.getChildValue(maxList[0]),
+        t.eq(layer.minScale.toPrecision(16), parser.getChildValue(maxList[0]),
              "(scales) node written with correct MaxScaleDenominator value");
 
         layer.metadataURL = 'http://foo';
-        node = wmc.write_wmc_Layer(layer);
+        layerContext = format.layerToContext(layer);
+        node = parser.write_wmc_Layer(layerContext);
         t.eq(node.childNodes[3].localName || node.childNodes[3].nodeName.split(":").pop(),
             'MetadataURL', "MinScaleDenominator is written after MetadataURL, so third node should be MetadataURL");
         t.eq(node.childNodes[4].localName || node.childNodes[4].nodeName.split(":").pop(),