gmaps4rails 1.0.2 → 1.1.0

data/app/assets/javascripts/gmaps4rails/gmaps4rails.openlayers.js.coffee

@@ -0,0 +1,210 @@
+#######################################################################################################
+##############################################  Open Layers  ##########################################
+#######################################################################################################
+
+#// http://wiki.openstreetmap.org/wiki/OpenLayers
+#// http://openlayers.org/dev/examples
+#//http://docs.openlayers.org/contents.html
+
+class @Gmaps4RailsOpenlayers extends Gmaps4Rails
+
+  constructor: ->
+    super
+    @map_options = {}
+    @mergeWithDefault "map_options"
+    @markers_conf = {}
+    @mergeWithDefault "markers_conf"
+
+    @openMarkers = null
+    @markersLayer = null
+    @markersControl = null
+
+  #////////////////////////////////////////////////////
+  #/////////////// Basic Objects   ////////////////////
+  #////////////////////////////////////////////////////
+
+  createPoint: (lat, lng)->
+
+  createLatLng: (lat, lng)->
+    return new OpenLayers.LonLat(lng, lat).transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913")) # transform from WGS 1984 to Spherical Mercator Projection
+              
+  createAnchor: (offset)->
+    return null if offset == null
+    return new OpenLayers.Pixel(offset[0], offset[1])
+
+  createSize: (width, height)->
+    return new OpenLayers.Size(width, height)
+
+  createLatLngBounds: ->
+     return new OpenLayers.Bounds()
+  
+  createMap: ->
+    #//todo add customization: kind of map and other map options
+    map = new OpenLayers.Map(@map_options.id)
+    map.addLayer(new OpenLayers.Layer.OSM())
+    map.setCenter(@createLatLng(@map_options.center_latitude, @map_options.center_longitude), #// Center of the map
+                  @map_options.zoom) #// Zoom level
+    return map
+
+  #////////////////////////////////////////////////////
+  #////////////////////// Markers /////////////////////
+  #////////////////////////////////////////////////////
+  #//http://openlayers.org/dev/examples/marker-shadow.html
+  createMarker: (args) ->
+    style_mark = OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default'])
+    style_mark.fillOpacity = 1
+  
+    #//creating markers' dedicated layer 
+    if (@markersLayer == null) 
+      @markersLayer = new OpenLayers.Layer.Vector("Markers", null)
+      @map.addLayer(@markersLayer)
+      #//TODO move?
+      @markersLayer.events.register("featureselected", @markersLayer, @onFeatureSelect)
+      @markersLayer.events.register("featureunselected", @markersLayer, @onFeatureUnselect)
+      @markersControl = new OpenLayers.Control.SelectFeature(@markersLayer)
+      @map.addControl(@markersControl)
+      @markersControl.activate()
+    #//showing default pic if none available
+    if args.marker_picture == ""  
+      #style_mark.graphicWidth = 24
+      style_mark.graphicHeight = 30
+      style_mark.externalGraphic = "http://openlayers.org/dev/img/marker-blue.png"
+    #//creating custom pic
+    else
+      style_mark.graphicWidth    = args.marker_width
+      style_mark.graphicHeight   = args.marker_height
+      style_mark.externalGraphic = args.marker_picture
+      #//adding anchor if any
+      if args.marker_anchor != null 
+        style_mark.graphicXOffset = args.marker_anchor[0]
+        style_mark.graphicYOffset = args.marker_anchor[1]
+      #//adding shadow if any
+      if args.shadow_picture != ""
+        style_mark.backgroundGraphic = args.shadow_picture
+        style_mark.backgroundWidth   = args.shadow_width
+        style_mark.backgroundHeight  = args.shadow_height
+        #//adding shadow's anchor if any
+        if args.shadow_anchor != null
+          style_mark.backgroundXOffset = args.shadow_anchor[0]
+          style_mark.backgroundYOffset = args.shadow_anchor[1]
+      
+    style_mark.graphicTitle = args.title
+    marker = new OpenLayers.Feature.Vector(
+               new OpenLayers.Geometry.Point(args.Lng, args.Lat),
+               null,
+              style_mark)
+    #//changing coordinates so that it actually appears on the map!
+    marker.geometry.transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"))
+    #//adding layer to the map
+    @markersLayer.addFeatures([marker])
+  
+    return marker
+
+  #//clear markers
+  clearMarkers: ->
+    @clearMarkersLayerIfExists()
+    @markersLayer = null
+    @boundsObject = new OpenLayers.Bounds()
+  
+  clearMarkersLayerIfExists: -> 
+    this.map.removeLayer(this.markersLayer) if @markersLayer != null and @map.getLayer(@markersLayer.id) != null
+  
+  extendBoundsWithMarkers: ->
+    for marker in @markers
+      @boundsObject.extend(@createLatLng(marker.lat,marker.lng))        
+
+  #////////////////////////////////////////////////////
+  #/////////////////// Clusterer //////////////////////
+  #////////////////////////////////////////////////////
+  #//too ugly to be considered valid :(
+
+  createClusterer: (markers_array)->
+     options = 
+       pointRadius: "${radius}"
+       fillColor: "#ffcc66"
+       fillOpacity: 0.8
+       strokeColor: "#cc6633"
+       strokeWidth: "${width}"
+       strokeOpacity: 0.8
+     funcs =
+       context:
+         width: (feature) ->
+           return (feature.cluster) ? 2 : 1
+         radius: (feature) ->
+           pix = 2
+           pix = Math.min(feature.attributes.count, 7) + 2 if feature.cluster
+           return pix
+     
+     style = new OpenLayers.Style options, funcs
+   
+     strategy = new OpenLayers.Strategy.Cluster()
+   
+     clusters = new OpenLayers.Layer.Vector "Clusters", 
+       strategies: [strategy]
+       styleMap: new OpenLayers.StyleMap
+         "default": style
+         "select": 
+            fillColor: "#8aeeef"
+            strokeColor: "#32a8a9"
+       
+     @clearMarkersLayerIfExists()
+     @map.addLayer(clusters)
+     clusters.addFeatures(markers_array)
+     return clusters
+   
+   clusterize: ->
+   
+     if @markers_conf.do_clustering == true
+       #//first clear the existing clusterer if any
+       if @markerClusterer != null
+         @clearClusterer()
+       markers_array = new Array
+       for marker in markers
+         markers_array.push(marker.serviceObject)
+       @markerClusterer = @createClusterer markers_array
+   
+   clearClusterer: ->
+     @map.removeLayer @markerClusterer
+
+  #////////////////////////////////////////////////////
+  #/////////////////// INFO WINDOW ////////////////////
+  #////////////////////////////////////////////////////
+
+  #// creates infowindows
+  createInfoWindow: -> (marker_container) ->
+    if marker_container.description?
+      marker_container.serviceObject.infoWindow = marker_container.description
+  
+  onPopupClose: (evt) ->
+    #// 'this' is the popup.
+    @markersControl.unselect @feature
+  
+  onFeatureSelect: (evt) ->
+    feature = evt.feature    
+    popup = new OpenLayers.Popup.FramedCloud("featurePopup",
+                               feature.geometry.getBounds().getCenterLonLat(),
+                               new OpenLayers.Size(300,200),
+                               feature.infoWindow,
+                               null, true, @onPopupClose)
+    feature.popup = popup
+    popup.feature = feature
+    @map.addPopup popup
+
+  onFeatureUnselect: (evt) ->
+    feature = evt.feature
+    if feature.popup
+      #//popup.feature = null;
+      @map.removePopup feature.popup
+      feature.popup.destroy()
+      feature.popup = null
+
+  # #////////////////////////////////////////////////////
+  # #/////////////////// Other methods //////////////////
+  # #////////////////////////////////////////////////////
+ 
+  fitBounds: ->
+    @map.zoomToExtent(@boundsObject, true)
+  
+  centerMapOnUser: ->
+    @map.setCenter @userLocation
+    

data/lib/generators/gmaps4rails/install_generator.rb

@@ -6,12 +6,20 @@ module Gmaps4rails
       desc 'Creates a Gmaps4rails initializer and copies the assets to the public folder.'
 
       def copy_locale
+        if Rails::VERSION::MINOR >= 1
+          copy_file '../../../app/assets/javascripts/gmaps4rails/gmaps4rails.base.js.coffee',       'app/assets/javascripts/gmaps4rails/gmaps4rails.base.js.coffee'
+          copy_file '../../../app/assets/javascripts/gmaps4rails/gmaps4rails.googlemaps.js.coffee', 'app/assets/javascripts/gmaps4rails/gmaps4rails.googlemaps.js.coffee'
+          copy_file '../../../app/assets/javascripts/gmaps4rails/gmaps4rails.openlayers.js.coffee', 'app/assets/javascripts/gmaps4rails/gmaps4rails.openlayers.js.coffee'
+          copy_file '../../../app/assets/javascripts/gmaps4rails/gmaps4rails.bing.js.coffee',       'app/assets/javascripts/gmaps4rails/gmaps4rails.bing.js.coffee'
+          copy_file '../../../app/assets/javascripts/gmaps4rails/gmaps4rails.mapquest.js.coffee',   'app/assets/javascripts/gmaps4rails/gmaps4rails.mapquest.js.coffee'        
+        else
         #I don't copy manifests, kind of useless
-        copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.base.js', 'public/javascripts/gmaps4rails.base.js'
-        copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.googlemaps.js', 'public/javascripts/gmaps4rails.googlemaps.js'
-        copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.bing.js', 'public/javascripts/gmaps4rails.bing.js'
-        copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.openlayers.js', 'public/javascripts/gmaps4rails.openlayers.js'
-        copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.mapquest.js', 'public/javascripts/gmaps4rails.mapquest.js'
+          copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.base.js', 'public/javascripts/gmaps4rails.base.js'
+          copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.googlemaps.js', 'public/javascripts/gmaps4rails.googlemaps.js'
+          copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.bing.js', 'public/javascripts/gmaps4rails.bing.js'
+          copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.openlayers.js', 'public/javascripts/gmaps4rails.openlayers.js'
+          copy_file '../../../public/javascripts/gmaps4rails/gmaps4rails.mapquest.js', 'public/javascripts/gmaps4rails.mapquest.js'
+        end
         copy_file '../../../public/stylesheets/gmaps4rails.css', 'public/stylesheets/gmaps4rails.css'
         copy_file '../../../public/images/marker.png', 'public/images/marker.png'
       end

data/lib/gmaps4rails.rb

@@ -13,9 +13,7 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
        end
        initializer "add asset directories to pipeline" do |app|
          if Rails::VERSION::MINOR >= 1
-           app.config.assets.paths << "#{root}/public/javascripts"
            app.config.assets.paths << "#{root}/public/stylesheets"
-           app.config.assets.paths << "#{root}/public/images"
          else
            app.middleware.use ::ActionDispatch::Static, "#{root}/public"
          end

data/lib/gmaps4rails/base.rb

@@ -205,14 +205,17 @@ module Gmaps4rails
 
     #means we are creating a new map
     if edit_map_with_id == false 
-
       result << "#{map_id} = new #{Gmaps4rails.get_constructor hash[:map_options] }" + ";"
       result << "function #{Gmaps4rails.js_function_name hash }() {"
+      
       #extract map_options
       unless hash[:map_options].nil?
         hash[:map_options].each do |option_k, option_v|
-          if option_k.to_sym == :bounds #particular case
+          case option_k.to_sym 
+          when :bounds #particular case
             result << "#{map_id}.map_options.#{option_k} = #{option_v};"
+          when :class
+          when :container_class
           else
             result << "#{map_id}.map_options.#{option_k} = #{Gmaps4rails.filter option_v};"
           end
@@ -251,12 +254,14 @@ module Gmaps4rails
         result << "#{map_id}.create_#{category}();"
       end 
     end
+    result << "#{map_id}.adjustMapToBounds();"
     result << "#{map_id}.callback();"
     
     if edit_map_with_id == false 
       result << "};"
       if hash[:last_map].nil? || hash[:last_map] == true
-        result << "window.onload = Gmaps.loadMaps;"
+        result << "window.onload = function() { Gmaps.loadMaps(); };"
+        #result << "window.onload = load_map;"
       end
     end
     

data/public/javascripts/gmaps4rails/gmaps4rails.base.js

@@ -1,537 +1,461 @@
-var Gmaps = {};
-
-Gmaps.loadMaps = function(){
-  //loop through all variable names.
-  // there should only be maps inside so it trigger their load function
-  for (var attrname in Gmaps) {
-    if (attrname !== "loadMaps"){
-      window["load_" + attrname]();
+(function() {
+  var Gmaps;
+  Gmaps = {};
+  Gmaps.loadMaps = function() {
+    var key, value, _results;
+    _results = [];
+    for (key in Gmaps) {
+      value = Gmaps[key];
+      _results.push(key !== "loadMaps" ? window["load_" + key]() : void 0);
     }
-  }
-}
-
-function Gmaps4Rails() {
-
-  //map config
-  this.map =  null;                  // contains the map we're working on
-  this.visibleInfoWindow = null;    //contains the current opened infowindow
-  this.userLocation = null;         //contains user's location if geolocalization was performed and successful
-
-  //empty slots
-  this.geolocationFailure = function() { return false;}  //triggered when geolocation fails. If customized, must be like= function(navigator_handles_geolocation){} where 'navigator_handles_geolocation' is a boolean
-  this.callback =           function() { return false;}  //to let user set a custom callback function
-  this.customClusterer =    function() { return null;}   //to let user set custom clusterer pictures
-  this.infobox =            function() { return null;}   //to let user use custom infoboxes
-
-  this.default_map_options = {
-    id: 'map',
-    draggable: true,
-    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: 7,
-    maxZoom: null,
-    minZoom: null,
-    auto_adjust : true,     // 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": }]    
+    return _results;
   };
-  
-  this.default_markers_conf = {
-    // Marker config
-    title: "",
-    // MarkerImage config
-    picture : "",
-    width: 22,
-    length: 32,
-    draggable: false,         // how to modify: <%= gmaps( "markers" => { "data" => @object.to_gmaps4rails, "options" => { "draggable" => true }}) %>
-    //clustering config
-    do_clustering: true,      // do clustering if set to true
-    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
-    offset: 0                 //used when adding_markers to an existing map. Because new markers are concated with previous one, offset is here to prevent the existing from being re-created.
-  };
-  
-  //Stored variables
-  this.markers = [];            // contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "serviceObject": google_marker}
-  this.boundsObject = null;     // contains current bounds from markers, polylines etc...
-  this.polygons = [];           // contains raw data, array of arrays (first element could be a hash containing options)
-  this.polylines = [];          // contains raw data, array of arrays (first element could be a hash containing options)
-  this.circles = [];            // contains raw data, array of hash
-  this.markerClusterer = null;  // contains all marker clusterers
-  this.markerImages = [];
-  
-  //initializes the map
-  this.initialize = function() {
-
-    this.map = this.createMap();
-
-    if (this.map_options.detect_location === true || this.map_options.center_on_user === true) { 
-      this.findUserLocation(this);
-    }    
-    //resets sidebar if needed
-    this.resetSidebarContent();
-  }
-
- // this.initialize();
-
-  this.findUserLocation = function(map_object) {
-    if(navigator.geolocation) {
-      //try to retrieve user's position
-      navigator.geolocation.getCurrentPosition(function(position) {
-        //saves the position in the userLocation variable
-        map_object.userLocation = map_object.createLatLng(position.coords.latitude, position.coords.longitude);
-        //change map's center to focus on user's geoloc if asked
-        if(map_object.map_options.center_on_user === true) {
-          map_object.centerMapOnUser();
-        }
-      },
-      function() {
-        //failure, but the navigator handles geolocation
-        map_object.geolocationFailure(true);
-      });
+  window.Gmaps = Gmaps;
+  this.Gmaps4Rails = (function() {
+    function Gmaps4Rails() {
+      this.map = null;
+      this.visibleInfoWindow = null;
+      this.userLocation = null;
+      this.geolocationFailure = function() {
+        return false;
+      };
+      this.callback = function() {
+        return false;
+      };
+      this.customClusterer = function() {
+        return false;
+      };
+      this.infobox = function() {
+        return false;
+      };
+      this.default_map_options = {
+        id: 'map',
+        draggable: true,
+        detect_location: false,
+        center_on_user: false,
+        center_latitude: 0,
+        center_longitude: 0,
+        zoom: 7,
+        maxZoom: null,
+        minZoom: null,
+        auto_adjust: true,
+        auto_zoom: true,
+        bounds: []
+      };
+      this.default_markers_conf = {
+        title: "",
+        picture: "",
+        width: 22,
+        length: 32,
+        draggable: false,
+        do_clustering: true,
+        randomize: false,
+        max_random_distance: 100,
+        list_container: null,
+        offset: 0
+      };
+      this.markers = [];
+      this.boundsObject = null;
+      this.polygons = [];
+      this.polylines = [];
+      this.circles = [];
+      this.markerClusterer = null;
+      this.markerImages = [];
     }
-    else {
-      //failure but the navigator doesn't handle geolocation
-      map_object.geolocationFailure(false);
-    }
-  }
-
-  ////////////////////////////////////////////////////
-  //////////////////// DIRECTIONS ////////////////////
-  ////////////////////////////////////////////////////
-
-  this.create_direction = function(){
-    var directionsDisplay = new google.maps.DirectionsRenderer();
-    var directionsService = new google.maps.DirectionsService();
-
-    directionsDisplay.setMap(this.map);
-    //display panel only if required
-    if (this.direction_conf.display_panel) {	directionsDisplay.setPanel(document.getElementById(this.direction_conf.panel_id)); }
-    directionsDisplay.setOptions({
-      suppressMarkers:     false,
-      suppressInfoWindows: false,
-      suppressPolylines:   false
-    });
-    var request = {
-      origin:             this.direction_conf.origin, 
-      destination:        this.direction_conf.destination,
-      waypoints:          this.direction_conf.waypoints,
-      optimizeWaypoints:  this.direction_conf.optimizeWaypoints,
-      unitSystem:         google.maps.DirectionsUnitSystem[this.direction_conf.unitSystem],
-      avoidHighways:      this.direction_conf.avoidHighways,
-      avoidTolls:         this.direction_conf.avoidTolls,
-      region:             this.direction_conf.region, 
-      travelMode:         google.maps.DirectionsTravelMode[this.direction_conf.travelMode],
-      language:           "en"
+    Gmaps4Rails.prototype.initialize = function() {
+      this.map = this.createMap();
+      if (this.map_options.detect_location === true || this.map_options.center_on_user === true) {
+        this.findUserLocation(this);
+      }
+      return this.resetSidebarContent();
     };
-    directionsService.route(request, function(response, status) {
-      if (status == google.maps.DirectionsStatus.OK) {
-        directionsDisplay.setDirections(response);
+    Gmaps4Rails.prototype.findUserLocation = function(map_object) {
+      var positionFailure, positionSuccessful;
+      if (navigator.geolocation) {
+        positionSuccessful = function(position) {
+          map_object.userLocation = map_object.createLatLng(position.coords.latitude, position.coords.longitude);
+          if (map_object.map_options.center_on_user === true) {
+            return map_object.centerMapOnUser();
+          }
+        };
+        positionFailure = function() {
+          return map_object.geolocationFailure(true);
+        };
+        return navigator.geolocation.getCurrentPosition(positionSuccessful, positionFailure);
+      } else {
+        return map_object.geolocationFailure(false);
       }
-    });
-  }
-
-  ////////////////////////////////////////////////////
-  ///////////////////// CIRCLES //////////////////////
-  ////////////////////////////////////////////////////
-
-  //Loops through all circles
-  //Loops through all circles and draws them
-  this.create_circles = function() {
-    for (var i = 0; i < this.circles.length; ++i) {
-      //by convention, default style configuration could be integrated in the first element
-      this.create_circle(this.circles[i]);
-    }
-  }
-
-  this.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.lat) && this.exists(circle.lng)) {
-      // 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:        this.createLatLng(circle.lat, circle.lng),
-        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
+    };
+    Gmaps4Rails.prototype.create_direction = function() {
+      var directionsDisplay, directionsService, request;
+      directionsDisplay = new google.maps.DirectionsRenderer();
+      directionsService = new google.maps.DirectionsService();
+      directionsDisplay.setMap(this.map);
+      if (this.direction_conf.display_panel) {
+        directionsDisplay.setPanel(document.getElementById(this.direction_conf.panel_id));
+      }
+      directionsDisplay.setOptions({
+        suppressMarkers: false,
+        suppressInfoWindows: false,
+        suppressPolylines: false
       });
-      circle.serviceObject = newCircle;
-      newCircle.setMap(this.map);
-    }
-  }
-
-  // clear circles
-  this.clear_circles = function() {
-    for (var i = 0; i <  this.circles.length; ++i) {
-      this.clear_circle(this.circles[i]);
-    }
-  }
-
-  this.clear_circle = function(circle) {
-    circle.serviceObject.setMap(null);
-  }
-
-  this.hide_circles = function() {
-    for (var i = 0; i <  this.circles.length; ++i) {
-      this.hide_circle(this.circles[i]);
-    }
-  }
-
-  this.hide_circle = function(circle) {
-    circle.serviceObject.setMap(null);
-  }
-
-  this.show_circles = function() {
-    for (var i = 0; i <  this.circles.length; ++i) {
-      this.show_circle(this.circles[i]);
-    }
-  }
-
-  this.show_circle = function(circle) {
-    circle.serviceObject.setMap(this.map);
-  }
-
-  ////////////////////////////////////////////////////
-  ///////////////////// POLYGONS /////////////////////
-  ////////////////////////////////////////////////////
-
-  //polygons is an array of arrays. It loops.
-  this.create_polygons = function(){
-    for (var i = 0; i < this.polygons.length; ++i) {
-      this.create_polygon(i);
-    }
-  }
-
-  //creates a single polygon, triggered by create_polygons
-  this.create_polygon = function(i){
-    var polygon_coordinates = [];
-    var strokeColor;   
-    var strokeOpacity; 
-    var strokeWeight;  
-    var fillColor;  
-    var fillOpacity;
-    //Polygon points are in an Array, that's why looping is necessary
-    for (var j = 0; j < this.polygons[i].length; ++j) {
-      var latlng = this.createLatLng(this.polygons[i][j].lat, this.polygons[i][j].lng);
-      polygon_coordinates.push(latlng);
-      //first element of an Array could contain specific configuration for this particular polygon. If no config given, use default
-      if (j===0) {
-        strokeColor   = this.polygons[i][j].strokeColor   || this.polygons_conf.strokeColor;
-        strokeOpacity = this.polygons[i][j].strokeOpacity || this.polygons_conf.strokeOpacity;
-        strokeWeight  = this.polygons[i][j].strokeWeight  || this.polygons_conf.strokeWeight;
-        fillColor     = this.polygons[i][j].fillColor     || this.polygons_conf.fillColor;
-        fillOpacity   = this.polygons[i][j].fillOpacity   || this.polygons_conf.fillOpacity;
+      request = {
+        origin: this.direction_conf.origin,
+        destination: this.direction_conf.destination,
+        waypoints: this.direction_conf.waypoints,
+        optimizeWaypoints: this.direction_conf.optimizeWaypoints,
+        unitSystem: google.maps.DirectionsUnitSystem[this.direction_conf.unitSystem],
+        avoidHighways: this.direction_conf.avoidHighways,
+        avoidTolls: this.direction_conf.avoidTolls,
+        region: this.direction_conf.region,
+        travelMode: google.maps.DirectionsTravelMode[this.direction_conf.travelMode],
+        language: "en"
+      };
+      return directionsService.route(request, function(response, status) {
+        if (status === google.maps.DirectionsStatus.OK) {
+          return directionsDisplay.setDirections(response);
+        }
+      });
+    };
+    Gmaps4Rails.prototype.create_circles = function() {
+      var circle, _i, _len, _ref, _results;
+      _ref = this.circles;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        circle = _ref[_i];
+        _results.push(this.create_circle(circle));
       }
-    }
-
-    // Construct the polygon
-    var new_poly = new google.maps.Polygon({
-      paths:          polygon_coordinates,
-      strokeColor:    strokeColor,
-      strokeOpacity:  strokeOpacity,
-      strokeWeight:   strokeWeight,
-      fillColor:      fillColor,
-      fillOpacity:    fillOpacity,
-      clickable:      false
-    });
-    //save polygon in list
-    this.polygons[i].serviceObject = new_poly;
-    new_poly.setMap(this.map);
-  }
-
-  ////////////////////////////////////////////////////
-  /////////////////// POLYLINES //////////////////////
-  ////////////////////////////////////////////////////
-
-  //polylines is an array of arrays. It loops.
-  this.create_polylines = function(){
-    for (var i = 0; i < this.polylines.length; ++i) {
-      this.create_polyline(i);
-    }
-  }
-
-  //creates a single polyline, triggered by create_polylines
-  this.create_polyline = function(i) {
-    var polyline_coordinates = [];
-    var strokeColor;
-    var strokeOpacity;
-    var strokeWeight;
-
-    //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)) {
-        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) {
-          polyline_coordinates.push(decoded_array[k]);
-          polyline_coordinates.push(decoded_array[k]);
+      return _results;
+    };
+    Gmaps4Rails.prototype.create_circle = function(circle) {
+      var newCircle;
+      if (circle === this.circles[0]) {
+        if (circle.strokeColor != null) {
+          this.circles_conf.strokeColor = circle.strokeColor;
         }
+        if (circle.strokeOpacity != null) {
+          this.circles_conf.strokeOpacity = circle.strokeOpacity;
+        }
+        if (circle.strokeWeight != null) {
+          this.circles_conf.strokeWeight = circle.strokeWeight;
+        }
+        if (circle.fillColor != null) {
+          this.circles_conf.fillColor = circle.fillColor;
+        }
+        if (circle.fillOpacity != null) {
+          this.circles_conf.fillOpacity = circle.fillOpacity;
+        }
+      }
+      if ((circle.lat != null) && (circle.lng != null)) {
+        newCircle = new google.maps.Circle({
+          center: this.createLatLng(circle.lat, circle.lng),
+          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.serviceObject = newCircle;
+        return newCircle.setMap(this.map);
+      }
+    };
+    Gmaps4Rails.prototype.clear_circles = function() {
+      var circle, _i, _len, _ref, _results;
+      _ref = this.circles;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        circle = _ref[_i];
+        _results.push(this.clear_circle(circle));
       }
-      //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) {
-          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;
+      return _results;
+    };
+    Gmaps4Rails.prototype.clear_circle = function(circle) {
+      return circle.serviceObject.setMap(null);
+    };
+    Gmaps4Rails.prototype.hide_circles = function() {
+      var circle, _i, _len, _ref, _results;
+      _ref = this.circles;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        circle = _ref[_i];
+        _results.push(this.hide_circle(circle));
+      }
+      return _results;
+    };
+    Gmaps4Rails.prototype.hide_circle = function(circle) {
+      return circle.serviceObject.setMap(null);
+    };
+    Gmaps4Rails.prototype.show_circles = function() {
+      var circle, _i, _len, _ref, _results;
+      _ref = this.circles;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        circle = _ref[_i];
+        _results.push(this.show_circle(this.circle));
+      }
+      return _results;
+    };
+    Gmaps4Rails.prototype.show_circle = function(circle) {
+      return circle.serviceObject.setMap(this.map);
+    };
+    Gmaps4Rails.prototype.create_polygons = function() {
+      var polygon, _i, _len, _ref, _results;
+      _ref = this.polygons;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        polygon = _ref[_i];
+        _results.push(this.create_polygon(polygon));
+      }
+      return _results;
+    };
+    Gmaps4Rails.prototype.create_polygon = function(polygon) {
+      var fillColor, fillOpacity, latlng, new_poly, point, polygon_coordinates, strokeColor, strokeOpacity, strokeWeight, _i, _len;
+      polygon_coordinates = [];
+      for (_i = 0, _len = polygon.length; _i < _len; _i++) {
+        point = polygon[_i];
+        latlng = this.createLatLng(point.lat, point.lng);
+        polygon_coordinates.push(latlng);
+        if (point === polygon[0]) {
+          strokeColor = this.polygons[i][j].strokeColor || this.polygons_conf.strokeColor;
+          strokeOpacity = this.polygons[i][j].strokeOpacity || this.polygons_conf.strokeOpacity;
+          strokeWeight = this.polygons[i][j].strokeWeight || this.polygons_conf.strokeWeight;
+          fillColor = this.polygons[i][j].fillColor || this.polygons_conf.fillColor;
+          fillOpacity = this.polygons[i][j].fillOpacity || this.polygons_conf.fillOpacity;
         }
-        //add latlng if positions provided
-        if (this.exists(this.polylines[i][j].lat) && this.exists(this.polylines[i][j].lng)) {	
-          var latlng = this.createLatLng(this.polylines[i][j].lat, this.polylines[i][j].lng);
-          polyline_coordinates.push(latlng);
+      }
+      new_poly = new google.maps.Polygon({
+        paths: polygon_coordinates,
+        strokeColor: strokeColor,
+        strokeOpacity: strokeOpacity,
+        strokeWeight: strokeWeight,
+        fillColor: fillColor,
+        fillOpacity: fillOpacity,
+        clickable: false
+      });
+      polygon.serviceObject = new_poly;
+      return new_poly.setMap(this.map);
+    };
+    Gmaps4Rails.prototype.create_polylines = function() {
+      var polyline, _i, _len, _ref, _results;
+      _ref = this.polylines;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        polyline = _ref[_i];
+        _results.push(this.create_polyline(polyline));
+      }
+      return _results;
+    };
+    Gmaps4Rails.prototype.create_polyline = function(polyline) {
+      var decoded_array, element, latlng, new_poly, point, polyline_coordinates, strokeColor, strokeOpacity, strokeWeight, _i, _j, _len, _len2, _ref;
+      polyline_coordinates = [];
+      for (_i = 0, _len = polyline.length; _i < _len; _i++) {
+        element = polyline[_i];
+        if (element.coded_array != null) {
+          decoded_array = new google.maps.geometry.encoding.decodePath(element.coded_array);
+          _ref = decoded_array.length;
+          for (_j = 0, _len2 = _ref.length; _j < _len2; _j++) {
+            point = _ref[_j];
+            polyline_coordinates.push(point);
+            polyline_coordinates.push(point);
+          }
+        } else {
+          if (element === polyline[0]) {
+            strokeColor = element.strokeColor || this.polylines_conf.strokeColor;
+            strokeOpacity = element.strokeOpacity || this.polylines_conf.strokeOpacity;
+            strokeWeight = element.strokeWeight || this.polylines_conf.strokeWeight;
+          }
+          if ((element.lat != null) && (element.lng != null)) {
+            latlng = this.createLatLng(element.lat, element.lng);
+            polyline_coordinates.push(latlng);
+          }
         }
       }
-    }
-    // Construct the polyline		
-    var new_poly = new google.maps.Polyline({
-      path:         polyline_coordinates,
-      strokeColor:  strokeColor,
-      strokeOpacity: strokeOpacity,
-      strokeWeight: strokeWeight,
-      clickable:     false
-    });
-    //save polyline
-    this.polylines[i].serviceObject = new_poly;
-    new_poly.setMap(this.map);
-  }
-
-  ////////////////////////////////////////////////////
-  ///////////////////// MARKERS //////////////////////
-  //////////////////tests coded///////////////////////
-
-  //creates, clusterizes and adjusts map 
-  this.create_markers = function() {
-    this.createServiceMarkersFromMarkers();
-    this.clusterize();
-    this.adjustMapToBounds();
-  }
-
-  //create google.maps Markers from data provided by user
-  this.createServiceMarkersFromMarkers = function() {
-    for (var i = this.markers_conf.offset; i < this.markers.length; ++i) {
-        //extract options, test if value passed or use default
-        var Lat = this.markers[i].lat;
-        var Lng = this.markers[i].lng;
-
-        //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];
+      new_poly = new google.maps.Polyline({
+        path: polyline_coordinates,
+        strokeColor: strokeColor,
+        strokeOpacity: strokeOpacity,
+        strokeWeight: strokeWeight,
+        clickable: false
+      });
+      polyline.serviceObject = new_poly;
+      return new_poly.setMap(this.map);
+    };
+    Gmaps4Rails.prototype.create_markers = function() {
+      this.createServiceMarkersFromMarkers();
+      return this.clusterize();
+    };
+    Gmaps4Rails.prototype.createServiceMarkersFromMarkers = function() {
+      var Lat, LatLng, Lng, index, _ref, _ref2;
+      for (index = _ref = this.markers_conf.offset, _ref2 = this.markers.length - 1; _ref <= _ref2 ? index <= _ref2 : index >= _ref2; _ref <= _ref2 ? index++ : index--) {
+        Lat = this.markers[index].lat;
+        Lng = this.markers[index].lng;
+        if (this.markers_conf.randomize) {
+          LatLng = this.randomize(Lat, Lng);
+          Lat = LatLng[0];
+          Lng = LatLng[1];
         }
-        //save object
-        this.markers[i].serviceObject = this.createMarker({
-          "marker_picture":   this.exists(this.markers[i].picture)  ? this.markers[i].picture : this.markers_conf.picture,
-          "marker_width":     this.exists(this.markers[i].width)    ? this.markers[i].width   : this.markers_conf.width,
-          "marker_height":    this.exists(this.markers[i].height)   ? this.markers[i].height  : this.markers_conf.length,
-          "marker_title":     this.exists(this.markers[i].title)    ? this.markers[i].title   : null,
-          "marker_anchor":    this.exists(this.markers[i].marker_anchor)  ? this.markers[i].marker_anchor  : null,
-          "shadow_anchor":    this.exists(this.markers[i].shadow_anchor)  ? this.markers[i].shadow_anchor  : null,
-          "shadow_picture":   this.exists(this.markers[i].shadow_picture) ? this.markers[i].shadow_picture : null,
-          "shadow_width":     this.exists(this.markers[i].shadow_width)   ? this.markers[i].shadow_width   : null,
-          "shadow_height":    this.exists(this.markers[i].shadow_height)  ? this.markers[i].shadow_height  : null,
-          "marker_draggable": this.exists(this.markers[i].draggable)      ? this.markers[i].draggable      : this.markers_conf.draggable,
-          "rich_marker":      this.exists(this.markers[i].rich_marker)    ? this.markers[i].rich_marker    : null,
-          "Lat":              Lat,
-          "Lng":              Lng,
-          "index":            i
+        this.markers[index].serviceObject = this.createMarker({
+          "marker_picture": this.markers[index].picture ? this.markers[index].picture : this.markers_conf.picture,
+          "marker_width": this.markers[index].width ? this.markers[index].width : this.markers_conf.width,
+          "marker_height": this.markers[index].height ? this.markers[index].height : this.markers_conf.length,
+          "marker_title": this.markers[index].title ? this.markers[index].title : null,
+          "marker_anchor": this.markers[index].marker_anchor ? this.markers[index].marker_anchor : null,
+          "shadow_anchor": this.markers[index].shadow_anchor ? this.markers[index].shadow_anchor : null,
+          "shadow_picture": this.markers[index].shadow_picture ? this.markers[index].shadow_picture : null,
+          "shadow_width": this.markers[index].shadow_width ? this.markers[index].shadow_width : null,
+          "shadow_height": this.markers[index].shadow_height ? this.markers[index].shadow_height : null,
+          "marker_draggable": this.markers[index].draggable ? this.markers[index].draggable : this.markers_conf.draggable,
+          "rich_marker": this.markers[index].rich_marker ? this.markers[index].rich_marker : null,
+          "Lat": Lat,
+          "Lng": Lng,
+          "index": index
         });
-        //add infowindowstuff if enabled
-        this.createInfoWindow(this.markers[i]);
-        //create sidebar if enabled
-        this.createSidebar(this.markers[i]);
-    }
-    this.markers_conf.offset = this.markers.length;
-  }
-
-
-  // creates Image Anchor Position or return null if nothing passed	
-  this.createImageAnchorPosition = function(anchorLocation) {
-    if (anchorLocation === null)
-    { return null; }
-    else
-    { return this.createPoint(anchorLocation[0], anchorLocation[1]); }
-  }
-
-  // replace old markers with new markers on an existing map
-  this.replaceMarkers = function(new_markers){
-    this.clearMarkers();
-    //reset previous markers
-    this.markers = new Array;
-    //reset current bounds
-    this.boundsObject = this.createLatLngBounds();
-    //reset sidebar content if exists
-    this.resetSidebarContent();
-    //add new markers
-    this.addMarkers(new_markers);
-  }
-
-  //add new markers to on an existing map
-  this.addMarkers = function(new_markers){
-    //update the list of markers to take into account
-    this.markers = this.markers.concat(new_markers);
-    //put markers on the map
-    this.create_markers();
-  }  
-
-  ////////////////////////////////////////////////////
-  ///////////////////// SIDEBAR //////////////////////
-  ////////////////////////////////////////////////////
-
-  //creates sidebar
-  this.createSidebar = function(marker_container){
-    if (this.markers_conf.list_container)
-    {
-      var ul = document.getElementById(this.markers_conf.list_container);
-      var li = document.createElement('li');
-      var aSel = document.createElement('a');
-      aSel.href = 'javascript:void(0);';
-      var html = this.exists(marker_container.sidebar) ? marker_container.sidebar : "Marker";
-      aSel.innerHTML = html;
-      aSel.onclick = this.sidebar_element_handler(marker_container.serviceObject, 'click');
-      li.appendChild(aSel);
-      ul.appendChild(li);
-    }
-  }
-
-  //moves map to marker clicked + open infowindow
-  this.sidebar_element_handler = function(marker, eventType) {
-    return function() {
-      this.map.panTo(marker.position);
-      google.maps.event.trigger(marker, eventType);
+        this.createInfoWindow(this.markers[index]);
+        this.createSidebar(this.markers[index]);
+      }
+      return this.markers_conf.offset = this.markers.length;
     };
-  }
-
-  this.resetSidebarContent = function(){
-    if (this.markers_conf.list_container !== null ){
-      var ul = document.getElementById(this.markers_conf.list_container);
-      ul.innerHTML = "";
-    }
-  }
-
-  ////////////////////////////////////////////////////
-  ////////////////// MISCELLANEOUS ///////////////////
-  ////////////////////////////////////////////////////
-
-  //to make the map fit the different LatLng points
-  this.adjustMapToBounds = function() {
-
-    //FIRST_STEP: retrieve all bounds
-    //create the bounds object only if necessary
-    if (this.map_options.auto_adjust || this.map_options.bounds !== null) {
+    Gmaps4Rails.prototype.createImageAnchorPosition = function(anchorLocation) {
+      if (anchorLocation === null) {
+        return null;
+      } else {
+        return this.createPoint(anchorLocation[0], anchorLocation[1]);
+      }
+    };
+    Gmaps4Rails.prototype.replaceMarkers = function(new_markers) {
+      this.clearMarkers();
+      this.markers = new Array;
       this.boundsObject = this.createLatLngBounds();
-    }
-
-    //if autodjust is true, must get bounds from markers polylines etc...
-    if (this.map_options.auto_adjust) {
-      //from markers
-      this.extendBoundsWithMarkers();
-      //from polylines:
-      for (var i = 0; i < this.polylines.length; ++i) {        
-        var polyline_points = this.polylines[i].serviceObject.latLngs.getArray()[0].getArray();
-        for (var j = 0; j < polyline_points.length; ++j) {
-         this.boundsObject.extend(polyline_points[j]);
+      this.resetSidebarContent();
+      return this.addMarkers(new_markers);
+    };
+    Gmaps4Rails.prototype.addMarkers = function(new_markers) {
+      this.markers = this.markers.concat(new_markers);
+      this.create_markers();
+      return this.adjustMapToBounds();
+    };
+    Gmaps4Rails.prototype.createSidebar = function(marker_container) {
+      var aSel, currentMap, html, li, ul;
+      if (this.markers_conf.list_container) {
+        ul = document.getElementById(this.markers_conf.list_container);
+        li = document.createElement('li');
+        aSel = document.createElement('a');
+        aSel.href = 'javascript:void(0);';
+        html = marker_container.sidebar != null ? marker_container.sidebar : "Marker";
+        aSel.innerHTML = html;
+        currentMap = this;
+        aSel.onclick = this.sidebar_element_handler(currentMap, marker_container.serviceObject, 'click');
+        li.appendChild(aSel);
+        return ul.appendChild(li);
+      }
+    };
+    Gmaps4Rails.prototype.sidebar_element_handler = function(currentMap, marker, eventType) {
+      return function() {
+        currentMap.map.panTo(marker.position);
+        return google.maps.event.trigger(marker, eventType);
+      };
+    };
+    Gmaps4Rails.prototype.resetSidebarContent = function() {
+      var ul;
+      if (this.markers_conf.list_container !== null) {
+        ul = document.getElementById(this.markers_conf.list_container);
+        return ul.innerHTML = "";
+      }
+    };
+    Gmaps4Rails.prototype.adjustMapToBounds = function() {
+      var bound, circle, map_center, point, polygon, polygon_points, polyline, polyline_points, _i, _j, _k, _l, _len, _len2, _len3, _len4, _len5, _len6, _m, _n, _ref, _ref2, _ref3, _ref4;
+      if (this.map_options.auto_adjust || this.map_options.bounds !== null) {
+        this.boundsObject = this.createLatLngBounds();
+      }
+      if (this.map_options.auto_adjust) {
+        this.extendBoundsWithMarkers();
+        _ref = this.polylines;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          polyline = _ref[_i];
+          polyline_points = polyline.serviceObject.latLngs.getArray()[0].getArray();
+          for (_j = 0, _len2 = polyline.length; _j < _len2; _j++) {
+            point = polyline[_j];
+            this.boundsObject.extend(point);
+          }
+        }
+        _ref2 = this.polygons;
+        for (_k = 0, _len3 = _ref2.length; _k < _len3; _k++) {
+          polygon = _ref2[_k];
+          polygon_points = polygon.serviceObject.latLngs.getArray()[0].getArray();
+          for (_l = 0, _len4 = polygon.length; _l < _len4; _l++) {
+            point = polygon[_l];
+            this.boundsObject.extend(point);
+          }
+        }
+        _ref3 = this.circles;
+        for (_m = 0, _len5 = _ref3.length; _m < _len5; _m++) {
+          circle = _ref3[_m];
+          this.boundsObject.extend(circle.serviceObject.getBounds().getNorthEast());
+          this.boundsObject.extend(circle.serviceObject.getBounds().getSouthWest());
         }
       }
-      //from polygons:
-      for (var i = 0; i < this.polygons.length; ++i) {
-        var polygon_points = this.polygons[i].serviceObject.latLngs.getArray()[0].getArray();
-        for (var j = 0; j < polygon_points.length; ++j) {
-          this.boundsObject.extend(polygon_points[j]);
+      _ref4 = this.map_options.bounds;
+      for (_n = 0, _len6 = _ref4.length; _n < _len6; _n++) {
+        bound = _ref4[_n];
+        bound = this.createLatLng(bound.lat, bound.lng);
+        this.boundsObject.extend(bound);
+      }
+      if (this.map_options.auto_adjust || this.map_options.bounds.length > 0) {
+        if (!this.map_options.auto_zoom) {
+          map_center = this.boundsObject.getCenter();
+          this.map_options.center_latitude = map_center.lat();
+          this.map_options.center_longitude = map_center.lng();
+          return this.map.setCenter(map_center);
+        } else {
+          return this.fitBounds();
         }
       }
-      //from circles
-      for (var i = 0; i <  this.circles.length; ++i) {
-        this.boundsObject.extend(this.circles[i].serviceObject.getBounds().getNorthEast());
-        this.boundsObject.extend(this.circles[i].serviceObject.getBounds().getSouthWest());
-      }		
-    }
-    //in every case, I've to take into account the bounds set up by the user	
-    for (var i = 0; i < this.map_options.bounds.length; ++i) {
-      //create points from bounds provided
-      //TODO:only works with google maps
-      var bound = this.createLatLng(this.map_options.bounds[i].lat, this.map_options.bounds[i].lng);
-      this.boundsObject.extend(bound);
-    }
-
-    //SECOND_STEP: ajust the map to the bounds
-    if (this.map_options.auto_adjust || this.map_options.bounds.length > 0) {
-
-      //if autozoom is false, take user info into account
-      if(!this.map_options.auto_zoom) {
-        var map_center = this.boundsObject.getCenter();
-        this.map_options.center_latitude  = map_center.lat();
-        this.map_options.center_longitude = map_center.lng();
-        this.map.setCenter(map_center);
+    };
+    Gmaps4Rails.prototype.create_kml = function() {
+      var kml, _i, _len, _ref, _results;
+      _ref = this.kml;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        kml = _ref[_i];
+        _results.push(kml.serviceObject = this.createKmlLayer(kml));
       }
-      else {
-        this.fitBounds();
+      return _results;
+    };
+    Gmaps4Rails.prototype.exists = function(var_name) {
+      return var_name !== "" && typeof var_name !== "undefined";
+    };
+    Gmaps4Rails.prototype.randomize = function(Lat0, Lng0) {
+      var Lat, Lng, dx, dy;
+      dx = this.markers_conf.max_random_distance * this.random();
+      dy = this.markers_conf.max_random_distance * this.random();
+      Lat = parseFloat(Lat0) + (180 / Math.PI) * (dy / 6378137);
+      Lng = parseFloat(Lng0) + (90 / Math.PI) * (dx / 6378137) / Math.cos(Lat0);
+      return [Lat, Lng];
+    };
+    Gmaps4Rails.prototype.mergeObjectWithDefault = function(object1, object2) {
+      var copy_object1, key, value;
+      copy_object1 = object1;
+      for (key in object2) {
+        value = object2[key];
+        if (copy_object1[key] == null) {
+          copy_object1[key] = value;
+        }
       }
-    }
-  }
-  
-  ////////////////////////////////////////////////////
-  /////////////////        KML      //////////////////
-  ////////////////////////////////////////////////////
-  
-  this.create_kml = function(){
-    for (var i = 0; i <  this.kml.length; ++i) {
-      this.kml[i].serviceObject = this.createKmlLayer(this.kml[i]);
-    }
-  }
-
-
-  ////////////////////////////////////////////////////
-  ///////////////// Basic functions //////////////////
-  ///////////////////tests coded//////////////////////
-
-  //basic function to check existence of a variable
-  this.exists = function(var_name) {
-    return (var_name	!== "" && typeof var_name !== "undefined");
-  }
-
-  //randomize
-  this.randomize = function(Lat0, Lng0) {
-    //distance in meters between 0 and max_random_distance (positive or negative)
-    var dx = this.markers_conf.max_random_distance * this.random();
-    var dy = this.markers_conf.max_random_distance * this.random();
-    var Lat = parseFloat(Lat0) + (180/Math.PI)*(dy/6378137);
-    var Lng = parseFloat(Lng0) + ( 90/Math.PI)*(dx/6378137)/Math.cos(Lat0);
-    return [Lat, Lng];
-  }
-  
-  this.mergeObjectWithDefault = function(object1, object2){
-    var copy_object1 = object1;
-    for (var attrname in object2) {
-      if ( typeof(copy_object1[attrname]) === "undefined") {
-        copy_object1[attrname] = object2[attrname];
-      } 
-    }
-    return copy_object1;
-  }
-  
-  this.mergeWithDefault = function(objectName){
-    var default_object = this["default_" + objectName];
-    var object = this[objectName];
-    this[objectName] = this.mergeObjectWithDefault(object, default_object);
-    return true;
-  }
-  //gives a value between -1 and 1
-  this.random = function() { return(Math.random() * 2 -1); }	
-
-}
+      return copy_object1;
+    };
+    Gmaps4Rails.prototype.mergeWithDefault = function(objectName) {
+      var default_object, object;
+      default_object = this["default_" + objectName];
+      object = this[objectName];
+      this[objectName] = this.mergeObjectWithDefault(object, default_object);
+      return true;
+    };
+    Gmaps4Rails.prototype.random = function() {
+      return Math.random() * 2 - 1;
+    };
+    return Gmaps4Rails;
+  })();
+}).call(this);