Changeset 10560

Show
Ignore:
Timestamp:
08/02/10 12:49:52 (4 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:
17 added
6 modified

Legend:

Unmodified
Added
Removed
  • trunk/openlayers/lib/OpenLayers.js

    r10479 r10560  
    228228            "OpenLayers/Layer/GML.js", 
    229229            "OpenLayers/Style.js", 
     230            "OpenLayers/Style2.js", 
    230231            "OpenLayers/StyleMap.js", 
    231232            "OpenLayers/Rule.js", 
     
    304305            "OpenLayers/Control/ZoomPanel.js", 
    305306            "OpenLayers/Control/EditingToolbar.js", 
     307            "OpenLayers/Symbolizer.js", 
     308            "OpenLayers/Symbolizer/Point.js", 
     309            "OpenLayers/Symbolizer/Line.js", 
     310            "OpenLayers/Symbolizer/Polygon.js", 
     311            "OpenLayers/Symbolizer/Text.js", 
     312            "OpenLayers/Symbolizer/Raster.js", 
    306313            "OpenLayers/Lang.js", 
    307314            "OpenLayers/Lang/en.js" 
  • trunk/openlayers/lib/OpenLayers/Format/SLD/v1.js

    r10430 r10560  
    4040     */ 
    4141    schemaLocation: null, 
     42     
     43    /**  
     44     * APIProperty: multipleSymbolizers 
     45     * {Boolean} Support multiple symbolizers per rule.  Default is false.  if 
     46     *     true, an OpenLayers.Style2 instance will be created to represent  
     47     *     user styles instead of an OpenLayers.Style instace.  The  
     48     *     OpenLayers.Style2 class allows collections of rules with multiple 
     49     *     symbolizers, but is not currently useful for client side rendering. 
     50     *     If multiple symbolizers is true, multiple FeatureTypeStyle elements 
     51     *     are preserved in reading/writing by setting symbolizer zIndex values. 
     52     *     In addition, the <defaultSymbolizer> property is ignored if  
     53     *     multiple symbolizers are supported (defaults should be applied 
     54     *     when rendering). 
     55     */ 
     56    multipleSymbolizers: false, 
     57 
     58    /** 
     59     * Property: featureTypeCounter 
     60     * {Number} Private counter for multiple feature type styles. 
     61     */ 
     62    featureTypeCounter: null, 
    4263 
    4364    /** 
     
    139160            "UserStyle": function(node, layer) { 
    140161                var obj = {defaultsPerSymbolizer: true, rules: []}; 
     162                this.featureTypeCounter = -1; 
    141163                this.readChildNodes(node, obj); 
    142                 var style = new OpenLayers.Style(this.defaultSymbolizer, obj); 
     164                var style; 
     165                if (this.multipleSymbolizers) { 
     166                    delete obj.defaultsPerSymbolizer; 
     167                    style = new OpenLayers.Style2(obj); 
     168                } else { 
     169                    style = new OpenLayers.Style(this.defaultSymbolizer, obj); 
     170                } 
    143171                layer.userStyles.push(style); 
    144172            }, 
     
    149177            }, 
    150178            "FeatureTypeStyle": function(node, style) { 
    151                 // OpenLayers doesn't have a place for FeatureTypeStyle 
    152                 // Name, Title, Abstract, FeatureTypeName, or 
    153                 // SemanticTypeIdentifier so, we make a temporary object 
    154                 // and later just use the Rule(s). 
     179                ++this.featureTypeCounter; 
    155180                var obj = { 
    156                     rules: [] 
     181                    rules: this.multipleSymbolizers ? style.rules : [] 
    157182                }; 
    158183                this.readChildNodes(node, obj); 
    159                 style.rules = obj.rules; 
     184                if (!this.multipleSymbolizers) { 
     185                    style.rules = obj.rules; 
     186                } 
    160187            }, 
    161188            "Rule": function(node, obj) { 
    162                 var rule = new OpenLayers.Rule(); 
     189                var config; 
     190                if (this.multipleSymbolizers) { 
     191                    config = {symbolizers: []}; 
     192                } 
     193                var rule = new OpenLayers.Rule(config); 
    163194                this.readChildNodes(node, rule); 
    164195                obj.rules.push(rule); 
     
    174205            }, 
    175206            "TextSymbolizer": function(node, rule) { 
    176                 // OpenLayers doens't do painter's order, instead we extend 
    177                 var symbolizer = rule.symbolizer["Text"] || {}; 
    178                 this.readChildNodes(node, symbolizer); 
    179                 // in case it didn't exist before 
    180                 rule.symbolizer["Text"] = symbolizer; 
     207                var config = {}; 
     208                this.readChildNodes(node, config); 
     209                if (this.multipleSymbolizers) { 
     210                    config.zIndex = this.featureTypeCounter; 
     211                    rule.symbolizers.push( 
     212                        new OpenLayers.Symbolizer.Text(config) 
     213                    ); 
     214                } else { 
     215                    rule.symbolizer["Text"] = OpenLayers.Util.applyDefaults( 
     216                        config, rule.symbolizer["Text"] 
     217                    ); 
     218                } 
    181219            }, 
    182220            "Label": function(node, symbolizer) { 
     
    212250            }, 
    213251            "RasterSymbolizer": function(node, rule) { 
    214                 // OpenLayers doesn't do painter's order, instead we extend 
    215                 var symbolizer = rule.symbolizer["Raster"] || {}; 
    216                 this.readChildNodes(node, symbolizer); 
    217                 // in case it didn't exist before 
    218                 rule.symbolizer["Raster"] = symbolizer; 
     252                var config = {}; 
     253                this.readChildNodes(node, config); 
     254                if (this.multipleSymbolizers) { 
     255                    config.zIndex = this.featureTypeCounter; 
     256                    rule.symbolizers.push( 
     257                        new OpenLayers.Symbolizer.Raster(config) 
     258                    ); 
     259                } else { 
     260                    rule.symbolizer["Raster"] = OpenLayers.Util.applyDefaults( 
     261                        config, rule.symbolizer["Raster"] 
     262                    ); 
     263                } 
    219264            }, 
    220265            "Geometry": function(node, obj) { 
     
    237282            }, 
    238283            "LineSymbolizer": function(node, rule) { 
    239                 // OpenLayers doesn't do painter's order, instead we extend 
    240                 var symbolizer = rule.symbolizer["Line"] || {}; 
    241                 this.readChildNodes(node, symbolizer); 
    242                 // in case it didn't exist before 
    243                 rule.symbolizer["Line"] = symbolizer; 
     284                var config = {}; 
     285                this.readChildNodes(node, config); 
     286                if (this.multipleSymbolizers) { 
     287                    config.zIndex = this.featureTypeCounter; 
     288                    rule.symbolizers.push( 
     289                        new OpenLayers.Symbolizer.Line(config) 
     290                    ); 
     291                } else { 
     292                    rule.symbolizer["Line"] = OpenLayers.Util.applyDefaults( 
     293                        config, rule.symbolizer["Line"] 
     294                    ); 
     295                } 
    244296            }, 
    245297            "PolygonSymbolizer": function(node, rule) { 
    246                 // OpenLayers doens't do painter's order, instead we extend 
    247                 var symbolizer = rule.symbolizer["Polygon"] || { 
     298                var config = { 
    248299                    fill: false, 
    249300                    stroke: false 
    250301                }; 
    251                 this.readChildNodes(node, symbolizer); 
    252                 // in case it didn't exist before 
    253                 rule.symbolizer["Polygon"] = symbolizer; 
     302                if (!this.multipleSymbolizers) { 
     303                    config = rule.symbolizer["Polygon"] || config; 
     304                } 
     305                this.readChildNodes(node, config); 
     306                if (this.multipleSymbolizers) { 
     307                    config.zIndex = this.featureTypeCounter; 
     308                    rule.symbolizers.push( 
     309                        new OpenLayers.Symbolizer.Polygon(config) 
     310                    ); 
     311                } else { 
     312                    rule.symbolizer["Polygon"] = config; 
     313                } 
    254314            }, 
    255315            "PointSymbolizer": function(node, rule) { 
    256                 // OpenLayers doens't do painter's order, instead we extend 
    257                 var symbolizer = rule.symbolizer["Point"] || { 
     316                var config = { 
    258317                    fill: false, 
    259318                    stroke: false, 
    260319                    graphic: false 
    261320                }; 
    262                 this.readChildNodes(node, symbolizer); 
    263                 // in case it didn't exist before 
    264                 rule.symbolizer["Point"] = symbolizer; 
     321                if (!this.multipleSymbolizers) { 
     322                    config = rule.symbolizer["Point"] || config; 
     323                } 
     324                this.readChildNodes(node, config); 
     325                if (this.multipleSymbolizers) { 
     326                    config.zIndex = this.featureTypeCounter; 
     327                    rule.symbolizers.push( 
     328                        new OpenLayers.Symbolizer.Point(config) 
     329                    ); 
     330                } else { 
     331                    rule.symbolizer["Point"] = config; 
     332                } 
    265333            }, 
    266334            "Stroke": function(node, symbolizer) { 
     
    567635                 
    568636                // add FeatureTypeStyles 
    569                 this.writeNode("FeatureTypeStyle", style, node); 
     637                if (this.multipleSymbolizers && style.rules) { 
     638                    // group style objects by symbolizer zIndex 
     639                    var rulesByZ = { 
     640                        0: [] 
     641                    }; 
     642                    var zValues = [0]; 
     643                    var rule, ruleMap, symbolizer, zIndex, clone; 
     644                    for (var i=0, ii=style.rules.length; i<ii; ++i) { 
     645                        rule = style.rules[i]; 
     646                        if (rule.symbolizers) { 
     647                            ruleMap = {}; 
     648                            for (var j=0, jj=rule.symbolizers.length; j<jj; ++j) { 
     649                                symbolizer = rule.symbolizers[j]; 
     650                                zIndex = symbolizer.zIndex; 
     651                                if (!(zIndex in ruleMap)) { 
     652                                    clone = rule.clone(); 
     653                                    clone.symbolizers = []; 
     654                                    ruleMap[zIndex] = clone; 
     655                                } 
     656                                ruleMap[zIndex].symbolizers.push(symbolizer.clone()); 
     657                            } 
     658                            for (zIndex in ruleMap) { 
     659                                if (!(zIndex in rulesByZ)) { 
     660                                    zValues.push(zIndex); 
     661                                    rulesByZ[zIndex] = []; 
     662                                } 
     663                                rulesByZ[zIndex].push(ruleMap[zIndex]); 
     664                            } 
     665                        } else { 
     666                            // no symbolizers in rule 
     667                            rulesByZ[0].push(rule.clone()); 
     668                        } 
     669                    } 
     670                    // write one FeatureTypeStyle per zIndex 
     671                    zValues.sort(); 
     672                    var rules; 
     673                    for (var i=0, ii=zValues.length; i<ii; ++i) { 
     674                        rules = rulesByZ[zValues[i]]; 
     675                        if (rules.length > 0) { 
     676                            clone = style.clone(); 
     677                            clone.rules = rulesByZ[zValues[i]]; 
     678                            this.writeNode("FeatureTypeStyle", clone, node); 
     679                        } 
     680                    }                     
     681                } else { 
     682                    this.writeNode("FeatureTypeStyle", style, node); 
     683                } 
    570684                 
    571685                return node; 
     
    627741                } 
    628742                 
    629                 // add in symbolizers (relies on geometry type keys) 
    630                 var types = OpenLayers.Style.SYMBOLIZER_PREFIXES; 
    631743                var type, symbolizer; 
    632                 for(var i=0, len=types.length; i<len; ++i) { 
    633                     type = types[i]; 
    634                     symbolizer = rule.symbolizer[type]; 
    635                     if(symbolizer) { 
     744                if (this.multipleSymbolizers && rule.symbolizers) { 
     745                    var symbolizer; 
     746                    for (var i=0, ii=rule.symbolizers.length; i<ii; ++i) { 
     747                        symbolizer = rule.symbolizers[i]; 
     748                        type = symbolizer.CLASS_NAME.split(".").pop(); 
    636749                        this.writeNode( 
    637750                            type + "Symbolizer", symbolizer, node 
    638751                        ); 
     752                    } 
     753                } else { 
     754                    // add in symbolizers (relies on geometry type keys) 
     755                    var types = OpenLayers.Style.SYMBOLIZER_PREFIXES; 
     756                    for(var i=0, len=types.length; i<len; ++i) { 
     757                        type = types[i]; 
     758                        symbolizer = rule.symbolizer[type]; 
     759                        if(symbolizer) { 
     760                            this.writeNode( 
     761                                type + "Symbolizer", symbolizer, node 
     762                            ); 
     763                        } 
    639764                    } 
    640765                } 
     
    9261051                    this.writeNode("WellKnownName", symbolizer.graphicName, node); 
    9271052                } 
    928                 this.writeNode("Fill", symbolizer, node); 
    929                 this.writeNode("Stroke", symbolizer, node); 
     1053                if (symbolizer.fill !== false) { 
     1054                    this.writeNode("Fill", symbolizer, node); 
     1055                } 
     1056                if (symbolizer.stroke !== false) { 
     1057                    this.writeNode("Stroke", symbolizer, node); 
     1058                } 
    9301059                return node; 
    9311060            }, 
  • trunk/openlayers/lib/OpenLayers/Rule.js

    r10280 r10560  
    77 * @requires OpenLayers/Util.js 
    88 * @requires OpenLayers/Style.js 
     9 * @requires OpenLayers/Symbolizer/Point.js 
     10 * @requires OpenLayers/Symbolizer/Line.js 
     11 * @requires OpenLayers/Symbolizer/Polygon.js 
     12 * @requires OpenLayers/Symbolizer/Text.js 
     13 * @requires OpenLayers/Symbolizer/Raster.js 
    914 */ 
    1015 
     
    2530     * {String} name of this rule 
    2631     */ 
    27     name: 'default', 
     32    name: null, 
    2833     
    2934    /** 
     
    7580     
    7681    /** 
     82     * Property: symbolizers 
     83     * {Array} Collection of symbolizers associated with this rule.  If  
     84     *     provided at construction, the symbolizers array has precedence 
     85     *     over the deprecated symbolizer property.  Note that multiple  
     86     *     symbolizers are not currently supported by the vector renderers. 
     87     *     Rules with multiple symbolizers are currently only useful for 
     88     *     maintaining elements in an SLD document. 
     89     */ 
     90    symbolizers: null, 
     91     
     92    /** 
    7793     * APIProperty: minScaleDenominator 
    7894     * {Number} or {String} minimum scale at which to draw the feature. 
     
    104120        this.symbolizer = {}; 
    105121        OpenLayers.Util.extend(this, options); 
     122        if (this.symbolizers) { 
     123            delete this.symbolizer; 
     124        } 
    106125        this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); 
    107126    }, 
     
    116135        } 
    117136        this.symbolizer = null; 
     137        delete this.symbolizers; 
    118138    }, 
    119139     
     
    188208    clone: function() { 
    189209        var options = OpenLayers.Util.extend({}, this); 
    190         // clone symbolizer 
    191         options.symbolizer = {}; 
    192         var value, type; 
    193         for(var key in this.symbolizer) { 
    194             value = this.symbolizer[key]; 
    195             type = typeof value; 
    196             if(type === "object") { 
    197                 options.symbolizer[key] = OpenLayers.Util.extend({}, value); 
    198             } else if(type === "string") { 
    199                 options.symbolizer[key] = value; 
     210        if (this.symbolizers) { 
     211            // clone symbolizers 
     212            var len = this.symbolizers.length; 
     213            options.symbolizers = new Array(len); 
     214            for (var i=0; i<len; ++i) { 
     215                options.symbolizers[i] = this.symbolizers[i].clone(); 
     216            } 
     217        } else { 
     218            // clone symbolizer 
     219            options.symbolizer = {}; 
     220            var value, type; 
     221            for(var key in this.symbolizer) { 
     222                value = this.symbolizer[key]; 
     223                type = typeof value; 
     224                if(type === "object") { 
     225                    options.symbolizer[key] = OpenLayers.Util.extend({}, value); 
     226                } else if(type === "string") { 
     227                    options.symbolizer[key] = value; 
     228                } 
    200229            } 
    201230        } 
  • trunk/openlayers/tests/Format/SLD/v1_0_0.html

    r10349 r10560  
    33    <script src="../../../lib/OpenLayers.js"></script> 
    44    <script type="text/javascript"> 
     5 
     6    var xml = new OpenLayers.Format.XML();  
     7    function readXML(id) { 
     8        return xml.read(document.getElementById(id).firstChild.nodeValue); 
     9    } 
    510     
    611    var sld = 
     
    440445        t.xml_eq(got, expected, "Successfully round tripped RasterSymbolizer"); 
    441446    } 
     447     
     448    function test_zIndex(t) { 
     449        t.plan(1); 
     450         
     451        var format = new OpenLayers.Format.SLD.v1_0_0({ 
     452            multipleSymbolizers: true 
     453        }); 
     454         
     455        // three zIndex values -> three FeatureTypeStyle elements 
     456        var style = new OpenLayers.Style2({ 
     457            rules: [ 
     458                new OpenLayers.Rule({ 
     459                    filter: new OpenLayers.Filter.Comparison({ 
     460                        type: OpenLayers.Filter.Comparison.EQUAL_TO, 
     461                        property: "foo", 
     462                        value: "bar" 
     463                    }), 
     464                    minScaleDenominator: 100000, 
     465                    maxScaleDenominator: 200000, 
     466                    symbolizers: [ 
     467                        new OpenLayers.Symbolizer.Line({ 
     468                            strokeColor: "green", 
     469                            strokeWidth: 2, 
     470                            zIndex: 2 
     471                        }), 
     472                        new OpenLayers.Symbolizer.Line({ 
     473                            strokeColor: "red", 
     474                            strokeWidth: 3, 
     475                            zIndex: -1 
     476                        }), 
     477                        new OpenLayers.Symbolizer.Line({ 
     478                            strokeColor: "blue", 
     479                            strokeWidth: 1, 
     480                            zIndex: 5 
     481                        }) 
     482                    ] 
     483                }), 
     484                new OpenLayers.Rule({ 
     485                    filter: new OpenLayers.Filter.Comparison({ 
     486                        type: OpenLayers.Filter.Comparison.EQUAL_TO, 
     487                        property: "foo", 
     488                        value: "baz" 
     489                    }),                     
     490                    symbolizers: [ 
     491                        new OpenLayers.Symbolizer.Line({ 
     492                            strokeColor: "#000000", 
     493                            strokeWidth: 2, 
     494                            zIndex: 2 
     495                        }) 
     496                    ] 
     497                }) 
     498            ] 
     499        }); 
     500         
     501        var got = format.writeNode("sld:UserStyle", style); 
     502        var exp = readXML("zindex_test.sld").documentElement; 
     503        t.xml_eq(got, exp, "duplicated rules to write zIndex as FeatureTypeStyle elements"); 
     504         
     505    } 
     506     
     507    function test_read_FeatureTypeStyles(t) { 
     508         
     509        t.plan(13); 
     510         
     511        var format = new OpenLayers.Format.SLD.v1_0_0({ 
     512            multipleSymbolizers: true, 
     513            namedLayersAsArray: true 
     514        }); 
     515        var doc = readXML("line_linewithborder.sld"); 
     516         
     517        var obj = format.read(doc); 
     518 
     519        t.eq(obj.namedLayers.length, 1, "got one named layer"); 
     520        var namedLayer = obj.namedLayers[0]; 
     521         
     522        t.eq(namedLayer.userStyles.length, 1, "got one user style"); 
     523        var userStyle = namedLayer.userStyles[0]; 
     524        t.ok(userStyle instanceof OpenLayers.Style2, "user style represented with OpenLayers.Style2"); 
     525         
     526        // check rules and symbolizers 
     527        var rule, symbolizer; 
     528         
     529        t.eq(userStyle.rules.length, 2, "pulled two rules (from two FeatureTypeStyle elements)"); 
     530        rule = userStyle.rules[0]; 
     531        t.ok(rule instanceof OpenLayers.Rule, "first rule is an OpenLayers.Rule"); 
     532         
     533        t.eq(rule.symbolizers && rule.symbolizers.length, 1, "first rule has one symbolizer"); 
     534        symbolizer = rule.symbolizers[0]; 
     535        t.ok(symbolizer instanceof OpenLayers.Symbolizer, "first symbolizer in first rule is an OpenLayers.Symbolizer"); 
     536        t.ok(symbolizer instanceof OpenLayers.Symbolizer.Line, "first symbolizer in first rule is an OpenLayers.Symbolizer.Line"); 
     537        t.eq(symbolizer.zIndex, 0, "symbolizer from first FeatureTypeStyle element has zIndex 0"); 
     538         
     539        rule = userStyle.rules[1]; 
     540        t.eq(rule.symbolizers && rule.symbolizers.length, 1, "second rule has one symbolizer"); 
     541        symbolizer = rule.symbolizers[0]; 
     542        t.ok(symbolizer instanceof OpenLayers.Symbolizer, "first symbolizer in second rule is an OpenLayers.Symbolizer"); 
     543        t.ok(symbolizer instanceof OpenLayers.Symbolizer.Line, "first symbolizer in second rule is an OpenLayers.Symbolizer.Line"); 
     544        t.eq(symbolizer.zIndex, 1, "symbolizer from second FeatureTypeStyle element has zIndex 1"); 
     545         
     546    } 
     547 
     548    function test_roundtrip(t) { 
     549         
     550        t.plan(5); 
     551         
     552        var format = new OpenLayers.Format.SLD.v1_0_0({ 
     553            multipleSymbolizers: true, 
     554            namedLayersAsArray: true 
     555        }); 
     556        var doc, out; 
     557         
     558        // two FeatureTypeStyle elements and line symbolizers 
     559        doc = readXML("line_linewithborder.sld"); 
     560        out = format.write(format.read(doc)); 
     561        t.xml_eq(out, doc.documentElement, "round-tripped line_linewithborder.sld"); 
     562 
     563        // three FeatureTypeStyle elements and line symbolizers 
     564        doc = readXML("line_attributebasedline.sld"); 
     565        out = format.write(format.read(doc)); 
     566        t.xml_eq(out, doc.documentElement, "round-tripped line_attributebasedline.sld"); 
     567         
     568        // point symbolizer and text symbolizer 
     569        doc = readXML("point_pointwithdefaultlabel.sld"); 
     570        out = format.write(format.read(doc)); 
     571        t.xml_eq(out, doc.documentElement, "round-tripped point_pointwithdefaultlabel.sld"); 
     572         
     573        // polygon symbolizer with fill only  
     574        doc = readXML("polygon_simplepolygon.sld"); 
     575        out = format.write(format.read(doc)); 
     576        t.xml_eq(out, doc.documentElement, "round-tripped polygon_simplepolygon.sld"); 
     577 
     578        // polygon symbolizer and text symbolizer with halo 
     579        doc = readXML("polygon_labelhalo.sld"); 
     580        out = format.write(format.read(doc)); 
     581        t.xml_eq(out, doc.documentElement, "round-tripped polygon_labelhalo.sld"); 
     582 
     583    } 
    442584 
    443585    </script>  
    444586</head>  
    445587<body> 
     588<div id="line_linewithborder.sld"><!-- 
     589<StyledLayerDescriptor version="1.0.0"  
     590    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd"  
     591    xmlns="http://www.opengis.net/sld"  
     592    xmlns:ogc="http://www.opengis.net/ogc"  
     593    xmlns:xlink="http://www.w3.org/1999/xlink"  
     594    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
     595  <NamedLayer> 
     596    <Name>Line with border</Name> 
     597    <UserStyle> 
     598    <Title>SLD Cook Book: Line w2th border</Title> 
     599      <FeatureTypeStyle> 
     600         <Rule> 
     601          <LineSymbolizer> 
     602            <Stroke> 
     603              <CssParameter name="stroke">#333333</CssParameter>                            
     604              <CssParameter name="stroke-width">5</CssParameter>     
     605              <CssParameter name="stroke-linecap">round</CssParameter>     
     606            </Stroke>  
     607          </LineSymbolizer> 
     608        </Rule> 
     609      </FeatureTypeStyle> 
     610      <FeatureTypeStyle> 
     611         <Rule> 
     612          <LineSymbolizer> 
     613          <Stroke> 
     614              <CssParameter name="stroke">#6699FF</CssParameter>                            
     615              <CssParameter name="stroke-width">3</CssParameter>  
     616              <CssParameter name="stroke-linecap">round</CssParameter>   
     617            </Stroke> 
     618          </LineSymbolizer>                                           
     619         </Rule> 
     620      </FeatureTypeStyle> 
     621    </UserStyle> 
     622  </NamedLayer> 
     623</StyledLayerDescriptor> 
     624--></div> 
     625<div id="line_attributebasedline.sld"><!-- 
     626<StyledLayerDescriptor version="1.0.0"  
     627    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd"  
     628    xmlns="http://www.opengis.net/sld"  
     629    xmlns:ogc="http://www.opengis.net/ogc"  
     630    xmlns:xlink="http://www.w3.org/1999/xlink"  
     631    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
     632  <NamedLayer> 
     633    <Name>Attribute-based line</Name> 
     634    <UserStyle> 
     635      <Title>SLD Cook Book: Attribute-based line</Title> 
     636      <FeatureTypeStyle> 
     637        <Rule> 
     638          <Name>local-road</Name> 
     639          <ogc:Filter> 
     640            <ogc:PropertyIsEqualTo> 
     641              <ogc:PropertyName>type</ogc:PropertyName> 
     642              <ogc:Literal>local-road</ogc:Literal> 
     643            </ogc:PropertyIsEqualTo> 
     644          </ogc:Filter> 
     645          <LineSymbolizer> 
     646            <Stroke> 
     647              <CssParameter name="stroke">#009933</CssParameter> 
     648              <CssParameter name="stroke-width">2</CssParameter> 
     649            </Stroke> 
     650          </LineSymbolizer> 
     651        </Rule> 
     652      </FeatureTypeStyle> 
     653      <FeatureTypeStyle> 
     654        <Rule> 
     655          <Name>secondary</Name> 
     656          <ogc:Filter> 
     657            <ogc:PropertyIsEqualTo> 
     658              <ogc:PropertyName>type</ogc:PropertyName> 
     659              <ogc:Literal>secondary</ogc:Literal> 
     660            </ogc:PropertyIsEqualTo> 
     661          </ogc:Filter> 
     662          <LineSymbolizer> 
     663            <Stroke> 
     664              <CssParameter name="stroke">#0055CC</CssParameter> 
     665              <CssParameter name="stroke-width">3</CssParameter> 
     666            </Stroke> 
     667          </LineSymbolizer> 
     668        </Rule> 
     669      </FeatureTypeStyle> 
     670      <FeatureTypeStyle> 
     671        <Rule> 
     672        <Name>highway</Name> 
     673          <ogc:Filter> 
     674            <ogc:PropertyIsEqualTo> 
     675              <ogc:PropertyName>type</ogc:PropertyName> 
     676              <ogc:Literal>highway</ogc:Literal> 
     677            </ogc:PropertyIsEqualTo> 
     678          </ogc:Filter> 
     679          <LineSymbolizer> 
     680            <Stroke> 
     681              <CssParameter name="stroke">#FF0000</CssParameter> 
     682              <CssParameter name="stroke-width">6</CssParameter> 
     683            </Stroke> 
     684          </LineSymbolizer> 
     685        </Rule> 
     686      </FeatureTypeStyle> 
     687    </UserStyle> 
     688  </NamedLayer> 
     689</StyledLayerDescriptor>  
     690--></div> 
     691<div id="point_pointwithdefaultlabel.sld"><!-- 
     692<StyledLayerDescriptor version="1.0.0"  
     693    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd"  
     694    xmlns="http://www.opengis.net/sld"  
     695    xmlns:ogc="http://www.opengis.net/ogc"  
     696    xmlns:xlink="http://www.w3.org/1999/xlink"  
     697    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
     698  <NamedLayer> 
     699    <Name>Point with default label</Name> 
     700    <UserStyle> 
     701      <Title>GeoServer SLD Cook Book: Point with default label</Title> 
     702      <FeatureTypeStyle> 
     703        <Rule> 
     704          <PointSymbolizer> 
     705            <Graphic> 
     706              <Mark> 
     707                <WellKnownName>circle</WellKnownName> 
     708                <Fill> 
     709                  <CssParameter name="fill">#FF0000</CssParameter> 
     710                </Fill> 
     711              </Mark> 
     712              <Size>6</Size> 
     713            </Graphic> 
     714          </PointSymbolizer> 
     715          <TextSymbolizer> 
     716            <Label> 
     717              <ogc:PropertyName>name</ogc:PropertyName> 
     718            </Label> 
     719            <Fill> 
     720              <CssParameter name="fill">#000000</CssParameter> 
     721            </Fill> 
     722          </TextSymbolizer> 
     723        </Rule> 
     724      </FeatureTypeStyle> 
     725    </UserStyle> 
     726  </NamedLayer> 
     727</StyledLayerDescriptor> 
     728--></div> 
     729<div id="polygon_simplepolygon.sld"><!-- 
     730<StyledLayerDescriptor version="1.0.0"  
     731    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd"  
     732    xmlns="http://www.opengis.net/sld"  
     733    xmlns:ogc="http://www.opengis.net/ogc"  
     734    xmlns:xlink="http://www.w3.org/1999/xlink"  
     735    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
     736  <NamedLayer> 
     737    <Name>Simple polygon</Name> 
     738    <UserStyle> 
     739      <Title>SLD Cook Book: Simple polygon</Title> 
     740      <FeatureTypeStyle> 
     741        <Rule> 
     742          <PolygonSymbolizer> 
     743            <Fill> 
     744              <CssParameter name="fill">#000080</CssParameter> 
     745            </Fill> 
     746          </PolygonSymbolizer> 
     747        </Rule> 
     748      </FeatureTypeStyle> 
     749    </UserStyle> 
     750  </NamedLayer> 
     751</StyledLayerDescriptor> 
     752--></div> 
     753<div id="polygon_labelhalo.sld"><!-- 
     754<StyledLayerDescriptor version="1.0.0"  
     755    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd"  
     756    xmlns="http://www.opengis.net/sld"  
     757    xmlns:ogc="http://www.opengis.net/ogc"  
     758    xmlns:xlink="http://www.w3.org/1999/xlink"  
     759    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
     760  <NamedLayer> 
     761    <Name>Label halo</Name> 
     762    <UserStyle> 
     763      <Title>SLD Cook Book: Label halo</Title> 
     764      <FeatureTypeStyle> 
     765        <Rule> 
     766          <PolygonSymbolizer> 
     767            <Fill> 
     768              <CssParameter name="fill">#40FF40</CssParameter> 
     769            </Fill> 
     770            <Stroke> 
     771              <CssParameter name="stroke">#FFFFFF</CssParameter> 
     772              <CssParameter name="stroke-width">2</CssParameter> 
     773            </Stroke> 
     774          </PolygonSymbolizer>         
     775          <TextSymbolizer> 
     776            <Label> 
     777              <ogc:PropertyName>name</ogc:PropertyName> 
     778            </Label> 
     779            <Halo> 
     780              <Radius>3</Radius> 
     781              <Fill> 
     782                <CssParameter name="fill">#FFFFFF</CssParameter> 
     783              </Fill> 
     784            </Halo> 
     785          </TextSymbolizer> 
     786        </Rule> 
     787      </FeatureTypeStyle> 
     788    </UserStyle> 
     789  </NamedLayer> 
     790</StyledLayerDescriptor> 
     791--></div> 
     792<div id="zindex_test.sld"><!-- 
     793<sld:UserStyle xmlns:sld="http://www.opengis.net/sld"> 
     794    <sld:FeatureTypeStyle> 
     795        <sld:Rule> 
     796            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc"> 
     797                <ogc:PropertyIsEqualTo> 
     798                    <ogc:PropertyName>foo</ogc:PropertyName> 
     799                    <ogc:Literal>bar</ogc:Literal> 
     800                </ogc:PropertyIsEqualTo> 
     801            </ogc:Filter> 
     802            <sld:MinScaleDenominator>100000</sld:MinScaleDenominator> 
     803            <sld:MaxScaleDenominator>200000</sld:MaxScaleDenominator> 
     804            <sld:LineSymbolizer> 
     805                <sld:Stroke> 
     806                    <sld:CssParameter name="stroke">red</sld:CssParameter> 
     807                    <sld:CssParameter name="stroke-width">3</sld:CssParameter> 
     808                </sld:Stroke> 
     809            </sld:LineSymbolizer> 
     810        </sld:Rule> 
     811    </sld:FeatureTypeStyle> 
     812    <sld:FeatureTypeStyle> 
     813        <sld:Rule> 
     814            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc"> 
     815                <ogc:PropertyIsEqualTo> 
     816                    <ogc:PropertyName>foo</ogc:PropertyName> 
     817                    <ogc:Literal>bar</ogc:Literal> 
     818                </ogc:PropertyIsEqualTo> 
     819            </ogc:Filter> 
     820            <sld:MinScaleDenominator>100000</sld:MinScaleDenominator> 
     821            <sld:MaxScaleDenominator>200000</sld:MaxScaleDenominator> 
     822            <sld:LineSymbolizer> 
     823                <sld:Stroke> 
     824                    <sld:CssParameter name="stroke">green</sld:CssParameter> 
     825                    <sld:CssParameter name="stroke-width">2</sld:CssParameter> 
     826                </sld:Stroke> 
     827            </sld:LineSymbolizer> 
     828        </sld:Rule> 
     829        <sld:Rule> 
     830            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc"> 
     831                <ogc:PropertyIsEqualTo> 
     832                    <ogc:PropertyName>foo</ogc:PropertyName> 
     833                    <ogc:Literal>baz</ogc:Literal> 
     834                </ogc:PropertyIsEqualTo> 
     835            </ogc:Filter> 
     836            <sld:LineSymbolizer> 
     837                <sld:Stroke> 
     838                    <sld:CssParameter name="stroke">#000000</sld:CssParameter> 
     839                    <sld:CssParameter name="stroke-width">2</sld:CssParameter> 
     840                </sld:Stroke> 
     841            </sld:LineSymbolizer> 
     842        </sld:Rule> 
     843    </sld:FeatureTypeStyle> 
     844    <sld:FeatureTypeStyle> 
     845        <sld:Rule> 
     846            <ogc:Filter xmlns:ogc="http://www.opengis.net/ogc"> 
     847                <ogc:PropertyIsEqualTo> 
     848                    <ogc:PropertyName>foo</ogc:PropertyName> 
     849                    <ogc:Literal>bar</ogc:Literal> 
     850                </ogc:PropertyIsEqualTo> 
     851            </ogc:Filter> 
     852            <sld:MinScaleDenominator>100000</sld:MinScaleDenominator> 
     853            <sld:MaxScaleDenominator>200000</sld:MaxScaleDenominator> 
     854            <sld:LineSymbolizer> 
     855                <sld:Stroke> 
     856                    <sld:CssParameter name="stroke">blue</sld:CssParameter> 
     857                    <sld:CssParameter name="stroke-width">1</sld:CssParameter> 
     858                </sld:Stroke> 
     859            </sld:LineSymbolizer> 
     860        </sld:Rule> 
     861    </sld:FeatureTypeStyle> 
     862</sld:UserStyle> 
     863--></div> 
    446864</body>  
    447865</html>  
  • trunk/openlayers/tests/Rule.html

    r9071 r10560  
    4444    function test_clone(t) { 
    4545         
    46         t.plan(7); 
     46        t.plan(9); 
    4747         
    4848        var rule = new OpenLayers.Rule({ 
     
    8282        rule.destroy(); 
    8383        clone.destroy(); 
     84 
     85        // test multiple symbolizers 
     86        rule = new OpenLayers.Rule({ 
     87            name: "test rule", 
     88            minScaleDenominator: 10, 
     89            maxScaleDenominator: 20, 
     90            filter: new OpenLayers.Filter.Comparison({ 
     91                type: OpenLayers.Filter.Comparison.EQUAL_TO, 
     92                property: "prop", 
     93                value: "value" 
     94            }), 
     95            symbolizers: [ 
     96                new OpenLayers.Symbolizer.Line({ 
     97                    strokeColor: "black" 
     98                }) 
     99            ] 
     100        }); 
     101        clone = rule.clone(); 
     102 
     103        t.eq(clone.symbolizers.length, 1, "clone has one symbolizer"); 
     104        t.ok(clone.symbolizers[0] !== rule.symbolizers[0], "clone has different symbolizers than original"); 
     105         
     106        clone.destroy(); 
     107        rule.destroy(); 
    84108         
    85109    } 
  • trunk/openlayers/tests/list-tests.html

    r10474 r10560  
    183183    <li>Strategy/Refresh.html</li> 
    184184    <li>Style.html</li> 
     185    <li>Style2.html</li> 
    185186    <li>StyleMap.html</li> 
     187    <li>Symbolizer.html</li> 
     188    <li>Symbolizer/Line.html</li> 
     189    <li>Symbolizer/Point.html</li> 
     190    <li>Symbolizer/Polygon.html</li> 
     191    <li>Symbolizer/Raster.html</li> 
     192    <li>Symbolizer/Text.html</li> 
    186193    <li>Tile.html</li> 
    187194    <li>Tile/Image.html</li>