openlayers/lib/OpenLayers/Layer/VirtualEarth.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/EventPane.js
   8  * @requires OpenLayers/Layer/FixedZoomLevels.js
   9  */
  10
  11 /**
  12  * Class: OpenLayers.Layer.VirtualEarth
  13  *
  14  * Inherits from:
  15  *  - <OpenLayers.Layer.EventPane>
  16  *  - <OpenLayers.Layer.FixedZoomLevels>
  17  */
  18 OpenLayers.Layer.VirtualEarth = OpenLayers.Class(
  19     OpenLayers.Layer.EventPane,
  20     OpenLayers.Layer.FixedZoomLevels, {
  21
  22     /**
  23      * Constant: MIN_ZOOM_LEVEL
  24      * {Integer} 1
  25      */
  26     MIN_ZOOM_LEVEL: 1,
  27
  28     /**
  29      * Constant: MAX_ZOOM_LEVEL
  30      * {Integer} 17
  31      */
  32     MAX_ZOOM_LEVEL: 17,
  33
  34     /**
  35      * Constant: RESOLUTIONS
  36      * {Array(Float)} Hardcode these resolutions so that they are more closely
  37      *                tied with the standard wms projection
  38      */
  39     RESOLUTIONS: [
  40         1.40625,
  41         0.703125,
  42         0.3515625,
  43         0.17578125,
  44         0.087890625,
  45         0.0439453125,
  46         0.02197265625,
  47         0.010986328125,
  48         0.0054931640625,
  49         0.00274658203125,
  50         0.001373291015625,
  51         0.0006866455078125,
  52         0.00034332275390625,
  53         0.000171661376953125,
  54         0.0000858306884765625,
  55         0.00004291534423828125,
  56         0.00002145767211914062
  57     ],
  58
  59     /**
  60      * APIProperty: type
  61      * {VEMapType}
  62      */
  63     type: null,
  64
  65     /**
  66      * APIProperty: sphericalMercator
  67      * {Boolean} Should the map act as a mercator-projected map? This will
  68      *     cause all interactions with the map to be in the actual map
  69      *     projection, which allows support for vector drawing, overlaying
  70      *     other maps, etc.
  71      */
  72     sphericalMercator: false,
  73
  74     /**
  75      * Constructor: OpenLayers.Layer.VirtualEarth
  76      *
  77      * Parameters:
  78      * name - {String}
  79      * options - {Object}
  80      */
  81     initialize: function(name, options) {
  82         OpenLayers.Layer.EventPane.prototype.initialize.apply(this, arguments);
  83         OpenLayers.Layer.FixedZoomLevels.prototype.initialize.apply(this,
  84                                                                     arguments);
  85         if(this.sphericalMercator) {
  86             OpenLayers.Util.extend(this, OpenLayers.Layer.SphericalMercator);
  87             this.initMercatorParameters();
  88         }
  89     },
  90
  91     /**
  92      * Method: loadMapObject
  93      */
  94     loadMapObject:function() {
  95
  96         // create div and set to same size as map
  97         var veDiv = OpenLayers.Util.createDiv(this.name);
  98         var sz = this.map.getSize();
  99         veDiv.style.width = sz.w + "px";
 100         veDiv.style.height = sz.h + "px";
 101         this.div.appendChild(veDiv);
 102
 103         try { // crash prevention
 104             this.mapObject = new VEMap(this.name);
 105         } catch (e) { }
 106
 107         if (this.mapObject != null) {
 108             try { // this is to catch a Mozilla bug without falling apart
 109
 110                 // The fourth argument is whether the map is 'fixed' -- not
 111                 // draggable. See:
 112                 // http://blogs.msdn.com/virtualearth/archive/2007/09/28/locking-a-virtual-earth-map.aspx
 113                 //
 114                 this.mapObject.LoadMap(null, null, this.type, true);
 115                 this.mapObject.AttachEvent("onmousedown", function() {return true; });
 116
 117             } catch (e) { }
 118             this.mapObject.HideDashboard();
 119         }
 120
 121         //can we do smooth panning? this is an unpublished method, so we need
 122         // to be careful
 123         if ( !this.mapObject ||
 124              !this.mapObject.vemapcontrol ||
 125              !this.mapObject.vemapcontrol.PanMap ||
 126              (typeof this.mapObject.vemapcontrol.PanMap != "function")) {
 127
 128             this.dragPanMapObject = null;
 129         }
 130
 131     },
 132
 133     /**
 134      * APIMethod: getWarningHTML
 135      *
 136      * Returns:
 137      * {String} String with information on why layer is broken, how to get
 138      *          it working.
 139      */
 140     getWarningHTML:function() {
 141         return OpenLayers.i18n(
 142             "getLayerWarning", {'layerType':'VE', 'layerLib':'VirtualEarth'}
 143         );
 144     },
 145
 146
 147
 148     /************************************
 149      *                                  *
 150      *   MapObject Interface Controls   *
 151      *                                  *
 152      ************************************/
 153
 154
 155   // Get&Set Center, Zoom
 156
 157     /**
 158      * APIMethod: setMapObjectCenter
 159      * Set the mapObject to the specified center and zoom
 160      *
 161      * Parameters:
 162      * center - {Object} MapObject LonLat format
 163      * zoom - {int} MapObject zoom format
 164      */
 165     setMapObjectCenter: function(center, zoom) {
 166         this.mapObject.SetCenterAndZoom(center, zoom);
 167     },
 168
 169     /**
 170      * APIMethod: getMapObjectCenter
 171      *
 172      * Returns:
 173      * {Object} The mapObject's current center in Map Object format
 174      */
 175     getMapObjectCenter: function() {
 176         return this.mapObject.GetCenter();
 177     },
 178
 179     /**
 180      * APIMethod: dragPanMapObject
 181      *
 182      * Parameters:
 183      * dX - {Integer}
 184      * dY - {Integer}
 185      */
 186     dragPanMapObject: function(dX, dY) {
 187         this.mapObject.vemapcontrol.PanMap(dX, -dY);
 188     },
 189
 190     /**
 191      * APIMethod: getMapObjectZoom
 192      *
 193      * Returns:
 194      * {Integer} The mapObject's current zoom, in Map Object format
 195      */
 196     getMapObjectZoom: function() {
 197         return this.mapObject.GetZoomLevel();
 198     },
 199
 200
 201   // LonLat - Pixel Translation
 202
 203     /**
 204      * APIMethod: getMapObjectLonLatFromMapObjectPixel
 205      *
 206      * Parameters:
 207      * moPixel - {Object} MapObject Pixel format
 208      *
 209      * Returns:
 210      * {Object} MapObject LonLat translated from MapObject Pixel
 211      */
 212     getMapObjectLonLatFromMapObjectPixel: function(moPixel) {
 213         //the conditional here is to test if we are running the v6 of VE
 214         return (typeof VEPixel != 'undefined')
 215             ? this.mapObject.PixelToLatLong(moPixel)
 216             : this.mapObject.PixelToLatLong(moPixel.x, moPixel.y);
 217     },
 218
 219     /**
 220      * APIMethod: getMapObjectPixelFromMapObjectLonLat
 221      *
 222      * Parameters:
 223      * moLonLat - {Object} MapObject LonLat format
 224      *
 225      * Returns:
 226      * {Object} MapObject Pixel transtlated from MapObject LonLat
 227      */
 228     getMapObjectPixelFromMapObjectLonLat: function(moLonLat) {
 229         return this.mapObject.LatLongToPixel(moLonLat);
 230     },
 231
 232
 233     /************************************
 234      *                                  *
 235      *       MapObject Primitives       *
 236      *                                  *
 237      ************************************/
 238
 239
 240   // LonLat
 241
 242     /**
 243      * APIMethod: getLongitudeFromMapObjectLonLat
 244      *
 245      * Parameters:
 246      * moLonLat - {Object} MapObject LonLat format
 247      *
 248      * Returns:
 249      * {Float} Longitude of the given MapObject LonLat
 250      */
 251     getLongitudeFromMapObjectLonLat: function(moLonLat) {
 252         return this.sphericalMercator ?
 253             this.forwardMercator(moLonLat.Longitude, moLonLat.Latitude).lon :
 254             moLonLat.Longitude;
 255     },
 256
 257     /**
 258      * APIMethod: getLatitudeFromMapObjectLonLat
 259      *
 260      * Parameters:
 261      * moLonLat - {Object} MapObject LonLat format
 262      *
 263      * Returns:
 264      * {Float} Latitude of the given MapObject LonLat
 265      */
 266     getLatitudeFromMapObjectLonLat: function(moLonLat) {
 267         return this.sphericalMercator ?
 268             this.forwardMercator(moLonLat.Longitude, moLonLat.Latitude).lat :
 269             moLonLat.Latitude;
 270     },
 271
 272     /**
 273      * APIMethod: getMapObjectLonLatFromLonLat
 274      *
 275      * Parameters:
 276      * lon - {Float}
 277      * lat - {Float}
 278      *
 279      * Returns:
 280      * {Object} MapObject LonLat built from lon and lat params
 281      */
 282     getMapObjectLonLatFromLonLat: function(lon, lat) {
 283         var veLatLong;
 284         if(this.sphericalMercator) {
 285             var lonlat = this.inverseMercator(lon, lat);
 286             veLatLong = new VELatLong(lonlat.lat, lonlat.lon);
 287         } else {
 288             veLatLong = new VELatLong(lat, lon);
 289         }
 290         return veLatLong;
 291     },
 292
 293   // Pixel
 294
 295     /**
 296      * APIMethod: getXFromMapObjectPixel
 297      *
 298      * Parameters:
 299      * moPixel - {Object} MapObject Pixel format
 300      *
 301      * Returns:
 302      * {Integer} X value of the MapObject Pixel
 303      */
 304     getXFromMapObjectPixel: function(moPixel) {
 305         return moPixel.x;
 306     },
 307
 308     /**
 309      * APIMethod: getYFromMapObjectPixel
 310      *
 311      * Parameters:
 312      * moPixel - {Object} MapObject Pixel format
 313      *
 314      * Returns:
 315      * {Integer} Y value of the MapObject Pixel
 316      */
 317     getYFromMapObjectPixel: function(moPixel) {
 318         return moPixel.y;
 319     },
 320
 321     /**
 322      * APIMethod: getMapObjectPixelFromXY
 323      *
 324      * Parameters:
 325      * x - {Integer}
 326      * y - {Integer}
 327      *
 328      * Returns:
 329      * {Object} MapObject Pixel from x and y parameters
 330      */
 331     getMapObjectPixelFromXY: function(x, y) {
 332         //the conditional here is to test if we are running the v6 of VE
 333         return (typeof VEPixel != 'undefined') ? new VEPixel(x, y)
 334                          : new Msn.VE.Pixel(x, y);
 335     },
 336
 337     CLASS_NAME: "OpenLayers.Layer.VirtualEarth"
 338 });