postrunner 0.0.10 → 0.0.11

data/misc/openlayers/lib/OpenLayers/Layer/ArcGIS93Rest.js

@@ -1,225 +0,0 @@
-/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the 2-clause BSD license.
- * See license.txt in the OpenLayers distribution or repository for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Layer/Grid.js
- */
-
-/**
- * Class: OpenLayers.Layer.ArcGIS93Rest
- * Instances of OpenLayers.Layer.ArcGIS93Rest are used to display data from
- *     ESRI ArcGIS Server 9.3 (and up?) Mapping Services using the REST API.
- *     Create a new ArcGIS93Rest layer with the <OpenLayers.Layer.ArcGIS93Rest>
- *     constructor.  More detail on the REST API is available at
- *     http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/index.html ;
- *     specifically, the URL provided to this layer should be an export service
- *     URL: http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/export.html 
- * 
- * Inherits from:
- *  - <OpenLayers.Layer.Grid>
- */
-OpenLayers.Layer.ArcGIS93Rest = OpenLayers.Class(OpenLayers.Layer.Grid, {
-
-    /**
-     * Constant: DEFAULT_PARAMS
-     * {Object} Hashtable of default parameter key/value pairs 
-     */
-    DEFAULT_PARAMS: { 
-      format: "png"
-    },
-        
-    /**
-     * APIProperty: isBaseLayer
-     * {Boolean} Default is true for ArcGIS93Rest layer
-     */
-    isBaseLayer: true,
- 
- 
-    /**
-     * Constructor: OpenLayers.Layer.ArcGIS93Rest
-     * Create a new ArcGIS93Rest layer object.
-     *
-     * Example:
-     * (code)
-     * var arcims = new OpenLayers.Layer.ArcGIS93Rest("MyName",
-     *                                    "http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Specialty/ESRI_StateCityHighway_USA/MapServer/export", 
-     *                                    {
-     *                                      layers: "0,1,2"
-     *                                    });
-     * (end)
-     *
-     * Parameters:
-     * name - {String} A name for the layer
-     * url - {String} Base url for the ArcGIS server REST service
-     * options - {Object} An object with key/value pairs representing the
-     *                    options and option values.
-     *
-     * Valid Options:
-     *        format - {String} MIME type of desired image type.
-     *        layers - {String} Comma-separated list of layers to display.
-     *        srs - {String} Projection ID.
-     */
-    initialize: function(name, url, params, options) {
-        var newArguments = [];
-        //uppercase params
-        params = OpenLayers.Util.upperCaseObject(params);
-        newArguments.push(name, url, params, options);
-        OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
-        OpenLayers.Util.applyDefaults(
-                       this.params, 
-                       OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
-                       );
-                       
-        //layer is transparent        
-        if (this.params.TRANSPARENT && 
-            this.params.TRANSPARENT.toString().toLowerCase() == "true") {
-            
-            // unless explicitly set in options, make layer an overlay
-            if ( (options == null) || (!options.isBaseLayer) ) {
-                this.isBaseLayer = false;
-            } 
-            
-            // jpegs can never be transparent, so intelligently switch the 
-            //  format, depending on the browser's capabilities
-            if (this.params.FORMAT == "jpg") {
-                this.params.FORMAT = OpenLayers.Util.alphaHack() ? "gif"
-                                                                 : "png";
-            }
-        }
-    },    
-
-    /**
-         * Method: clone
-         * Create a clone of this layer
-         *
-         * Returns:
-         * {<OpenLayers.Layer.ArcGIS93Rest>} An exact clone of this layer
-         */
-    clone: function (obj) {
-        
-        if (obj == null) {
-            obj = new OpenLayers.Layer.ArcGIS93Rest(this.name,
-                                           this.url,
-                                           this.params,
-                                           this.getOptions());
-        }
-
-        //get all additions from superclasses
-        obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
-
-        // copy/set any non-init, non-simple values here
-
-        return obj;
-    },
-    
-    
-    /**
-     * Method: getURL
-     * Return an image url this layer.
-     *
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the
-     *                                request.
-     *
-     * Returns:
-     * {String} A string with the map image's url.
-     */
-    getURL: function (bounds) {
-        bounds = this.adjustBounds(bounds);
-
-        // ArcGIS Server only wants the numeric portion of the projection ID.
-        var projWords = this.projection.getCode().split(":");
-        var srid = projWords[projWords.length - 1];
-
-        var imageSize = this.getImageSize(); 
-        var newParams = {
-            'BBOX': bounds.toBBOX(),
-            'SIZE': imageSize.w + "," + imageSize.h,
-            // We always want image, the other options were json, image with a whole lotta html around it, etc.
-            'F': "image",
-            'BBOXSR': srid,
-            'IMAGESR': srid
-        };
-
-        // Now add the filter parameters.
-        if (this.layerDefs) {
-            var layerDefStrList = [];
-            var layerID;
-            for(layerID in this.layerDefs) {
-                if (this.layerDefs.hasOwnProperty(layerID)) {
-                    if (this.layerDefs[layerID]) {
-                        layerDefStrList.push(layerID);
-                        layerDefStrList.push(":");
-                        layerDefStrList.push(this.layerDefs[layerID]);
-                        layerDefStrList.push(";");
-                    }
-                }
-            }
-            if (layerDefStrList.length > 0) {
-                newParams['LAYERDEFS'] = layerDefStrList.join("");
-            }
-        }
-        var requestString = this.getFullRequestString(newParams);
-        return requestString;
-    },
-    
-    /**
-     * Method: setLayerFilter
-     * addTile creates a tile, initializes it, and adds it to the layer div. 
-     *
-     * Parameters:
-     * id - {String} The id of the layer to which the filter applies.
-     * queryDef - {String} A sql-ish query filter, for more detail see the ESRI
-     *                     documentation at http://sampleserver1.arcgisonline.com/ArcGIS/SDK/REST/export.html
-     */
-    setLayerFilter: function ( id, queryDef ) {
-        if (!this.layerDefs) {
-            this.layerDefs = {};
-        }
-        if (queryDef) {
-            this.layerDefs[id] = queryDef;
-        } else {
-            delete this.layerDefs[id];
-        }
-    },
-    
-    /**
-     * Method: clearLayerFilter
-     * Clears layer filters, either from a specific layer,
-     * or all of them.
-     *
-     * Parameters:
-     * id - {String} The id of the layer from which to remove any
-     *               filter.  If unspecified/blank, all filters
-     *               will be removed.
-     */
-    clearLayerFilter: function ( id ) {
-        if (id) {
-            delete this.layerDefs[id];
-        } else {
-            delete this.layerDefs;
-        }
-    },
-    
-    /**
-     * APIMethod: mergeNewParams
-     * Catch changeParams and uppercase the new params to be merged in
-     *     before calling changeParams on the super class.
-     * 
-     *     Once params have been changed, the tiles will be reloaded with
-     *     the new parameters.
-     * 
-     * Parameters:
-     * newParams - {Object} Hashtable of new params to use
-     */
-    mergeNewParams:function(newParams) {
-        var upperParams = OpenLayers.Util.upperCaseObject(newParams);
-        var newArguments = [upperParams];
-        return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(this, 
-                                                             newArguments);
-    },
-
-    CLASS_NAME: "OpenLayers.Layer.ArcGIS93Rest"
-});

data/misc/openlayers/lib/OpenLayers/Layer/ArcGISCache.js

@@ -1,480 +0,0 @@
-/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the 2-clause BSD license.
- * See license.txt in the OpenLayers distribution or repository for the
- * full text of the license. */
-
-/** 
- * @requires OpenLayers/Layer/XYZ.js
- */ 
-
-/** 
- * Class: OpenLayers.Layer.ArcGISCache   
- * Layer for accessing cached map tiles from an ArcGIS Server style mapcache. 
- * Tile must already be cached for this layer to access it. This does not require 
- * ArcGIS Server itself.
- * 
- * A few attempts have been made at this kind of layer before. See 
- * http://trac.osgeo.org/openlayers/ticket/1967 
- * and 
- * http://trac.osgeo.org/openlayers/browser/sandbox/tschaub/arcgiscache/lib/OpenLayers/Layer/ArcGISCache.js
- *
- * Typically the problem encountered is that the tiles seem to "jump around".
- * This is due to the fact that the actual max extent for the tiles on AGS layers
- * changes at each zoom level due to the way these caches are constructed.
- * We have attempted to use the resolutions, tile size, and tile origin
- * from the cache meta data to make the appropriate changes to the max extent
- * of the tile to compensate for this behavior.  This must be done as zoom levels change
- * and before tiles are requested, which is why methods from base classes are overridden.
- *
- * For reference, you can access mapcache meta data in two ways. For accessing a 
- * mapcache through ArcGIS Server, you can simply go to the landing page for the
- * layer. (ie. http://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer)
- * For accessing it directly through HTTP, there should always be a conf.xml file
- * in the root directory. 
- * (ie. http://serverx.esri.com/arcgiscache/DG_County_roads_yesA_backgroundDark/Layers/conf.xml)
- *  
- *Inherits from: 
- *  - <OpenLayers.Layer.XYZ>             
- */    
-OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, {  
-
-    /**
-     * APIProperty: url
-     * {String | Array} The base URL for the layer cache.  You can also
-     *     provide a list of URL strings for the layer if your cache is
-     *     available from multiple origins.  This must be set before the layer
-     *     is drawn.
-     */
-    url: null,
-    
-   /**
-    * APIProperty: tileOrigin
-    * {<OpenLayers.LonLat>} The location of the tile origin for the cache.
-    *     An ArcGIS cache has it's origin at the upper-left (lowest x value
-    *     and highest y value of the coordinate system).  The units for the
-    *     tile origin should be the same as the units for the cached data.
-    */
-    tileOrigin: null, 
-   
-   /**
-    * APIProperty: tileSize
-    * {<OpenLayers.Size>} This size of each tile. Defaults to 256 by 256 pixels.
-    */
-    tileSize: new OpenLayers.Size(256, 256),
-    
-   /**
-    * APIProperty: useAGS
-    * {Boolean} Indicates if we are going to be accessing the ArcGIS Server (AGS)
-    *     cache via an AGS MapServer or directly through HTTP. When accessing via
-    *     AGS the path structure uses a standard z/y/x structure. But AGS actually
-    *     stores the tile images on disk using a hex based folder structure that looks
-    *     like "http://example.com/mylayer/L00/R00000000/C00000000.png".  Learn more
-    *     about this here:
-    *     http://blogs.esri.com/Support/blogs/mappingcenter/archive/2010/08/20/Checking-Your-Local-Cache-Folders.aspx
-    *     Defaults to true;
-    */    
-    useArcGISServer: true,
-
-   /**
-    * APIProperty: type
-    * {String} Image type for the layer.  This becomes the filename extension
-    *     in tile requests.  Default is "png" (generating a url like
-    *     "http://example.com/mylayer/L00/R00000000/C00000000.png").
-    */
-    type: 'png',
-    
-    /**
-    * APIProperty: useScales
-    * {Boolean} Optional override to indicate that the layer should use 'scale' information
-    *     returned from the server capabilities object instead of 'resolution' information.
-    *     This can be important if your tile server uses an unusual DPI for the tiles.
-    */
-    useScales: false,
-    
-   /**
-    * APIProperty: overrideDPI
-    * {Boolean} Optional override to change the OpenLayers.DOTS_PER_INCH setting based 
-    *     on the tile information in the server capabilities object.  This can be useful 
-    *     if your server has a non-standard DPI setting on its tiles, and you're only using 
-    *     tiles with that DPI.  This value is used while OpenLayers is calculating resolution
-    *     using scales, and is not necessary if you have resolution information. (This is
-    *     typically the case)  Regardless, this setting can be useful, but is dangerous
-    *     because it will impact other layers while calculating resolution.  Only use this
-    *     if you know what you are doing.  (See OpenLayers.Util.getResolutionFromScale)
-    */
-    overrideDPI: false,
-    
-   /**
-    * Constructor: OpenLayers.Layer.ArcGISCache 
-    * Creates a new instance of this class 
-    * 
-    * Parameters: 
-    * name - {String} 
-    * url - {String} 
-    * options - {Object} extra layer options
-    */ 
-    initialize: function(name, url, options) { 
-        OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments);
-
-        if (this.resolutions) {        
-            this.serverResolutions = this.resolutions;
-            this.maxExtent = this.getMaxExtentForResolution(this.resolutions[0]);
-        }
-
-        // this block steps through translating the values from the server layer JSON 
-        // capabilities object into values that we can use.  This is also a helpful
-        // reference when configuring this layer directly.
-        if (this.layerInfo) {
-            // alias the object
-            var info = this.layerInfo;
-            
-            // build our extents
-            var startingTileExtent = new OpenLayers.Bounds(
-                info.fullExtent.xmin, 
-                info.fullExtent.ymin, 
-                info.fullExtent.xmax, 
-                info.fullExtent.ymax  
-            );
-
-            // set our projection based on the given spatial reference.
-            // esri uses slightly different IDs, so this may not be comprehensive
-            this.projection = 'EPSG:' + info.spatialReference.wkid;
-            this.sphericalMercator = (info.spatialReference.wkid == 102100);
-            
-            // convert esri units into openlayers units (basic feet or meters only)
-            this.units = (info.units == "esriFeet") ? 'ft' : 'm';
-
-            // optional extended section based on whether or not the server returned
-            // specific tile information
-            if (!!info.tileInfo) {            
-                // either set the tiles based on rows/columns, or specific width/height
-                this.tileSize = new OpenLayers.Size(
-                    info.tileInfo.width || info.tileInfo.cols, 
-                    info.tileInfo.height || info.tileInfo.rows
-                );
-                
-                // this must be set when manually configuring this layer
-                this.tileOrigin = new OpenLayers.LonLat(
-                    info.tileInfo.origin.x, 
-                    info.tileInfo.origin.y
-                );
-
-                var upperLeft = new OpenLayers.Geometry.Point(
-                    startingTileExtent.left, 
-                    startingTileExtent.top
-                );
-                
-                var bottomRight = new OpenLayers.Geometry.Point(
-                    startingTileExtent.right, 
-                    startingTileExtent.bottom
-                );            
-                
-                if (this.useScales) {
-                    this.scales = [];
-                } else {
-                    this.resolutions = [];
-                }
-                
-                this.lods = [];
-                for(var key in info.tileInfo.lods) {
-                    if (info.tileInfo.lods.hasOwnProperty(key)) {
-                        var lod = info.tileInfo.lods[key];
-                        if (this.useScales) {
-                            this.scales.push(lod.scale);
-                        } else {
-                            this.resolutions.push(lod.resolution);
-                        }
-                    
-                        var start = this.getContainingTileCoords(upperLeft, lod.resolution);
-                        lod.startTileCol = start.x;
-                        lod.startTileRow = start.y;
-                    
-                        var end = this.getContainingTileCoords(bottomRight, lod.resolution);
-                        lod.endTileCol = end.x;
-                        lod.endTileRow = end.y;    
-                        this.lods.push(lod);
-                    }
-                }
-
-                this.maxExtent = this.calculateMaxExtentWithLOD(this.lods[0]);
-                this.serverResolutions = this.resolutions;
-                if (this.overrideDPI && info.tileInfo.dpi) {
-                    // see comment above for 'overrideDPI'
-                    OpenLayers.DOTS_PER_INCH = info.tileInfo.dpi;
-                }
-            } 
-       }
-    }, 
-
-   /** 
-    * Method: getContainingTileCoords
-    * Calculates the x/y pixel corresponding to the position of the tile
-    *     that contains the given point and for the for the given resolution.
-    * 
-    * Parameters:
-    * point - {<OpenLayers.Geometry.Point>} 
-    * res - {Float} The resolution for which to compute the extent.
-    * 
-    * Returns: 
-    * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position 
-    * of the upper left tile for the given resolution.
-    */
-    getContainingTileCoords: function(point, res) {
-        return new OpenLayers.Pixel(
-           Math.max(Math.floor((point.x - this.tileOrigin.lon) / (this.tileSize.w * res)),0),
-           Math.max(Math.floor((this.tileOrigin.lat - point.y) / (this.tileSize.h * res)),0)
-        );
-    },
-    
-   /** 
-    * Method: calculateMaxExtentWithLOD
-    * Given a Level of Detail object from the server, this function
-    *     calculates the actual max extent
-    * 
-    * Parameters: 
-    * lod - {Object} a Level of Detail Object from the server capabilities object 
-            representing a particular zoom level
-    * 
-    * Returns: 
-    * {<OpenLayers.Bounds>} The actual extent of the tiles for the given zoom level
-    */
-   calculateMaxExtentWithLOD: function(lod) {
-        // the max extent we're provided with just overlaps some tiles
-        // our real extent is the bounds of all the tiles we touch
-
-        var numTileCols = (lod.endTileCol - lod.startTileCol) + 1;
-        var numTileRows = (lod.endTileRow - lod.startTileRow) + 1;        
-
-        var minX = this.tileOrigin.lon + (lod.startTileCol * this.tileSize.w * lod.resolution);
-        var maxX = minX + (numTileCols * this.tileSize.w * lod.resolution);
-
-        var maxY = this.tileOrigin.lat - (lod.startTileRow * this.tileSize.h * lod.resolution);
-        var minY = maxY - (numTileRows * this.tileSize.h * lod.resolution);
-        return new OpenLayers.Bounds(minX, minY, maxX, maxY);
-   },
-    
-   /** 
-    * Method: calculateMaxExtentWithExtent
-    * Given a 'suggested' max extent from the server, this function uses
-    *     information about the actual tile sizes to determine the actual
-    *     extent of the layer.
-    * 
-    * Parameters: 
-    * extent - {<OpenLayers.Bounds>} The 'suggested' extent for the layer
-    * res - {Float} The resolution for which to compute the extent.
-    * 
-    * Returns: 
-    * {<OpenLayers.Bounds>} The actual extent of the tiles for the given zoom level
-    */
-   calculateMaxExtentWithExtent: function(extent, res) {
-        var upperLeft = new OpenLayers.Geometry.Point(extent.left, extent.top);
-        var bottomRight = new OpenLayers.Geometry.Point(extent.right, extent.bottom);
-        var start = this.getContainingTileCoords(upperLeft, res);
-        var end = this.getContainingTileCoords(bottomRight, res);
-        var lod = {
-            resolution: res,
-            startTileCol: start.x,
-            startTileRow: start.y,
-            endTileCol: end.x,
-            endTileRow: end.y
-        };
-        return this.calculateMaxExtentWithLOD(lod);
-   },
-    
-    /** 
-    * Method: getUpperLeftTileCoord
-    * Calculates the x/y pixel corresponding to the position 
-    *     of the upper left tile for the given resolution.
-    * 
-    * Parameters: 
-    * res - {Float} The resolution for which to compute the extent.
-    * 
-    * Returns: 
-    * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position 
-    * of the upper left tile for the given resolution.
-    */
-    getUpperLeftTileCoord: function(res) {
-        var upperLeft = new OpenLayers.Geometry.Point(
-            this.maxExtent.left,
-            this.maxExtent.top);
-        return this.getContainingTileCoords(upperLeft, res);
-    },
-
-    /** 
-    * Method: getLowerRightTileCoord
-    * Calculates the x/y pixel corresponding to the position 
-    *     of the lower right tile for the given resolution.
-    *  
-    * Parameters: 
-    * res - {Float} The resolution for which to compute the extent.
-    * 
-    * Returns: 
-    * {<OpenLayers.Pixel>} The x/y pixel corresponding to the position
-    * of the lower right tile for the given resolution.
-    */
-    getLowerRightTileCoord: function(res) {
-        var bottomRight = new OpenLayers.Geometry.Point(
-            this.maxExtent.right,
-            this.maxExtent.bottom);
-        return this.getContainingTileCoords(bottomRight, res);
-    },
-    
-   /** 
-    * Method: getMaxExtentForResolution
-    * Since the max extent of a set of tiles can change from zoom level
-    *     to zoom level, we need to be able to calculate that max extent 
-    *     for a given resolution.
-    *
-    * Parameters: 
-    * res - {Float} The resolution for which to compute the extent.
-    * 
-    * Returns: 
-    * {<OpenLayers.Bounds>} The extent for this resolution
-    */ 
-    getMaxExtentForResolution: function(res) {
-        var start = this.getUpperLeftTileCoord(res);
-        var end = this.getLowerRightTileCoord(res);
-
-        var numTileCols = (end.x - start.x) + 1;
-        var numTileRows = (end.y - start.y) + 1;
-
-        var minX = this.tileOrigin.lon + (start.x * this.tileSize.w * res);
-        var maxX = minX + (numTileCols * this.tileSize.w * res);
-        
-        var maxY = this.tileOrigin.lat - (start.y * this.tileSize.h * res);
-        var minY = maxY - (numTileRows * this.tileSize.h * res);
-        return new OpenLayers.Bounds(minX, minY, maxX, maxY);
-    },
-    
-   /** 
-    * APIMethod: clone 
-    * Returns an exact clone of this OpenLayers.Layer.ArcGISCache
-    * 
-    * Parameters: 
-    * [obj] - {Object} optional object to assign the cloned instance to.
-    *  
-    * Returns: 
-    * {<OpenLayers.Layer.ArcGISCache>} clone of this instance 
-    */ 
-    clone: function (obj) { 
-        if (obj == null) { 
-            obj = new OpenLayers.Layer.ArcGISCache(this.name, this.url, this.options);
-        }
-        return OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]);
-    },
-
-    /**
-     * Method: initGriddedTiles
-     * 
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>}
-     */
-    initGriddedTiles: function(bounds) {
-        delete this._tileOrigin;
-        OpenLayers.Layer.XYZ.prototype.initGriddedTiles.apply(this, arguments);
-    },
-    
-    /**
-     * Method: getMaxExtent
-     * Get this layer's maximum extent.
-     *
-     * Returns:
-     * {<OpenLayers.Bounds>}
-     */
-    getMaxExtent: function() {
-        var resolution = this.map.getResolution();
-        return this.maxExtent = this.getMaxExtentForResolution(resolution);
-    },
-
-    /**
-     * Method: getTileOrigin
-     * Determine the origin for aligning the grid of tiles.  
-     *     The origin will be derived from the layer's <maxExtent> property. 
-     *
-     * Returns:
-     * {<OpenLayers.LonLat>} The tile origin.
-     */
-    getTileOrigin: function() {
-        if (!this._tileOrigin) {
-            var extent = this.getMaxExtent();
-            this._tileOrigin = new OpenLayers.LonLat(extent.left, extent.bottom);
-        }
-        return this._tileOrigin;
-    },
-
-   /**
-    * Method: getURL
-    * Determine the URL for a tile given the tile bounds.  This is should support
-    *     urls that access tiles through an ArcGIS Server MapServer or directly through
-    *     the hex folder structure using HTTP.  Just be sure to set the useArcGISServer
-    *     property appropriately!  This is basically the same as 
-    *     'OpenLayers.Layer.TMS.getURL',  but with the addition of hex addressing,
-    *     and tile rounding.
-    *
-    * Parameters:
-    * bounds - {<OpenLayers.Bounds>}
-    *
-    * Returns:
-    * {String} The URL for a tile based on given bounds.
-    */
-    getURL: function (bounds) {
-        var res = this.getResolution(); 
-
-        // tile center
-        var originTileX = (this.tileOrigin.lon + (res * this.tileSize.w/2)); 
-        var originTileY = (this.tileOrigin.lat - (res * this.tileSize.h/2));
-
-        var center = bounds.getCenterLonLat();
-        var point = { x: center.lon, y: center.lat };
-        var x = (Math.round(Math.abs((center.lon - originTileX) / (res * this.tileSize.w)))); 
-        var y = (Math.round(Math.abs((originTileY - center.lat) / (res * this.tileSize.h)))); 
-        var z = this.map.getZoom();
-
-        // this prevents us from getting pink tiles (non-existant tiles)
-        if (this.lods) {        
-            var lod = this.lods[this.map.getZoom()];
-            if ((x < lod.startTileCol || x > lod.endTileCol) 
-                || (y < lod.startTileRow || y > lod.endTileRow)) {
-                    return null;
-            }
-        }
-        else {
-            var start = this.getUpperLeftTileCoord(res);
-            var end = this.getLowerRightTileCoord(res);
-            if ((x < start.x || x >= end.x)
-                || (y < start.y || y >= end.y)) {
-                    return null;
-            }        
-        }
-
-        // Construct the url string
-        var url = this.url;
-        var s = '' + x + y + z;
-
-        if (OpenLayers.Util.isArray(url)) {
-            url = this.selectUrl(s, url);
-        }
-
-        // Accessing tiles through ArcGIS Server uses a different path
-        // structure than direct access via the folder structure.
-        if (this.useArcGISServer) {
-            // AGS MapServers have pretty url access to tiles
-            url = url + '/tile/${z}/${y}/${x}';
-        } else {
-            // The tile images are stored using hex values on disk.
-            x = 'C' + OpenLayers.Number.zeroPad(x, 8, 16);
-            y = 'R' + OpenLayers.Number.zeroPad(y, 8, 16);
-            z = 'L' + OpenLayers.Number.zeroPad(z, 2, 10);
-            url = url + '/${z}/${y}/${x}.' + this.type;
-        }
-
-        // Write the values into our formatted url
-        url = OpenLayers.String.format(url, {'x': x, 'y': y, 'z': z});
-
-        return OpenLayers.Util.urlAppend(
-            url, OpenLayers.Util.getParameterString(this.params)
-        );
-    },
-
-    CLASS_NAME: 'OpenLayers.Layer.ArcGISCache' 
-});