postrunner 0.0.10 → 0.0.11

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

@@ -1,425 +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
- * @requires OpenLayers/Format/ArcXML.js
- * @requires OpenLayers/Request.js
- */
-
-/**
- * Class: OpenLayers.Layer.ArcIMS
- * Instances of OpenLayers.Layer.ArcIMS are used to display data from ESRI ArcIMS
- *     Mapping Services. Create a new ArcIMS layer with the <OpenLayers.Layer.ArcIMS>
- *     constructor.
- * 
- * Inherits from:
- *  - <OpenLayers.Layer.Grid>
- */
-OpenLayers.Layer.ArcIMS = OpenLayers.Class(OpenLayers.Layer.Grid, {
-
-    /**
-     * Constant: DEFAULT_PARAMS
-     * {Object} Default query string parameters.
-     */
-    DEFAULT_PARAMS: { 
-        ClientVersion: "9.2",
-        ServiceName: ''
-    },
-    
-    /**
-     * APIProperty: featureCoordSys
-     * {String} Code for feature coordinate system.  Default is "4326".
-     */
-    featureCoordSys: "4326",
-    
-    /**
-     * APIProperty: filterCoordSys
-     * {String} Code for filter coordinate system.  Default is "4326".
-     */
-    filterCoordSys: "4326",
-    
-    /**
-     * APIProperty: layers
-     * {Array} An array of objects with layer properties.
-     */
-    layers: null,
-    
-    /**
-     * APIProperty: async
-     * {Boolean} Request images asynchronously.  Default is true.
-     */
-    async: true,
-    
-    /**
-     * APIProperty: name
-     * {String} Layer name.  Default is "ArcIMS".
-     */
-    name: "ArcIMS",
-
-    /**
-     * APIProperty: isBaseLayer
-     * {Boolean} The layer is a base layer.  Default is true.
-     */
-    isBaseLayer: true,
-
-    /**
-     * Constant: DEFAULT_OPTIONS
-     * {Object} Default layers properties.
-     */
-    DEFAULT_OPTIONS: {
-        tileSize: new OpenLayers.Size(512, 512),
-        featureCoordSys: "4326",
-        filterCoordSys: "4326",
-        layers: null,
-        isBaseLayer: true,
-        async: true,
-        name: "ArcIMS"
-    }, 
- 
-    /**
-     * Constructor: OpenLayers.Layer.ArcIMS
-     * Create a new ArcIMS layer object.
-     *
-     * Example:
-     * (code)
-     * var arcims = new OpenLayers.Layer.ArcIMS(
-     *     "Global Sample",
-     *     "http://sample.avencia.com/servlet/com.esri.esrimap.Esrimap", 
-     *     {
-     *         service: "OpenLayers_Sample", 
-     *         layers: [
-     *             // layers to manipulate
-     *             {id: "1", visible: true}
-     *         ]
-     *     }
-     * );
-     * (end)
-     *
-     * Parameters:
-     * name - {String} A name for the layer
-     * url - {String} Base url for the ArcIMS server
-     * options - {Object} Optional object with properties to be set on the
-     *     layer.
-     */
-    initialize: function(name, url, options) {
-        
-        this.tileSize = new OpenLayers.Size(512, 512);
-
-        // parameters
-        this.params = OpenLayers.Util.applyDefaults(
-            {ServiceName: options.serviceName},
-            this.DEFAULT_PARAMS
-        );
-        this.options = OpenLayers.Util.applyDefaults(
-            options, this.DEFAULT_OPTIONS
-        );
-          
-        OpenLayers.Layer.Grid.prototype.initialize.apply(
-            this, [name, url, this.params, options]
-        );
-
-        //layer is transparent        
-        if (this.transparent) {
-            
-            // unless explicitly set in options, make layer an overlay
-            if (!this.isBaseLayer) {
-                this.isBaseLayer = false;
-            } 
-            
-            // jpegs can never be transparent, so intelligently switch the 
-            //  format, depending on the browser's capabilities
-            if (this.format == "image/jpeg") {
-                this.format = OpenLayers.Util.alphaHack() ? "image/gif" : "image/png";
-            }
-        }
-
-        // create an empty layer list if no layers specified in the options
-        if (this.options.layers === null) {
-            this.options.layers = [];
-        }
-    },    
-
-    /**
-     * 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) {
-        var url = "";
-        bounds = this.adjustBounds(bounds);
-        
-        // create an arcxml request to generate the image
-        var axlReq = new OpenLayers.Format.ArcXML( 
-            OpenLayers.Util.extend(this.options, {
-                requesttype: "image",
-                envelope: bounds.toArray(),
-                tileSize: this.tileSize
-            })
-        );
-        
-        // create a synchronous ajax request to get an arcims image
-        var req = new OpenLayers.Request.POST({
-            url: this.getFullRequestString(),
-            data: axlReq.write(),
-            async: false
-        });
-        
-        // if the response exists
-        if (req != null) {
-            var doc = req.responseXML;
-
-            if (!doc || !doc.documentElement) {            
-                doc = req.responseText;
-            }
-
-            // create a new arcxml format to read the response
-            var axlResp = new OpenLayers.Format.ArcXML();
-            var arcxml = axlResp.read(doc);
-            url = this.getUrlOrImage(arcxml.image.output);
-        }
-        
-        return url;
-    },
-    
-    
-    /**
-     * Method: getURLasync
-     * Get an image url this layer asynchronously, and execute a callback
-     *     when the image url is generated.
-     *
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the
-     *     request.
-     * callback - {Function} Function to call when image url is retrieved.
-     * scope - {Object} The scope of the callback method.
-     */
-    getURLasync: function(bounds, callback, scope) {
-        bounds = this.adjustBounds(bounds);
-        
-        // create an arcxml request to generate the image
-        var axlReq = new OpenLayers.Format.ArcXML(  
-            OpenLayers.Util.extend(this.options, { 
-                requesttype: "image",
-                envelope: bounds.toArray(),
-                tileSize: this.tileSize
-            })
-        );
-        
-        // create an asynchronous ajax request to get an arcims image
-        OpenLayers.Request.POST({
-            url: this.getFullRequestString(),
-            async: true,
-            data: axlReq.write(),
-            callback: function(req) {
-                // process the response from ArcIMS, and call the callback function
-                // to set the image URL
-                var doc = req.responseXML;
-                if (!doc || !doc.documentElement) {            
-                    doc = req.responseText;
-                }
-
-                // create a new arcxml format to read the response
-                var axlResp = new OpenLayers.Format.ArcXML();
-                var arcxml = axlResp.read(doc);
-                
-                callback.call(scope, this.getUrlOrImage(arcxml.image.output));
-            },
-            scope: this
-        });
-    },
-    
-    /**
-     * Method: getUrlOrImage
-     * Extract a url or image from the ArcXML image output.
-     *
-     * Parameters:
-     * output - {Object} The image.output property of the object returned from
-     *     the ArcXML format read method.
-     *
-     * Returns:
-     * {String} A URL for an image (potentially with the data protocol).
-     */
-    getUrlOrImage: function(output) {
-        var ret = "";
-        if(output.url) {
-            // If the image response output url is a string, then the image
-            // data is not inline.
-            ret = output.url;
-        } else if(output.data) {
-            // The image data is inline and base64 encoded, create a data
-            // url for the image.  This will only work for small images,
-            // due to browser url length limits.
-            ret = "data:image/" + output.type + 
-                  ";base64," + output.data;
-        }
-        return ret;
-    },
-    
-    /**
-     * Method: setLayerQuery
-     * Set the query definition on this layer. Query definitions are used to
-     *     render parts of the spatial data in an image, and can be used to
-     *     filter features or layers in the ArcIMS service.
-     *
-     * Parameters:
-     * id - {String} The ArcIMS layer ID.
-     * querydef - {Object} The query definition to apply to this layer.
-     */
-    setLayerQuery: function(id, querydef) {
-        // find the matching layer, if it exists
-        for (var lyr = 0; lyr < this.options.layers.length; lyr++) {
-            if (id == this.options.layers[lyr].id) {
-                // replace this layer definition
-                this.options.layers[lyr].query = querydef;
-                return;
-            }
-        }
-      
-        // no layer found, create a new definition
-        this.options.layers.push({id: id, visible: true, query: querydef});
-    },
-    
-    /**
-     * Method: getFeatureInfo
-     * Get feature information from ArcIMS.  Using the applied geometry, apply
-     *     the options to the query (buffer, area/envelope intersection), and
-     *     query the ArcIMS service.
-     *
-     * A note about accuracy:
-     * ArcIMS interprets the accuracy attribute in feature requests to be
-     *     something like the 'modulus' operator on feature coordinates,
-     *     applied to the database geometry of the feature.  It doesn't round,
-     *     so your feature coordinates may be up to (1 x accuracy) offset from
-     *     the actual feature coordinates.  If the accuracy of the layer is not
-     *     specified, the accuracy will be computed to be approximately 1
-     *     feature coordinate per screen  pixel.
-     *
-     * Parameters:
-     * geometry - {<OpenLayers.LonLat>} or {<OpenLayers.Geometry.Polygon>} The
-     *     geometry to use when making the query. This should be a closed
-     *     polygon for behavior approximating a free selection.
-     * layer - {Object} The ArcIMS layer definition. This is an anonymous object
-     *     that looks like:
-     * (code)
-     * {
-     *     id: "ArcXML layer ID",  // the ArcXML layer ID
-     *     query: {
-     *         where: "STATE = 'PA'",  // the where clause of the query
-     *         accuracy: 100           // the accuracy of the returned feature
-     *     }
-     * }
-     * (end)
-     * options - {Object} Object with non-default properties to set on the layer.
-     *     Supported properties are buffer, callback, scope, and any other
-     *     properties applicable to the ArcXML format.  Set the 'callback' and
-     *     'scope' for an object and function to recieve the parsed features
-     *     from ArcIMS.
-     */
-    getFeatureInfo: function(geometry, layer, options) {
-        // set the buffer to 1 unit (dd/m/ft?) by default
-        var buffer = options.buffer || 1;
-        // empty callback by default
-        var callback = options.callback || function() {};
-        // default scope is window (global)
-        var scope = options.scope || window;
-
-        // apply these option to the request options
-        var requestOptions = {};
-        OpenLayers.Util.extend(requestOptions, this.options);
-
-        // this is a feature request
-        requestOptions.requesttype = "feature";
-
-        if (geometry instanceof OpenLayers.LonLat) {
-            // create an envelope if the geometry is really a lon/lat
-            requestOptions.polygon = null;
-            requestOptions.envelope = [ 
-                geometry.lon - buffer, 
-                geometry.lat - buffer,
-                geometry.lon + buffer,
-                geometry.lat + buffer
-            ];
-        } else if (geometry instanceof OpenLayers.Geometry.Polygon) {
-            // use the polygon assigned, and empty the envelope
-            requestOptions.envelope = null;
-            requestOptions.polygon = geometry;
-        }
-      
-        // create an arcxml request to get feature requests
-        var arcxml = new OpenLayers.Format.ArcXML(requestOptions);
-
-        // apply any get feature options to the arcxml request
-        OpenLayers.Util.extend(arcxml.request.get_feature, options);
-
-        arcxml.request.get_feature.layer = layer.id;
-        if (typeof layer.query.accuracy == "number") {
-            // set the accuracy if it was specified
-            arcxml.request.get_feature.query.accuracy = layer.query.accuracy;
-        } else {
-            // guess that the accuracy is 1 per screen pixel
-            var mapCenter = this.map.getCenter();
-            var viewPx = this.map.getViewPortPxFromLonLat(mapCenter);
-            viewPx.x++;
-            var mapOffCenter = this.map.getLonLatFromPixel(viewPx);
-            arcxml.request.get_feature.query.accuracy = mapOffCenter.lon - mapCenter.lon;
-        }
-        
-        // set the get_feature query to be the same as the layer passed in
-        arcxml.request.get_feature.query.where = layer.query.where;
-        
-        // use area_intersection
-        arcxml.request.get_feature.query.spatialfilter.relation = "area_intersection";
-      
-        // create a new asynchronous request to get the feature info
-        OpenLayers.Request.POST({
-            url: this.getFullRequestString({'CustomService': 'Query'}),
-            data: arcxml.write(),
-            callback: function(request) {
-                // parse the arcxml response
-                var response = arcxml.parseResponse(request.responseText);
-                
-                if (!arcxml.iserror()) {
-                    // if the arcxml is not an error, call the callback with the features parsed
-                    callback.call(scope, response.features);
-                } else {
-                    // if the arcxml is an error, return null features selected
-                    callback.call(scope, null);
-                }
-            }
-        });
-    },
-
-    /**
-     * Method: clone
-     * Create a clone of this layer
-     *
-     * Returns:
-     * {<OpenLayers.Layer.ArcIMS>} An exact clone of this layer
-     */
-    clone: function (obj) {
-
-        if (obj == null) {
-            obj = new OpenLayers.Layer.ArcIMS(this.name,
-                                           this.url,
-                                           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;
-    },
-    
-    CLASS_NAME: "OpenLayers.Layer.ArcIMS"
-});

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

@@ -1,333 +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.Bing
- * Bing layer using direct tile access as provided by Bing Maps REST Services.
- * See http://msdn.microsoft.com/en-us/library/ff701713.aspx for more
- * information. Note: Terms of Service compliant use requires the map to be
- * configured with an <OpenLayers.Control.Attribution> control and the
- * attribution placed on or near the map.
- * 
- * Inherits from:
- *  - <OpenLayers.Layer.XYZ>
- */
-OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, {
-
-    /**
-     * Property: key
-     * {String} API key for Bing maps, get your own key 
-     *     at http://bingmapsportal.com/ .
-     */
-    key: null,
-
-    /**
-     * Property: serverResolutions
-     * {Array} the resolutions provided by the Bing servers.
-     */
-    serverResolutions: [
-        156543.03390625, 78271.516953125, 39135.7584765625,
-        19567.87923828125, 9783.939619140625, 4891.9698095703125,
-        2445.9849047851562, 1222.9924523925781, 611.4962261962891,
-        305.74811309814453, 152.87405654907226, 76.43702827453613,
-        38.218514137268066, 19.109257068634033, 9.554628534317017,
-        4.777314267158508, 2.388657133579254, 1.194328566789627,
-        0.5971642833948135, 0.29858214169740677, 0.14929107084870338,
-        0.07464553542435169
-    ],
-    
-    /**
-     * Property: attributionTemplate
-     * {String}
-     */
-    attributionTemplate: '<span class="olBingAttribution ${type}">' +
-         '<div><a target="_blank" href="http://www.bing.com/maps/">' +
-         '<img src="${logo}" /></a></div>${copyrights}' +
-         '<a style="white-space: nowrap" target="_blank" '+
-         'href="http://www.microsoft.com/maps/product/terms.html">' +
-         'Terms of Use</a></span>',
-
-    /**
-     * Property: metadata
-     * {Object} Metadata for this layer, as returned by the callback script
-     */
-    metadata: null,
-
-    /**
-     * Property: protocolRegex
-     * {RegExp} Regular expression to match and replace http: in bing urls
-     */
-    protocolRegex: /^http:/i,
-    
-    /**
-     * APIProperty: type
-     * {String} The layer identifier.  Any non-birdseye imageryType
-     *     from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be
-     *     used.  Default is "Road".
-     */
-    type: "Road",
-    
-    /**
-     * APIProperty: culture
-     * {String} The culture identifier.  See http://msdn.microsoft.com/en-us/library/ff701709.aspx
-     * for the definition and the possible values.  Default is "en-US".
-     */
-    culture: "en-US",
-    
-    /**
-     * APIProperty: metadataParams
-     * {Object} Optional url parameters for the Get Imagery Metadata request
-     * as described here: http://msdn.microsoft.com/en-us/library/ff701716.aspx
-     */
-    metadataParams: null,
-
-    /** APIProperty: tileOptions
-     *  {Object} optional configuration options for <OpenLayers.Tile> instances
-     *  created by this Layer. Default is
-     *
-     *  (code)
-     *  {crossOriginKeyword: 'anonymous'}
-     *  (end)
-     */
-    tileOptions: null,
-
-    /** APIProperty: protocol
-     *  {String} Protocol to use to fetch Imagery Metadata, tiles and bing logo
-     *  Can be 'http:' 'https:' or ''
-     *
-     *  Warning: tiles may not be available under both HTTP and HTTPS protocols.
-     *  Microsoft approved use of both HTTP and HTTPS urls for tiles. However
-     *  this is undocumented and the Imagery Metadata API always returns HTTP
-     *  urls.
-     *
-     *  Default is '', unless when executed from a file:/// uri, in which case
-     *  it is 'http:'.
-     */
-    protocol: ~window.location.href.indexOf('http') ? '' : 'http:',
-
-    /**
-     * Constructor: OpenLayers.Layer.Bing
-     * Create a new Bing layer.
-     *
-     * Example:
-     * (code)
-     * var road = new OpenLayers.Layer.Bing({
-     *     name: "My Bing Aerial Layer",
-     *     type: "Aerial",
-     *     key: "my-api-key-here",
-     * });
-     * (end)
-     *
-     * Parameters:
-     * options - {Object} Configuration properties for the layer.
-     *
-     * Required configuration properties:
-     * key - {String} Bing Maps API key for your application. Get one at
-     *     http://bingmapsportal.com/.
-     * type - {String} The layer identifier.  Any non-birdseye imageryType
-     *     from http://msdn.microsoft.com/en-us/library/ff701716.aspx can be
-     *     used.
-     *
-     * Any other documented layer properties can be provided in the config object.
-     */
-    initialize: function(options) {
-        options = OpenLayers.Util.applyDefaults({
-            sphericalMercator: true
-        }, options);
-        var name = options.name || "Bing " + (options.type || this.type);
-        
-        var newArgs = [name, null, options];
-        OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs);
-        this.tileOptions = OpenLayers.Util.extend({
-            crossOriginKeyword: 'anonymous'
-        }, this.options.tileOptions);
-        this.loadMetadata(); 
-    },
-
-    /**
-     * Method: loadMetadata
-     */
-    loadMetadata: function() {
-        this._callbackId = "_callback_" + this.id.replace(/\./g, "_");
-        // link the processMetadata method to the global scope and bind it
-        // to this instance
-        window[this._callbackId] = OpenLayers.Function.bind(
-            OpenLayers.Layer.Bing.processMetadata, this
-        );
-        var params = OpenLayers.Util.applyDefaults({
-            key: this.key,
-            jsonp: this._callbackId,
-            include: "ImageryProviders"
-        }, this.metadataParams);
-        var url = this.protocol + "//dev.virtualearth.net/REST/v1/Imagery/Metadata/" +
-            this.type + "?" + OpenLayers.Util.getParameterString(params);
-        var script = document.createElement("script");
-        script.type = "text/javascript";
-        script.src = url;
-        script.id = this._callbackId;
-        document.getElementsByTagName("head")[0].appendChild(script);
-    },
-    
-    /**
-     * Method: initLayer
-     *
-     * Sets layer properties according to the metadata provided by the API
-     */
-    initLayer: function() {
-        var res = this.metadata.resourceSets[0].resources[0];
-        var url = res.imageUrl.replace("{quadkey}", "${quadkey}");
-        url = url.replace("{culture}", this.culture);
-        url = url.replace(this.protocolRegex, this.protocol);
-        this.url = [];
-        for (var i=0; i<res.imageUrlSubdomains.length; ++i) {
-            this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i]));
-        }
-        this.addOptions({
-            maxResolution: Math.min(
-                this.serverResolutions[res.zoomMin],
-                this.maxResolution || Number.POSITIVE_INFINITY
-            ),
-            numZoomLevels: Math.min(
-                res.zoomMax + 1 - res.zoomMin, this.numZoomLevels
-            )
-        }, true);
-        if (!this.isBaseLayer) {
-            this.redraw();
-        }
-        this.updateAttribution();
-    },
-    
-    /**
-     * Method: getURL
-     *
-     * Paramters:
-     * bounds - {<OpenLayers.Bounds>}
-     */
-    getURL: function(bounds) {
-        if (!this.url) {
-            return;
-        }
-        var xyz = this.getXYZ(bounds), x = xyz.x, y = xyz.y, z = xyz.z;
-        var quadDigits = [];
-        for (var i = z; i > 0; --i) {
-            var digit = '0';
-            var mask = 1 << (i - 1);
-            if ((x & mask) != 0) {
-                digit++;
-            }
-            if ((y & mask) != 0) {
-                digit++;
-                digit++;
-            }
-            quadDigits.push(digit);
-        }
-        var quadKey = quadDigits.join("");
-        var url = this.selectUrl('' + x + y + z, this.url);
-
-        return OpenLayers.String.format(url, {'quadkey': quadKey});
-    },
-    
-    /**
-     * Method: updateAttribution
-     * Updates the attribution according to the requirements outlined in
-     * http://gis.638310.n2.nabble.com/Bing-imagery-td5789168.html
-     */
-    updateAttribution: function() {
-        var metadata = this.metadata;
-        if (!metadata.resourceSets || !this.map || !this.map.center) {
-            return;
-        }
-        var res = metadata.resourceSets[0].resources[0];
-        var extent = this.map.getExtent().transform(
-            this.map.getProjectionObject(),
-            new OpenLayers.Projection("EPSG:4326")
-        );
-        var providers = res.imageryProviders || [],
-            zoom = OpenLayers.Util.indexOf(this.serverResolutions,
-                                           this.getServerResolution()),
-            copyrights = "", provider, i, ii, j, jj, bbox, coverage;
-        for (i=0,ii=providers.length; i<ii; ++i) {
-            provider = providers[i];
-            for (j=0,jj=provider.coverageAreas.length; j<jj; ++j) {
-                coverage = provider.coverageAreas[j];
-                // axis order provided is Y,X
-                bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true);
-                if (extent.intersectsBounds(bbox) &&
-                        zoom <= coverage.zoomMax && zoom >= coverage.zoomMin) {
-                    copyrights += provider.attribution + " ";
-                }
-            }
-        }
-        var logo = metadata.brandLogoUri.replace(this.protocolRegex, this.protocol);
-        this.attribution = OpenLayers.String.format(this.attributionTemplate, {
-            type: this.type.toLowerCase(),
-            logo: logo,
-            copyrights: copyrights
-        });
-        this.map && this.map.events.triggerEvent("changelayer", {
-            layer: this,
-            property: "attribution"
-        });
-    },
-    
-    /**
-     * Method: setMap
-     */
-    setMap: function() {
-        OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments);
-        this.map.events.register("moveend", this, this.updateAttribution);
-    },
-    
-    /**
-     * APIMethod: clone
-     * 
-     * Parameters:
-     * obj - {Object}
-     * 
-     * Returns:
-     * {<OpenLayers.Layer.Bing>} An exact clone of this <OpenLayers.Layer.Bing>
-     */
-    clone: function(obj) {
-        if (obj == null) {
-            obj = new OpenLayers.Layer.Bing(this.options);
-        }
-        //get all additions from superclasses
-        obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]);
-        // copy/set any non-init, non-simple values here
-        return obj;
-    },
-    
-    /**
-     * Method: destroy
-     */
-    destroy: function() {
-        this.map &&
-            this.map.events.unregister("moveend", this, this.updateAttribution);
-        OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments);
-    },
-    
-    CLASS_NAME: "OpenLayers.Layer.Bing"
-});
-
-/**
- * Function: OpenLayers.Layer.Bing.processMetadata
- * This function will be bound to an instance, linked to the global scope with
- * an id, and called by the JSONP script returned by the API.
- *
- * Parameters:
- * metadata - {Object} metadata as returned by the API
- */
-OpenLayers.Layer.Bing.processMetadata = function(metadata) {
-    this.metadata = metadata;
-    this.initLayer();
-    var script = document.getElementById(this._callbackId);
-    script.parentNode.removeChild(script);
-    window[this._callbackId] = undefined; // cannot delete from window in IE
-    delete this._callbackId;
-};