ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

removed auto-script loader from VirtualEarth.js, beginning adding accessor and translation functions so that it can be used as a base layer. still not complete.

Browse Source 
git-svn-id: http://svn.openlayers.org/trunk/openlayers@947 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
This commit is contained in:
euzuro
2006-07-14 19:01:45 +00:00
parent e645fb03ac
commit f013e9c2e5
1 changed files with 363 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

386
lib/OpenLayers/Layer/VirtualEarth.js
View File

@@ -1,12 +1,55 @@
/* 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
// load VE map control script
document.write("<script src='http://dev.virtualearth.net/mapcontrol/v3/mapcontrol.js'></script>");
if (typeof VEMap != "undefined") {
/** Hack-on function because VE does not give it to us
*
* @param {VELatLong} veLatLng
*
* @returns A Pixel specifying veLatLong translated into "Container" coords
* @type Pixel
*/
VEMap.prototype.fromLatLngToContainerPixel = function(veLatLong) {
// first we translate into "DivPixel"
var pixel = this.LatLongToPixel(veLatLong);
// locate the upper-left tile
var tile = this.mapelement.firstChild.childNodes[2];
// adjust by the offset of tile
pixel.x += tile.offsetLeft;
pixel.y += tile.offsetTop;
return pixel;
};
/** Hack-on function because VE does not give it to us
*
* @param {Pixel} pixel
*
* @returns A VELatLong specifying "Container" pixel translated to lonlat
* @type VELatLong
*/
VEMap.prototype.fromContainerPixelToLatLng = function(pixel) {
// locate the upper-left tile
var tile = this.mapelement.firstChild.childNodes[2];
// adjust by the offset of tile
pixel.x -= tile.offsetLeft;
pixel.y -= tile.offsetTop;
// first we translate into "DivPixel"
return this.PixelToLatLong(pixel);
};
}
/**
* @class
*/
@@ -74,20 +117,74 @@ OpenLayers.Layer.VirtualEarth.prototype =
veDiv.style.height = sz.h;
this.div.appendChild(veDiv);
// create VEMap, hide nav controls
this.vemap = new VEMap(this.name);
this.vemap.LoadMap();
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));
try {
// create VEMap, hide nav controls
this.vemap = new VEMap(this.name);
this.vemap.LoadMap();
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));
} catch (e) {
this.loadWarningMessage();
}
},
/** 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 = "red";
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
*/
@@ -95,13 +192,256 @@ OpenLayers.Layer.VirtualEarth.prototype =
var veCenter = this.vemap.GetCenter();
var veZoom = this.vemap.GetZoomLevel();
var olCenter = new OpenLayers.LonLat(veCenter.Longitude,
veCenter.Latitude);
this.map.setCenter(olCenter, veZoom - 1);
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);
// note we use special hacked function here
var veLatLong = this.vemap.fromContainerPixelToLatLng(pixel)
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);
// note we use special hacked function here
var pixel = this.vemap.fromLatLngToContainerPixel(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;
},
/**
* @returns A Bounds object which represents the lon/lat bounds of the
* current viewPort.
* If vemap is not loaded, returns null
* @type OpenLayers.Bounds
*/
getExtent: function () {
var extent = null;
if (this.vemap != null) {
if (this.vemap.getCenter() == null) {
this.moveTo();
}
var veLatLongBounds = this.vemap.getBounds();
extent = this.getOLBoundsFromVELatLongBounds(veLatLongBounds);
}
return extent;
},
/********************************************************/
/* */
/* 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 GPoint
*/
getGPointFromOLPixel: function(olPixel) {
return olPixel;
},
//
// 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"