Changeset 9733

Timestamp:

10/08/09 17:24:54 (11 months ago)

Author:

tschaub

Message:

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)

Location:

trunk/openlayers

Files:

• lib/OpenLayers/Format/WMC.js (modified) (5 diffs)
• lib/OpenLayers/Format/WMC/v1.js (modified) (26 diffs)
• lib/OpenLayers/Format/WMC/v1_0_0.js (modified) (1 diff)
• lib/OpenLayers/Format/WMC/v1_1_0.js (modified) (2 diffs)
• tests/Format/WMC/v1.html (modified) (11 diffs)
• tests/Format/WMC/v1_1_0.html (modified) (4 diffs)

trunk/openlayers/lib/OpenLayers/Format/WMC.js

@@ -87 +87 @@
         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) {
@@ -116 +104 @@
         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;
+    },
     
     /**
@@ -134 +243 @@
             projection: context.projection
         });
-        map.addLayers(context.layers);
+        map.addLayers(this.getLayersFromContext(context.layersContext));
         map.setCenter(
             context.bounds.getCenterLonLat(),
@@ -154 +263 @@
      */
     mergeContextToMap: function(context, map) {
-        map.addLayers(context.layers);
+        map.addLayers(this.getLayersFromContext(context.layersContext));
         return map;
     },
@@ -170 +279 @@
      */
     write: function(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: layerToContext
+     * Create a layer context object given a wms layer object.
+     *
+     * Parameters:
+     * 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.
+     */
+    toContext: function(obj) {
+        var context = {};
+        var layers = obj.layers;
         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);
-        return wmc;
-    },
-    
-    /**
-     * Method: mapToContext
-     * Create a context object given a map.
-     *
-     * Parameters:
-     * map - {<OpenLayers.Map>} The map.
-     *
-     * 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()
-        };
+            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;
     },

trunk/openlayers/lib/OpenLayers/Format/WMC/v1.js

@@ -158 +158 @@
      */
     read_wmc_LayerList: function(context, node) {
-        context.layers = [];
+        // layersContext is an array containing info for each layer
+        context.layersContext = [];
         this.runChildNodes(context, node);
     },
@@ -166 +167 @@
      */
     read_wmc_Layer: function(context, node) {
-        var layerInfo = {
-            params: this.layerParams || {},
-            options: {
-                visibility: (node.getAttribute("hidden") != "1"),
-                queryable: (node.getAttribute("queryable") == "1")
-                
-            },
+        var layerContext = {
+            visibility: (node.getAttribute("hidden") != "1"),
+            queryable: (node.getAttribute("queryable") == "1"),
             formats: [],
             styles: []
         };
-        this.runChildNodes(layerInfo, node);
+
+        this.runChildNodes(layerContext, 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);
-    },
-    
-    /**
-     * Method: getLayerFromInfo
-     * Create a WMS layer from a layerInfo object.
-     *
-     * 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;
+        context.layersContext.push(layerContext);
     },
     
@@ -219 +189 @@
      * Method: read_ol_units
      */
-    read_ol_units: function(layerInfo, node) {
-        layerInfo.options.units = this.getChildValue(node);
+    read_ol_units: function(layerContext, node) {
+        layerContext.units = this.getChildValue(node);
     },
     
@@ -237 +207 @@
      * Method: read_ol_transparent
      */
-    read_ol_transparent: function(layerInfo, node) {
-        layerInfo.params.transparent = this.getChildValue(node);
+    read_ol_transparent: function(layerContext, node) {
+        layerContext.transparent = this.getChildValue(node);
     },
 
@@ -244 +214 @@
      * Method: read_ol_numZoomLevels
      */
-    read_ol_numZoomLevels: function(layerInfo, node) {
-        layerInfo.options.numZoomLevels = parseInt(this.getChildValue(node));
+    read_ol_numZoomLevels: function(layerContext, node) {
+        layerContext.numZoomLevels = parseInt(this.getChildValue(node));
     },
 
@@ -251 +221 @@
      * Method: read_ol_opacity
      */
-    read_ol_opacity: function(layerInfo, node) {
-        layerInfo.options.opacity = parseFloat(this.getChildValue(node));
+    read_ol_opacity: function(layerContext, node) {
+        layerContext.opacity = parseFloat(this.getChildValue(node));
     },
 
@@ -258 +228 @@
      * Method: read_ol_singleTile
      */
-    read_ol_singleTile: function(layerInfo, node) {
-        layerInfo.options.singleTile = (this.getChildValue(node) == "true");
+    read_ol_singleTile: function(layerContext, node) {
+        layerContext.singleTile = (this.getChildValue(node) == "true");
     },
 
@@ -265 +235 @@
      * Method: read_ol_isBaseLayer
      */
-    read_ol_isBaseLayer: function(layerInfo, node) {
-        layerInfo.options.isBaseLayer = (this.getChildValue(node) == "true");
+    read_ol_isBaseLayer: function(layerContext, node) {
+        layerContext.isBaseLayer = (this.getChildValue(node) == "true");
     },
 
@@ -272 +242 @@
      * Method: read_ol_displayInLayerSwitcher
      */
-    read_ol_displayInLayerSwitcher: function(layerInfo, node) {
-        layerInfo.options.displayInLayerSwitcher =
-            (this.getChildValue(node) == "true");
+    read_ol_displayInLayerSwitcher: function(layerContext, node) {
+        layerContext.displayInLayerSwitcher = (this.getChildValue(node) == "true");
     },
 
@@ -280 +249 @@
      * Method: read_wmc_Server
      */
-    read_wmc_Server: function(layerInfo, node) {
-        layerInfo.params.version = node.getAttribute("version");
-        this.runChildNodes(layerInfo, node);
+    read_wmc_Server: function(layerContext, node) {
+        layerContext.version = node.getAttribute("version");
+        var server = {};
+        var links = node.getElementsByTagName("OnlineResource");
+        if(links.length > 0) {
+            this.read_wmc_OnlineResource(server, links[0]);
+        }
+        layerContext.url = server.href;
     },
 
@@ -288 +262 @@
      * Method: read_wmc_FormatList
      */
-    read_wmc_FormatList: function(layerInfo, node) {
-        this.runChildNodes(layerInfo, node);
+    read_wmc_FormatList: function(layerContext, node) {
+        this.runChildNodes(layerContext, node);
     },
 
@@ -295 +269 @@
      * Method: read_wmc_Format
      */
-    read_wmc_Format: function(layerInfo, node) {
-        var format = this.getChildValue(node);
-        layerInfo.formats.push(format);
+    read_wmc_Format: function(layerContext, node) {
+        var format = {
+            value: this.getChildValue(node)
+        };
         if(node.getAttribute("current") == "1") {
-            layerInfo.params.format = format;
-        }
+            format.current = true;
+        }
+        layerContext.formats.push(format);
     },
     
@@ -306 +282 @@
      * Method: read_wmc_StyleList
      */
-    read_wmc_StyleList: function(layerInfo, node) {
-        this.runChildNodes(layerInfo, node);
+    read_wmc_StyleList: function(layerContext, node) {
+        this.runChildNodes(layerContext, node);
     },
 
@@ -313 +289 @@
      * 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
-            // 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);
+            style.current = true;
+        }
+        layerContext.styles.push(style);
     },
     
@@ -381 +346 @@
      * Method: read_wmc_MetadataURL
      */
-    read_wmc_MetadataURL: function(layerInfo, node) {
+    read_wmc_MetadataURL: function(layerContext, node) {
         var metadataURL = {};
         var links = node.getElementsByTagName("OnlineResource");
@@ -387 +352 @@
             this.read_wmc_OnlineResource(metadataURL, links[0]);
         }
-        layerInfo.options.metadataURL = metadataURL.href;
+        layerContext.metadataURL = metadataURL.href;
 
     },
@@ -401 +366 @@
     },
     
+    //FIXME: LatLonBoundingBox is not in spec
     /**
      * Method: read_wmc_LatLonBoundingBox
      */
-    read_wmc_LatLonBoundingBox: function(layer, node) {
-        layer.llbbox = [
-            parseFloat(node.getAttribute("minx")),
-            parseFloat(node.getAttribute("miny")),
-            parseFloat(node.getAttribute("maxx")),
-            parseFloat(node.getAttribute("maxy"))
-        ];
-    },
+    //read_wmc_LatLonBoundingBox: function(layer, node) {
+        //layer.llbbox = [
+            //parseFloat(node.getAttribute("minx")),
+            //parseFloat(node.getAttribute("miny")),
+            //parseFloat(node.getAttribute("maxx")),
+            //parseFloat(node.getAttribute("maxy"))
+        //];
+    //},
 
     /**
@@ -595 +561 @@
         var list = this.createElementDefaultNS("LayerList");
         
-        var layer;
-        for(var i=0, len=context.layers.length; i<len; ++i) {
-            layer = context.layers[i];
-            if(layer instanceof OpenLayers.Layer.WMS) {
-                list.appendChild(this.write_wmc_Layer(layer));
-            }
+        for(var i=0, len=context.layersContext.length; i<len; ++i) {
+            list.appendChild(this.write_wmc_Layer(context.layersContext[i]));
         }
         
@@ -608 +570 @@
     /**
      * Method: write_wmc_Layer
-     * Create a Layer node given a layer object.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * Create a Layer node given a layer context object.
+     *
+     * Parameters:
+     * 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",
-                hidden: layer.visibility ? "0" : "1"
+                queryable: context.queryable ? "1" : "0",
+                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) {
-            node.appendChild(this.write_wmc_MetadataURL(layer));
+        if (context.metadataURL) {
+            node.appendChild(this.write_wmc_MetadataURL(context.metadataURL));
         }
         
@@ -650 +612 @@
      *
      * 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"
@@ -670 +632 @@
         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);
@@ -717 +670 @@
     /**
      * Method: write_wmc_Server
-     * Create a Server node given a layer object.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * Create a Server node given a layer context object.
+     *
+     * Parameters:
+     * 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;
@@ -740 +693 @@
     /**
      * Method: write_wmc_MetadataURL
-     * Create a MetadataURL node given a layer object.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * Create a MetadataURL node given a metadataURL string.
+     *
+     * Parameters:
+     * 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;
@@ -759 +712 @@
     /**
      * Method: write_wmc_FormatList
-     * Create a FormatList node given a layer.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * Create a FormatList node given a layer context.
+     *
+     * Parameters:
+     * 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(
-            "Format", layer.params["FORMAT"], {current: "1"}
-        ));
+        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;
@@ -778 +737 @@
     /**
      * Method: write_wmc_StyleList
-     * Create a StyleList node given a layer.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer.WMS>} Layer object.
+     * Create a StyleList node given a layer context.
+     *
+     * Parameters:
+     * context - {Object} Layer context object.
      *
      * Returns:
@@ -788 +747 @@
     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):
-        // 1) an SLD parameter
-        // 2) and SLD_BODY parameter
-        // 3) the STYLES parameter
-        
-        if(layer.params["SLD"]) {
-            // create link from SLD parameter
-            var sld = this.createElementDefaultNS("SLD");
-            var link = this.write_wmc_OnlineResource(layer.params["SLD"]);
-            sld.appendChild(link);
-            style.appendChild(sld);
-        } else if(layer.params["SLD_BODY"]) {
-            // include sld fragment from SLD_BODY parameter
-            var sld = this.createElementDefaultNS("SLD");
-            var body = layer.params["SLD_BODY"];
-            // read in body as xml doc - assume proper namespace declarations
-            var doc = OpenLayers.Format.XML.prototype.read.apply(this, [body]);
-            // append to StyledLayerDescriptor node
-            var imported = doc.documentElement;
-            if(sld.ownerDocument && sld.ownerDocument.importNode) {
-                imported = sld.ownerDocument.importNode(imported, true);
+
+        var styles = layer.styles;
+        if (styles && styles instanceof Array) {
+            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");
+                    var link = this.write_wmc_OnlineResource(s.href);
+                    sld.appendChild(link);
+                    // 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;
     },

trunk/openlayers/lib/OpenLayers/Format/WMC/v1_0_0.js

@@ -47 +47 @@
     /**
      * 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));
     },    
 

trunk/openlayers/lib/OpenLayers/Format/WMC/v1_1_0.js

@@ -54 +54 @@
      *
      * 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) {
-        layerInfo.options.maxScale = this.getChildValue(node);
+    read_sld_MinScaleDenominator: function(layerContext, node) {
+        layerContext.maxScale = this.getChildValue(node);
     },
 
@@ -66 +66 @@
      *
      * 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) {
-        layerInfo.options.minScale = this.getChildValue(node);
+    read_sld_MaxScaleDenominator: function(layerContext, node) {
+        layerContext.minScale = this.getChildValue(node);
     },
 
     /**
      * Method: write_wmc_Layer
-     * Create a Layer node given a layer object.  This method adds elements
-     *     specific to version 1.1.0.
+     * Create a Layer node given a layer context object. This method adds
+     *     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 ||
-           layer.options.minResolution || layer.options.maxScale) {
+        if(context.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 ||
-           layer.options.maxResolution || layer.options.minScale) {
+        if(context.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;

trunk/openlayers/tests/Format/WMC/v1.html

@@ -7 +7 @@
         t.plan(3);
         
-        var layer, got, expected;
-        
-        var parser = new OpenLayers.Format.WMC.v1();
+        var layer, layerContext, got, expected;
+        
+        var format = new OpenLayers.Format.WMC();
+        var parser = format.getParser("1");
         var name = "test";
         var url = "http://foo";
@@ -17 +18 @@
             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'>" +
@@ -32 +34 @@
             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'>" +
@@ -40 +43 @@
                                         "xlink:type='simple' " +
                                         "xlink:href='http://linked.sld' />" +
+                        "<Name></Name><Title>Default</Title>" +
                     "</SLD>" + 
                 "</Style>" +
@@ -79 +83 @@
         });
         
-        got = parser.write_wmc_StyleList(layer);
+        layerContext = format.layerToContext(layer);
+        got = parser.write_wmc_StyleList(layerContext);
         expected =
             "<StyleList xmlns='http://www.opengis.net/context'>" +
@@ -111 +116 @@
                             "</sld:NamedLayer>" +
                         "</sld:StyledLayerDescriptor>" +
+                        "<Name></Name><Title>Default</Title>" +
                     "</SLD>" +
                 "</Style>" + 
@@ -123 +129 @@
         
         var xml = new OpenLayers.Format.XML();
-        var parser = new OpenLayers.Format.WMC.v1();
-        var node, text, layerInfo;
+        var format = new OpenLayers.Format.WMC();
+        var parser = format.getParser("1");
+        var node, text, layerContext, layer;
 
         // test named style
@@ -134 +141 @@
             "</StyleList>";
         node = xml.read(text).documentElement;
-        layerInfo = {
-            params: {},
+        layerContext = {
             styles: []
         };
-        parser.read_wmc_StyleList(layerInfo, node);
-        t.eq(layerInfo.params.styles, "mystyle", "named style correctly read");
+        parser.read_wmc_StyleList(layerContext, node);
+        layer = format.getLayerFromContext(layerContext);
+        t.eq(layer.params.STYLES, "mystyle", "named style correctly read");
         
         // test linked style
@@ -153 +160 @@
             "</StyleList>";
         node = xml.read(text).documentElement;
-        layerInfo = {
-            params: {},
+        layerContext = {
             styles: []
         };
-        parser.read_wmc_StyleList(layerInfo, node);
-        t.eq(layerInfo.params.sld, "http://linked.sld", "linked style correctly read");        
+        parser.read_wmc_StyleList(layerContext, node);
+        layer = format.getLayerFromContext(layerContext);
+        t.eq(layer.params.SLD, "http://linked.sld", "linked style correctly read");        
         
         // test inline style
@@ -177 +184 @@
             "</StyleList>";
         node = xml.read(text).documentElement;
-        layerInfo = {
-            params: {},
+        layerContext = {
             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' " +
@@ -189 +196 @@
                 "<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");
 
     }

trunk/openlayers/tests/Format/WMC/v1_1_0.html

@@ -13 +13 @@
 
         // direct construction of a parser for a unit test
-        var wmc = new OpenLayers.Format.WMC.v1_1_0();
-        var sldNS = wmc.namespaces["sld"];
+        var format = new OpenLayers.Format.WMC();
+        var parser = format.getParser("1_1_0");
+        var sldNS = parser.namespaces["sld"];
 
         // test that Min/MaxScaleDenominator is not written out when no
@@ -22 +23 @@
             {maxExtent: new OpenLayers.Bounds(1, 2, 3, 4)}
         );
-        var node = wmc.write_wmc_Layer(layer);
-        var minList = wmc.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
+        var layerContext = format.layerToContext(layer);
+        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");
 
@@ -36 +38 @@
         layer.minScale = Math.random();
         layer.maxScale = Math.random();
-        sldNS = wmc.namespaces["sld"];
-        node = wmc.write_wmc_Layer(layer);
-        minList = wmc.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
+        sldNS = parser.namespaces["sld"];
+        layerContext = format.layerToContext(layer);
+        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");
 
@@ -53 +56 @@
         layer.minScale = Math.random();
         layer.maxScale = Math.random();
-        node = wmc.write_wmc_Layer(layer);
-        minList = wmc.getElementsByTagNameNS(node, sldNS, "MinScaleDenominator");
+        layerContext = format.layerToContext(layer);
+        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");