OpenLayers OpenLayers

Ticket #1297: 1297-r5949-A3.patch

File 1297-r5949-A3.patch, 12.5 kB (added by ahocevar, 1 year ago)

  • examples/georss-flickr.html

    old new  
    2828             
    2929            // create a property style that reads the externalGraphic url from 
    3030            // the thumbail attribute of the rss item 
    31             style = new OpenLayers.Style({ 
    32                 externalGraphic: "${thumbnail}", 
    33                 pointRadius: 20}); 
     31            style = new OpenLayers.Style({externalGraphic: "${thumbnail}"}); 
    3432             
    3533            // create a rule with a point symbolizer that will make the thumbnail 
    3634            // larger if the title of the rss item conatins "powder" 
    …… 
    4139                    symbolizer: {"Point": {pointRadius: 30}}}); 
    4240            rule.value2regex("*"); 
    4341             
    44             style.addRules([rule]); 
     42            // If the above rule does not apply, use a smaller pointRadius. 
     43            var elseRule = new OpenLayers.Rule({ 
     44                    symbolizer: {"Point": {pointRadius: 20}}}); 
     45             
     46            style.addRules([rule, elseRule]); 
    4547             
    4648            markerLayer = new OpenLayers.Layer.Vector("", {style: style}); 
    4749            map.addLayer(markerLayer); 

  • examples/tasmania/sld-tasmania.xml

    old new  
    5151            </sld:Stroke> 
    5252          </sld:PolygonSymbolizer> 
    5353        </sld:Rule> 
     54        <sld:Rule> 
     55          <sld:Name>testRuleNameElse</sld:Name> 
     56          <sld:Title>title</sld:Title> 
     57          <sld:Abstract>Abstract</sld:Abstract> 
     58          <ogc:ElseFilter/> 
     59        </sld:Rule> 
    5460      </sld:FeatureTypeStyle> 
    5561    </sld:UserStyle> 
    5662 
    …… 
    113119            </sld:Stroke> 
    114120          </sld:PolygonSymbolizer> 
    115121        </sld:Rule> 
    116  
     122        <sld:Rule> 
     123          <sld:Name>testRuleNameHoverElse</sld:Name> 
     124          <sld:Title>title</sld:Title> 
     125          <sld:Abstract>Abstract</sld:Abstract> 
     126          <ogc:ElseFilter/> 
     127        </sld:Rule> 
    117128      </sld:FeatureTypeStyle> 
    118129    </sld:UserStyle> 
    119130 

  • lib/OpenLayers/Format/SLD.js

    old new  
    106106            data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); 
    107107        } 
    108108         
     109        options = options || {}; 
    109110        OpenLayers.Util.applyDefaults(options, { 
    110111            withNamedLayer: false, 
    111112            overrideDefaultStyleKey: true 
    …… 
    206207        if (filter && filter.length > 0) { 
    207208            var rule = this.parseFilter(filter[0]); 
    208209        } else { 
    209             // rule applies to all features 
     210            // rule applies to all features (no filter or ElseFilter) 
    210211            var rule = new OpenLayers.Rule(); 
    211212        } 
    212213        rule.name = name; 
    …… 
    218219            xmlNode, this.sldns, "MinScaleDenominator" 
    219220        ); 
    220221        if (minScale && minScale.length > 0) { 
    221             rule.minScale = parseFloat(this.getChildValue(minScale[0])); 
     222            rule.minScaleDenominator =  
     223                parseFloat(this.getChildValue(minScale[0])); 
    222224        } 
    223225         
    224226        // MaxScaleDenominator 
    …… 
    226228            xmlNode, this.sldns, "MaxScaleDenominator" 
    227229        ); 
    228230        if (maxScale && maxScale.length > 0) { 
    229             rule.maxScale = parseFloat(this.getChildValue(maxScale[0])); 
     231            rule.maxScaleDenominator = 
     232                parseFloat(this.getChildValue(maxScale[0])); 
    230233        } 
    231234         
    232235        // STYLES 

  • lib/OpenLayers/Rule.js

    old new  
    2828    symbolizer: null, 
    2929     
    3030    /** 
    31      * APIProperty: minScale 
     31     * APIProperty: minScaleDenominator 
    3232     * {Number} or {String} minimum scale at which to draw the feature. 
    3333     * In the case of a String, this can be a combination of text and 
    3434     * propertyNames in the form "literal ${propertyName}" 
    …… 
    3333     * In the case of a String, this can be a combination of text and 
    3434     * propertyNames in the form "literal ${propertyName}" 
    3535     */ 
    36     minScale: null, 
     36    minScaleDenominator: null, 
    3737 
    3838    /** 
    39      * APIProperty: maxScale 
     39     * APIProperty: maxScaleDenominator 
    4040     * {Number} or {String} maximum scale at which to draw the feature. 
    4141     * In the case of a String, this can be a combination of text and 
    4242     * propertyNames in the form "literal ${propertyName}" 
    …… 
    4141     * In the case of a String, this can be a combination of text and 
    4242     * propertyNames in the form "literal ${propertyName}" 
    4343     */ 
    44     maxScale: null, 
    45  
     44    maxScaleDenominator: null, 
     45     
    4646    /**  
    4747     * Constructor: OpenLayers.Rule 
    4848     * Creates a Rule. 

  • lib/OpenLayers/Style.js

    old new  
    107107     * Returns: 
    108108     * {<OpenLayers.Feature.Vector.style>} hash of feature styles 
    109109     */ 
    110     createStyle: function(feature, baseStyle) { 
    111         if (!baseStyle) { 
    112             baseStyle = this.defaultStyle; 
    113         } 
    114         var style = OpenLayers.Util.extend({}, baseStyle); 
     110    createStyle: function(feature) { 
     111        var style = OpenLayers.Util.extend({}, this.defaultStyle); 
    115112         
    116         var draw = true; 
     113        var rules = this.rules; 
     114        var draw = rules.length == 0 ? true : false; 
    117115 
    118         for (var i=0; i<this.rules.length; i++) { 
     116        var rule; 
     117        for (var i=0; i<rules.length; i++) { 
     118            rule = rules[i]; 
    119119            // does the rule apply?         
    120             var applies = this.rules[i].evaluate(feature); 
     120            var applies = rule.evaluate(feature); 
     121             
     122            if (rule.minScaleDenominator || rule.maxScaleDenominator) { 
     123                var scale = feature.layer.map.getScale(); 
     124            } 
     125             
     126            // check if within minScale/maxScale bounds 
     127            if (rule.minScaleDenominator) { 
     128                applies = scale >= OpenLayers.Style.createLiteral( 
     129                        rule.minScaleDenominator, feature); 
     130            } 
     131            if (applies && rule.maxScaleDenominator) { 
     132                applies = scale < OpenLayers.Style.createLiteral( 
     133                        rule.maxScaleDenominator, feature); 
     134            } 
     135             
     136            if (draw && rule.CLASS_NAME == "OpenLayers.Rule") { 
     137                // apply plain rules only if no other applied (ElseFilter) 
     138                applies = false; 
     139            } 
     140 
    121141            if (applies) { 
    122                 // check if within minScale/maxScale bounds 
    123                 var scale = feature.layer.map.getScale(); 
    124                 if (this.rules[i].minScale) { 
    125                     draw = scale > OpenLayers.Style.createLiteral( 
    126                             this.rules[i].minScale, feature); 
    127                 } 
    128                 if (draw && this.rules[i].maxScale) { 
    129                     draw = scale < OpenLayers.Style.createLiteral( 
    130                             this.rules[i].maxScale, feature); 
    131                 } 
    132                  
     142                draw = true; 
     143 
    133144                // determine which symbolizer (Point, Line, Polygon) to use 
    134145                var symbolizerPrefix = feature.geometry ? 
    135146                        this.getSymbolizerPrefix(feature.geometry) : 
    …… 
    135146                        this.getSymbolizerPrefix(feature.geometry) : 
    136147                        OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; 
    137148 
    138                 // now merge the style with the current style 
     149                // merge the style with the current style 
    139150                var symbolizer = this.rules[i].symbolizer[symbolizerPrefix]; 
    140151                OpenLayers.Util.extend(style, symbolizer); 
    141152            } 
    …… 
    141152            } 
    142153        } 
    143154 
     155        // calculate literals for all styles in the propertyStyles cache 
     156        this.createLiterals(style, feature); 
    144157        style.display = draw ? "" : "none"; 
    145  
    146         // calculate literals for all styles in the propertyStyles cache 
     158         
     159        return style; 
     160    }, 
     161     
     162    /** 
     163     * Method: createLiterals 
     164     * creates literals for all style properties that have an entry in 
     165     * <this.propertyStyles>. 
     166     *  
     167     * Parameters: 
     168     * style   - {Object} style to create literals for. Will be modified 
     169     *           inline. 
     170     * feature - {<OpenLayers.Feature.Vector>} feature to take properties from 
     171     *  
     172     * Returns; 
     173     * {Object} the modified style 
     174     */ 
     175    createLiterals: function(style, feature) { 
    147176        for (var i in this.propertyStyles) { 
    148177            style[i] = OpenLayers.Style.createLiteral(style[i], feature); 
    149178        } 
    150          
    151179        return style; 
    152180    }, 
    153181     

  • tests/test_Style.html

    old new  
    1515    } 
    1616     
    1717    function test_Style_create(t) { 
    18         t.plan(5); 
     18        t.plan(10); 
    1919         
    2020        var map = new OpenLayers.Map("map"); 
    2121         
    …… 
    2727         
    2828        var style = new OpenLayers.Style(baseStyle); 
    2929         
    30         var rule = new OpenLayers.Rule.FeatureId({ 
     30        var rule1 = new OpenLayers.Rule.FeatureId({ 
    3131                fids: ["1"], 
    3232                symbolizer: {"Point": {fillColor: "green"}}, 
    33                 maxScale: 2000000}); 
    34         style.addRules([rule]); 
     33                maxScaleDenominator: 500000}); 
     34        var rule2 = new OpenLayers.Rule.FeatureId({ 
     35                fids: ["1"], 
     36                symbolizer: {"Point": {fillColor: "yellow"}}, 
     37                minScaleDenominator: 500000, 
     38                maxScaleDenominator: 1000000}); 
     39        var rule3 = new OpenLayers.Rule.FeatureId({ 
     40                fids: ["1"], 
     41                symbolizer: {"Point": {fillColor: "red"}}, 
     42                minScaleDenominator: 1000000, 
     43                maxScaleDenominator: 2500000}); 
     44        style.addRules([rule1, rule2, rule3]); 
    3545         
    3646        var feature = new OpenLayers.Feature.Vector( 
    3747                new OpenLayers.Geometry.Point(3,5), 
    …… 
    4555        map.addLayer(layer); 
    4656        map.setBaseLayer(layer); 
    4757 
    48         map.setCenter(new OpenLayers.LonLat(3,5), 8); 
    49         // at this scale, the feature should be visible 
     58        map.setCenter(new OpenLayers.LonLat(3,5), 10); 
     59 
     60        // at this scale, the feature should be green 
    5061        var createdStyle = style.createStyle(feature); 
    5162        t.eq(createdStyle.externalGraphic, "barbar.png", "Calculated property style correctly."); 
    5263        t.eq(createdStyle.display, "", "Feature is visible at scale "+map.getScale()); 
     64        t.eq(createdStyle.fillColor, "green", "Point symbolizer from rule applied correctly."); 
     65 
     66        map.setCenter(new OpenLayers.LonLat(3,5), 9); 
     67        // at this scale, the feature should be red 
     68        createdStyle = style.createStyle(feature); 
     69        t.eq(createdStyle.display, "", "Feature is visible at scale "+map.getScale()); 
     70        t.eq(createdStyle.fillColor, "yellow", "Point symbolizer from rule applied correctly."); 
     71 
     72        map.setCenter(new OpenLayers.LonLat(3,5), 8); 
     73        // at this scale, the feature should be yellow 
     74        createdStyle = style.createStyle(feature); 
     75        t.eq(createdStyle.display, "", "Feature is visible at scale "+map.getScale()); 
     76        t.eq(createdStyle.fillColor, "red", "Point symbolizer from rule applied correctly."); 
    5377 
    5478        map.setCenter(new OpenLayers.LonLat(3,5), 7); 
    5579        // at this scale, the feature should be invisible 
    …… 
    5579        // at this scale, the feature should be invisible 
    5680        createdStyle = style.createStyle(feature); 
    5781        t.eq(createdStyle.display, "none", "Feature is invisible at scale "+map.getScale()); 
    58         t.eq(createdStyle.fillColor, "green", "Point symbolizer from rule for fid=\"1\" applied correctly."); 
     82        t.eq(createdStyle.fillColor, baseStyle.fillColor, "Point symbolizer from base style applied correctly."); 
    5983         
    6084        feature.fid = "2"; 
    6185        // now the rule should not apply 
    …… 
    6286         
    6387        createdStyle = style.createStyle(feature); 
    6488        t.eq(createdStyle.fillColor, baseStyle.fillColor, "Correct style for rule that does not apply to fid=\"2\"."); 
    65          
    6689    } 
    6790 
    6891    function test_Style_destroy(t) {