postrunner 0.0.10 → 0.0.11

data/misc/openlayers/lib/OpenLayers/Layer/Vector/RootContainer.js

@@ -1,154 +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/Vector.js
- */
-
-/**
- * Class: OpenLayers.Layer.Vector.RootContainer
- * A special layer type to combine multiple vector layers inside a single
- *     renderer root container. This class is not supposed to be instantiated
- *     from user space, it is a helper class for controls that require event
- *     processing for multiple vector layers.
- *
- * Inherits from:
- *  - <OpenLayers.Layer.Vector>
- */
-OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, {
-    
-    /**
-     * Property: displayInLayerSwitcher
-     * Set to false for this layer type
-     */
-    displayInLayerSwitcher: false,
-    
-    /**
-     * APIProperty: layers
-     * Layers that are attached to this container. Required config option.
-     */
-    layers: null,
-    
-    /**
-     * Constructor: OpenLayers.Layer.Vector.RootContainer
-     * Create a new root container for multiple vector layer. This constructor
-     * is not supposed to be used from user space, it is only to be used by
-     * controls that need feature selection across multiple vector layers.
-     *
-     * Parameters:
-     * name - {String} A name for the layer
-     * options - {Object} Optional object with non-default properties to set on
-     *           the layer.
-     * 
-     * Required options properties:
-     * layers - {Array(<OpenLayers.Layer.Vector>)} The layers managed by this
-     *     container
-     *
-     * Returns:
-     * {<OpenLayers.Layer.Vector.RootContainer>} A new vector layer root
-     *     container
-     */
-    
-    /**
-     * Method: display
-     */
-    display: function() {},
-    
-    /**
-     * Method: getFeatureFromEvent
-     * walk through the layers to find the feature returned by the event
-     * 
-     * Parameters:
-     * evt - {Object} event object with a feature property
-     * 
-     * Returns:
-     * {<OpenLayers.Feature.Vector>}
-     */
-    getFeatureFromEvent: function(evt) {
-        var layers = this.layers;
-        var feature;
-        for(var i=0; i<layers.length; i++) {
-            feature = layers[i].getFeatureFromEvent(evt);
-            if(feature) {
-                return feature;
-            }
-        }
-    },
-    
-    /**
-     * Method: setMap
-     * 
-     * Parameters:
-     * map - {<OpenLayers.Map>}
-     */
-    setMap: function(map) {
-        OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments);
-        this.collectRoots();
-        map.events.register("changelayer", this, this.handleChangeLayer);
-    },
-    
-    /**
-     * Method: removeMap
-     * 
-     * Parameters:
-     * map - {<OpenLayers.Map>}
-     */
-    removeMap: function(map) {
-        map.events.unregister("changelayer", this, this.handleChangeLayer);
-        this.resetRoots();
-        OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments);
-    },
-    
-    /**
-     * Method: collectRoots
-     * Collects the root nodes of all layers this control is configured with
-     * and moveswien the nodes to this control's layer
-     */
-    collectRoots: function() {
-        var layer;
-        // walk through all map layers, because we want to keep the order
-        for(var i=0; i<this.map.layers.length; ++i) {
-            layer = this.map.layers[i];
-            if(OpenLayers.Util.indexOf(this.layers, layer) != -1) {
-                layer.renderer.moveRoot(this.renderer);
-            }
-        }
-    },
-    
-    /**
-     * Method: resetRoots
-     * Resets the root nodes back into the layers they belong to.
-     */
-    resetRoots: function() {
-        var layer;
-        for(var i=0; i<this.layers.length; ++i) {
-            layer = this.layers[i];
-            if(this.renderer && layer.renderer.getRenderLayerId() == this.id) {
-                this.renderer.moveRoot(layer.renderer);
-            }
-        }
-    },
-    
-    /**
-     * Method: handleChangeLayer
-     * Event handler for the map's changelayer event. We need to rebuild
-     * this container's layer dom if order of one of its layers changes.
-     * This handler is added with the setMap method, and removed with the
-     * removeMap method.
-     * 
-     * Parameters:
-     * evt - {Object}
-     */
-    handleChangeLayer: function(evt) {
-        var layer = evt.layer;
-        if(evt.property == "order" &&
-                        OpenLayers.Util.indexOf(this.layers, layer) != -1) {
-            this.resetRoots();
-            this.collectRoots();
-        }
-    },
-
-    CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer"
-});

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

@@ -1,267 +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.WMS
- * Instances of OpenLayers.Layer.WMS are used to display data from OGC Web
- *     Mapping Services. Create a new WMS layer with the <OpenLayers.Layer.WMS>
- *     constructor.
- * 
- * Inherits from:
- *  - <OpenLayers.Layer.Grid>
- */
-OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, {
-
-    /**
-     * Constant: DEFAULT_PARAMS
-     * {Object} Hashtable of default parameter key/value pairs 
-     */
-    DEFAULT_PARAMS: { service: "WMS",
-                      version: "1.1.1",
-                      request: "GetMap",
-                      styles: "",
-                      format: "image/jpeg"
-                     },
-    
-    /**
-     * APIProperty: isBaseLayer
-     * {Boolean} Default is true for WMS layer
-     */
-    isBaseLayer: true,
-    
-    /**
-     * APIProperty: encodeBBOX
-     * {Boolean} Should the BBOX commas be encoded? The WMS spec says 'no', 
-     * but some services want it that way. Default false.
-     */
-    encodeBBOX: false,
-    
-    /** 
-     * APIProperty: noMagic 
-     * {Boolean} If true, the image format will not be automagicaly switched 
-     *     from image/jpeg to image/png or image/gif when using 
-     *     TRANSPARENT=TRUE. Also isBaseLayer will not changed by the  
-     *     constructor. Default false. 
-     */ 
-    noMagic: false,
-    
-    /**
-     * Property: yx
-     * {Object} Keys in this object are EPSG codes for which the axis order
-     *     is to be reversed (yx instead of xy, LatLon instead of LonLat), with
-     *     true as value. This is only relevant for WMS versions >= 1.3.0, and
-     *     only if yx is not set in <OpenLayers.Projection.defaults> for the
-     *     used projection.
-     */
-    yx: {},
-    
-    /**
-     * Constructor: OpenLayers.Layer.WMS
-     * Create a new WMS layer object
-     *
-     * Examples:
-     *
-     * The code below creates a simple WMS layer using the image/jpeg format.
-     * (code)
-     * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic",
-     *                                    "http://wms.jpl.nasa.gov/wms.cgi", 
-     *                                    {layers: "modis,global_mosaic"});
-     * (end)
-     * Note the 3rd argument (params). Properties added to this object will be
-     * added to the WMS GetMap requests used for this layer's tiles. The only
-     * mandatory parameter is "layers". Other common WMS params include
-     * "transparent", "styles" and "format". Note that the "srs" param will
-     * always be ignored. Instead, it will be derived from the baseLayer's or
-     * map's projection.
-     *
-     * The code below creates a transparent WMS layer with additional options.
-     * (code)
-     * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic",
-     *                                    "http://wms.jpl.nasa.gov/wms.cgi", 
-     *                                    {
-     *                                        layers: "modis,global_mosaic",
-     *                                        transparent: true
-     *                                    }, {
-     *                                        opacity: 0.5,
-     *                                        singleTile: true
-     *                                    });
-     * (end)
-     * Note that by default, a WMS layer is configured as baseLayer. Setting
-     * the "transparent" param to true will apply some magic (see <noMagic>).
-     * The default image format changes from image/jpeg to image/png, and the
-     * layer is not configured as baseLayer.
-     *
-     * Parameters:
-     * name - {String} A name for the layer
-     * url - {String} Base url for the WMS
-     *                (e.g. http://wms.jpl.nasa.gov/wms.cgi)
-     * params - {Object} An object with key/value pairs representing the
-     *                   GetMap query string parameters and parameter values.
-     * options - {Object} Hashtable of extra options to tag onto the layer.
-     *     These options include all properties listed above, plus the ones
-     *     inherited from superclasses.
-     */
-    initialize: function(name, url, params, options) {
-        var newArguments = [];
-        //uppercase params
-        params = OpenLayers.Util.upperCaseObject(params);
-        if (parseFloat(params.VERSION) >= 1.3 && !params.EXCEPTIONS) {
-            params.EXCEPTIONS = "INIMAGE";
-        } 
-        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.noMagic && 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 == "image/jpeg") {
-                this.params.FORMAT = OpenLayers.Util.alphaHack() ? "image/gif"
-                                                                 : "image/png";
-            }
-        }
-
-    },    
-
-    /**
-     * Method: clone
-     * Create a clone of this layer
-     *
-     * Returns:
-     * {<OpenLayers.Layer.WMS>} An exact clone of this layer
-     */
-    clone: function (obj) {
-        
-        if (obj == null) {
-            obj = new OpenLayers.Layer.WMS(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;
-    },    
-    
-    /**
-     * APIMethod: reverseAxisOrder
-     * Returns true if the axis order is reversed for the WMS version and
-     * projection of the layer.
-     * 
-     * Returns:
-     * {Boolean} true if the axis order is reversed, false otherwise.
-     */
-    reverseAxisOrder: function() {
-        var projCode = this.projection.getCode();
-        return parseFloat(this.params.VERSION) >= 1.3 && 
-            !!(this.yx[projCode] || (OpenLayers.Projection.defaults[projCode] && 
-            OpenLayers.Projection.defaults[projCode].yx));
-    },
-    
-    /**
-     * Method: getURL
-     * Return a GetMap query string for this layer
-     *
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>} A bounds representing the bbox for the
-     *                                request.
-     *
-     * Returns:
-     * {String} A string with the layer's url and parameters and also the
-     *          passed-in bounds and appropriate tile size specified as 
-     *          parameters.
-     */
-    getURL: function (bounds) {
-        bounds = this.adjustBounds(bounds);
-        
-        var imageSize = this.getImageSize();
-        var newParams = {};
-        // WMS 1.3 introduced axis order
-        var reverseAxisOrder = this.reverseAxisOrder();
-        newParams.BBOX = this.encodeBBOX ?
-            bounds.toBBOX(null, reverseAxisOrder) :
-            bounds.toArray(reverseAxisOrder);
-        newParams.WIDTH = imageSize.w;
-        newParams.HEIGHT = imageSize.h;
-        var requestString = this.getFullRequestString(newParams);
-        return requestString;
-    },
-
-    /**
-     * 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);
-    },
-
-    /** 
-     * APIMethod: getFullRequestString
-     * Combine the layer's url with its params and these newParams. 
-     *   
-     *     Add the SRS parameter from projection -- this is probably
-     *     more eloquently done via a setProjection() method, but this 
-     *     works for now and always.
-     *
-     * Parameters:
-     * newParams - {Object}
-     * altUrl - {String} Use this as the url instead of the layer's url
-     * 
-     * Returns:
-     * {String} 
-     */
-    getFullRequestString:function(newParams, altUrl) {
-        var mapProjection = this.map.getProjectionObject();
-        var projectionCode = this.projection && this.projection.equals(mapProjection) ?
-            this.projection.getCode() :
-            mapProjection.getCode();
-        var value = (projectionCode == "none") ? null : projectionCode;
-        if (parseFloat(this.params.VERSION) >= 1.3) {
-            this.params.CRS = value;
-        } else {
-            this.params.SRS = value;
-        }
-        
-        if (typeof this.params.TRANSPARENT == "boolean") {
-            newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE";
-        }
-
-        return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(
-                                                    this, arguments);
-    },
-
-    CLASS_NAME: "OpenLayers.Layer.WMS"
-});

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

@@ -1,510 +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.WMTS
- * Instances of the WMTS class allow viewing of tiles from a service that 
- *     implements the OGC WMTS specification version 1.0.0.
- * 
- * Inherits from:
- *  - <OpenLayers.Layer.Grid>
- */
-OpenLayers.Layer.WMTS = OpenLayers.Class(OpenLayers.Layer.Grid, {
-    
-    /**
-     * APIProperty: isBaseLayer
-     * {Boolean} The layer will be considered a base layer.  Default is true.
-     */
-    isBaseLayer: true,
-
-    /**
-     * Property: version
-     * {String} WMTS version.  Default is "1.0.0".
-     */
-    version: "1.0.0",
-    
-    /**
-     * APIProperty: requestEncoding
-     * {String} Request encoding.  Can be "REST" or "KVP".  Default is "KVP".
-     */
-    requestEncoding: "KVP",
-    
-    /**
-     * APIProperty: url
-     * {String|Array(String)} The base URL or request URL template for the WMTS
-     * service. Must be provided. Array is only supported for base URLs, not
-     * for request URL templates. URL templates are only supported for
-     * REST <requestEncoding>.
-     */
-    url: null,
-
-    /**
-     * APIProperty: layer
-     * {String} The layer identifier advertised by the WMTS service.  Must be 
-     *     provided.
-     */
-    layer: null,
-    
-    /** 
-     * APIProperty: matrixSet
-     * {String} One of the advertised matrix set identifiers.  Must be provided.
-     */
-    matrixSet: null,
-
-    /** 
-     * APIProperty: style
-     * {String} One of the advertised layer styles.  Must be provided.
-     */
-    style: null,
-    
-    /** 
-     * APIProperty: format
-     * {String} The image MIME type.  Default is "image/jpeg".
-     */
-    format: "image/jpeg",
-    
-    /**
-     * APIProperty: tileOrigin
-     * {<OpenLayers.LonLat>} The top-left corner of the tile matrix in map 
-     *     units.  If the tile origin for each matrix in a set is different,
-     *     the <matrixIds> should include a topLeftCorner property.  If
-     *     not provided, the tile origin will default to the top left corner
-     *     of the layer <maxExtent>.
-     */
-    tileOrigin: null,
-    
-    /**
-     * APIProperty: tileFullExtent
-     * {<OpenLayers.Bounds>}  The full extent of the tile set.  If not supplied,
-     *     the layer's <maxExtent> property will be used.
-     */
-    tileFullExtent: null,
-
-    /**
-     * APIProperty: formatSuffix
-     * {String} For REST request encoding, an image format suffix must be 
-     *     included in the request.  If not provided, the suffix will be derived
-     *     from the <format> property.
-     */
-    formatSuffix: null,    
-
-    /**
-     * APIProperty: matrixIds
-     * {Array} A list of tile matrix identifiers.  If not provided, the matrix
-     *     identifiers will be assumed to be integers corresponding to the 
-     *     map zoom level.  If a list of strings is provided, each item should
-     *     be the matrix identifier that corresponds to the map zoom level.
-     *     Additionally, a list of objects can be provided.  Each object should
-     *     describe the matrix as presented in the WMTS capabilities.  These
-     *     objects should have the propertes shown below.
-     * 
-     * Matrix properties:
-     * identifier - {String} The matrix identifier (required).
-     * scaleDenominator - {Number} The matrix scale denominator.
-     * topLeftCorner - {<OpenLayers.LonLat>} The top left corner of the 
-     *     matrix.  Must be provided if different than the layer <tileOrigin>.
-     * tileWidth - {Number} The tile width for the matrix.  Must be provided 
-     *     if different than the width given in the layer <tileSize>.
-     * tileHeight - {Number} The tile height for the matrix.  Must be provided 
-     *     if different than the height given in the layer <tileSize>.
-     */
-    matrixIds: null,
-    
-    /**
-     * APIProperty: dimensions
-     * {Array} For RESTful request encoding, extra dimensions may be specified.
-     *     Items in this list should be property names in the <params> object.
-     *     Values of extra dimensions will be determined from the corresponding
-     *     values in the <params> object.
-     */
-    dimensions: null,
-    
-    /**
-     * APIProperty: params
-     * {Object} Extra parameters to include in tile requests.  For KVP 
-     *     <requestEncoding>, these properties will be encoded in the request 
-     *     query string.  For REST <requestEncoding>, these properties will
-     *     become part of the request path, with order determined by the 
-     *     <dimensions> list.
-     */
-    params: null,
-    
-    /**
-     * APIProperty: zoomOffset
-     * {Number} If your cache has more levels than you want to provide
-     *     access to with this layer, supply a zoomOffset.  This zoom offset
-     *     is added to the current map zoom level to determine the level
-     *     for a requested tile.  For example, if you supply a zoomOffset
-     *     of 3, when the map is at the zoom 0, tiles will be requested from
-     *     level 3 of your cache.  Default is 0 (assumes cache level and map
-     *     zoom are equivalent).  Additionally, if this layer is to be used
-     *     as an overlay and the cache has fewer zoom levels than the base
-     *     layer, you can supply a negative zoomOffset.  For example, if a
-     *     map zoom level of 1 corresponds to your cache level zero, you would
-     *     supply a -1 zoomOffset (and set the maxResolution of the layer
-     *     appropriately).  The zoomOffset value has no effect if complete
-     *     matrix definitions (including scaleDenominator) are supplied in
-     *     the <matrixIds> property.  Defaults to 0 (no zoom offset).
-     */
-    zoomOffset: 0,
-
-    /**
-     * APIProperty: serverResolutions
-     * {Array} A list of all resolutions available on the server.  Only set this
-     *     property if the map resolutions differ from the server. This
-     *     property serves two purposes. (a) <serverResolutions> can include
-     *     resolutions that the server supports and that you don't want to
-     *     provide with this layer; you can also look at <zoomOffset>, which is
-     *     an alternative to <serverResolutions> for that specific purpose.
-     *     (b) The map can work with resolutions that aren't supported by
-     *     the server, i.e. that aren't in <serverResolutions>. When the
-     *     map is displayed in such a resolution data for the closest
-     *     server-supported resolution is loaded and the layer div is
-     *     stretched as necessary.
-     */
-    serverResolutions: null,
-
-    /**
-     * Property: formatSuffixMap
-     * {Object} a map between WMTS 'format' request parameter and tile image file suffix
-     */
-    formatSuffixMap: {
-        "image/png": "png",
-        "image/png8": "png",
-        "image/png24": "png",
-        "image/png32": "png",
-        "png": "png",
-        "image/jpeg": "jpg",
-        "image/jpg": "jpg",
-        "jpeg": "jpg",
-        "jpg": "jpg"
-    },
-    
-    /**
-     * Property: matrix
-     * {Object} Matrix definition for the current map resolution.  Updated by
-     *     the <updateMatrixProperties> method.
-     */
-    matrix: null,
-    
-    /**
-     * Constructor: OpenLayers.Layer.WMTS
-     * Create a new WMTS layer.
-     *
-     * Example:
-     * (code)
-     * var wmts = new OpenLayers.Layer.WMTS({
-     *     name: "My WMTS Layer",
-     *     url: "http://example.com/wmts", 
-     *     layer: "layer_id",
-     *     style: "default",
-     *     matrixSet: "matrix_id"
-     * });
-     * (end)
-     *
-     * Parameters:
-     * config - {Object} Configuration properties for the layer.
-     *
-     * Required configuration properties:
-     * url - {String} The base url for the service.  See the <url> property.
-     * layer - {String} The layer identifier.  See the <layer> property.
-     * style - {String} The layer style identifier.  See the <style> property.
-     * matrixSet - {String} The tile matrix set identifier.  See the <matrixSet>
-     *     property.
-     *
-     * Any other documented layer properties can be provided in the config object.
-     */
-    initialize: function(config) {
-
-        // confirm required properties are supplied
-        var required = {
-            url: true,
-            layer: true,
-            style: true,
-            matrixSet: true
-        };
-        for (var prop in required) {
-            if (!(prop in config)) {
-                throw new Error("Missing property '" + prop + "' in layer configuration.");
-            }
-        }
-
-        config.params = OpenLayers.Util.upperCaseObject(config.params);
-        var args = [config.name, config.url, config.params, config];
-        OpenLayers.Layer.Grid.prototype.initialize.apply(this, args);
-        
-
-        // determine format suffix (for REST)
-        if (!this.formatSuffix) {
-            this.formatSuffix = this.formatSuffixMap[this.format] || this.format.split("/").pop();            
-        }
-
-        // expand matrixIds (may be array of string or array of object)
-        if (this.matrixIds) {
-            var len = this.matrixIds.length;
-            if (len && typeof this.matrixIds[0] === "string") {
-                var ids = this.matrixIds;
-                this.matrixIds = new Array(len);
-                for (var i=0; i<len; ++i) {
-                    this.matrixIds[i] = {identifier: ids[i]};
-                }
-            }
-        }
-
-    },
-    
-    /**
-     * Method: setMap
-     */
-    setMap: function() {
-        OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments);
-    },
-    
-    /**
-     * Method: updateMatrixProperties
-     * Called when map resolution changes to update matrix related properties.
-     */
-    updateMatrixProperties: function() {
-        this.matrix = this.getMatrix();
-        if (this.matrix) {
-            if (this.matrix.topLeftCorner) {
-                this.tileOrigin = this.matrix.topLeftCorner;
-            }
-            if (this.matrix.tileWidth && this.matrix.tileHeight) {
-                this.tileSize = new OpenLayers.Size(
-                    this.matrix.tileWidth, this.matrix.tileHeight
-                );
-            }
-            if (!this.tileOrigin) { 
-                this.tileOrigin = new OpenLayers.LonLat(
-                    this.maxExtent.left, this.maxExtent.top
-                );
-            }   
-            if (!this.tileFullExtent) { 
-                this.tileFullExtent = this.maxExtent;
-            }
-        }
-    },
-    
-    /**
-     * Method: moveTo
-     * 
-     * Parameters:
-     * bounds - {<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) {
-        if (zoomChanged || !this.matrix) {
-            this.updateMatrixProperties();
-        }
-        return OpenLayers.Layer.Grid.prototype.moveTo.apply(this, arguments);
-    },
-
-    /**
-     * APIMethod: clone
-     * 
-     * Parameters:
-     * obj - {Object}
-     * 
-     * Returns:
-     * {<OpenLayers.Layer.WMTS>} An exact clone of this <OpenLayers.Layer.WMTS>
-     */
-    clone: function(obj) {
-        if (obj == null) {
-            obj = new OpenLayers.Layer.WMTS(this.options);
-        }
-        //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: getIdentifier
-     * Get the current index in the matrixIds array.
-     */
-    getIdentifier: function() {
-        return this.getServerZoom();
-    },
-    
-    /**
-     * Method: getMatrix
-     * Get the appropriate matrix definition for the current map resolution.
-     */
-    getMatrix: function() {
-        var matrix;
-        if (!this.matrixIds || this.matrixIds.length === 0) {
-            matrix = {identifier: this.getIdentifier()};
-        } else {
-            // get appropriate matrix given the map scale if possible
-            if ("scaleDenominator" in this.matrixIds[0]) {
-                // scale denominator calculation based on WMTS spec
-                var denom = 
-                    OpenLayers.METERS_PER_INCH * 
-                    OpenLayers.INCHES_PER_UNIT[this.units] * 
-                    this.getServerResolution() / 0.28E-3;
-                var diff = Number.POSITIVE_INFINITY;
-                var delta;
-                for (var i=0, ii=this.matrixIds.length; i<ii; ++i) {
-                    delta = Math.abs(1 - (this.matrixIds[i].scaleDenominator / denom));
-                    if (delta < diff) {
-                        diff = delta;
-                        matrix = this.matrixIds[i];
-                    }
-                }
-            } else {
-                // fall back on zoom as index
-                matrix = this.matrixIds[this.getIdentifier()];
-            }
-        }
-        return matrix;
-    },
-    
-    /** 
-     * Method: getTileInfo
-     * Get tile information for a given location at the current map resolution.
-     *
-     * Parameters:
-     * loc - {<OpenLayers.LonLat} A location in map coordinates.
-     *
-     * Returns:
-     * {Object} An object with "col", "row", "i", and "j" properties.  The col
-     *     and row values are zero based tile indexes from the top left.  The
-     *     i and j values are the number of pixels to the left and top 
-     *     (respectively) of the given location within the target tile.
-     */
-    getTileInfo: function(loc) {
-        var res = this.getServerResolution();
-        
-        var fx = (loc.lon - this.tileOrigin.lon) / (res * this.tileSize.w);
-        var fy = (this.tileOrigin.lat - loc.lat) / (res * this.tileSize.h);
-
-        var col = Math.floor(fx);
-        var row = Math.floor(fy);
-        
-        return {
-            col: col, 
-            row: row,
-            i: Math.floor((fx - col) * this.tileSize.w),
-            j: Math.floor((fy - row) * this.tileSize.h)
-        };
-    },
-    
-    /**
-     * Method: getURL
-     * 
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>}
-     * 
-     * Returns:
-     * {String} A URL for the tile corresponding to the given bounds.
-     */
-    getURL: function(bounds) {
-        bounds = this.adjustBounds(bounds);
-        var url = "";
-        if (!this.tileFullExtent || this.tileFullExtent.intersectsBounds(bounds)) {            
-
-            var center = bounds.getCenterLonLat();            
-            var info = this.getTileInfo(center);
-            var matrixId = this.matrix.identifier;
-            var dimensions = this.dimensions, params;
-
-            if (OpenLayers.Util.isArray(this.url)) {
-                url = this.selectUrl([
-                    this.version, this.style, this.matrixSet,
-                    this.matrix.identifier, info.row, info.col
-                ].join(","), this.url);
-            } else {
-                url = this.url;
-            }
-
-            if (this.requestEncoding.toUpperCase() === "REST") {
-                params = this.params;
-                if (url.indexOf("{") !== -1) {
-                    var template = url.replace(/\{/g, "${");
-                    var context = {
-                        // spec does not make clear if capital S or not
-                        style: this.style, Style: this.style,
-                        TileMatrixSet: this.matrixSet,
-                        TileMatrix: this.matrix.identifier,
-                        TileRow: info.row,
-                        TileCol: info.col
-                    };
-                    if (dimensions) {
-                        var dimension, i;
-                        for (i=dimensions.length-1; i>=0; --i) {
-                            dimension = dimensions[i];
-                            context[dimension] = params[dimension.toUpperCase()];
-                        }
-                    }
-                    url = OpenLayers.String.format(template, context);
-                } else {
-                    // include 'version', 'layer' and 'style' in tile resource url
-                    var path = this.version + "/" + this.layer + "/" + this.style + "/";
-
-                    // append optional dimension path elements
-                    if (dimensions) {
-                        for (var i=0; i<dimensions.length; i++) {
-                            if (params[dimensions[i]]) {
-                                path = path + params[dimensions[i]] + "/";
-                            }
-                        }
-                    }
-
-                    // append other required path elements
-                    path = path + this.matrixSet + "/" + this.matrix.identifier + 
-                        "/" + info.row + "/" + info.col + "." + this.formatSuffix;
-
-                    if (!url.match(/\/$/)) {
-                        url = url + "/";
-                    }
-                    url = url + path;
-                }
-            } else if (this.requestEncoding.toUpperCase() === "KVP") {
-
-                // assemble all required parameters
-                params = {
-                    SERVICE: "WMTS",
-                    REQUEST: "GetTile",
-                    VERSION: this.version,
-                    LAYER: this.layer,
-                    STYLE: this.style,
-                    TILEMATRIXSET: this.matrixSet,
-                    TILEMATRIX: this.matrix.identifier,
-                    TILEROW: info.row,
-                    TILECOL: info.col,
-                    FORMAT: this.format
-                };
-                url = OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, [params]);
-
-            }
-        }
-        return url;    
-    },
-    
-    /**
-     * APIMethod: mergeNewParams
-     * Extend the existing layer <params> with new properties.  Tiles will be
-     *     reloaded with updated params in the request.
-     * 
-     * Parameters:
-     * newParams - {Object} Properties to extend to existing <params>.
-     */
-    mergeNewParams: function(newParams) {
-        if (this.requestEncoding.toUpperCase() === "KVP") {
-            return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(
-                this, [OpenLayers.Util.upperCaseObject(newParams)]
-            );
-        }
-    },
-
-    CLASS_NAME: "OpenLayers.Layer.WMTS"
-});