/* 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/Grid.js
*/
/**
* Class: OpenLayers.Layer.KaMap
*
* Inherits from:
* - <OpenLayers.Layer.Grid>
*/
OpenLayers.Layer.KaMap = OpenLayers.Class(OpenLayers.Layer.Grid, {
/**
* APIProperty: isBaseLayer
* {Boolean} KaMap Layer is always a base layer
*/
isBaseLayer: true,
/**
* APIProperty: units
* {?}
*/
units: null,
/**
* APIProperty: resolution
* {Float}
*/
resolution: OpenLayers.DOTS_PER_INCH,
/**
* Constant: DEFAULT_PARAMS
* {Object} parameters set by default. The default parameters set
* the format via the 'i' parameter to 'jpeg'.
*/
DEFAULT_PARAMS: {
i: 'jpeg',
map: ''
},
/**
* Constructor: OpenLayers.Layer.KaMap
*
* Parameters:
* name - {String}
* url - {String}
* params - {Object} Parameters to be sent to the HTTP server in the
* query string for the tile. The format can be set via the 'i'
* parameter (defaults to jpg) , and the map should be set via
* the 'map' parameter. It has been reported that ka-Map may behave
* inconsistently if your format parameter does not match the format
* parameter configured in your config.php. (See ticket #327 for more
* information.)
* options - {Object} Additional options for the layer. Any of the
* APIProperties listed on this layer, and any layer types it
* extends, can be overridden through the options parameter.
*/
initialize: function(name, url, params, options) {
var newArguments = [];
newArguments.push(name, url, params, options);
OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
this.params = OpenLayers.Util.applyDefaults(
this.params, this.DEFAULT_PARAMS
);
},
/**
* Method: getURL
*
* Parameters:
* bounds - {<OpenLayers.Bounds>}
*
* 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 mapRes = this.map.getResolution();
var scale = Math.round((this.map.getScale() * 10000)) / 10000;
var pX = Math.round(bounds.left / mapRes);
var pY = -Math.round(bounds.top / mapRes);
return this.getFullRequestString(
{ t: pY,
l: pX,
s: scale
});
},
/**
* Method: addTile
*
* Parameters:
* bounds - {<OpenLayers.Bounds>}
* position - {<OpenLayers.Pixel>}
*
* Returns:
* {<OpenLayers.Tile.Image>}
*/
addTile:function(bounds,position) {
var url = this.getURL(bounds);
return new OpenLayers.Tile.Image(this, position, bounds,
url, this.tileSize);
},
/**
* Method: calculateGridLayout
* ka-Map uses the center point of the map as an origin for
* its tiles. Override calculateGridLayout to center tiles
* correctly for this case.
*
* Parameters:
* bounds - {<OpenLayers.Bound>}
* extent - {<OpenLayers.Bounds>}
* resolution - {Number}
*
* Returns:
* Object containing properties tilelon, tilelat, tileoffsetlat,
* tileoffsetlat, tileoffsetx, tileoffsety
*/
calculateGridLayout: function(bounds, extent, resolution) {
var tilelon = resolution*this.tileSize.w;
var tilelat = resolution*this.tileSize.h;
var offsetlon = bounds.left;
var tilecol = Math.floor(offsetlon/tilelon) - this.buffer;
var tilecolremain = offsetlon/tilelon - tilecol;
var tileoffsetx = -tilecolremain * this.tileSize.w;
var tileoffsetlon = tilecol * tilelon;
var offsetlat = bounds.top;
var tilerow = Math.ceil(offsetlat/tilelat) + this.buffer;
var tilerowremain = tilerow - offsetlat/tilelat;
var tileoffsety = -(tilerowremain+1) * this.tileSize.h;
var tileoffsetlat = tilerow * tilelat;
return {
tilelon: tilelon, tilelat: tilelat,
tileoffsetlon: tileoffsetlon, tileoffsetlat: tileoffsetlat,
tileoffsetx: tileoffsetx, tileoffsety: tileoffsety
};
},
/**
* APIMethod: clone
*
* Parameters:
* obj - {Object}
*
* Returns:
* {<OpenLayers.Layer.Kamap>} An exact clone of this OpenLayers.Layer.KaMap
*/
clone: function (obj) {
if (obj == null) {
obj = new OpenLayers.Layer.KaMap(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
if (this.tileSize != null) {
obj.tileSize = this.tileSize.clone();
}
// we do not want to copy reference to grid, so we make a new array
obj.grid = [];
return obj;
},
/**
* APIMethod: getTileBounds
* Returns The tile bounds for a layer given a pixel location.
*
* Parameters:
* viewPortPx - {<OpenLayers.Pixel>} The location in the viewport.
*
* Returns:
* {<OpenLayers.Bounds>} Bounds of the tile at the given pixel location.
*/
getTileBounds: function(viewPortPx) {
var resolution = this.getResolution();
var tileMapWidth = resolution * this.tileSize.w;
var tileMapHeight = resolution * this.tileSize.h;
var mapPoint = this.getLonLatFromViewPortPx(viewPortPx);
var tileLeft = tileMapWidth * Math.floor(mapPoint.lon / tileMapWidth);
var tileBottom = tileMapHeight * Math.floor(mapPoint.lat / tileMapHeight);
return new OpenLayers.Bounds(tileLeft, tileBottom,
tileLeft + tileMapWidth,
tileBottom + tileMapHeight);
},
CLASS_NAME: "OpenLayers.Layer.KaMap"
});