Ticket #1830: resFactor.patch

tests/Strategy/BBOX.html

@@ -58 +58 @@
             map: {
                 getExtent: function() {
                     return bounds;
+                },
+                getResolution: function() {
+                    return 1;
                 }
             }
         });
@@ -157 +160 @@
         // 2 tests
         s.merge({features: features});
     }
+    
+    function test_resFactor(t) {
+        t.plan(0);
+        
+        var map = new OpenLayers.Map("map");
+        var bbox = new OpenLayers.Strategy.BBOX();
+        var layer = new OpenLayers.Layer.Vector("test", {
+            strategies: [bbox],
+            isBaseLayer: true
+        });
+        map.addLayer(layer);
+        map.setCenter(new OpenLayers.LonLat(0, 0), 0);
+        
+        // This test needs to be finished.  Stopping here because it looks
+        // like this reveals a bug with the "moveend" event.
+        
+    }
 
   </script>
 </head>

lib/OpenLayers/Strategy/BBOX.js

@@ -24 +24 @@
     bounds: null,
     
     /**
+     * Property: resolution
+     * {Float} The current data resolution.
+     */
+    resolution: null,
+    
+    /**
      * Property: ratio
      * {Float} The ratio of the data bounds to the viewport bounds (in each
      *     dimension).
      */
     ratio: 2,
+    
+    /**
+     * Property: resFactor
+     * {Float} Optional factor used to determine when previously requested
+     *     features are invalid.  If set, the resFactor will be compared to
+     *     the resolution of the previous request to the current map resolution.
+     *     If resFactor > (old / new) and 1/resFactor < (old / new).  If you
+     *     set a resFactor of 1, data will be requested every time the
+     *     resolution changes.  If you set a resFactor of 3, data will be
+     *     requested if the old resolution is 3 times the new, or if the new
+     *     is 3 times the old.  If the old bounds do not contain the new bounds
+     *     new data will always be requested (with or without considering
+     *     resFactor).
+     */
+    resFactor: null,
 
     /**
      * Property: response
@@ -106 +127 @@
         var mapBounds = this.layer.map.getExtent();
         if ((options && options.force) || this.invalidBounds(mapBounds)) {
             this.calculateBounds(mapBounds);
+            this.resolution = this.layer.map.getResolution();
             this.triggerRead();
         }
     },
 
     /**
      * Method: invalidBounds
+     * Determine whether the previously requested set of features is invalid.
+     *     This occurs when the new map bounds do not contain the previously
+     *     requested bounds.  In addition, if <resFactor> is set, it will be
+     *     considered.
      *
      * Parameters:
      * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be
@@ -124 +150 @@
         if(!mapBounds) {
             mapBounds = this.layer.map.getExtent();
         }
-        return !this.bounds || !this.bounds.containsBounds(mapBounds);
+        var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds);
+        if(!invalid && this.resFactor) {
+            var ratio = this.resolution / this.layer.map.getResolution();
+            invalid = (ratio >= this.resFactor || ratio <= (1 / this.resFactor));
+        }
+        return invalid;
     },
  
     /**