OpenLayers OpenLayers

Ticket #628: no-more-feature-r3034.patch

File no-more-feature-r3034.patch, 53.2 kB (added by crschmidt, 2 years ago)

  • tests/test_Geometry.html

    old new  
    178178    }     
    179179 
    180180    function test_99_Geometry_destroy(t) { 
    181         t.plan( 3 ); 
     181        t.plan( 2 ); 
    182182 
    183183        var g = new OpenLayers.Geometry(); 
    184184        g.bounds = new OpenLayers.Bounds(); 
    185         g.feature = new Object(); 
    186185 
    187186        g_style_destroy = null; 
    188187        g.destroy(); 
    …… 
    190189        t.eq(g.id, null, "id nullified"); 
    191190 
    192191        t.eq(g.bounds, null, "bounds nullified"); 
    193         t.eq(g.feature, null, "feature reference nullified"); 
    194192 
    195193    } 
    196194 

  • tests/Feature/test_Vector.html

    old new  
    22<head> 
    33  <script src="../../lib/OpenLayers.js"></script> 
    44  <script type="text/javascript"><!-- 
    5     var isMozilla = (navigator.userAgent.indexOf("compatible") == -1); 
    65    var map;  
    76    var feature;  
    87     

  • tests/Layer/test_Vector.html

    old new  
    2121        var layer = new OpenLayers.Layer.Vector(name); 
    2222 
    2323        var point = new OpenLayers.Geometry.Point(-111.04, 45.68); 
    24         var pointFeature = new OpenLayers.Feature.Vector(layer, point); 
    25          
     24        var pointFeature = new OpenLayers.Feature.Vector(point); 
    2625        layer.addFeatures([pointFeature]); 
    2726         
    2827        t.eq(layer.features.length, 1, "OpenLayers.Layer.Vector.addFeatures adds something to the array"); 
    …… 
    6059        layer.addFeatures(f); 
    6160        t.ok( f.style != null, "Feature style is set by layer."); 
    6261    } 
     62     
     63    function test_Layer_Vector_drawFeature(t) { 
     64        t.plan(4); 
     65        var layer = new OpenLayers.Layer.Vector("Test Layer"); 
     66        var map = new OpenLayers.Map('map'); 
     67        map.addLayer(layer); 
     68        var geometry = new OpenLayers.Geometry.Point(10, 10); 
     69        var feature = new OpenLayers.Feature.Vector(geometry); 
     70         
     71        var f, s; 
     72        layer.renderer = { 
     73            drawFeature: function(feature, style) { 
     74                f = feature; 
     75                s = style; 
     76            } 
     77        }; 
    6378 
     79        layer.drawFeature(feature); 
     80        t.ok(geometry.equals(f.geometry), 
     81             "calls layer.renderer.drawFeature() with feature.geometry"); 
     82         
     83        feature.style = 'exists'; 
     84        layer.drawFeature(feature); 
     85        t.eq(feature.style, s, 
     86             "calls layer.renderer.drawFeature() with feature.style"); 
     87         
     88        feature.style = null; 
     89        layer.style = 'exists'; 
     90        layer.drawFeature(feature); 
     91        t.eq(layer.style, s, 
     92             "given null feature style, uses layer style"); 
     93 
     94        feature.style = 'exists'; 
     95        layer.style = 'exists'; 
     96        var customStyle = 'custom'; 
     97        layer.drawFeature(feature, customStyle); 
     98        t.eq(customStyle, s, 
     99             "given a custom style, renders with that"); 
     100         
     101    } 
     102 
    64103    function test_Layer_Vector_destroyFeatures (t) { 
    65104        t.plan(2);  
    66105        layer = new OpenLayers.Layer.Vector(name); 

  • lib/OpenLayers/Control/SelectFeature.js

    old new  
    2727     
    2828    /** 
    2929     * @type {Function} Optional function to be called when a feature is selected. 
    30      *                  The function should expect to be called with a geometry. 
     30     *                  The function should expect to be called with a feature. 
    3131     */ 
    3232    onSelect: function() {}, 
    3333 
    3434    /** 
    3535     * @type {Function} Optional function to be called when a feature is unselected. 
    36      *                  The function should expect to be called with a geometry. 
     36     *                  The function should expect to be called with a feature. 
    3737     */ 
    3838    onUnselect: function() {}, 
    3939 
    …… 
    7676 
    7777    /** 
    7878     * Called when the feature handler detects a mouse-down on a feature 
    79      * @param {OpenLayers.Geometry} 
     79     * @param {OpenLayers.Vector.Feature} 
    8080     */ 
    81     downFeature: function(geometry) { 
     81    downFeature: function(feature) { 
    8282        if(this.hover) { 
    8383            return; 
    8484        } 
    85         if(geometry.parent) { 
    86             geometry = geometry.parent; 
    87         } 
    8885        if (this.multiple) { 
    89             if(OpenLayers.Util.indexOf(this.layer.selectedFeatures, geometry.feature) > -1) { 
    90                 this.unselect(geometry); 
     86            if(OpenLayers.Util.indexOf(this.layer.selectedFeatures, feature) > -1) { 
     87                this.unselect(feature); 
    9188            } else { 
    92                 this.select(geometry); 
     89                this.select(feature); 
    9390            } 
    9491        } else { 
    95             if(OpenLayers.Util.indexOf(this.layer.selectedFeatures, geometry.feature) > -1) { 
    96                 this.unselect(geometry); 
     92            if(OpenLayers.Util.indexOf(this.layer.selectedFeatures, feature) > -1) { 
     93                this.unselect(feature); 
    9794            } else { 
    9895                if (this.layer.selectedFeatures) { 
    9996                    for (var i = 0; i < this.layer.selectedFeatures.length; i++) { 
    100                         this.unselect(this.layer.selectedFeatures[i].geometry); 
     97                        this.unselect(this.layer.selectedFeatures[i]); 
    10198                    } 
    10299                } 
    103                 this.select(geometry); 
     100                this.select(feature); 
    104101            } 
    105102        } 
    106103    }, 
    …… 
    108105    /** 
    109106     * Called when the feature handler detects a mouse-over on a feature. 
    110107     * Only responds if this.hover is true. 
    111      * @param {OpenLayers.Geometry} 
     108     * @param {OpenLayers.Feature.Vector} 
    112109     */ 
    113     overFeature: function(geometry) { 
     110    overFeature: function(feature) { 
    114111        if(!this.hover) { 
    115112            return; 
    116113        } 
    117         if(geometry.parent) { 
    118             geometry = geometry.parent; 
     114        if(!(OpenLayers.Util.indexOf(this.layer.selectedFeatures, feature) > -1)) { 
     115            this.select(feature); 
    119116        } 
    120         if(!(OpenLayers.Util.indexOf(this.layer.selectedFeatures, geometry.feature) > -1)) { 
    121             this.select(geometry); 
    122         } 
    123117    }, 
    124118 
    125119    /** 
    126120     * Called when the feature handler detects a mouse-out on a feature. 
    127121     * Only responds if this.hover is true. 
    128      * @param {OpenLayers.Geometry} 
     122     * @param {OpenLayers.Feature.Vector} 
    129123     */ 
    130     outFeature: function(geometry) { 
     124    outFeature: function(feature) { 
    131125        if(!this.hover) { 
    132126            return; 
    133127        } 
    134         if(geometry.parent) { 
    135             geometry = geometry.parent; 
    136         } 
    137         this.unselect(geometry); 
     128        this.unselect(feature); 
    138129    }, 
    139130     
    140131    /** 
    141132     * Add feature to the layer's selectedFeature array, render the feature as 
    142133     * selected, and call the onSelect function. 
    143      * @param {OpenLayers.Geometry} geometry 
     134     * @param {OpenLayers.Feature.Vector} feature 
    144135     */ 
    145     select: function(geometry) { 
     136    select: function(feature) { 
    146137        // Store feature style for restoration later 
    147         if(geometry.feature.originalStyle == null) { 
    148             geometry.feature.originalStyle = geometry.feature.style; 
     138        if(feature.originalStyle == null) { 
     139            feature.originalStyle = feature.style; 
    149140        } 
    150         this.layer.selectedFeatures.push(geometry.feature); 
    151         this.layer.renderer.drawGeometry(geometry, this.selectStyle); 
    152         this.onSelect(geometry); 
     141        this.layer.selectedFeatures.push(feature); 
     142        this.layer.drawFeature(feature, this.selectStyle); 
     143        this.onSelect(feature); 
    153144    }, 
    154145 
    155146    /** 
    156147     * Remove feature from the layer's selectedFeature array, render the feature as 
    157148     * normal, and call the onUnselect function. 
    158      * @param {OpenLayers.Geometry} geometry 
     149     * @param {OpenLayers.Feature.Vector} feature 
    159150     */ 
    160     unselect: function(geometry) { 
     151    unselect: function(feature) { 
    161152        // Store feature style for restoration later 
    162         if(geometry.feature.originalStyle == null) { 
    163             geometry.feature.originalStyle = geometry.feature.style; 
     153        if(feature.originalStyle == null) { 
     154            feature.originalStyle = feature.style; 
    164155        } 
    165         this.layer.renderer.drawGeometry(geometry, geometry.feature.originalStyle); 
    166         OpenLayers.Util.removeItem(this.layer.selectedFeatures, geometry.feature); 
    167         this.onUnselect(geometry); 
     156        this.layer.drawFeature(feature, feature.originalStyle); 
     157        OpenLayers.Util.removeItem(this.layer.selectedFeatures, feature); 
     158        this.onUnselect(feature); 
    168159    }, 
    169160 
    170161    /** Set the map property for the control.  

  • lib/OpenLayers/Renderer.js

    old new  
    107107    }, 
    108108     
    109109    /**  
     110     * Draw the feature.  The optional style argument can be used 
     111     * to override the feature's own style.  This method should only 
     112     * be called from layer.drawFeature().  Implemented by a renderer 
     113     * subclass. 
     114     * 
     115     * @param {OpenLayers.Feature.Vector} feature  
     116     * @param {Object} style 
     117     */ 
     118    drawFeature: function(feature, style) {}, 
     119 
     120    /**  
    110121     * virtual function 
    111122     *  
    112      * Draw a geometry on the specified layer. 
     123     * Draw a geometry.  This should only be called from the renderer itself. 
     124     * Use layer.drawFeature() from outside the renderer. 
    113125     * 
    114126     * @param geometry {OpenLayers.Geometry} 
    115127     * @param style {Object} 
     128     * @private 
    116129     */ 
    117130    drawGeometry: function(geometry, style) {}, 
    118131         
    …… 
    127140    /** 
    128141     * virtual function 
    129142     *  
    130      * Returns a geometry from an event that happened on a layer.   
    131      * How this happens is specific to the renderer. 
     143     * Returns a feature id from an event on the renderer.   
     144     * How this happens is specific to the renderer.  This should be 
     145     * called from layer.getFeatureFromEvent(). 
    132146     *  
    133147     * @param evt {OpenLayers.Event} 
    134148     * 
    135      * @returns A geometry from an event that happened on a layer 
    136      * @type OpenLayers.Geometry 
     149     * @returns A feature id or null 
     150     * @type String 
     151     * @private 
    137152     */ 
    138     getGeometryFromEvent: function(evt) {}, 
     153    getFeatureIdFromEvent: function(evt) {}, 
    139154     
    140155    /** 
    141156     * virtual function 

  • lib/OpenLayers/Format/GML.js

    old new  
    165165            } 
    166166        } 
    167167         
    168         feature.setGeometry(geom, false);  
     168        feature.geometry = geom;  
    169169        if (this.extractAttributes) { 
    170170            feature.attributes = this.parseAttributes(xmlNode); 
    171171        }     

  • lib/OpenLayers/Format/KML.js

    old new  
    8080            } 
    8181        } 
    8282         
    83         feature.setGeometry(geom); 
     83        feature.geometry = geom; 
    8484        feature.attributes = this.parseAttributes(xmlNode); 
    8585         
    8686        return feature; 

  • lib/OpenLayers/Feature/Vector.js

    old new  
    4646    initialize: function(geometry, data, style) { 
    4747        OpenLayers.Feature.prototype.initialize.apply(this, [null, null, data]); 
    4848        this.lonlat = null; 
    49         this.setGeometry(geometry); 
     49        this.geometry = geometry; 
    5050        this.state = null; 
    5151        if (data) { 
    5252            OpenLayers.Util.extend(this.attributes, data); 
    …… 
    126126    }, 
    127127 
    128128    /** 
    129      * Set a feature id to the feature 
    130      * 
    131      * @param {String} feature id to set 
    132      */ 
    133     setFid: function(fid) { 
    134         this.fid = fid; 
    135     }, 
    136  
    137     /** 
    138      * Set a geometry to the feature 
    139      * 
    140      * @param {OpenLayers.Geometry} geometry to set 
    141      * @param {Boolean} recurse Recursively set feature (for components) 
    142      */ 
    143     setGeometry: function(geometry, recurse) { 
    144         if(geometry) { 
    145             this.geometry = geometry; 
    146             this.geometry.feature = this; 
    147             if (recurse != false) { 
    148                 this._setGeometryFeatureReference(this.geometry, this); 
    149             }     
    150         } 
    151     }, 
    152      
    153     /** 
    154      * Sets recursively the reference to the feature in the geometry 
    155      * 
    156      * @param {OpenLayers.Geometry} 
    157      * @param {OpenLayers.Feature} 
    158      */ 
    159     _setGeometryFeatureReference: function(geometry, feature) { 
    160         geometry.feature = feature; 
    161         if (geometry.components) { 
    162             for (var i = 0; i < geometry.components.length; i++) { 
    163                 this._setGeometryFeatureReference(geometry.components[i], feature); 
    164             } 
    165         } 
    166     }, 
    167      
    168     /** 
    169      * Adds attributes an attributes object to the feature. 
    170      * (should not be in geometry but in feature class) 
    171      * 
    172      * @param {Attributes} attributes 
    173      */ 
    174     setAttributes: function(attributes) { 
    175         this.attributes=attributes; 
    176     }, 
    177  
    178     /** 
    179129     * @param {OpenLayers.LonLat} lonlat 
    180130     * @param {float} toleranceLon Optional tolerance in Geometric Coords 
    181131     * @param {float} toleranceLat Optional tolerance in Geographic Coords 

  • lib/OpenLayers/Renderer/Elements.js

    old new  
    6161     
    6262    /** 
    6363     * Remove all the elements from the root 
    64      * 
     64     * @private 
    6565     */     
    6666    clear: function() { 
    6767        if (this.root) { 
    …… 
    7171        } 
    7272    }, 
    7373 
    74     /** 
    75      * Cycle through the rendered nodes and reproject them (this should be  
    76      *  called when the extent or size has changed); 
    77      * 
    78      * @param {OpenLayers.Bounds} extent 
    79      */ 
    80     reproject: function(extent) { 
    81  
    82         for (var i = 0; i < this.root.childNodes.length; i++) { 
    83             var node = this.root.childNodes[i]; 
    84             //reproject node 
    85             //  for the moment, this only really happens so as to reset 
    86             //  the heaviness of the line relative to the resolution and 
    87             //  the size of the circle for the Point object 
    88             this.reprojectNode(node); 
    89         } 
    90     }, 
    91  
    9274    /** This function is in charge of asking the specific renderer which type 
    9375     *   of node to create for the given geometry. All geometries in an  
    9476     *   Elements-based renderer consist of one node and some attributes. We 
    …… 
    10082     *  
    10183     * @returns The corresponding node type for the specified geometry 
    10284     * @type String 
     85     * @private 
    10386     */ 
    10487    getNodeType: function(geometry) { }, 
    105          
     88 
    10689    /**  
    107      * Draw the geometry on the specified layer, creating new nodes,  
    108      * setting paths, setting style. 
     90     * Draw the feature.  The optional style argument can be used 
     91     * to override the feature's own style.  This method should only 
     92     * be called from layer.drawFeature(). 
    10993     * 
     94     * @param {OpenLayers.Feature.Vector} feature  
     95     * @param {Object} style 
     96     */ 
     97    drawFeature: function(feature, style) { 
     98        if(style == null) { 
     99            style = feature.style; 
     100        } 
     101        this.drawGeometry(feature.geometry, style, feature.id); 
     102    }, 
     103 
     104    /**  
     105     * Draw the geometry, creating new nodes, setting paths, setting style, 
     106     * setting featureId on the node.  This method should only be called 
     107     * by the renderer itself. 
     108     * 
    110109     * @param {OpenLayers.Geometry} geometry  
    111      * @param {Object} style  
     110     * @param {Object} style 
     111     * @param {String} featureId 
     112     * @private 
    112113     */ 
    113     drawGeometry: function(geometry, style) { 
     114    drawGeometry: function(geometry, style, featureId) { 
    114115 
    115116        if ((geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint") || 
    116117            (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString") || 
    117118            (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon")) { 
    118119            for (var i = 0; i < geometry.components.length; i++) { 
    119                 this.drawGeometry(geometry.components[i], style); 
     120                this.drawGeometry(geometry.components[i], style, featureId); 
    120121            } 
    121122            return; 
    122123        }; 
    …… 
    124125        //first we create the basic node and add it to the root 
    125126        var nodeType = this.getNodeType(geometry); 
    126127        var node = this.nodeFactory(geometry.id, nodeType, geometry); 
    127         node.geometry = geometry; 
    128         node.olStyle = style; 
     128        node._featureId = featureId; 
     129        node._geometryClass = geometry.CLASS_NAME; 
     130        node._style = style; 
    129131        this.root.appendChild(node); 
    130132         
    131133        //now actually draw the node, and style it 
    132         this.drawGeometryNode(node); 
     134        this.drawGeometryNode(node, geometry); 
    133135    }, 
    134136 
    135137    /**  
    136138     * Given a node, draw a geometry on the specified layer. 
     139     * node and geometry are required arguments, style is optional. 
     140     * This method is only called by the render itself. 
    137141     * 
    138142     * @param {DOMElement} node 
    139143     * @param {OpenLayers.Geometry} geometry  
    140      * @param {Object} style  
     144     * @param {Object} style 
     145     * @private 
    141146     */ 
    142147    drawGeometryNode: function(node, geometry, style) { 
    143         geometry = geometry || node.geometry; 
    144         style = style || node.olStyle; 
     148        style = style || node._style; 
    145149 
    146150        var options = { 
    147151            'isFilled': true, 
    …… 
    171175                break; 
    172176        } 
    173177 
    174         node.olStyle = style;  
    175         node.olOptions = options;  
     178        node._style = style;  
     179        node._options = options;  
    176180 
    177181        //set style 
    178         this.setStyle(node); 
     182        //TBD simplify this 
     183        this.setStyle(node, style, options, geometry); 
    179184    }, 
    180185     
    181186    /**  
    182187     * virtual functions for drawing different Geometries.  
    183188     * These should all be implemented by subclasses. 
     189     * These methods are only called by the render itself. 
    184190     * 
    185191     * @param {DOMElement} node 
    186      * @param {OpenLayers.Geometry} geometry  
     192     * @param {OpenLayers.Geometry} geometry 
     193     * @private 
    187194     */ 
    188195    drawPoint: function(node, geometry) {}, 
    189196    drawLineString: function(node, geometry) {}, 
    …… 
    200207     * @returns A geometry from an event that happened on a layer 
    201208     * @type OpenLayers.Geometry 
    202209     */ 
    203     getGeometryFromEvent: function(evt) { 
     210    getFeatureIdFromEvent: function(evt) { 
    204211        var node = evt.target || evt.srcElement; 
    205         var geometry = node.geometry ? node.geometry : null 
    206         return geometry; 
     212        return node._featureId; 
    207213    }, 
    208214 
    209215    /** Erase a geometry from the renderer. In the case of a multi-geometry,  

  • lib/OpenLayers/Renderer/VML.js

    old new  
    8989     *  
    9090     * @returns The corresponding node type for the specified geometry 
    9191     * @type String 
     92     * @private 
    9293     */ 
    9394    getNodeType: function(geometry) { 
    9495        var nodeType = null; 
    …… 
    113114    }, 
    114115 
    115116    /** 
    116      * @param {DOMElement} node 
    117      */ 
    118     reprojectNode: function(node) { 
    119         //we have to reprojectNode the entire node since the coordinates  
    120         // system has changed 
    121         this.drawGeometryNode(node);   
    122     }, 
    123  
    124  
    125     /** 
    126117     * Use to set all the style attributes to a VML node. 
    127118     * 
    128119     * @param {DOMElement} node 
    129120     * @param {Object} style 
    130121     * @param {Object} options 
    131122     * @option isFilled {boolean}  
    132      * @option isStroked {boolean}  
     123     * @option isStroked {boolean} 
     124     * @param {OpenLayers.Geometry} geometry 
     125     * @private 
    133126     */ 
    134     setStyle: function(node, style, options) { 
    135         style = style  || node.olStyle; 
    136         options = options || node.olOptions; 
     127    setStyle: function(node, style, options, geometry) { 
     128        style = style  || node._style; 
     129        options = options || node._options; 
    137130         
    138         if (node.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { 
    139             this.drawCircle(node, node.geometry, style.pointRadius); 
     131        if (node._geometryClass == "OpenLayers.Geometry.Point") { 
     132            this.drawCircle(node, geometry, style.pointRadius); 
    140133        } 
    141134 
    142135      //fill 
    …… 
    186179     *    
    187180     * @param {DOMElement} node 
    188181     * @param {OpenLayers.Geometry} geometry 
     182     * @private 
    189183     */ 
    190184    setNodeDimension: function(node, geometry) { 
    191185 
    …… 
    257251    /** 
    258252     * @returns The specific render engine's root element 
    259253     * @type DOMElement 
     254     * @private 
    260255     */ 
    261256    createRenderRoot: function() { 
    262257        var id = this.container.id + "_vmlRoot"; 
    …… 
    267262    /** 
    268263     * @returns The main root element to which we'll add vectors 
    269264     * @type DOMElement 
     265     * @private 
    270266     */ 
    271267    createRoot: function() { 
    272268        var id = this.container.id + "_root"; 
    …… 
    282278 
    283279    /** 
    284280     * @param {DOMElement} node 
    285      * @param {OpenLayers.Geometry} geometry  
     281     * @param {OpenLayers.Geometry} geometry 
     282     * @private 
    286283     */ 
    287284    drawPoint: function(node, geometry) { 
    288         this.drawCircle(node, node.geometry, 1); 
     285        this.drawCircle(node, geometry, 1); 
    289286    }, 
    290287 
    291288    /** Size and Center a circle given geometry (x,y center) and radius 
    …… 
    293290     * @param {DOMElement} node 
    294291     * @param {OpenLayers.Geometry} geometry 
    295292     * @param {float} radius 
     293     * @private 
    296294     */ 
    297295    drawCircle: function(node, geometry, radius) { 
    298296 
    …… 
    311309    /** 
    312310     * @param {DOMElement} node 
    313311     * @param {OpenLayers.Geometry} geometry 
     312     * @private 
    314313     */ 
    315314    drawLineString: function(node, geometry) { 
    316315        this.drawLine(node, geometry, false); 
    …… 
    319318    /** 
    320319     * @param {DOMElement} node 
    321320     * @param {OpenLayers.Geometry} geometry 
     321     * @private 
    322322     */ 
    323323    drawLinearRing: function(node, geometry) { 
    324324        this.drawLine(node, geometry, true); 
    …… 
    328328     * @param {DOMElement} node 
    329329     * @param {OpenLayers.Geometry} geometry 
    330330     * @param {Boolean} closeLine Close the line? (make it a ring?) 
     331     * @private 
    331332     */ 
    332333    drawLine: function(node, geometry, closeLine) { 
    333334 
    …… 
    352353    /** 
    353354     * @parm {DOMElement} node 
    354355     * @param {OpenLayers.Geometry} geometry 
     356     * @private 
    355357     */ 
    356358    drawPolygon: function(node, geometry) { 
    357359        this.setNodeDimension(node, geometry); 
    …… 
    380382    /** 
    381383     * @parm {DOMElement} node 
    382384     * @param {OpenLayers.Geometry} geometry 
     385     * @private 
    383386     */ 
    384387    drawRectangle: function(node, geometry) { 
    385388        var resolution = this.getResolution(); 
    …… 
    395398    /** 
    396399     * @parm {DOMElement} node 
    397400     * @param {OpenLayers.Geometry} geometry 
     401     * @private 
    398402     */ 
    399403    drawCurve: function(node, geometry) { 
    400404        this.setNodeDimension(node, geometry); 
    …… 
    421425    /** 
    422426     * @parm {DOMElement} node 
    423427     * @param {OpenLayers.Geometry} geometry 
     428     * @private 
    424429     */ 
    425430    drawSurface: function(node, geometry) { 
    426431 

  • lib/OpenLayers/Renderer/SVG.js

    old new  
    4646 
    4747    /** 
    4848     * @param {OpenLayers.Bounds} extent 
     49     * @private 
    4950     */ 
    5051    setExtent: function(extent) { 
    5152        OpenLayers.Renderer.Elements.prototype.setExtent.apply(this,  
    …… 
    6465     * sets the size of the drawing surface 
    6566     * 
    6667     * @param size {OpenLayers.Size} the size of the drawing surface 
     68     * @private 
    6769     */ 
    6870    setSize: function(size) { 
    6971        OpenLayers.Renderer.prototype.setSize.apply(this, arguments); 
    …… 
    8082     *  
    8183     * @returns The corresponding node type for the specified geometry 
    8284     * @type String 
     85     * @private 
    8386     */ 
    8487    getNodeType: function(geometry) { 
    8588        var nodeType = null; 
    …… 
    106109        } 
    107110        return nodeType; 
    108111    }, 
    109        
    110     /** 
    111      * @param {DOMElement} node 
    112      */ 
    113     reprojectNode: function(node) { 
    114         this.drawGeometryNode(node);   
    115     }, 
    116      
     112 
    117113    /**  
    118114     * Use to set all the style attributes to a SVG node. 
    119115     *  
    …… 
    125121     * @param {Object} options 
    126122     * @option isFilled {boolean}  
    127123     * @option isStroked {boolean}  
     124     * @private 
    128125     */ 
    129126    setStyle: function(node, style, options) { 
    130         style = style  || node.olStyle; 
    131         options = options || node.olOptions; 
     127        style = style  || node._style; 
     128        options = options || node._options; 
    132129 
    133  
    134         if (node.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") { 
     130        if (node._geometryClass == "OpenLayers.Geometry.Point") { 
    135131            node.setAttributeNS(null, "r", style.pointRadius); 
    136132        } 
    137133         
    …… 
    192188    /** 
    193189     * @returns The specific render engine's root element 
    194190     * @type DOMElement 
     191     * @private 
    195192     */ 
    196193    createRenderRoot: function() { 
    197194        var id = this.container.id + "_svgRoot"; 
    …… 
    202199    /** 
    203200     * @returns The main root element to which we'll add vectors 
    204201     * @type DOMElement 
     202     * @private 
    205203     */ 
    206204    createRoot: function() { 
    207205        var id = this.container.id + "_root"; 
    …… 
    224222    /**  
    225223     * @param {DOMElement} node 
    226224     * @param {OpenLayers.Geometry} geometry 
     225     * @private 
    227226     */ 
    228227    drawPoint: function(node, geometry) { 
    229228        this.drawCircle(node, geometry, 1); 
    …… 
    233232     * @param {DOMElement} node 
    234233     * @param {OpenLayers.Geometry} geometry 
    235234     * @param {float} radius 
     235     * @private 
    236236     */ 
    237237    drawCircle: function(node, geometry, radius) { 
    238238        var resolution = this.getResolution(); 
    …… 
    244244    /**  
    245245     * @param {DOMElement} node 
    246246     * @param {OpenLayers.Geometry} geometry 
     247     * @private 
    247248     */ 
    248249    drawLineString: function(node, geometry) { 
    249250        node.setAttributeNS(null, "points", this.getComponentsString(geometry.components));   
    …… 
    252253    /**  
    253254     * @param {DOMElement} node 
    254255     * @param {OpenLayers.Geometry} geometry 
     256     * @private 
    255257     */ 
    256258    drawLinearRing: function(node, geometry) { 
    257259        node.setAttributeNS(null, "points", this.getComponentsString(geometry.components)); 
    …… 
    260262    /**  
    261263     * @param {DOMElement} node 
    262264     * @param {OpenLayers.Geometry} geometry 
     265     * @private 
    263266     */ 
    264267    drawPolygon: function(node, geometry) { 
    265268        var d = ""; 
    …… 
    279282    /**  
    280283     * @param {DOMElement} node 
    281284     * @param {OpenLayers.Geometry} geometry 
     285     * @private 
    282286     */ 
    283287    drawRectangle: function(node, geometry) { 
    284288        node.setAttributeNS(null, "x", geometry.x / resolution); 
    …… 
    291295    /**  
    292296     * @param {DOMElement} node 
    293297     * @param {OpenLayers.Geometry} geometry 
     298     * @private 
    294299     */ 
    295300    drawCurve: function(node, geometry) { 
    296301        var d = null; 
    …… 
    309314    /**  
    310315     * @param {DOMElement} node 
    311316     * @param {OpenLayers.Geometry} geometry 
     317     * @private 
    312318     */ 
    313319    drawSurface: function(node, geometry) { 
    314320 
    …… 
    329335 
    330336    /**  
    331337     * @param {Array} components array of points 
     338     * @private 
    332339     */ 
    333340    getComponentsString: function(components) { 
    334341        var strings = []; 
    …… 
    341348     
    342349    /**  
    343350     * @param {OpenLayers.Geometry.Point} point 
     351     * @private 
    344352     */ 
    345353    getShortString: function(point) { 
    346354        var resolution = this.getResolution(); 

  • lib/OpenLayers/Geometry.js

    old new  
    1919 
    2020    /** @type OpenLayers.Bounds */ 
    2121    bounds: null, 
    22      
    23     /**  
    24      * Cross reference back to the feature that owns this geometry so 
    25      * that that the feature can be identified after the geometry has been 
    26      * selected by a mouse click. 
    27      *  
    28      * @type OpenLayers.Feature */ 
    29     feature: null, 
    3022 
    3123    /** 
    3224     * @constructor 
    …… 
    4234        this.id = null; 
    4335 
    4436        this.bounds = null; 
    45         this.feature = null; 
    4637 
    4738    }, 
    4839     

  • lib/OpenLayers/Layer/Vector.js

    old new  
    2121    /** @type Boolean */ 
    2222    isVector: true, 
    2323 
    24     /** @type {Array(OpenLayer.Feature.Vector)} */ 
     24    /** @type Array(OpenLayer.Feature.Vector) */ 
    2525    features: null, 
    2626     
    27     /** @type {Array(OpenLayers.Feature.Vector)} */ 
     27    /** @type Array(OpenLayers.Feature.Vector) */ 
    2828    selectedFeatures: [], 
    2929 
    3030    /** @type {Boolean} */ 
    31     editing: false, 
    32  
    33     /** @type {Boolean} */ 
    34     editable: false, 
    35  
    36     /** @type {Boolean} */ 
    3731    reportError: true,  
    3832 
    3933    /** @type {Object} */ 
    …… 
    7569     * Options renderer {Object}: Typically SVGRenderer or VMLRenderer. 
    7670     */ 
    7771    initialize: function(name, options) { 
     72        this.style = OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default']); 
    7873        OpenLayers.Layer.prototype.initialize.apply(this, arguments); 
    7974 
    8075        // allow user-set renderer, otherwise assign one 
    …… 
    10297        //              calling feature[i].destroy() here.  
    10398        this.features = null; 
    10499        this.selectedFeatures = null; 
    105         this.editing = null; 
    106         this.editable = null; 
    107100        if (this.renderer) { 
    108101            this.renderer.destroy(); 
    109102        } 
    …… 
    172165    /** Reset the vector layer's div so that it once again is lined up with  
    173166     *   the map. Notify the renderer of the change of extent, and in the 
    174167     *   case of a change of zoom level (resolution), have the  
    175      *   renderer reproject. 
     168     *   renderer redraw features. 
    176169     *  
    177170     *  If the layer has not yet been drawn, cycle through the layer's  
    178171     *   features and draw each one. 
    …… 
    191184            this.renderer.setExtent(extent); 
    192185        } 
    193186 
    194         if (zoomChanged) { 
    195             this.renderer.reproject(); 
    196         } 
    197          
    198         if (!this.drawn) { 
     187        if (!this.drawn || zoomChanged) { 
    199188            this.drawn = true; 
    200189            for(var i = 0; i < this.features.length; i++) { 
    201190                var feature = this.features[i]; 
    202                 this.renderer.drawGeometry(feature.geometry, feature.style); 
     191                this.drawFeature(feature); 
    203192            } 
    204193        }     
    205194    }, 
    …… 
    228217            feature.layer = this; 
    229218 
    230219            if (!feature.style) { 
    231                 if (this.style) { 
    232                     feature.style = OpenLayers.Util.extend({}, this.style); 
    233                 } else { 
    234                     feature.style = OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default']); 
    235                 }     
     220                feature.style = OpenLayers.Util.extend({}, this.style); 
    236221            } 
    237222 
    238223            this.preFeatureInsert(feature); 
    239224 
    240225            if (this.drawn) { 
    241                 this.renderer.drawGeometry(feature.geometry, feature.style); 
     226                this.drawFeature(feature); 
    242227            } 
    243228             
    244229            this.onFeatureInsert(feature); 
    …… 
    271256    }, 
    272257 
    273258    /** 
    274      * @param {String} fid 
     259     * Draw (or redraw) a feature on the layer.  If the optional style argument 
     260     * is included, this style will be used.  If no style is included, the 
     261     * feature's style will be used.  If the feature doesn't have a style, 
     262     * the layer's style will be used. 
     263     *  
     264     * @param {OpenLayers.Feature.Vector} feature 
    275265     * @param {Object} style 
    276266     */ 
    277     redrawFeature: function(fid, style) { 
    278         for (var i = 0; i < this.features.length; i++) { 
    279             var feature = this.features[i]; 
    280             if (feature.fid == fid) { 
    281                 this.renderer.drawGeometry(feature.geometry, style); 
     267    drawFeature: function(feature, style) { 
     268        if(style == null) { 
     269            if(feature.style) { 
     270                style = feature.style; 
     271            } else { 
     272                style = this.style; 
    282273            } 
    283274        } 
     275        this.renderer.drawFeature(feature, style); 
    284276    }, 
    285277     
    286278    /** 
    287      * Start editing the layer 
    288      *  
    289      * @returns Whether or not the layer is editable 
    290      * @type Boolean 
     279     * Given an event, return a feature if the event occurred over one. 
     280     * Otherwise, return null. 
     281     * 
     282     * @param {Event} 
     283     * @type OpenLayers.Feature.Vector 
     284     * @return A feature if one was under the event 
    291285     */ 
    292     unlock: function() { 
    293         if(this.editable) { 
    294             this.editing = true; 
    295         } 
    296         return this.editable; 
     286    getFeatureFromEvent: function(evt) { 
     287        var featureId = this.renderer.getFeatureIdFromEvent(evt); 
     288        return this.getFeatureById(featureId); 
    297289    }, 
    298  
     290     
    299291    /** 
    300      * Stop editing the layer 
     292     * Given a feature id, return the feature if it exists in the features array 
    301293     *  
    302      * @return Whether or not the layer *was* editing  
    303      * HACK HACK This return value seems wierd to me. 
    304      * @type Boolean 
     294     * @param String featureId 
     295     * @type OpenLayers.Feature.Vector 
     296     * @return A feature corresponding to the given featureId 
    305297