From 256f027c7cd889b678efaa63386b56b603c3c3f3 Mon Sep 17 00:00:00 2001
From: crschmidt <crschmidt@crschmidt.net>
Date: Wed, 28 Jan 2009 01:43:04 +0000
Subject: [PATCH] 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 | 38 +++++++++++++++++++++----
 tests/Strategy/Fixed.html        | 49 +++++++++++++++++++++++++-------
 2 files changed, 71 insertions(+), 16 deletions(-)

diff --git a/lib/OpenLayers/Strategy/Fixed.js b/lib/OpenLayers/Strategy/Fixed.js
index e9572dbf23..43ad55243d 100644
--- a/lib/OpenLayers/Strategy/Fixed.js
+++ b/lib/OpenLayers/Strategy/Fixed.js
@@ -14,6 +14,14 @@
  *  - <OpenLayers.Strategy>
  */
 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
@@ -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 
-     * to the layer.
+     * Activate the strategy: load data or add listener to load when visible
      *
      * Returns:
      * {Boolean} True if the strategy was successfully activated or false if
@@ -46,14 +53,33 @@ OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
      */
     activate: function() {
         if(OpenLayers.Strategy.prototype.activate.apply(this, arguments)) {
-            this.layer.protocol.read({
-                callback: this.merge,
-                scope: this
-            });
+            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
+        });
+        this.layer.events.un({
+            "visibilitychanged": this.load,
+            scope: this
+        });
+    },
 
     /**
      * Method: merge
diff --git a/tests/Strategy/Fixed.html b/tests/Strategy/Fixed.html
index 2c791c6b24..c529435e1f 100644
--- a/tests/Strategy/Fixed.html
+++ b/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'];
+        // a fake 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()],
-
-            // a fake protocol
-            protocol: {
-                read: function(options) {
-                    options.callback.call(options.scope, {features: featureList});
-                }
-            },
-            
+            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>