OpenLayers OpenLayers

Ticket #628: no.more.geometry.feature.patch

File no.more.geometry.feature.patch, 53.2 kB (added by tschaub, 1 year ago)

end of geometry.feature

  • examples/openmnnd.html

    old new  
    9999                } 
    100100            } 
    101101        } 
    102         var displayedGeom = null; 
    103         function feature_info_hover(geometry) { 
    104             if(geometry.parent) { 
    105                 geometry = geometry.parent; 
    106             } 
    107             if (displayedGeom != geometry &&  
    108                (!geometry.feature.layer.selectedFeatures.length ||  
    109                (geometry.feature.layer.selectedFeatures[0].geometry == geometry))) { 
    110             feature_info(geometry); 
    111             displaydGeom = geometry; 
     102        var displayedFeature = null; 
     103        function feature_info_hover(feature) { 
     104            if (displayedFeature != feature &&  
     105               (!feature.layer.selectedFeatures.length ||  
     106               (feature.layer.selectedFeatures[0] == feature))) { 
     107            feature_info(feature); 
     108            displayedFeature = feature; 
    112109           } 
    113110        }     
    114         function feature_info(geometry) { 
    115             if(geometry.parent) { 
    116                 geometry = geometry.parent; 
    117             } 
     111        function feature_info(feature) { 
    118112            var html = "<ul>"; 
    119             for(var i in geometry.feature.attributes) 
    120                html += "<li><b>" + i + "</b>: "+  geometry.feature.attributes[i] + "</li>"; 
     113            for(var i in feature.attributes) 
     114               html += "<li><b>" + i + "</b>: "+  feature.attributes[i] + "</li>"; 
    121115            html += "</ul>"; 
    122116            $('feature_info').innerHTML = html; 
    123117        } 

  • examples/wfs-scribble.html

    old new  
    3535            df.featureAdded = function(feature) {  
    3636              feature.state = OpenLayers.State.INSERT;  
    3737              feature.style['strokeColor'] = "#ff0000";  
    38               feature.layer.renderer.drawGeometry(feature.geometry, feature.style);   
     38              feature.layer.drawFeature(feature);   
    3939            } 
    4040            p.addControls([ new OpenLayers.Control.Navigation(), df ]); 
    4141              
    …… 
    4747            for(var i = 0; i < map.layers[1].features.length; i++) {  
    4848                var f = map.layers[1].features[i];  
    4949                f.style['strokeColor'] = '#ee9900';  
    50                 map.layers[1].renderer.drawGeometry(f.geometry, f.style);   
     50                map.layers[1].drawFeature(f);   
    5151            }  
    5252            map.layers[1].commit(); 
    5353            return false; 

  • examples/wfs-t.html

    old new  
    2727                      featureNS: 'http://www.openplans.org/topp',  
    2828                      extractAttributes: false 
    2929               } ); 
    30             rlayer.onFeatureInsert=function(feature) { feature.style.strokeColor = "#ff0000"; feature.layer.renderer.drawGeometry(feature.geometry, feature.style); } 
     30            rlayer.onFeatureInsert=function(feature) { feature.style.strokeColor = "#ff0000"; feature.layer.drawFeature(feature); } 
    3131            map.addLayer(rlayer); 
    3232            layer = new OpenLayers.Layer.WFS( "Cities",  
    3333                    "http://dev.openlayers.org/geoserver/wfs", {typename: 'topp:tasmania_cities'},  
    …… 
    4444            df.featureAdded = function(feature) {  
    4545              feature.state = OpenLayers.State.INSERT;  
    4646              feature.style['strokeColor'] = "#0000ff";  
    47               feature.layer.renderer.drawGeometry(feature.geometry, feature.style);   
     47              feature.layer.drawFeature(feature);   
    4848            } 
    4949            dp = new OpenLayers.Control.DrawFeature(layer, OpenLayers.Handler.Point, {handlerOptions: {'freehand': false}, 'displayClass': 'olControlDrawFeaturePoint'}); 
    5050            dp.featureAdded = function(feature) {  
    …… 
    5353              feature.geometry = new OpenLayers.Geometry.MultiPoint(oldgeom); 
    5454              feature.state = OpenLayers.State.INSERT;  
    5555              feature.style['strokeColor'] = "#0000ff";  
    56               feature.layer.renderer.drawGeometry(feature.geometry, feature.style);   
     56              feature.layer.drawFeature(feature);   
    5757            } 
    5858            p.addControls([ new OpenLayers.Control.Navigation(), df, dp ]); 
    5959              

  • examples/wkt.html

    old new  
    7777            } 
    7878        } 
    7979         
    80         function displayWKT(geometry) { 
    81             var str = wkt.write(geometry); 
     80        function displayWKT(feature) { 
     81            var str = wkt.write(feature.geometry); 
    8282            // not a good idea in general, just for this demo 
    8383            str = str.replace(/,/g, ', '); 
    8484            document.getElementById('info').innerHTML = str; 

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

    old new  
    2121    layerIndex: null, 
    2222     
    2323    /** 
    24      * @type {OpenLayers.Geometry} 
     24     * @type {OpenLayers.Feature.Vector} 
    2525     */ 
    26     geometry: null, 
     26    feature: null, 
    2727     
    2828    /** 
    2929     * @constructor 
    …… 
    3333     * @param {Array} callbacks An object with a 'over' property whos value is 
    3434     *                          a function to be called when the mouse is over 
    3535     *                          a feature. The callback should expect to recieve 
    36      *                          a single argument, the geometry. 
     36     *                          a single argument, the feature. 
    3737     * @param {Object} options 
    3838     */ 
    3939    initialize: function(control, layer, callbacks, options) { 
    …… 
    7575     
    7676    /** 
    7777     * Capture double-clicks.  Let the event continue propagating if the  
    78      * double-click doesn't hit a geometry.  Otherwise call the dblclick 
     78     * double-click doesn't hit a feature.  Otherwise call the dblclick 
    7979     * callback. 
    8080     * 
    8181     * @param {Event} evt 
    …… 
    9292     * @type {Boolean} A feature was selected 
    9393     */ 
    9494    select: function(type, evt) {     
    95         var geometry = this.layer.renderer.getGeometryFromEvent(evt); 
    96         if(geometry) { 
     95        var feature = this.layer.getFeatureFromEvent(evt); 
     96        if(feature) { 
    9797            // three cases: 
    9898            // over a new, out of the last and over a new, or still on the last 
    99             if(!this.geometry) { 
    100                 // over a new geometry 
    101                 this.callback('over', [geometry]); 
    102             } else if(this.geometry != geometry) { 
     99            if(!this.feature) { 
     100                // over a new feature 
     101                this.callback('over', [feature]); 
     102            } else if(this.feature != feature) { 
    103103                // out of the last and over a new 
    104                 this.callback('out', [this.geometry]); 
    105                 this.callback('over', [geometry]); 
     104                this.callback('out', [this.feature]); 
     105                this.callback('over', [feature]); 
    106106            } 
    107             this.geometry = geometry; 
    108             this.callback(type, [geometry]); 
     107            this.feature = feature; 
     108            this.callback(type, [feature]); 
    109109            return true; 
    110110        } else { 
    111             if(this.geometry) { 
     111            if(this.feature) { 
    112112                // out of the last 
    113                 this.callback('out', [this.geometry]); 
    114                 this.geometry = null; 
     113                this.callback('out', [this.feature]); 
     114                this.feature = null; 
    115115            } 
    116116            return false; 
    117117        } 

  • lib/OpenLayers/Handler/Path.js

    old new  
    1717  OpenLayers.Class.inherit(OpenLayers.Handler.Point, { 
    1818     
    1919    /** 
    20      * @type OpenLayers.Geometry.LineString 
     20     * @type OpenLayers.Feature.Vector 
    2121     * @private 
    2222     */ 
    2323    line: null, 
    …… 
    6565    /** 
    6666     * Add temporary geometries 
    6767     */ 
    68     createGeometry: function() { 
    69         this.line = new OpenLayers.Geometry.LineString(); 
    70         this.point = new OpenLayers.Geometry.Point(); 
     68    createFeature: function() { 
     69        this.line = new OpenLayers.Feature.Vector( 
     70                                        new OpenLayers.Geometry.LineString()); 
     71        this.point = new OpenLayers.Feature.Vector( 
     72                                        new OpenLayers.Geometry.Point()); 
    7173    }, 
    7274         
    7375    /** 
    7476     * Destroy temporary geometries 
    7577     */ 
    76     destroyGeometry: function() { 
     78    destroyFeature: function() { 
    7779        this.line.destroy(); 
    7880        this.point.destroy(); 
    7981    }, 
    …… 
    8385     * the behavior of LinearRing that disregards adding duplicate points. 
    8486     */ 
    8587    addPoint: function() { 
    86         this.line.addComponent(this.point.clone(), this.line.components.length); 
     88        this.line.geometry.addComponent(this.point.geometry.clone(), 
     89                                        this.line.geometry.components.length); 
     90        this.callback("point", [this.point.geometry]); 
    8791    }, 
    8892     
    8993    /** 
    …… 
    100104     * Modify the existing geometry given the new point 
    101105     *  
    102106     */ 
    103     modifyGeometry: function() { 
    104         var index = this.line.components.length - 1; 
    105         this.line.components[index].x = this.point.x; 
    106         this.line.components[index].y = this.point.y; 
     107    modifyFeature: function() { 
     108        var index = this.line.geometry.components.length - 1; 
     109        this.line.geometry.components[index].x = this.point.geometry.x; 
     110        this.line.geometry.components[index].y = this.point.geometry.y; 
    107111    }, 
    108112     
    109113    /** 
    110114     * Render geometries on the temporary layer. 
    111115     */ 
    112     drawGeometry: function() { 
    113         this.layer.renderer.drawGeometry(this.line, this.style); 
    114         this.layer.renderer.drawGeometry(this.point, this.style); 
     116    drawFeature: function() { 
     117        this.layer.drawFeature(this.line, this.style); 
     118        this.layer.drawFeature(this.point, this.style); 
    115119    }, 
    116120 
    117121    /** 
    …… 
    120124     * @type OpenLayers.Geometry.LineString 
    121125     */ 
    122126    geometryClone: function() { 
    123         return this.line.clone(); 
     127        return this.line.geometry.clone(); 
    124128    }, 
    125129 
    126130    /** 
    …… 
    136140            return false; 
    137141        } 
    138142        if(this.lastDown == null) { 
    139             this.createGeometry(); 
     143            this.createFeature(); 
    140144        } 
    141145        this.mouseDown = true; 
    142146        this.lastDown = evt.xy; 
    143147        var lonlat = this.control.map.getLonLatFromPixel(evt.xy); 
    144         this.point.x = lonlat.lon; 
    145         this.point.y = lonlat.lat; 
     148        this.point.geometry.x = lonlat.lon; 
     149        this.point.geometry.y = lonlat.lat; 
    146150        if((this.lastUp == null) || !this.lastUp.equals(evt.xy)) { 
    147151            this.addPoint(); 
    148152        } 
    149         this.drawGeometry(); 
     153        this.drawFeature(); 
    150154        this.drawing = true; 
    151155        return false; 
    152156    }, 
    …… 
    161165    mousemove: function (evt) { 
    162166        if(this.drawing) {  
    163167            var lonlat = this.map.getLonLatFromPixel(evt.xy); 
    164             this.point.x = lonlat.lon; 
    165             this.point.y = lonlat.lat; 
     168            this.point.geometry.x = lonlat.lon; 
     169            this.point.geometry.y = lonlat.lat; 
    166170            if(this.mouseDown && this.freehandMode(evt)) { 
    167171                this.addPoint(); 
    168172            } else { 
    169                 this.modifyGeometry(); 
     173                this.modifyFeature(); 
    170174            } 
    171             this.drawGeometry(); 
     175            this.drawFeature(); 
    172176        } 
    173177        return true; 
    174178    }, 
    …… 
    190194                   this.addPoint(); 
    191195                } 
    192196                this.lastUp = evt.xy; 
    193                 this.callback("point", [this.point]); 
    194197            } 
    195198            return false; 
    196199        } 
    …… 
    205208     */ 
    206209    dblclick: function(evt) { 
    207210        if(!this.freehandMode(evt)) { 
    208             var index = this.line.components.length - 1; 
    209             this.line.removeComponent(this.line.components[index]); 
    210             this.finalize(this.line); 
     211            var index = this.line.geometry.components.length - 1; 
     212            this.line.geometry.removeComponent(this.line.geometry.components[index]); 
     213            this.finalize(); 
    211214        } 
    212215        return false; 
    213216    }, 

  • lib/OpenLayers/Handler/Point.js

    old new  
    1616  OpenLayers.Class.inherit(OpenLayers.Handler, { 
    1717     
    1818    /** 
    19      * @type OpenLayers.Geometry.Point 
     19     * @type OpenLayers.Feature.Vector 
    2020     * @private 
    2121     */ 
    2222    point: null, 
    …… 
    8787    }, 
    8888     
    8989    /** 
    90      * Add temporary geometries 
     90     * Add temporary features 
    9191     */ 
    92     createGeometry: function() { 
    93         this.point = new OpenLayers.Geometry.Point(); 
     92    createFeature: function() { 
     93        this.point = new OpenLayers.Feature.Vector( 
     94                                              new OpenLayers.Geometry.Point()); 
    9495    }, 
    9596 
    9697    /** 
    …… 
    112113    /** 
    113114     * Destroy the temporary geometries 
    114115     */ 
    115     destroyGeometry: function() { 
     116    destroyFeature: function() { 
    116117        this.point.destroy(); 
    117118    }, 
    118119 
    …… 
    122123    finalize: function() { 
    123124        this.layer.renderer.clear(); 
    124125        this.callback("done", [this.geometryClone()]); 
    125         this.destroyGeometry(); 
     126        this.destroyFeature(); 
    126127        this.drawing = false; 
    127128        this.mouseDown = false; 
    128129        this.lastDown = null; 
    …… 
    135136    cancel: function() { 
    136137        this.layer.renderer.clear(); 
    137138        this.callback("cancel", [this.geometryClone()]); 
    138         this.destroyGeometry(); 
     139        this.destroyFeature(); 
    139140        this.drawing = false; 
    140141        this.mouseDown = false; 
    141142        this.lastDown = null; 
    …… 
    151152    }, 
    152153     
    153154    /** 
    154      * Render geometries on the temporary layer. 
     155     * Render features on the temporary layer. 
    155156     */ 
    156     drawGeometry: function() { 
    157         this.layer.renderer.drawGeometry(this.point, this.style); 
     157    drawFeature: function() { 
     158        this.layer.drawFeature(this.point, this.style); 
    158159    }, 
    159160     
    160161    /** 
    …… 
    163164     * @type OpenLayers.Geometry.Point 
    164165     */ 
    165166    geometryClone: function() { 
    166         return this.point.clone(); 
     167        return this.point.geometry.clone(); 
    167168    }, 
    168169   
    169170    /** 
    …… 
    183184            return true; 
    184185        } 
    185186        if(this.lastDown == null) { 
    186             this.createGeometry(); 
     187            this.createFeature(); 
    187188        } 
    188189        this.lastDown = evt.xy; 
    189190        this.drawing = true; 
    190191        var lonlat = this.map.getLonLatFromPixel(evt.xy); 
    191         this.point.x = lonlat.lon; 
    192         this.point.y = lonlat.lat; 
    193         this.drawGeometry(); 
     192        this.point.geometry.x = lonlat.lon; 
     193        this.point.geometry.y = lonlat.lat; 
     194        this.drawFeature(); 
    194195        return false; 
    195196    }, 
    196197 
    …… 
    204205    mousemove: function (evt) { 
    205206        if(this.drawing) { 
    206207            var lonlat = this.map.getLonLatFromPixel(evt.xy); 
    207             this.point.x = lonlat.lon; 
    208             this.point.y = lonlat.lat; 
    209             this.drawGeometry(); 
     208            this.point.geometry.x = lonlat.lon; 
     209            this.point.geometry.y = lonlat.lat; 
     210            this.drawFeature(); 
    210211        } 
    211212        return true; 
    212213    }, 
    …… 
    220221     */ 
    221222    mouseup: function (evt) { 
    222223        if(this.drawing) { 
    223             this.finalize(this.point); 
     224            this.finalize(); 
    224225            return false; 
    225226        } else { 
    226227            return true; 

  • lib/OpenLayers/Handler/Polygon.js

    old new  
    1616  OpenLayers.Class.inherit(OpenLayers.Handler.Path, { 
    1717     
    1818    /** 
    19      * @type OpenLayers.Geometry.Polygon 
     19     * @type OpenLayers.Feature.Vector 
    2020     * @private 
    2121     */ 
    2222    polygon: null, 
    …… 
    4444    /** 
    4545     * Add temporary geometries 
    4646     */ 
    47     createGeometry: function() { 
    48         this.polygon = new OpenLayers.Geometry.Polygon(); 
    49         this.line = new OpenLayers.Geometry.LinearRing(); 
    50         this.polygon.addComponent(this.line); 
    51         this.point = new OpenLayers.Geometry.Point(); 
     47    createFeature: function() { 
     48        this.polygon = new OpenLayers.Feature.Vector( 
     49                                        new OpenLayers.Geometry.Polygon()); 
     50        this.line = new OpenLayers.Feature.Vector( 
     51                                        new OpenLayers.Geometry.LinearRing()); 
     52        this.polygon.geometry.addComponent(this.line.geometry); 
     53        this.point = new OpenLayers.Feature.Vector( 
     54                                        new OpenLayers.Geometry.Point()); 
    5255    }, 
    5356 
    5457    /** 
    5558     * Destroy temporary geometries 
    5659     */ 
    57     destroyGeometry: function() { 
     60    destroyFeature: function() { 
    5861        this.polygon.destroy(); 
    5962        this.point.destroy(); 
    6063    }, 
    …… 
    6366     * Modify the existing geometry given the new point 
    6467     *  
    6568     */ 
    66     modifyGeometry: function() { 
    67         var index = this.line.components.length - 2; 
    68         this.line.components[index].x = this.point.x; 
    69         this.line.components[index].y = this.point.y; 
     69    modifyFeature: function() { 
     70        var index = this.line.geometry.components.length - 2; 
     71        this.line.geometry.components[index].x = this.point.geometry.x; 
     72        this.line.geometry.components[index].y = this.point.geometry.y; 
    7073    }, 
    7174 
    7275    /** 
    7376     * Render geometries on the temporary layer. 
    7477     */ 
    75     drawGeometry: function() { 
    76         this.layer.renderer.drawGeometry(this.polygon, this.style); 
    77         this.layer.renderer.drawGeometry(this.point, this.style); 
     78    drawFeature: function() { 
     79        this.layer.drawFeature(this.polygon, this.style); 
     80        this.layer.drawFeature(this.point, this.style); 
    7881    }, 
    7982 
    8083    /** 
    …… 
    8386     * @type OpenLayers.Geometry.Polygon 
    8487     */ 
    8588    geometryClone: function() { 
    86         return this.polygon.clone(); 
     89        return this.polygon.geometry.clone(); 
    8790    }, 
    8891 
    8992    /** 
    …… 
    9598    dblclick: function(evt) { 
    9699        if(!this.freehandMode(evt)) { 
    97100            // remove the penultimate point 
    98             var index = this.line.components.length - 2; 
    99             this.line.removeComponent(this.line.components[index]); 
    100             this.finalize(this.line); 
     101            var index = this.line.geometry.components.length - 2; 
     102            this.line.geometry.removeComponent(this.line.geometry.components[index]); 
     103            this.finalize(); 
    101104        } 
    102105        return false; 
    103106    }, 

  • 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     */ 
    306     lock: function() { 
    307         if(this.editing) { 
    308             this.editing = false; 
     298    getFeatureById: function(featureId) { 
     299        //TBD - would it be more efficient to use a hash for this.features? 
     300        var feature = null; 
     301        for(var i=0; i<this.features.length; ++i) { 
     302            if(this.features[i].id == featureId) { 
     303                feature = this.features[i]; 
     304                break; 
     305            } 
    309306        } 
    310         return this.editing; 
     307        return feature; 
    311308    }, 
    312  
     309     
    313310    /** 
    314311     * Unselect the selected features 
    315312     * i.e. clears the featureSelection array 
    …… 
    319316       var vectorLayer = this.map.vectorLayer; 
    320317        for (var i = 0; i < this.map.featureSelection.length; i++) { 
    321318            var featureSelection = this.map.featureSelection[i]; 
    322             vectorLayer.renderer.drawGeometry(featureSelection.geometry,  
    323                                               vectorLayer.style); 
     319            vectorLayer.drawFeature(featureSelection, vectorLayer.style); 
    324320        } 
    325321        this.map.featureSelection = []; 
    326322    }, 

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