RubyGems - ym4r-mapstraction - Versions diffs - 0.0.1 - Mend

ym4r-mapstraction 0.0.1

Files changed (25) hide show

data/.DS_Store +0 -0
data/.gitignore +2 -0
data/LICENSE +20 -0
data/README.rdoc +158 -0
data/Rakefile +52 -0
data/VERSION +1 -0
data/javascript/clusterer.js +410 -0
data/javascript/mapquest-js/mqcommon.js +1740 -0
data/javascript/mapquest-js/mqexec.js +977 -0
data/javascript/mapquest-js/mqobjects.js +10733 -0
data/javascript/mapquest-js/mqutils.js +1001 -0
data/javascript/mapstraction-geocode.js +179 -0
data/javascript/mapstraction-route.js +200 -0
data/javascript/mapstraction.js +3570 -0
data/javascript/ym4r-mapstraction.js +105 -0
data/lib/mapstraction_plugin/helper.rb +14 -0
data/lib/mapstraction_plugin/mapping.rb +120 -0
data/lib/mapstraction_plugin/mapstraction.rb +309 -0
data/lib/mapstraction_plugin/overlay.rb +105 -0
data/lib/mapstraction_plugin/routing.rb +56 -0
data/lib/ym4r_mapstraction.rb +43 -0
data/tasks/ym4r_mapstraction_tasks.rake +4 -0
data/test/ym4r_mapstraction_test.rb +8 -0
data/ym4r-mapstraction.gemspec +69 -0
metadata +84 -0

data/.DS_Store ADDED Viewed

Binary file

data/.gitignore ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ *.sample
2	+ pkg

data/LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Luke van der Hoeven
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc ADDED Viewed

@@ -0,0 +1,158 @@
+=YM4R/Mapstraction plugin for Rails
+This is the YM4R/Mapstraction plugin for Rails. It is aimed at facilitating the use of the Mapstraction library from Rails application.
+==Getting Started
+I present here the most common operations you would want to do with YM4R/Mapstraction. Read the rest of the documents if you want more details.
+If you are using the GoogleMaps, Map24, MapQuest, or MultiMap APIs, you will need to create a file housing the API keys as follows:
+===GoogleMaps
+For development and test, we have only one possible host (localhost:3000), so there is only a single key associated with the mode.
+In production, the app can be accessed through 2 different hosts: test.com and exmaple.com. There then needs a 2-key hash. If you deployed to one host, only the API key would be needed (as in development and test).
+	development:
+	 ABQIAAAAzMUFFnT9uH0xq39J0Y4kbhTJQa0g3IQ9GZqIMmInSLzwtGDKaBR6j135zrztfTGVOm2QlWnkaidDIQ
+	test:
+	 ABQIAAAAzMUFFnT9uH0xq39J0Y4kbhTJQa0g3IQ9GZqIMmInSLzwtGDKaBR6j135zrztfTGVOm2QlWnkaidDIQ
+	production:
+	 test.com: ABQIAAAAzMUFFnT9uH0Sfg76Y4kbhTJQa0g3IQ9GZqIMmInSLzwtGDmlRT6e90j135zat56yhJKQlWnkaidDIQ
+	 example.com: ABQIAAAAzMUFFnT9uH0Sfg98Y4kbhGFJQa0g3IQ9GZqIMmInSLrthJKGDmlRT98f4j135zat56yjRKQlWnkmod3TB
+===24Maps, MapQuest, MultiMap
+For development and test, we have only one possible host (localhost:3000), so there is only a single key associated with the mode.
+In production, the app can be accessed through 2 different hosts: test.com and exmaple.com. There then needs a 2-key hash. If you deployed to one host, only the API key would be needed (as in development and test).
+	development:
+	 localhost: xxx
+	test:
+	 localhost: xxx
+	production:
+	 exmaple.org: xxx
+	 example.com: xxx
+==Examples
+In your controller, here is a typical initialization sequence in action +index+:
+	def index
+	  @map = Mapstraction.new("map_div",:yahoo)
+	  @map.control_init(:small => true)
+	  @map.center_zoom_init([75.5,-42.56],4)
+	  @map.marker_init(Marker.new([75.6,-42.467],:label => "Hello", :info_bubble => "Info! Info!",
+		:icon => "/images/icon02.png"))
+	end
+Here I create a Mapstraction map (which will be placed inside a DIV of id +map_div+) which will use Yahoo! Maps, add a small control (it is the only available control currently), set the center and the zoom and add a marker. The 3 possible options to pass to the +Marker+ constructor are all shown above. Of these 4 steps only the creation of the map and the setting of the center and the zoom are absolutely necessary. Apart from Yahoo! Maps, I could have created a map of type <tt>:google</tt> (Google Maps) or <tt>:microsoft</tt> (Virtual Earth).
+In your view, here is what you would have:
+	<html><head><title>Test</title>
+	<%= Mapstraction.header(:yahoo) %>
+	<%= @map.to_html %>
+	</head><body>
+	<%= @map.div(:width => 600, :height => 400) %>
+	</body></html>
+First you must output the header, used by all the maps of the page: It includes the Mapstraction JS code and the JS helper functions of YM4R/Mapstraction. It also includes the API files, as determined according to the parameter of the method. Usually, if you only have one map, there will be a single symbol, identical to the one used to create the map. But you can also pass an array of symbols, in which case all the corresponding API's will be included. Then we initialize the map by calling <tt>@map.to_html</tt>. In the body, we need a DIV whose +id+ is the same as the one passed to the Mapstraction constructor in the controller. The call to <tt>@map.div</tt> outputs such a DIV. We pass to it options to set the width and height of the map in the style attribute of the DIV.
+<b>Note that you need to set a size for the map DIV element at some point or the map will not be displayed.</b> You have a few ways to do this:
+- You define it yourself, wherever you want. Usually as part of the layout definition in an external CSS.
+- In the head of the document, through a CSS instruction output by <tt>@map.header_width_height</tt>, to which you pass 2 arguments (width and height).
+- When outputting the DIV with <tt>@map.div</tt>, you can also pass an option hash, with keys <tt>:width</tt> and <tt>:height</tt> and a style attribute for the DIV element will be output.
+You can update the map trough RJS. Here is an action you can call from a <tt>link_remote_tag</tt> which would do this:
+	def update
+	  @map = Variable.new("map")
+	  @marker = Marker.new([75.89,-42.767],:label => "Update", :info_bubble => "I have been placed through RJS")
+	end
+Here, I first bind the Ruby <tt>@map</tt> variable to the JS variable <tt>map</tt>, which already exists in the client browser. +map+ is by default the name given to a map created from YM4R/Mapstraction (this could be overriden by passing a second argument to the Mapstraction constructor). Then I create a marker.
+And you would have inside the RJS template for the action:
+	page << @map.remove_all_markers
+	page << @map.add_marker(@marker)
+Here I first clear the map of all markers. Then I add the marker. Note that the +marker_init+ is not used anymore since, as its name indicates, this method is only for the initialization of the map.
+==Installation
+gem install ym4r-mapstraction
+As part of the installation procedure, the JavaScript files found in the <tt>PLUGIN_ROOT/javascript</tt> directory will be copied to the <tt>RAILS_ROOT/public/javascripts/</tt> directory.
+Moreover a <tt>gmaps_api_key.yml</tt> file will also be created in the <tt>RAILS_ROOT/config/</tt> folder. This is in order to setup the Google Maps API in case you want to use it with Mapstraction. You don't need to do anything special if you use only Yahoo! Maps or Virtual Earth. If this file already exists (installed for example by a previous version of the plugin), nothing will be done to it, so you can keep your configuration data even after updating the plugin. This file is a YAML representation of a hash, similar to the <tt>database.yml</tt> file in that the primary keys in the file are the different environments (development, test, production), since you will probably need to have different Google Maps API keys depending on that criteria (for example: a key for localhost for development and test; a key for your host for production). If you don't have any special need, there will be only one key associated with each environment. If however, you need to have multiple keys (for example if your app will be accessible from multiple URLs, for which you need different keys), you can also associate a hash to the environment, whose keys will be the different hosts. In this case, you will need to pass a value to the <tt>:host</tt> key when calling the method <tt>Mapstraction.header</tt> (usually <tt>@request.host</tt>).
+==Operations
+===Static switching between mapping API's
+It is the goal of the Mapstraction API to make it trivial to switch API (for example, in case the currently used API changes its term of service). It is equally easy to do this with YM4R/Mapstraction. You need to do 2 things:
+- Change the provider when creating a Mapstraction map
+- Change the provider when calling the <tt>Mapstraction.header</tt>
+===Dynamic switching between mapping API's
+The Mapstraction API provides a method +swap+ to be called on a Mapstraction JS object, with the name of the new API as argument, that will switch the mapping API on the fly. The zoom levels and elements will be copied over to the new API.
+===Markers
+Markers are constructed with either a LatLonPoint or a 2D-array of coordinates in the first argument, followed by an option hash. The keys to the hash can be <tt>:info_bubble</tt> (text to display when the marker is clicked), <tt>:label</tt> (summary text of the marker; The way it is displayed depends on the mapping service used) or <tt>:icon</tt> (to indicate the URL of an icon to use for the marker). Support for icons is a bit flaky since the different services have different conventions for their origins, so you should probably have different sets of icons depending on the service to make it less confusing for the user.
+===MarkerGroup
+Surprisingly, MarkerGroups are groups of markers. They can be useful if you want to be able to show and hide a group of markers at the same time in response to a user-generated event (for example, as a response to a click on a link in the HTML page) without having to declare all the markers as global variables. Instead you declare only the group as global and give it the markers. Then you can call +show+ and +hide+ on the group, to act on all the markers of the group at the same time.
+===Polylines
+Polylines are constructed with an array of LatLonPoints, as well as with options like the opacity (<tt>:opacity</tt>), the width (<tt>:width</tt>) or the color (<tt>:color</tt> and with a value in the form "#RRGGBB", with RR, GG and BB numbers between 0 and 255 in hexadecimal form). You add the marker to the map at initialization time with the method +polyline_init+:
+	@map.polyline_init(Polyline.new([LatLonPoint.new([45.12,22.3]),
+	LatLonPoint.new([34.12,56.1])],:width => 5, :color => "#FF00AB",
+	:opacity => 0.7))
+===Clusterer
+A clusterer contains a large number of markers, which are dynamically grouped in clusters if needed. This allows to have a lot of markers on a map without being slowed down too much. It is an adaptation to Mapstraction of Jef Poskanzer's Clusterer2 library for Google Maps. It works for all 3 Mapstraction backends. To use it from your Rails code, do the following:
+	marker_array = [.....] #large number of markers
+	clusterer = Clusterer.new(marker_array,:max_visible_markers => 20)
+	@map.clusterer_init(clusterer)
+By default the markers start being clustered when there are more than 150 in the clusterer. Nothing special happens before this. This setting can be changed with the <tt>:max_visible_markers</tt> option. Other options are possible. Look inside the JS code inside the <tt>clusterer.js</tt> to know what they are.
+===Routing
+Currently supported only by Mapquest.
+Must be initialized at the same time as the map. In your controller, here is a typical initialization sequence in action +index+:
+	def index
+	  @router = Router.new(:display_route, 'mapquest', :error_route)
+	end
+The router is created with 3 possible options to pass to the +Router+ constructor and all are necessary. First one is the name of the callback function that will show the route on the map. You can change the name of the callback function but if you do not pass :no_callback option in +to_html+ the method will be implemented as shown in routing.rb. The same goes for :error_route callback (gets called if an error occures). If you leave them as they are in the example, all will work fine. The middle parameter is the name of the routing provider and for now it is allways 'mapquest'. Additionally, you can pass two more parameters, the variable name for the router (default = "router") and variable name for the map (default = "map").
+In your view, xou have to output the header after map header (@map.to_html):
+<%= @router.to_html %>
+For usage, you can choose weather you will use the routing option with geocoding, as in mapstraction examples or you can prepare point in some other fashion and just use the router to connect them. So, when you have the points, in your rjs you can do the following:
+page << @router.routePoints(@points)
+Be carefull here because routePoints is an additional mastraction library method that is not in the main trunk yet. But you can use +route+ too.
+==Recent changes
+- Support for latest Mapstraction version
+- Support for polylines
+- Some additional documentation
+==TODO
+- Update to newer versions of Mapstraction as they come along
+- More documentation
+==License
+The YM4R/Mapstraction plugin is released under the MIT license.
+==Support
+Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:hungerandthirst@gmail.com.
+== Note on Patches/Pull Requests
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+== Copyright
+Copyright (c) 2010 Luke van der Hoeven. See LICENSE for details.

data/Rakefile ADDED Viewed

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ym4r-mapstraction"
+    gem.summary = %Q{ym4r-mapstraction: Mapstraction library for ruby applications.}
+    gem.description = %Q{This is an updated/gemmed version of the ym4r-mapstraction plugin by nofxx}
+    gem.email = "hungerandthirst@gmail.com"
+    gem.homepage = "http://github.com/plukevdh/ym4r_mapstraction"
+    gem.authors = ["Luke van der Hoeven"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+task :test => :check_dependencies
+task :default => :test
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ym4r-mapstraction #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION ADDED Viewed

	@@ -0,0 +1 @@
1	+ 0.0.1

data/javascript/clusterer.js ADDED Viewed

@@ -0,0 +1,410 @@
+// Clusterer for Mapstraction: To display a large number of markers
+//
+// Usage:
+//
+// When you have a Mapstraction object (for example, of name mapstraction), do:
+//
+// var clusterer = new Clusterer(mapstraction);
+//
+// Then you must add markers to the clusterer.
+//
+// clusterer.addMarker(marker);
+//
+// By default, the clustering will start when there are more than 150 markers in the Clusterer object.
+// You can pass options to the Clusterer constructor to change this behaviour.
+//
+// Copyright � 2005,2006 by Jef Poskanzer <jef@mail.acme.com>.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+//
+// For commentary on this license please see http://www.acme.com/license.html
+//
+// Modified for use with Mapstraction by Guilhem Vellut. Bugs and comments: guilhem.vellut@gmail.com
+//Add a method to the Mapstraction class to add a clusterer
+Mapstraction.prototype.addClusterer = function(clusterer){
+    clusterer.initialize(this);
+}
+// Constructor.
+Clusterer = function (markers, options){
+    this.markers = markers || [];
+    for(var i = 0, len = markers.length ; i < len ; ++i){
+	markers[i].onMap = false;
+    }
+    this.clusters = [];
+    this.timeout = null;
+    options = options || new Object();
+    this.maxVisibleMarkers = options.maxVisibleMarkers || 150;
+    this.gridSize = options.gridSize || 5;
+    this.minMarkersPerCluster = options.minMarkersPerCluster ||5;
+    this.maxLinesPerInfoBox = options.maxLinesPerInfoBox ||10;
+    this.icon = options.icon;
+    map.addEventListener("moveend",Clusterer.makeCaller( Clusterer.display, this ) );
+};
+// Call this to add a marker.
+Clusterer.prototype.addMarker = function ( marker){
+    marker.onMap = false;
+    this.markers.push( marker );
+    if(this.map != null){
+	if ( marker.setMap != null )
+	    marker.setMap( this.map );
+	this.displayLater();
+    }
+};
+Clusterer.prototype.initialize = function(mapstraction){
+    this.map = mapstraction;
+    this.currentZoomLevel = mapstraction.getZoom();
+    for(var i = 0, len = this.markers.length; i < len; ++i ){
+	this.markers[i].setMap(mapstraction);
+    }
+    this.displayLater();
+}
+// Call this to remove a marker.
+Clusterer.prototype.removeMarker = function ( marker )
+    {
+    for ( var i = 0; i < this.markers.length; ++i )
+	if ( this.markers[i] == marker )
+	    {
+	    if ( marker.onMap )
+		this.map.removeMarker( marker );
+	    for ( var j = 0; j < this.clusters.length; ++j )
+		{
+		var cluster = this.clusters[j];
+		if ( cluster != null )
+		    {
+		    for ( var k = 0; k < cluster.markers.length; ++k )
+			if ( cluster.markers[k] == marker )
+			    {
+			    cluster.markers[k] = null;
+			    --cluster.markerCount;
+			    break;
+			    }
+		    if ( cluster.markerCount == 0 )
+			{
+			this.clearCluster( cluster );
+			this.clusters[j] = null;
+			}
+		    }
+	       }
+	    this.markers[i] = null;
+	    break;
+	    }
+    this.displayLater();
+    };
+Clusterer.prototype.displayLater = function ()
+    {
+    if ( this.timeout != null )
+	clearTimeout( this.timeout );
+    this.timeout = setTimeout( Clusterer.makeCaller( Clusterer.display, this ), 50 );
+    };
+Clusterer.display = function ( clusterer )
+    {
+    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.lon - sw.lon;
+    var dy = ne.lat - sw.lat;
+    dx *= 0.10;
+    dy *= 0.10;
+    bounds = new BoundingBox(sw.lat - dy, sw.lon - dx,ne.lat + dy, ne.lon + 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.location ) )
+		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.removeMarker( 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.location ) && cluster.onMap )
+	    {
+	    clusterer.map.removeMarker( 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 BoundingBox( lat, lng , 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.location ) )
+			{
+			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.removeMarker( 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.location.lng );
+			yTotal += ( + marker.location.lat );
+			}
+		    }
+		var location = new LatLonPoint( yTotal / cluster.markerCount, xTotal / cluster.markerCount );
+		marker = new Marker( location);
+		if(clusterer.icon)
+		    marker.setIcon(clusterer.icon);
+		marker.setInfoBubble(Clusterer.popUpText(cluster));
+		cluster.marker = marker;
+		}
+	    }
+	}
+    // 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.addMarker( marker );
+	    if ( marker.addedToMap != null )
+		marker.addedToMap();
+	    marker.onMap = true;
+	    }
+	}
+    // 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.location ) )
+	    {
+	    clusterer.map.addMarker( cluster.marker );
+	    cluster.onMap = true;
+	    }
+	}
+ };
+Clusterer.popUpText = function (cluster)
+    {
+    var clusterer = cluster.clusterer;
+    var html = '<table width="300">';
+    var n = 0;
+    for ( var i = 0; i < cluster.markers.length; ++i )
+	{
+	var marker = cluster.markers[i];
+	if ( marker != null )
+	    {
+	    ++n;
+	    html += '<tr>';
+	    html += '<td>' ;
+	    if( marker.labelText != null)
+		html += marker.labelText;
+	    else
+		html += 'marker #' + i;
+	    if(marker.iconUrl != null){
+		html += '<td><img src="' + marker.iconUrl + '" /></td>';
+	    }
+	    html += '</td></tr>';
+	    if ( n == clusterer.maxLinesPerInfoBox - 1 && cluster.markerCount > clusterer.maxLinesPerInfoBox  )
+		{
+		html += '<tr><td colspan="2">...and ' + ( cluster.markerCount - n ) + ' more</td></tr>';
+		break;
+		}
+	    }
+	}
+    html += '</table>';
+    return html;
+};
+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.onMap )
+	{
+	this.map.removeMarker( 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 ); };
+    };
+// Augment GMarker so it handles markers that have been created but
+// not yet addOverlayed.
+Marker.prototype.setMap = function ( map )
+    {
+    this.map = map;
+    };
+Marker.prototype.addedToMap = function ()
+    {
+    this.map = null;
+    };