443f28dee8
git-svn-id: http://svn.openlayers.org/trunk/openlayers@1049 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
400 lines
12 KiB
JavaScript
400 lines
12 KiB
JavaScript
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
|
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
|
* text of the license. */
|
|
|
|
// @require: OpenLayers/Layer.js
|
|
|
|
/**
|
|
* @class
|
|
*/
|
|
OpenLayers.Layer.VirtualEarth = Class.create();
|
|
OpenLayers.Layer.VirtualEarth.prototype =
|
|
Object.extend( new OpenLayers.Layer(), {
|
|
|
|
/** @type Boolean */
|
|
isFixed: true,
|
|
|
|
/** @type VEMap */
|
|
vemap: null,
|
|
|
|
/**
|
|
* @constructor
|
|
*
|
|
* @param {str} name
|
|
*/
|
|
initialize:function(name) {
|
|
OpenLayers.Layer.prototype.initialize.apply(this, arguments);
|
|
},
|
|
|
|
/**
|
|
* @param {OpenLayers.Map} map
|
|
*/
|
|
setMap:function(map) {
|
|
OpenLayers.Layer.prototype.setMap.apply(this, arguments);
|
|
|
|
// once our layer has been added to the map, we can create the vemap
|
|
this.map.events.register("addlayer", this, this.loadVEMap);
|
|
},
|
|
|
|
/** Virtual Earth layer is always a base class.
|
|
* @type Boolean
|
|
*/
|
|
isBaseLayer: function() {
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* @param {OpenLayers.Bounds} bounds
|
|
* @param {Boolean} zoomChanged
|
|
* @param {Boolean} minor
|
|
*/
|
|
moveTo:function(bounds, zoomChanged, minor) {
|
|
|
|
if (this.vemap != null) {
|
|
var olCenter = this.map.getCenter();
|
|
var olZoom = this.map.getZoom();
|
|
|
|
var veCenter = this.getVELatLongFromOLLonLat(olCenter);
|
|
var veZoom = this.getVEZoomFromOLZoom(olZoom);
|
|
|
|
this.vemap.SetCenterAndZoom(veCenter, veZoom);
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
loadVEMap:function() {
|
|
// create div and set to same size as map
|
|
var veDiv = OpenLayers.Util.createDiv(this.name);
|
|
var sz = this.map.getSize();
|
|
veDiv.style.width = sz.w;
|
|
veDiv.style.height = sz.h;
|
|
this.div.appendChild(veDiv);
|
|
|
|
try {
|
|
|
|
// create VEMap, hide nav controls
|
|
this.vemap = new VEMap(this.name);
|
|
} catch (e) {
|
|
// do nothing this is to keep from crashing
|
|
// if the VE library was not loaded.
|
|
}
|
|
|
|
|
|
if (this.vemap == null) {
|
|
this.loadWarningMessage();
|
|
} else {
|
|
|
|
|
|
try {
|
|
this.vemap.LoadMap();
|
|
} catch (e) {
|
|
// this is to catch a Mozilla bug without falling apart
|
|
}
|
|
|
|
this.vemap.HideDashboard();
|
|
|
|
// catch pans and zooms from VE Map
|
|
this.vemap.AttachEvent("onendcontinuouspan",
|
|
this.catchPanZoom.bindAsEventListener(this));
|
|
this.vemap.AttachEvent("onendzoom",
|
|
this.catchPanZoom.bindAsEventListener(this));
|
|
}
|
|
|
|
},
|
|
|
|
/** If we can't load the vemap, then display an error message to the
|
|
* user and tell them where to go for help.
|
|
*
|
|
* @private
|
|
*
|
|
*/
|
|
loadWarningMessage:function() {
|
|
|
|
this.div.style.backgroundColor = "darkblue";
|
|
|
|
var html = "";
|
|
html += "The VE Layer was unable to load correctly.<br>";
|
|
html += "<br>";
|
|
html += "To get rid of this message, click on the VE Layer's "
|
|
html += "tab in the layer switcher in the upper-right corner.<br>";
|
|
html += "<br>";
|
|
html += "Most likely, this is because the VE library";
|
|
html += " script was either not correctly included.<br>";
|
|
html += "<br>";
|
|
html += "Developers: For help getting this working correctly, ";
|
|
html += "<a href='http://trac.openlayers.org/wiki/VE' "
|
|
html += "target='_blank'>";
|
|
html += "click here";
|
|
html += "</a>";
|
|
|
|
var viewSize = this.map.getSize();
|
|
|
|
msgW = Math.min(viewSize.w, 300);
|
|
msgH = Math.min(viewSize.h, 200);
|
|
var size = new OpenLayers.Size(msgW, msgH);
|
|
|
|
var centerPx = new OpenLayers.Pixel(viewSize.w/2, viewSize.h/2);
|
|
|
|
var topLeft = centerPx.add(-size.w/2, -size.h/2);
|
|
|
|
var div = OpenLayers.Util.createDiv("veWarning",
|
|
topLeft,
|
|
size,
|
|
null,
|
|
null,
|
|
null,
|
|
"auto");
|
|
|
|
div.style.padding = "7px";
|
|
div.style.backgroundColor = "yellow";
|
|
|
|
div.innerHTML = html;
|
|
this.div.appendChild(div);
|
|
},
|
|
|
|
/**
|
|
* @param {event} e
|
|
*/
|
|
catchPanZoom: function(e) {
|
|
|
|
var veCenter = this.vemap.GetCenter();
|
|
var veZoom = this.vemap.GetZoomLevel();
|
|
|
|
var olCenter = this.getOLLonLatFromVELatLong(veCenter);
|
|
var olZoom = this.getOLZoomFromVEZoom(veZoom);
|
|
|
|
this.map.setCenter(olCenter, olZoom);
|
|
},
|
|
|
|
|
|
|
|
/********************************************************/
|
|
/* */
|
|
/* Baselayer Functions */
|
|
/* */
|
|
/********************************************************/
|
|
|
|
/**
|
|
* @param {OpenLayers.Pixel} viewPortPx
|
|
*
|
|
* @returns An OpenLayers.LonLat which is the passed-in view port
|
|
* OpenLayers.Pixel, translated into lon/lat by VE
|
|
* If vemap is not loaded, returns null.
|
|
* @type OpenLayers.LonLat
|
|
*/
|
|
getLonLatFromViewPortPx: function (viewPortPx) {
|
|
var lonlat = null;
|
|
if (this.vemap != null) {
|
|
var pixel = this.getPixelFromOLPixel(viewPortPx);
|
|
var zoom = this.vemap.GetZoomLevel();
|
|
var veLatLong = this.vemap.PixelToLatLong(pixel.x, pixel.y, zoom);
|
|
lonlat = this.getOLLonLatFromVELatLong(veLatLong);
|
|
}
|
|
return lonlat;
|
|
},
|
|
|
|
|
|
/**
|
|
* @param {OpenLayers.LonLat} lonlat
|
|
*
|
|
* @returns An OpenLayers.Pixel which is the passed-in OpenLayers.LonLat,
|
|
* translated into view port pixels BY VE
|
|
* If vemap is not loaded, returns null.
|
|
* @type OpenLayers.Pixel
|
|
*/
|
|
getViewPortPxFromLonLat: function (lonlat) {
|
|
var viewPortPx = null;
|
|
if (this.vemap != null) {
|
|
var veLatLong = this.getVELatLongFromOLLonLat(lonlat);
|
|
var pixel = this.vemap.LatLongToPixel(veLatLong);
|
|
viewPortPx = this.getOLPixelFromPixel(pixel);
|
|
}
|
|
return viewPortPx;
|
|
},
|
|
|
|
|
|
/**
|
|
* @param {OpenLayers.Bounds} bounds
|
|
*
|
|
* @returns Corresponding zoom level for a specified Bounds.
|
|
* If vemap is not loaded, returns null.
|
|
* @type int
|
|
*/
|
|
getZoomForExtent: function (bounds) {
|
|
var zoom = null;
|
|
if (this.vemap != null) {
|
|
var gBounds = this.getVELatLongBoundsFromOLBounds(bounds);
|
|
var gZoom = this.vemap.getBoundsZoomLevel(gBounds);
|
|
zoom = this.getOLZoomFromGZoom(gZoom);
|
|
}
|
|
return zoom;
|
|
},
|
|
|
|
|
|
/********************************************************/
|
|
/* */
|
|
/* Translation Functions */
|
|
/* */
|
|
/* The following functions translate GMaps and OL */
|
|
/* formats for Pixel, LonLat, Bounds, and Zoom */
|
|
/* */
|
|
/********************************************************/
|
|
|
|
//
|
|
// TRANSLATION: GZoom <-> OpenLayers Zoom
|
|
//
|
|
|
|
/**
|
|
* @param {int} veZoom
|
|
*
|
|
* @returns An OpenLayers Zoom level, translated from the passed in veZoom
|
|
* Returns null if null value is passed in
|
|
* @type int
|
|
*/
|
|
getOLZoomFromVEZoom: function(veZoom) {
|
|
var zoom = null;
|
|
if (veZoom != null) {
|
|
zoom = veZoom - 1;
|
|
}
|
|
return zoom;
|
|
},
|
|
|
|
/**
|
|
* @param {int} olZoom
|
|
*
|
|
* @returns A VEZoom level, translated from the passed in olZoom
|
|
* Returns null if null value is passed in
|
|
* @type int
|
|
*/
|
|
getVEZoomFromOLZoom: function(olZoom) {
|
|
var zoom = null;
|
|
if (olZoom != null) {
|
|
zoom = olZoom + 1;
|
|
}
|
|
return zoom;
|
|
},
|
|
|
|
//
|
|
// TRANSLATION: VELatLong <-> LonLat
|
|
//
|
|
|
|
/**
|
|
* @param {VELatLong} veLatLong
|
|
*
|
|
* @returns An OpenLayers.LonLat, translated from the passed in VELatLong
|
|
* Returns null if null value is passed in
|
|
* @type OpenLayers.LonLat
|
|
*/
|
|
getOLLonLatFromVELatLong: function(veLatLong) {
|
|
var olLonLat = null;
|
|
if (veLatLong != null) {
|
|
olLonLat = new OpenLayers.LonLat(veLatLong.Longitude,
|
|
veLatLong.Latitude);
|
|
}
|
|
return olLonLat;
|
|
},
|
|
|
|
/**
|
|
* @param {OpenLayers.LonLat} olLonLat
|
|
*
|
|
* @returns A VELatLong, translated from the passed in OpenLayers.LonLat
|
|
* Returns null if null value is passed in
|
|
* @type VELatLong
|
|
*/
|
|
getVELatLongFromOLLonLat: function(olLonLat) {
|
|
var veLatLong = null;
|
|
if (olLonLat != null) {
|
|
veLatLong = new VELatLong(olLonLat.lat, olLonLat.lon);
|
|
}
|
|
return veLatLong;
|
|
},
|
|
|
|
|
|
//
|
|
// TRANSLATION: Pixel <-> OpenLayers.Pixel
|
|
//
|
|
|
|
/**
|
|
* @param {Pixel} pixel
|
|
*
|
|
* @returns An OpenLayers.Pixel, translated from the passed in Pixel
|
|
* Returns null if null value is passed in
|
|
* @type OpenLayers.Pixel
|
|
*/
|
|
getOLPixelFromPixel: function(pixel) {
|
|
var olPixel = null;
|
|
if (pixel != null) {
|
|
olPixel = new OpenLayers.Pixel(pixel.x, pixel.y);
|
|
}
|
|
return olPixel;
|
|
},
|
|
|
|
/**
|
|
* @param {OpenLayers.Pixel} olPixel
|
|
*
|
|
* @returns A Pixel, translated from the passed in OpenLayers.Pixel
|
|
* Returns null if null value is passed in
|
|
*
|
|
* As it turns out, the only specifications we can see for the
|
|
* VE-compatible Pixel is an x & y property, which every
|
|
* OpenLayers.Pixel has by default. So just leave it as-is.
|
|
*
|
|
* @type Pixel
|
|
*/
|
|
getPixelFromOLPixel: function(olPixel) {
|
|
var pixel = null;
|
|
if (olPixel != null) {
|
|
pixel = new Msn.VE.Pixel(olPixel.x, olPixel.y);
|
|
}
|
|
return pixel;
|
|
},
|
|
|
|
//
|
|
// TRANSLATION: VELatLongBounds <-> OpenLayers.Bounds
|
|
//
|
|
|
|
/**
|
|
* @param {VELatLongBounds} veLatLongBounds
|
|
*
|
|
* @returns An OpenLayers.Bounds, translated from veLatLongBounds
|
|
* Returns null if null value is passed in
|
|
* @type OpenLayers.Bounds
|
|
*/
|
|
getOLBoundsFromVELatLongBounds: function(veLatLongBounds) {
|
|
var olBounds = null;
|
|
if (veLatLongBounds != null) {
|
|
var sw = veLatLongBounds.getSouthWest();
|
|
var ne = veLatLongBounds.getNorthEast();
|
|
olBounds = new OpenLayers.Bounds(sw.lng(),
|
|
sw.lat(),
|
|
ne.lng(),
|
|
ne.lat() );
|
|
}
|
|
return olBounds;
|
|
},
|
|
|
|
/**
|
|
* @param {OpenLayers.Bounds} olBounds
|
|
*
|
|
* @returns A VELatLongBounds, translated from olBounds
|
|
* Returns null if null value is passed in
|
|
* @type VELatLongBounds
|
|
*/
|
|
getVELatLongBoundsFromOLBounds: function(olBounds) {
|
|
var veLatLongBounds = null;
|
|
if (olBounds != null) {
|
|
var sw = new VELatLong(olBounds.bottom, olBounds.left);
|
|
var ne = new VELatLong(olBounds.top, olBounds.right);
|
|
veLatLongBounds = new VELatLongBounds(sw, ne);
|
|
}
|
|
return veLatLongBounds;
|
|
},
|
|
|
|
|
|
|
|
/** @final @type String */
|
|
CLASS_NAME: "OpenLayers.Layer.VirtualEarth"
|
|
}); |