OpenLayers OpenLayers

Ticket #628: geometry.feature.patch

File geometry.feature.patch, 23.9 kB (added by tschaub, 1 year ago)

conceal 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  
    142142     */ 
    143143    setGeometry: function(geometry, recurse) { 
    144144        if(geometry) { 
    145             this.geometry = geometry; 
    146             this.geometry.feature = this; 
     145            geometry.feature = this; 
    147146            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); 
     147                if (geometry.components) { 
     148                    // set geometry.feature for all components 
     149                    for (var i = 0; i < geometry.components.length; i++) { 
     150                        OpenLayers.Feature.Vector.prototype.setGeometry.apply( 
     151                                        this, [geometry.components[i], recurse]); 
     152                    } 
     153                } 
    164154            } 
     155            this.geometry = geometry; 
    165156        } 
    166157    }, 
    167158     

  • lib/OpenLayers/Geometry.js

    old new  
    2323    /**  
    2424     * Cross reference back to the feature that owns this geometry so 
    2525     * that that the feature can be identified after the geometry has been 
    26      * selected by a mouse click. 
    27      *  
    28      * @type OpenLayers.Feature */ 
     26     * selected by a mouse click.  This is subject to change.  Not to be 
     27     * considered a stable part of the API. 
     28     * 
     29     * @private 
     30     * @type OpenLayers.Feature 
     31     */ 
    2932    feature: null, 
    3033 
    3134    /** 

  • 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 
    …… 
    9494    select: function(type, evt) {     
    9595        var geometry = this.layer.renderer.getGeometryFromEvent(evt); 
    9696        if(geometry) { 
     97            var feature; 
     98            if(geometry.parent) { 
     99                feature = geometry.parent.feature; 
     100            } else { 
     101                feature = geometry.feature; 
     102            } 
    97103            // three cases: 
    98104            // 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) { 
     105            if(!this.feature) { 
     106                // over a new feature 
     107                this.callback('over', [feature]); 
     108            } else if(this.feature != feature) { 
    103109                // out of the last and over a new 
    104                 this.callback('out', [this.geometry]); 
    105                 this.callback('over', [geometry]); 
     110                this.callback('out', [this.feature]); 
     111                this.callback('over', [feature]); 
    106112            } 
    107             this.geometry = geometry; 
    108             this.callback(type, [geometry]); 
     113            this.feature = feature; 
     114            this.callback(type, [feature]); 
    109115            return true; 
    110116        } else { 
    111             if(this.geometry) { 
     117            if(this.feature) { 
    112118                // out of the last 
    113                 this.callback('out', [this.geometry]); 
    114                 this.geometry = null; 
     119                this.callback('out', [this.feature]); 
     120                this.feature = null; 
    115121            } 
    116122            return false; 
    117123        } 

  • lib/OpenLayers/Layer/Vector.js

    old new  
    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        } 
    …… 
    199192            this.drawn = true; 
    200193            for(var i = 0; i < this.features.length; i++) { 
    201194                var feature = this.features[i]; 
    202                 this.renderer.drawGeometry(feature.geometry, feature.style); 
     195                this.drawFeature(feature); 
    203196            } 
    204197        }     
    205198    }, 
    …… 
    228221            feature.layer = this; 
    229222 
    230223            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                 }     
     224                feature.style = OpenLayers.Util.extend({}, this.style); 
    236225            } 
    237226 
    238227            this.preFeatureInsert(feature); 
    239228 
    240229            if (this.drawn) { 
    241                 this.renderer.drawGeometry(feature.geometry, feature.style); 
     230                this.drawFeature(feature); 
    242231            } 
    243232             
    244233            this.onFeatureInsert(feature); 
    …… 
    271260    }, 
    272261 
    273262    /** 
    274      * @param {String} fid 
     263     * Draw (or redraw) a feature on the layer.  If the optional style argument 
     264     * is included, this style will be used.  If no style is included, the 
     265     * feature's style will be used.  If the feature doesn't have a style, 
     266     * the layer's style will be used. 
     267     *  
     268     * @param {OpenLayers.Feature.Vector} feature 
    275269     * @param {Object} style 
    276270     */ 
    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); 
     271    drawFeature: function(feature, style) { 
     272        if(style == null) { 
     273            if(feature.style) { 
     274                style = feature.style; 
     275            } else { 
     276                style = this.style; 
    282277            } 
    283278        } 
     279        this.renderer.drawGeometry(feature.geometry, style); 
    284280    }, 
    285281     
    286282    /** 
    …… 
    297293    }, 
    298294 
    299295    /** 
    300      * Stop editing the layer 
    301      *  
    302      * @return Whether or not the layer *was* editing  
    303      * HACK HACK This return value seems wierd to me. 
    304      * @type Boolean 
    305      */ 
    306     lock: function() { 
    307         if(this.editing) { 
    308             this.editing = false; 
    309         } 
    310         return this.editing; 
    311     }, 
    312  
    313     /** 
    314296     * Unselect the selected features 
    315297     * i.e. clears the featureSelection array 
    316298     * change the style back 
    …… 
    319301       var vectorLayer = this.map.vectorLayer; 
    320302        for (var i = 0; i < this.map.featureSelection.length; i++) { 
    321303            var featureSelection = this.map.featureSelection[i]; 
    322             vectorLayer.renderer.drawGeometry(featureSelection.geometry,  
    323                                               vectorLayer.style); 
     304            vectorLayer.drawFeature(featureSelection, vectorLayer.style); 
    324305        } 
    325306        this.map.featureSelection = []; 
    326307    }, 

  • 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     
    …… 
    1413        t.ok( feature instanceof OpenLayers.Feature.Vector, "new OpenLayers.Feature.Vector returns Feature.Vector object" ); 
    1514    } 
    1615     
     16    function test_Feature_Vector_setGeometry(t) { 
     17        t.plan(5); 
     18        var p0 = new OpenLayers.Geometry.Point(0, 0); 
     19        var p1 = new OpenLayers.Geometry.Point(1, 1); 
     20        var line = new OpenLayers.Geometry.LineString([ 
     21                        new OpenLayers.Geometry.Point(2, 2), 
     22                        new OpenLayers.Geometry.Point(3, 3)]); 
     23        var collection = new OpenLayers.Geometry.Collection([p0, p1, line]); 
     24        var feature = new OpenLayers.Feature.Vector(); 
     25         
     26        feature.setGeometry(collection); 
     27        t.ok(collection.feature, 
     28             "geometry.feature property is set"); 
     29        t.ok(collection.feature instanceof OpenLayers.Feature.Vector, 
     30             "geometry.feature is an OpenLayers.Feature.Vector"); 
     31        t.eq(collection.feature.id, feature.id, 
     32             "geometry.feature has the same id as the original feature"); 
     33        t.eq(collection.components[0].feature.id, feature.id, 
     34             "recursive call sets geometry.feature on geometry.components[0]"); 
     35         
     36        var p0 = new OpenLayers.Geometry.Point(0, 0); 
     37        var p1 = new OpenLayers.Geometry.Point(1, 1); 
     38        var line = new OpenLayers.Geometry.LineString([ 
     39                        new OpenLayers.Geometry.Point(2, 2), 
     40                        new OpenLayers.Geometry.Point(3, 3)]); 
     41        var collection = new OpenLayers.Geometry.Collection([p0, p1, line]); 
     42        var feature = new OpenLayers.Feature.Vector(); 
     43        feature.setGeometry(collection, false); 
     44        t.ok(!collection.components[0].feature, 
     45             "recursive call can be disabled"); 
     46         
     47    } 
     48     
    1749 
    1850  // --> 
    1951  </script> 

  • 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"); 
    …… 
    5554        layer.addFeatures(f); 
    5655        t.ok( f.style != null, "Feature style is set by layer."); 
    5756    } 
     57     
     58    function test_Layer_Vector_drawFeature(t) { 
     59        t.plan(4); 
     60        var layer = new OpenLayers.Layer.Vector("Test Layer"); 
     61        var map = new OpenLayers.Map('map'); 
     62        map.addLayer(layer); 
     63        var geometry = new OpenLayers.Geometry.Point(10, 10); 
     64        var feature = new OpenLayers.Feature.Vector(geometry); 
     65         
     66        var g, s; 
     67        layer.renderer = { 
     68            drawGeometry: function(geometry, style) { 
     69                g = geometry; 
     70                s = style; 
     71            } 
     72        }; 
    5873 
     74        layer.drawFeature(feature); 
     75        t.ok(geometry.equals(g), 
     76             "calls layer.renderer.drawGeometry() with feature.geometry"); 
     77         
     78        feature.style = 'exists'; 
     79        layer.drawFeature(feature); 
     80        t.eq(feature.style, s, 
     81             "calls layer.renderer.drawGeometry() with feature.style"); 
     82         
     83        feature.style = null; 
     84        layer.style = 'exists'; 
     85        layer.drawFeature(feature); 
     86        t.eq(layer.style, s, 
     87             "given null feature style, uses layer style"); 
     88 
     89        feature.style = 'exists'; 
     90        layer.style = 'exists'; 
     91        var customStyle = 'custom'; 
     92        layer.drawFeature(feature, customStyle); 
     93        t.eq(customStyle, s, 
     94             "given a custom style, renders with that"); 
     95         
     96    } 
     97 
    5998    function test_Layer_Vector_destroyFeatures (t) { 
    6099        t.plan(2);  
    61100        layer = new OpenLayers.Layer.Vector(name);