← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/openlayers/lib/OpenLayers/Layer/EventPane.js

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/openlayers/lib/OpenLayers/Layer/EventPane.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.js
 
8
 * @requires OpenLayers/Util.js
 
9
 */
 
10
 
 
11
/**
 
12
 * Class: OpenLayers.Layer.EventPane
 
13
 * Base class for 3rd party layers.  Create a new event pane layer with the
 
14
 * <OpenLayers.Layer.EventPane> constructor.
 
15
 * 
 
16
 * Inherits from:
 
17
 *  - <OpenLayers.Layer>
 
18
 */
 
19
OpenLayers.Layer.EventPane = OpenLayers.Class(OpenLayers.Layer, {
 
20
    
 
21
    /**
 
22
     * APIProperty: smoothDragPan
 
23
     * {Boolean} smoothDragPan determines whether non-public/internal API
 
24
     *     methods are used for better performance while dragging EventPane 
 
25
     *     layers. When not in sphericalMercator mode, the smoother dragging 
 
26
     *     doesn't actually move north/south directly with the number of 
 
27
     *     pixels moved, resulting in a slight offset when you drag your mouse 
 
28
     *     north south with this option on. If this visual disparity bothers 
 
29
     *     you, you should turn this option off, or use spherical mercator. 
 
30
     *     Default is on.
 
31
     */
 
32
    smoothDragPan: true,
 
33
 
 
34
    /**
 
35
     * Property: isBaseLayer
 
36
     * {Boolean} EventPaned layers are always base layers, by necessity.
 
37
     */ 
 
38
    isBaseLayer: true,
 
39
 
 
40
    /**
 
41
     * APIProperty: isFixed
 
42
     * {Boolean} EventPaned layers are fixed by default.
 
43
     */ 
 
44
    isFixed: true,
 
45
 
 
46
    /**
 
47
     * Property: pane
 
48
     * {DOMElement} A reference to the element that controls the events.
 
49
     */
 
50
    pane: null,
 
51
 
 
52
 
 
53
    /**
 
54
     * Property: mapObject
 
55
     * {Object} This is the object which will be used to load the 3rd party library
 
56
     * in the case of the google layer, this will be of type GMap, 
 
57
     * in the case of the ve layer, this will be of type VEMap
 
58
     */ 
 
59
    mapObject: null,
 
60
 
 
61
 
 
62
    /**
 
63
     * Constructor: OpenLayers.Layer.EventPane
 
64
     * Create a new event pane layer
 
65
     *
 
66
     * Parameters:
 
67
     * name - {String}
 
68
     * options - {Object} Hashtable of extra options to tag onto the layer
 
69
     */
 
70
    initialize: function(name, options) {
 
71
        OpenLayers.Layer.prototype.initialize.apply(this, arguments);
 
72
        if (this.pane == null) {
 
73
            this.pane = OpenLayers.Util.createDiv(this.div.id + "_EventPane");
 
74
        }
 
75
    },
 
76
    
 
77
    /**
 
78
     * APIMethod: destroy
 
79
     * Deconstruct this layer.
 
80
     */
 
81
    destroy: function() {
 
82
        this.mapObject = null;
 
83
        OpenLayers.Layer.prototype.destroy.apply(this, arguments); 
 
84
    },
 
85
 
 
86
    
 
87
    /**
 
88
     * Method: setMap
 
89
     * Set the map property for the layer. This is done through an accessor
 
90
     * so that subclasses can override this and take special action once 
 
91
     * they have their map variable set. 
 
92
     *
 
93
     * Parameters:
 
94
     * map - {<OpenLayers.Map>}
 
95
     */
 
96
    setMap: function(map) {
 
97
        OpenLayers.Layer.prototype.setMap.apply(this, arguments);
 
98
        
 
99
        this.pane.style.zIndex = parseInt(this.div.style.zIndex) + 1;
 
100
        this.pane.style.display = this.div.style.display;
 
101
        this.pane.style.width="100%";
 
102
        this.pane.style.height="100%";
 
103
        if (OpenLayers.Util.getBrowserName() == "msie") {
 
104
            this.pane.style.background = 
 
105
                "url(" + OpenLayers.Util.getImagesLocation() + "blank.gif)";
 
106
        }
 
107
 
 
108
        if (this.isFixed) {
 
109
            this.map.viewPortDiv.appendChild(this.pane);
 
110
        } else {
 
111
            this.map.layerContainerDiv.appendChild(this.pane);
 
112
        }
 
113
 
 
114
        // once our layer has been added to the map, we can load it
 
115
        this.loadMapObject();
 
116
    
 
117
        // if map didn't load, display warning
 
118
        if (this.mapObject == null) {
 
119
            this.loadWarningMessage();
 
120
        }
 
121
    },
 
122
 
 
123
    /**
 
124
     * APIMethod: removeMap
 
125
     * On being removed from the map, we'll like to remove the invisible 'pane'
 
126
     *     div that we added to it on creation. 
 
127
     * 
 
128
     * Parameters:
 
129
     * map - {<OpenLayers.Map>}
 
130
     */
 
131
    removeMap: function(map) {
 
132
        if (this.pane && this.pane.parentNode) {
 
133
            this.pane.parentNode.removeChild(this.pane);
 
134
            this.pane = null;
 
135
        }
 
136
        OpenLayers.Layer.prototype.removeMap.apply(this, arguments);
 
137
    },
 
138
  
 
139
    /**
 
140
     * Method: loadWarningMessage
 
141
     * If we can't load the map lib, then display an error message to the 
 
142
     *     user and tell them where to go for help.
 
143
     * 
 
144
     *     This function sets up the layout for the warning message. Each 3rd
 
145
     *     party layer must implement its own getWarningHTML() function to 
 
146
     *     provide the actual warning message.
 
147
     */
 
148
    loadWarningMessage:function() {
 
149
 
 
150
        this.div.style.backgroundColor = "darkblue";
 
151
 
 
152
        var viewSize = this.map.getSize();
 
153
        
 
154
        var msgW = Math.min(viewSize.w, 300);
 
155
        var msgH = Math.min(viewSize.h, 200);
 
156
        var size = new OpenLayers.Size(msgW, msgH);
 
157
 
 
158
        var centerPx = new OpenLayers.Pixel(viewSize.w/2, viewSize.h/2);
 
159
 
 
160
        var topLeft = centerPx.add(-size.w/2, -size.h/2);            
 
161
 
 
162
        var div = OpenLayers.Util.createDiv(this.name + "_warning", 
 
163
                                            topLeft, 
 
164
                                            size,
 
165
                                            null,
 
166
                                            null,
 
167
                                            null,
 
168
                                            "auto");
 
169
 
 
170
        div.style.padding = "7px";
 
171
        div.style.backgroundColor = "yellow";
 
172
 
 
173
        div.innerHTML = this.getWarningHTML();
 
174
        this.div.appendChild(div);
 
175
    },
 
176
  
 
177
    /** 
 
178
     * Method: getWarningHTML
 
179
     * To be implemented by subclasses.
 
180
     * 
 
181
     * Returns:
 
182
     * {String} String with information on why layer is broken, how to get
 
183
     *          it working.
 
184
     */
 
185
    getWarningHTML:function() {
 
186
        //should be implemented by subclasses
 
187
        return "";
 
188
    },
 
189
  
 
190
    /**
 
191
     * Method: display
 
192
     * Set the display on the pane
 
193
     *
 
194
     * Parameters:
 
195
     * display - {Boolean}
 
196
     */
 
197
    display: function(display) {
 
198
        OpenLayers.Layer.prototype.display.apply(this, arguments);
 
199
        this.pane.style.display = this.div.style.display;
 
200
    },
 
201
  
 
202
    /**
 
203
     * Method: setZIndex
 
204
     * Set the z-index order for the pane.
 
205
     * 
 
206
     * Parameters:
 
207
     * zIndex - {int}
 
208
     */
 
209
    setZIndex: function (zIndex) {
 
210
        OpenLayers.Layer.prototype.setZIndex.apply(this, arguments);
 
211
        this.pane.style.zIndex = parseInt(this.div.style.zIndex) + 1;
 
212
    },
 
213
 
 
214
    /**
 
215
     * Method: moveTo
 
216
     * Handle calls to move the layer.
 
217
     * 
 
218
     * Parameters:
 
219
     * bounds - {<OpenLayers.Bounds>}
 
220
     * zoomChanged - {Boolean}
 
221
     * dragging - {Boolean}
 
222
     */
 
223
    moveTo:function(bounds, zoomChanged, dragging) {
 
224
        OpenLayers.Layer.prototype.moveTo.apply(this, arguments);
 
225
 
 
226
        if (this.mapObject != null) {
 
227
 
 
228
            var newCenter = this.map.getCenter();
 
229
            var newZoom = this.map.getZoom();
 
230
 
 
231
            if (newCenter != null) {
 
232
 
 
233
                var moOldCenter = this.getMapObjectCenter();
 
234
                var oldCenter = this.getOLLonLatFromMapObjectLonLat(moOldCenter);
 
235
 
 
236
                var moOldZoom = this.getMapObjectZoom();
 
237
                var oldZoom= this.getOLZoomFromMapObjectZoom(moOldZoom);
 
238
 
 
239
                if ( !(newCenter.equals(oldCenter)) || 
 
240
                     !(newZoom == oldZoom) ) {
 
241
 
 
242
                    if (dragging && this.dragPanMapObject && 
 
243
                        this.smoothDragPan) {
 
244
                        var oldPx = this.map.getViewPortPxFromLonLat(oldCenter);
 
245
                        var newPx = this.map.getViewPortPxFromLonLat(newCenter);
 
246
                        this.dragPanMapObject(newPx.x-oldPx.x, oldPx.y-newPx.y);
 
247
                    } else {
 
248
                        var center = this.getMapObjectLonLatFromOLLonLat(newCenter);
 
249
                        var zoom = this.getMapObjectZoomFromOLZoom(newZoom);
 
250
                        this.setMapObjectCenter(center, zoom, dragging);
 
251
                    }
 
252
                }
 
253
            }
 
254
        }
 
255
    },
 
256
 
 
257
 
 
258
  /********************************************************/
 
259
  /*                                                      */
 
260
  /*                 Baselayer Functions                  */
 
261
  /*                                                      */
 
262
  /********************************************************/
 
263
 
 
264
    /**
 
265
     * Method: getLonLatFromViewPortPx
 
266
     * Get a map location from a pixel location
 
267
     * 
 
268
     * Parameters:
 
269
     * viewPortPx - {<OpenLayers.Pixel>}
 
270
     *
 
271
     * Returns:
 
272
     *  {<OpenLayers.LonLat>} An OpenLayers.LonLat which is the passed-in view
 
273
     *  port OpenLayers.Pixel, translated into lon/lat by map lib
 
274
     *  If the map lib is not loaded or not centered, returns null
 
275
     */
 
276
    getLonLatFromViewPortPx: function (viewPortPx) {
 
277
        var lonlat = null;
 
278
        if ( (this.mapObject != null) && 
 
279
             (this.getMapObjectCenter() != null) ) {
 
280
            var moPixel = this.getMapObjectPixelFromOLPixel(viewPortPx);
 
281
            var moLonLat = this.getMapObjectLonLatFromMapObjectPixel(moPixel);
 
282
            lonlat = this.getOLLonLatFromMapObjectLonLat(moLonLat);
 
283
        }
 
284
        return lonlat;
 
285
    },
 
286
 
 
287
 
 
288
    /**
 
289
     * Method: getViewPortPxFromLonLat
 
290
     * Get a pixel location from a map location
 
291
     *
 
292
     * Parameters:
 
293
     * lonlat - {<OpenLayers.LonLat>}
 
294
     *
 
295
     * Returns:
 
296
     * {<OpenLayers.Pixel>} An OpenLayers.Pixel which is the passed-in
 
297
     * OpenLayers.LonLat, translated into view port pixels by map lib
 
298
     * If map lib is not loaded or not centered, returns null
 
299
     */
 
300
    getViewPortPxFromLonLat: function (lonlat) {
 
301
        var viewPortPx = null;
 
302
        if ( (this.mapObject != null) && 
 
303
             (this.getMapObjectCenter() != null) ) {
 
304
 
 
305
            var moLonLat = this.getMapObjectLonLatFromOLLonLat(lonlat);
 
306
            var moPixel = this.getMapObjectPixelFromMapObjectLonLat(moLonLat);
 
307
        
 
308
            viewPortPx = this.getOLPixelFromMapObjectPixel(moPixel);
 
309
        }
 
310
        return viewPortPx;
 
311
    },
 
312
 
 
313
  /********************************************************/
 
314
  /*                                                      */
 
315
  /*               Translation Functions                  */
 
316
  /*                                                      */
 
317
  /*   The following functions translate Map Object and   */
 
318
  /*            OL formats for Pixel, LonLat              */
 
319
  /*                                                      */
 
320
  /********************************************************/
 
321
 
 
322
  //
 
323
  // TRANSLATION: MapObject LatLng <-> OpenLayers.LonLat
 
324
  //
 
325
 
 
326
    /**
 
327
     * Method: getOLLonLatFromMapObjectLonLat
 
328
     * Get an OL style map location from a 3rd party style map location
 
329
     *
 
330
     * Parameters
 
331
     * moLonLat - {Object}
 
332
     * 
 
333
     * Returns:
 
334
     * {<OpenLayers.LonLat>} An OpenLayers.LonLat, translated from the passed in 
 
335
     *          MapObject LonLat
 
336
     *          Returns null if null value is passed in
 
337
     */
 
338
    getOLLonLatFromMapObjectLonLat: function(moLonLat) {
 
339
        var olLonLat = null;
 
340
        if (moLonLat != null) {
 
341
            var lon = this.getLongitudeFromMapObjectLonLat(moLonLat);
 
342
            var lat = this.getLatitudeFromMapObjectLonLat(moLonLat);
 
343
            olLonLat = new OpenLayers.LonLat(lon, lat);
 
344
        }
 
345
        return olLonLat;
 
346
    },
 
347
 
 
348
    /**
 
349
     * Method: getMapObjectLonLatFromOLLonLat
 
350
     * Get a 3rd party map location from an OL map location.
 
351
     *
 
352
     * Parameters:
 
353
     * olLonLat - {<OpenLayers.LonLat>}
 
354
     * 
 
355
     * Returns:
 
356
     * {Object} A MapObject LonLat, translated from the passed in 
 
357
     *          OpenLayers.LonLat
 
358
     *          Returns null if null value is passed in
 
359
     */
 
360
    getMapObjectLonLatFromOLLonLat: function(olLonLat) {
 
361
        var moLatLng = null;
 
362
        if (olLonLat != null) {
 
363
            moLatLng = this.getMapObjectLonLatFromLonLat(olLonLat.lon,
 
364
                                                         olLonLat.lat);
 
365
        }
 
366
        return moLatLng;
 
367
    },
 
368
 
 
369
 
 
370
  //
 
371
  // TRANSLATION: MapObject Pixel <-> OpenLayers.Pixel
 
372
  //
 
373
 
 
374
    /**
 
375
     * Method: getOLPixelFromMapObjectPixel
 
376
     * Get an OL pixel location from a 3rd party pixel location.
 
377
     *
 
378
     * Parameters:
 
379
     * moPixel - {Object}
 
380
     * 
 
381
     * Returns:
 
382
     * {<OpenLayers.Pixel>} An OpenLayers.Pixel, translated from the passed in 
 
383
     *          MapObject Pixel
 
384
     *          Returns null if null value is passed in
 
385
     */
 
386
    getOLPixelFromMapObjectPixel: function(moPixel) {
 
387
        var olPixel = null;
 
388
        if (moPixel != null) {
 
389
            var x = this.getXFromMapObjectPixel(moPixel);
 
390
            var y = this.getYFromMapObjectPixel(moPixel);
 
391
            olPixel = new OpenLayers.Pixel(x, y);
 
392
        }
 
393
        return olPixel;
 
394
    },
 
395
 
 
396
    /**
 
397
     * Method: getMapObjectPixelFromOLPixel
 
398
     * Get a 3rd party pixel location from an OL pixel location
 
399
     *
 
400
     * Parameters:
 
401
     * olPixel - {<OpenLayers.Pixel>}
 
402
     * 
 
403
     * Returns:
 
404
     * {Object} A MapObject Pixel, translated from the passed in 
 
405
     *          OpenLayers.Pixel
 
406
     *          Returns null if null value is passed in
 
407
     */
 
408
    getMapObjectPixelFromOLPixel: function(olPixel) {
 
409
        var moPixel = null;
 
410
        if (olPixel != null) {
 
411
            moPixel = this.getMapObjectPixelFromXY(olPixel.x, olPixel.y);
 
412
        }
 
413
        return moPixel;
 
414
    },
 
415
 
 
416
    CLASS_NAME: "OpenLayers.Layer.EventPane"
 
417
});