gmapsjs 0.2.13 → 0.2.30

data/app/assets/javascripts/gmapsjs/gmapsjs.js

@@ -1,5 +1,5 @@
 /*!
- * GMaps.js v0.2.13
+ * GMaps.js v0.2.30
  * http://hpneo.github.com/gmaps/
  *
  * Copyright 2012, Gustavo Leon
@@ -24,13 +24,18 @@ if(window.google && window.google.maps){
 
     var GMaps = function(options) {
       var self = this;
+      var events_that_hide_context_menu = ['bounds_changed', 'center_changed', 'click', 'dblclick', 'drag', 'dragend', 'dragstart', 'idle', 'maptypeid_changed', 'projection_changed', 'resize', 'tilesloaded', 'zoom_changed'];
+      var events_that_doesnt_hide_context_menu = ['mousemove', 'mouseout', 'mouseover'];
+
       window.context_menu = {};
 
-      if(typeof(options.div)=='string'){
-        this.div = getElementById(options.div, options.context);
-      }else{this.div = options.div;};
-      this.div.style.width = options.width || this.div.scrollWidth || this.div.offsetWidth;
-      this.div.style.height = options.height || this.div.scrollHeight || this.div.offsetHeight;
+      if (typeof(options.el) === 'string' || typeof(options.div) === 'string') {
+        this.el = getElementById(options.el || options.div, options.context);
+      } else {
+        this.el = options.el || options.div;
+      };
+      this.el.style.width = options.width || this.el.scrollWidth || this.el.offsetWidth;
+      this.el.style.height = options.height || this.el.scrollHeight || this.el.offsetHeight;
 
       this.controls = [];
       this.overlays = [];
@@ -41,9 +46,11 @@ if(window.google && window.google.maps){
       this.routes = [];
       this.polygons = [];
       this.infoWindow = null;
-      this.overlay_div = null;
+      this.overlay_el = null;
       this.zoom = options.zoom || 15;
 
+      var markerClusterer = options.markerClusterer;
+
       //'Hybrid', 'Roadmap', 'Satellite' or 'Terrain'
       var mapType;
 
@@ -56,12 +63,13 @@ if(window.google && window.google.maps){
 
       var map_center = new google.maps.LatLng(options.lat, options.lng);
 
-      delete options.div;
+      delete options.el;
       delete options.lat;
       delete options.lng;
       delete options.mapType;
       delete options.width;
       delete options.height;
+      delete options.markerClusterer;
 
       var zoomControlOpt = options.zoomControlOpt || {
         style: 'DEFAULT',
@@ -77,10 +85,15 @@ if(window.google && window.google.maps){
           streetViewControl = options.streetViewControl || true,
           overviewMapControl = overviewMapControl || true;
 
+      var map_options = {};
+
       var map_base_options = {
         zoom: this.zoom,
         center: map_center,
-        mapTypeId: mapType,
+        mapTypeId: mapType
+      };
+
+      var map_controls_options = {
         panControl: panControl,
         zoomControl: zoomControl,
         zoomControlOptions: {
@@ -91,76 +104,92 @@ if(window.google && window.google.maps){
         scaleControl: scaleControl,
         streetViewControl: streetViewControl,
         overviewMapControl: overviewMapControl
-      };
+      }
+
+      if(options.disableDefaultUI != true)
+        map_base_options = extend_object(map_base_options, map_controls_options);
+
+      map_options = extend_object(map_base_options, options);
 
-      var map_options = extend_object(map_base_options, options);
+      for(var i = 0; i < events_that_hide_context_menu.length; i++) {
+        delete map_options[events_that_hide_context_menu[i]];
+      }
+
+      for(var i = 0; i < events_that_doesnt_hide_context_menu.length; i++) {
+        delete map_options[events_that_doesnt_hide_context_menu[i]];
+      }
 
-      this.map = new google.maps.Map(this.div, map_options);
+      this.map = new google.maps.Map(this.el, map_options);
+
+      if(markerClusterer) {
+        this.markerClusterer = markerClusterer.apply(this, [this.map]);
+      }
 
       // Context menus
       var buildContextMenuHTML = function(control, e) {
-          var html = '';
-          var options = window.context_menu[control];
-          for (var i in options){
-            if (options.hasOwnProperty(i)){
-              var option = options[i];
-              html += '<li><a id="' + control + '_' + i + '" href="#">' +
-                option.title + '</a></li>';
-            }
+        var html = '';
+        var options = window.context_menu[control];
+        for (var i in options){
+          if (options.hasOwnProperty(i)){
+            var option = options[i];
+            html += '<li><a id="' + control + '_' + i + '" href="#">' +
+              option.title + '</a></li>';
           }
+        }
 
-          if(!getElementById('gmaps_context_menu')) return;
+        if(!getElementById('gmaps_context_menu')) return;
           
-          var context_menu_element = getElementById('gmaps_context_menu');
-          context_menu_element.innerHTML = html;
+        var context_menu_element = getElementById('gmaps_context_menu');
+        context_menu_element.innerHTML = html;
 
-          var context_menu_items = context_menu_element.getElementsByTagName('a');
+        var context_menu_items = context_menu_element.getElementsByTagName('a');
 
-          var context_menu_items_count = context_menu_items.length;
+        var context_menu_items_count = context_menu_items.length;
 
-          for(var i=0;i<context_menu_items_count;i++){
-            var context_menu_item = context_menu_items[i];
+        for(var i = 0; i < context_menu_items_count; i++){
+          var context_menu_item = context_menu_items[i];
 
-            var assign_menu_item_action = function(ev){
-              ev.preventDefault();
+          var assign_menu_item_action = function(ev){
+            ev.preventDefault();
 
-              options[this.id.replace(control + '_', '')].action.call(self, e);
-              self.hideContextMenu();
-            };
+            options[this.id.replace(control + '_', '')].action.apply(self, [e]);
+            self.hideContextMenu();
+          };
 
-            google.maps.event.clearListeners(context_menu_item, 'click');
-            google.maps.event.addDomListenerOnce(context_menu_item, 'click', assign_menu_item_action, false);
-          }
+          google.maps.event.clearListeners(context_menu_item, 'click');
+          google.maps.event.addDomListenerOnce(context_menu_item, 'click', assign_menu_item_action, false);
+        }
 
-          var left = self.div.offsetLeft + e.pixel.x - 15;
-          var top = self.div.offsetTop + e.pixel.y - 15;
+        var left = self.el.offsetLeft + e.pixel.x - 15;
+        var top = self.el.offsetTop + e.pixel.y - 15;
 
-          context_menu_element.style.left = left + "px";
-          context_menu_element.style.top = top + "px";
+        context_menu_element.style.left = left + "px";
+        context_menu_element.style.top = top + "px";
 
-          context_menu_element.style.display = 'block';
-        };
+        context_menu_element.style.display = 'block';
+      };
 
       var buildContextMenu = function(control, e) {
-          if (control === 'marker') {
-            e.pixel = {};
-            var overlay = new google.maps.OverlayView();
-            overlay.setMap(self.map);
-            overlay.draw = function() {
-              var projection = overlay.getProjection();
-              var position = e.marker.getPosition();
-              e.pixel = projection.fromLatLngToContainerPixel(position);
-
-              buildContextMenuHTML(control, e);
-            };
-          }
-          else {
+        if (control === 'marker') {
+          e.pixel = {};
+          var overlay = new google.maps.OverlayView();
+          overlay.setMap(self.map);
+          overlay.draw = function() {
+            var projection = overlay.getProjection();
+            var position = e.marker.getPosition();
+            e.pixel = projection.fromLatLngToContainerPixel(position);
+
             buildContextMenuHTML(control, e);
-          }
-        };
+          };
+        }
+        else {
+          buildContextMenuHTML(control, e);
+        }
+      };
 
       this.setContextMenu = function(options) {
         window.context_menu[options.control] = {};
+
         for (var i in options.options){
           if (options.options.hasOwnProperty(i)){
             var option = options.options[i];
@@ -170,7 +199,9 @@ if(window.google && window.google.maps){
             };
           }
         }
+
         var ul = doc.createElement('ul');
+        
         ul.id = 'gmaps_context_menu';
         ul.style.display = 'none';
         ul.style.position = 'absolute';
@@ -201,33 +232,32 @@ if(window.google && window.google.maps){
 
       //Events
 
-      var events_that_hide_context_menu = ['bounds_changed', 'center_changed', 'click', 'dblclick', 'drag', 'dragend', 'dragstart', 'idle', 'maptypeid_changed', 'projection_changed', 'resize', 'tilesloaded', 'zoom_changed'];
-      var events_that_doesnt_hide_context_menu = ['mousemove', 'mouseout', 'mouseover'];
+      var setupListener = function(object, name) {
+        google.maps.event.addListener(object, name, function(e){
+          if(e == undefined) {
+            e = this;
+          }
 
-      for (var ev = 0; ev < events_that_hide_context_menu.length; ev++) {
-        (function(object, name) {
-          google.maps.event.addListener(object, name, function(e){
-            if(e == undefined)
-              e = this;
+          options[name].apply(this, [e]);
 
-            if (options[name])
-              options[name].apply(this, [e]);
+          self.hideContextMenu();
+        });
+      }
 
-            self.hideContextMenu();
-          });
-        })(this.map, events_that_hide_context_menu[ev]);
+      for (var ev = 0; ev < events_that_hide_context_menu.length; ev++) {
+        var name = events_that_hide_context_menu[ev];
+
+        if (name in options) {
+          setupListener(this.map, name);
+        }
       }
 
       for (var ev = 0; ev < events_that_doesnt_hide_context_menu.length; ev++) {
-        (function(object, name) {
-          google.maps.event.addListener(object, name, function(e){
-            if(e == undefined)
-              e = this;
-            
-            if (options[name])
-              options[name].apply(this, [e]);
-          });
-        })(this.map, events_that_doesnt_hide_context_menu[ev]);
+        var name = events_that_doesnt_hide_context_menu[ev];
+
+        if (name in options) {
+          setupListener(this.map, name);
+        }
       }
 
       google.maps.event.addListener(this.map, 'rightclick', function(e) {
@@ -235,7 +265,9 @@ if(window.google && window.google.maps){
           options.rightclick.apply(this, [e]);
         }
 
-        buildContextMenu('map', e);
+        if(window.context_menu['map'] != undefined) {
+          buildContextMenu('map', e);
+        }
       });
 
       this.refresh = function() {
@@ -250,10 +282,10 @@ if(window.google && window.google.maps){
           latLngs.push(this.markers[i].getPosition());
         }
 
-        this.fitBounds(latLngs);
+        this.fitLatLngBounds(latLngs);
       };
 
-      this.fitBounds = function(latLngs) {
+      this.fitLatLngBounds = function(latLngs) {
         var total = latLngs.length;
         var bounds = new google.maps.LatLngBounds();
 
@@ -272,8 +304,8 @@ if(window.google && window.google.maps){
         }
       };
 
-      this.getDiv = function() {
-        return this.div;
+      this.getElement = function() {
+        return this.el;
       };
 
       this.zoomIn = function(value) {
@@ -310,11 +342,20 @@ if(window.google && window.google.maps){
         control.style.fontSize = '13px';
         control.style.boxShadow = 'rgba(0, 0, 0, 0.398438) 0px 2px 4px';
 
-        for(var option in options.style){
+        for(var option in options.style)
           control.style[option] = options.style[option];
+
+        if(options.id) {
+          control.id = options.id;
+        }
+
+        if(options.classes) {
+          control.className = options.classes;
         }
 
-        control.textContent = options.text;
+        if(options.content) {
+          control.innerHTML = options.content;
+        }
 
         for (var ev in options.events) {
           (function(object, name) {
@@ -393,16 +434,16 @@ if(window.google && window.google.maps){
             })(marker, marker_events[ev]);
           }
 
-          for (var ev = 0; ev < marker_events.length; ev++) {
-            (function(object, name) {
+          for (var ev = 0; ev < marker_events_with_mouse.length; ev++) {
+            (function(map, object, name) {
               google.maps.event.addListener(object, name, function(me){
                 if(!me.pixel){
-                  me.pixel = this.map.getProjection().fromLatLngToPoint(me.latLng)
+                  me.pixel = map.getProjection().fromLatLngToPoint(me.latLng)
                 }
                 if (options[name])
                   options[name].apply(this, [me]);
               });
-            })(marker, marker_events_with_mouse[ev]);
+            })(this.map, marker, marker_events_with_mouse[ev]);
           }
 
           google.maps.event.addListener(marker, 'click', function() {
@@ -418,6 +459,18 @@ if(window.google && window.google.maps){
             }
           });
 
+          google.maps.event.addListener(marker, 'rightclick', function(e) {
+            e.marker = this;
+
+            if (options.rightclick) {
+              options.rightclick.apply(this, [e]);
+            }
+
+            if (window.context_menu['marker'] != undefined) {
+              buildContextMenu('marker', e);
+            }
+          });
+
           if (options.dragend || marker.fences) {
             google.maps.event.addListener(marker, 'dragend', function() {
               if (marker.fences) {
@@ -436,16 +489,28 @@ if(window.google && window.google.maps){
       };
 
       this.addMarker = function(options) {
-        if ((options.hasOwnProperty('lat') && options.hasOwnProperty('lng')) || options.position) {
-          var marker = this.createMarker(options);
-          marker.setMap(this.map);
-          this.markers.push(marker);
-
-          return marker;
+        var marker;
+        if(options.hasOwnProperty('gm_accessors_')) {
+          // Native google.maps.Marker object
+          marker = options;
         }
         else {
-          throw 'No latitude or longitude defined';
+          if ((options.hasOwnProperty('lat') && options.hasOwnProperty('lng')) || options.position) {
+            marker = this.createMarker(options);
+          }
+          else {
+            throw 'No latitude or longitude defined';
+          }
         }
+
+        marker.setMap(this.map);
+
+        if(this.markerClusterer)
+          this.markerClusterer.addMarker(marker);
+
+        this.markers.push(marker);
+
+        return marker;
       };
 
       this.addMarkers = function(array) {
@@ -463,6 +528,19 @@ if(window.google && window.google.maps){
         }
       };
 
+      this.removeMarker = function(marker) {
+        for(var i = 0; i < this.markers.length; i++) {
+          if(this.markers[i] === marker) {
+            this.markers[i].setMap(null);
+            this.markers.splice(i, 1);
+
+            break;
+          }
+        }
+
+        return marker;
+      };
+
       this.removeMarkers = function(collection) {
         var collection = (collection || this.markers);
           
@@ -482,6 +560,7 @@ if(window.google && window.google.maps){
       };
 
       // Overlays
+
       this.drawOverlay = function(options) {
         var overlay = new google.maps.OverlayView();
         overlay.setMap(self.map);
@@ -492,21 +571,21 @@ if(window.google && window.google.maps){
           auto_show = options.auto_show;
 
         overlay.onAdd = function() {
-          var div = doc.createElement('div');
-          div.style.borderStyle = "none";
-          div.style.borderWidth = "0px";
-          div.style.position = "absolute";
-          div.style.zIndex = 100;
-          div.innerHTML = options.content;
+          var el = doc.createElement('div');
+          el.style.borderStyle = "none";
+          el.style.borderWidth = "0px";
+          el.style.position = "absolute";
+          el.style.zIndex = 100;
+          el.innerHTML = options.content;
 
-          overlay.div = div;
+          overlay.el = el;
 
           var panes = this.getPanes();
           if (!options.layer) {
             options.layer = 'overlayLayer';
           }
           var overlayLayer = panes[options.layer];
-          overlayLayer.appendChild(div);
+          overlayLayer.appendChild(el);
 
           var stop_overlay_events = ['contextmenu', 'DOMMouseScroll', 'dblclick', 'mousedown'];
 
@@ -521,7 +600,7 @@ if(window.google && window.google.maps){
                   e.stopPropagation();
                 }
               });
-            })(div, stop_overlay_events[ev]);
+            })(el, stop_overlay_events[ev]);
           }
 
           google.maps.event.trigger(this, 'ready');
@@ -534,54 +613,54 @@ if(window.google && window.google.maps){
           options.horizontalOffset = options.horizontalOffset || 0;
           options.verticalOffset = options.verticalOffset || 0;
 
-          var div = overlay.div;
-          var content = div.children[0];
+          var el = overlay.el;
+          var content = el.children[0];
 
           var content_height = content.clientHeight;
           var content_width = content.clientWidth;
 
           switch (options.verticalAlign) {
             case 'top':
-              div.style.top = (pixel.y - content_height + options.verticalOffset) + 'px';
+              el.style.top = (pixel.y - content_height + options.verticalOffset) + 'px';
               break;
             default:
             case 'middle':
-              div.style.top = (pixel.y - (content_height / 2) + options.verticalOffset) + 'px';
+              el.style.top = (pixel.y - (content_height / 2) + options.verticalOffset) + 'px';
               break;
             case 'bottom':
-              div.style.top = (pixel.y + options.verticalOffset) + 'px';
+              el.style.top = (pixel.y + options.verticalOffset) + 'px';
               break;
           }
 
           switch (options.horizontalAlign) {
             case 'left':
-              div.style.left = (pixel.x - content_width + options.horizontalOffset) + 'px';
+              el.style.left = (pixel.x - content_width + options.horizontalOffset) + 'px';
               break;
             default:
             case 'center':
-              div.style.left = (pixel.x - (content_width / 2) + options.horizontalOffset) + 'px';
+              el.style.left = (pixel.x - (content_width / 2) + options.horizontalOffset) + 'px';
               break;
             case 'right':
-              div.style.left = (pixel.x + options.horizontalOffset) + 'px';
+              el.style.left = (pixel.x + options.horizontalOffset) + 'px';
               break;
           }
 
-          div.style.display = auto_show ? 'block' : 'none';
+          el.style.display = auto_show ? 'block' : 'none';
 
           if(!auto_show){
-            options.show.apply(this, [div]);
+            options.show.apply(this, [el]);
           }
         };
 
         overlay.onRemove = function() {
-          var div = overlay.div;
+          var el = overlay.el;
 
           if(options.remove){
-            options.remove.apply(this, [div]);
+            options.remove.apply(this, [el]);
           }
           else{
-            overlay.div.parentNode.removeChild(overlay.div);
-            overlay.div = null;
+            overlay.el.parentNode.removeChild(overlay.el);
+            overlay.el = null;
           }
         };
 
@@ -590,7 +669,14 @@ if(window.google && window.google.maps){
       };
 
       this.removeOverlay = function(overlay) {
-        overlay.setMap(null);
+        for(var i = 0; i < this.overlays.length; i++) {
+          if(this.overlays[i] === overlay) {
+            this.overlays[i].setMap(null);
+            this.overlays.splice(i, 1);
+
+            break;
+          }
+        }
       };
 
       this.removeOverlays = function() {
@@ -600,12 +686,7 @@ if(window.google && window.google.maps){
         self.overlays = [];
       };
 
-      this.removePolylines = function() {
-        for (var i=0, item; item=self.polylines[i]; i++){
-          item.setMap(null);
-        }
-        self.polylines = [];
-      };
+      // Geometry
 
       this.drawPolyline = function(options) {
         var path = [];
@@ -622,14 +703,31 @@ if(window.google && window.google.maps){
           }
         }
 
-        var polyline = new google.maps.Polyline({
+        var polyline_options = {
           map: this.map,
           path: path,
           strokeColor: options.strokeColor,
           strokeOpacity: options.strokeOpacity,
           strokeWeight: options.strokeWeight,
-          geodesic: options.geodesic
-        });
+          geodesic: options.geodesic,
+          clickable: true,
+          editable: false,
+          visible: true
+        };
+
+        if(options.hasOwnProperty("clickable"))
+          polyline_options.clickable = options.clickable;
+
+        if(options.hasOwnProperty("editable"))
+          polyline_options.editable = options.editable;
+
+        if(options.hasOwnProperty("icons"))
+          polyline_options.icons = options.icons;
+
+        if(options.hasOwnProperty("zIndex"))
+          polyline_options.zIndex = options.zIndex;
+
+        var polyline = new google.maps.Polyline(polyline_options);
 
         var polyline_events = ['click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'rightclick'];
 
@@ -647,6 +745,24 @@ if(window.google && window.google.maps){
         return polyline;
       };
 
+      this.removePolyline = function(polyline) {
+        for(var i = 0; i < this.polylines.length; i++) {
+          if(this.polylines[i] === polyline) {
+            this.polylines[i].setMap(null);
+            this.polylines.splice(i, 1);
+            
+            break;
+          }
+        }
+      };
+
+      this.removePolylines = function() {
+        for (var i=0, item; item=self.polylines[i]; i++){
+          item.setMap(null);
+        }
+        self.polylines = [];
+      };
+
       this.drawCircle = function(options) {
         options =  extend_object({
           map: this.map,
@@ -697,21 +813,30 @@ if(window.google && window.google.maps){
             });
           })(polygon, polygon_events[ev]);
         }
-
+        
         this.polygons.push(polygon);
-
+        
         return polygon;
       };
 
       this.drawPolygon = function(options) {
+        var useGeoJSON = false;
+        if(options.hasOwnProperty("useGeoJSON"))
+          useGeoJSON = options.useGeoJSON;
+
+        delete options.useGeoJSON;
+
         options = extend_object({
           map: this.map
         }, options);
 
+        if(useGeoJSON == false)
+          options.paths = [options.paths.slice(0)];
+
         if(options.paths.length > 0) {
-            if(options.paths[0].length > 0) {
-               options.paths = array_map(options.paths, arrayToLatLng);
-            }
+          if(options.paths[0].length > 0) {
+            options.paths = array_flat(array_map(options.paths, arrayToLatLng, useGeoJSON));
+          }
         }
 
         var polygon = new google.maps.Polygon(options);
@@ -732,7 +857,16 @@ if(window.google && window.google.maps){
         return polygon;
       };
 
-      this.removePolygon = this.removeOverlay;
+      this.removePolygon = function(polygon) {
+        for(var i = 0; i < this.polygons.length; i++) {
+          if(this.polygons[i] === polygon) {
+            this.polygons[i].setMap(null);
+            this.polygons.splice(i, 1);
+            
+            break;
+          }
+        }
+      };
 
       this.removePolygons = function() {
         for (var i=0, item; item=self.polygons[i]; i++){
@@ -741,6 +875,8 @@ if(window.google && window.google.maps){
         self.polygons = [];
       };
 
+      // Fusion Tables
+
       this.getFromFusionTables = function(options) {
         var events = options.events;
 
@@ -770,6 +906,8 @@ if(window.google && window.google.maps){
         return layer;
       };
 
+      // KML
+
       this.getFromKML = function(options) {
         var url = options.url;
         var events = options.events;
@@ -801,7 +939,8 @@ if(window.google && window.google.maps){
         return layer;
       };
 
-      // Services
+      // Routes
+
       var travelMode, unitSystem;
       this.getRoutes = function(options) {
         switch (options.travelMode) {
@@ -873,7 +1012,7 @@ if(window.google && window.google.maps){
 
         if(options.locations.length > 0) {
           if(options.locations[0].length > 0) {
-            options.locations = array_map(options.locations, arrayToLatLng);
+            options.locations = array_flat(array_map([options.locations], arrayToLatLng,  false));
           }
         }
 
@@ -915,7 +1054,8 @@ if(window.google && window.google.maps){
           origin: options.origin,
           destination: options.destination,
           travelMode: options.travelMode,
-          waypoints : options.waypoints,
+          waypoints: options.waypoints,
+          unitSystem: options.unitSystem,
           callback: function(e) {
             if (e.length > 0) {
               self.drawPolyline({
@@ -1031,6 +1171,7 @@ if(window.google && window.google.maps){
       };
 
       // Geofence
+
       this.checkGeofence = function(lat, lng, fence) {
         return fence.containsLatLng(new google.maps.LatLng(lat, lng));
       };
@@ -1046,7 +1187,8 @@ if(window.google && window.google.maps){
         }
       };
 
-      //add layers to the maps
+      // Layers
+
       this.addLayer = function(layerName, options) {
         //var default_layers = ['weather', 'clouds', 'traffic', 'transit', 'bicycling', 'panoramio', 'places'];
         options = options || {};
@@ -1126,18 +1268,19 @@ if(window.google && window.google.maps){
         }
       };
 
-      //remove layers
       this.removeLayer = function(layerName) {
         if(this.singleLayers[layerName] !== undefined) {
            this.singleLayers[layerName].setMap(null);
            delete this.singleLayers[layerName];
         }
       };
+      
+      // Static Maps
 
       this.toImage = function(options) {
         var options = options || {};
         var static_map_options = {};
-        static_map_options['size'] = options['size'] || [this.div.clientWidth, this.div.clientHeight];
+        static_map_options['size'] = options['size'] || [this.el.clientWidth, this.el.clientHeight];
         static_map_options['lat'] = this.getCenter().lat();
         static_map_options['lng'] = this.getCenter().lng();
 
@@ -1163,6 +1306,97 @@ if(window.google && window.google.maps){
         return GMaps.staticMapURL(static_map_options);
       };
 
+      // Map Types
+
+      this.addMapType = function(mapTypeId, options) {
+        if(options.hasOwnProperty("getTileUrl") && typeof(options["getTileUrl"]) == "function") {
+          options.tileSize = options.tileSize || new google.maps.Size(256, 256);
+          
+          var mapType = new google.maps.ImageMapType(options);
+
+          this.map.mapTypes.set(mapTypeId, mapType);
+        }
+        else {
+          throw "'getTileUrl' function required";
+        }
+      };
+
+      this.addOverlayMapType = function(options) {
+        if(options.hasOwnProperty("getTile") && typeof(options["getTile"]) == "function") {
+          var overlayMapTypeIndex = options.index;
+
+          delete options.index;
+
+          this.map.overlayMapTypes.insertAt(overlayMapTypeIndex, options);
+        }
+        else {
+          throw "'getTile' function required";
+        }
+      };
+
+      this.removeOverlayMapType = function(overlayMapTypeIndex) {
+        this.map.overlayMapTypes.removeAt(overlayMapTypeIndex);
+      };
+
+      // Styles
+      
+      this.addStyle = function(options) {       
+        var styledMapType = new google.maps.StyledMapType(options.styles, options.styledMapName);
+        
+        this.map.mapTypes.set(options.mapTypeId, styledMapType);
+      };
+      
+      this.setStyle = function(mapTypeId) {     
+        this.map.setMapTypeId(mapTypeId);
+      };
+
+      // StreetView
+
+      this.createPanorama = function(streetview_options) {
+        if (!streetview_options.hasOwnProperty('lat') || !streetview_options.hasOwnProperty('lng')) {
+          streetview_options.lat = this.getCenter().lat();
+          streetview_options.lng = this.getCenter().lng();
+        }
+
+        this.panorama = GMaps.createPanorama(streetview_options);
+
+        this.map.setStreetView(this.panorama);
+
+        return this.panorama;
+      };
+    };
+
+    GMaps.createPanorama = function(options) {
+      var el = getElementById(options.el, options.context);
+
+      options.position = new google.maps.LatLng(options.lat, options.lng);
+
+      delete options.el;
+      delete options.context;
+      delete options.lat;
+      delete options.lng;
+
+      var streetview_events = ['closeclick', 'links_changed', 'pano_changed', 'position_changed', 'pov_changed', 'resize', 'visible_changed'];
+
+      var streetview_options = extend_object({visible : true}, options);
+
+      for(var i = 0; i < streetview_events.length; i++) {
+        delete streetview_options[streetview_events[i]];
+      }
+
+      var panorama = new google.maps.StreetViewPanorama(el, streetview_options);
+
+      for(var i = 0; i < streetview_events.length; i++) {
+        (function(object, name) {
+          google.maps.event.addListener(object, name, function(){
+            if (options[name]) {
+              options[name].apply(this);
+            }
+          });
+        })(panorama, streetview_events[i]);
+      }
+
+      return panorama;
     };
 
     GMaps.Route = function(options) {
@@ -1206,23 +1440,28 @@ if(window.google && window.google.maps){
 
     // Geolocation (Modern browsers only)
     GMaps.geolocate = function(options) {
+      var complete_callback = options.always || options.complete;
+
       if (navigator.geolocation) {
         navigator.geolocation.getCurrentPosition(function(position) {
           options.success(position);
-          if (options.always) {
-            options.always();
+
+          if (complete_callback) {
+            complete_callback();
           }
         }, function(error) {
           options.error(error);
-          if (options.always) {
-            options.always();
+
+          if (complete_callback) {
+            complete_callback();
           }
         }, options.options);
       }
       else {
         options.not_supported();
-        if (options.always) {
-          options.always();
+
+        if (complete_callback) {
+          complete_callback();
         }
       }
     };
@@ -1427,40 +1666,42 @@ if(window.google && window.google.maps){
       };
     }
 
-    // Polygon containsLatLng - method to determine if a latLng is within a polygon
-    google.maps.Polygon.prototype.containsLatLng = function(latLng) {
-      // Exclude points outside of bounds as there is no way they are in the poly
-      var bounds = this.getBounds();
+    if (!google.maps.Polygon.prototype.containsLatLng) {
+      // Polygon containsLatLng - method to determine if a latLng is within a polygon
+      google.maps.Polygon.prototype.containsLatLng = function(latLng) {
+        // Exclude points outside of bounds as there is no way they are in the poly
+        var bounds = this.getBounds();
 
-      if (bounds !== null && !bounds.contains(latLng)) {
-        return false;
-      }
+        if (bounds !== null && !bounds.contains(latLng)) {
+          return false;
+        }
 
-      // Raycast point in polygon method
-      var inPoly = false;
+        // Raycast point in polygon method
+        var inPoly = false;
 
-      var numPaths = this.getPaths().getLength();
-      for (var p = 0; p < numPaths; p++) {
-        var path = this.getPaths().getAt(p);
-        var numPoints = path.getLength();
-        var j = numPoints - 1;
+        var numPaths = this.getPaths().getLength();
+        for (var p = 0; p < numPaths; p++) {
+          var path = this.getPaths().getAt(p);
+          var numPoints = path.getLength();
+          var j = numPoints - 1;
 
-        for (var i = 0; i < numPoints; i++) {
-          var vertex1 = path.getAt(i);
-          var vertex2 = path.getAt(j);
+          for (var i = 0; i < numPoints; i++) {
+            var vertex1 = path.getAt(i);
+            var vertex2 = path.getAt(j);
 
-          if (vertex1.lng() < latLng.lng() && vertex2.lng() >= latLng.lng() || vertex2.lng() < latLng.lng() && vertex1.lng() >= latLng.lng()) {
-            if (vertex1.lat() + (latLng.lng() - vertex1.lng()) / (vertex2.lng() - vertex1.lng()) * (vertex2.lat() - vertex1.lat()) < latLng.lat()) {
-              inPoly = !inPoly;
+            if (vertex1.lng() < latLng.lng() && vertex2.lng() >= latLng.lng() || vertex2.lng() < latLng.lng() && vertex1.lng() >= latLng.lng()) {
+              if (vertex1.lat() + (latLng.lng() - vertex1.lng()) / (vertex2.lng() - vertex1.lng()) * (vertex2.lat() - vertex1.lat()) < latLng.lat()) {
+                inPoly = !inPoly;
+              }
             }
-          }
 
-          j = i;
+            j = i;
+          }
         }
-      }
 
-      return inPoly;
-    };
+        return inPoly;
+      };
+    }
 
     google.maps.LatLngBounds.prototype.containsLatLng = function(latLng) {
       return this.contains(latLng);
@@ -1477,43 +1718,85 @@ if(window.google && window.google.maps){
     return GMaps;
   }(this));
 
-  var arrayToLatLng = function(coords) {
-    return new google.maps.LatLng(coords[0], coords[1]);
+  var coordsToLatLngs = function(coords, useGeoJSON) {
+    var first_coord = coords[0];
+    var second_coord = coords[1];
+
+    if(useGeoJSON) {
+      first_coord = coords[1];
+      second_coord = coords[0];
+    }
+
+    return new google.maps.LatLng(first_coord, second_coord);
+  };
+
+  var arrayToLatLng = function(coords, useGeoJSON) {
+    for(var i=0; i < coords.length; i++) {
+      if(coords[i].length > 0 && typeof(coords[i][0]) != "number") {
+        coords[i] = arrayToLatLng(coords[i], useGeoJSON);
+      }
+      else {
+        coords[i] = coordsToLatLngs(coords[i], useGeoJSON);
+      }
+    }
+
+    return coords;
   };
 
   var extend_object = function(obj, new_obj) {
     if(obj === new_obj) return obj;
 
-    for(var name in new_obj){
+    for(var name in new_obj) {
       obj[name] = new_obj[name];
     }
 
     return obj;
   };
 
+  var replace_object = function(obj, replace) {
+    if(obj === replace) return obj;
+
+    for(var name in replace) {
+      if(obj[name] != undefined)
+        obj[name] = replace[name];
+    }
+
+    return obj;
+  };
+
   var array_map = function(array, callback) {
+    var original_callback_params = Array.prototype.slice.call(arguments, 2);
+
     if (Array.prototype.map && array.map === Array.prototype.map) {
-      return array.map(callback);
-    } else {
-      var array_return = [];
+      return Array.prototype.map.call(array, function(item) {
+        callback_params = original_callback_params;
+        callback_params.splice(0, 0, item);
 
+        return callback.apply(this, callback_params);
+      });
+    }
+    else {
+      var array_return = [];
       var array_length = array.length;
 
       for(var i = 0; i < array_length; i++) {
-        array_return.push(callback(array[i]));
+        callback_params = original_callback_params;
+        callback_params = callback_params.splice(0, 0, array[i]);
+        array_return.push(callback.apply(this, callback_params));
       }
 
       return array_return;
     }
-  }
-
-}
-
-/*Extension: Styled map*/
-GMaps.prototype.addStyle = function(options){       
-  var styledMapType = new google.maps.StyledMapType(options.styles, options.styledMapName);
-  this.map.mapTypes.set(options.mapTypeId, styledMapType);
-};
-GMaps.prototype.setStyle = function(mapTypeId){     
-  this.map.setMapTypeId(mapTypeId);
-};
+  };
+
+  var array_flat = function(array) {
+    new_array = [];
+
+    for(var i=0; i < array.length; i++) {
+      new_array = new_array.concat(array[i]);
+    }
+
+    return new_array;
+  };
+
+}

data/lib/gmapsjs/version.rb

@@ -1,3 +1,3 @@
 module GmapsJS
-  VERSION = "0.2.13"
+  VERSION = "0.2.30"
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: gmapsjs
 version: !ruby/object:Gem::Version
-  version: 0.2.13
   prerelease: 
+  version: 0.2.30
 platform: ruby
 authors:
 - Alvaro Pereyra
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-24 00:00:00.000000000Z
+date: 2013-01-07 00:00:00.000000000 Z
 dependencies: []
 description: ! 'gmaps.js allows you to use the potential of Google Maps in a simple
   way.
@@ -41,20 +41,20 @@ rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+  none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: ''