" +
"![]()
" +
"
";
return bubbleHtml;
};
LovelyMapControl.prototype.closeBubble = function(){
if (this.map.getInfoWindow())
this.map.closeInfoWindow();
if (this.map.getExtInfoWindow())
this.map.closeExtInfoWindow();
};
LovelyMapControl.prototype.setZoom = function(zoom){
this.map.setZoom(zoom);
};
LovelyMapControl.prototype.setZoomType = function(type, lat, lon){
this.setZoom(this.zoomLevels[type])
if (lat && lon)
this.setCenter(lat, lon);
else
this.syncPois();
var cz = this.getCenterAndZoom();
if (this.manager.focus.isSet)
this.manager.focus.releaseFocus();
//else this.manager.breadcrumbs.refreshOnCoord(cz.lat, cz.lon, this.());
//close all bubbles
if (this.manager.mode == "map")
mbCloseBubble();
//or switch to the titlepage if on a focussed item in magazine
return this.zoomLevels[type];
};
LovelyMapControl.prototype.getLevelForZoom = function(zoom){ // marked for deletion
for (var p in this.zoomRanges) {
error("somebody called map.getLevelForZoom");
if (this.zoomRanges[p].contains(zoom))
return p;
}
};
LovelyMapControl.prototype.getCurrentZoomLevel = function(){ // marked for deletion
error("somebody called getCurrentZoomLevel");
return this.getZoom();
};
LovelyMapControl.prototype.getCenterAndZoom = function(){
var cz = {
lat: this.map.getCenter().lat(),
lon: this.map.getCenter().lng(),
zoom: this.getZoom()
}
return cz;
};
LovelyMapControl.prototype.setCenterAndZoom = function(lat, lon, zoom){
this.map.setCenter(new GLatLng(lat, lon), Math.round(zoom));
};
LovelyMapControl.prototype.setCenter = function(lat, lon, nomove){ // marked for deletion
error("somebody called map.setCenter");
if (!nomove)
this.getZoom(lat, lon, this.getZoom())
};
LovelyMapControl.prototype.onFocusSet = function(data){ // marked for deletion
if (data.privacy)
this.showPrivacyMessage();
else
this.hidePrivacyMessage();
info("map.onFocusSet", data);
error("somebody called map.onFocusSet");
};
LovelyMapControl.prototype.showDistrict = function(lat, lon, name){ // marked for deletion
if (this.cityName == name)
var zoom = this.zoomLevels['city'];
else
var zoom = this.zoomLevels['district'];
this.setCenterAndZoom(lat, lon, zoom);
this.syncPois();
error("somebody called map.showDistrict");
return zoom;
};
LovelyMapControl.prototype.showItemOnMap = function(uid, privacy){ // marked for deletion
this.manager.resolveByUid(uid, function(data){
mbShowBubble(data.uid, data.lat, data.lon, data.type, data.subtype, data.title, true);
});
this.manager.setMode("map");
error("somebody called map.showDistrict");
};
LovelyMapControl.prototype.showPrivacyMessage = function(){ // marked for deletion
$('div#privatelocationinfo').show();
error("somebody called map.showPrivacyMessage");
};
LovelyMapControl.prototype.hidePrivacyMessage = function(force){ // marked for deletion
if ((!this.stillOnPrivate()) || force)
$('div#privatelocationinfo').hide();
error("somebody called map.hidePrivacyMessage");
};
LovelyMapControl.prototype.stillOnFocus = function(){ // marked for deletion
error("somebody called map.stillOnFocus");
//FIXME timing problems. aarghh
if (this.manager.focusedItem) {
if (this.manager.focusedItem.lat == this.getCenterAndZoom().lat &&
this.manager.focusedItem.lat == this.getCenterAndZoom().lon) {
return true;
}
else {
return false;
}
}
else {
return false;
}
};
LovelyMapControl.prototype.stillOnPrivate = function(){ // marked for deletion
error("somebody called map.stillOnPrivate");
if (this.privateLat == this.getCenterAndZoom().lat &&
this.privateLon == this.getCenterAndZoom().lon) {
return true;
}
else {
return false;
}
};
LovelyMapControl.prototype.showAddressOnMap = function(lat, lon, zoom){
set_pos_and_zoom(lat, lon, zoom);
show_adress();
if (this.manager.currentPage.id != "map") {
this.manager.showPage("map")
}
LPM.onMapUpdate();
//LPM.breadcrumbs.refreshOnCoord(lat, lon, zoom);
};
LovelyMapControl.prototype.getZoom = function(){
return this.map.getZoom();
};
LovelyMapControl.prototype.resolvePointDistance = function(p1, p2, cb){
var callback = cb;
var p1s = [p1.lat, p1.lon].join(",");
var p2s = [p2.lat, p2.lon].join(",");
var param = [p1s, p2s].join(";");
var url = "/coords/" + param + "/distance";
$.getJSON(url, {}, function(response){
if (response)
callback.call(this, response.distance);
else
callback.call(this, false);
});
};
/* MapGrid */
MapGrid = function(){
this.tileSizeByZoom = tileSizeConfig;
this.MAGTILEFACTOR = MAGTILEFACTOR;
}
MapGrid.prototype.init = function(map){
this.map = map;
this.manager = map.manager;
}
MapGrid.prototype.tileSize = function(zoom){
ts = this.tileSizeByZoom[zoom];
if (ts)
return ts;
else
error("No Tilesize for Zoom found: ", zoom, this.tileSizeByZoom)
}
MapGrid.prototype.normalize = function(coord, zoom){
w = this.tileSize(zoom).w;
h = this.tileSize(zoom).h;
//only northern hemisphere compatible
var left = Math.floor(coord.lon / w) * w;
var top = Math.ceil(coord.lat / h) * h;
var right = left + w;
var bottom = top - h;
var clat = (top + bottom) / 2;
var clon = (left + right) / 2;
var glon = (coord.lon % w >= w / 2) && right || left;
var glat = (coord.lat % h >= h / 2) && top || bottom;
var ret = {
tile: {
lt: {
lat: top,
lon: left
},
rb: {
lat: bottom,
lon: right
}
},
center: {
lat: clat,
lon: clon
},
grid: {
lat: glat,
lon: glon
},
original: coord
}
return ret;
}
MapGrid.prototype.normalizeToCenter = function(coord, zoom){
return this.normalize(coord, zoom).center;
}
MapGrid.prototype.normalizeToGrid = function(coord, zoom){
return this.normalize(coord, zoom).grid;
}
MapGrid.prototype.getMapTile = function(coord, zoom){
return this.normalize(coord, zoom).tile;
}
MapGrid.prototype.test = function(lat, lon){
for (var zoom = 12; zoom < 20; zoom++) {
var tile = this.getMapTile({
lat: lat,
lon: lon
}, zoom);
log(lat, lon, " - ", tile.lt.lat.toFixed(6), tile.lt.lon.toFixed(6), ' - ', tile.rb.lat.toFixed(6), tile.rb.lon.toFixed(6));
}
};
MapGrid.prototype.getMagazineTile = function(coord, zoom){
var factor = this.MAGTILEFACTOR;
var size = this.tileSize(zoom);
if (factor % 2) {
//odd magtilefactors are calculated based on a surrounding tile
start = this.getMapTile(coord, zoom).lt;
}
else {
//even magtilefactors are calculated from a gridpoint
start = this.normalizeToGrid(coord, zoom);
}
var leftTop = {
lat: start.lat + ((factor - 1) * size.h),
lon: start.lon - ((factor - 1) * size.w)
}
var rightBottom = {
lat: leftTop.lat - (factor * size.h),
lon: leftTop.lon + (factor * size.w)
}
var center = {
lat: (leftTop.lat + rightBottom.lat) / 2,
lon: (leftTop.lon + rightBottom.lon) / 2
}
return {
lt: leftTop,
rb: rightBottom,
center: center
}
}
MapGrid.prototype.getEnclosingMapTiles = function(lt, rb, zoom){
var nlt = this.getMapTile(lt, zoom);
var nrb = this.getMapTile(rb, zoom);
var tileSize = this.tileSize(zoom);
var left = nlt.lt.lon;
var top = nlt.lt.lat;
var right = nrb.rb.lon;
var bottom = nrb.rb.lat;
var tiles = [];
for (var x = left; x < right; x += tileSize.w) {
for (var y = top; y > bottom; y -= tileSize.h) {
var len = tiles.push({
lt: {
lat: y,
lon: x
},
rb: {
lat: y - tileSize.h,
lon: x + tileSize.w
}
})
//abort if more than 20 tiles. this must be an error in arguments
if (len > 20) {
error("Calculated more than 20 Tiles. Check your arguments:", lt, rb, zoom)
return tiles;
}
}
}
return tiles;
};
MapGrid.prototype.draw = function(corners, zoom){
corners = corners || this.map.getBorders();
zoom = zoom || this.map.getZoom();
tiles = this.getEnclosingMapTiles(corners.lt, corners.rb, zoom);
for (var i = 0; i < tiles.length; i++) {
var lt = tiles[i].lt;
var rb = tiles[i].rb;
mbMakeLine([lt.lat, lt.lon, lt.lat, rb.lon, rb.lat, rb.lon, rb.lat, lt.lon], 'line');
}
var cz = this.map.getCenterAndZoom();
magtile = this.getMagazineTile(cz, zoom);
};
MapGrid.prototype.drawNormalization = function(o, n, color){
//show both points and draw a line between
mbMakeLine([o.lat, o.lon, n.lat, n.lon], 'line', color)
var pt = new GLatLng(o.lat, o.lon);
var ma = new GMarker(pt)
map.addOverlay(ma);
var pt = new GLatLng(n.lat, n.lon);
var ma = new GMarker(pt)
map.addOverlay(ma);
};
//tile-based pin handler -------------------------------------------------------
TileBasedPinHandler = function(){
this.map;
this.manager;
this.currentRequest;
this.loadedTilesAmount = 1;
this.loadedTilesData = [];
// Changed from 20 to 100 - As we´re only displaying 5 Pins per Tile
// and this ammount doesn´t matter anymore. :-)
this.MAX_PIN_AMOUNT = 100;
// We get the tile sizes from the created table to make sure Zope and JS are
// using exacly the same values because they are used to calculate the cache
// values.
this.tileSizeByZoom = tileSizeConfig;
}
TileBasedPinHandler.prototype.init = function(map){
this.map = map;
this.grid = map.grid;
this.manager = map.manager;
}
TileBasedPinHandler.prototype.getPins = function(ltlat, ltlon, rblat, rblon, zoom, filter){
//abort if same as last request
if (this.currentRequest) {
if (ltlat == this.currentRequest.lt.lat &&
ltlon == this.currentRequest.lt.lon &&
rblat == this.currentRequest.rb.lat &&
rblon == this.currentRequest.rb.lon &&
zoom == this.currentRequest.zoom &&
filter == this.currentRequest.filter) {
warn("requesting pins for the second time. ", this.currentRequest)
}
}
var lt = {
lat: ltlat,
lon: ltlon
};
var rb = {
lat: rblat,
lon: rblon
};
this.currentRequest = {
lt: lt,
rb: rb,
zoom: zoom,
filter: filter,
timestamp: new Date().getTime() //include a timestamp to identifiy the last request
}
var tiles = this.grid.getEnclosingMapTiles(lt, rb, zoom);
log("amount of tiles to load: ", tiles.length)
this.loadedTilesAmount = tiles.length;
this.loadedTilesData = [];
for (var i = 0; i < tiles.length; i++) {
var tile = tiles[i];
this.loadTile(tile.lt, tile.rb, zoom, filter, this.currentRequest.timestamp);
}
}
TileBasedPinHandler.prototype.loadTile = function(lt, rb, zoom, filter, timestamp){
var self = this;
url = this.manager.getGlobals().portalUrl
req = url +
'/area/' +
lt.lat.toFixed(6) +
',' +
lt.lon.toFixed(6) +
'/' +
rb.lat.toFixed(6) +
',' +
rb.lon.toFixed(6) +
'/' +
zoom +
'/' +
filter +
'/pois'
info('req: ',req);
$.getJSON(req, function(json){
self.onTileLoaded(json, timestamp);
});
};
TileBasedPinHandler.prototype.onTileLoaded = function(pins, timestamp){
//check the timestamp and abort if not matching
//and therefor ignore "old" requests
if (timestamp != this.currentRequest.timestamp)
return;
// Aber hier modifiziert für verteilte Ausgabe auf Kacheln - Nur die ersten 5
var MaxPinsPerTile = 10;
if (pins.length > MaxPinsPerTile && zoom < 17)
var newpins = pins.slice(0, MaxPinsPerTile);
else
var newpins = pins;
this.loadedTilesData.push(newpins);
if (this.loadedTilesData.length == this.loadedTilesAmount)
this.compileTiles();
}
TileBasedPinHandler.prototype.compileTiles = function(){
var all = []
for (var i = 0; i < this.loadedTilesData.length; i++) {
all = all.concat(this.loadedTilesData[i]);
}
all = this.filterByBounds(all);
all.sort(function(a, b){
if (a.sort < b.sort) {
return -1;
}
else {
return 1;
}
});
this.onTilesCompiled(all.slice(0, this.MAX_PIN_AMOUNT));
}
TileBasedPinHandler.prototype.filterByBounds = function(pins){
//use the googlemaps api
//google uses left-bottom and right-top corners
var rq = this.currentRequest;
var bounds = new GLatLngBounds(new GLatLng(rq.rb.lat, rq.lt.lon), new GLatLng(rq.lt.lat, rq.rb.lon))
var filtered = [];
for (var i = 0; i < pins.length; i++) {
var pin = pins[i];
var coord = new GLatLng(pin.lat, pin.lon);
if (bounds.contains(coord)) {
filtered.push(pin);
}
}
return filtered;
}
TileBasedPinHandler.prototype.onTilesCompiled = function(pins){
info('on tiles compiled:', pins);
this.map.onPinsForAreaLoaded(pins);
}
TileBasedPinHandler.prototype.toString = function(){
return "[TileBasedPinHandler Object]";
}
erstellt: " + pda['date'] + "
" + flag + "