Software: Apache. PHP/5.5.15 uname -a: Windows NT SVR-DMZ 6.1 build 7600 (Windows Server 2008 R2 Enterprise Edition) i586 SYSTEM Safe-mode: OFF (not secure) C:\dmz\phpMyAdmin\js\openlayers\src\openlayers\lib\OpenLayers\Layer\ drwxrwxrwx |
Viewing file: FixedZoomLevels.js (11.79 KB) -rw-rw-rw- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) | /* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for * full list of contributors). Published under the Clear BSD license. * See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Layer.js */ /** * Class: OpenLayers.Layer.FixedZoomLevels * Some Layers will already have established zoom levels (like google * or ve). Instead of trying to determine them and populate a resolutions[] * Array with those values, we will hijack the resolution functionality * here. * * When you subclass FixedZoomLevels: * * The initResolutions() call gets nullified, meaning no resolutions[] array * is set up. Which would be a big problem getResolution() in Layer, since * it merely takes map.zoom and indexes into resolutions[]... but.... * * The getResolution() call is also overridden. Instead of using the * resolutions[] array, we simply calculate the current resolution based * on the current extent and the current map size. But how will we be able * to calculate the current extent without knowing the resolution...? * * The getExtent() function is also overridden. Instead of calculating extent * based on the center point and the current resolution, we instead * calculate the extent by getting the lonlats at the top-left and * bottom-right by using the getLonLatFromViewPortPx() translation function, * taken from the pixel locations (0,0) and the size of the map. But how * will we be able to do lonlat-px translation without resolution....? * * The getZoomForResolution() method is overridden. Instead of indexing into * the resolutions[] array, we call OpenLayers.Layer.getExent(), passing in * the desired resolution. With this extent, we then call getZoomForExtent() * * * Whenever you implement a layer using OpenLayers.Layer.FixedZoomLevels, * it is your responsibility to provide the following three functions: * * - getLonLatFromViewPortPx * - getViewPortPxFromLonLat * - getZoomForExtent * * ...those three functions should generally be provided by any reasonable * API that you might be working from. * */ OpenLayers.Layer.FixedZoomLevels = OpenLayers.Class({ /********************************************************/ /* */ /* Baselayer Functions */ /* */ /* The following functions must all be implemented */ /* by all base layers */ /* */ /********************************************************/ /** * Constructor: OpenLayers.Layer.FixedZoomLevels * Create a new fixed zoom levels layer. */ initialize: function() { //this class is only just to add the following functions... // nothing to actually do here... but it is probably a good // idea to have layers that use these functions call this // inititalize() anyways, in case at some point we decide we // do want to put some functionality or state in here. }, /** * Method: initResolutions * Populate the resolutions array */ initResolutions: function() { var props = new Array('minZoomLevel', 'maxZoomLevel', 'numZoomLevels'); for(var i=0, len=props.length; i<len; i++) { var property = props[i]; this[property] = (this.options[property] != null) ? this.options[property] : this.map[property]; } if ( (this.minZoomLevel == null) || (this.minZoomLevel < this.MIN_ZOOM_LEVEL) ){ this.minZoomLevel = this.MIN_ZOOM_LEVEL; } // // At this point, we know what the minimum desired zoom level is, and // we must calculate the total number of zoom levels. // // Because we allow for the setting of either the 'numZoomLevels' // or the 'maxZoomLevel' properties... on either the layer or the // map, we have to define some rules to see which we take into // account first in this calculation. // // The following is the precedence list for these properties: // // (1) numZoomLevels set on layer // (2) maxZoomLevel set on layer // (3) numZoomLevels set on map // (4) maxZoomLevel set on map* // (5) none of the above* // // *Note that options (4) and (5) are only possible if the user // _explicitly_ sets the 'numZoomLevels' property on the map to // null, since it is set by default to 16. // // // Note to future: In 3.0, I think we should remove the default // value of 16 for map.numZoomLevels. Rather, I think that value // should be set as a default on the Layer.WMS class. If someone // creates a 3rd party layer and does not specify any 'minZoomLevel', // 'maxZoomLevel', or 'numZoomLevels', and has not explicitly // specified any of those on the map object either.. then I think // it is fair to say that s/he wants all the zoom levels available. // // By making map.numZoomLevels *null* by default, that will be the // case. As it is, I don't feel comfortable changing that right now // as it would be a glaring API change and actually would probably // break many peoples' codes. // //the number of zoom levels we'd like to have. var desiredZoomLevels; //this is the maximum number of zoom levels the layer will allow, // given the specified starting minimum zoom level. var limitZoomLevels = this.MAX_ZOOM_LEVEL - this.minZoomLevel + 1; if ( ((this.options.numZoomLevels == null) && (this.options.maxZoomLevel != null)) // (2) || ((this.numZoomLevels == null) && (this.maxZoomLevel != null)) // (4) ) { //calculate based on specified maxZoomLevel (on layer or map) desiredZoomLevels = this.maxZoomLevel - this.minZoomLevel + 1; } else { //calculate based on specified numZoomLevels (on layer or map) // this covers cases (1) and (3) desiredZoomLevels = this.numZoomLevels; } if (desiredZoomLevels != null) { //Now that we know what we would *like* the number of zoom levels // to be, based on layer or map options, we have to make sure that // it does not conflict with the actual limit, as specified by // the constants on the layer itself (and calculated into the // 'limitZoomLevels' variable). this.numZoomLevels = Math.min(desiredZoomLevels, limitZoomLevels); } else { // case (5) -- neither 'numZoomLevels' not 'maxZoomLevel' was // set on either the layer or the map. So we just use the // maximum limit as calculated by the layer's constants. this.numZoomLevels = limitZoomLevels; } //now that the 'numZoomLevels' is appropriately, safely set, // we go back and re-calculate the 'maxZoomLevel'. this.maxZoomLevel = this.minZoomLevel + this.numZoomLevels - 1; if (this.RESOLUTIONS != null) { var resolutionsIndex = 0; this.resolutions = []; for(var i= this.minZoomLevel; i <= this.maxZoomLevel; i++) { this.resolutions[resolutionsIndex++] = this.RESOLUTIONS[i]; } this.maxResolution = this.resolutions[0]; this.minResolution = this.resolutions[this.resolutions.length - 1]; } }, /** * APIMethod: getResolution * Get the current map resolution * * Returns: * {Float} Map units per Pixel */ getResolution: function() { if (this.resolutions != null) { return OpenLayers.Layer.prototype.getResolution.apply(this, arguments); } else { var resolution = null; var viewSize = this.map.getSize(); var extent = this.getExtent(); if ((viewSize != null) && (extent != null)) { resolution = Math.max( extent.getWidth() / viewSize.w, extent.getHeight() / viewSize.h ); } return resolution; } }, /** * APIMethod: getExtent * Calculates using px-> lonlat translation functions on tl and br * corners of viewport * * Returns: * {<OpenLayers.Bounds>} A Bounds object which represents the lon/lat * bounds of the current viewPort. */ getExtent: function () { var extent = null; var size = this.map.getSize(); var tlPx = new OpenLayers.Pixel(0,0); var tlLL = this.getLonLatFromViewPortPx(tlPx); var brPx = new OpenLayers.Pixel(size.w, size.h); var brLL = this.getLonLatFromViewPortPx(brPx); if ((tlLL != null) && (brLL != null)) { extent = new OpenLayers.Bounds(tlLL.lon, brLL.lat, brLL.lon, tlLL.lat); } return extent; }, /** * Method: getZoomForResolution * Get the zoom level for a given resolution * * Parameters: * resolution - {Float} * * Returns: * {Integer} A suitable zoom level for the specified resolution. * If no baselayer is set, returns null. */ getZoomForResolution: function(resolution) { if (this.resolutions != null) { return OpenLayers.Layer.prototype.getZoomForResolution.apply(this, arguments); } else { var extent = OpenLayers.Layer.prototype.getExtent.apply(this, []); return this.getZoomForExtent(extent); } }, /********************************************************/ /* */ /* Translation Functions */ /* */ /* The following functions translate GMaps and OL */ /* formats for Pixel, LonLat, Bounds, and Zoom */ /* */ /********************************************************/ // // TRANSLATION: MapObject Zoom <-> OpenLayers Zoom // /** * Method: getOLZoomFromMapObjectZoom * Get the OL zoom index from the map object zoom level * * Parameters: * moZoom - {Integer} * * Returns: * {Integer} An OpenLayers Zoom level, translated from the passed in zoom * Returns null if null value is passed in */ getOLZoomFromMapObjectZoom: function(moZoom) { var zoom = null; if (moZoom != null) { zoom = moZoom - this.minZoomLevel; } return zoom; }, /** * Method: getMapObjectZoomFromOLZoom * Get the map object zoom level from the OL zoom level * * Parameters: * olZoom - {Integer} * * Returns: * {Integer} A MapObject level, translated from the passed in olZoom * Returns null if null value is passed in */ getMapObjectZoomFromOLZoom: function(olZoom) { var zoom = null; if (olZoom != null) { zoom = olZoom + this.minZoomLevel; } return zoom; }, CLASS_NAME: "OpenLayers.Layer.FixedZoomLevels" }); |
:: Command execute :: | |
--[ c99shell v. 1.0 pre-release build #13 powered by Captain Crunch Security Team | http://ccteam.ru | Generation time: 0.0312 ]-- |