gmaps4rails 0.8.4 → 0.8.5

data/public/javascripts/gmaps4rails.js

@@ -1,59 +1,70 @@
 var Gmaps4Rails = {
 	//map config
-	map: null,									//contains the map we're working on
-	visibleInfoWindow: null,
-  
+	map: null,									// contains the map we're working on
+	visibleInfoWindow: null,    //contains the current opened infowindow
+  userLocation: null,         //contains user's location if geolocalization was performed and successful
+
 	//Map settings
 	map_options: {
 	  id: 'gmaps4rails_map',
-	  type: "ROADMAP",        // HYBRID, ROADMAP, SATELLITE, TERRAIN
-		center_latitude : 0,
-		center_longitude : 0, 
-		zoom : 1,
+		disableDefaultUI: false,
+		disableDoubleClickZoom: false,
+		draggable: true,
+	  type: "ROADMAP",         // HYBRID, ROADMAP, SATELLITE, TERRAIN
+		detect_location: false,  // should the browser attempt to use geolocation detection features of HTML5?
+	  center_on_user: false,   // centers map on the location detected through the browser
+		center_latitude: 0,
+		center_longitude: 0, 
+		zoom: 1,
 		maxZoom: null,
 		minZoom: null,
-		auto_adjust : false,    //adjust the map to the markers if set to true
-		auto_zoom: true,        //zoom given by auto-adjust
-		bounds: []              //adjust map to these limits. Should be [{"lat": , "lng": }]
-		},				
+		auto_adjust : false,    // adjust the map to the markers if set to true
+		auto_zoom: true,        // zoom given by auto-adjust
+		bounds: []              // adjust map to these limits. Should be [{"lat": , "lng": }]
+	},				
 	
 	//markers + info styling
 	markers_conf: {
+		// Marker config
+		title: "",
+		// MarkerImage config
 	  picture : "",
-		width : 22,
-		length : 32,
+		width: 22,
+		length: 32,
+		anchor: null,             // centeranchor position of the marker image. Default is null <=> center, you can set options: top_left, top_center, top_right, center_left, center, center_right, bottom_right, bottom_center, bottom_left
 		//clustering config
-	  do_clustering: true,			//do clustering if set to true
-	  clusterer_gridSize: 50,		//the more the quicker but the less precise
-		clusterer_maxZoom:  5,		//removes clusterer  at this zoom level
-		randomize: false,         //Google maps can't display two markers which have the same coordinates. This randomizer enables to prevent this situation from happening.
-		max_random_distance: 100, //in meters. Each marker coordinate could be altered by this distance in a random direction
-		list_container : null     //id of the ul that will host links to all markers
-		},
+	  do_clustering: true,			// do clustering if set to true
+	  clusterer_gridSize: 50,		// the more the quicker but the less precise
+		clusterer_maxZoom:  5,		// removes clusterer  at this zoom level
+		randomize: false,         // Google maps can't display two markers which have the same coordinates. This randomizer enables to prevent this situation from happening.
+		max_random_distance: 100, // in meters. Each marker coordinate could be altered by this distance in a random direction
+		list_container: null,     // id of the ul that will host links to all markers
+		custom_cluster_pictures: null
+	},
 	
 	//Stored variables
-	markers : [],							  //contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "google_object": google_marker}
-	bounds_object: null,				//contains current bounds from markers, polylines etc...
-	polygons: [], 						  //contains raw data, array of arrays (first element could be a hash containing options)
-	polylines: [], 						  //contains raw data, array of arrays (first element could be a hash containing options)
-	circles: [],                //contains raw data, array of hash
-  markerClusterer: null,			//contains all marker clusterers
+	markers: [],							  // contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "google_object": google_marker}
+	bounds_object: null,				// contains current bounds from markers, polylines etc...
+	polygons: [], 						  // contains raw data, array of arrays (first element could be a hash containing options)
+	polylines: [], 						  // contains raw data, array of arrays (first element could be a hash containing options)
+	circles: [],                // contains raw data, array of hash
+  markerClusterer: null,			// contains all marker clusterers
   
 	//Polygon Styling
-	polygons_conf: {						//default style for polygons
+	polygons_conf: {						// default style for polygons
 		strokeColor: "#FFAA00",
   	strokeOpacity: 0.8,
   	strokeWeight: 2,
     fillColor: "#000000",
   	fillOpacity: 0.35
-		},
+	},
 
 	//Polyline Styling		
 	polylines_conf: {						//default style for polylines
 		strokeColor: "#FF0000",
   	strokeOpacity: 1,
   	strokeWeight: 2
-		},
+	},
 		
 	//Circle Styling	
 	circles_conf: {							//default style for circles
@@ -61,8 +72,10 @@ var Gmaps4Rails = {
 	  fillOpacity: 0.35,
 		strokeColor: "#FFAA00",
 	  strokeOpacity: 0.8,
-	  strokeWeight: 2
-		},
+	  strokeWeight: 2,
+		clickable: false,
+		zIndex: null
+	},
 	
 	//Direction Settings
 	direction_conf: {
@@ -70,7 +83,7 @@ var Gmaps4Rails = {
 		display_panel: 			false,
 		origin: 						null, 
     destination: 				null,
-		waypoints: 					[], //[{location: "toulouse,fr", stopover: true}, {location: "Clermont-Ferrand, fr", stopover: true}]
+		waypoints: 					[],       //[{location: "toulouse,fr", stopover: true}, {location: "Clermont-Ferrand, fr", stopover: true}]
     optimizeWaypoints: 	false,
 		unitSystem: 				"METRIC", //IMPERIAL
 		avoidHighways: 			false,
@@ -78,19 +91,50 @@ var Gmaps4Rails = {
 		region: 						null, 
 		travelMode: 				"DRIVING" //WALKING, BICYCLING
 	},
+	
 	//initializes the map
-	initialize: function(){
+	initialize: function() {
+		
 		this.map = new google.maps.Map(document.getElementById(this.map_options.id), {
 			  maxZoom: this.map_options.maxZoom,
 			  minZoom: this.map_options.minZoom,
 				zoom: this.map_options.zoom,
-				center: new google.maps.LatLng(this.map_options.center_latitude, this.map_options.center_longitude),
-				mapTypeId: google.maps.MapTypeId[this.map_options.type]
+		 		center: new google.maps.LatLng(this.map_options.center_latitude, this.map_options.center_longitude),
+				mapTypeId: google.maps.MapTypeId[this.map_options.type],
+				mapTypeControl: this.map_options.mapTypeControl,
+				disableDefaultUI: this.map_options.disableDefaultUI,
+				disableDoubleClickZoom: this.map_options.disableDoubleClickZoom,
+				draggable: this.map_options.draggable
 		});
+		
+		if (this.map_options.detect_location === true || this.map_options.center_on_user === true) { 
+			this.findUserLocation();
+		}    
 		//resets sidebar if needed
 		this.reset_sidebar_content();
 	},
 	
+	findUserLocation: function() {
+		if(navigator.geolocation) {
+	    navigator.geolocation.getCurrentPosition(function(position) {
+	      Gmaps4Rails.userLocation = new google.maps.LatLng(position.coords.latitude, position.coords.longitude);
+	    	//change map's center to focus on user's geoloc
+				if(Gmaps4Rails.map_options.center_on_user === true) {
+					Gmaps4Rails.map.setCenter(Gmaps4Rails.userLocation);
+				}
+	    },
+	    function() {
+			  if(this.fnSet("gmaps4rails_geolocation_failure")) { gmaps4rails_geolocation_failure(true); }
+		});
+	  } else {
+		  if(this.fnSet("gmaps4rails_geolocation_failure")) { gmaps4rails_geolocation_failure(false); }
+	  }
+	},
+
+	////////////////////////////////////////////////////
+	//////////////////// DIRECTIONS ////////////////////
+	////////////////////////////////////////////////////
+	
 	create_direction: function(){
 		var directionsDisplay = new google.maps.DirectionsRenderer();
 		var directionsService = new google.maps.DirectionsService();
@@ -99,9 +143,9 @@ var Gmaps4Rails = {
 		//display panel only if required
 		if (this.direction_conf.display_panel) {	directionsDisplay.setPanel(document.getElementById(this.direction_conf.panel_id)); }
 		directionsDisplay.setOptions({
-			suppressMarkers: true,
+			suppressMarkers:     false,
 			suppressInfoWindows: false,
-			suppressPolylines: false
+			suppressPolylines:   false
 		});
 	  var request = {
 	        origin: 						this.direction_conf.origin, 
@@ -113,7 +157,7 @@ var Gmaps4Rails = {
 					avoidTolls: 				this.direction_conf.avoidTolls,
 					region: 						this.direction_conf.region, 
 					travelMode: 				google.maps.DirectionsTravelMode[this.direction_conf.travelMode],
-					language: 					"fr"
+					language: 					"en"
 	    };
 	   directionsService.route(request, function(response, status) {
 	      if (status == google.maps.DirectionsStatus.OK) {
@@ -122,38 +166,81 @@ var Gmaps4Rails = {
 	    });
 	},
 	
+	////////////////////////////////////////////////////
+	///////////////////// CIRCLES //////////////////////
+	////////////////////////////////////////////////////
+	
 	//Loops through all circles
-	create_circles: function(){
+	//Loops through all circles and draws them
+	create_circles: function() {
 		for (var i = 0; i < this.circles.length; ++i) {
 			//by convention, default style configuration could be integrated in the first element
-			if ( i === 0 )
-			{
-				if (this.exists(this.circles[i].strokeColor  )) { this.circles_conf.strokeColor 	= this.circles[i].strokeColor; 	 }
-				if (this.exists(this.circles[i].strokeOpacity)) { this.circles_conf.strokeOpacity = this.circles[i].strokeOpacity; }
-			  if (this.exists(this.circles[i].strokeWeight )) { this.circles_conf.strokeWeight 	= this.circles[i].strokeWeight;  }
-			  if (this.exists(this.circles[i].fillColor 	 )) { this.circles_conf.fillColor 		= this.circles[i].fillColor; 		 }
-			  if (this.exists(this.circles[i].fillOpacity  )) { this.circles_conf.fillOpacity 	= this.circles[i].fillOpacity; 	 }
-			}
-			if (this.exists(this.circles[i].latitude) && this.exists(this.circles[i].longitude))
-			{
-				 center = new google.maps.LatLng(this.circles[i].latitude, this.circles[i].longitude);
-				 //always check if a config is given, if not, use defaults
-				 var circle = new google.maps.Circle({
-			   center:        center,
-			   strokeColor:   this.circles[i].strokeColor   || this.circles_conf.strokeColor,
-			   strokeOpacity: this.circles[i].strokeOpacity || this.circles_conf.strokeOpacity,
-			   strokeWeight: 	this.circles[i].strokeWeight  || this.circles_conf.strokeWeight,
-				 fillOpacity: 	this.circles[i].fillOpacity   || this.circles_conf.fillOpacity,
-				 fillColor: 		this.circles[i].fillColor     || this.circles_conf.fillColor,
-				 radius: 				this.circles[i].radius,
-				 clickable:     false
-			 	});
-				this.circles[i].google_object = circle;
-				circle.setMap(this.map);
-			}
+			this.create_circle(this.circles[i]);
+		}
+	},
+	
+	create_circle: function(circle) {
+		if ( i === 0 ) {
+			if (this.exists(circle.strokeColor  )) { this.circles_conf.strokeColor 	 = circle.strokeColor; 	 }
+			if (this.exists(circle.strokeOpacity)) { this.circles_conf.strokeOpacity = circle.strokeOpacity; }
+		  if (this.exists(circle.strokeWeight )) { this.circles_conf.strokeWeight  = circle.strokeWeight;  }
+		  if (this.exists(circle.fillColor    )) { this.circles_conf.fillColor 		 = circle.fillColor; 		 }
+		  if (this.exists(circle.fillOpacity  )) { this.circles_conf.fillOpacity 	 = circle.fillOpacity; 	 }
+		}
+		if (this.exists(circle.latitude) && this.exists(circle.longitude)) {
+			// always check if a config is given, if not, use defaults
+			// NOTE: is there a cleaner way to do this? Maybe a hash merge of some sort?
+			var newCircle = new google.maps.Circle({
+			   center:        new google.maps.LatLng(circle.latitude, circle.longitude),
+			   strokeColor:   circle.strokeColor   || this.circles_conf.strokeColor,
+			   strokeOpacity: circle.strokeOpacity || this.circles_conf.strokeOpacity,
+			   strokeWeight: 	circle.strokeWeight  || this.circles_conf.strokeWeight,
+				 fillOpacity: 	circle.fillOpacity   || this.circles_conf.fillOpacity,
+				 fillColor: 		circle.fillColor     || this.circles_conf.fillColor,
+				 clickable:     circle.clickable     || this.circles_conf.clickable,
+				 zIndex: 				circle.zIndex				 || this.circles_conf.zIndex,
+				 radius: 				circle.radius
+		 	});
+			circle.google_object = newCircle;
+			newCircle.setMap(this.map);
 		}
 	},
 	
+	// clear circles
+  clear_circles: function() {
+		for (var i = 0; i <  this.circles.length; ++i) {
+			this.clear_circle(this.circles[i]);
+    }
+  },
+
+	clear_circle: function(circle) {
+		circle.google_object.setMap(null);
+	},
+	
+	hide_circles: function() {
+		for (var i = 0; i <  this.circles.length; ++i) {
+			this.hide_circle(this.circles[i]);
+    }
+	},
+	
+	hide_circle: function(circle) {
+		circle.google_object.setMap(null);
+	},
+	
+	show_circles: function() {
+		for (var i = 0; i <  this.circles.length; ++i) {
+			this.show_circle(this.circles[i]);
+    }
+	},
+	
+	show_circle: function(circle) {
+		circle.google_object.setMap(this.map);
+	},
+
+	////////////////////////////////////////////////////
+	///////////////////// POLYGONS /////////////////////
+	////////////////////////////////////////////////////
+	
 	//polygons is an array of arrays. It loops.
 	create_polygons: function(){
 		for (var i = 0; i < this.polygons.length; ++i) {
@@ -197,6 +284,10 @@ var Gmaps4Rails = {
 		this.polygons[i].google_object = new_poly;
 		new_poly.setMap(this.map);
 	},
+
+	////////////////////////////////////////////////////
+	/////////////////// POLYLINES //////////////////////
+	////////////////////////////////////////////////////
 	
 	//polylines is an array of arrays. It loops.
 	create_polylines: function(){
@@ -206,7 +297,7 @@ var Gmaps4Rails = {
 	},
 	
 	//creates a single polyline, triggered by create_polylines
-	create_polyline: function(i){
+	create_polyline: function(i) {
 		var polyline_coordinates = [];
 		var strokeColor;
 	  var strokeOpacity;
@@ -215,7 +306,7 @@ var Gmaps4Rails = {
 		//2 cases here, either we have a coded array of LatLng or we have an Array of LatLng
 		for (var j = 0; j < this.polylines[i].length; ++j) {
 			//if we have a coded array
-			if (this.exists(this.polylines[i][j].coded_array)){
+			if (this.exists(this.polylines[i][j].coded_array)) {
 				var decoded_array = new google.maps.geometry.encoding.decodePath(this.polylines[i][j].coded_array);
 				//loop through every point in the array
 				for (var k = 0; k < decoded_array.length; ++k) {		
@@ -226,14 +317,13 @@ var Gmaps4Rails = {
 			//or we have an array of latlng
 			else{
 				//by convention, a single polyline could be customized in the first array or it uses default values
-				if (j===0){
+				if (j===0) {
 					strokeColor   = this.polylines[i][0].strokeColor   || this.polylines_conf.strokeColor;
 				  strokeOpacity = this.polylines[i][0].strokeOpacity || this.polylines_conf.strokeOpacity;
 			  	strokeWeight  = this.polylines[i][0].strokeWeight  || this.polylines_conf.strokeWeight;
 				}
 				//add latlng if positions provided
-				if (this.exists(this.polylines[i][j].latitude) && this.exists(this.polylines[i][j].longitude)) 
-				{	
+				if (this.exists(this.polylines[i][j].latitude) && this.exists(this.polylines[i][j].longitude)) {	
 					var latlng = new google.maps.LatLng(this.polylines[i][j].latitude, this.polylines[i][j].longitude);
 			  	polyline_coordinates.push(latlng);
 				}
@@ -252,6 +342,10 @@ var Gmaps4Rails = {
 		new_poly.setMap(this.map);
 	},
 
+	////////////////////////////////////////////////////
+	///////////////////// MARKERS //////////////////////
+	////////////////////////////////////////////////////
+
 	//creates, clusterizes and adjusts map 
 	create_markers: function() {
 		this.create_google_markers_from_markers();
@@ -260,7 +354,7 @@ var Gmaps4Rails = {
 	},
 	
 	//create google.maps Markers from data provided by user
-	create_google_markers_from_markers: function(){
+	create_google_markers_from_markers: function() {
 		for (var i = 0; i < this.markers.length; ++i) {
 		  //check if the marker has not already been created
 			if (!this.exists(this.markers[i].google_object)) {
@@ -268,49 +362,122 @@ var Gmaps4Rails = {
 			   var marker_picture = this.exists(this.markers[i].picture) ? this.markers[i].picture : this.markers_conf.picture;
 			   var marker_width 	= this.exists(this.markers[i].width)   ? this.markers[i].width 	 : this.markers_conf.width;
 			   var marker_height 	= this.exists(this.markers[i].height)  ? this.markers[i].height  : this.markers_conf.length;
+				 var marker_anchor	= this.exists(this.markers[i].anchor)	 ? this.markers[i].anchor  : this.markers_conf.anchor;
 			   var marker_title 	= this.exists(this.markers[i].title)   ? this.markers[i].title 	 : null;
       	 var Lat = this.markers[i].latitude;
 				 var Lng = this.markers[i].longitude;
-				 
+				 var imageAnchorPosition = null;
+				 // calculate MarkerImage anchor location
+				 if (this.exists(this.markers[i].width) && this.exists(this.markers[i].height) && marker_anchor !== null) {
+				 		imageAnchorPosition = getImageAnchorPosition(marker_width, marker_height, marker_anchor);
+				 }
+				
 				 //alter coordinates if randomize is true
-				 if ( this.markers_conf.randomize)
-				 {
-					var LatLng = this.randomize(Lat, Lng);
-				  //retrieve coordinates from the array
-				  Lat = LatLng[0]; Lng = LatLng[1];
+				 if ( this.markers_conf.randomize) {
+						var LatLng = this.randomize(Lat, Lng);
+				  	//retrieve coordinates from the array
+				  	Lat = LatLng[0]; Lng = LatLng[1];
 				 }
 				
-				 var myLatLng = new google.maps.LatLng(Lat, Lng); 
-				 var ThisMarker;
+				 var markerLatLng = new google.maps.LatLng(Lat, Lng); 
+				 var thisMarker;
 				 // Marker sizes are expressed as a Size of X,Y
-		 		 if (marker_picture === "")
-					{ ThisMarker = new google.maps.Marker({position: myLatLng, map: this.map, title: marker_title});	}
-					else 
-				  {
-						var image = new google.maps.MarkerImage(marker_picture, new google.maps.Size(marker_width, marker_height) );
-					  ThisMarker = new google.maps.Marker({position: myLatLng, map: this.map, icon: image, title: marker_title});
-					}
-					//save object
-					this.markers[i].google_object = ThisMarker; 
-					//add infowindowstuff if enabled
-					this.create_info_window(this.markers[i]);
-					//create sidebar if enabled
-					this.create_sidebar(this.markers[i]);
+		 		 if (marker_picture === "") { 
+						thisMarker = new google.maps.Marker({position: markerLatLng, map: this.map, title: marker_title});	
+				 } else {
+						var image = new google.maps.MarkerImage(marker_picture, new google.maps.Size(marker_width, marker_height), null, imageAnchorPosition, null );
+					  thisMarker = new google.maps.Marker({position: markerLatLng, map: this.map, icon: image, title: marker_title});
+				 }
+				 //save object
+				 this.markers[i].google_object = thisMarker; 
+				 //add infowindowstuff if enabled
+				 this.create_info_window(this.markers[i]);
+				 //create sidebar if enabled
+				 this.create_sidebar(this.markers[i]);
 			 }
 		}
 		
+		// calculate anchor point for MarkerImage	
+		function getImageAnchorPosition(markerWidth, markerHeight, anchorLocation) {
+			var x;
+			var y;
+			switch (anchorLocation) {
+				case "top_left":
+					x = 0;
+					y = 0;
+					break;
+				case "top_center":
+					x = markerWidth / 2;
+					y = 0;
+					break;		
+				case "top_right":
+					x = markerWidth;
+					y = 0;
+					break;		
+				case "center_left":
+					x = 0;
+					y = markerHeight / 2;
+					break;		
+				case "center":
+					x = markerWidth / 2;
+					y = markerHeight / 2;
+					break;
+				case "center_right":
+					x = markerWidth;
+					y = markerHeight / 2;
+					break;		
+				case "bottom_left":
+					x = 0;
+					y = markerHeight;
+					break;		
+				case "bottom_center":
+					x = markerWidth / 2;
+					y = markerHeight;
+					break;		
+				case "bottom_right":
+					x = markerWidth;
+					y = markerHeight;
+					break;		
+			}
+			return new google.maps.Point(x,y);
+		}
 	},
 
   // clear markers
-  clear_markers: function(){
+  clear_markers: function() {
     if (this.markerClusterer !== null){
 			this.markerClusterer.clearMarkers();
 		}
-		for (var i = 0; i <  this.markers.length; ++i) {
-      this.markers[i].google_object.setMap(null);
+		for (var i = 0; i < this.markers.length; ++i) {
+      this.clear_marker(this.markers[i]);
     }
   },
 
+	clear_marker: function(marker) {
+		marker.google_object.setMap(null);
+	},
+
+	// show and hide markers
+	show_markers: function() {
+		for (var i = 0; i < this.markers.length; ++i) {
+      this.show_marker(this.markers[i]);
+    }
+	},
+	
+	show_marker: function(marker) {
+		marker.google_object.setVisible(true);
+	},
+	
+	hide_markers: function() {
+		for (var i = 0; i < this.markers.length; ++i) {
+      this.hide_marker(this.markers[i]);
+    }
+	},
+	
+	hide_marker: function(marker) {
+		marker.google_object.setVisible(false);
+	},
+	
   // replace old markers with new markers on an existing map
   replace_markers: function(new_markers){
 	  //reset previous markers
@@ -342,19 +509,27 @@ var Gmaps4Rails = {
 			for (var i = 0; i <  this.markers.length; ++i) {
        gmarkers_array.push(this.markers[i].google_object);
       }
-			
-			
-			this.markerClusterer = new MarkerClusterer(this.map, gmarkers_array, {	maxZoom: this.markers_conf.clusterer_maxZoom, gridSize: this.markers_conf.clusterer_gridSize });
+			var clustererStyle = null;
+			if(this.fnSet("gmaps_custom_clusterer_pic")) {
+				clustererStyle = gmaps_custom_clusterer_pic();
+			}
+			this.markerClusterer = new MarkerClusterer( this.map,
+																									gmarkers_array, 
+																									{	maxZoom: this.markers_conf.clusterer_maxZoom, gridSize: this.markers_conf.clusterer_gridSize, styles: clustererStyle }
+																								);
 	  }
 	},
-	
+
+	////////////////////////////////////////////////////
+	/////////////////// INFO WINDOW ////////////////////
+	////////////////////////////////////////////////////
+
 	// creates infowindows
 	create_info_window: function(marker_container){
 		//create the infowindow
 		var info_window = new google.maps.InfoWindow({content: marker_container.description });
 		//add the listener associated
 		google.maps.event.addListener(marker_container.google_object, 'click', this.openInfoWindow(info_window, marker_container.google_object));
-
 	},
 
 	openInfoWindow: function(infoWindow, marker) {
@@ -369,6 +544,10 @@ var Gmaps4Rails = {
     };
   },
 
+	////////////////////////////////////////////////////
+	///////////////////// SIDEBAR //////////////////////
+	////////////////////////////////////////////////////
+
 	//creates sidebar
 	create_sidebar: function(marker_container){
 		if (this.markers_conf.list_container)
@@ -400,6 +579,10 @@ var Gmaps4Rails = {
 		}
 	},
 
+	////////////////////////////////////////////////////
+	////////////////// MISCELLANEOUS ///////////////////
+	////////////////////////////////////////////////////
+
 	//to make the map fit the different LatLng points
 	adjust_map_to_bounds: function(latlng) {
 		
@@ -417,11 +600,11 @@ var Gmaps4Rails = {
 	    }
  		  //from polygons:
 			for (var i = 0; i <  this.polylines.length; ++i) {
-				this.polylines[i].google_object.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.google_bounds.extend(obj2);} );})
+				this.polylines[i].google_object.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.google_bounds.extend(obj2);} );});
 			}
 			//from polylines:
 			for (var i = 0; i <  this.polygons.length; ++i) {
-				this.polygons[i].google_object.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.google_bounds.extend(obj2);} );})
+				this.polygons[i].google_object.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.google_bounds.extend(obj2);} );});
 			}
 			//from circles
 			for (var i = 0; i <  this.circles.length; ++i) {
@@ -454,7 +637,11 @@ var Gmaps4Rails = {
 
 	//basic function to check existence of a variable
 	exists: function(var_name) {
-		return var_name	!== "" && typeof var_name !== "undefined"
+		return (var_name	!== "" && typeof var_name !== "undefined");
+	},
+	//check existence of function
+	fnSet: function(fn_name){
+		return(typeof fn_name == 'function');
 	},
 
 	//randomize

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gmaps4rails
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 53
   prerelease: false
   segments: 
   - 0
   - 8
-  - 4
-  version: 0.8.4
+  - 5
+  version: 0.8.5
 platform: ruby
 authors: 
 - Benjamin Roth
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-11 00:00:00 +02:00
+date: 2011-05-16 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency