]> dev.renevier.net Git - syp.git/blob - openlayers/lib/OpenLayers/Layer/KaMap.js
update german translation
[syp.git] / openlayers / lib / OpenLayers / Layer / KaMap.js
1 /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
2  * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
3  * full text of the license. */
4
5
6 /**
7  * @requires OpenLayers/Layer/Grid.js
8  */
9
10 /**
11  * Class: OpenLayers.Layer.KaMap
12  * 
13  * Inherits from:
14  *  - <OpenLayers.Layer.Grid>
15  */
16 OpenLayers.Layer.KaMap = OpenLayers.Class(OpenLayers.Layer.Grid, {
17
18     /** 
19      * APIProperty: isBaseLayer
20      * {Boolean} KaMap Layer is always a base layer 
21      */    
22     isBaseLayer: true,
23
24     /**
25      * APIProperty: units
26      * {?}
27      */    
28     units: null,
29
30     /**
31      * APIProperty: resolution
32      * {Float}
33      */
34     resolution: OpenLayers.DOTS_PER_INCH,
35     
36     /**
37      * Constant: DEFAULT_PARAMS
38      * {Object} parameters set by default. The default parameters set 
39      * the format via the 'i' parameter to 'jpeg'.    
40      */
41     DEFAULT_PARAMS: {
42         i: 'jpeg',
43         map: ''
44     },
45         
46     /**
47      * Constructor: OpenLayers.Layer.KaMap
48      * 
49      * Parameters:
50      * name - {String}
51      * url - {String}
52      * params - {Object} Parameters to be sent to the HTTP server in the
53      *    query string for the tile. The format can be set via the 'i'
54      *    parameter (defaults to jpg) , and the map should be set via 
55      *    the 'map' parameter. It has been reported that ka-Map may behave
56      *    inconsistently if your format parameter does not match the format
57      *    parameter configured in your config.php. (See ticket #327 for more
58      *    information.)
59      * options - {Object} Additional options for the layer. Any of the 
60      *     APIProperties listed on this layer, and any layer types it
61      *     extends, can be overridden through the options parameter. 
62      */
63     initialize: function(name, url, params, options) {
64         var newArguments = [];
65         newArguments.push(name, url, params, options);
66         OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
67         this.params = OpenLayers.Util.applyDefaults(
68             this.params, this.DEFAULT_PARAMS
69         );
70     },
71
72     /**
73      * Method: getURL
74      * 
75      * Parameters:
76      * bounds - {<OpenLayers.Bounds>} 
77      * 
78      * Returns:
79      * {String} A string with the layer's url and parameters and also the 
80      *          passed-in bounds and appropriate tile size specified as 
81      *          parameters
82      */
83     getURL: function (bounds) {
84         bounds = this.adjustBounds(bounds);
85         var mapRes = this.map.getResolution();
86         var scale = Math.round((this.map.getScale() * 10000)) / 10000;
87         var pX = Math.round(bounds.left / mapRes);
88         var pY = -Math.round(bounds.top / mapRes);
89         return this.getFullRequestString(
90                       { t: pY, 
91                         l: pX,
92                         s: scale
93                       });
94     },
95
96     /**
97      * Method: addTile
98      * 
99      * Parameters:
100      * bounds - {<OpenLayers.Bounds>}
101      * position - {<OpenLayers.Pixel>}
102      * 
103      * Returns:
104      * {<OpenLayers.Tile.Image>}
105      */    
106     addTile:function(bounds,position) {
107         var url = this.getURL(bounds);
108         return new OpenLayers.Tile.Image(this, position, bounds, 
109                                              url, this.tileSize);
110     },
111
112     /** 
113      * Method: calculateGridLayout
114      * ka-Map uses the center point of the map as an origin for 
115      * its tiles. Override calculateGridLayout to center tiles 
116      * correctly for this case.
117      *
118      * Parameters:
119      * bounds - {<OpenLayers.Bound>}
120      * extent - {<OpenLayers.Bounds>}
121      * resolution - {Number}
122      *
123      * Returns:
124      * Object containing properties tilelon, tilelat, tileoffsetlat,
125      * tileoffsetlat, tileoffsetx, tileoffsety
126      */
127     calculateGridLayout: function(bounds, extent, resolution) {
128         var tilelon = resolution*this.tileSize.w;
129         var tilelat = resolution*this.tileSize.h;
130         
131         var offsetlon = bounds.left;
132         var tilecol = Math.floor(offsetlon/tilelon) - this.buffer;
133         var tilecolremain = offsetlon/tilelon - tilecol;
134         var tileoffsetx = -tilecolremain * this.tileSize.w;
135         var tileoffsetlon = tilecol * tilelon;
136         
137         var offsetlat = bounds.top;  
138         var tilerow = Math.ceil(offsetlat/tilelat) + this.buffer;
139         var tilerowremain = tilerow - offsetlat/tilelat;
140         var tileoffsety = -(tilerowremain+1) * this.tileSize.h;
141         var tileoffsetlat = tilerow * tilelat;
142         
143         return { 
144           tilelon: tilelon, tilelat: tilelat,
145           tileoffsetlon: tileoffsetlon, tileoffsetlat: tileoffsetlat,
146           tileoffsetx: tileoffsetx, tileoffsety: tileoffsety
147         };
148     },    
149
150     /**
151      * APIMethod: clone
152      * 
153      * Parameters: 
154      * obj - {Object}
155      * 
156      * Returns:
157      * {<OpenLayers.Layer.Kamap>} An exact clone of this OpenLayers.Layer.KaMap
158      */
159     clone: function (obj) {
160         
161         if (obj == null) {
162             obj = new OpenLayers.Layer.KaMap(this.name,
163                                             this.url,
164                                             this.params,
165                                             this.options);
166         }
167
168         //get all additions from superclasses
169         obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
170
171         // copy/set any non-init, non-simple values here
172         if (this.tileSize != null) {
173             obj.tileSize = this.tileSize.clone();
174         }
175         
176         // we do not want to copy reference to grid, so we make a new array
177         obj.grid = [];
178
179         return obj;
180     },    
181     
182     /**
183      * APIMethod: getTileBounds
184      * Returns The tile bounds for a layer given a pixel location.
185      *
186      * Parameters:
187      * viewPortPx - {<OpenLayers.Pixel>} The location in the viewport.
188      *
189      * Returns:
190      * {<OpenLayers.Bounds>} Bounds of the tile at the given pixel location.
191      */
192     getTileBounds: function(viewPortPx) {
193         var resolution = this.getResolution();
194         var tileMapWidth = resolution * this.tileSize.w;
195         var tileMapHeight = resolution * this.tileSize.h;
196         var mapPoint = this.getLonLatFromViewPortPx(viewPortPx);
197         var tileLeft = tileMapWidth * Math.floor(mapPoint.lon / tileMapWidth);
198         var tileBottom = tileMapHeight * Math.floor(mapPoint.lat / tileMapHeight);
199         return new OpenLayers.Bounds(tileLeft, tileBottom,
200                                      tileLeft + tileMapWidth,
201                                      tileBottom + tileMapHeight);
202     },
203
204     CLASS_NAME: "OpenLayers.Layer.KaMap"
205 });