diff --git a/lib/OpenLayers/Format/WMC.js b/lib/OpenLayers/Format/WMC.js
index cac71e91f9..be0a46d12f 100644
--- a/lib/OpenLayers/Format/WMC.js
+++ b/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 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;
     },
 
diff --git a/lib/OpenLayers/Format/WMC/v1.js b/lib/OpenLayers/Format/WMC/v1.js
index 550a550c5c..d01ef6a387 100644
--- a/lib/OpenLayers/Format/WMC/v1.js
+++ b/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 = {
-            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);
     },
     
     /**
@@ -218,8 +188,8 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     /**
      * 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);
     },
     
     /**
@@ -236,100 +206,95 @@ OpenLayers.Format.WMC.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     /**
      * 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);
     },
 
     /**
      * 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));
     },
 
     /**
      * 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));
     },
 
     /**
      * 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");
     },
 
     /**
      * 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");
     },
 
     /**
      * 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");
     },
 
     /**
      * 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;
     },
 
     /**
      * Method: read_wmc_FormatList
      */
-    read_wmc_FormatList: function(layerInfo, node) {
-        this.runChildNodes(layerInfo, node);
+    read_wmc_FormatList: function(layerContext, node) {
+        this.runChildNodes(layerContext, node);
     },
 
     /**
      * 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);
     },
     
     /**
      * Method: read_wmc_StyleList
      */
-    read_wmc_StyleList: function(layerInfo, node) {
-        this.runChildNodes(layerInfo, node);
+    read_wmc_StyleList: function(layerContext, 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
-            // 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;
-            }
+            style.current = true;
         }
-        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) {
-        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"))
+        //];
+    //},
 
     /**
      * 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.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]));
         }
         
         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",
-                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));
         }
         
         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(
-            "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;
     },
 
     /**
      * 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):
-        // 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;
     },
 
diff --git a/lib/OpenLayers/Format/WMC/v1_0_0.js b/lib/OpenLayers/Format/WMC/v1_0_0.js
index d12f250092..5092fb6c42 100644
--- a/lib/OpenLayers/Format/WMC/v1_0_0.js
+++ b/lib/OpenLayers/Format/WMC/v1_0_0.js
@@ -46,29 +46,30 @@ 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" 
 
-});
\ No newline at end of file
+});
diff --git a/lib/OpenLayers/Format/WMC/v1_1_0.js b/lib/OpenLayers/Format/WMC/v1_1_0.js
index a7dc3b28cc..e842403f43 100644
--- a/lib/OpenLayers/Format/WMC/v1_1_0.js
+++ b/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) {
-        layerInfo.options.maxScale = this.getChildValue(node);
+    read_sld_MinScaleDenominator: function(layerContext, 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) {
-        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;
         
diff --git a/tests/Format/WMC/v1.html b/tests/Format/WMC/v1.html
index 5d3bdb8e0e..840cfc91bc 100644
--- a/tests/Format/WMC/v1.html
+++ b/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 node, text, layerInfo;
+        var format = new OpenLayers.Format.WMC();
+        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 = {
-            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
         text = 
@@ -152,12 +159,12 @@
                 "</Style>" +
             "</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
         // any valid xml under the StyledLayerDescriptor node should make the
@@ -176,11 +183,11 @@
                 "</Style>" +
             "</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' " +
                 "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");
 
     }
     
diff --git a/tests/Format/WMC/v1_1_0.html b/tests/Format/WMC/v1_1_0.html
index edc3eccf12..203e849a08 100644
--- a/tests/Format/WMC/v1_1_0.html
+++ b/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 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
         // 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 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");
 
         // 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"];
-        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");
 
         layer = new OpenLayers.Layer.WMS(
@@ -52,19 +55,21 @@
         );
         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");
         t.eq(node.childNodes[4].localName || node.childNodes[4].nodeName.split(":").pop(),