diff --git a/lib/OpenLayers/Layer/Vector.js b/lib/OpenLayers/Layer/Vector.js
index 333a7a8d68..52fadd687a 100644
--- a/lib/OpenLayers/Layer/Vector.js
+++ b/lib/OpenLayers/Layer/Vector.js
@@ -229,13 +229,19 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
      */
     destroy: function() {
         if (this.strategies) {
-            for(var i=0, len=this.strategies.length; i<len; i++) {
-                this.strategies[i].destroy();
+            var strategy, i, len;
+            for(i=0, len=this.strategies.length; i<len; i++) {
+                strategy = this.strategies[i];
+                if(strategy.autoDestroy) {
+                    strategy.destroy();
+                }
             }
             this.strategies = null;
         }
         if (this.protocol) {
-            this.protocol.destroy();
+            if(this.protocol.autoDestroy) {
+                this.protocol.destroy();
+            }
             this.protocol = null;
         }
         this.destroyFeatures();
@@ -296,8 +302,31 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
             this.renderer.setSize(this.map.getSize());
         }
         if(this.strategies) {
-            for(var i=0, len=this.strategies.length; i<len; i++) {
-                this.strategies[i].activate();
+            var strategy, i, len;
+            for(i=0, len=this.strategies.length; i<len; i++) {
+                strategy = this.strategies[i];
+                if(strategy.autoActivate) {
+                    strategy.activate();
+                }
+            }
+        }
+    },
+
+    /**
+     * Method: removeMap
+     * The layer has been removed from the map.
+     *
+     * Parameters:
+     * map - {<OpenLayers.Map>}
+     */
+    removeMap: function(map) {
+        if(this.strategies) {
+            var strategy, i, len;
+            for(i=0, len=this.strategies.length; i<len; i++) {
+                strategy = this.strategies[i];
+                if(strategy.autoActivate) {
+                    strategy.deactivate();
+                }
             }
         }
     },
diff --git a/lib/OpenLayers/Protocol.js b/lib/OpenLayers/Protocol.js
index ba36f57e79..da69194669 100755
--- a/lib/OpenLayers/Protocol.js
+++ b/lib/OpenLayers/Protocol.js
@@ -20,7 +20,15 @@ OpenLayers.Protocol = OpenLayers.Class({
      * Any options sent to the constructor.
      */
     options: null,
-    
+
+    /**
+     * Property: autoDestroy
+     * {Boolean} The creator of the protocol can set autoDestroy to false
+     *      to fully control when the protocol is destroyed. Defaults to
+     *      true.
+     */
+    autoDestroy: true,
+   
     /**
      * Constructor: OpenLayers.Protocol
      * Abstract class for vector protocols.  Create instances of a subclass.
diff --git a/lib/OpenLayers/Strategy.js b/lib/OpenLayers/Strategy.js
index d5efe93572..2e682f47da 100755
--- a/lib/OpenLayers/Strategy.js
+++ b/lib/OpenLayers/Strategy.js
@@ -21,6 +21,28 @@ OpenLayers.Strategy = OpenLayers.Class({
      */
     options: null,
 
+    /** 
+     * Property: active 
+     * {Boolean} The control is active.
+     */
+    active: null,
+
+    /**
+     * Property: autoActivate
+     * {Boolean} The creator of the strategy can set autoActivate to false
+     *      to fully control when the protocol is activated and deactivated.
+     *      Defaults to true.
+     */
+    autoActivate: true,
+
+    /**
+     * Property: autoDestroy
+     * {Boolean} The creator of the strategy can set autoDestroy to false
+     *      to fully control when the strategy is destroyed. Defaults to
+     *      true.
+     */
+    autoDestroy: true,
+
     /**
      * Constructor: OpenLayers.Strategy
      * Abstract class for vector strategies.  Create instances of a subclass.
@@ -32,6 +54,8 @@ OpenLayers.Strategy = OpenLayers.Class({
     initialize: function(options) {
         OpenLayers.Util.extend(this, options);
         this.options = options;
+        // set the active property here, so that user cannot override it
+        this.active = false;
     },
     
     /**
@@ -57,16 +81,34 @@ OpenLayers.Strategy = OpenLayers.Class({
     /**
      * Method: activate
      * Activate the strategy.  Register any listeners, do appropriate setup.
+     *
+     * Returns:
+     * {Boolean} True if the strategy was successfully activated or false if
+     *      the strategy was already active.
      */
     activate: function() {
+        if (!this.active) {
+            this.active = true;
+            return true;
+        }
+        return false;
     },
     
     /**
      * Method: deactivate
      * Deactivate the strategy.  Unregister any listeners, do appropriate
      *     tear-down.
+     *
+     * Returns:
+     * {Boolean} True if the strategy was successfully deactivated or false if
+     *      the strategy was already inactive.
      */
     deactivate: function() {
+        if (this.active) {
+            this.active = false;
+            return true;
+        }
+        return false;
     },
    
     CLASS_NAME: "OpenLayers.Strategy" 
diff --git a/lib/OpenLayers/Strategy/Fixed.js b/lib/OpenLayers/Strategy/Fixed.js
index 551d834691..e9572dbf23 100644
--- a/lib/OpenLayers/Strategy/Fixed.js
+++ b/lib/OpenLayers/Strategy/Fixed.js
@@ -39,13 +39,20 @@ OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
      * Method: activate
      * Activate the strategy: reads all features from the protocol and add them 
      * to the layer.
+     *
+     * Returns:
+     * {Boolean} True if the strategy was successfully activated or false if
+     *      the strategy was already active.
      */
     activate: function() {
-        OpenLayers.Strategy.prototype.activate.apply(this, arguments);
-        this.layer.protocol.read({
-            callback: this.merge,
-            scope: this
-        });
+        if(OpenLayers.Strategy.prototype.activate.apply(this, arguments)) {
+            this.layer.protocol.read({
+                callback: this.merge,
+                scope: this
+            });
+            return true;
+        }
+        return false;
     },
 
     /**
diff --git a/tests/Protocol.html b/tests/Protocol.html
index dab990addf..e3ef06db70 100644
--- a/tests/Protocol.html
+++ b/tests/Protocol.html
@@ -4,13 +4,14 @@
   <script type="text/javascript">
 
     function test_initialize(t) {
-        t.plan(2);
+        t.plan(3);
         var options = {};
         var protocol = new OpenLayers.Protocol(options);
 
         t.ok(protocol instanceof OpenLayers.Protocol,
              "new OpenLayers.Protocol returns object" );
         t.eq(protocol.options, options, "constructor sets this.options");
+        t.eq(protocol.autoDestroy, true, "constructor does not modify this.autoDestroy");
     }
     
     function test_destroy(t) {
diff --git a/tests/Strategy.html b/tests/Strategy.html
index 4e16c3c30a..99521f6065 100644
--- a/tests/Strategy.html
+++ b/tests/Strategy.html
@@ -4,13 +4,16 @@
   <script type="text/javascript">
 
     function test_initialize(t) {
-        t.plan(2);
+        t.plan(5);
         var options = {};
         var strategy = new OpenLayers.Strategy(options);
 
         t.ok(strategy instanceof OpenLayers.Strategy,
              "new OpenLayers.Strategy returns object" );
         t.eq(strategy.options, options, "constructor sets this.options");
+        t.eq(strategy.active, false, "constructor sets this.active to false");
+        t.eq(strategy.autoActivate, true, "constructor does not modify this.autoActivate");
+        t.eq(strategy.autoDestroy, true, "constructor does not modify this.autoDestroy");
     }
 
     function test_activate(t) {
@@ -46,6 +49,43 @@
         t.eq(strategy.options, null, "destroy nullify protocol.options");
     }
 
+    function test_activate(t) {
+        t.plan(4);
+        var strategy = new OpenLayers.Strategy({
+            layer: 'foo'
+        });
+
+        var ret;
+        ret = strategy.activate();
+
+        t.eq(strategy.active, true, "activate sets this.active to true on first call");
+        t.eq(ret, true, "activate returns true on first call");
+
+        ret = strategy.activate();
+
+        t.eq(strategy.active, true, "activate does not modify this.active on second call");
+        t.eq(ret, false, "activate returns false on second call");
+    }
+
+    function test_deactivate(t) {
+        t.plan(4);
+        var strategy = new OpenLayers.Strategy({
+            layer: 'foo'
+        });
+        strategy.activate();
+
+        var ret;
+        ret = strategy.deactivate();
+
+        t.eq(strategy.active, false, "deactivate sets this.active to false on first call");
+        t.eq(ret, true, "deactivate returns true on first call");
+
+        ret = strategy.deactivate();
+
+        t.eq(strategy.active, false, "deactivate does not modify this.active on second call");
+        t.eq(ret, false, "deactivate returns false on second call");
+    }
+
   </script>
 </head>
 <body>