OpenLayers OpenLayers

Ticket #1120: stylemap_new.patch

File stylemap_new.patch, 27.5 kB (added by crschmidt, 8 months ago)

with fixed examples

  • tests/Control/test_SelectFeature.html

    old new  
    3333    } 
    3434     
    3535    function test_Control_SelectFeature_select(t) { 
    36         t.plan(7); 
     36        t.plan(2); 
    3737        var map = new OpenLayers.Map("map"); 
    3838        var layer = new OpenLayers.Layer.Vector(); 
    3939        map.addLayer(layer); 
    4040        var control = new OpenLayers.Control.SelectFeature(layer); 
    4141        var feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(0,0)); 
    4242        layer.addFeatures(feature); 
    43         layer.drawFeature = function() { } 
     43        layer.drawFeature = function(feature, style) { 
     44            layer.styleMap.createSymbolizer(feature, style); 
     45        } 
    4446        control.select(feature); 
    45         t.eq(feature.style.strokeColor, OpenLayers.Feature.Vector.style['select'].strokeColor, "feature style is set to select style"); 
     47        t.eq(feature.renderIntent, "select", "render intent is set to select"); 
    4648        control.unselect(feature); 
    47         t.eq(feature.style.strokeColor, OpenLayers.Feature.Vector.style['default'].strokeColor, "feature style is set back to old style"); 
    48          
    49         // Don't ever overwrite my feature style with undefined properties from the selectStyle 
    50         feature.style = {externalGraphic: "foo.png", pointRadius: 39}; 
    51         control.selectStyle.pointRadius = undefined; 
    52         control.select(feature); 
    53         t.eq(feature.style.pointRadius, 39, "undefined style property inherited from original feature style"); 
    54         control.unselect(feature); 
    55          
    56         // Ok, that one went well. But I'm sure you cannot handle OL.Style. 
    57         feature.style = new OpenLayers.Style({externalGraphic: "foo.png", pointRadius: 39}); 
    58         control.select(feature); 
    59         t.eq(feature.style.pointRadius, 39, "undefined style property inherited from original feature style object"); 
    60         control.unselect(feature); 
    61          
    62         // Wow, but using OL.Style as selectStyle will break you. 
    63         control.selectStyle = new OpenLayers.Style({strokeColor: "green"}); 
    64         control.select(feature); 
    65         t.eq(feature.style.strokeColor, "green", "style correct if both feature.style and selectStyle are OL.Style"); 
    66         control.unselect(feature); 
    67          
    68         // Not bad, not bad. And what if I set feature.style back to a style hash? 
    69         feature.style = layer.style; 
    70         control.select(feature); 
    71         t.eq(feature.style.strokeColor, "green", "style still correct with only selectStyle being OL.Style"); 
    72         control.unselect(feature); 
    73         t.eq(feature.style.strokeColor, OpenLayers.Feature.Vector.style["default"].strokeColor, "style set back to original correctly"); 
     49        t.eq(feature.renderIntent, "default", "render intent is set back to default"); 
    7450    } 
    7551     
    7652    function test_Control_SelectFeature_clickFeature(t) { 

  • tests/Control/test_ModifyFeature.html

    old new  
    55     
    66    function test_ModifyFeature_constructor(t) { 
    77        t.plan(3); 
     8        var layer = {name: "foo", styleMap: {createSymbolizer: function(){}}};    
    89        var layer = { 
     10            styleMap: {createSymbolizer: function(){}}, 
    911            events: { 
    1012                on: function() {} 
    1113            } 
    …… 
    7779         */ 
    7880         
    7981        var control = new OpenLayers.Control.ModifyFeature({ 
    80             style: null, 
     82           styleMap: {createSymbolizer: function(){}}, 
    8183            events: { 
    8284                on: function() {} 
    8385            } 

  • tests/test_Style.html

    old new  
    1111        t.ok(style instanceof OpenLayers.Style,  
    1212             "new OpenLayers.Style returns object" );  
    1313        t.eq(style.foo, "bar", "constructor sets options correctly");  
    14         t.eq(typeof style.createStyle, "function", "style has a createStyle function");  
     14        t.eq(typeof style.createSymbolizer, "function", "style has a createSymbolizer function");  
    1515    } 
    1616     
    1717    function test_Style_create(t) { 
    …… 
    4545         
    4646        var feature = new OpenLayers.Feature.Vector( 
    4747                new OpenLayers.Geometry.Point(3,5), 
    48                 {"foo": "bar"}, 
    49                 style); 
     48                {"foo": "bar"}); 
    5049 
    5150        feature.fid = "1"; 
    5251        // for this fid, the above rule should apply 
     52         
     53        layer.styleMap = new OpenLayers.StyleMap(style); 
    5354                 
    5455        layer.addFeatures([feature]); 
    5556        map.addLayer(layer); 
    …… 
    5859        map.setCenter(new OpenLayers.LonLat(3,5), 10); 
    5960 
    6061        // at this scale, the feature should be green 
    61         var createdStyle = style.createStyle(feature); 
     62        var createdStyle = style.createSymbolizer(feature); 
    6263        t.eq(createdStyle.externalGraphic, "barbar.png", "Calculated property style correctly."); 
    6364        t.eq(createdStyle.display, "", "Feature is visible at scale "+map.getScale()); 
    6465        t.eq(createdStyle.fillColor, "green", "Point symbolizer from rule applied correctly."); 
    6566 
    6667        map.setCenter(new OpenLayers.LonLat(3,5), 9); 
    6768        // at this scale, the feature should be red 
    68         createdStyle = style.createStyle(feature); 
     69        createdStyle = style.createSymbolizer(feature); 
    6970        t.eq(createdStyle.display, "", "Feature is visible at scale "+map.getScale()); 
    7071        t.eq(createdStyle.fillColor, "yellow", "Point symbolizer from rule applied correctly."); 
    7172 
    7273        map.setCenter(new OpenLayers.LonLat(3,5), 8); 
    7374        // at this scale, the feature should be yellow 
    74         createdStyle = style.createStyle(feature); 
     75        createdStyle = style.createSymbolizer(feature); 
    7576        t.eq(createdStyle.display, "", "Feature is visible at scale "+map.getScale()); 
    7677        t.eq(createdStyle.fillColor, "red", "Point symbolizer from rule applied correctly."); 
    7778 
    7879        map.setCenter(new OpenLayers.LonLat(3,5), 7); 
    7980        // at this scale, the feature should be invisible 
    80         createdStyle = style.createStyle(feature); 
     81        createdStyle = style.createSymbolizer(feature); 
    8182        t.eq(createdStyle.display, "none", "Feature is invisible at scale "+map.getScale()); 
    8283        t.eq(createdStyle.fillColor, baseStyle.fillColor, "Point symbolizer from base style applied correctly."); 
    8384         
    8485        feature.fid = "2"; 
    8586        // now the rule should not apply 
    8687         
    87         createdStyle = style.createStyle(feature); 
     88        createdStyle = style.createSymbolizer(feature); 
    8889        t.eq(createdStyle.fillColor, baseStyle.fillColor, "Correct style for rule that does not apply to fid=\"2\"."); 
    8990    } 
    9091     
    91     function test_Style_createStyle(t) { 
     92    function test_Style_createSymbolizer(t) { 
    9293        t.plan(2); 
    9394        var style = new OpenLayers.Style(); 
    9495        var rule = new OpenLayers.Rule({ 
    …… 
    104105        style.applySymbolizer = function(r) { 
    105106            t.eq(r.id, rule.id, "(plain) applySymbolizer called with correct rule"); 
    106107        } 
    107         style.createStyle(new OpenLayers.Feature.Vector()); 
     108        style.createSymbolizer(new OpenLayers.Feature.Vector()); 
    108109 
    109110        rule.evaluate = function() {return false;}; 
    110111        style.applySymbolizer = function(r) { 
    111112            t.eq(r.id, elseRule.id, "(else) applySymbolizer called with correct rule"); 
    112113        } 
    113         style.createStyle(new OpenLayers.Feature.Vector()); 
     114        style.createSymbolizer(new OpenLayers.Feature.Vector()); 
    114115    } 
    115116     
    116117    function test_Style_context(t) { 
    …… 
    126127            symbolizer: {"Point": {externalGraphic: "${foo}.png"}}}); 
    127128        var style = new OpenLayers.Style(); 
    128129        style.addRules([rule]); 
    129         var styleHash = style.createStyle(new OpenLayers.Feature.Vector()); 
     130        var styleHash = style.createSymbolizer(new OpenLayers.Feature.Vector()); 
    130131        t.eq(styleHash.externalGraphic, "bar.png", "correctly evaluated rule against a custom context"); 
    131132    } 
    132133 

  • tests/Layer/test_Vector.html

    old new  
    6969             "OpenLayers.Layer.Vector.removeFeatures(layer.features) removes all feature from the features array"); 
    7070    } 
    7171     
    72     function test_Layer_Vector_addStyle (t) { 
    73         t.plan(2);     
    74         var layer = new OpenLayers.Layer.Vector(name); 
    75         var map = new OpenLayers.Map('map'); 
    76         map.addLayer(layer); 
    77         var g = new OpenLayers.Geometry.Point(0, 0); 
    78         var f = new OpenLayers.Feature.Vector(g); 
    79         t.eq( f.style,  null, "Feature style is null by default."); 
    80         layer.addFeatures(f); 
    81         t.ok( f.style != null, "Feature style is set by layer."); 
    82     } 
    83      
    8472    function test_Layer_Vector_drawFeature(t) { 
    8573        t.plan(4); 
    8674        var layer = new OpenLayers.Layer.Vector("Test Layer"); 
    …… 
    10694        t.ok(geometry.equals(f.geometry), 
    10795             "calls layer.renderer.drawFeature() with feature.geometry"); 
    10896         
    109         feature.style = 'exists'; 
     97        feature.style = {foo: "bar"}; 
    11098        layer.drawFeature(feature); 
    11199        t.eq(feature.style, s, 
    112100             "calls layer.renderer.drawFeature() with feature.style"); 
    113101         
    114102        feature.style = null; 
    115         layer.style = 'exists'; 
     103        layer.style = {foo: "bar"}; 
    116104        layer.drawFeature(feature); 
    117         t.eq(layer.style, s, 
     105        t.eq(layer.style.foo, s.foo, 
    118106             "given null feature style, uses layer style"); 
    119107 
    120         feature.style = 'exists'; 
    121         layer.style = 'exists'; 
    122         var customStyle = 'custom'; 
     108        feature.style = {foo1: "bar1"}; 
     109        layer.style = {foo2: "bar2"}; 
     110        var customStyle = {foo: "bar"}; 
    123111        layer.drawFeature(feature, customStyle); 
    124         t.eq(customStyle, s, 
     112        t.eq(customStyle.foo, s.foo, 
    125113             "given a custom style, renders with that"); 
    126114         
    127115    } 

  • tests/list-tests.html

    old new  
    4242    <li>test_Feature.html</li> 
    4343    <li>Feature/test_Vector.html</li> 
    4444    <li>test_Style.html</li> 
     45    <li>test_StyleMap.html</li> 
    4546    <li>test_Rule.html</li> 
    4647    <li>Rule/test_Comparison.html</li> 
    4748    <li>Rule/test_FeatureId.html</li> 

  • lib/OpenLayers/Control/SelectFeature.js

    old new  
    9595     * APIProperty: selectStyle  
    9696     * {Object} Hash of styles 
    9797     */ 
    98     selectStyle: OpenLayers.Feature.Vector.style['select'], 
     98    selectStyle: null, 
     99     
     100    /** 
     101     * Property: renderIntent 
     102     * {String} key used to retrieve the select style from the layer's 
     103     * style map. 
     104     */ 
     105    renderIntent: "select", 
    99106 
    100107    /** 
    101108     * Property: handler 
    …… 
    247254     * feature - {<OpenLayers.Feature.Vector>}  
    248255     */ 
    249256    select: function(feature) { 
    250         // Store feature style for restoration later 
    251         if(feature.originalStyle != feature.style) { 
    252             feature.originalStyle = feature.style; 
    253         } 
    254257        this.layer.selectedFeatures.push(feature); 
    255258 
    256         var selectStyle = this.selectStyle; 
    257  
    258         if (feature.style.CLASS_NAME == "OpenLayers.Style") { 
    259             feature.style = feature.style.createStyle(feature); 
    260         } else { 
    261             feature.style = OpenLayers.Util.extend({}, feature.style); 
    262         } 
    263         if (selectStyle.CLASS_NAME == "OpenLayers.Style") { 
    264             selectStyle = selectStyle.createStyle(feature); 
    265         } 
    266         OpenLayers.Util.extend(feature.style, selectStyle); 
    267  
    268         this.layer.drawFeature(feature); 
     259        var selectStyle = this.selectStyle || this.renderIntent; 
     260         
     261        this.layer.drawFeature(feature, selectStyle); 
    269262        this.layer.events.triggerEvent("featureselected", {feature: feature}); 
    270263        this.onSelect(feature); 
    271264    }, 
    …… 
    280273     */ 
    281274    unselect: function(feature) { 
    282275        // Store feature style for restoration later 
    283         if(feature.originalStyle != null) { 
    284             feature.style = feature.originalStyle; 
    285         } 
    286         this.layer.drawFeature(feature); 
     276        this.layer.drawFeature(feature, "default"); 
    287277        OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); 
    288278        this.layer.events.triggerEvent("featureunselected", {feature: feature}); 
    289279        this.onUnselect(feature); 

  • lib/OpenLayers/Control/ModifyFeature.js

    old new  
    167167        this.layer = layer; 
    168168        this.vertices = []; 
    169169        this.virtualVertices = []; 
    170         this.styleVirtual = OpenLayers.Util.extend({}, this.layer.style); 
     170        this.styleVirtual = OpenLayers.Util.extend({}, 
     171            this.layer.style || this.layer.styleMap.createSymbolizer()); 
    171172        this.styleVirtual.fillOpacity = 0.3; 
    172173        this.styleVirtual.strokeOpacity = 0.3; 
    173174        this.deleteCodes = [46, 100]; 
    …… 
    409410                this.layer.destroyFeatures(this.virtualVertices); 
    410411                this.virtualVertices = []; 
    411412            } 
    412             this.layer.drawFeature(this.feature, this.selectControl.selectStyle); 
     413            this.layer.drawFeature(this.feature, this.selectControl.renderIntent); 
    413414        } 
    414415        // keep the vertex on top so it gets the mouseout after dragging 
    415416        // this should be removed in favor of an option to draw under or 
    …… 
    496497                // remove the vertex 
    497498                vertex.geometry.parent.removeComponent(vertex.geometry); 
    498499                this.layer.drawFeature(this.feature, 
    499                                        this.selectControl.selectStyle); 
     500                                       this.selectControl.renderIntent); 
    500501                this.resetVertices(); 
    501502                this.onModification(this.feature); 
    502503            } 

  • lib/OpenLayers/Feature/Vector.js

    old new  
    5959     */ 
    6060    style: null, 
    6161     
     62    /** 
     63     * Property: renderIntent 
     64     * {String} rendering intent currently being used 
     65     */ 
     66    renderIntent: "default", 
     67 
    6268    /**  
    6369     * Constructor: OpenLayers.Feature.Vector 
    6470     * Create a vector feature.  

  • lib/OpenLayers/Style.js

    old new  
    4343    /** 
    4444     * Property: defaultStyle 
    4545     * {Object} hash of style properties to use as default for merging 
    46      * rule-based style symbolizers onto. If no rules are defined, createStyle 
    47      * will return this style. 
     46     * rule-based style symbolizers onto. If no rules are defined, 
     47     * createSymbolizer will return this style. 
    4848     */ 
    4949    defaultStyle: null, 
    5050     
    …… 
    5555     */ 
    5656    propertyStyles: null, 
    5757     
    58  
    5958    /**  
    6059     * Constructor: OpenLayers.Style 
    6160     * Creates a UserStyle. 
    …… 
    9695    }, 
    9796     
    9897    /** 
    99      * APIMethod: createStyle 
     98     * Method: createSymbolizer 
    10099     * creates a style by applying all feature-dependent rules to the base 
    101100     * style. 
    102101     *  
    103102     * Parameters: 
    104103     * feature - {<OpenLayers.Feature>} feature to evaluate rules for 
    105      * baseStyle - {Object} hash of styles feature styles to extend 
    106104     *  
    107105     * Returns: 
    108      * {<OpenLayers.Feature.Vector.style>} hash of feature styles 
     106     * {Object} symbolizer hash 
    109107     */ 
    110     createStyle: function(feature) { 
     108    createSymbolizer: function(feature) { 
    111109        var style = OpenLayers.Util.extend({}, this.defaultStyle); 
    112110         
    113111        var rules = this.rules; 

  • lib/OpenLayers/Layer/Vector.js

    old new  
    103103     * {Object} Default style for the layer 
    104104     */ 
    105105    style: null, 
     106     
     107    /** 
     108     * Property: styleMap 
     109     * {<OpenLayers.StyleMap>} 
     110     */ 
     111    styleMap: null, 
    106112 
    107113    /** 
    108114     * Property: renderers 
    …… 
    146152     * {<OpenLayers.Layer.Vector>} A new vector layer 
    147153     */ 
    148154    initialize: function(name, options) { 
    149  
    150         var defaultStyle = OpenLayers.Feature.Vector.style['default']; 
    151         this.style = OpenLayers.Util.extend({}, defaultStyle); 
    152  
    153155        OpenLayers.Layer.prototype.initialize.apply(this, arguments); 
    154156 
    155157        // allow user-set renderer, otherwise assign one 
    …… 
    163165            this.displayError(); 
    164166        }  
    165167 
     168        if (!this.styleMap) { 
     169            this.styleMap = new OpenLayers.StyleMap(); 
     170        } 
     171 
    166172        this.features = []; 
    167173        this.selectedFeatures = []; 
    168174    }, 
    …… 
    308314            //give feature reference to its layer 
    309315            feature.layer = this; 
    310316 
    311             if (!feature.style) { 
    312                 feature.style = OpenLayers.Util.extend({}, this.style); 
    313             } 
    314  
    315317            if (notify) { 
    316318                this.events.triggerEvent("beforefeatureadded", { 
    317319                    feature: feature 
    …… 
    399401     *  
    400402     * Parameters:  
    401403     * feature - {<OpenLayers.Feature.Vector>}  
    402      * style - {Object}  
     404     * style - {Object} Symbolizer hash or {String} renderIntent 
    403405     */ 
    404406    drawFeature: function(feature, style) { 
    405         if(style == null) { 
    406             if(feature.style) { 
    407                 style = feature.style; 
    408             } else { 
    409                 style = this.style; 
     407        if (typeof style != "object") { 
     408            var renderIntent = typeof style == "string" ? 
     409                style : feature.renderIntent; 
     410            if (this.style && !feature.style) { 
     411                feature.style = this.style; 
     412            }     
     413            style = feature.style; 
     414            if (!style) { 
     415                style = this.styleMap.createSymbolizer(feature, renderIntent); 
    410416            } 
    411417        } 
    412  
    413         if (style && style.CLASS_NAME &&  
    414             style.CLASS_NAME == "OpenLayers.Style") { 
    415             style = style.createStyle(feature); 
    416         }     
    417418         
    418419        this.renderer.drawFeature(feature, style); 
    419420    }, 

  • lib/OpenLayers.js

    old new  
    176176            "OpenLayers/Layer/PointTrack.js", 
    177177            "OpenLayers/Layer/GML.js", 
    178178            "OpenLayers/Style.js", 
     179            "OpenLayers/StyleMap.js", 
    179180            "OpenLayers/Rule.js", 
    180181            "OpenLayers/Rule/FeatureId.js", 
    181182            "OpenLayers/Rule/Logical.js", 

  • examples/wfs-scribble.html

    old new  
    3535            df = new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Path, {handlerOptions: {'freehand': false}, 'displayClass': 'olControlDrawFeaturePath'}); 
    3636            df.featureAdded = function(feature) { 
    3737              feature.state = OpenLayers.State.INSERT; 
    38               feature.style['strokeColor'] = "#ff0000"; 
     38              feature.style = OpenLayers.Util.extend({'strokeColor': '#ff0000'}, OpenLayers.Feature.Vector.style['default']); 
    3939              feature.layer.drawFeature(feature); 
    4040            } 
    4141            p.addControls([ new OpenLayers.Control.Navigation(), df ]); 

  • examples/georss-flickr.html

    old new  
    3131            // the thumbail attribute of the rss item 
    3232            style = new OpenLayers.Style({externalGraphic: "${thumbnail}"}); 
    3333             
     34            // make the thumbnails larger when we select them 
     35            selectStyle = new OpenLayers.Style({pointRadius: 35}); 
     36             
    3437            // create a rule with a point symbolizer that will make the thumbnail 
    3538            // larger if the title of the rss item conatins "powder" 
    3639            var rule = new OpenLayers.Rule.Comparison({ 
    …… 
    4750             
    4851            style.addRules([rule, elseRule]); 
    4952             
    50             markerLayer = new OpenLayers.Layer.Vector("", {style: style}); 
     53            markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({ 
     54                "default": style, 
     55                "select": selectStyle})}); 
    5156            map.addLayer(markerLayer); 
    5257             
    5358            // control that will show a popup when clicking on a thumbnail 
    5459            var popupControl = new OpenLayers.Control.SelectFeature(markerLayer, { 
    55               selectStyle: style, 
    5660              onSelect: function(feature) { 
    5761                  var pos = feature.geometry; 
    5862                  if (popup) { 

  • examples/openmnnd.html

    old new  
    1616        var map, layer; 
    1717 
    1818        function init(){ 
    19             OpenLayers.ProxyHost="/proxy/?url="; 
     19            OpenLayers.ProxyHost="/cgi-bin/proxy.cgi?url="; 
    2020            map = new OpenLayers.Map('map', {'maxResolution':'auto', maxExtent: new OpenLayers.Bounds(-203349.72008129774,4816309.33,1154786.8041952979,5472346.5), projection: 'EPSG:26915' } ); 
    2121            layer = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
    2222                    ["http://geoint.lmic.state.mn.us/cgi-bin/wms"], {layers: 'fsa'} ); 
    …… 
    2828 
    2929            map.addLayer(wms); 
    3030 
    31             wfs = new OpenLayers.Layer.WFS("Minnesota Streams (WFS)", wfs_url, {'typename':'streams'}, {ratio:1.25, minZoomLevel:4}); 
     31            wfs = new OpenLayers.Layer.WFS("Minnesota Streams (WFS)", wfs_url, {'typename':'streams'}, {ratio:1.25, minZoomLevel:4, style: OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default'])}); 
    3232 
    3333            // preFeatureInsert can be used to set style before the feature is drawn 
    34             wfs.preFeatureInsert= function(feature) { feature.style.strokeWidth="3"; feature.style.strokeColor="blue"; 
     34            wfs.preFeatureInsert= function(feature) {  
     35              feature.style = OpenLayers.Util.extend({}, feature.layer.style); 
     36              feature.style.strokeWidth="3"; feature.style.strokeColor="blue"; 
    3537            } 
    3638            wfs.onFeatureInsert = function(feature) { 
    3739              OpenLayers.Util.getElement('stream_features').innerHTML = feature.layer.features.length; 
    …… 
    5759            map.addLayer(pwfs); 
    5860 
    5961            rstyle = OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default']); 
    60             OpenLayers.Util.extend(rstyle, {'strokeColor': 'white', strokeWIdth: "4"}); 
     62            OpenLayers.Util.extend(rstyle, {'strokeColor': 'white', strokeWidth: "4"}); 
    6163            rwfs = new OpenLayers.Layer.WFS("Minnesota Roads (WFS)", wfs_url, {'typename':'roads'}, 
    6264              {ratio:1.25, minZoomLevel:7, extractAttributes: true, style:rstyle}); 
    6365 

  • examples/sld.html

    old new  
    3232             
    3333            styles = sld[1]; 
    3434             
    35             waterStyle = styles["WaterBodies"]; 
     35            // for the hover style, we do not want to use the SLD default as 
     36            // base style 
     37            styles["WaterBodies"]["Hover Styler"].defaultStyle = OpenLayers.Util.extend({}, 
     38                OpenLayers.Feature.Vector.style["select"]); 
    3639             
    3740            gmlLayers = [ 
    3841                    // use the sld UserStyle named "Default Styler" 
    3942                    new OpenLayers.Layer.GML("StateBoundaries", 
    4043                            "tasmania/TasmaniaStateBoundaries.xml", { 
    41                             style: waterStyle["default"]}), 
     44                            styleMap: new OpenLayers.StyleMap(styles["WaterBodies"])}), 
    4245                    new OpenLayers.Layer.GML("Roads", 
    4346                            "tasmania/TasmaniaRoads.xml", { 
    44                             style: waterStyle["default"]}), 
     47                            styleMap: new OpenLayers.StyleMap(styles["Roads"])}), 
    4548                    new OpenLayers.Layer.GML("WaterBodies", 
    4649                            "tasmania/TasmaniaWaterBodies.xml", { 
    47                             style: waterStyle["default"]}), 
     50                            styleMap: new OpenLayers.StyleMap(styles["WaterBodies"])}), 
    4851                    new OpenLayers.Layer.GML("Cities", 
    4952                            "tasmania/TasmaniaCities.xml", { 
    50                             style: waterStyle["default"]})]; 
     53                            styleMap: new OpenLayers.StyleMap(styles["Cities"])})]; 
    5154  
    52             // add the first layer with the style passed to the constructor 
    53             map.addLayer(gmlLayers[0]); 
    54             // add the other layers after setting the style using the 
    55             // setStyle() method, which will pick the correct default style 
    56             // from the styles hash we got back from 
    57             // OpenLayers.Format.SLD.read() 
    58             for (var i=1; i<gmlLayers.length; i++) { 
    59                 gmlLayers[i].style = styles[gmlLayers[i].name]["default"]; 
    60                       map.addLayer(gmlLayers[i]); 
    61                 gmlLayers[i].redraw(); 
     55            for (var i=0; i<gmlLayers.length; i++) { 
     56                map.addLayer(gmlLayers[i]); 
    6257            } 
    6358             
    64             // SLD can also be used for the SelectFeature control 
    65             waterStyle["Hover Styler"].defaultStyle = 
    66                     OpenLayers.Feature.Vector.style["select"]; 
    6759            hover = new OpenLayers.Control.SelectFeature(gmlLayers[2], { 
    68                     selectStyle: waterStyle["Hover Styler"], 
    69                     hover: true 
     60                    hover: true, 
     61                    renderIntent: "Hover Styler" 
    7062                }); 
    7163            map.addControl(hover); 
    7264            hover.activate(); 
    …… 
    7466         
    7567        // set a new style when the radio button changes 
    7668        function setStyle(styleName) { 
     69            gmlLayers[2].styleMap.styles["default"] = styles["WaterBodies"][styleName]; 
    7770            // change the style of the features of the WaterBodies layer 
    78             var features = gmlLayers[2].features; 
    79             for (var i=0; i<features.length; i++) { 
    80                 features[i].style = waterStyle[styleName]; 
    81             } 
    8271            gmlLayers[2].redraw(); 
    8372        } 
    8473    </script> 

  • examples/osm-layer.html

    old new  
    4747            gml.loadGML(); 
    4848        } 
    4949        function style_osm_feature(feature) { 
    50             feature.style.fill = "black"; 
     50            feature.style = OpenLayers.Util.extend({'fill':'black'}, OpenLayers.Feature.Vector.style['default']); 
    5151            if (feature.attributes.highway == "motorway") { 
    5252                feature.style.strokeColor = "blue"; 
    5353                feature.style.strokeWidth = 5;