Ticket #434: mulafese001.patch

lib/OpenLayers/Control/SelectFeature.js

@@ -81 +81 @@
-    geometryTypes: null,
-
-    /**
-
-<OpenLayers.Layer.Vector>
+s
+Array(<OpenLayers.Layer.Vector>)
-     */
-
+s
-    
-    /**
-     * APIProperty: callbacks
@@ -118 +118 @@
-     * layer - {<OpenLayers.Layer.Vector>} 
-     * options - {Object} 
-     */
-
+s
-        OpenLayers.Control.prototype.initialize.apply(this, [options]);
- = layer
+s = layers instanceof Array ? layers : [layers]
-        this.callbacks = OpenLayers.Util.extend({
-                                                  click: this.clickFeature,
-                                                  clickout: this.clickoutFeature,
@@ -128 +128 @@
-                                                  out: this.outFeature
-                                                }, this.callbacks);
-        var handlerOptions = { geometryTypes: this.geometryTypes};
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    },
-
-    /**
@@ -143 +167 @@
-     */
-    unselectAll: function(options) {
-        // we'll want an option to supress notification here
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-        }
-    },
-
@@ -162 +189 @@
-     */
-    clickFeature: function(feature) {
-        if(!this.hover) {
-(OpenLayers.Util.indexOf(this.layer.selectedFeatures,
-                                        feature) > -1);
+this.featureIsSelected(feature);
+
-            if(selected) {
-                if(this.toggleSelect()) {
-                    this.unselect(feature);
@@ -226 +253 @@
-     * feature - {<OpenLayers.Feature.Vector>} 
-     */
-    overFeature: function(feature) {
-
-
+
-            this.select(feature);
-        }
-    },
@@ -255 +281 @@
-     * feature - {<OpenLayers.Feature.Vector>} 
-     */
-    select: function(feature) {
-
+
+
-
-        var selectStyle = this.selectStyle || this.renderIntent;
-        
-this.
-this.
+
+
-        this.onSelect(feature);
-    },
-
@@ -274 +301 @@
-     */
-    unselect: function(feature) {
-        // Store feature style for restoration later
-
-
-
+
+
+
+
-        this.onUnselect(feature);
-    },
-
@@ -291 +319 @@
-        this.handler.setMap(map);
-        OpenLayers.Control.prototype.setMap.apply(this, arguments);
-    },
+    
+    /** 
+     * Method: featureIsSelected
+     * Convenience method.
+     * 
+     * Parameters:
+     * feature - {<OpenLayers.Feature>}
+     * 
+     * Returns:
+     * {Boolean} True iff the feature is selected. 
+     */
+    featureIsSelected: function(feature) {
+        return OpenLayers.Util.indexOf(
+            feature.layer.selectedFeatures, feature) > -1;
+    },
-
-    CLASS_NAME: "OpenLayers.Control.SelectFeature"
-});

lib/OpenLayers/Feature/Vector.js

@@ -39 +39 @@
-     * {<OpenLayers.Geometry>} 
-     */
-    geometry: null,
+    
+    /**
+     * Property: viewGeometry 
+     * {<OpenLayers.Geometry>}
+     * viewGeometry is the geometry representing the visual appearance 
+     * of the feature.
+     * For most features, this is just their ordinary geometry.
+     * For Points it's a rectangle whose size is based on 
+     * the size of its style properties.
+     * 
+     * Access via getViewGeometry()
+     */
+    viewGeometry: null,
+    
+    /**
+     * Property: resolutionOfViewGeometry
+     * {Number}
+     * The resolution for which the viewGeometry was calculated.
+     * This is stored to be able to know if the viewGeometry
+     * should be recalculated.
+     */
+    resolutionOfViewGeometry: null,
-
-    /** 
-     * APIProperty: attributes 
@@ -260 +282 @@
-        }
-    },
-    
+    /**
+     * Method: getViewGeometry
+     * Returns the "viewGeometry" of the feature.
+     * viewGeometry is the geometry representing the visual appearance 
+     * of the feature.
+     * For most features, this is just their ordinary geometry.
+     * For Points it's a rectangle whose size is based on 
+     * the size of its style properties.
+     * 
+     * Returns:
+     * {<OpenLayers.Geometry>} The viewGeometry of the feature.
+     */
+    getViewGeometry: function() {
+        var newRes = this.layer.getResolution();
+        if( !this.viewGeometry || newRes != this.resolutionOfViewGeometry ) {
+            this.resolutionOfViewGeometry = newRes;
+            this.viewGeometry = this.calcViewGeometry(this.geometry);
+        }
+        return this.viewGeometry;
+    },
+    
+    /**
+     * Method: calcViewGeometry
+     * Calculates a viewGeometry corresponding to a given geometry.
+     * 
+     * Used only internally (= by this class).
+     * 
+     * Parameters:
+     * {<OpenLayers.Geometry>} The original geometry.
+     * 
+     * Returns:
+     * {<OpenLayers.Geometry>} The viewGeometry.
+     */
+    calcViewGeometry: function(geometry) {
+        var layer = this.layer;
+        switch(geometry.CLASS_NAME) {
+            
+        case "OpenLayers.Geometry.Point":
+            // A point is presented as a rectangle whose size and
+            // position (offset) is determined by its style properties.
+            
+            var style = this.style || OpenLayers.Feature.Vector.style['default'];
+            
+            var res = layer.getResolution();
+            var x = geometry.x;
+            var y = geometry.y;
+                
+            var width,height,xOffset,yOffset;
+            
+            // use the graphic size if it is specified
+            if(style.graphicWidth && style.graphicHeight) {
+                width = style.graphicWidth * res;
+                height = style.graphicHeight * res;
+                xOffset = style.graphicXOffset ? style.graphicXOffset * res : 0;
+                yOffset = style.graphicYOffset ? style.graphicYOffset * res : 0;
+            }
+            // otherwise use the pointRadius property
+            // TBD: in this case, it could be possible to create 
+            // a circle-like geometry instead of a rectangle...
+            else {
+                var rad = style.pointRadius * res;
+                width = height = rad*2;
+                xOffset = yOffset = -rad;
+            }
+            
+            var left = x + xOffset;
+            var top = y + yOffset;
+            var right = left + width;
+            var bottom  = top + height;
+            
+            var bounds = new OpenLayers.Bounds(left,bottom,right,top);
+            return bounds.toGeometry();
+        
+        case "OpenLayers.Geometry.Collection":
+        case "OpenLayers.Geometry.MultiPoint":
+            var components = Array(geometry.components.length);
+            for(var i=0; i<components.length; ++i) {
+                components[i] = this.calcViewGeometry(geometry.components[i]);
+            }
+            return new OpenLayers.Geometry.Collection(components);
+        
+        default:
+            return geometry;
+        }
+    },
+    
-    CLASS_NAME: "OpenLayers.Feature.Vector"
-});
-

lib/OpenLayers/Layer/Vector.js

@@ -526 +526 @@
-    },
-    
-    /**
+     * Method: getFeaturesIntersectingGeometry
+     * Given a geometry, returns an array of features that intersect
+     * the geometry. The features' viewGeometry property is used
+     * in the intersection tests.
+     *
+     * Parameters:
+     * geometry - {<OpenLayers.Geometry>} The geometry.
+     *
+     * Returns:
+     * {Array(<OpenLayers.Feature.Vector>)} The intersecting features.
+     */
+    getFeaturesIntersectingGeometry: function(geometry) {
+        var intersecting = [];
+        var feature;
+        for(var i=0; i<this.features.length; ++i){
+            feature = this.features[i];
+            if( geometry.intersects(feature.getViewGeometry()) ) {
+                intersecting.push(feature);
+            }
+        }
+        return intersecting;
+    },
+    
+    /**
-     * Unselect the selected features
-     * i.e. clears the featureSelection array
-     * change the style back

lib/OpenLayers.js

@@ -134 +134 @@
-            "OpenLayers/Handler/Path.js",
-            "OpenLayers/Handler/Polygon.js",
-            "OpenLayers/Handler/Feature.js",
+            "OpenLayers/Handler/MultiLayerFeature.js",
-            "OpenLayers/Handler/Drag.js",
-            "OpenLayers/Handler/RegularPolygon.js",
-            "OpenLayers/Handler/Box.js",