8e0876488b
the map level) strategies need to check that the layer is in range and active before fetching new features. r=ahocevar (closes #1678) git-svn-id: http://svn.openlayers.org/trunk/openlayers@7874 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
1147 lines
38 KiB
JavaScript
1147 lines
38 KiB
JavaScript
/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
|
|
* license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
|
|
* full text of the license. */
|
|
|
|
|
|
/**
|
|
* @requires OpenLayers/Map.js
|
|
* @requires OpenLayers/Projection.js
|
|
*/
|
|
|
|
/**
|
|
* Class: OpenLayers.Layer
|
|
*/
|
|
OpenLayers.Layer = OpenLayers.Class({
|
|
|
|
/**
|
|
* APIProperty: id
|
|
* {String}
|
|
*/
|
|
id: null,
|
|
|
|
/**
|
|
* APIProperty: name
|
|
* {String}
|
|
*/
|
|
name: null,
|
|
|
|
/**
|
|
* APIProperty: div
|
|
* {DOMElement}
|
|
*/
|
|
div: null,
|
|
|
|
/**
|
|
* Property: opacity
|
|
* {Float} The layer's opacity. Float number between 0.0 and 1.0.
|
|
*/
|
|
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:
|
|
* (code)
|
|
* layer.events.register(type, obj, listener);
|
|
* (end)
|
|
*
|
|
* Listeners will be called with a reference to an event object. The
|
|
* properties of this event depends on exactly what happened.
|
|
*
|
|
* All event objects have at least the following properties:
|
|
* - *object* {Object} A reference to layer.events.object.
|
|
* - *element* {DOMElement} A reference to layer.events.element.
|
|
*
|
|
* Supported map event types:
|
|
* - *loadstart* Triggered when layer loading starts.
|
|
* - *loadend* Triggered when layer loading ends.
|
|
* - *loadcancel* Triggered when layer loading is canceled.
|
|
* - *visibilitychanged* Triggered when layer visibility is changed.
|
|
* - *moveend* Triggered when layer is moved, object passed as
|
|
* argument has a zoomChanged boolean property which tells that the
|
|
* zoom has changed.
|
|
*/
|
|
EVENT_TYPES: ["loadstart", "loadend", "loadcancel", "visibilitychanged",
|
|
"moveend"],
|
|
|
|
/**
|
|
* APIProperty: events
|
|
* {<OpenLayers.Events>}
|
|
*/
|
|
events: null,
|
|
|
|
/**
|
|
* APIProperty: map
|
|
* {<OpenLayers.Map>} This variable is set when the layer is added to
|
|
* the map, via the accessor function setMap().
|
|
*/
|
|
map: null,
|
|
|
|
/**
|
|
* APIProperty: isBaseLayer
|
|
* {Boolean} Whether or not the layer is a base layer. This should be set
|
|
* individually by all subclasses. Default is false
|
|
*/
|
|
isBaseLayer: false,
|
|
|
|
/**
|
|
* Property: alpha
|
|
* {Boolean} The layer's images have an alpha channel. Default is false.
|
|
*/
|
|
alpha: false,
|
|
|
|
/**
|
|
* APIProperty: displayInLayerSwitcher
|
|
* {Boolean} Display the layer's name in the layer switcher. Default is
|
|
* true.
|
|
*/
|
|
displayInLayerSwitcher: true,
|
|
|
|
/**
|
|
* APIProperty: visibility
|
|
* {Boolean} The layer should be displayed in the map. Default is true.
|
|
*/
|
|
visibility: true,
|
|
|
|
/**
|
|
* APIProperty: attribution
|
|
* {String} Attribution string, displayed when an
|
|
* <OpenLayers.Control.Attribution> has been added to the map.
|
|
*/
|
|
attribution: null,
|
|
|
|
/**
|
|
* Property: inRange
|
|
* {Boolean} The current map resolution is within the layer's min/max
|
|
* range. This is set in <OpenLayers.Map.setCenter> whenever the zoom
|
|
* changes.
|
|
*/
|
|
inRange: false,
|
|
|
|
/**
|
|
* Propery: imageSize
|
|
* {<OpenLayers.Size>} For layers with a gutter, the image is larger than
|
|
* the tile by twice the gutter in each dimension.
|
|
*/
|
|
imageSize: null,
|
|
|
|
/**
|
|
* Property: imageOffset
|
|
* {<OpenLayers.Pixel>} For layers with a gutter, the image offset
|
|
* represents displacement due to the gutter.
|
|
*/
|
|
imageOffset: null,
|
|
|
|
// OPTIONS
|
|
|
|
/**
|
|
* Property: options
|
|
* {Object} An optional object whose properties will be set on the layer.
|
|
* Any of the layer properties can be set as a property of the options
|
|
* object and sent to the constructor when the layer is created.
|
|
*/
|
|
options: null,
|
|
|
|
/**
|
|
* APIProperty: eventListeners
|
|
* {Object} If set as an option at construction, the eventListeners
|
|
* object will be registered with <OpenLayers.Events.on>. Object
|
|
* structure must be a listeners object as shown in the example for
|
|
* the events.on method.
|
|
*/
|
|
eventListeners: null,
|
|
|
|
/**
|
|
* APIProperty: gutter
|
|
* {Integer} Determines the width (in pixels) of the gutter around image
|
|
* tiles to ignore. By setting this property to a non-zero value,
|
|
* images will be requested that are wider and taller than the tile
|
|
* size by a value of 2 x gutter. This allows artifacts of rendering
|
|
* at tile edges to be ignored. Set a gutter value that is equal to
|
|
* half the size of the widest symbol that needs to be displayed.
|
|
* Defaults to zero. Non-tiled layers always have zero gutter.
|
|
*/
|
|
gutter: 0,
|
|
|
|
/**
|
|
* APIProperty: projection
|
|
* {<OpenLayers.Projection>} or {<String>} Set in the layer options to
|
|
* override the default projection string this layer - also set maxExtent,
|
|
* maxResolution, and units if appropriate. Can be either a string or
|
|
* an <OpenLayers.Projection> object when created -- will be converted
|
|
* to an object when setMap is called if a string is passed.
|
|
*/
|
|
projection: null,
|
|
|
|
/**
|
|
* APIProperty: units
|
|
* {String} The layer map units. Defaults to 'degrees'. Possible values
|
|
* are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'.
|
|
*/
|
|
units: null,
|
|
|
|
/**
|
|
* APIProperty: scales
|
|
* {Array} An array of map scales in descending order. The values in the
|
|
* array correspond to the map scale denominator. Note that these
|
|
* values only make sense if the display (monitor) resolution of the
|
|
* client is correctly guessed by whomever is configuring the
|
|
* application. In addition, the units property must also be set.
|
|
* Use <resolutions> instead wherever possible.
|
|
*/
|
|
scales: null,
|
|
|
|
/**
|
|
* APIProperty: resolutions
|
|
* {Array} A list of map resolutions (map units per pixel) in descending
|
|
* order. If this is not set in the layer constructor, it will be set
|
|
* based on other resolution related properties (maxExtent,
|
|
* maxResolution, maxScale, etc.).
|
|
*/
|
|
resolutions: null,
|
|
|
|
/**
|
|
* APIProperty: maxExtent
|
|
* {<OpenLayers.Bounds>} The center of these bounds will not stray outside
|
|
* of the viewport extent during panning. In addition, if
|
|
* <displayOutsideMaxExtent> is set to false, data will not be
|
|
* requested that falls completely outside of these bounds.
|
|
*/
|
|
maxExtent: null,
|
|
|
|
/**
|
|
* APIProperty: minExtent
|
|
* {<OpenLayers.Bounds>}
|
|
*/
|
|
minExtent: null,
|
|
|
|
/**
|
|
* APIProperty: maxResolution
|
|
* {Float} Default max is 360 deg / 256 px, which corresponds to
|
|
* zoom level 0 on gmaps. Specify a different value in the layer
|
|
* options if you are not using a geographic projection and
|
|
* displaying the whole world.
|
|
*/
|
|
maxResolution: null,
|
|
|
|
/**
|
|
* APIProperty: minResolution
|
|
* {Float}
|
|
*/
|
|
minResolution: null,
|
|
|
|
/**
|
|
* APIProperty: numZoomLevels
|
|
* {Integer}
|
|
*/
|
|
numZoomLevels: null,
|
|
|
|
/**
|
|
* APIProperty: minScale
|
|
* {Float}
|
|
*/
|
|
minScale: null,
|
|
|
|
/**
|
|
* APIProperty: maxScale
|
|
* {Float}
|
|
*/
|
|
maxScale: null,
|
|
|
|
/**
|
|
* APIProperty: displayOutsideMaxExtent
|
|
* {Boolean} Request map tiles that are completely outside of the max
|
|
* extent for this layer. Defaults to false.
|
|
*/
|
|
displayOutsideMaxExtent: false,
|
|
|
|
/**
|
|
* APIProperty: wrapDateLine
|
|
* {Boolean} #487 for more info.
|
|
*/
|
|
wrapDateLine: false,
|
|
|
|
/**
|
|
* APIProperty: transitionEffect
|
|
* {String} The transition effect to use when the map is panned or
|
|
* zoomed.
|
|
*
|
|
* There are currently two supported values:
|
|
* - *null* No transition effect (the default).
|
|
* - *resize* Existing tiles are resized on zoom to provide a visual
|
|
* effect of the zoom having taken place immediately. As the
|
|
* new tiles become available, they are drawn over top of the
|
|
* resized tiles.
|
|
*/
|
|
transitionEffect: null,
|
|
|
|
/**
|
|
* Property: SUPPORTED_TRANSITIONS
|
|
* {Array} An immutable (that means don't change it!) list of supported
|
|
* transitionEffect values.
|
|
*/
|
|
SUPPORTED_TRANSITIONS: ['resize'],
|
|
|
|
/**
|
|
* Constructor: OpenLayers.Layer
|
|
*
|
|
* Parameters:
|
|
* name - {String} The layer name
|
|
* options - {Object} Hashtable of extra options to tag onto the layer
|
|
*/
|
|
initialize: function(name, options) {
|
|
|
|
this.addOptions(options);
|
|
|
|
this.name = name;
|
|
|
|
if (this.id == null) {
|
|
|
|
this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
|
|
|
|
this.div = OpenLayers.Util.createDiv(this.id);
|
|
this.div.style.width = "100%";
|
|
this.div.style.height = "100%";
|
|
|
|
this.events = new OpenLayers.Events(this, this.div,
|
|
this.EVENT_TYPES);
|
|
if(this.eventListeners instanceof Object) {
|
|
this.events.on(this.eventListeners);
|
|
}
|
|
|
|
}
|
|
|
|
if (this.wrapDateLine) {
|
|
this.displayOutsideMaxExtent = true;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: destroy
|
|
* Destroy is a destructor: this is to alleviate cyclic references which
|
|
* the Javascript garbage cleaner can not take care of on its own.
|
|
*
|
|
* Parameters:
|
|
* setNewBaseLayer - {Boolean} Set a new base layer when this layer has
|
|
* been destroyed. Default is true.
|
|
*/
|
|
destroy: function(setNewBaseLayer) {
|
|
if (setNewBaseLayer == null) {
|
|
setNewBaseLayer = true;
|
|
}
|
|
if (this.map != null) {
|
|
this.map.removeLayer(this, setNewBaseLayer);
|
|
}
|
|
this.projection = null;
|
|
this.map = null;
|
|
this.name = null;
|
|
this.div = null;
|
|
this.options = null;
|
|
|
|
if (this.events) {
|
|
if(this.eventListeners) {
|
|
this.events.un(this.eventListeners);
|
|
}
|
|
this.events.destroy();
|
|
}
|
|
this.eventListeners = null;
|
|
this.events = null;
|
|
},
|
|
|
|
/**
|
|
* Method: clone
|
|
*
|
|
* Parameters:
|
|
* obj - {<OpenLayers.Layer>} The layer to be cloned
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Layer>} An exact clone of this <OpenLayers.Layer>
|
|
*/
|
|
clone: function (obj) {
|
|
|
|
if (obj == null) {
|
|
obj = new OpenLayers.Layer(this.name, this.options);
|
|
}
|
|
|
|
// catch any randomly tagged-on properties
|
|
OpenLayers.Util.applyDefaults(obj, this);
|
|
|
|
// a cloned layer should never have its map property set
|
|
// because it has not been added to a map yet.
|
|
obj.map = null;
|
|
|
|
return obj;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: setName
|
|
* Sets the new layer name for this layer. Can trigger a changelayer event
|
|
* on the map.
|
|
*
|
|
* Parameters:
|
|
* newName - {String} The new name.
|
|
*/
|
|
setName: function(newName) {
|
|
if (newName != this.name) {
|
|
this.name = newName;
|
|
if (this.map != null) {
|
|
this.map.events.triggerEvent("changelayer", {
|
|
layer: this,
|
|
property: "name"
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* APIMethod: addOptions
|
|
*
|
|
* Parameters:
|
|
* newOptions - {Object}
|
|
*/
|
|
addOptions: function (newOptions) {
|
|
|
|
if (this.options == null) {
|
|
this.options = {};
|
|
}
|
|
|
|
// update our copy for clone
|
|
OpenLayers.Util.extend(this.options, newOptions);
|
|
|
|
// add new options to this
|
|
OpenLayers.Util.extend(this, newOptions);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: onMapResize
|
|
* This function can be implemented by subclasses
|
|
*/
|
|
onMapResize: function() {
|
|
//this function can be implemented by subclasses
|
|
},
|
|
|
|
/**
|
|
* APIMethod: redraw
|
|
* Redraws the layer. Returns true if the layer was redrawn, false if not.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The layer was redrawn.
|
|
*/
|
|
redraw: function() {
|
|
var redrawn = false;
|
|
if (this.map) {
|
|
|
|
// min/max Range may have changed
|
|
this.inRange = this.calculateInRange();
|
|
|
|
// map's center might not yet be set
|
|
var extent = this.getExtent();
|
|
|
|
if (extent && this.inRange && this.visibility) {
|
|
this.moveTo(extent, true, false);
|
|
redrawn = true;
|
|
}
|
|
}
|
|
return redrawn;
|
|
},
|
|
|
|
/**
|
|
* Method: moveTo
|
|
*
|
|
* Parameters:
|
|
* bound - {<OpenLayers.Bounds>}
|
|
* zoomChanged - {Boolean} Tells when zoom has changed, as layers have to
|
|
* do some init work in that case.
|
|
* dragging - {Boolean}
|
|
*/
|
|
moveTo:function(bounds, zoomChanged, dragging) {
|
|
var display = this.visibility;
|
|
if (!this.isBaseLayer) {
|
|
display = display && this.inRange;
|
|
}
|
|
this.display(display);
|
|
},
|
|
|
|
/**
|
|
* Method: setMap
|
|
* Set the map property for the layer. This is done through an accessor
|
|
* so that subclasses can override this and take special action once
|
|
* they have their map variable set.
|
|
*
|
|
* Here we take care to bring over any of the necessary default
|
|
* properties from the map.
|
|
*
|
|
* Parameters:
|
|
* map - {<OpenLayers.Map>}
|
|
*/
|
|
setMap: function(map) {
|
|
if (this.map == null) {
|
|
|
|
this.map = map;
|
|
|
|
// grab some essential layer data from the map if it hasn't already
|
|
// been set
|
|
this.maxExtent = this.maxExtent || this.map.maxExtent;
|
|
this.projection = this.projection || this.map.projection;
|
|
|
|
if (this.projection && typeof this.projection == "string") {
|
|
this.projection = new OpenLayers.Projection(this.projection);
|
|
}
|
|
|
|
// Check the projection to see if we can get units -- if not, refer
|
|
// to properties.
|
|
this.units = this.projection.getUnits() ||
|
|
this.units || this.map.units;
|
|
|
|
this.initResolutions();
|
|
|
|
if (!this.isBaseLayer) {
|
|
this.inRange = this.calculateInRange();
|
|
var show = ((this.visibility) && (this.inRange));
|
|
this.div.style.display = show ? "" : "none";
|
|
}
|
|
|
|
// deal with gutters
|
|
this.setTileSize();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* APIMethod: removeMap
|
|
* Just as setMap() allows each layer the possibility to take a
|
|
* personalized action on being added to the map, removeMap() allows
|
|
* each layer to take a personalized action on being removed from it.
|
|
* For now, this will be mostly unused, except for the EventPane layer,
|
|
* which needs this hook so that it can remove the special invisible
|
|
* pane.
|
|
*
|
|
* Parameters:
|
|
* map - {<OpenLayers.Map>}
|
|
*/
|
|
removeMap: function(map) {
|
|
//to be overridden by subclasses
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getImageSize
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Size>} The size that the image should be, taking into
|
|
* account gutters.
|
|
*/
|
|
getImageSize: function() {
|
|
return (this.imageSize || this.tileSize);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: setTileSize
|
|
* Set the tile size based on the map size. This also sets layer.imageSize
|
|
* and layer.imageOffset for use by Tile.Image.
|
|
*
|
|
* Parameters:
|
|
* size - {<OpenLayers.Size>}
|
|
*/
|
|
setTileSize: function(size) {
|
|
var tileSize = (size) ? size :
|
|
((this.tileSize) ? this.tileSize :
|
|
this.map.getTileSize());
|
|
this.tileSize = tileSize;
|
|
if(this.gutter) {
|
|
// layers with gutters need non-null tile sizes
|
|
//if(tileSize == null) {
|
|
// OpenLayers.console.error("Error in layer.setMap() for " +
|
|
// this.name + ": layers with " +
|
|
// "gutters need non-null tile sizes");
|
|
//}
|
|
this.imageOffset = new OpenLayers.Pixel(-this.gutter,
|
|
-this.gutter);
|
|
this.imageSize = new OpenLayers.Size(tileSize.w + (2*this.gutter),
|
|
tileSize.h + (2*this.gutter));
|
|
}
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getVisibility
|
|
*
|
|
* Returns:
|
|
* {Boolean} The layer should be displayed (if in range).
|
|
*/
|
|
getVisibility: function() {
|
|
return this.visibility;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: setVisibility
|
|
* Set the visibility flag for the layer and hide/show & redraw
|
|
* accordingly. Fire event unless otherwise specified
|
|
*
|
|
* Note that visibility is no longer simply whether or not the layer's
|
|
* style.display is set to "block". Now we store a 'visibility' state
|
|
* property on the layer class, this allows us to remember whether or
|
|
* not we *desire* for a layer to be visible. In the case where the
|
|
* map's resolution is out of the layer's range, this desire may be
|
|
* subverted.
|
|
*
|
|
* Parameters:
|
|
* visible - {Boolean} Whether or not to display the layer (if in range)
|
|
*/
|
|
setVisibility: function(visibility) {
|
|
if (visibility != this.visibility) {
|
|
this.visibility = visibility;
|
|
this.display(visibility);
|
|
this.redraw();
|
|
if (this.map != null) {
|
|
this.map.events.triggerEvent("changelayer", {
|
|
layer: this,
|
|
property: "visibility"
|
|
});
|
|
}
|
|
this.events.triggerEvent("visibilitychanged");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* APIMethod: display
|
|
* Hide or show the Layer
|
|
*
|
|
* Parameters:
|
|
* display - {Boolean}
|
|
*/
|
|
display: function(display) {
|
|
var inRange = this.calculateInRange();
|
|
if (display != (this.div.style.display != "none")) {
|
|
this.div.style.display = (display && inRange) ? "block" : "none";
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: calculateInRange
|
|
*
|
|
* Returns:
|
|
* {Boolean} The layer is displayable at the current map's current
|
|
* resolution. Note that if 'alwaysInRange' is true for the layer,
|
|
* this function will always return true.
|
|
*/
|
|
calculateInRange: function() {
|
|
var inRange = false;
|
|
|
|
if (this.alwaysInRange) {
|
|
inRange = true;
|
|
} else {
|
|
if (this.map) {
|
|
var resolution = this.map.getResolution();
|
|
inRange = ( (resolution >= this.minResolution) &&
|
|
(resolution <= this.maxResolution) );
|
|
}
|
|
}
|
|
return inRange;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: setIsBaseLayer
|
|
*
|
|
* Parameters:
|
|
* isBaseLayer - {Boolean}
|
|
*/
|
|
setIsBaseLayer: function(isBaseLayer) {
|
|
if (isBaseLayer != this.isBaseLayer) {
|
|
this.isBaseLayer = isBaseLayer;
|
|
if (this.map != null) {
|
|
this.map.events.triggerEvent("changebaselayer", {
|
|
layer: this
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
/********************************************************/
|
|
/* */
|
|
/* Baselayer Functions */
|
|
/* */
|
|
/********************************************************/
|
|
|
|
/**
|
|
* Method: initResolutions
|
|
* This method's responsibility is to set up the 'resolutions' array
|
|
* for the layer -- this array is what the layer will use to interface
|
|
* between the zoom levels of the map and the resolution display
|
|
* of the layer.
|
|
*
|
|
* The user has several options that determine how the array is set up.
|
|
*
|
|
* For a detailed explanation, see the following wiki from the
|
|
* openlayers.org homepage:
|
|
* http://trac.openlayers.org/wiki/SettingZoomLevels
|
|
*/
|
|
initResolutions: function() {
|
|
|
|
// These are the relevant options which are used for calculating
|
|
// resolutions information.
|
|
//
|
|
var props = new Array(
|
|
'projection', 'units',
|
|
'scales', 'resolutions',
|
|
'maxScale', 'minScale',
|
|
'maxResolution', 'minResolution',
|
|
'minExtent', 'maxExtent',
|
|
'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.
|
|
//
|
|
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
|
|
if ((this.options.minScale != null ||
|
|
this.options.maxScale != null) &&
|
|
this.options.scales == null) {
|
|
|
|
confProps.scales = null;
|
|
}
|
|
// Do not use the resolutions array set at the map level if
|
|
// either minResolution or maxResolution or both are set at the
|
|
// layer level
|
|
if ((this.options.minResolution != null ||
|
|
this.options.maxResolution != null) &&
|
|
this.options.resolutions == null) {
|
|
|
|
confProps.resolutions = null;
|
|
}
|
|
|
|
// If numZoomLevels hasn't been set and the maxZoomLevel *has*,
|
|
// then use maxZoomLevel to calculate numZoomLevels
|
|
//
|
|
if ( (!confProps.numZoomLevels) && (confProps.maxZoomLevel) ) {
|
|
confProps.numZoomLevels = confProps.maxZoomLevel + 1;
|
|
}
|
|
|
|
// First off, we take whatever hodge-podge of values we have and
|
|
// calculate/distill them down into a resolutions[] array
|
|
//
|
|
if ((confProps.scales != null) || (confProps.resolutions != null)) {
|
|
//preset levels
|
|
if (confProps.scales != null) {
|
|
confProps.resolutions = [];
|
|
for(var i=0, len=confProps.scales.length; i<len; i++) {
|
|
var scale = confProps.scales[i];
|
|
confProps.resolutions[i] =
|
|
OpenLayers.Util.getResolutionFromScale(scale,
|
|
confProps.units);
|
|
}
|
|
}
|
|
confProps.numZoomLevels = confProps.resolutions.length;
|
|
|
|
} else {
|
|
//maxResolution and numZoomLevels based calculation
|
|
|
|
// determine maxResolution
|
|
if (confProps.minScale) {
|
|
confProps.maxResolution =
|
|
OpenLayers.Util.getResolutionFromScale(confProps.minScale,
|
|
confProps.units);
|
|
} else if (confProps.maxResolution == "auto") {
|
|
var viewSize = this.map.getSize();
|
|
var wRes = confProps.maxExtent.getWidth() / viewSize.w;
|
|
var hRes = confProps.maxExtent.getHeight()/ viewSize.h;
|
|
confProps.maxResolution = Math.max(wRes, hRes);
|
|
}
|
|
|
|
// determine minResolution
|
|
if (confProps.maxScale != null) {
|
|
confProps.minResolution =
|
|
OpenLayers.Util.getResolutionFromScale(confProps.maxScale,
|
|
confProps.units);
|
|
} else if ( (confProps.minResolution == "auto") &&
|
|
(confProps.minExtent != null) ) {
|
|
var viewSize = this.map.getSize();
|
|
var wRes = confProps.minExtent.getWidth() / viewSize.w;
|
|
var hRes = confProps.minExtent.getHeight()/ viewSize.h;
|
|
confProps.minResolution = Math.max(wRes, hRes);
|
|
}
|
|
|
|
// determine numZoomLevels if not already set on the layer
|
|
// this gives numZoomLevels assuming approximately base 2 scaling
|
|
if (confProps.minResolution != null &&
|
|
this.options.numZoomLevels == undefined) {
|
|
var ratio = confProps.maxResolution / confProps.minResolution;
|
|
confProps.numZoomLevels =
|
|
Math.floor(Math.log(ratio) / Math.log(2)) + 1;
|
|
}
|
|
|
|
// now we have numZoomLevels and maxResolution,
|
|
// we can populate the resolutions array
|
|
confProps.resolutions = new Array(confProps.numZoomLevels);
|
|
var base = 2;
|
|
if(typeof confProps.minResolution == "number" &&
|
|
confProps.numZoomLevels > 1) {
|
|
/**
|
|
* If maxResolution and minResolution are set (or related
|
|
* scale properties), we calculate the base for exponential
|
|
* scaling that starts at maxResolution and ends at
|
|
* minResolution in numZoomLevels steps.
|
|
*/
|
|
base = Math.pow(
|
|
(confProps.maxResolution / confProps.minResolution),
|
|
(1 / (confProps.numZoomLevels - 1))
|
|
);
|
|
}
|
|
for (var i=0; i < confProps.numZoomLevels; i++) {
|
|
var res = confProps.maxResolution / Math.pow(base, i);
|
|
confProps.resolutions[i] = res;
|
|
}
|
|
}
|
|
|
|
//sort resolutions array ascendingly
|
|
//
|
|
confProps.resolutions.sort( function(a, b) { return(b-a); } );
|
|
|
|
// now set our newly calculated values back to the layer
|
|
// Note: We specifically do *not* set them to layer.options, which we
|
|
// will preserve as it was when we added this layer to the map.
|
|
// this way cloned layers reset themselves to new map div
|
|
// dimensions)
|
|
//
|
|
|
|
this.resolutions = confProps.resolutions;
|
|
this.maxResolution = confProps.resolutions[0];
|
|
var lastIndex = confProps.resolutions.length - 1;
|
|
this.minResolution = confProps.resolutions[lastIndex];
|
|
|
|
this.scales = [];
|
|
for(var i=0, len=confProps.resolutions.length; i<len; i++) {
|
|
this.scales[i] =
|
|
OpenLayers.Util.getScaleFromResolution(confProps.resolutions[i],
|
|
confProps.units);
|
|
}
|
|
this.minScale = this.scales[0];
|
|
this.maxScale = this.scales[this.scales.length - 1];
|
|
|
|
this.numZoomLevels = confProps.numZoomLevels;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getResolution
|
|
*
|
|
* Returns:
|
|
* {Float} The currently selected resolution of the map, taken from the
|
|
* resolutions array, indexed by current zoom level.
|
|
*/
|
|
getResolution: function() {
|
|
var zoom = this.map.getZoom();
|
|
return this.getResolutionForZoom(zoom);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getExtent
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Bounds>} A Bounds object which represents the lon/lat
|
|
* bounds of the current viewPort.
|
|
*/
|
|
getExtent: function() {
|
|
// just use stock map calculateBounds function -- passing no arguments
|
|
// means it will user map's current center & resolution
|
|
//
|
|
return this.map.calculateBounds();
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getZoomForExtent
|
|
*
|
|
* Parameters:
|
|
* bounds - {<OpenLayers.Bounds>}
|
|
* closest - {Boolean} Find the zoom level that most closely fits the
|
|
* specified bounds. Note that this may result in a zoom that does
|
|
* not exactly contain the entire extent.
|
|
* Default is false.
|
|
*
|
|
* Returns:
|
|
* {Integer} The index of the zoomLevel (entry in the resolutions array)
|
|
* for the passed-in extent. We do this by calculating the ideal
|
|
* resolution for the given extent (based on the map size) and then
|
|
* calling getZoomForResolution(), passing along the 'closest'
|
|
* parameter.
|
|
*/
|
|
getZoomForExtent: function(extent, closest) {
|
|
var viewSize = this.map.getSize();
|
|
var idealResolution = Math.max( extent.getWidth() / viewSize.w,
|
|
extent.getHeight() / viewSize.h );
|
|
|
|
return this.getZoomForResolution(idealResolution, closest);
|
|
},
|
|
|
|
/**
|
|
* Method: getDataExtent
|
|
* Calculates the max extent which includes all of the data for the layer.
|
|
* This function is to be implemented by subclasses.
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Bounds>}
|
|
*/
|
|
getDataExtent: function () {
|
|
//to be implemented by subclasses
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getResolutionForZoom
|
|
*
|
|
* Parameter:
|
|
* zoom - {Float}
|
|
*
|
|
* Returns:
|
|
* {Float} A suitable resolution for the specified zoom.
|
|
*/
|
|
getResolutionForZoom: function(zoom) {
|
|
zoom = Math.max(0, Math.min(zoom, this.resolutions.length - 1));
|
|
var resolution;
|
|
if(this.map.fractionalZoom) {
|
|
var low = Math.floor(zoom);
|
|
var high = Math.ceil(zoom);
|
|
resolution = this.resolutions[high] +
|
|
((zoom-low) * (this.resolutions[low]-this.resolutions[high]));
|
|
} else {
|
|
resolution = this.resolutions[Math.round(zoom)];
|
|
}
|
|
return resolution;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getZoomForResolution
|
|
*
|
|
* Parameters:
|
|
* resolution - {Float}
|
|
* closest - {Boolean} Find the zoom level that corresponds to the absolute
|
|
* closest resolution, which may result in a zoom whose corresponding
|
|
* resolution is actually smaller than we would have desired (if this
|
|
* is being called from a getZoomForExtent() call, then this means that
|
|
* the returned zoom index might not actually contain the entire
|
|
* extent specified... but it'll be close).
|
|
* Default is false.
|
|
*
|
|
* Returns:
|
|
* {Integer} The index of the zoomLevel (entry in the resolutions array)
|
|
* that corresponds to the best fit resolution given the passed in
|
|
* value and the 'closest' specification.
|
|
*/
|
|
getZoomForResolution: function(resolution, closest) {
|
|
var zoom;
|
|
if(this.map.fractionalZoom) {
|
|
var lowZoom = 0;
|
|
var highZoom = this.resolutions.length - 1;
|
|
var highRes = this.resolutions[lowZoom];
|
|
var lowRes = this.resolutions[highZoom];
|
|
var res;
|
|
for(var i=0, len=this.resolutions.length; i<len; ++i) {
|
|
res = this.resolutions[i];
|
|
if(res >= resolution) {
|
|
highRes = res;
|
|
lowZoom = i;
|
|
}
|
|
if(res <= resolution) {
|
|
lowRes = res;
|
|
highZoom = i;
|
|
break;
|
|
}
|
|
}
|
|
var dRes = highRes - lowRes;
|
|
if(dRes > 0) {
|
|
zoom = lowZoom + ((resolution - lowRes) / dRes);
|
|
} else {
|
|
zoom = lowZoom;
|
|
}
|
|
} else {
|
|
var diff;
|
|
var minDiff = Number.POSITIVE_INFINITY;
|
|
for(var i=0, len=this.resolutions.length; i<len; i++) {
|
|
if (closest) {
|
|
diff = Math.abs(this.resolutions[i] - resolution);
|
|
if (diff > minDiff) {
|
|
break;
|
|
}
|
|
minDiff = diff;
|
|
} else {
|
|
if (this.resolutions[i] < resolution) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
zoom = Math.max(0, i-1);
|
|
}
|
|
return zoom;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getLonLatFromViewPortPx
|
|
*
|
|
* Parameters:
|
|
* viewPortPx - {<OpenLayers.Pixel>}
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.LonLat>} An OpenLayers.LonLat which is the passed-in
|
|
* view port <OpenLayers.Pixel>, translated into lon/lat by the layer.
|
|
*/
|
|
getLonLatFromViewPortPx: function (viewPortPx) {
|
|
var lonlat = null;
|
|
if (viewPortPx != null) {
|
|
var size = this.map.getSize();
|
|
var center = this.map.getCenter();
|
|
if (center) {
|
|
var res = this.map.getResolution();
|
|
|
|
var delta_x = viewPortPx.x - (size.w / 2);
|
|
var delta_y = viewPortPx.y - (size.h / 2);
|
|
|
|
lonlat = new OpenLayers.LonLat(center.lon + delta_x * res ,
|
|
center.lat - delta_y * res);
|
|
|
|
if (this.wrapDateLine) {
|
|
lonlat = lonlat.wrapDateLine(this.maxExtent);
|
|
}
|
|
} // else { DEBUG STATEMENT }
|
|
}
|
|
return lonlat;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getViewPortPxFromLonLat
|
|
* Returns a pixel location given a map location. This method will return
|
|
* fractional pixel values.
|
|
*
|
|
* Parameters:
|
|
* lonlat - {<OpenLayers.LonLat>}
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Pixel>} An <OpenLayers.Pixel> which is the passed-in
|
|
* <OpenLayers.LonLat>,translated into view port pixels.
|
|
*/
|
|
getViewPortPxFromLonLat: function (lonlat) {
|
|
var px = null;
|
|
if (lonlat != null) {
|
|
var resolution = this.map.getResolution();
|
|
var extent = this.map.getExtent();
|
|
px = new OpenLayers.Pixel(
|
|
(1/resolution * (lonlat.lon - extent.left)),
|
|
(1/resolution * (extent.top - lonlat.lat))
|
|
);
|
|
}
|
|
return px;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: setOpacity
|
|
* Sets the opacity for the entire layer (all images)
|
|
*
|
|
* Parameter:
|
|
* opacity - {Float}
|
|
*/
|
|
setOpacity: function(opacity) {
|
|
if (opacity != this.opacity) {
|
|
this.opacity = opacity;
|
|
for(var i=0, len=this.div.childNodes.length; i<len; ++i) {
|
|
var element = this.div.childNodes[i].firstChild;
|
|
OpenLayers.Util.modifyDOMElement(element, null, null, null,
|
|
null, null, null, opacity);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: setZIndex
|
|
*
|
|
* Parameters:
|
|
* zIndex - {Integer}
|
|
*/
|
|
setZIndex: function (zIndex) {
|
|
this.div.style.zIndex = zIndex;
|
|
},
|
|
|
|
/**
|
|
* Method: adjustBounds
|
|
* This function will take a bounds, and if wrapDateLine option is set
|
|
* on the layer, it will return a bounds which is wrapped around the
|
|
* world. We do not wrap for bounds which *cross* the
|
|
* maxExtent.left/right, only bounds which are entirely to the left
|
|
* or entirely to the right.
|
|
*
|
|
* Parameters:
|
|
* bounds - {<OpenLayers.Bounds>}
|
|
*/
|
|
adjustBounds: function (bounds) {
|
|
|
|
if (this.gutter) {
|
|
// Adjust the extent of a bounds in map units by the
|
|
// layer's gutter in pixels.
|
|
var mapGutter = this.gutter * this.map.getResolution();
|
|
bounds = new OpenLayers.Bounds(bounds.left - mapGutter,
|
|
bounds.bottom - mapGutter,
|
|
bounds.right + mapGutter,
|
|
bounds.top + mapGutter);
|
|
}
|
|
|
|
if (this.wrapDateLine) {
|
|
// wrap around the date line, within the limits of rounding error
|
|
var wrappingOptions = {
|
|
'rightTolerance':this.getResolution()
|
|
};
|
|
bounds = bounds.wrapDateLine(this.maxExtent, wrappingOptions);
|
|
|
|
}
|
|
return bounds;
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Layer"
|
|
});
|