Commit a change to the Strategy/Fixed to behave more like GeoRSS/Text/GML

layers, and not load by default if the layer is not visible. Includes tests.
Default Behavior can be changed with 
'OpenLayers.Strategy.Fixed.prototype.preload=true;'. With review from elemoine,
comments from tschaub, review from me. Patch by Edgemaster. (Closes #1852) 


git-svn-id: http://svn.openlayers.org/trunk/openlayers@8775 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers/Strategy/Fixed.js

@@ -15,6 +15,14 @@
  */
 OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
     
+    /**
+     * APIProperty: preload
+     * {Boolean} Load data before layer made visible. Enabling this may result
+     *   in considerable overhead if your application loads many data layers
+     *   that are not visible by default. Default is true.
+     */
+    preload: false,
+
     /**
      * Constructor: OpenLayers.Strategy.Fixed
      * Create a new Fixed strategy.
@@ -37,8 +45,7 @@ OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
 
     /**
      * Method: activate
-     * Activate the strategy: reads all features from the protocol and add them 
+     * Activate the strategy: load data or add listener to load when visible
-     * to the layer.
      *
      * Returns:
      * {Boolean} True if the strategy was successfully activated or false if
@@ -46,13 +53,32 @@ OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
      */
     activate: function() {
         if(OpenLayers.Strategy.prototype.activate.apply(this, arguments)) {
+            if(this.layer.visibility == true || this.preload) {
+                this.load();
+            } else {
+                this.layer.events.on({
+                    "visibilitychanged": this.load,
+                    scope: this
+                });
+            }
+            return true;
+        }
+        return false;
+    },
+    
+    /**
+     * Method: load
+     * Tells protocol to load data and unhooks the visibilitychanged event
+     */
+    load: function() {
         this.layer.protocol.read({
             callback: this.merge,
             scope: this
         });
-            return true;
+        this.layer.events.un({
-        }
+            "visibilitychanged": this.load,
-        return false;
+            scope: this
+        });
     },
 
     /**

tests/Strategy/Fixed.html

@@ -4,26 +4,55 @@
   <script type="text/javascript">
 
     function test_activate(t) {
-        t.plan(1);
+        t.plan(5);
+
         var featureList = ['foo', 'bar'];
-
-        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
-            strategies: [new OpenLayers.Strategy.Fixed()],
-
         // a fake protocol
-            protocol: {
+        var protocol = {
             read: function(options) {
                 options.callback.call(options.scope, {features: featureList});
             }
-            },
+        };
 
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [new OpenLayers.Strategy.Fixed()],
+            protocol: protocol,
             addFeatures: function(features) {
                 t.eq(features, featureList, "Features added to the layer");
             }
         });
         
+        var layerp = new OpenLayers.Layer.Vector("Hidden preload Layer", {
+            strategies: [new OpenLayers.Strategy.Fixed({preload:true})],
+            protocol: protocol,
+            visibility: false,
+            addFeatures: function(features) {
+                t.ok(!this.visibility, "Features preloaded before visible");
+            }
+        });
+
+        var s = new OpenLayers.Strategy.Fixed();
+        var layer2 = new OpenLayers.Layer.Vector("Hidden lazyload Layer", {
+            strategies: [s],
+            protocol: protocol,
+            visibility: false,
+            addFeatures: function(features) {
+                t.ok(this.visibility, "Layer visible when features added");
+            }
+        });
+
         var map = new OpenLayers.Map('map');
-        map.addLayer(layer);
+        map.addLayers([layer, layerp, layer2]);
+
+        t.ok(layer2.events.listeners["visibilitychanged"][0].obj == s &&
+                layer2.events.listeners["visibilitychanged"][0].func == s.load,
+                "activate registers visibilitychanged listener if layer hidden"+
+                " and is lazyloading");
+
+        layer2.setVisibility(true);
+        
+        t.ok(layer2.events.listeners["visibilitychanged"] == false,
+                "visibilitychanged listener unregistered");
     }
 
   </script>