OpenLayers OpenLayers

Changeset 6079

Show
Ignore:
Timestamp:
02/08/08 01:05:43 (1 year ago)
Author:
ahocevar
Message:

first working version of StyleMap

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/ahocevar/styleMap/openlayers/examples/georss-flickr.html

    r5978 r6079  
    4747            style.addRules([rule, elseRule]); 
    4848             
    49             markerLayer = new OpenLayers.Layer.Vector("", {style: style}); 
     49            markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap(style)}); 
    5050            map.addLayer(markerLayer); 
    5151             

  • sandbox/ahocevar/styleMap/openlayers/examples/sld.html

    r5925 r6079  
    3232            styles = sld[1]; 
    3333             
    34             waterStyle = styles["WaterBodies"]; 
     34            // for the hover style, we do not want to use the SLD default as 
     35            // base style 
     36            styles["WaterBodies"]["select"].defaultStyle = OpenLayers.Util.extend({}, 
     37                OpenLayers.Feature.Vector.style["select"]); 
    3538             
    3639            gmlLayers = [ 
    …… 
    3841                    new OpenLayers.Layer.GML("StateBoundaries", 
    3942                            "tasmania/TasmaniaStateBoundaries.xml", { 
    40                             style: waterStyle["default"]}), 
     43                            styleMap: new OpenLayers.StyleMap(styles["WaterBodies"])}), 
    4144                    new OpenLayers.Layer.GML("Roads", 
    4245                            "tasmania/TasmaniaRoads.xml", { 
    43                             style: waterStyle["default"]}), 
     46                            styleMap: new OpenLayers.StyleMap(styles["Roads"])}), 
    4447                    new OpenLayers.Layer.GML("WaterBodies", 
    4548                            "tasmania/TasmaniaWaterBodies.xml", { 
    46                             style: waterStyle["default"]}), 
     49                            styleMap: new OpenLayers.StyleMap(styles["WaterBodies"])}), 
    4750                    new OpenLayers.Layer.GML("Cities", 
    4851                            "tasmania/TasmaniaCities.xml", { 
    49                             style: waterStyle["default"]})]; 
     52                            styleMap: new OpenLayers.StyleMap(styles["Cities"])})]; 
    5053  
    51             // add the first layer with the style passed to the constructor 
    52             map.addLayer(gmlLayers[0]); 
    53             // add the other layers after setting the style using the 
    54             // setStyle() method, which will pick the correct default style 
    55             // from the styles hash we got back from 
    56             // OpenLayers.Format.SLD.read() 
    57             for (var i=1; i<gmlLayers.length; i++) { 
    58                 gmlLayers[i].style = styles[gmlLayers[i].name]["default"]; 
    59                       map.addLayer(gmlLayers[i]); 
    60                 gmlLayers[i].redraw(); 
     54            for (var i=0; i<gmlLayers.length; i++) { 
     55                map.addLayer(gmlLayers[i]); 
    6156            } 
    6257             
    63             // SLD can also be used for the SelectFeature control 
    64             waterStyle["Hover Styler"].defaultStyle = 
    65                     OpenLayers.Feature.Vector.style["select"]; 
    6658            hover = new OpenLayers.Control.SelectFeature(gmlLayers[2], { 
    67                     selectStyle: waterStyle["Hover Styler"], 
    6859                    hover: true 
    6960                }); 
    …… 
    7465        // set a new style when the radio button changes 
    7566        function setStyle(styleName) { 
     67            gmlLayers[2].styleMap.styles["default"] = styles["WaterBodies"][styleName]; 
    7668            // change the style of the features of the WaterBodies layer 
    77             var features = gmlLayers[2].features; 
    78             for (var i=0; i<features.length; i++) { 
    79                 features[i].style = waterStyle[styleName]; 
    80             } 
    8169            gmlLayers[2].redraw(); 
    8270        } 

  • sandbox/ahocevar/styleMap/openlayers/examples/tasmania/sld-tasmania.xml

    r5964 r6079  
    6262 
    6363    <sld:UserStyle> 
    64       <sld:Name>Hover Styler</sld:Name> 
     64      <sld:Name>select</sld:Name> 
    6565      <sld:Title>Hover Styler</sld:Title> 
    6666      <sld:Abstract></sld:Abstract> 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers.js

    r5921 r6079  
    175175            "OpenLayers/Layer/GML.js", 
    176176            "OpenLayers/Style.js", 
     177            "OpenLayers/StyleMap.js", 
    177178            "OpenLayers/Rule.js", 
    178179            "OpenLayers/Rule/FeatureId.js", 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Control/SelectFeature.js

    r5959 r6079  
    9696     * {Object} Hash of styles 
    9797     */ 
    98     selectStyle: OpenLayers.Feature.Vector.style['select'], 
     98    selectStyle: null, 
    9999 
    100100    /** 
    …… 
    248248     */ 
    249249    select: function(feature) { 
    250         // Store feature style for restoration later 
    251         if(feature.originalStyle != feature.style) { 
    252             feature.originalStyle = feature.style; 
    253         } 
    254250        this.layer.selectedFeatures.push(feature); 
    255251 
    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); 
     252        var selectStyle = this.selectStyle || "select"; 
     253         
     254        this.layer.drawFeature(feature, selectStyle); 
    269255        this.onSelect(feature); 
    270256    }, 
    …… 
    280266    unselect: function(feature) { 
    281267        // Store feature style for restoration later 
    282         if(feature.originalStyle != null) { 
    283             feature.style = feature.originalStyle; 
    284         } 
    285         this.layer.drawFeature(feature); 
     268        this.layer.drawFeature(feature, "default"); 
    286269        OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); 
    287270        this.onUnselect(feature); 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Feature/Vector.js

    r5909 r6079  
    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 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Format/SLD.js

    r5978 r6079  
    344344            for (var i=0; i<filters.length; i++) { 
    345345                if (filters[i].nodeType == 1) { 
    346                     rule.children.push(this.parseFilter(filters[i])); 
     346                    rule.rules.push(this.parseFilter(filters[i])); 
    347347                } 
    348348            } 
    …… 
    358358            for (var i=0; i<filters.length; i++) { 
    359359                if (filters[i].nodeType == 1) { 
    360                     rule.children.push(this.parseFilter(filters[i])); 
     360                    rule.rules.push(this.parseFilter(filters[i])); 
    361361                } 
    362362            } 
    …… 
    369369            var rule = new OpenLayers.Rule.Logical( 
    370370                    {type: OpenLayers.Rule.Logical.NOT}); 
    371             rule.children.push(this.parseFilter(filter[0])); 
     371            rule.rules.push(this.parseFilter(filter[0])); 
    372372            return rule; 
    373373        } 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Layer/Vector.js

    r5614 r6079  
    6464     */ 
    6565    style: null, 
     66     
     67    /** 
     68     * Property: styleMap 
     69     * {<OpenLayers.StyleMap>} 
     70     */ 
     71    styleMap: null, 
    6672 
    6773    /** 
    …… 
    107113     */ 
    108114    initialize: function(name, options) { 
    109  
    110         var defaultStyle = OpenLayers.Feature.Vector.style['default']; 
    111         this.style = OpenLayers.Util.extend({}, defaultStyle); 
    112  
    113115        OpenLayers.Layer.prototype.initialize.apply(this, arguments); 
    114116 
    …… 
    123125            this.displayError(); 
    124126        }  
     127 
     128        if (!this.styleMap) { 
     129            this.styleMap = new OpenLayers.StyleMap(); 
     130        } 
    125131 
    126132        this.features = []; 
    …… 
    269275            feature.layer = this; 
    270276 
    271             if (!feature.style) { 
    272                 feature.style = OpenLayers.Util.extend({}, this.style); 
    273             } 
    274  
    275277            if (notify) { 
    276278                this.preFeatureInsert(feature); 
    …… 
    350352     * Parameters:  
    351353     * feature - {<OpenLayers.Feature.Vector>}  
    352      * style - {Object}  
     354     * style - {Object} Symbolizer hash or {String} renderIntent 
    353355     */ 
    354356    drawFeature: function(feature, style) { 
    355         if(style == null) { 
    356             if(feature.style) { 
    357                 style = feature.style; 
    358             } else { 
    359                 style = this.style; 
    360             } 
    361         } 
    362  
    363         if (style && style.CLASS_NAME &&  
    364             style.CLASS_NAME == "OpenLayers.Style") { 
    365             style = style.createStyle(feature); 
    366         }     
     357        if (typeof style != "object") { 
     358            var renderIntent = typeof style == "string" ? 
     359                style : "default"; 
     360            style = feature.style || this.style; 
     361            if (!style) { 
     362                style = this.styleMap.createSymbolizer(feature, renderIntent); 
     363            } 
     364        } 
    367365         
    368366        this.renderer.drawFeature(feature, style); 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Rule.js

    r5978 r6079  
    2020     */ 
    2121    name: 'default', 
     22     
     23    /** 
     24     * Property: context 
     25     * {Object} An optional object with properties that the rule and its 
     26     * symbolizers' property values should be evaluatad against. If no 
     27     * context is specified, feature.attributes will be used 
     28     */ 
     29    context: null, 
    2230 
    2331    /** 
    …… 
    94102     */ 
    95103    evaluate: function(feature) { 
    96         // Default rule always applies. Subclasses will want to override this. 
    97         return true; 
     104        var context = this.getContext(feature); 
     105        var applies = true; 
     106 
     107        if (this.minScaleDenominator || this.maxScaleDenominator) { 
     108            var scale = feature.layer.map.getScale(); 
     109        } 
     110         
     111        // check if within minScale/maxScale bounds 
     112        if (this.minScaleDenominator) { 
     113            applies = scale >= OpenLayers.Style.createLiteral( 
     114                    this.minScaleDenominator, context); 
     115        } 
     116        if (applies && this.maxScaleDenominator) { 
     117            applies = scale < OpenLayers.Style.createLiteral( 
     118                    this.maxScaleDenominator, context); 
     119        } 
     120 
     121        return applies; 
    98122    }, 
    99123     
     124    /** 
     125     * Method: getContext 
     126     * Gets the context for evaluating this rule 
     127     *  
     128     * Paramters: 
     129     * feature - {<OpenLayers.Feature>} feature to take the context from if 
     130     *           none is specified. 
     131     */ 
     132    getContext: function(feature) { 
     133        var context = this.context; 
     134        if (!context) { 
     135            context = feature.attributes || feature.data; 
     136        } 
     137        return context; 
     138    }, 
     139         
    100140    CLASS_NAME: "OpenLayers.Rule" 
    101141}); 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Rule/Comparison.js

    r5614 r6079  
    3434     * APIProperty: property 
    3535     * {String} 
    36      * name of the feature attribute to compare 
     36     * name of the context proeprty to compare 
    3737     */ 
    3838    property: null, 
    …… 
    8585    /** 
    8686     * APIMethod: evaluate 
    87      * evaluates this rule for a specific feature 
    88      *  
    89      * Parameters: 
    90      * feature - {<OpenLayers.Feature>} feature to apply the rule to. 
     87     * evaluates this rule for a specific context 
     88     *  
     89     * Parameters: 
     90     * context - {Object} context to apply the rule to. 
    9191     *  
    9292     * Returns: 
    …… 
    9494     */ 
    9595    evaluate: function(feature) { 
    96         var attributes = feature.attributes || feature.data; 
     96        if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) { 
     97            return false; 
     98        } 
     99        var context = this.getContext(feature); 
    97100        switch(this.type) { 
    98101            case OpenLayers.Rule.Comparison.EQUAL_TO: 
    …… 
    101104            case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO: 
    102105            case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO: 
    103                 return this.binaryCompare(feature, this.property, this.value); 
     106                return this.binaryCompare(context, this.property, this.value); 
    104107             
    105108            case OpenLayers.Rule.Comparison.BETWEEN: 
    106109                var result = 
    107                         attributes[this.property] > this.lowerBoundary; 
     110                        context[this.property] > this.lowerBoundary; 
    108111                result = result && 
    109                         attributes[this.property] < this.upperBoundary; 
     112                        context[this.property] < this.upperBoundary; 
    110113                return result; 
    111114            case OpenLayers.Rule.Comparison.LIKE: 
    112115                var regexp = new RegExp(this.value, 
    113116                                "gi"); 
    114                 return regexp.test(attributes[this.property]);  
     117                return regexp.test(context[this.property]);  
    115118        } 
    116119    }, 
    …… 
    166169     *  
    167170     * Parameters: 
    168      * feature  - {<OpenLayers.Feature>} 
     171     * context  - {Object} 
    169172     * property - {String} or {Number} 
    170173     * value    - {String} or {Number}, same as property 
    …… 
    173176     * {boolean} 
    174177     */ 
    175     binaryCompare: function(feature, property, value) { 
    176         var attributes = feature.attributes || feature.data; 
     178    binaryCompare: function(context, property, value) { 
    177179        switch (this.type) { 
    178180            case OpenLayers.Rule.Comparison.EQUAL_TO: 
    179                 return attributes[property] == value; 
     181                return context[property] == value; 
    180182            case OpenLayers.Rule.Comparison.NOT_EQUAL_TO: 
    181                 return attributes[property] != value; 
     183                return context[property] != value; 
    182184            case OpenLayers.Rule.Comparison.LESS_THAN: 
    183                 return attributes[property] < value; 
     185                return context[property] < value; 
    184186            case OpenLayers.Rule.Comparison.GREATER_THAN: 
    185                 return attributes[property] > value; 
     187                return context[property] > value; 
    186188            case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO: 
    187                 return attributes[property] <= value; 
     189                return context[property] <= value; 
    188190            case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO: 
    189                 return attributes[property] >= value; 
     191                return context[property] >= value; 
    190192        }       
    191193    }, 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Rule/FeatureId.js

    r5614 r6079  
    5454     */ 
    5555    evaluate: function(feature) { 
     56        if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) { 
     57            return false; 
     58        } 
    5659        for (var i=0; i<this.fids.length; i++) { 
    5760            var fid = feature.fid || feature.id; 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Rule/Logical.js

    r5614 r6079  
    2121     * {Array(<OpenLayers.Rule>)} child rules for this rule 
    2222     */ 
    23     children: null,  
     23    rules: null,  
    2424      
    2525    /** 
    …… 
    4444     */ 
    4545    initialize: function(options) { 
    46         this.children = []; 
     46        this.rules = []; 
    4747        OpenLayers.Rule.prototype.initialize.apply(this, [options]); 
    4848    }, 
    …… 
    5353     */ 
    5454    destroy: function() { 
    55         for (var i=0; i<this.children.length; i++) { 
    56             this.children[i].destroy(); 
     55        for (var i=0; i<this.rules.length; i++) { 
     56            this.rules[i].destroy(); 
    5757        } 
    58         this.children = null; 
     58        this.rules = null; 
    5959        OpenLayers.Rule.prototype.destroy.apply(this, arguments); 
    6060    }, 
    …… 
    7171     */ 
    7272    evaluate: function(feature) { 
     73        if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) { 
     74            return false; 
     75        } 
    7376        switch(this.type) { 
    7477            case OpenLayers.Rule.Logical.AND: 
    75                 for (var i=0; i<this.children.length; i++) { 
    76                     if (this.children[i].evaluate(feature) == false) { 
     78                for (var i=0; i<this.rules.length; i++) { 
     79                    if (this.rules[i].evaluate(feature) == false) { 
    7780                        return false; 
    7881                    } 
    …… 
    8184                 
    8285            case OpenLayers.Rule.Logical.OR: 
    83                 for (var i=0; i<this.children.length; i++) { 
    84                     if (this.children[i].evaluate(feature) == true) { 
     86                for (var i=0; i<this.rules.length; i++) { 
     87                    if (this.rules[i].evaluate(feature) == true) { 
    8588                        return true; 
    8689                    } 
    …… 
    8992             
    9093            case OpenLayers.Rule.Logical.NOT: 
    91                 return (!this.children[0].evaluate(feature)); 
     94                return (!this.rules[0].evaluate(feature)); 
    9295        } 
    9396    }, 

  • sandbox/ahocevar/styleMap/openlayers/lib/OpenLayers/Style.js

    r5978 r6079  
    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, 
    …… 
    5656    propertyStyles: null, 
    5757     
    58  
    5958    /**  
    6059     * Constructor: OpenLayers.Style 
    …… 
    9796     
    9897    /** 
    99      * APIMethod: createStyle 
     98     * Method: createSymbolizer 
    10099     * creates a style by applying all feature-dependent rules to the base 
    101100     * style. 
    …… 
    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 
    109      */ 
    110     createStyle: function(feature) { 
     106     * {Object} symbolizer hash 
     107     */ 
     108    createSymbolizer: function(feature) { 
    111109        var style = OpenLayers.Util.extend({}, this.defaultStyle); 
    112110         
    113111        var rules = this.rules; 
    114112 
    115         var rule; 
     113        var rule, context; 
    116114        var elseRules = []; 
    117115        var appliedRules = false; 
    118116        for(var i=0; i<rules.length; i++) { 
    119117            rule = rules[i]; 
     118            context = rule.context; 
     119            if (!context) { 
     120                context = feature.attributes || feature.data; 
     121            } 
    120122            // does the rule apply? 
    121123            var applies = rule.evaluate(feature); 
    122124             
    123             if (rule.minScaleDenominator || rule.maxScaleDenominator) { 
    124                 var scale = feature.layer.map.getScale(); 
    125             } 
    126              
    127             // check if within minScale/maxScale bounds 
    128             if (rule.minScaleDenominator) { 
    129                 applies = scale >= OpenLayers.Style.createLiteral( 
    130                         rule.minScaleDenominator, feature); 
    131             } 
    132             if (applies && rule.maxScaleDenominator) { 
    133                 applies = scale < OpenLayers.Style.createLiteral( 
    134                         rule.maxScaleDenominator, feature); 
    135             } 
    136  
    137125            if(applies) { 
    138126                if(rule instanceof OpenLayers.Rule && rule.elseFilter) { 
    …… 
    140128                } else { 
    141129                    appliedRules = true; 
    142                     this.applySymbolizer(rule, style, feature); 
     130                    this.applySymbolizer(rule, style, feature, context); 
    143131                } 
    144132            } 
    …… 
    149137            appliedRules = true; 
    150138            for(var i=0; i<elseRules.length; i++) { 
    151                 this.applySymbolizer(elseRules[i], style, feature); 
    152             } 
    153         } 
    154  
    155         // calculate literals for all styles in the propertyStyles cache 
    156         this.createLiterals(style, feature); 
     139                this.applySymbolizer(elseRules[i], style, feature, context); 
     140            } 
     141        } 
    157142 
    158143        // don't display if there were rules but none applied 
    …… 
    173158     * style - {Object} 
    174159     * feature - {<OpenLayer.Feature.Vector>} 
     160     * context - {Object} 
    175161     * 
    176162     * Returns: 
    177163     * {Object} A style with new symbolizer applied. 
    178164     */ 
    179     applySymbolizer: function(rule, style, feature) { 
     165    applySymbolizer: function(rule, style, feature, context) { 
    180166        var symbolizerPrefix = feature.geometry ? 
    181167                this.getSymbolizerPrefix(feature.geometry) : 
    182168                OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; 
    183169 
     170        var symbolizer = rule.symbolizer[symbolizerPrefix]; 
     171 
    184172        // merge the style with the current style 
    185         var symbolizer = rule.symbolizer[symbolizerPrefix]; 
    186         return OpenLayers.Util.extend(style, symbolizer); 
     173        return this.createLiterals( 
     174                OpenLayers.Util.extend(style, symbolizer), context); 
    187175    }, 
    188176     
    …… 
    195183     * style   - {Object} style to create literals for. Will be modified 
    196184     *           inline. 
    197      * feature - {<OpenLayers.Feature.Vector>} feature to take properties from 
     185     * context - {Object} context to take property values from. Defaults to 
     186     *           feature.attributes (or feature.data, if attributes are not 
     187     *           available) 
    198188     *  
    199189     * Returns; 
    200190     * {Object} the modified style 
    201191     */ 
    202     createLiterals: function(style, feature) { 
     192    createLiterals: function(style, context) { 
    203193        for (var i in this.propertyStyles) { 
    204             style[i] = OpenLayers.Style.createLiteral(style[i], feature); 
     194            style[i] = OpenLayers.Style.createLiteral(style[i], context); 
    205195        } 
    206196        return style; 
    …… 
    303293 *         will be replaced by the value of the "bar" attribute of the passed 
    304294 *         feature. 
    305  * feature {<OpenLayers.Feature>} feature to take attribute values from 
     295 * context {Object} context to take attribute values from 
    306296 *  
    307297 * Returns: 
    …… 
    310300 * attribute named "bar" with the value "valueOfBar". 
    311301 */ 
    312 OpenLayers.Style.createLiteral = function(value, feature) { 
     302OpenLayers.Style.createLiteral = function(value, context) { 
    313303    if (typeof value == "string" && value.indexOf("${") != -1) { 
    314         var attributes = feature.attributes || feature.data; 
    315         value = OpenLayers.String.format(value, attributes) 
     304        value = OpenLayers.String.format(value, context) 
    316305        value = isNaN(value) ? value : parseFloat(value); 
    317306    } 

  • sandbox/ahocevar/styleMap/openlayers/tests/Control/test_SelectFeature.html

    r5959 r6079  
    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(); 
    …… 
    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     

  • sandbox/ahocevar/styleMap/openlayers/tests/Layer/test_Vector.html

    r5476 r6079  
    6868        t.ok(layer.features.length == 0, 
    6969             "OpenLayers.Layer.Vector.removeFeatures(layer.features) removes all feature from the features array"); 
    70     } 
    71      
    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."); 
    8270    } 
    8371     
    …… 
    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, 
    …… 
    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         

  • sandbox/ahocevar/styleMap/openlayers/tests/Rule/test_Logical.html

    r5429 r6079  
    2020        var rule = new OpenLayers.Rule.Logical(); 
    2121        rule.destroy(); 
    22         t.eq(rule.children, null, "children array nulled properly"); 
     22        t.eq(rule.rules, null, "rules array nulled properly"); 
    2323    } 
    2424     
    …… 
    2828        var rule = new OpenLayers.Rule.Logical({ 
    2929                type: OpenLayers.Rule.Logical.NOT}); 
    30         rule.children.push(new OpenLayers.Rule()); 
     30        rule.rules.push(new OpenLayers.Rule()); 
    3131         
    3232        var feature = new OpenLayers.Feature.Vector(); 

  • sandbox/ahocevar/styleMap/openlayers/tests/list-tests.html

    r5990 r6079  
    4242    <li>Feature/test_Vector.html</li> 
    4343    <li>test_Style.html</li> 
     44    <li>test_StyleMap.html</li> 
    4445    <li>test_Rule.html</li> 
    4546    <li>Rule/test_Comparison.html</li> 

  • sandbox/ahocevar/styleMap/openlayers/tests/test_Style.html

    r5978 r6079  
    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     
    …… 
    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]); 
    …… 
    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()); 
    …… 
    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."); 
    …… 
    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."); 
    …… 
    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."); 
    …… 
    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(); 
    …… 
    105106            t.eq(r.id, rule.id, "(plain) applySymbolizer called with correct rule"); 
    106107        } 
    107         style.createStyle(new OpenLayers.Feature.Vector());