Changeset 7863

Timestamp:

08/26/08 10:27:36 (3 months ago)

Author:

crschmidt

Message:

Update calculateInRange: Only turn layers off if they have some scale-related
properties set directly in their creation options. By default, layers will
be "always on", with an overridable "alwaysInRange" parameter.

To maintain the old behavior, set:

OpenLayers.Layer.prototype.alwaysInRange = false;

r=euzuro
(Closes #987)

Files:

• trunk/openlayers/lib/OpenLayers/Layer.js (modified) (4 diffs)
• trunk/openlayers/tests/Layer.html (modified) (3 diffs)

trunk/openlayers/lib/OpenLayers/Layer.js

@@ -37 +37 @@
-     */
-    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,   
-
-    /**
@@ -616 +633 @@
-     * Returns:
-     * {Boolean} The layer is displayable at the current map's current
-
+
+
-     */
-    calculateInRange: function() {
-        var inRange = false;
-
-
-
-
+
+
+
+
+
+
+
+
+
-        }
-        return inRange;
@@ -678 +701 @@
-        );
-
+        //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
@@ -685 +717 @@
-        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;
-        }
-

trunk/openlayers/tests/Layer.html

@@ -146 +146 @@
-
-    function test_Layer_initResolutions(t) {
-2
+5
-        var map = new OpenLayers.Map("map");
-        var options, layer;
-        
-hree t
+
-        options = {
-            minResolution: 1.5,
@@ -164 +164 @@
-             "(with numZoomLevels) layer maxResolution preserved");
-        t.eq(layer.numZoomLevels, 5, "(with numZoomLevels) layer numZoomLevels preserved");
-
+
+
-        // three tests for minResolution, and maxResolution
-        options = {
@@ -207 +208 @@
-             "(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();