OpenLayers OpenLayers

Ticket #1120: stylemap.diff

File stylemap.diff, 33.6 kB (added by ahocevar, 7 months ago)

  • 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_StyleMap.html

    old new  
     1<html>  
     2<head>  
     3    <script src="../lib/OpenLayers.js"></script>  
     4    <script type="text/javascript"> 
     5 
     6    function test_StyleMap_constructor(t) {  
     7        t.plan(6); 
     8          
     9        var options = {'foo': 'bar'};  
     10        var styleMap = new OpenLayers.StyleMap(null, options);  
     11        t.ok(styleMap instanceof OpenLayers.StyleMap,  
     12             "new OpenLayers.StyleMap returns object" );  
     13        t.eq(styleMap.foo, "bar", "constructor sets options correctly");  
     14 
     15        var style = new OpenLayers.Style(); 
     16        var styleMap = new OpenLayers.StyleMap(style); 
     17        t.eq(styleMap.styles["default"].defaultStyle.strokeColor, style.defaultStyle.strokeColor, "default style set correctly from style object"); 
     18 
     19        var style = {strokeColor: "blue"}; 
     20        var styleMap = new OpenLayers.StyleMap(style); 
     21        t.eq(styleMap.styles["default"].defaultStyle.strokeColor, "blue", "default style set correctly from style hash"); 
     22         
     23        var style = { 
     24            "default": new OpenLayers.Style({strokeColor: "yellow"}), 
     25            "select": {strokeColor: "blue"}}; 
     26        var styleMap = new OpenLayers.StyleMap(style); 
     27        t.eq(styleMap.styles["default"].defaultStyle.strokeColor, "yellow", "default style set correctly from a mixed hash of renderIntents"); 
     28        t.eq(styleMap.styles["select"].defaultStyle.strokeColor, "blue", "select style set correctly from a mixed hash of renderIntents"); 
     29    } 
     30     
     31    function test_StyleMap_destroy(t) { 
     32        t.plan(2); 
     33        var styleMap = new OpenLayers.StyleMap(); 
     34        t.ok(styleMap.styles["default"], "Got a default style after initialisation"); 
     35        styleMap.destroy(); 
     36        t.ok(!styleMap.styles, "StyleMap styles successfully destroyed"); 
     37    } 
     38     
     39    </script>  
     40</head>  
     41<body>  
     42  <div id="map" style="width:500px;height:500px"></div> 
     43</body>  
     44</html>  

  • 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/Map.js

    old new  
    12751275    pan: function(dx, dy, options) { 
    12761276         
    12771277        if (!options) { 
    1278             options = {animate: true} 
     1278            options = {} 
    12791279        }     
    12801280        // getCenter 
    12811281        var centerPx = this.getViewPortPxFromLonLat(this.getCenter()); 

  • lib/OpenLayers/Rule/Comparison.js

    old new  
    3333    /** 
    3434     * APIProperty: property 
    3535     * {String} 
    36      * name of the context property to compare 
     36     * name of the context proeprty to compare 
    3737     */ 
    3838    property: null, 
    3939     

  • lib/OpenLayers/StyleMap.js

    old new  
     1/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD 
     2 * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the 
     3 * full text of the license. */ 
     4 
     5/** 
     6 * @requires OpenLayers/Style.js 
     7 * @requires OpenLayers/Feature/Vector.js 
     8 */ 
     9  
     10/** 
     11 * Class: OpenLayers.StyleMap 
     12 */ 
     13OpenLayers.StyleMap = OpenLayers.Class({ 
     14     
     15    /** 
     16     * Property: styles 
     17     * Hash of {<OpenLayers.Style>}, keyed by names of well known 
     18     * rendering intents (e.g. "default", "temporary", "select"). 
     19     */ 
     20    styles: null, 
     21     
     22    /** 
     23     * Property: extendDefault 
     24     * {Boolean} if true, every render intent will extend the symbolizers 
     25     * specified for the "default" intent. Otherwise, every rendering intent 
     26     * is treated as a completely independent symbolizer. 
     27     */ 
     28    extendDefault: true, 
     29     
     30    /** 
     31     * Constructor: OpenLayers.StyleMap 
     32     *  
     33     * Parameters: 
     34     * style   - {Object} Optional. Either a style hash, or a style object, or 
     35     *           a hash of style objects (style hashes) keyed by rendering 
     36     *           intent 
     37     * options - {Object} optional hash of additional options for this 
     38     *           instance 
     39     */ 
     40    initialize: function (style, options) { 
     41        this.styles = { 
     42            "default": new OpenLayers.Style( 
     43                OpenLayers.Feature.Vector.style["default"]), 
     44            "select": new OpenLayers.Style( 
     45                OpenLayers.Feature.Vector.style["select"]), 
     46            "temporary": new OpenLayers.Style( 
     47                OpenLayers.Feature.Vector.style["temporary"]) 
     48        }; 
     49         
     50        // take whatever the user passed as style parameter and convert it 
     51        // into parts of stylemap. 
     52        if(style instanceof OpenLayers.Style) { 
     53            // user passed a style object 
     54            this.styles["default"] = style; 
     55        } else if(typeof style == "object") { 
     56            for(var key in style) { 
     57                if(style[key] instanceof OpenLayers.Style) { 
     58                    // user passed a hash of style objects 
     59                    this.styles[key] = style[key]; 
     60                } else if(typeof style[key] == "object") { 
     61                    // user passsed a hash of style hashes 
     62                    this.styles[key] = new OpenLayers.Style(style[key]); 
     63                } else { 
     64                    // user passed a style hash (i.e. symbolizer) 
     65                    this.styles["default"] = new OpenLayers.Style(style); 
     66                    break; 
     67                } 
     68            } 
     69        } 
     70        OpenLayers.Util.extend(this, options); 
     71    }, 
     72 
     73    /** 
     74     * Method: destroy 
     75     */ 
     76    destroy: function() { 
     77        for(var key in this.styles) { 
     78            this.styles[key].destroy(); 
     79        } 
     80        this.styles = null; 
     81    }, 
     82     
     83    /** 
     84     * Method: createSymbolizer 
     85     * Creates the symbolizer for a feature for a render intent. 
     86     *  
     87     * Parameters: 
     88     * feature - {<OpenLayers.Feature>} 
     89     * intent  - {String} 
     90     */ 
     91    createSymbolizer: function(feature, intent) { 
     92        if(!feature) { 
     93            feature = new OpenLayers.Feature.Vector(); 
     94        } 
     95        if(!this.styles[intent]) { 
     96            intent = "default"; 
     97        } 
     98        feature.renderIntent = intent; 
     99        var defaultSymbolizer = {}; 
     100        if(this.extendDefault && intent != "default") { 
     101            defaultSymbolizer = this.styles["default"].createSymbolizer(feature); 
     102        } 
     103        return OpenLayers.Util.extend(defaultSymbolizer, 
     104            this.styles[intent].createSymbolizer(feature)); 
     105    }, 
     106 
     107    CLASS_NAME: "OpenLayers.StyleMap" 
     108}); 

  • 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            style = feature.style || this.style; 
     411            if (!style) { 
     412                style = this.styleMap.createSymbolizer(feature, renderIntent); 
    410413            } 
    411414        } 
    412  
    413         if (style && style.CLASS_NAME &&  
    414             style.CLASS_NAME == "OpenLayers.Style") { 
    415             style = style.createStyle(feature); 
    416         }     
    417415         
    418416        this.renderer.drawFeature(feature, style); 
    419417    }, 

  • lib/OpenLayers.js

    old new  
    175175            "OpenLayers/Layer/PointTrack.js", 
    176176            "OpenLayers/Layer/GML.js", 
    177177            "OpenLayers/Style.js", 
     178            "OpenLayers/StyleMap.js", 
    178179            "OpenLayers/Rule.js", 
    179180            "OpenLayers/Rule/FeatureId.js", 
    180181            "OpenLayers/Rule/Logical.js", 

  • 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/fullScreen.html

    old new  
    2323            function init(){ 
    2424                map = new OpenLayers.Map('map'); 
    2525 
    26             var ol_wms = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
    27                     "http://labs.metacarta.com/wms/vmap0", 
    28                     {layers: 'basic'} ); 
    2926            var jpl_wms = new OpenLayers.Layer.WMS( "NASA Global Mosaic", 
    3027                "http://t1.hypercube.telascience.org/cgi-bin/landsat7",  
    3128                {layers: "landsat7"}); 

  • 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>