Changeset 10560

Timestamp:

08/02/10 12:49:52 (3 years ago)

Author:

tschaub

Message:

Adding point, line, polygon, text, and raster symbolizer constructors. This paves the way for rendering multiple symbolizers per rule. The SLD parser now successfully round-trips documents with multiple symbolizers and multiple FeatureTypeStyle elements (through the symbolizer zIndex property). The Style2 (yes, ack) constructor is used to represent a collection of rules with multiple symbolizers. Style2 objects are currently only used by the SLD parser if the multipleSymbolizer property is set to true. Future enhancements to the renderers can be made to account for multiple symbolizers. r=ahocevar (closes #2760).

Location:

trunk/openlayers

Files:

• examples/sld-parser.html (added)
• lib/OpenLayers.js (modified) (2 diffs)
• lib/OpenLayers/Format/SLD/v1.js (modified) (9 diffs)
• lib/OpenLayers/Rule.js (modified) (6 diffs)
• lib/OpenLayers/Style2.js (added)
• lib/OpenLayers/Symbolizer (added)
• lib/OpenLayers/Symbolizer.js (added)
• lib/OpenLayers/Symbolizer/Line.js (added)
• lib/OpenLayers/Symbolizer/Point.js (added)
• lib/OpenLayers/Symbolizer/Polygon.js (added)
• lib/OpenLayers/Symbolizer/Raster.js (added)
• lib/OpenLayers/Symbolizer/Text.js (added)
• tests/Format/SLD/v1_0_0.html (modified) (2 diffs)
• tests/Rule.html (modified) (2 diffs)
• tests/Style2.html (added)
• tests/Symbolizer (added)
• tests/Symbolizer.html (added)
• tests/Symbolizer/Line.html (added)
• tests/Symbolizer/Point.html (added)
• tests/Symbolizer/Polygon.html (added)
• tests/Symbolizer/Raster.html (added)
• tests/Symbolizer/Text.html (added)
• tests/list-tests.html (modified) (1 diff)

trunk/openlayers/lib/OpenLayers.js

@@ -228 +228 @@
             "OpenLayers/Layer/GML.js",
             "OpenLayers/Style.js",
+            "OpenLayers/Style2.js",
             "OpenLayers/StyleMap.js",
             "OpenLayers/Rule.js",
@@ -304 +305 @@
             "OpenLayers/Control/ZoomPanel.js",
             "OpenLayers/Control/EditingToolbar.js",
+            "OpenLayers/Symbolizer.js",
+            "OpenLayers/Symbolizer/Point.js",
+            "OpenLayers/Symbolizer/Line.js",
+            "OpenLayers/Symbolizer/Polygon.js",
+            "OpenLayers/Symbolizer/Text.js",
+            "OpenLayers/Symbolizer/Raster.js",
             "OpenLayers/Lang.js",
             "OpenLayers/Lang/en.js"

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

@@ -40 +40 @@
      */
     schemaLocation: null,
+    
+    /** 
+     * APIProperty: multipleSymbolizers
+     * {Boolean} Support multiple symbolizers per rule.  Default is false.  if
+     *     true, an OpenLayers.Style2 instance will be created to represent 
+     *     user styles instead of an OpenLayers.Style instace.  The 
+     *     OpenLayers.Style2 class allows collections of rules with multiple
+     *     symbolizers, but is not currently useful for client side rendering.
+     *     If multiple symbolizers is true, multiple FeatureTypeStyle elements
+     *     are preserved in reading/writing by setting symbolizer zIndex values.
+     *     In addition, the <defaultSymbolizer> property is ignored if 
+     *     multiple symbolizers are supported (defaults should be applied
+     *     when rendering).
+     */
+    multipleSymbolizers: false,
+
+    /**
+     * Property: featureTypeCounter
+     * {Number} Private counter for multiple feature type styles.
+     */
+    featureTypeCounter: null,
 
     /**
@@ -139 +160 @@
             "UserStyle": function(node, layer) {
                 var obj = {defaultsPerSymbolizer: true, rules: []};
+                this.featureTypeCounter = -1;
                 this.readChildNodes(node, obj);
-                var style = new OpenLayers.Style(this.defaultSymbolizer, obj);
+                var style;
+                if (this.multipleSymbolizers) {
+                    delete obj.defaultsPerSymbolizer;
+                    style = new OpenLayers.Style2(obj);
+                } else {
+                    style = new OpenLayers.Style(this.defaultSymbolizer, obj);
+                }
                 layer.userStyles.push(style);
             },
@@ -149 +177 @@
             },
             "FeatureTypeStyle": function(node, style) {
-                // OpenLayers doesn't have a place for FeatureTypeStyle
-                // Name, Title, Abstract, FeatureTypeName, or
-                // SemanticTypeIdentifier so, we make a temporary object
-                // and later just use the Rule(s).
+                ++this.featureTypeCounter;
                 var obj = {
-                    rules: []
+                    rules: this.multipleSymbolizers ? style.rules : []
                 };
                 this.readChildNodes(node, obj);
-                style.rules = obj.rules;
+                if (!this.multipleSymbolizers) {
+                    style.rules = obj.rules;
+                }
             },
             "Rule": function(node, obj) {
-                var rule = new OpenLayers.Rule();
+                var config;
+                if (this.multipleSymbolizers) {
+                    config = {symbolizers: []};
+                }
+                var rule = new OpenLayers.Rule(config);
                 this.readChildNodes(node, rule);
                 obj.rules.push(rule);
@@ -174 +205 @@
             },
             "TextSymbolizer": function(node, rule) {
-                // OpenLayers doens't do painter's order, instead we extend
-                var symbolizer = rule.symbolizer["Text"] || {};
-                this.readChildNodes(node, symbolizer);
-                // in case it didn't exist before
-                rule.symbolizer["Text"] = symbolizer;
+                var config = {};
+                this.readChildNodes(node, config);
+                if (this.multipleSymbolizers) {
+                    config.zIndex = this.featureTypeCounter;
+                    rule.symbolizers.push(
+                        new OpenLayers.Symbolizer.Text(config)
+                    );
+                } else {
+                    rule.symbolizer["Text"] = OpenLayers.Util.applyDefaults(
+                        config, rule.symbolizer["Text"]
+                    );
+                }
             },
             "Label": function(node, symbolizer) {
@@ -212 +250 @@
             },
             "RasterSymbolizer": function(node, rule) {
-                // OpenLayers doesn't do painter's order, instead we extend
-                var symbolizer = rule.symbolizer["Raster"] || {};
-                this.readChildNodes(node, symbolizer);
-                // in case it didn't exist before
-                rule.symbolizer["Raster"] = symbolizer;
+                var config = {};
+                this.readChildNodes(node, config);
+                if (this.multipleSymbolizers) {
+                    config.zIndex = this.featureTypeCounter;
+                    rule.symbolizers.push(
+                        new OpenLayers.Symbolizer.Raster(config)
+                    );
+                } else {
+                    rule.symbolizer["Raster"] = OpenLayers.Util.applyDefaults(
+                        config, rule.symbolizer["Raster"]
+                    );
+                }
             },
             "Geometry": function(node, obj) {
@@ -237 +282 @@
             },
             "LineSymbolizer": function(node, rule) {
-                // OpenLayers doesn't do painter's order, instead we extend
-                var symbolizer = rule.symbolizer["Line"] || {};
-                this.readChildNodes(node, symbolizer);
-                // in case it didn't exist before
-                rule.symbolizer["Line"] = symbolizer;
+                var config = {};
+                this.readChildNodes(node, config);
+                if (this.multipleSymbolizers) {
+                    config.zIndex = this.featureTypeCounter;
+                    rule.symbolizers.push(
+                        new OpenLayers.Symbolizer.Line(config)
+                    );
+                } else {
+                    rule.symbolizer["Line"] = OpenLayers.Util.applyDefaults(
+                        config, rule.symbolizer["Line"]
+                    );
+                }
             },
             "PolygonSymbolizer": function(node, rule) {
-                // OpenLayers doens't do painter's order, instead we extend
-                var symbolizer = rule.symbolizer["Polygon"] || {
+                var config = {
                     fill: false,
                     stroke: false
                 };
-                this.readChildNodes(node, symbolizer);
-                // in case it didn't exist before
-                rule.symbolizer["Polygon"] = symbolizer;
+                if (!this.multipleSymbolizers) {
+                    config = rule.symbolizer["Polygon"] || config;
+                }
+                this.readChildNodes(node, config);
+                if (this.multipleSymbolizers) {
+                    config.zIndex = this.featureTypeCounter;
+                    rule.symbolizers.push(
+                        new OpenLayers.Symbolizer.Polygon(config)
+                    );
+                } else {
+                    rule.symbolizer["Polygon"] = config;
+                }
             },
             "PointSymbolizer": function(node, rule) {
-                // OpenLayers doens't do painter's order, instead we extend
-                var symbolizer = rule.symbolizer["Point"] || {
+                var config = {
                     fill: false,
                     stroke: false,
                     graphic: false
                 };
-                this.readChildNodes(node, symbolizer);
-                // in case it didn't exist before
-                rule.symbolizer["Point"] = symbolizer;
+                if (!this.multipleSymbolizers) {
+                    config = rule.symbolizer["Point"] || config;
+                }
+                this.readChildNodes(node, config);
+                if (this.multipleSymbolizers) {
+                    config.zIndex = this.featureTypeCounter;
+                    rule.symbolizers.push(
+                        new OpenLayers.Symbolizer.Point(config)
+                    );
+                } else {
+                    rule.symbolizer["Point"] = config;
+                }
             },
             "Stroke": function(node, symbolizer) {
@@ -567 +635 @@
                 
                 // add FeatureTypeStyles
-                this.writeNode("FeatureTypeStyle", style, node);
+                if (this.multipleSymbolizers && style.rules) {
+                    // group style objects by symbolizer zIndex
+                    var rulesByZ = {
+                        0: []
+                    };
+                    var zValues = [0];
+                    var rule, ruleMap, symbolizer, zIndex, clone;
+                    for (var i=0, ii=style.rules.length; i<ii; ++i) {
+                        rule = style.rules[i];
+                        if (rule.symbolizers) {
+                            ruleMap = {};
+                            for (var j=0, jj=rule.symbolizers.length; j<jj; ++j) {
+                                symbolizer = rule.symbolizers[j];
+                                zIndex = symbolizer.zIndex;
+                                if (!(zIndex in ruleMap)) {
+                                    clone = rule.clone();
+                                    clone.symbolizers = [];
+                                    ruleMap[zIndex] = clone;
+                                }
+                                ruleMap[zIndex].symbolizers.push(symbolizer.clone());
+                            }
+                            for (zIndex in ruleMap) {
+                                if (!(zIndex in rulesByZ)) {
+                                    zValues.push(zIndex);
+                                    rulesByZ[zIndex] = [];
+                                }
+                                rulesByZ[zIndex].push(ruleMap[zIndex]);
+                            }
+                        } else {
+                            // no symbolizers in rule
+                            rulesByZ[0].push(rule.clone());
+                        }
+                    }
+                    // write one FeatureTypeStyle per zIndex
+                    zValues.sort();
+                    var rules;
+                    for (var i=0, ii=zValues.length; i<ii; ++i) {
+                        rules = rulesByZ[zValues[i]];
+                        if (rules.length > 0) {
+                            clone = style.clone();
+                            clone.rules = rulesByZ[zValues[i]];
+                            this.writeNode("FeatureTypeStyle", clone, node);
+                        }
+                    }                    
+                } else {
+                    this.writeNode("FeatureTypeStyle", style, node);
+                }
                 
                 return node;
@@ -627 +741 @@
                 }
                 
-                // add in symbolizers (relies on geometry type keys)
-                var types = OpenLayers.Style.SYMBOLIZER_PREFIXES;
                 var type, symbolizer;
-                for(var i=0, len=types.length; i<len; ++i) {
-                    type = types[i];
-                    symbolizer = rule.symbolizer[type];
-                    if(symbolizer) {
+                if (this.multipleSymbolizers && rule.symbolizers) {
+                    var symbolizer;
+                    for (var i=0, ii=rule.symbolizers.length; i<ii; ++i) {
+                        symbolizer = rule.symbolizers[i];
+                        type = symbolizer.CLASS_NAME.split(".").pop();
                         this.writeNode(
                             type + "Symbolizer", symbolizer, node
                         );
+                    }
+                } else {
+                    // add in symbolizers (relies on geometry type keys)
+                    var types = OpenLayers.Style.SYMBOLIZER_PREFIXES;
+                    for(var i=0, len=types.length; i<len; ++i) {
+                        type = types[i];
+                        symbolizer = rule.symbolizer[type];
+                        if(symbolizer) {
+                            this.writeNode(
+                                type + "Symbolizer", symbolizer, node
+                            );
+                        }
                     }
                 }
@@ -926 +1051 @@
                     this.writeNode("WellKnownName", symbolizer.graphicName, node);
                 }
-                this.writeNode("Fill", symbolizer, node);
-                this.writeNode("Stroke", symbolizer, node);
+                if (symbolizer.fill !== false) {
+                    this.writeNode("Fill", symbolizer, node);
+                }
+                if (symbolizer.stroke !== false) {
+                    this.writeNode("Stroke", symbolizer, node);
+                }
                 return node;
             },

trunk/openlayers/lib/OpenLayers/Rule.js

@@ -7 +7 @@
  * @requires OpenLayers/Util.js
  * @requires OpenLayers/Style.js
+ * @requires OpenLayers/Symbolizer/Point.js
+ * @requires OpenLayers/Symbolizer/Line.js
+ * @requires OpenLayers/Symbolizer/Polygon.js
+ * @requires OpenLayers/Symbolizer/Text.js
+ * @requires OpenLayers/Symbolizer/Raster.js
  */
 
@@ -25 +30 @@
      * {String} name of this rule
      */
-    name: 'default',
+    name: null,
     
     /**
@@ -75 +80 @@
     
     /**
+     * Property: symbolizers
+     * {Array} Collection of symbolizers associated with this rule.  If 
+     *     provided at construction, the symbolizers array has precedence
+     *     over the deprecated symbolizer property.  Note that multiple 
+     *     symbolizers are not currently supported by the vector renderers.
+     *     Rules with multiple symbolizers are currently only useful for
+     *     maintaining elements in an SLD document.
+     */
+    symbolizers: null,
+    
+    /**
      * APIProperty: minScaleDenominator
      * {Number} or {String} minimum scale at which to draw the feature.
@@ -104 +120 @@
         this.symbolizer = {};
         OpenLayers.Util.extend(this, options);
+        if (this.symbolizers) {
+            delete this.symbolizer;
+        }
         this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
     },
@@ -116 +135 @@
         }
         this.symbolizer = null;
+        delete this.symbolizers;
     },
     
@@ -188 +208 @@
     clone: function() {
         var options = OpenLayers.Util.extend({}, this);
-        // clone symbolizer
-        options.symbolizer = {};
-        var value, type;
-        for(var key in this.symbolizer) {
-            value = this.symbolizer[key];
-            type = typeof value;
-            if(type === "object") {
-                options.symbolizer[key] = OpenLayers.Util.extend({}, value);
-            } else if(type === "string") {
-                options.symbolizer[key] = value;
+        if (this.symbolizers) {
+            // clone symbolizers
+            var len = this.symbolizers.length;
+            options.symbolizers = new Array(len);
+            for (var i=0; i<len; ++i) {
+                options.symbolizers[i] = this.symbolizers[i].clone();
+            }
+        } else {
+            // clone symbolizer
+            options.symbolizer = {};
+            var value, type;
+            for(var key in this.symbolizer) {
+                value = this.symbolizer[key];
+                type = typeof value;
+                if(type === "object") {
+                    options.symbolizer[key] = OpenLayers.Util.extend({}, value);
+                } else if(type === "string") {
+                    options.symbolizer[key] = value;
+                }
             }
         }

trunk/openlayers/tests/Format/SLD/v1_0_0.html

@@ -3 +3 @@
     <script src="../../../lib/OpenLayers.js"></script>
     <script type="text/javascript">
+
+    var xml = new OpenLayers.Format.XML(); 
+    function readXML(id) {
+        return xml.read(document.getElementById(id).firstChild.nodeValue);
+    }
     
     var sld =
@@ -440 +445 @@
         t.xml_eq(got, expected, "Successfully round tripped RasterSymbolizer");
     }
+    
+    function test_zIndex(t) {
+        t.plan(1);
+        
+        var format = new OpenLayers.Format.SLD.v1_0_0({
+            multipleSymbolizers: true
+        });
+        
+        // three zIndex values -> three FeatureTypeStyle elements
+        var style = new OpenLayers.Style2({
+            rules: [
+                new OpenLayers.Rule({
+                    filter: new OpenLayers.Filter.Comparison({
+                        type: OpenLayers.Filter.Comparison.EQUAL_TO,
+                        property: "foo",
+                        value: "bar"
+                    }),
+                    minScaleDenominator: 100000,
+                    maxScaleDenominator: 200000,
+                    symbolizers: [
+                        new OpenLayers.Symbolizer.Line({
+                            strokeColor: "green",
+                            strokeWidth: 2,
+                            zIndex: 2
+                        }),
+                        new OpenLayers.Symbolizer.Line({
+                            strokeColor: "red",
+                            strokeWidth: 3,
+                            zIndex: -1
+                        }),
+                        new OpenLayers.Symbolizer.Line({
+                            strokeColor: "blue",
+                            strokeWidth: 1,
+                            zIndex: 5
+                        })
+                    ]
+                }),
+                new OpenLayers.Rule({
+                    filter: new OpenLayers.Filter.Comparison({
+                        type: OpenLayers.Filter.Comparison.EQUAL_TO,
+                        property: "foo",
+                        value: "baz"
+                    }),                    
+                    symbolizers: [
+                        new OpenLayers.Symbolizer.Line({
+                            strokeColor: "#000000",
+                            strokeWidth: 2,
+                            zIndex: 2
+                        })
+                    ]
+                })
+            ]
+        });
+        
+        var got = format.writeNode("sld:UserStyle", style);
+        var exp = readXML("zindex_test.sld").documentElement;
+        t.xml_eq(got, exp, "duplicated rules to write zIndex as FeatureTypeStyle elements");
+        
+    }
+    
+    function test_read_FeatureTypeStyles(t) {
+        
+        t.plan(13);
+        
+        var format = new OpenLayers.Format.SLD.v1_0_0({
+            multipleSymbolizers: true,
+            namedLayersAsArray: true
+        });
+        var doc = readXML("line_linewithborder.sld");
+        
+        var obj = format.read(doc);
+
+        t.eq(obj.namedLayers.length, 1, "got one named layer");
+        var namedLayer = obj.namedLayers[0];
+        
+        t.eq(namedLayer.userStyles.length, 1, "got one user style");
+        var userStyle = namedLayer.userStyles[0];
+        t.ok(userStyle instanceof OpenLayers.Style2, "user style represented with OpenLayers.Style2");
+        
+        // check rules and symbolizers
+        var rule, symbolizer;
+        
+        t.eq(userStyle.rules.length, 2, "pulled two rules (from two FeatureTypeStyle elements)");
+        rule = userStyle.rules[0];
+        t.ok(rule instanceof OpenLayers.Rule, "first rule is an OpenLayers.Rule");
+        
+        t.eq(rule.symbolizers && rule.symbolizers.length, 1, "first rule has one symbolizer");
+        symbolizer = rule.symbolizers[0];
+        t.ok(symbolizer instanceof OpenLayers.Symbolizer, "first symbolizer in first rule is an OpenLayers.Symbolizer");
+        t.ok(symbolizer instanceof OpenLayers.Symbolizer.Line, "first symbolizer in first rule is an OpenLayers.Symbolizer.Line");
+        t.eq(symbolizer.zIndex, 0, "symbolizer from first FeatureTypeStyle element has zIndex 0");
+        
+        rule = userStyle.rules[1];
+        t.eq(rule.symbolizers && rule.symbolizers.length, 1, "second rule has one symbolizer");
+        symbolizer = rule.symbolizers[0];
+        t.ok(symbolizer instanceof OpenLayers.Symbolizer, "first symbolizer in second rule is an OpenLayers.Symbolizer");
+        t.ok(symbolizer instanceof OpenLayers.Symbolizer.Line, "first symbolizer in second rule is an OpenLayers.Symbolizer.Line");
+        t.eq(symbolizer.zIndex, 1, "symbolizer from second FeatureTypeStyle element has zIndex 1");
+        
+    }
+
+    function test_roundtrip(t) {
+        
+        t.plan(5);
+        
+        var format = new OpenLayers.Format.SLD.v1_0_0({
+            multipleSymbolizers: true,
+            namedLayersAsArray: true
+        });
+        var doc, out;
+        
+        // two FeatureTypeStyle elements and line symbolizers
+        doc = readXML("line_linewithborder.sld");
+        out = format.write(format.read(doc));
+        t.xml_eq(out, doc.documentElement, "round-tripped line_linewithborder.sld");
+
+        // three FeatureTypeStyle elements and line symbolizers
+        doc = readXML("line_attributebasedline.sld");
+        out = format.write(format.read(doc));
+        t.xml_eq(out, doc.documentElement, "round-tripped line_attributebasedline.sld");
+        
+        // point symbolizer and text symbolizer
+        doc = readXML("point_pointwithdefaultlabel.sld");
+        out = format.write(format.read(doc));
+        t.xml_eq(out, doc.documentElement, "round-tripped point_pointwithdefaultlabel.sld");
+        
+        // polygon symbolizer with fill only 
+        doc = readXML("polygon_simplepolygon.sld");
+        out = format.write(format.read(doc));
+        t.xml_eq(out, doc.documentElement, "round-tripped polygon_simplepolygon.sld");
+
+        // polygon symbolizer and text symbolizer with halo
+        doc = readXML("polygon_labelhalo.sld");
+        out = format.write(format.read(doc));
+        t.xml_eq(out, doc.documentElement, "round-tripped polygon_labelhalo.sld");
+
+    }
 
     </script> 
 </head> 
 <body>
+<div id="line_linewithborder.sld"><!--
+<StyledLayerDescriptor version="1.0.0" 
+    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd" 
+    xmlns="http://www.opengis.net/sld" 
+    xmlns:ogc="http://www.opengis.net/ogc" 
+    xmlns:xlink="http://www.w3.org/1999/xlink" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <NamedLayer>
+    <Name>Line with border</Name>
+    <UserStyle>
+    <Title>SLD Cook Book: Line w2th border</Title>
+      <FeatureTypeStyle>
+         <Rule>
+          <LineSymbolizer>
+            <Stroke>
+              <CssParameter name="stroke">#333333</CssParameter>                           
+              <CssParameter name="stroke-width">5</CssParameter>    
+              <CssParameter name="stroke-linecap">round</CssParameter>    
+            </Stroke> 
+          </LineSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+      <FeatureTypeStyle>
+         <Rule>
+          <LineSymbolizer>
+          <Stroke>
+              <CssParameter name="stroke">#6699FF</CssParameter>                           
+              <CssParameter name="stroke-width">3</CssParameter> 
+              <CssParameter name="stroke-linecap">round</CssParameter>  
+            </Stroke>
+          </LineSymbolizer>                                          
+         </Rule>
+      </FeatureTypeStyle>
+    </UserStyle>
+  </NamedLayer>
+</StyledLayerDescriptor>
+--></div>
+<div id="line_attributebasedline.sld"><!--
+<StyledLayerDescriptor version="1.0.0" 
+    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd" 
+    xmlns="http://www.opengis.net/sld" 
+    xmlns:ogc="http://www.opengis.net/ogc" 
+    xmlns:xlink="http://www.w3.org/1999/xlink" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <NamedLayer>
+    <Name>Attribute-based line</Name>
+    <UserStyle>
+      <Title>SLD Cook Book: Attribute-based line</Title>
+      <FeatureTypeStyle>
+        <Rule>
+          <Name>local-road</Name>
+          <ogc:Filter>
+            <ogc:PropertyIsEqualTo>
+              <ogc:PropertyName>type</ogc:PropertyName>
+              <ogc:Literal>local-road</ogc:Literal>
+            </ogc:PropertyIsEqualTo>
+          </ogc:Filter>
+          <LineSymbolizer>
+            <Stroke>
+              <CssParameter name="stroke">#009933</CssParameter>
+              <CssParameter name="stroke-width">2</CssParameter>
+            </Stroke>
+          </LineSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+      <FeatureTypeStyle>
+        <Rule>
+          <Name>secondary</Name>
+          <ogc:Filter>
+            <ogc:PropertyIsEqualTo>
+              <ogc:PropertyName>type</ogc:PropertyName>
+              <ogc:Literal>secondary</ogc:Literal>
+            </ogc:PropertyIsEqualTo>
+          </ogc:Filter>
+          <LineSymbolizer>
+            <Stroke>
+              <CssParameter name="stroke">#0055CC</CssParameter>
+              <CssParameter name="stroke-width">3</CssParameter>
+            </Stroke>
+          </LineSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+      <FeatureTypeStyle>
+        <Rule>
+        <Name>highway</Name>
+          <ogc:Filter>
+            <ogc:PropertyIsEqualTo>
+              <ogc:PropertyName>type</ogc:PropertyName>
+              <ogc:Literal>highway</ogc:Literal>
+            </ogc:PropertyIsEqualTo>
+          </ogc:Filter>
+          <LineSymbolizer>
+            <Stroke>
+              <CssParameter name="stroke">#FF0000</CssParameter>
+              <CssParameter name="stroke-width">6</CssParameter>
+            </Stroke>
+          </LineSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+    </UserStyle>
+  </NamedLayer>
+</StyledLayerDescriptor> 
+--></div>
+<div id="point_pointwithdefaultlabel.sld"><!--
+<StyledLayerDescriptor version="1.0.0" 
+    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd" 
+    xmlns="http://www.opengis.net/sld" 
+    xmlns:ogc="http://www.opengis.net/ogc" 
+    xmlns:xlink="http://www.w3.org/1999/xlink" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <NamedLayer>
+    <Name>Point with default label</Name>
+    <UserStyle>
+      <Title>GeoServer SLD Cook Book: Point with default label</Title>
+      <FeatureTypeStyle>
+        <Rule>
+          <PointSymbolizer>
+            <Graphic>
+              <Mark>
+                <WellKnownName>circle</WellKnownName>
+                <Fill>
+                  <CssParameter name="fill">#FF0000</CssParameter>
+                </Fill>
+              </Mark>
+              <Size>6</Size>
+            </Graphic>
+          </PointSymbolizer>
+          <TextSymbolizer>
+            <Label>
+              <ogc:PropertyName>name</ogc:PropertyName>
+            </Label>
+            <Fill>
+              <CssParameter name="fill">#000000</CssParameter>
+            </Fill>
+          </TextSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+    </UserStyle>
+  </NamedLayer>
+</StyledLayerDescriptor>
+--></div>
+<div id="polygon_simplepolygon.sld"><!--
+<StyledLayerDescriptor version="1.0.0" 
+    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd" 
+    xmlns="http://www.opengis.net/sld" 
+    xmlns:ogc="http://www.opengis.net/ogc" 
+    xmlns:xlink="http://www.w3.org/1999/xlink" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <NamedLayer>
+    <Name>Simple polygon</Name>
+    <UserStyle>
+      <Title>SLD Cook Book: Simple polygon</Title>
+      <FeatureTypeStyle>
+        <Rule>
+          <PolygonSymbolizer>
+            <Fill>
+              <CssParameter name="fill">#000080</CssParameter>
+            </Fill>
+          </PolygonSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+    </UserStyle>
+  </NamedLayer>
+</StyledLayerDescriptor>
+--></div>
+<div id="polygon_labelhalo.sld"><!--
+<StyledLayerDescriptor version="1.0.0" 
+    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd" 
+    xmlns="http://www.opengis.net/sld" 
+    xmlns:ogc="http://www.opengis.net/ogc" 
+    xmlns:xlink="http://www.w3.org/1999/xlink" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <NamedLayer>
+    <Name>Label halo</Name>
+    <UserStyle>
+      <Title>SLD Cook Book: Label halo</Title>
+      <FeatureTypeStyle>
+        <Rule>
+          <PolygonSymbolizer>
+            <Fill>
+              <CssParameter name="fill">#40FF40</CssParameter>
+            </Fill>
+            <Stroke>
+              <CssParameter name="stroke">#FFFFFF</CssParameter>
+              <CssParameter name="stroke-width">2</CssParameter>
+            </Stroke>
+          </PolygonSymbolizer>        
+          <TextSymbolizer>
+            <Label>
+              <ogc:PropertyName>name</ogc:PropertyName>
+            </Label>
+            <Halo>
+              <Radius>3</Radius>
+              <Fill>
+                <CssParameter name="fill">#FFFFFF</CssParameter>
+              </Fill>
+            </Halo>
+          </TextSymbolizer>
+        </Rule>
+      </FeatureTypeStyle>
+    </UserStyle>
+  </NamedLayer>
+</StyledLayerDescriptor>
+--></div>
+<div id="zindex_test.sld"><!--
+<sld:UserStyle xmlns:sld="http://www.opengis.net/sld">
+    <sld:FeatureTypeStyle>
+        <sld:Rule>
+            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">
+                <ogc:PropertyIsEqualTo>
+                    <ogc:PropertyName>foo</ogc:PropertyName>
+                    <ogc:Literal>bar</ogc:Literal>
+                </ogc:PropertyIsEqualTo>
+            </ogc:Filter>
+            <sld:MinScaleDenominator>100000</sld:MinScaleDenominator>
+            <sld:MaxScaleDenominator>200000</sld:MaxScaleDenominator>
+            <sld:LineSymbolizer>
+                <sld:Stroke>
+                    <sld:CssParameter name="stroke">red</sld:CssParameter>
+                    <sld:CssParameter name="stroke-width">3</sld:CssParameter>
+                </sld:Stroke>
+            </sld:LineSymbolizer>
+        </sld:Rule>
+    </sld:FeatureTypeStyle>
+    <sld:FeatureTypeStyle>
+        <sld:Rule>
+            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">
+                <ogc:PropertyIsEqualTo>
+                    <ogc:PropertyName>foo</ogc:PropertyName>
+                    <ogc:Literal>bar</ogc:Literal>
+                </ogc:PropertyIsEqualTo>
+            </ogc:Filter>
+            <sld:MinScaleDenominator>100000</sld:MinScaleDenominator>
+            <sld:MaxScaleDenominator>200000</sld:MaxScaleDenominator>
+            <sld:LineSymbolizer>
+                <sld:Stroke>
+                    <sld:CssParameter name="stroke">green</sld:CssParameter>
+                    <sld:CssParameter name="stroke-width">2</sld:CssParameter>
+                </sld:Stroke>
+            </sld:LineSymbolizer>
+        </sld:Rule>
+        <sld:Rule>
+            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">
+                <ogc:PropertyIsEqualTo>
+                    <ogc:PropertyName>foo</ogc:PropertyName>
+                    <ogc:Literal>baz</ogc:Literal>
+                </ogc:PropertyIsEqualTo>
+            </ogc:Filter>
+            <sld:LineSymbolizer>
+                <sld:Stroke>
+                    <sld:CssParameter name="stroke">#000000</sld:CssParameter>
+                    <sld:CssParameter name="stroke-width">2</sld:CssParameter>
+                </sld:Stroke>
+            </sld:LineSymbolizer>
+        </sld:Rule>
+    </sld:FeatureTypeStyle>
+    <sld:FeatureTypeStyle>
+        <sld:Rule>
+            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">
+                <ogc:PropertyIsEqualTo>
+                    <ogc:PropertyName>foo</ogc:PropertyName>
+                    <ogc:Literal>bar</ogc:Literal>
+                </ogc:PropertyIsEqualTo>
+            </ogc:Filter>
+            <sld:MinScaleDenominator>100000</sld:MinScaleDenominator>
+            <sld:MaxScaleDenominator>200000</sld:MaxScaleDenominator>
+            <sld:LineSymbolizer>
+                <sld:Stroke>
+                    <sld:CssParameter name="stroke">blue</sld:CssParameter>
+                    <sld:CssParameter name="stroke-width">1</sld:CssParameter>
+                </sld:Stroke>
+            </sld:LineSymbolizer>
+        </sld:Rule>
+    </sld:FeatureTypeStyle>
+</sld:UserStyle>
+--></div>
 </body> 
 </html> 

trunk/openlayers/tests/Rule.html

@@ -44 +44 @@
     function test_clone(t) {
         
-        t.plan(7);
+        t.plan(9);
         
         var rule = new OpenLayers.Rule({
@@ -82 +82 @@
         rule.destroy();
         clone.destroy();
+
+        // test multiple symbolizers
+        rule = new OpenLayers.Rule({
+            name: "test rule",
+            minScaleDenominator: 10,
+            maxScaleDenominator: 20,
+            filter: new OpenLayers.Filter.Comparison({
+                type: OpenLayers.Filter.Comparison.EQUAL_TO,
+                property: "prop",
+                value: "value"
+            }),
+            symbolizers: [
+                new OpenLayers.Symbolizer.Line({
+                    strokeColor: "black"
+                })
+            ]
+        });
+        clone = rule.clone();
+
+        t.eq(clone.symbolizers.length, 1, "clone has one symbolizer");
+        t.ok(clone.symbolizers[0] !== rule.symbolizers[0], "clone has different symbolizers than original");
+        
+        clone.destroy();
+        rule.destroy();
         
     }

trunk/openlayers/tests/list-tests.html

@@ -183 +183 @@
     <li>Strategy/Refresh.html</li>
     <li>Style.html</li>
+    <li>Style2.html</li>
     <li>StyleMap.html</li>
+    <li>Symbolizer.html</li>
+    <li>Symbolizer/Line.html</li>
+    <li>Symbolizer/Point.html</li>
+    <li>Symbolizer/Polygon.html</li>
+    <li>Symbolizer/Raster.html</li>
+    <li>Symbolizer/Text.html</li>
     <li>Tile.html</li>
     <li>Tile/Image.html</li>