Ticket #987: layer.3.patch

tests/Layer.html

@@ -145 +145 @@
-    }
-
-    function test_Layer_initResolutions(t) {
-2
+5
-        var map = new OpenLayers.Map("map");
-        var options, layer;
-        
-hree t
+
-        options = {
-            minResolution: 1.5,
-            maxResolution: 10.5,
@@ -163 +163 @@
-        t.eq(layer.maxResolution.toPrecision(6), (10.5).toPrecision(6),
-             "(with numZoomLevels) layer maxResolution preserved");
-        t.eq(layer.numZoomLevels, 5, "(with numZoomLevels) layer numZoomLevels preserved");
-
+
+
-        // three tests for minResolution, and maxResolution
-        options = {
-            minResolution: 1.5,
@@ -206 +207 @@
-        t.eq(layer.maxScale.toPrecision(6), (155).toPrecision(6),
-             "(without numZoomLevels) layer maxScale preserved");
-        t.eq(layer.numZoomLevels, 4, "(without numZoomLevels) layer numZoomLevels calculated");
+        
+        layer = new OpenLayers.Layer("test", {'projection': 'EPSG:4326', 'map': map});
+        layer.initResolutions();
+        t.eq(layer.alwaysInRange, true, "always in range true if only get projection.");     
+        
+        OpenLayers.Layer.prototype.alwaysInRange = false;
+        layer = new OpenLayers.Layer("test", {'projection': 'EPSG:4326', 'map': map});
+        layer.initResolutions();
+        t.eq(layer.alwaysInRange, false, "always in range true if overridden on prototype.");     
+        OpenLayers.Layer.prototype.alwaysInRange = null;
-
-        map.destroy();
-        

lib/OpenLayers/Layer.js

@@ -38 +38 @@
-    opacity: null,
-
-    /**
+     * APIProperty: alwaysInRange
+     * {Boolean} If a layer's display should not be scale-based, this should 
+     *     be set to true. This will cause the layer, as an overlay, to always 
+     *     be 'active', by always returning true from the calculateInRange() 
+     *     function. 
+     * 
+     *     If not explicitly specified for a layer, its value will be 
+     *     determined on startup in initResolutions() based on whether or not 
+     *     any scale-specific properties have been set as options on the 
+     *     layer. If no scale-specific options have been set on the layer, we 
+     *     assume that it should always be in range.
+     * 
+     *     See #987 for more info.
+     */
+    alwaysInRange: null,   
+
+    /**
-     * Constant: EVENT_TYPES
-     * {Array(String)} Supported application event types.  Register a listener
-     *     for a particular event with the following syntax:
@@ -615 +632 @@
-     * 
-     * Returns:
-     * {Boolean} The layer is displayable at the current map's current
-
+
+
-     */
-    calculateInRange: function() {
-        var inRange = false;
-
-
-
-
+
+
+
+
+
+
+
+
+
-        }
-        return inRange;
-    },
@@ -677 +700 @@
-          'numZoomLevels', 'maxZoomLevel'
-        );
-
+        //these are the properties which do *not* imply that user wishes 
+        // this layer to be scale-dependant
+        var notScaleProps = ['projection', 'units'];    
+
+        //should the layer be scale-dependant? default is false -- this will 
+        // only be set true if we find that the user has specified a property
+        // from the 'props' array that is not in 'notScaleProps'
+        var useInRange = false;
+
-        // First we create a new object where we will store all of the 
-        //  resolution-related properties that we find in either the layer's
-        //  'options' array or from the map.
@@ -684 +716 @@
-        var confProps = {};        
-        for(var i=0, len=props.length; i<len; i++) {
-            var property = props[i];
+            
+            // If the layer had one of these properties set *and* it is 
+            // a scale property (is not a non-scale property), then we assume
+            // the user did intend to use scale-dependant display (useInRange).
+            if (this.options[property] && 
+                OpenLayers.Util.indexOf(notScaleProps, property) == -1) {
+                useInRange = true;
+            }
+                   
-            confProps[property] = this.options[property] || this.map[property];
-        }
-
+        //only automatically set 'alwaysInRange' if the user hasn't already 
+        // set it (to true or false, since the default is null). If user did
+        // not intend to use scale-dependant display then we set they layer
+        // as alwaysInRange. This means calculateInRange() will always return 
+        // true and the layer will never be turned off due to scale changes.
+        //
+        if (this.alwaysInRange == null) {
+            this.alwaysInRange = !useInRange;
+        }
+
-        // Do not use the scales array set at the map level if 
-        // either minScale or maxScale or both are set at the
-        // layer level