';
var n = 0;
for ( var i = 0; i < cluster.markers.length; ++i )
{
var marker = cluster.markers[i];
if ( marker != null )
{
++n;
html += '
';
if ( marker.getIcon().smallImage != null )
html += '';
else
html += '';
html += '
' + marker.title + '
';
if ( n == clusterer.maxLinesPerInfoBox - 1 && cluster.markerCount > clusterer.maxLinesPerInfoBox )
{
html += '
...and ' + ( cluster.markerCount - n ) + ' more
';
break;
}
}
}
html += '
';
clusterer.map.closeInfoWindow();
cluster.marker.openInfoWindowHtml( html );
clusterer.poppedUpCluster = cluster;
};
**********************/
// modifiée 25/06/2007 15:13:09
// zoom sur les hotels contenu dans le cluster
Clusterer.PopUp = function ( cluster )
{
var bm = new GLatLngBounds() ;
for ( var i = 0; i < cluster.markers.length; ++i )
{
var marker = cluster.markers[i];
bm.extend( marker.getPoint() );
}
clusterer.map.setZoom( clusterer.map.getBoundsZoomLevel( bm ));
clusterer.map.setCenter(bm.getCenter());
}
Clusterer.RePop = function ( clusterer )
{
if ( clusterer.poppedUpCluster != null )
Clusterer.PopUp( clusterer.poppedUpCluster );
};
Clusterer.PopDown = function ( clusterer )
{
clusterer.poppedUpCluster = null;
};
Clusterer.prototype.ClearCluster = function ( cluster )
{
var i, marker;
for ( i = 0; i < cluster.markers.length; ++i )
if ( cluster.markers[i] != null )
{
cluster.markers[i].inCluster = false;
cluster.markers[i] = null;
}
cluster.markers.length = 0;
cluster.markerCount = 0;
if ( cluster == this.poppedUpCluster )
this.map.closeInfoWindow();
if ( cluster.onMap )
{
this.map.removeOverlay( cluster.marker );
cluster.onMap = false;
}
};
// This returns a function closure that calls the given routine with the
// specified arg.
Clusterer.MakeCaller = function ( func, arg )
{
return function () { func( arg ); };
};
Clusterer.prototype.DisplayLater = function ()
{
if ( this.timeout != null )
clearTimeout( this.timeout );
this.timeout = setTimeout( Clusterer.MakeCaller( Clusterer.Display, this ), 50 );
};
Clusterer.Display = function ( clusterer )
{
if( clusterer.killDisplayStat == true ){ // on stoppe l'execution de clustering
clusterer.killDisplayStat = false ;
return ;
}
var i, j, marker, cluster;
clearTimeout( clusterer.timeout );
var newZoomLevel = clusterer.map.getZoom();
if ( newZoomLevel != clusterer.currentZoomLevel )
{
// When the zoom level changes, we have to remove all the clusters.
for ( i = 0; i < clusterer.clusters.length; ++i )
if ( clusterer.clusters[i] != null )
{
clusterer.ClearCluster( clusterer.clusters[i] );
clusterer.clusters[i] = null;
}
clusterer.clusters.length = 0;
clusterer.currentZoomLevel = newZoomLevel;
}
// Get the current bounds of the visible area.
var bounds = clusterer.map.getBounds();
// Expand the bounds a little, so things look smoother when scrolling
// by small amounts.
var sw = bounds.getSouthWest();
var ne = bounds.getNorthEast();
var dx = ne.lng() - sw.lng();
var dy = ne.lat() - sw.lat();
if ( dx < 300 && dy < 150 )
{
dx *= 0.10;
dy *= 0.10;
bounds = new GLatLngBounds(
new GLatLng( sw.lat() - dy, sw.lng() - dx ),
new GLatLng( ne.lat() + dy, ne.lng() + dx ) );
}
// Partition the markers into visible and non-visible lists.
var visibleMarkers = [];
var nonvisibleMarkers = [];
for ( i = 0; i < clusterer.markers.length; ++i )
{
marker = clusterer.markers[i];
if ( marker != null )
if ( bounds.contains( marker.getPoint() ) )
visibleMarkers.push( marker );
else
nonvisibleMarkers.push( marker );
}
// Take down the non-visible markers.
for ( i = 0; i < nonvisibleMarkers.length; ++i )
{
marker = nonvisibleMarkers[i];
if ( marker.onMap )
{
clusterer.map.removeOverlay( marker );
marker.onMap = false;
}
}
// Take down the non-visible clusters.
for ( i = 0; i < clusterer.clusters.length; ++i )
{
cluster = clusterer.clusters[i];
if ( cluster != null && ! bounds.contains( cluster.marker.getPoint() ) && cluster.onMap )
{
clusterer.map.removeOverlay( cluster.marker );
cluster.onMap = false;
}
}
// Clustering! This is some complicated stuff. We have three goals
// here. One, limit the number of markers & clusters displayed, so the
// maps code doesn't slow to a crawl. Two, when possible keep existing
// clusters instead of replacing them with new ones, so that the app pans
// better. And three, of course, be CPU and memory efficient.
if ( visibleMarkers.length > clusterer.maxVisibleMarkers )
{
// Add to the list of clusters by splitting up the current bounds
// into a grid.
var latRange = bounds.getNorthEast().lat() - bounds.getSouthWest().lat();
var latInc = latRange / clusterer.gridSize;
var lngInc = latInc / Math.cos( ( bounds.getNorthEast().lat() + bounds.getSouthWest().lat() ) / 2.0 * Math.PI / 180.0 );
for ( var lat = bounds.getSouthWest().lat(); lat <= bounds.getNorthEast().lat(); lat += latInc )
for ( var lng = bounds.getSouthWest().lng(); lng <= bounds.getNorthEast().lng(); lng += lngInc )
{
cluster = new Object();
cluster.clusterer = clusterer;
cluster.bounds = new GLatLngBounds( new GLatLng( lat, lng ), new GLatLng( lat + latInc, lng + lngInc ) );
cluster.markers = [];
cluster.markerCount = 0;
cluster.onMap = false;
cluster.marker = null;
clusterer.clusters.push( cluster );
}
// Put all the unclustered visible markers into a cluster - the first
// one it fits in, which favors pre-existing clusters.
for ( i = 0; i < visibleMarkers.length; ++i )
{
marker = visibleMarkers[i];
if ( marker != null && ! marker.inCluster )
{
for ( j = 0; j < clusterer.clusters.length; ++j )
{
cluster = clusterer.clusters[j];
if ( cluster != null && cluster.bounds.contains( marker.getPoint() ) )
{
cluster.markers.push( marker );
++cluster.markerCount;
marker.inCluster = true;
}
}
}
}
// Get rid of any clusters containing only a few markers.
for ( i = 0; i < clusterer.clusters.length; ++i )
if ( clusterer.clusters[i] != null && clusterer.clusters[i].markerCount < clusterer.minMarkersPerCluster )
{
clusterer.ClearCluster( clusterer.clusters[i] );
clusterer.clusters[i] = null;
}
// Shrink the clusters list.
for ( i = clusterer.clusters.length - 1; i >= 0; --i )
if ( clusterer.clusters[i] != null )
break;
else
--clusterer.clusters.length;
// Ok, we have our clusters. Go through the markers in each
// cluster and remove them from the map if they are currently up.
for ( i = 0; i < clusterer.clusters.length; ++i )
{
cluster = clusterer.clusters[i];
if ( cluster != null )
{
for ( j = 0; j < cluster.markers.length; ++j )
{
marker = cluster.markers[j];
if ( marker != null && marker.onMap )
{
clusterer.map.removeOverlay( marker );
marker.onMap = false;
}
}
}
}
// Now make cluster-markers for any clusters that need one.
for ( i = 0; i < clusterer.clusters.length; ++i )
{
cluster = clusterer.clusters[i];
if ( cluster != null && cluster.marker == null )
{
// Figure out the average coordinates of the markers in this
// cluster.
var xTotal = 0.0, yTotal = 0.0;
for ( j = 0; j < cluster.markers.length; ++j )
{
marker = cluster.markers[j];
if ( marker != null )
{
xTotal += ( + marker.getPoint().lng() );
yTotal += ( + marker.getPoint().lat() );
}
}
var location = new GLatLng( yTotal / cluster.markerCount, xTotal / cluster.markerCount );
marker = new GMarker( location, { icon: clusterer.icon } );
cluster.marker = marker;
GEvent.addListener( marker, 'click', Clusterer.MakeCaller( Clusterer.PopUp, cluster ) );
}
}
}
// Display the visible markers not already up and not in clusters.
for ( i = 0; i < visibleMarkers.length; ++i )
{
marker = visibleMarkers[i];
if ( marker != null && ! marker.onMap && ! marker.inCluster )
{
clusterer.map.addOverlay( marker );
if ( marker.addedToMap != null )
marker.addedToMap();
marker.onMap = true;
}
}
//************* ici
if (clusterer.Infodiv != null );
{
var DisplayHotels = new Array();
for ( i = 0; i < visibleMarkers.length; ++i )
{
marker = visibleMarkers[i];
if(marker.onMap && ! marker.inCluster)
{
DisplayHotels[DisplayHotels.length] = marker.id ;
}
}
new Ajax.Updater( clusterer.Infodiv , clusterer.infoPageData , { evalScripts:'true', method : 'post', parameters: { 'Hotels[]' : DisplayHotels }} );
}
// Display the visible clusters not already up.
for ( i = 0; i < clusterer.clusters.length; ++i )
{
cluster = clusterer.clusters[i];
if ( cluster != null && ! cluster.onMap && bounds.contains( cluster.marker.getPoint() ) )
{
clusterer.map.addOverlay( cluster.marker );
cluster.onMap = true;
}
}
// In case a cluster is currently popped-up, re-pop to get any new
// markers into the infobox.
Clusterer.RePop( clusterer );
};
// Augment GMarker so it handles markers that have been created but
// not yet addOverlayed.
GMarker.prototype.setMap = function ( map )
{
this.map = map;
};
GMarker.prototype.addedToMap = function ()
{
this.map = null;
};
GMarker.prototype.origOpenInfoWindow = GMarker.prototype.openInfoWindow;
GMarker.prototype.openInfoWindow = function ( node, opts )
{
if ( this.map != null )
return this.map.openInfoWindow( this.getPoint(), node, opts );
else
return this.origOpenInfoWindow( node, opts );
};
GMarker.prototype.origOpenInfoWindowHtml = GMarker.prototype.openInfoWindowHtml;
GMarker.prototype.openInfoWindowHtml = function ( html, opts )
{
if ( this.map != null )
return this.map.openInfoWindowHtml( this.getPoint(), html, opts );
else
return this.origOpenInfoWindowHtml( html, opts );
};
GMarker.prototype.origOpenInfoWindowTabs = GMarker.prototype.openInfoWindowTabs;
GMarker.prototype.openInfoWindowTabs = function ( tabNodes, opts )
{
if ( this.map != null )
return this.map.openInfoWindowTabs( this.getPoint(), tabNodes, opts );
else
return this.origOpenInfoWindowTabs( tabNodes, opts );
};
GMarker.prototype.origOpenInfoWindowTabsHtml = GMarker.prototype.openInfoWindowTabsHtml;
GMarker.prototype.openInfoWindowTabsHtml = function ( tabHtmls, opts )
{
if ( this.map != null )
return this.map.openInfoWindowTabsHtml( this.getPoint(), tabHtmls, opts );
else
return this.origOpenInfoWindowTabsHtml( tabHtmls, opts );
};
GMarker.prototype.origShowMapBlowup = GMarker.prototype.showMapBlowup;
GMarker.prototype.showMapBlowup = function ( opts )
{
if ( this.map != null )
return this.map.showMapBlowup( this.getPoint(), opts );
else
return this.origShowMapBlowup( opts );
};