// // Ryzom Maps // Copyright (c) 2009 Meelis Mägi // // This file is part of Ryzom Maps. // // Ryzom Maps is free software; you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published by // the Free Software Foundation; either version 3 of the License, or // (at your option) any later version. // // Ryzom Maps is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program; if not, write to the Free Software Foundation, // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // if(!Array.prototype.indexOf){ Array.prototype.indexOf = function(obj, n){ var len=this.length; n=n||0; for(var i=n; i pixel coorindate mapper * definition below */ var RyzomXY = {}; /** * Modifies icon URL such that it uses new color * @return GIcon */ GIcon.prototype.setColor=function(color){ // if no _name is set, then we dont use RyzomIcon if(!this._name) return; //var color=r.toString(16)+g.toString(16)+b.toString(16); this._color=color; this._over=MAPS_HOST+'api/icons.php?icon='+this._name+'_over&color='+color; this._original = MAPS_HOST+'api/icons.php?icon='+this._name+'&color='+color; this.image=this._original; return this; }; /** * Returns own copy * @return GIcon */ GIcon.prototype.copy=function(){ var c=new GIcon(this); if(this._name){ c._name=this._name; c._over=this._over; c._original=this._original; } return c; }; /** * Swaps marker icon * @param boolean state */ GMarker.prototype.setOver=function(state){ // do nothing for hidden marker if(this.isHidden()) return; var icon=this.getIcon(); if(state){ if(icon._over!=undefined){ this.setImage(icon._over); } }else{ if(icon._original!=undefined){ this.setImage(icon._original); } } }; var RyzomIcons = function(){ var me=this; // helper function to get icon full path function mkurl(image){ return MAPS_HOST+'images/icons/'+image; }; /** * Helper to create GIcon instance * * iconAnchor is set to middle of image, * infoWindowAnchor is set to top-center * dragCrossAnchor is set to 0x0 from iconAnchor. * icon will not rise when it's being dragged */ this.createIcon=function(name, color, size, shadowSize, imageMap){ var icon=new GIcon(); icon._name=name; icon.setColor(color); // setColor will also set icon name // GIcon properties icon.shadow = mkurl(name+'/shadow.png'); icon.printImage = mkurl(name+'/printImage.gif'); icon.mozPrintImage = mkurl(name+'/mozPrintImage.gif'); icon.printShadow = mkurl(name+'/printShadow.gif'); icon.transparent = mkurl(name+'/transparent.png'); icon.iconSize = size; icon.shadowSize = shadowSize; icon.iconAnchor = new GPoint(size.width/2, size.height/2); icon.infoWindowAnchor = new GPoint(size.width/2, 0); icon.imageMap = imageMap; icon.maxHeight = 0; // return icon; }; /** * Search icon by it's name and return it * @param icon one of 'lm_marker', 'op_townhall', 'building', etc * @return GIcon instance like RyzomIcons.MARKER, RyzomIcons.OP_TOWNHALL, etc * FALSE if icon was not found */ this.find = function(icon){ for(var a in me){ if(me[a] instanceof GIcon && me[a]._name==icon){ return a; } } return false; }; // this.MARKER = createIcon('lm_marker', 'ef4e4e', new GSize(24,24), new GSize(24,24), [23,15,19,23,18,23,6,23,1,15,5,0,19,0]); this.MISSION = this.MARKER.copy().setColor('1b9acf'); this.OUTPOST = this.MARKER.copy().setColor('1bcf34'); // this.OP_TOWNHALL = createIcon('op_townhall', '', new GSize(40,40), new GSize(60,40), [0,29,12,39,28,40,40,29,28,1,8,1]); this.BUILDING = createIcon('building', '', new GSize(32,32), new GSize(48,32), [1,11,21,2,31,13,31,24,18,30,3,26]); // this.MEKTOUB = createIcon('mektoub', '', new GSize(24,24), new GSize(36,24), [0,16,7,23,18,24,24,16,20,0,3,0]), this.SPAWN = createIcon('spawn', '', new GSize(24,24), new GSize(36,24), [0,15,5,24,17,24,24,15,19,0,5,0]); this.PORTAL = createIcon('portal', '', new GSize( 9, 9), new GSize(36, 9), [0,9,9,9,9,0,0,0]); // this.KAMI_TP = createIcon('tp_kami', '', new GSize(24,24), new GSize(36,24), [3,0,2,12,6,22,17,22,21,13,21,0]); this.KARAVAN_TP = createIcon('tp_karavan', '', new GSize(24,28), new GSize(38,28), [0,19,7,28,15,28,24,19,24,10,12,0,0,0]); // this.BANDIT_TRIBE = createIcon('camp', 'ef4e4e', new GSize(24,24), new GSize(36,24), [0,16,5,22,19,22,24,16,18,0,5,0,0,15]); this.KAMI_TRIBE = this.BANDIT_TRIBE.copy().setColor('ffff00'); this.KARAVAN_TRIBE = this.BANDIT_TRIBE.copy().setColor('00ffff'); // this.NPC = createIcon('npc', 'ffffff', new GSize(19,22), new GSize(30,22), [0,16,5,22,14,22,19,16,13,0,5,0,0,16]); this.NPC_VENDOR = this.NPC.copy().setColor('005bff'); this.NPC_MISSION = this.NPC_VENDOR.copy().setColor('7efc00'); this.NPC_TRAINER = this.NPC_VENDOR.copy().setColor('febe00'); // this.DIG_RESOURCE = createIcon('dig', 'ffffff', new GSize(24,24), new GSize(36,24), [3,23,11,23,24,18,24,9,15,0,2,0]); this.DIG_MISSION = this.DIG_RESOURCE.copy().setColor('9f9f9f'); return this; }(); /** * @return GMap2 instance */ function RyzomMap(id, defaultZoom, minZoom, maxZoom){ // our instance for anonymous functions var me=this; var minZoom = minZoom || 1; var maxZoom = maxZoom || 11; var defaultZoom = defaultZoom || 5; if (!GBrowserIsCompatible()) { alert('Sorry. Your browser is not supported by google maps'); return; } // default language var lang='en'; me.season='sp'; var tileserver=MAPS_HOST+'images/'; //****************************************************************************** // real world tiles var tilelayer = new GTileLayer(new GCopyrightCollection("Ryzom Maps by bmsite.net"), minZoom, maxZoom); tilelayer.getCopyright = function(a, b){ return {prefix: "Ryzom maps ©", copyrightTexts:["bmsite.net"]}; }; tilelayer.getTileUrl= function (a,z) { return tileserver+'atys/zoom_'+z+'/atys_'+z+'_'+a.x+'x'+a.y+'.jpg'; }; tilelayer.isPng = function() { return false; }; tilelayer.getOpacity = function() { return 1.0;}; //****************************************************************************** // ingame 'sattellite' tiles var igtiles = new GTileLayer(new GCopyrightCollection("Ryzom IG maps by bmsite.net"), minZoom, maxZoom); igtiles.getCopyright = function(a, b){ return {prefix: "Ryzom IG: ©", copyrightTexts:["bmsite.net"]}; }; igtiles.getTileUrl= function (a,z) { return tileserver+'atys_'+me.season+'/zoom_'+z+'/atys_'+me.season+'_'+z+'_'+a.x+'x'+a.y+'.jpg'; }; igtiles.isPng = function() { return false; }; igtiles.getOpacity = function() { return 1.0;}; //****************************************************************************** var projection=new GMercatorProjection(32); //****************************************************************************** var atysmap = new GMapType([tilelayer], projection, "Atys", { errorMessage:"No chart data available", minResolution:minZoom, maxResolution:maxZoom, textColor:'#555', linkColor:'#888' }); //****************************************************************************** var igmap = new GMapType([igtiles], projection, "Satellite", { errorMessage:"No chart data available", minResolution:minZoom, maxResolution:maxZoom, textColor:'#555', linkColor:'#888' }); //****************************************************************************** // GMap instance var map = new GMap2(document.getElementById(id), { backgroundColor: '#000', mapTypes:[atysmap, igmap] }); map.enableContinuousZoom(); map.enableScrollWheelZoom(); map.addControl(new GLargeMapControl(), new GControlPosition(G_ANCHOR_TOP_LEFT, new GSize(2,25))); map.addControl(new GMapTypeControl()); map.minZoom=minZoom; map.maxZoom=maxZoom; // create marker tooltip me.tooltip=new RyzomTooltip(new GSize(10, 10)); map.addOverlay(me.tooltip); /** * Event delegation - listen DOM mouseover/out events on main map container */ GEvent.addDomListener(map.getContainer(), 'mouseover', function(e){ //draggable marker has __e_ if(e.target.__marker__ != undefined){ try{ e.target.__marker__.setOver(true); // show tooltip if(e.target.__marker__.tooltip){ var pos=map.fromLatLngToDivPixel(e.target.__marker__.getLatLng()); me.tooltip.show(pos.x, pos.y, e.target.__marker__.tooltip); } }catch(ex){ // incase there is error } } }); GEvent.addDomListener(map.getContainer(), 'mouseout', function(e){ if(e.target.__marker__ != undefined){ try{ e.target.__marker__.setOver(false); // show tooltip me.tooltip.hide(); }catch(ex){ // incase there is error } } }); /** * hook up some ryzom methods to GMap2 map instance */ // Set map center point using ingame x/y // @param ax ingame x // @param ay ingame y // @param zoom zoom level starting from 1 (automatically adjusted to GMap zoom level // @param show_ig set TRUE if satellite view should be activated map.igCenter=function(ax, ay, zoom, show_ig){ map.setCenter(map.fromIngame(ax, ay), zoom, show_ig ? map.igMapType() : map.worldMapType()); }; // Returns GMap map type object for 'atys' view map.worldMapType=function(){ return atysmap; }; // Returns GMap map type object for 'satellite' view map.igMapType=function(){ return igmap; }; // returns true if ig tiles are active map.isIgMap=function(){ return map.getCurrentMapType()==igmap; }; // set IG tile season map.setSeason = function(season){ map.savePosition(); me.season=season; map.returnToSavedPosition(); }; //var world=RyzomXY.outgame_coordinates.world; //var world_w=world.r-world.l; //var world_h=world.b-world.t; // default center spot map.setCenter(map.fromImage(3540, 3540), defaultZoom, atysmap); // Return GMap2 object return map; }; /** * Translate Ryzom ingame x/y to LatLng and return GPoint instance * * @param ax ingame x * @param ay ingame y * @return GPoint */ GMap2.prototype.fromIngame=function(ax, ay){ var p=RyzomXY.fromIngameToOutgame(ax, ay, 2); return this.fromImage(p.x, p.y); }; /** * Convert image pixel coordinates to LatLng * * @param ax image x * @param ay image y * @return GPoint */ GMap2.prototype.fromImage=function(ax, ay){ return this.getCurrentMapType().getProjection().fromPixelToLatLng(new GPoint(ax, ay), RyzomXY.BASE_ZOOM); }; /** * Convert GPoint latLng to Ryzom ingame x/y * * @param latLng GPoint instance * @return {x:ig_x, y:ig_y, regions:[ig_street, ig_area, ig_region, ig_zone...]} * x is ingame x * y is ingame y * TODO: region only has lists one zone currently * regions is array of ingame regions that matched. sorted by region size, so 'smallest first' */ GMap2.prototype.toIngame=function(latLng){ var p=this.getCurrentMapType().getProjection().fromLatLngToPixel(latLng, RyzomXY.BASE_ZOOM); var ig=RyzomXY.fromOutgameToIngame(p.x, p.y); // TODO: do polygon search (slow!!) for ig_x/y if we need to know exact location return {x:ig.x, y:ig.y, regions: ig.regions}; }; //**************************************************************************** /** * Translates current mouse coordinates to ingame x/y/zone and displays them */ function RyzomNavLabelControl(){} RyzomNavLabelControl.prototype=new GControl(); /** * Create element where info is displayed and add it to map * Automatically called */ RyzomNavLabelControl.prototype.initialize=function(map){ var container = document.createElement('div'); this.setStyle(container); map.getContainer().appendChild(container); var start=new Date().getTime(); GEvent.addListener(map, 'mousemove', function(latlng){ // if less than 100ms apart, then skip coords update - html update does take a lot of 'power' var now=new Date().getTime(); if(now-start<100){ return; } start=now; // do latLng->Pixel->Ryzom ingame conversion var ig=map.toIngame(latlng); if(ig.regions.length == 0){ // out of zone, so clear status container.innerHTML="-"; }else{ container.innerHTML=ig.regions.join(';')+': x='+(ig.x.toFixed(2))+', y='+(ig.y.toFixed(2)) } }); return container; }; /** * Set the default location */ RyzomNavLabelControl.prototype.getDefaultPosition = function(){ return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 30)); }; /** * Define textbox style */ RyzomNavLabelControl.prototype.setStyle=function(div){ div.style.color = "#0000cc"; div.style.backgroundColor="white"; div.style.font="small Arial"; div.style.border="1px solid black"; div.style.padding="2px"; div.style.width="200px"; div.style.height="1.2em"; div.style.textAlign="center"; div.style.cursor="pointer"; div.style.fontSize="10px"; }; //**************************************************************************** /* * X/Y remapping * world map size * @zoom level 1 -- 1px ~ 512m ( 27x27 ) * @zoom level 2 -- 1px ~ 256m ( 55x55 ) * @zoom level 3 -- 1px ~ 128m ( 110x110 ) * @zoom level 4 -- 1px ~ 64m ( 221x221 ) * @zoom level 5 -- 1px ~ 32m ( 442x442 ) * @zoom level 6 -- 1px ~ 16m ( 885x885 ) * @zoom level 7 -- 1px = 8m ( 1770x1770 ) * @zoom level 8 -- 1px = 4m ( 3540x3540 ) * @zoom level 9 -- 1px = 2m ( 7080x7080 ) * @zoom level 10 -- 1px = 1m (14160x14160) * @zoom level 11 -- 1px = 0.5m (28320x28320) * * FIXME: create php mapxy to javascript exporter * * this needs to be in sync with tile creator data */ RyzomXY.BASE_ZOOM = 9; RyzomXY.outgame_coordinates = { //world : {l:0, t:0, r:7080, b:7080}, // fyros : {l:1460, t:318, w:2240, h:1600}, matis : {l:3880, t:176, w:2960, h:3760}, tryker : {l:3858, t:4112, w:3120, h:2720}, zorai : {l: 94, t:4442, w:2800, h:2480}, nexus : {l:4098, t:2828, w: 960, h:1120}, bagne : {l:4196, t:1870, w: 560, h: 800}, route_gouffre : {l:2896, t:2072, w: 960, h:3680}, terre : {l:1186, t:2480, w:1440, h:1360}, sources : {l:346, t:3500, w: 640, h: 800}, // newbieland : {l: 0, t:8000, w:1600, h:1040}, kitiniere : {l:2000, t:8000, w: 640, h: 640}, corrupted_moor: {l:4000, t:8000, w:1680, h:1130}, // fyros_newbie : {l:8000, t: 0, w:1120, h: 880}, matis_newbie : {l:8000, t:2000, w:1200, h: 960}, tryker_newbie : {l:8000, t:4000, w:1200, h: 960}, zorai_newbie : {l:8000, t:6000, w: 960, h: 720}, // fyros_island : {l:11000,t: 0, w:2400, h:560}, matis_island : {l:11000,t:2000, w:2160, h:640}, tryker_island : {l:11000,t:4000, w:3040, h:560}, zorai_island : {l:11000,t:6000, w:2400, h:640}, // almati : {l:11000,t: 2000,w: 640,h: 640}, olkern : {l:12840,t: 4080,w: 480,h: 480}, aelius : {l:12840,t: 0,w: 560,h: 320}, // testroom : {l:20000,t: 0,w:3200, h: 2615}, indoors : {l: 0,t:10000,w: 640, h: 160}, // r2_desert : {l:20000,t: 0,w: 4999,h: 5000}, r2_jungle : {l:26000,t: 0,w: 4999,h: 5000}, r2_lakes : {l:20000,t: 6000,w: 4999,h: 5000}, r2_forest : {l:26000,t: 6000,w: 4999,h: 5000}, r2_roots : {l:32000,t: 0,w: 5000,h: 5000}, //mask 'last comma' and also catch coords from full default zoom level grid size grid:{l: 0, t:0, w: 131072, h:131072} }; RyzomXY.ingame_coordinates = { // l=left, b=bottom, r=right, t=top, p=parent) fyros:{l:15840, b:-27040, r:20320, t:-23840, p:''}, matis:{l:320, b:-7840, r:6240, t:-320, p:''}, tryker:{l:13760, b:-34880, r:20000, t:-29440, p:''}, zorai:{l:6880, b:-5920, r:12480, t:-960, p:''}, bagne:{l:480, b:-11360, r:1600, t:-9760, p:''}, // abyss of ichor route_gouffre:{l:5440, b:-16960, r:7360, t:-9600, p:''}, // land of umbra sources:{l:2560, b:-11360, r:3840, t:-9760, p:''}, // under spring terre:{l:160, b:-15840, r:3040, t:-13120, p:''}, // wasteland nexus:{l:7840, b:-8320, r:9760, t:-6080, p:''}, // silan newbieland:{l:8160, b:-12320, r:11360, t:-10240, p:''}, // silan // city: fyros place_pyr:{l:18400, b:-24720, r:19040, t:-24240, p:'fyros'}, place_dyron:{l:16480, b:-24800, r:16720, t:-24480, p:'fyros'}, place_thesos:{l:19520, b:-26400, r:19760, t:-26080, p:'fyros'}, // city: matis place_yrkanis:{l:4640, b:-3680, r:4800, t:-3200, p:'matis'}, place_natae:{l:3600, b:-3840, r:3840, t:-3680, p:'matis'}, place_davae:{l:4160, b:-4240, r:4320, t:-4000, p:'matis'}, place_avalae:{l:4800, b:-4480, r:4960, t:-4320, p:'matis'}, // city: tryker place_avendale:{l:18000, b:-31200, r:18240, t:-30960, p:'tryker'}, place_crystabell:{l:17760, b:-32000, r:18000, t:-31760, p:'tryker'}, place_fairhaven:{l:16960, b:-33280, r:17440, t:-32720, p:'tryker'}, place_windermeer:{l:15440, b:-33120, r:15760, t:-32880, p:'tryker'}, // city: zorai place_zorai:{l:8480, b:-3040, r:8800, t:-2720, p:'zorai'}, place_hoi_cho:{l:9440, b:-3680, r:9680, t:-3360, p:'zorai'}, place_jen_lai:{l:8640, b:-3840, r:8960, t:-3520, p:'zorai'}, place_min_cho:{l:9760, b:-4320, r:10080, t:-4000, p:'zorai'}, // old pvp challenge areas fyros_island:{l:21120, b:-24960, r:25920, t:-23840, p:''}, tryker_island:{l:21120, b:-30560, r:27200, t:-29440, p:''}, matis_island:{l:14080, b:-1600, r:18400, t:-320, p:''}, zorai_island:{l:13920, b:-4800, r:18720, t:-3520, p:''}, // episode 2 areas almati:{l:14080, b:-1600, r:15360, t:-320, p:'matis_island'}, // Almati olkern:{l:24800, b:-30560, r:25760, t:-29600, p:'tryker_island'}, // Olkern aelius:{l:24800, b:-24480, r:25920, t:-23840, p:'fyros_island'}, // Aelius // old starter zones fyros_newbie:{l:20960, b:-27040, r:23200, t:-25280, p:''}, tryker_newbie:{l:20800, b:-34880, r:23200, t:-32960, p:''}, matis_newbie:{l:320, b:-7680, r:2720, t:-5760, p:''}, zorai_newbie:{l:7040, b:-5600, r:8960, t:-4160, p:''}, // corrupted_moor:{l:12480, b:-12200, r:15840, t:-9940, p:''}, kitiniere:{l:1760, b:-17440, r:3040, t:-16160, p:''}, // cont_kitiniere, 'kitiniere' has 160,-17600 .. 3040,-13120 // indoors:{l:20000, b:-640, r:21280, t:-320, p:''}, testroom:{l:33000, b:-5630, r:39400, t: -400, p:''}, // note: r2 t/b is reversed r2_roots:{l:30960, t:-20800, r:40960, b:-30800, p:''}, r2_desert:{l:20960, t:-800, r:30959, b:-10800, p:''}, r2_lakes:{l:20960, t:-10800, r:30959, b:-20800, p:''}, r2_forest:{l:30960, t:-800, r:40959, b:-10800, p:''}, r2_jungle:{l:30960, t:-10800, r:40959, b:-20800, p:''}, // mask 'last comma' grid: {l:-262144, b:-262144, r:0, t:0} }; /** * Searches in which region(s) X,Y belongs to * @return array of regions that match, first will always be smallest match (first is pyr, second is fyros for example) */ RyzomXY.belongsToIngame=function(x, y){ var me=this; function compare(i, j){ var a=me.ingame_coordinates[i], b=me.ingame_coordinates[j]; var aw=a.r-a.l, ah=a.t-a.b; var bw=b.r-b.l, bh=b.t-b.b; if(awbw || ah>bh) return 1; else return 0; } var matches=[]; for(var i in this.ingame_coordinates){ var z=this.ingame_coordinates[i]; if(x>=z.l && x<=z.r && y>=z.b && y<=z.t) { // (y>z.b && yb.w || a.h>b.h) return 1; else return 0; } var matches=[]; for(var i in this.outgame_coordinates){ var z=this.outgame_coordinates[i]; // skip those thos l/t is 0 //if(z.l==0 &&z.t==0) continue; var r=z.l+z.w; var b=z.t+z.h; if(x>=z.l && x<=r && y>=z.t && y<=b){ matches.push(i); } } matches.sort(compare); if(matches.length>0){ // first is smallest return matches[0]; }else{ return 'grid'; // should reach here anyway } }; /** * Converts Outgame coordinates to ingame ones * TODO: dive into towns and other inner regions / zones * * @param z ingame zone * @param x pixel coordinate * @param y pixel coordinate */ RyzomXY.fromOutgameToIngame = function(x, y, ig_region){ if(ig_region==undefined){ // if ig_region is not set, then try to find out where the x/y belongs to ig_region=this.belongsToOutgame(x, y); } var zone = this.outgame_coordinates[ig_region]; if( zone === undefined ){ return {x:0, y:0, regions:[]}; } if(DEBUG){ console.debug('fromOutGameToIngame: [', ig_region, ']; x=',x, 'y=',y); } // if zone is world level 'cont_*', then move it to zone level, modify x and y accordingly if(ig_region.match(/^cont_.*/)){ //console.debug('world level detected [',z,']'); // world level zone area might be different size so need to do careful x/y conversion // zone's continent coordinates var cont=this.outgame_coordinates[ig_region]; if(typeof cont.w == 'undefined'){ // fill in the blanks cont.w=cont.r-cont.l; cont.h=cont.b-cont.t; } var cont_px=(x-cont.l)/cont.w; var cont_py=(y-cont.t)/cont.h; if(DEBUG){ console.debug('cont = ', cont); console.debug('cont_w = ', cont.w, '; cont_h = ', cont.h); console.debug('cont_px = ', cont_px, '; cont_py = ', cont_py); } // convert cont_* to zone level ig_region = ig_region.replace(/^cont_/, ''); if(DEBUG){ console.debug('zone level [',ig_region,']'); } // take new zone now zone = this.outgame_coordinates[ig_region]; if( zone === undefined ){ // zone not found ? FIXME: break or continue with cont ?? return {x:0, y:0, regions:[]}; } // .. and new x/y is... x=zone.l+cont_px*zone.w; y=zone.t+cont_py*zone.h; if(DEBUG){ console.debug('zone = ', zone); console.debug('zone_w = ', zone.w, '; zone_h = ', zone.h); console.debug('zone_x = ', x, '; zone_y = ', y); console.debug(' --- '); } } // fill in the blanks if(typeof zone.w == 'undefined'){ // fill in the blanks zone.w=zone.r-zone.l; zone.h=zone.b-zone.t; } // outgame zone - x/y in 0x0 to WxH box var px=(x-zone.l)/zone.w; var py=(y-zone.t)/zone.h; if(DEBUG){ console.debug('zw = ', zone.w, '; zh = ', zone.h); console.debug('px = ', px, '; py = ', py); } // ingame zone var ig = this.ingame_coordinates[ig_region]; if( ig === undefined){ // fall back to full grid space ig_region='grid'; // ingame zone not found, map to 'grid' ig=this.ingame_coordinates[ig_region]; //return {x:0,y:0,regions:[]}; } if(DEBUG) console.debug('matched ig', ig_region, ig); var ig_w=ig.r-ig.l; var ig_h=Math.abs(ig.b-ig.t); var new_x=(ig.l+px*ig_w); var new_y=(ig.t-py*ig_h); // FIXME: verify this if(DEBUG){ console.debug('ig = ', ig_region, ig); console.debug('ig_w = ', ig_w, '; ig_h = ', ig_h); console.debug('new_x = ', new_x, '; new_y = ', new_y); console.debug(x, 'x', y, ' translated to outgame ', ig_region, zone); } // get ig regions where this spot really belongs to var igr=this.belongsToIngame(new_x, new_y); return { x: new_x, y: new_y, regions: igr }; }; /* * Maps ingame coordinates to pixel coordinates * * @param x * @param y * * @return object with {name, x, y} parameters where name is map name and x/y map coords * */ RyzomXY.fromIngameToOutgame = function(x, y){ var zones = this.belongsToIngame(x, y); if(DEBUG){ console.debug('ingame ', x, y, ' belongsTo ingame ', zones); } // no match ?? if(zones.length==0){ // try to find closest zone and attach the point var prev_dx=Infinity; var prev_dy=Infinity; var closest=''; for(var i in this.ingame_coordinates){ var z=this.ingame_coordinates[i]; // distance for 4 sides var dxl=Math.abs(z.l-x); var dyb=Math.abs(z.b-y); var dxr=Math.abs(z.r-x); var dyt=Math.abs(z.t-y); var dx, dy; if(dxl // // This file is part of Ryzom Maps at http://maps.bmsite.net // /** * Translates current mouse coordinates to ingame x/y/zone and displays them */ function RyzomMapLabelControl(rl){ this.langs=['en', 'fr', 'de', 'ru']; this.rl_=rl; this.doLabelChange=function(self, target){ return true;}; } RyzomMapLabelControl.prototype=new GControl(); /** * Create element where info is displayed and add it to map * Automatically called */ RyzomMapLabelControl.prototype.initialize=function(map){ var container = document.createElement('div'); this.setStyle(container); for(var i=0;i // // This file is part of Ryzom Maps at http://maps.bmsite.net // /** * Labels for map - comes with it's own marker manager * * @param string lang label language - en, fr, de * @param bool show_region_level if set to TRUE, then show colored region names - default is FALSE */ function RyzomMapLabelOverlay(lang, show_region_level){ // default language is 'en' this.lang=lang; this.show_region_level = false; this.dragged=false; // this.labels = []; // this.hidden = false; }; RyzomMapLabelOverlay.prototype=new GOverlay(); /** * Set label language and calls redraw */ RyzomMapLabelOverlay.prototype.setLanguage=function(lang){ if(this.lang==lang) return; var me=this; // change language this.lang=lang; setTimeout(function(){ for(var i=0,len=me.labels.length;i'; if(me.labels[i].marker.tooltip != undefined){ me.labels[i].marker.tooltip=name; }else{ try{ me.labels[i].marker.setContents(name); }catch(ex){ me.labels[i].marker.html=name; } } } }, 0); }; /** * Attach or remove region color CSS rules * * @param bool state */ RyzomMapLabelOverlay.prototype.showRegionLevel=function(state){ if(this.show_region_level==state){ return; } // FIXME: must look thru all the labels and change their class name // there is no one single DIV unfortunately this.show_region_level=state; }; /** * @param GMap2 map */ RyzomMapLabelOverlay.prototype.initialize=function(map){ // called by map after the overlay is added to the map using GMap2.addOverlay() this.map_ = map; // disable redraw when map is being dragged var me=this; GEvent.addListener(this.map_, 'dragstart', function(){ me.dragged=true; }); GEvent.addListener(this.map_, 'dragend', function(){ me.dragged=false; me.redraw(); }); // prep labels this.doLabels(); // set css to show colorized region labels this.showRegionLevel(this.show_region_level); }; RyzomMapLabelOverlay.prototype.remove=function(){ // remove labels from map for(var i=0,len=this.labels.length;i=opts.min && zoom<=opts.max && ((m.is_label && opts.label) || (!m.is_label && opts.icon))) { if(!m.marker.attached){ this.map_.addOverlay(m.marker); m.marker.attached=true; } m.marker.show(); }else{ m.marker.hide(); } } }; RyzomMapLabelOverlay.prototype.getKml=function(callback){ return false; }; RyzomMapLabelOverlay.prototype.hide=function(){ this.hidden=true; for(var i=0,len=this.labels.length;i9; minZoom=7; break; case 3: // stable minZoom=7; showLabel=false; break; case 4: // region minZoom=7; break; case 5: // area minZoom=8; break; case 6: // street minZoom=10; break; } return { min:minZoom, max:maxZoom, icon:showIcon, label:showLabel}; }; /** * Creates label elements and adds them to map */ RyzomMapLabelOverlay.prototype.doLabels=function(){ // this.disabledRegions=[ // 'corrupted_moor', // Ring region text 'r2_desert', 'r2_lakes', 'r2_jungle', 'r2_forest', 'r2_roots', // these mask 'Old Land' text //'tryker_island', 'matis_island', 'zorai_island', 'fyros_island' ]; var markers=[]; for(var i=0,len=ryzomLabels.length;i0 && this.disabledRegions.indexOf(dst[0])>-1){ continue; } var latlng=this.map_.fromIngame(ryzomLabels[i].x, ryzomLabels[i].y); if(ryzomLabels[i].icon!=''){ // icon might have a tooltip var icon=new GMarker(latlng, { icon: RyzomIcons.OUTPOST }); icon.tooltip = ''+ryzomLabels[i].name[this.lang]+''; this.labels.push({ idx : i, type : ryzomLabels[i].type, latlng : latlng, marker : icon, is_label: false, attached: false // is marker added to map ? }); } var level=ryzomLabels[i].level || '0'; var label = new ELabel(latlng, ryzomLabels[i].name[this.lang], "mapLabel mapLabel"+ryzomLabels[i].type+" region-q"+level, new GSize(-100, 0)); // FIXME: dup code this.labels.push({ idx : i, type : ryzomLabels[i].type, latlng : latlng, marker : label, is_label: true, attached: false // is marker added to map ? }); } }; // ELabel.js // // This Javascript is provided by Mike Williams // Community Church Javascript Team // http://www.bisphamchurch.org.uk/ // http://econym.org.uk/gmap/ // // This work is licenced under a Creative Commons Licence // http://creativecommons.org/licenses/by/2.0/uk/ // // Version 0.2 the .copy() parameters were wrong // version 1.0 added .show() .hide() .setContents() .setPoint() .setOpacity() .overlap // version 1.1 Works with GMarkerManager in v2.67, v2.68, v2.69, v2.70 and v2.71 // version 1.2 Works with GMarkerManager in v2.72, v2.73, v2.74 and v2.75 // version 1.3 add .isHidden() // version 1.4 permit .hide and .show to be used before addOverlay() // version 1.5 fix positioning bug while label is hidden // version 1.6 added .supportsHide() // version 1.7 fix .supportsHide() // version 1.8 remove the old GMarkerManager support due to clashes with v2.143 function ELabel(point, html, classname, pixelOffset, percentOpacity, overlap) { // Mandatory parameters this.point = point; this.html = html; // Optional parameters this.classname = classname||""; this.pixelOffset = pixelOffset||new GSize(0,0); if (percentOpacity) { if(percentOpacity<0){percentOpacity=0;} if(percentOpacity>100){percentOpacity=100;} } this.percentOpacity = percentOpacity; this.overlap=overlap||false; this.hidden = false; } ELabel.prototype = new GOverlay(); ELabel.prototype.initialize = function(map) { var div = document.createElement("div"); div.style.position = "absolute"; div.innerHTML = '
' + this.html + '
' ; //map.getPane(G_MAP_FLOAT_SHADOW_PANE).appendChild(div); map.getPane(G_MAP_MARKER_SHADOW_PANE).appendChild(div); this.map_ = map; this.div_ = div; if (this.percentOpacity) { if(typeof(div.style.filter)=='string'){div.style.filter='alpha(opacity:'+this.percentOpacity+')';} if(typeof(div.style.KHTMLOpacity)=='string'){div.style.KHTMLOpacity=this.percentOpacity/100;} if(typeof(div.style.MozOpacity)=='string'){div.style.MozOpacity=this.percentOpacity/100;} if(typeof(div.style.opacity)=='string'){div.style.opacity=this.percentOpacity/100;} } if (this.overlap) { var z = GOverlay.getZIndex(this.point.lat()); this.div_.style.zIndex = z; } if (this.hidden) { this.hide(); } }; ELabel.prototype.remove = function() { this.div_.parentNode.removeChild(this.div_); }; ELabel.prototype.copy = function() { return new ELabel(this.point, this.html, this.classname, this.pixelOffset, this.percentOpacity, this.overlap); }; ELabel.prototype.redraw = function(force) { if(force){ var p = this.map_.fromLatLngToDivPixel(this.point); var h = parseInt(this.div_.clientHeight); this.div_.style.left = (p.x + this.pixelOffset.width) + "px"; this.div_.style.top = (p.y +this.pixelOffset.height - h) + "px"; } }; ELabel.prototype.show = function() { if (this.div_) { this.div_.style.display=""; this.redraw(); } this.hidden = false; }; ELabel.prototype.hide = function() { if (this.div_) { this.div_.style.display="none"; } this.hidden = true; }; ELabel.prototype.isHidden = function() { return this.hidden; }; ELabel.prototype.supportsHide = function() { return true; }; ELabel.prototype.setContents = function(html) { this.html = html; this.div_.innerHTML = '
' + this.html + '
' ; this.redraw(true); }; ELabel.prototype.setPoint = function(point) { this.point = point; if (this.overlap) { var z = GOverlay.getZIndex(this.point.lat()); this.div_.style.zIndex = z; } this.redraw(true); }; ELabel.prototype.setOpacity = function(percentOpacity) { if (percentOpacity) { if(percentOpacity<0){percentOpacity=0;} if(percentOpacity>100){percentOpacity=100;} } this.percentOpacity = percentOpacity; if (this.percentOpacity) { if(typeof(this.div_.style.filter)=='string'){this.div_.style.filter='alpha(opacity:'+this.percentOpacity+')';} if(typeof(this.div_.style.KHTMLOpacity)=='string'){this.div_.style.KHTMLOpacity=this.percentOpacity/100;} if(typeof(this.div_.style.MozOpacity)=='string'){this.div_.style.MozOpacity=this.percentOpacity/100;} if(typeof(this.div_.style.opacity)=='string'){this.div_.style.opacity=this.percentOpacity/100;} } }; ELabel.prototype.getPoint = function() { return this.point; }; ELabel.prototype.getLatLng = function() { return this.point; }; /** * @name MarkerClusterer * @version 1.0 * @author Xiaoxi Wu * @copyright (c) 2009 Xiaoxi Wu * @fileoverview * This javascript library creates and manages per-zoom-level * clusters for large amounts of markers (hundreds or thousands). * This library was inspired by the * Maptimize hosted clustering solution. *

* How it works:
* The MarkerClusterer will group markers into clusters according to * their distance from a cluster's center. When a marker is added, * the marker cluster will find a position in all the clusters, and * if it fails to find one, it will create a new cluster with the marker. * The number of markers in a cluster will be displayed * on the cluster marker. When the map viewport changes, * MarkerClusterer will destroy the clusters in the viewport * and regroup them into new clusters. * */ /* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @name MarkerClustererOptions * @class This class represents optional arguments to the {@link MarkerClusterer} * constructor. * @property {Number} [maxZoom] The max zoom level monitored by a * marker cluster. If not given, the marker cluster assumes the maximum map * zoom level. When maxZoom is reached or exceeded all markers will be shown * without cluster. * @property {Number} [gridSize=60] The grid size of a cluster in pixel. Each * cluster will be a square. If you want the algorithm to run faster, you can set * this value larger. * @property {Array of MarkerStyleOptions} [styles] * Custom styles for the cluster markers. * The array should be ordered according to increasing cluster size, * with the style for the smallest clusters first, and the style for the * largest clusters last. * @property {Function} [calculator] A function to calculator what will be showed * on cluster marker and what kind of style will cluster marker be. * This function auto called by Cluster. The default calculator will show number * of markers in a cluster. This function take one parm: markers. * You can add some property to marker of this markers array to calculat values. * This function returns an object: * { * 'text': 'The text to be showed on cluster marker', * 'index': 'Style index in array of MarginStylesOptions user passed.' * } * @property {Boolean} [zoomOnClick=true] Whether default behaviour of zooming on a cluster * upon clicking should be used. */ /** * @name MarkerStyleOptions * @class An array of these is passed into the {@link MarkerClustererOptions} * styles option. * @property {String} [url] Image url. * @property {Number} [height] Image height. * @property {Number} [height] Image width. * @property {Array of Number} [opt_anchor] Anchor for label text, like [24, 12]. * If not set, the text will align center and middle. * @property {String} [opt_textColor="black"] Text color. * @property {Number} [opt_textSize=11] Text size in px. */ /** * Creates a new MarkerClusterer to cluster markers on the map. * * @constructor * @param {GMap2} map The map that the markers should be added to. * @param {Array of GMarker} opt_markers Initial set of markers to be clustered. * @param {MarkerClustererOptions} opt_opts A container for optional arguments. */ function MarkerClusterer(map, opt_markers, opt_opts) { // private members var clusters_ = []; var map_ = map; var maxZoom_ = null; var me_ = this; var gridSize_ = 60; var sizes = [53, 56, 66, 78, 90]; var styles_ = []; var leftMarkers_ = []; var mcfn_ = null; var zoomOnClick_ = true; // default calculator function var calculator_ = function (markers) { var index = 0; var count = markers.length; var dv = count; while (dv !== 0) { dv = parseInt(dv / 10, 10); index ++; } var stylesCount = this.getStyles().length; if (stylesCount < index) { index = stylesCount; } return { 'text': count, 'index': index }; }; var i = 0; for (i = 1; i <= 5; ++i) { styles_.push({ 'url': 'http://gmaps-utility-library.googlecode.com/svn/trunk/markerclusterer/images/m' + i + '.png', 'height': sizes[i - 1], 'width': sizes[i - 1] }); } if (typeof opt_opts === 'object' && opt_opts !== null) { if (typeof opt_opts.gridSize === 'number' && opt_opts.gridSize > 0) { gridSize_ = opt_opts.gridSize; } if (typeof opt_opts.maxZoom === 'number') { maxZoom_ = opt_opts.maxZoom; } if (typeof opt_opts.styles === 'object' && opt_opts.styles !== null && opt_opts.styles.length !== 0) { styles_ = opt_opts.styles; } if (typeof opt_opts.calculator === 'function') { calculator_ = opt_opts.calculator; } if (typeof opt_opts.zoomOnClick === 'boolean') { zoomOnClick_ = opt_opts.zoomOnClick; } } /** * Set calculator function * @param {Function} calculator calculator function. */ this.setCalculator = function (calculator) { calculator_ = calculator; }; /** * Get calculator function. * @return {Object} */ this.getCalculator = function () { return GEvent.callback(this, calculator_); }; /** * Get boolean value representing whether default behaviour of zooming on cluster upon clicking should be used. * @return {Boolean} */ this.isZoomOnClick = function() { return zoomOnClick_; }; /** * When we add a marker, the marker may not in the viewport of map, then we don't deal with it, instead * we add the marker into a array called leftMarkers_. When we reset MarkerClusterer we should add the * leftMarkers_ into MarkerClusterer. */ function addLeftMarkers_() { if (leftMarkers_.length === 0) { return; } var leftMarkers = []; for (i = 0; i < leftMarkers_.length; ++i) { if (isMarkerInViewport_(leftMarkers_[i])) { me_.addMarker(leftMarkers_[i], true, null, null, true); } else { leftMarkers.push(leftMarkers_[i]); } } leftMarkers_ = leftMarkers; } /** * Get cluster marker images of this marker cluster. Mostly used by {@link Cluster} * @return {Array of String} */ this.getStyles = function () { return styles_; }; /** * Remove all markers from MarkerClusterer. */ this.clearMarkers = function () { for (var i = 0; i < clusters_.length; ++i) { if (typeof clusters_[i] !== "undefined" && clusters_[i] !== null) { clusters_[i].clearMarkers(); } } clusters_ = []; leftMarkers_ = []; // GEvent.removeListener(mcfn_); }; /** * Check a marker, whether it is in current map viewport. * @private * @return {Boolean} if it is in current map viewport */ function isMarkerInViewport_(marker) { return map_.getBounds().containsLatLng(marker.getLatLng()); } /** * When reset MarkerClusterer, there will be some markers get out of its cluster. * These markers should be add to new clusters. * @param {Array of GMarker} markers Markers to add. */ function reAddMarkers_(markers) { var len = markers.length; var clusters = []; for (var i = len - 1; i >= 0; --i) { me_.addMarker(markers[i].marker, true, markers[i].isAdded, clusters, true); } addLeftMarkers_(); } /** * Add a marker. * @private * @param {GMarker} marker Marker you want to add * @param {Boolean} opt_isNodraw Whether redraw the cluster contained the marker * @param {Boolean} opt_isAdded Whether the marker is added to map. Never use it. * @param {Array of Cluster} opt_clusters Provide a list of clusters, the marker * cluster will only check these cluster where the marker should join. */ this.addMarker = function (marker, opt_isNodraw, opt_isAdded, opt_clusters, opt_isNoCheck) { if (opt_isNoCheck !== true) { if (!isMarkerInViewport_(marker)) { leftMarkers_.push(marker); return; } } var isAdded = opt_isAdded; var clusters = opt_clusters; var pos = map_.fromLatLngToDivPixel(marker.getLatLng()); if (typeof isAdded !== "boolean") { isAdded = false; } if (typeof clusters !== "object" || clusters === null) { clusters = clusters_; } var length = clusters.length; var cluster = null; for (var i = length - 1; i >= 0; i--) { cluster = clusters[i]; var center = cluster.getCenter(); if (center === null) { continue; } center = map_.fromLatLngToDivPixel(center); // Found a cluster which contains the marker. if (pos.x >= center.x - gridSize_ && pos.x <= center.x + gridSize_ && pos.y >= center.y - gridSize_ && pos.y <= center.y + gridSize_) { cluster.addMarker({ 'isAdded': isAdded, 'marker': marker }); if (!opt_isNodraw) { cluster.redraw_(); } return; } } // No cluster contain the marker, create a new cluster. cluster = new Cluster(this, map); cluster.addMarker({ 'isAdded': isAdded, 'marker': marker }); if (!opt_isNodraw) { cluster.redraw_(); } // Add this cluster both in clusters provided and clusters_ clusters.push(cluster); if (clusters !== clusters_) { clusters_.push(cluster); } }; /** * Remove a marker. * * @param {GMarker} marker The marker you want to remove. */ this.removeMarker = function (marker) { for (var i = 0; i < clusters_.length; ++i) { if (clusters_[i] && clusters_[i].removeMarker(marker)) { clusters_[i].redraw_(); return; } } }; /** * Redraw all clusters in viewport. */ this.redraw_ = function () { var clusters = this.getClustersInViewport_(); for (var i = 0; i < clusters.length; ++i) { clusters[i].redraw_(true); } }; /** * Get all clusters in viewport. * @return {Array of Cluster} */ this.getClustersInViewport_ = function () { var clusters = []; var curBounds = map_.getBounds(); for (var i = 0; i < clusters_.length; i ++) { if (clusters_[i].isInBounds(curBounds)) { clusters.push(clusters_[i]); } } return clusters; }; /** * Get max zoom level. * @private * @return {Number} */ this.getMaxZoom_ = function () { return maxZoom_; }; /** * Get map object. * @private * @return {GMap2} */ this.getMap_ = function () { return map_; }; /** * Get grid size * @private * @return {Number} */ this.getGridSize_ = function () { return gridSize_; }; /** * Get total number of markers. * @return {Number} */ this.getTotalMarkers = function () { var result = 0; for (var i = 0; i < clusters_.length; ++i) { result += clusters_[i].getTotalMarkers(); } return result; }; /** * Get total number of clusters. * @return {int} */ this.getTotalClusters = function () { return clusters_.length; }; /** * Collect all markers of clusters in viewport and regroup them. */ this.resetViewport = function () { var clusters = this.getClustersInViewport_(); var tmpMarkers = []; var removed = 0; for (var i = 0; i < clusters.length; ++i) { var cluster = clusters[i]; var oldZoom = cluster.getCurrentZoom(); if (oldZoom === null) { continue; } var curZoom = map_.getZoom(); if (curZoom !== oldZoom) { // If the cluster zoom level changed then destroy the cluster // and collect its markers. var mks = cluster.getMarkers(); for (var j = 0; j < mks.length; ++j) { var newMarker = { 'isAdded': false, 'marker': mks[j].marker }; tmpMarkers.push(newMarker); } cluster.clearMarkers(); removed++; for (j = 0; j < clusters_.length; ++j) { if (cluster === clusters_[j]) { clusters_.splice(j, 1); } } } } // Add the markers collected into marker cluster to reset reAddMarkers_(tmpMarkers); this.redraw_(); }; /** * Add a set of markers. * * @param {Array of GMarker} markers The markers you want to add. */ this.addMarkers = function (markers) { for (var i = 0; i < markers.length; ++i) { this.addMarker(markers[i], true); } this.redraw_(); }; /** * Returns the cluster containing this marker, if any. * * @param {GMarker} marker The marker whose containing cluster is to be returned. * @return {Cluster} */ this.getParentCluster = function(marker) { return marker.parentCluster_; }; // initialize if (typeof opt_markers === "object" && opt_markers !== null) { this.addMarkers(opt_markers); } // when map move end, regroup. mcfn_ = GEvent.addListener(map_, "moveend", function () { me_.resetViewport(); }); } /** * Create a cluster to collect markers. * A cluster includes some markers which are in a block of area. * If there are more than one markers in cluster, the cluster * will create a {@link ClusterMarker_} and show the total number * of markers in cluster. * * @constructor * @private * @param {MarkerClusterer} markerClusterer The marker cluster object */ function Cluster(markerClusterer) { var center_ = null; var markers_ = []; var markerClusterer_ = markerClusterer; var map_ = markerClusterer.getMap_(); var clusterMarker_ = null; var zoom_ = map_.getZoom(); var this_ = this; /** * Get markers of this cluster. * * @return {Array of GMarker} */ this.getMarkers = function () { return markers_; }; /** * Get the marker clusterer handling this cluster * * @return {MarkerClusterer} The marker clusterer object */ this.getMarkerClusterer = function() { return markerClusterer_; }; /** * If this cluster intersects certain bounds. * * @param {GLatLngBounds} bounds A bounds to test * @return {Boolean} Is this cluster intersects the bounds */ this.isInBounds = function (bounds) { if (center_ === null) { return false; } if (!bounds) { bounds = map_.getBounds(); } var sw = map_.fromLatLngToDivPixel(bounds.getSouthWest()); var ne = map_.fromLatLngToDivPixel(bounds.getNorthEast()); var centerxy = map_.fromLatLngToDivPixel(center_); var inViewport = true; var gridSize = markerClusterer.getGridSize_(); if (zoom_ !== map_.getZoom()) { var dl = map_.getZoom() - zoom_; gridSize = Math.pow(2, dl) * gridSize; } if (ne.x !== sw.x && (centerxy.x + gridSize < sw.x || centerxy.x - gridSize > ne.x)) { inViewport = false; } if (inViewport && (centerxy.y + gridSize < ne.y || centerxy.y - gridSize > sw.y)) { inViewport = false; } return inViewport; }; /** * Get cluster center. * * @return {GLatLng} */ this.getCenter = function () { return center_; }; /** * Add a marker. * * @param {Object} marker An object of marker you want to add: * {Boolean} isAdded If the marker is added on map. * {GMarker} marker The marker you want to add. */ this.addMarker = function (marker) { if (center_ === null) { /*var pos = marker['marker'].getLatLng(); pos = map.fromLatLngToContainerPixel(pos); pos.x = parseInt(pos.x - pos.x % (GRIDWIDTH * 2) + GRIDWIDTH); pos.y = parseInt(pos.y - pos.y % (GRIDWIDTH * 2) + GRIDWIDTH); center = map.fromContainerPixelToLatLng(pos);*/ center_ = marker.marker.getLatLng(); } marker.marker.parentCluster_ = this_; markers_.push(marker); }; /** * Remove a marker from cluster. * * @param {GMarker} marker The marker you want to remove. * @return {Boolean} Whether find the marker to be removed. */ this.removeMarker = function (marker) { for (var i = 0; i < markers_.length; ++i) { if (marker === markers_[i].marker) { if (markers_[i].isAdded) { map_.removeOverlay(markers_[i].marker); } delete markers_[i].marker.parentCluster_; markers_.splice(i, 1); return true; } } return false; }; /** * Get current zoom level of this cluster. * Note: the cluster zoom level and map zoom level not always the same. * * @return {Number} */ this.getCurrentZoom = function () { return zoom_; }; /** * Redraw a cluster. * @private * @param {Boolean} isForce If redraw by force, no matter if the cluster is * in viewport. */ this.redraw_ = function (isForce) { if (!isForce && !this.isInBounds()) { return; } // Set cluster zoom level. zoom_ = map_.getZoom(); var i = 0; var mz = markerClusterer.getMaxZoom_(); if (mz === null) { mz = map_.getCurrentMapType().getMaximumResolution(); } if (zoom_ > mz || this.getTotalMarkers() === 1) { // If current zoom level is beyond the max zoom level or the cluster // have only one marker, the marker(s) in cluster will be showed on map. for (i = 0; i < markers_.length; ++i) { if (markers_[i].isAdded) { if (markers_[i].marker.isHidden()) { markers_[i].marker.show(); } } else { map_.addOverlay(markers_[i].marker); markers_[i].isAdded = true; } } if (clusterMarker_ !== null) { clusterMarker_.hide(); } } else if (this.getTotalMarkers() > 1) { // Else add a cluster marker on map to show the number of markers in // this cluster. for (i = 0; i < markers_.length; ++i) { if (markers_[i].isAdded && (!markers_[i].marker.isHidden())) { markers_[i].marker.hide(); } } var sums = markerClusterer_.getCalculator()(this.getRealMarkers()); if (clusterMarker_ === null) { clusterMarker_ = new ClusterMarker_(center_, sums, markerClusterer_.getStyles(), markerClusterer_.getGridSize_(), this_); map_.addOverlay(clusterMarker_); } else { if (clusterMarker_.isHidden()) { clusterMarker_.show(); } clusterMarker_.setSums(sums); clusterMarker_.redraw(true); } } }; /** * Remove all the markers from this cluster. */ this.clearMarkers = function () { if (clusterMarker_ !== null) { map_.removeOverlay(clusterMarker_); } for (var i = 0; i < markers_.length; ++i) { if (markers_[i].isAdded) { map_.removeOverlay(markers_[i].marker); } delete markers_[i].marker.parentCluster_; } markers_ = []; }; /** * Get number of markers. * @return {Number} */ this.getTotalMarkers = function () { return markers_.length; }; /** * Get all real markers by array. * @return {GMarker} */ this.getRealMarkers = function () { var result = []; for (var i = 0; i < markers_.length; ++i) { result.push(markers_[i].marker); } return result; }; } /** * ClusterMarker_ creates a marker that shows the number of markers that * a cluster contains. * * @constructor * @private * @param {GLatLng} latlng Marker's lat and lng. * @param {Object} sums text and image to show: * {String} text Text to show. * {Number} index Image index by styles. * @param {Array of Object} styles The image list to be showed: * {String} url Image url. * {Number} height Image height. * {Number} width Image width. * {Array of Number} anchor Text anchor of image left and top. * {String} textColor text color. * @param {Number} padding Padding of marker center. * @param {Cluster} cluster Cluster object that corresponds to this marker. */ function ClusterMarker_(latlng, sums, styles, padding, cluster) { /* var index = 0; var dv = count; while (dv !== 0) { dv = parseInt(dv / 10, 10); index ++; } if (styles.length < index) { index = styles.length; }*/ var index = sums.index; this.useStyle(styles[index-1]); this.styleDirty_ = false; this.latlng_ = latlng; this.index_ = index; this.styles_ = styles; this.text_ = sums.text; this.padding_ = padding; this.sums_ = sums; this.cluster_ = cluster; } ClusterMarker_.prototype = new GOverlay(); /** * Populates style dependant fields given a particular style. * @private */ ClusterMarker_.prototype.useStyle = function(style) { this.url_ = style.url; this.height_ = style.height; this.width_ = style.width; this.textColor_ = style.opt_textColor; this.anchor_ = style.opt_anchor; this.textSize_ = style.opt_textSize; }; /** * Initialize cluster marker. * @private */ ClusterMarker_.prototype.initialize = function (map) { this.map_ = map; var div = document.createElement("div"); var latlng = this.latlng_; var pos = this.getPosFromLatLng(latlng); div.style.cssText = this.createCss(pos); div.innerHTML = this.text_; map.getPane(G_MAP_MAP_PANE).appendChild(div); var padding = this.padding_; var cluster = this.cluster_; GEvent.addDomListener(div, "click", function () { GEvent.trigger(cluster.getMarkerClusterer(), "clusterclick", cluster); if (cluster.getMarkerClusterer().isZoomOnClick()) { var pos = map.fromLatLngToDivPixel(latlng); var sw = new GPoint(pos.x - padding, pos.y + padding); sw = map.fromDivPixelToLatLng(sw); var ne = new GPoint(pos.x + padding, pos.y - padding); ne = map.fromDivPixelToLatLng(ne); var zoom = map.getBoundsZoomLevel(new GLatLngBounds(sw, ne), map.getSize()); map.setCenter(latlng, zoom); } }); this.div_ = div; }; /** * Returns position to place the div depending on the latlong. * @private */ ClusterMarker_.prototype.getPosFromLatLng = function(latlng) { var pos = this.map_.fromLatLngToDivPixel(latlng); pos.x -= parseInt(this.width_ / 2, 10); pos.y -= parseInt(this.height_ / 2, 10); return pos; }; /** * Returns the css style string to be applied to the div given its position. * @private */ ClusterMarker_.prototype.createCss = function(pos) { var mstyle = ""; if (document.all) { mstyle = 'filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale,src="' + this.url_ + '");'; } else { mstyle = "background:url(" + this.url_ + ");"; } if (typeof this.anchor_ === "object") { if (typeof this.anchor_[0] === "number" && this.anchor_[0] > 0 && this.anchor_[0] < this.height_) { mstyle += 'height:' + (this.height_ - this.anchor_[0]) + 'px;padding-top:' + this.anchor_[0] + 'px;'; } else { mstyle += 'height:' + this.height_ + 'px;line-height:' + this.height_ + 'px;'; } if (typeof this.anchor_[1] === "number" && this.anchor_[1] > 0 && this.anchor_[1] < this.width_) { mstyle += 'width:' + (this.width_ - this.anchor_[1]) + 'px;padding-left:' + this.anchor_[1] + 'px;'; } else { mstyle += 'width:' + this.width_ + 'px;text-align:center;'; } } else { mstyle += 'height:' + this.height_ + 'px;line-height:' + this.height_ + 'px;'; mstyle += 'width:' + this.width_ + 'px;text-align:center;'; } var txtColor = this.textColor_ ? this.textColor_ : 'black'; var txtSize = this.textSize_ ? this.textSize_ : 11; return mstyle + 'cursor:pointer;top:' + pos.y + "px;left:" + pos.x + "px;color:" + txtColor + ";position:absolute;font-size:" + txtSize + "px;" + 'font-family:Arial,sans-serif;font-weight:bold'; }; /** * Remove this overlay. * @private */ ClusterMarker_.prototype.remove = function () { this.div_.parentNode.removeChild(this.div_); }; /** * Copy this overlay. * @private */ ClusterMarker_.prototype.copy = function () { return new ClusterMarker_(this.latlng_, this.sums_, this.text_, this.styles_, this.padding_, this.cluster_); }; /** * Redraw this overlay. * @private */ ClusterMarker_.prototype.redraw = function (force) { if (!force) { return; } var pos = this.getPosFromLatLng(this.latlng_); if (this.styleDirty_) { this.styleDirty_ = false; this.useStyle(this.styles_[this.index_-1]); this.div_.style.cssText = this.createCss(pos); } else { this.div_.style.top = pos.y + "px"; this.div_.style.left = pos.x + "px"; } }; /** * Hide this cluster marker. */ ClusterMarker_.prototype.hide = function () { this.div_.style.display = "none"; }; /** * Show this cluster marker. */ ClusterMarker_.prototype.show = function () { this.div_.style.display = ""; }; /** * Get whether the cluster marker is hidden. * @return {Boolean} */ ClusterMarker_.prototype.isHidden = function () { return this.div_.style.display === "none"; }; /** * Sets this cluster marker sums value, updates its text and marks the style for updating on next redraw if necessary. * @param {Object} sums text and image to show: * {String} text Text to show. * {Number} index Image index by styles. */ ClusterMarker_.prototype.setSums = function (sums) { if (sums.index !== this.index_) { this.styleDirty_ = true; } this.sums_ = sums; this.text_ = sums.text; this.index_ = sums.index; this.div_.innerHTML = sums.text; }; /** * @name MarkerManager * @version 1.0 * @copyright (c) 2007 Google Inc. * @author Doug Ricket, others * * @fileoverview Marker manager is an interface between the map and the user, * designed to manage adding and removing many points when the viewport changes. *

* How it Works:
* The MarkerManager places its markers onto a grid, similar to the map tiles. * When the user moves the viewport, it computes which grid cells have * entered or left the viewport, and shows or hides all the markers in those * cells. * (If the users scrolls the viewport beyond the markers that are loaded, * no markers will be visible until the EVENT_moveend * triggers an update.) * In practical consequences, this allows 10,000 markers to be distributed over * a large area, and as long as only 100-200 are visible in any given viewport, * the user will see good performance corresponding to the 100 visible markers, * rather than poor performance corresponding to the total 10,000 markers. * Note that some code is optimized for speed over space, * with the goal of accommodating thousands of markers. */ /* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @name MarkerManagerOptions * @class This class represents optional arguments to the {@link MarkerManager} * constructor. * @property {Number} [maxZoom] Sets the maximum zoom level monitored by a * marker manager. If not given, the manager assumes the maximum map zoom * level. This value is also used when markers are added to the manager * without the optional {@link maxZoom} parameter. * @property {Number} [borderPadding] Specifies, in pixels, the extra padding * outside the map's current viewport monitored by a manager. Markers that * fall within this padding are added to the map, even if they are not fully * visible. * @property {Boolean} [trackMarkers=false] Indicates whether or not a marker * manager should track markers' movements. If you wish to move managed * markers using the {@link setPoint}/{@link setLatLng} methods, * this option should be set to {@link true}. */ /** * Creates a new MarkerManager that will show/hide markers on a map. * * @constructor * @param {Map} map The map to manage. * @param {Object} opt_opts A container for optional arguments: * {Number} maxZoom The maximum zoom level for which to create tiles. * {Number} borderPadding The width in pixels beyond the map border, * where markers should be display. * {Boolean} trackMarkers Whether or not this manager should track marker * movements. */ function MarkerManager(map, opt_opts) { var me = this; me.map_ = map; me.mapZoom_ = map.getZoom(); me.projection_ = map.getCurrentMapType().getProjection(); opt_opts = opt_opts || {}; me.tileSize_ = MarkerManager.DEFAULT_TILE_SIZE_; var mapTypes = map.getMapTypes(); var mapMaxZoom = mapTypes[0].getMaximumResolution(); for (var i = 0; i < mapTypes.length; i++) { var mapTypeMaxZoom = mapTypes[i].getMaximumResolution(); if (mapTypeMaxZoom > mapMaxZoom) { mapMaxZoom = mapTypeMaxZoom; } } me.maxZoom_ = opt_opts.maxZoom || mapMaxZoom; me.trackMarkers_ = opt_opts.trackMarkers; me.show_ = opt_opts.show || true; var padding; if (typeof opt_opts.borderPadding === "number") { padding = opt_opts.borderPadding; } else { padding = MarkerManager.DEFAULT_BORDER_PADDING_; } // The padding in pixels beyond the viewport, where we will pre-load markers. me.swPadding_ = new GSize(-padding, padding); me.nePadding_ = new GSize(padding, -padding); me.borderPadding_ = padding; me.gridWidth_ = []; me.grid_ = []; me.grid_[me.maxZoom_] = []; me.numMarkers_ = []; me.numMarkers_[me.maxZoom_] = 0; GEvent.bind(map, "moveend", me, me.onMapMoveEnd_); // NOTE: These two closures provide easy access to the map. // They are used as callbacks, not as methods. me.removeOverlay_ = function (marker) { map.removeOverlay(marker); me.shownMarkers_--; }; me.addOverlay_ = function (marker) { if (me.show_) { map.addOverlay(marker); me.shownMarkers_++; } }; me.resetManager_(); me.shownMarkers_ = 0; me.shownBounds_ = me.getMapGridBounds_(); } // Static constants: MarkerManager.DEFAULT_TILE_SIZE_ = 1024; MarkerManager.DEFAULT_BORDER_PADDING_ = 100; MarkerManager.MERCATOR_ZOOM_LEVEL_ZERO_RANGE = 256; /** * Initializes MarkerManager arrays for all zoom levels * Called by constructor and by clearAllMarkers */ MarkerManager.prototype.resetManager_ = function () { var me = this; var mapWidth = MarkerManager.MERCATOR_ZOOM_LEVEL_ZERO_RANGE; for (var zoom = 0; zoom <= me.maxZoom_; ++zoom) { me.grid_[zoom] = []; me.numMarkers_[zoom] = 0; me.gridWidth_[zoom] = Math.ceil(mapWidth / me.tileSize_); mapWidth *=2; } }; /** * Removes all markers in the manager, and * removes any visible markers from the map. */ MarkerManager.prototype.clearMarkers = function () { var me = this; me.processAll_(me.shownBounds_, me.removeOverlay_); me.resetManager_(); }; /** * Gets the tile coordinate for a given latlng point. * * @param {LatLng} latlng The geographical point. * @param {Number} zoom The zoom level. * @param {GSize} padding The padding used to shift the pixel coordinate. * Used for expanding a bounds to include an extra padding * of pixels surrounding the bounds. * @return {GPoint} The point in tile coordinates. * */ MarkerManager.prototype.getTilePoint_ = function (latlng, zoom, padding) { var pixelPoint = this.projection_.fromLatLngToPixel(latlng, zoom); return new GPoint( Math.floor((pixelPoint.x + padding.width) / this.tileSize_), Math.floor((pixelPoint.y + padding.height) / this.tileSize_)); }; /** * Finds the appropriate place to add the marker to the grid. * Optimized for speed; does not actually add the marker to the map. * Designed for batch-processing thousands of markers. * * @param {Marker} marker The marker to add. * @param {Number} minZoom The minimum zoom for displaying the marker. * @param {Number} maxZoom The maximum zoom for displaying the marker. */ MarkerManager.prototype.addMarkerBatch_ = function (marker, minZoom, maxZoom) { var mPoint = marker.getPoint(); marker.MarkerManager_minZoom = minZoom; // Tracking markers is expensive, so we do this only if the // user explicitly requested it when creating marker manager. if (this.trackMarkers_) { GEvent.bind(marker, "changed", this, this.onMarkerMoved_); } var gridPoint = this.getTilePoint_(mPoint, maxZoom, GSize.ZERO); for (var zoom = maxZoom; zoom >= minZoom; zoom--) { var cell = this.getGridCellCreate_(gridPoint.x, gridPoint.y, zoom); cell.push(marker); gridPoint.x = gridPoint.x >> 1; gridPoint.y = gridPoint.y >> 1; } }; /** * Returns whether or not the given point is visible in the shown bounds. This * is a helper method that takes care of the corner case, when shownBounds have * negative minX value. * * @param {Point} point a point on a grid. * @return {Boolean} Whether or not the given point is visible in the currently * shown bounds. */ MarkerManager.prototype.isGridPointVisible_ = function (point) { var me = this; var vertical = me.shownBounds_.minY <= point.y && point.y <= me.shownBounds_.maxY; var minX = me.shownBounds_.minX; var horizontal = minX <= point.x && point.x <= me.shownBounds_.maxX; if (!horizontal && minX < 0) { // Shifts the negative part of the rectangle. As point.x is always less // than grid width, only test shifted minX .. 0 part of the shown bounds. var width = me.gridWidth_[me.shownBounds_.z]; horizontal = minX + width <= point.x && point.x <= width - 1; } return vertical && horizontal; }; /** * Reacts to a notification from a marker that it has moved to a new location. * It scans the grid all all zoom levels and moves the marker from the old grid * location to a new grid location. * * @param {Marker} marker The marker that moved. * @param {LatLng} oldPoint The old position of the marker. * @param {LatLng} newPoint The new position of the marker. */ MarkerManager.prototype.onMarkerMoved_ = function (marker, oldPoint, newPoint) { // NOTE: We do not know the minimum or maximum zoom the marker was // added at, so we start at the absolute maximum. Whenever we successfully // remove a marker at a given zoom, we add it at the new grid coordinates. var me = this; var zoom = me.maxZoom_; var changed = false; var oldGrid = me.getTilePoint_(oldPoint, zoom, GSize.ZERO); var newGrid = me.getTilePoint_(newPoint, zoom, GSize.ZERO); while (zoom >= 0 && (oldGrid.x !== newGrid.x || oldGrid.y !== newGrid.y)) { var cell = me.getGridCellNoCreate_(oldGrid.x, oldGrid.y, zoom); if (cell) { if (me.removeFromArray_(cell, marker)) { me.getGridCellCreate_(newGrid.x, newGrid.y, zoom).push(marker); } } // For the current zoom we also need to update the map. Markers that no // longer are visible are removed from the map. Markers that moved into // the shown bounds are added to the map. This also lets us keep the count // of visible markers up to date. if (zoom === me.mapZoom_) { if (me.isGridPointVisible_(oldGrid)) { if (!me.isGridPointVisible_(newGrid)) { me.removeOverlay_(marker); changed = true; } } else { if (me.isGridPointVisible_(newGrid)) { me.addOverlay_(marker); changed = true; } } } oldGrid.x = oldGrid.x >> 1; oldGrid.y = oldGrid.y >> 1; newGrid.x = newGrid.x >> 1; newGrid.y = newGrid.y >> 1; --zoom; } if (changed) { me.notifyListeners_(); } }; /** * Removes marker from the manager and from the map * (if it's currently visible). * @param {GMarker} marker The marker to delete. */ MarkerManager.prototype.removeMarker = function (marker) { var me = this; var zoom = me.maxZoom_; var changed = false; var point = marker.getPoint(); var grid = me.getTilePoint_(point, zoom, GSize.ZERO); while (zoom >= 0) { var cell = me.getGridCellNoCreate_(grid.x, grid.y, zoom); if (cell) { me.removeFromArray_(cell, marker); } // For the current zoom we also need to update the map. Markers that no // longer are visible are removed from the map. This also lets us keep the count // of visible markers up to date. if (zoom === me.mapZoom_) { if (me.isGridPointVisible_(grid)) { me.removeOverlay_(marker); changed = true; } } grid.x = grid.x >> 1; grid.y = grid.y >> 1; --zoom; } if (changed) { me.notifyListeners_(); } me.numMarkers_[marker.MarkerManager_minZoom]--; }; /** * Add many markers at once. * Does not actually update the map, just the internal grid. * * @param {Array of Marker} markers The markers to add. * @param {Number} minZoom The minimum zoom level to display the markers. * @param {Number} opt_maxZoom The maximum zoom level to display the markers. */ MarkerManager.prototype.addMarkers = function (markers, minZoom, opt_maxZoom) { var maxZoom = this.getOptMaxZoom_(opt_maxZoom); for (var i = markers.length - 1; i >= 0; i--) { this.addMarkerBatch_(markers[i], minZoom, maxZoom); } this.numMarkers_[minZoom] += markers.length; }; /** * Returns the value of the optional maximum zoom. This method is defined so * that we have just one place where optional maximum zoom is calculated. * * @param {Number} opt_maxZoom The optinal maximum zoom. * @return The maximum zoom. */ MarkerManager.prototype.getOptMaxZoom_ = function (opt_maxZoom) { return opt_maxZoom || this.maxZoom_; }; /** * Calculates the total number of markers potentially visible at a given * zoom level. * * @param {Number} zoom The zoom level to check. */ MarkerManager.prototype.getMarkerCount = function (zoom) { var total = 0; for (var z = 0; z <= zoom; z++) { total += this.numMarkers_[z]; } return total; }; /** * Returns a marker given latitude, longitude and zoom. If the marker does not * exist, the method will return a new marker. If a new marker is created, * it will NOT be added to the manager. * * @param {Number} lat - the latitude of a marker. * @param {Number} lng - the longitude of a marker. * @param {Number} zoom - the zoom level * @return {GMarker} marker - the marker found at lat and lng */ MarkerManager.prototype.getMarker = function(lat, lng, zoom) { var me = this; var mPoint = new GLatLng(lat, lng); var gridPoint = me.getTilePoint_(mPoint, zoom, GSize.ZERO); var marker = new GMarker(mPoint); var cellArray = me.getGridCellNoCreate_(gridPoint.x, gridPoint.y, zoom); if(cellArray != undefined){ for (var i = 0; i < cellArray.length; i++) { if(lat == cellArray[i].getLatLng().lat() && lng == cellArray[i].getLatLng().lng()) { marker = cellArray[i]; } } } return marker; }; /** * Add a single marker to the map. * * @param {Marker} marker The marker to add. * @param {Number} minZoom The minimum zoom level to display the marker. * @param {Number} opt_maxZoom The maximum zoom level to display the marker. */ MarkerManager.prototype.addMarker = function (marker, minZoom, opt_maxZoom) { var me = this; var maxZoom = this.getOptMaxZoom_(opt_maxZoom); me.addMarkerBatch_(marker, minZoom, maxZoom); var gridPoint = me.getTilePoint_(marker.getPoint(), me.mapZoom_, GSize.ZERO); if (me.isGridPointVisible_(gridPoint) && minZoom <= me.shownBounds_.z && me.shownBounds_.z <= maxZoom) { me.addOverlay_(marker); me.notifyListeners_(); } this.numMarkers_[minZoom]++; }; /** * Returns true if this bounds (inclusively) contains the given point. * @param {Point} point The point to test. * @return {Boolean} This Bounds contains the given Point. */ GBounds.prototype.containsPoint = function (point) { var outer = this; return (outer.minX <= point.x && outer.maxX >= point.x && outer.minY <= point.y && outer.maxY >= point.y); }; /** * Get a cell in the grid, creating it first if necessary. * * Optimization candidate * * @param {Number} x The x coordinate of the cell. * @param {Number} y The y coordinate of the cell. * @param {Number} z The z coordinate of the cell. * @return {Array} The cell in the array. */ MarkerManager.prototype.getGridCellCreate_ = function (x, y, z) { var grid = this.grid_[z]; if (x < 0) { x += this.gridWidth_[z]; } var gridCol = grid[x]; if (!gridCol) { gridCol = grid[x] = []; return (gridCol[y] = []); } var gridCell = gridCol[y]; if (!gridCell) { return (gridCol[y] = []); } return gridCell; }; /** * Get a cell in the grid, returning undefined if it does not exist. * * NOTE: Optimized for speed -- otherwise could combine with getGridCellCreate_. * * @param {Number} x The x coordinate of the cell. * @param {Number} y The y coordinate of the cell. * @param {Number} z The z coordinate of the cell. * @return {Array} The cell in the array. */ MarkerManager.prototype.getGridCellNoCreate_ = function (x, y, z) { var grid = this.grid_[z]; if (x < 0) { x += this.gridWidth_[z]; } var gridCol = grid[x]; return gridCol ? gridCol[y] : undefined; }; /** * Turns at geographical bounds into a grid-space bounds. * * @param {LatLngBounds} bounds The geographical bounds. * @param {Number} zoom The zoom level of the bounds. * @param {GSize} swPadding The padding in pixels to extend beyond the * given bounds. * @param {GSize} nePadding The padding in pixels to extend beyond the * given bounds. * @return {GBounds} The bounds in grid space. */ MarkerManager.prototype.getGridBounds_ = function (bounds, zoom, swPadding, nePadding) { zoom = Math.min(zoom, this.maxZoom_); var bl = bounds.getSouthWest(); var tr = bounds.getNorthEast(); var sw = this.getTilePoint_(bl, zoom, swPadding); var ne = this.getTilePoint_(tr, zoom, nePadding); var gw = this.gridWidth_[zoom]; // Crossing the prime meridian requires correction of bounds. if (tr.lng() < bl.lng() || ne.x < sw.x) { sw.x -= gw; } if (ne.x - sw.x + 1 >= gw) { // Computed grid bounds are larger than the world; truncate. sw.x = 0; ne.x = gw - 1; } var gridBounds = new GBounds([sw, ne]); gridBounds.z = zoom; return gridBounds; }; /** * Gets the grid-space bounds for the current map viewport. * * @return {Bounds} The bounds in grid space. */ MarkerManager.prototype.getMapGridBounds_ = function () { var me = this; return me.getGridBounds_(me.map_.getBounds(), me.mapZoom_, me.swPadding_, me.nePadding_); }; /** * Event listener for map:movend. * NOTE: Use a timeout so that the user is not blocked * from moving the map. * */ MarkerManager.prototype.onMapMoveEnd_ = function () { var me = this; me.objectSetTimeout_(this, this.updateMarkers_, 0); }; /** * Call a function or evaluate an expression after a specified number of * milliseconds. * * Equivalent to the standard window.setTimeout function, but the given * function executes as a method of this instance. So the function passed to * objectSetTimeout can contain references to this. * objectSetTimeout(this, function () { alert(this.x) }, 1000); * * @param {Object} object The target object. * @param {Function} command The command to run. * @param {Number} milliseconds The delay. * @return {Boolean} Success. */ MarkerManager.prototype.objectSetTimeout_ = function (object, command, milliseconds) { return window.setTimeout(function () { command.call(object); }, milliseconds); }; /** * Is this layer visible? * * Returns visibility setting * * @return {Boolean} Visible */ MarkerManager.prototype.visible = function () { return this.show_ ? true : false; }; /** * Returns true if the manager is hidden. * Otherwise returns false. * @return {Boolean} Hidden */ MarkerManager.prototype.isHidden = function () { return !this.show_; }; /** * Shows the manager if it's currently hidden. */ MarkerManager.prototype.show = function () { this.show_ = true; this.refresh(); }; /** * Hides the manager if it's currently visible */ MarkerManager.prototype.hide = function () { this.show_ = false; this.refresh(); }; /** * Toggles the visibility of the manager. */ MarkerManager.prototype.toggle = function () { this.show_ = !this.show_; this.refresh(); }; /** * Refresh forces the marker-manager into a good state. *
    *
  1. If never before initialized, shows all the markers.
    2. *
  2. If previously initialized, removes and re-adds all markers.
    3. *
*/ MarkerManager.prototype.refresh = function () { var me = this; if (me.shownMarkers_ > 0) { me.processAll_(me.shownBounds_, me.removeOverlay_); } // An extra check on me.show_ to increase performance (no need to processAll_) if (me.show_) { me.processAll_(me.shownBounds_, me.addOverlay_); } me.notifyListeners_(); }; /** * After the viewport may have changed, add or remove markers as needed. */ MarkerManager.prototype.updateMarkers_ = function () { var me = this; me.mapZoom_ = this.map_.getZoom(); var newBounds = me.getMapGridBounds_(); // If the move does not include new grid sections, // we have no work to do: if (newBounds.equals(me.shownBounds_) && newBounds.z === me.shownBounds_.z) { return; } if (newBounds.z !== me.shownBounds_.z) { me.processAll_(me.shownBounds_, me.removeOverlay_); if (me.show_) { // performance me.processAll_(newBounds, me.addOverlay_); } } else { // Remove markers: me.rectangleDiff_(me.shownBounds_, newBounds, me.removeCellMarkers_); // Add markers: if (me.show_) { // performance me.rectangleDiff_(newBounds, me.shownBounds_, me.addCellMarkers_); } } me.shownBounds_ = newBounds; me.notifyListeners_(); }; /** * Notify listeners when the state of what is displayed changes. */ MarkerManager.prototype.notifyListeners_ = function () { GEvent.trigger(this, "changed", this.shownBounds_, this.shownMarkers_); }; /** * Process all markers in the bounds provided, using a callback. * * @param {Bounds} bounds The bounds in grid space. * @param {Function} callback The function to call for each marker. */ MarkerManager.prototype.processAll_ = function (bounds, callback) { for (var x = bounds.minX; x <= bounds.maxX; x++) { for (var y = bounds.minY; y <= bounds.maxY; y++) { this.processCellMarkers_(x, y, bounds.z, callback); } } }; /** * Process all markers in the grid cell, using a callback. * * @param {Number} x The x coordinate of the cell. * @param {Number} y The y coordinate of the cell. * @param {Number} z The z coordinate of the cell. * @param {Function} callback The function to call for each marker. */ MarkerManager.prototype.processCellMarkers_ = function (x, y, z, callback) { var cell = this.getGridCellNoCreate_(x, y, z); if (cell) { for (var i = cell.length - 1; i >= 0; i--) { callback(cell[i]); } } }; /** * Remove all markers in a grid cell. * * @param {Number} x The x coordinate of the cell. * @param {Number} y The y coordinate of the cell. * @param {Number} z The z coordinate of the cell. */ MarkerManager.prototype.removeCellMarkers_ = function (x, y, z) { this.processCellMarkers_(x, y, z, this.removeOverlay_); }; /** * Add all markers in a grid cell. * * @param {Number} x The x coordinate of the cell. * @param {Number} y The y coordinate of the cell. * @param {Number} z The z coordinate of the cell. */ MarkerManager.prototype.addCellMarkers_ = function (x, y, z) { this.processCellMarkers_(x, y, z, this.addOverlay_); }; /** * Use the rectangleDiffCoords_ function to process all grid cells * that are in bounds1 but not bounds2, using a callback, and using * the current MarkerManager object as the instance. * * Pass the z parameter to the callback in addition to x and y. * * @param {Bounds} bounds1 The bounds of all points we may process. * @param {Bounds} bounds2 The bounds of points to exclude. * @param {Function} callback The callback function to call * for each grid coordinate (x, y, z). */ MarkerManager.prototype.rectangleDiff_ = function (bounds1, bounds2, callback) { var me = this; me.rectangleDiffCoords_(bounds1, bounds2, function (x, y) { callback.apply(me, [x, y, bounds1.z]); }); }; /** * Calls the function for all points in bounds1, not in bounds2 * * @param {Bounds} bounds1 The bounds of all points we may process. * @param {Bounds} bounds2 The bounds of points to exclude. * @param {Function} callback The callback function to call * for each grid coordinate. */ MarkerManager.prototype.rectangleDiffCoords_ = function (bounds1, bounds2, callback) { var minX1 = bounds1.minX; var minY1 = bounds1.minY; var maxX1 = bounds1.maxX; var maxY1 = bounds1.maxY; var minX2 = bounds2.minX; var minY2 = bounds2.minY; var maxX2 = bounds2.maxX; var maxY2 = bounds2.maxY; var x, y; for (x = minX1; x <= maxX1; x++) { // All x in R1 // All above: for (y = minY1; y <= maxY1 && y < minY2; y++) { // y in R1 above R2 callback(x, y); } // All below: for (y = Math.max(maxY2 + 1, minY1); // y in R1 below R2 y <= maxY1; y++) { callback(x, y); } } for (y = Math.max(minY1, minY2); y <= Math.min(maxY1, maxY2); y++) { // All y in R2 and in R1 // Strictly left: for (x = Math.min(maxX1 + 1, minX2) - 1; x >= minX1; x--) { // x in R1 left of R2 callback(x, y); } // Strictly right: for (x = Math.max(minX1, maxX2 + 1); // x in R1 right of R2 x <= maxX1; x++) { callback(x, y); } } }; /** * Removes value from array. O(N). * * @param {Array} array The array to modify. * @param {any} value The value to remove. * @param {Boolean} opt_notype Flag to disable type checking in equality. * @return {Number} The number of instances of value that were removed. */ MarkerManager.prototype.removeFromArray_ = function (array, value, opt_notype) { var shift = 0; for (var i = 0; i < array.length; ++i) { if (array[i] === value || (opt_notype && array[i] === value)) { array.splice(i--, 1); shift++; } } return shift; }; // cache created 2010-09-03 16:40:02 UTC