gmaps4rails 1.5.8 → 2.0.0.pre

data/vendor/assets/javascripts/gmaps4rails/base/configuration.coffee

@@ -0,0 +1,7 @@
+@Gmaps4Rails.Configuration =
+
+  setConf: ->
+    if @CONF?
+      @mergeObjects(@CONF, @DEFAULT_CONF)
+    else
+      @DEFAULT_CONF

data/vendor/assets/javascripts/gmaps4rails/base/gmaps.coffee

@@ -0,0 +1,13 @@
+@Gmaps = 
+  triggerOldOnload: ->
+    window.Gmaps.oldOnload() if typeof(window.Gmaps.oldOnload) == 'function'
+
+  loadMaps: ->
+    #loop through all variable names.
+    #there should only be maps inside so it trigger their load function
+    for key, value of window.Gmaps
+      #console.log key, searchLoadIncluded
+      if /^load_/.test(key)
+        #load_function_name = "load_" + key
+        window.Gmaps[key]()
+

data/vendor/assets/javascripts/gmaps4rails/base/interfaces/basic_interface.coffee

@@ -0,0 +1,15 @@
+Gmaps4Rails.Interfaces ||= {}
+
+Gmaps4Rails.Interfaces.Basic =
+
+  clear: ()->
+    throw "clear should be implemented"
+
+  show: () ->
+    throw "show should be implemented"
+
+  hide: () ->
+    throw "hide should be implemented"
+
+  isVisible: ->
+    throw "hide should be implemented"

data/vendor/assets/javascripts/gmaps4rails/base/interfaces/controller_interface.coffee

@@ -0,0 +1,15 @@
+Gmaps4Rails.Interfaces ||= {}
+
+Gmaps4Rails.Interfaces.Controller =
+
+  # module is the namespace of the map provider you implement, ie: Gmaps4Rails.Google
+  getModule: ->
+    throw "getModule should be implemented in controller"
+
+  # This method should create and return a clusterer object
+  createClusterer : (markers_array) ->
+    throw "createClusterer should be implemented in controller"
+
+  # this method should reset the clusterer
+  clearClusterer : ->
+    throw "clearClusterer should be implemented in controller"

data/vendor/assets/javascripts/gmaps4rails/base/interfaces/map_interface.coffee

@@ -0,0 +1,27 @@
+Gmaps4Rails.Interfaces ||= {}
+
+Gmaps4Rails.Interfaces.Map = 
+
+  extendBoundsWithMarker : (marker) ->
+    throw "extendBoundsWithMarker should be implemented in controller"
+
+  extendBoundsWithPolyline: (polyline)->
+    throw "extendBoundsWithPolyline should be implemented in controller"
+
+  extendBoundsWithPolygon: (polygon)->
+    throw "extendBoundsWithPolygon should be implemented in controller"
+
+  extendBoundsWithCircle: (circle)->
+    throw "extendBoundsWithCircle should be implemented in controller"
+
+  extendBound: (bound)->
+    throw "extendBound should be implemented in controller"
+
+  adaptToBounds:()->
+    throw "adaptToBounds should be implemented in controller"
+
+  fitBounds : ->
+    throw "fitBounds should be implemented in controller"
+
+  centerMapOnUser : (position)->
+    throw "centerMapOnUser should be implemented in controller"

data/vendor/assets/javascripts/gmaps4rails/base/interfaces/marker_interface.coffee

@@ -0,0 +1,15 @@
+Gmaps4Rails.Interfaces ||= {}
+
+Gmaps4Rails.Interfaces.Marker =
+
+  createInfoWindow : () ->
+    throw "createInfoWindow should be implemented in marker"
+
+  clear: ()->
+    throw "clear should be implemented in marker"
+
+  show: () ->
+    throw "show should be implemented in marker"
+
+  hide: () ->
+    throw "hide should be implemented in marker"

data/vendor/assets/javascripts/gmaps4rails/base/main.coffee

@@ -0,0 +1,124 @@
+#= require './common'
+#= require './configuration'
+#= require './gmaps'
+
+#= require_tree './objects'
+#= require_tree './main_controller_extensions'
+#= require_tree './interfaces'
+
+class @Gmaps4Rails.BaseController extends Gmaps4Rails.Common
+
+  @include Gmaps4Rails.MarkerController
+  @include Gmaps4Rails.PolylineController
+  @include Gmaps4Rails.PolygonController
+  @include Gmaps4Rails.CircleController
+  @include Gmaps4Rails.KmlController
+
+  @include Gmaps4Rails.Interfaces.Controller
+
+  visibleInfoWindow: null  #contains the current opened infowindow
+  userLocation:      null       #contains user's location if geolocalization was performed and successful
+
+  #empty slots
+  afterMapInitialization: -> false
+  geolocationSuccess: -> false
+  geolocationFailure: -> false  #triggered when geolocation fails. If customized, must be like= function(navigator_handles_geolocation){} where 'navigator_handles_geolocation' is a boolean
+  callback:           -> false  #to let user set a custom callback function
+  customClusterer:    -> false  #to let user set custom clusterer pictures
+  infobox:            -> false  #to let user use custom infoboxes
+  jsTemplate:         false     #to let user create infowindows client side
+  
+
+  #Stored variables
+  map_options:  {}            # deleted once map is created
+  markers:      []            # contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "serviceObject": google_marker}
+  boundsObject: 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
+  markerImages: []
+  kmls:         []
+  rootModule:   null
+
+  constructor: ->
+    @rootModule = @getModule()
+    @markers_conf   = @rootModule.Marker.setConf()   if @rootModule.Marker? 
+    @polylines_conf = @rootModule.Polyline.setConf() if @rootModule.Polyline? 
+    @polygons_conf  = @rootModule.Polygon.setConf()  if @rootModule.Polygon? 
+    @circles_conf   = @rootModule.Circle.setConf()   if @rootModule.Circle? 
+ 
+  #////////////////////////////////////////////////////
+  #/////////////// Basic Objects         //////////////
+  #////////////////////////////////////////////////////
+
+  createMap : ->
+    new @rootModule.Map(@map_options, @)
+
+  createMarker: (args)->
+    new @rootModule.Marker(args, @)
+
+  createPolyline: (args)->
+    new @rootModule.Polyline(args, @)
+
+  createPolygon: (args)->
+    new @rootModule.Polygon(args, @)
+
+  createCircle: (args)->
+    new @rootModule.Circle(args, @)
+
+  createKml: (args)->
+    new @rootModule.Kml(args, @)
+
+  #///////////////////////////////////
+  #/////////////// Map  //////////////
+  #///////////////////////////////////
+
+  initialize : ->
+    detectUserLocation = @map_options.detect_location or @map_options.center_on_user
+    center_on_user     = @map_options.center_on_user
+    @map = @createMap()
+    @afterMapInitialization()
+    
+    delete @map_options
+
+    if detectUserLocation
+      @findUserLocation(this, center_on_user)
+
+  getMapObject: ->
+    @map.serviceObject
+
+  adjustMapToBounds: ->
+    @map.adjustToBounds() if @map.autoAdjustRequested()
+
+  #////////////////////////////////////////////////////
+  #/////////////// Miscellaneous         //////////////
+  #////////////////////////////////////////////////////
+
+  clusterize : ->
+    if @markers_conf.do_clustering
+      #first clear the existing clusterer if any
+      @clearClusterer() if @markerClusterer?
+
+      markers_array = []
+      for marker in @markers
+        markers_array.push(marker.serviceObject)
+
+      @markerClusterer = @createClusterer(markers_array)
+
+  findUserLocation : (controller, center_on_user) ->
+    if navigator.geolocation
+      #try to retrieve user's position
+      positionSuccessful = (position) ->
+        controller.userLocation = controller.createLatLng(position.coords.latitude, position.coords.longitude)
+        #change map's center to focus on user's geoloc if asked
+        controller.geolocationSuccess()
+        if center_on_user
+          controller.map.centerMapOnUser(controller.userLocation)
+      positionFailure = (error)->
+        controller.geolocationFailure(true)
+
+      navigator.geolocation.getCurrentPosition( positionSuccessful, positionFailure)
+    else
+      #failure but the navigator doesn't handle geolocation
+      controller.geolocationFailure(false)

data/vendor/assets/javascripts/gmaps4rails/base/main_controller_extensions/circle_controller.coffee

@@ -0,0 +1,29 @@
+@Gmaps4Rails.CircleController =
+
+  #polygons is an array of arrays. It loops.
+  addCircles: (circleData)->
+    for circleArgs in circleData
+      @circles.push @createCircle(circleArgs)
+
+  replaceCircles : (circleData) ->
+    #reset previous polylines and kill them from map
+    @clearCircles()
+    #set new polylines
+    @addCircles(circleData)
+    #.... and adjust map boundaries
+    @adjustMapToBounds()
+
+  clearCircles : ->
+    for circle in @circles
+      #delete polylines from map
+      circle.clear()
+    #empty array
+    @circles = []
+
+  showCircles : ->
+    for circle in @circles
+      circle.show()
+
+  hideCircles : ->
+    for circle in @circles
+      circle.hide()

data/vendor/assets/javascripts/gmaps4rails/base/main_controller_extensions/kml_controller.coffee

@@ -0,0 +1,5 @@
+@Gmaps4Rails.KmlController =
+
+  addKml : (kmlData) ->
+    for kml in kmlData
+      @kmls.push @createKml kml

data/vendor/assets/javascripts/gmaps4rails/base/main_controller_extensions/marker_controller.coffee

@@ -0,0 +1,76 @@
+@Gmaps4Rails.MarkerController =
+
+  addMarkers: (markersData)->
+    @clearClusterer() if @markerClusterer?
+
+    for markerData, index in markersData
+      #unless markerData.serviceObject?
+
+      lat = markerData.lat
+      lng = markerData.lng
+
+      if @markers_conf.randomize
+        latLng = @randomize(lat, lng)
+        #retrieve coordinates from the array
+        lat = latLng[0]
+        lng = latLng[1]
+
+      newMarker = @createMarker
+        "marker_picture":   if markerData.picture  then markerData.picture else @markers_conf.picture
+        "marker_width":     if markerData.width    then markerData.width   else @markers_conf.width
+        "marker_height":    if markerData.height   then markerData.height  else @markers_conf.length
+        "marker_title":     if markerData.title    then markerData.title   else null
+        "marker_anchor":    if markerData.marker_anchor  then markerData.marker_anchor  else null
+        "shadow_anchor":    if markerData.shadow_anchor  then markerData.shadow_anchor  else null
+        "shadow_picture":   if markerData.shadow_picture then markerData.shadow_picture else null
+        "shadow_width":     if markerData.shadow_width   then markerData.shadow_width   else null
+        "shadow_height":    if markerData.shadow_height  then markerData.shadow_height  else null
+        "marker_draggable": if markerData.draggable      then markerData.draggable      else @markers_conf.draggable
+        "rich_marker":      if markerData.rich_marker    then markerData.rich_marker    else null
+        "zindex":           if markerData.zindex         then markerData.zindex         else null
+        "lat":              lat
+        "lng":              lng
+        "index":            index
+
+
+      Gmaps4Rails.Common.mergeWith.call(newMarker, markerData)
+      #add infowindowstuff if enabled
+      newMarker.createInfoWindow()
+      
+      @markers.push newMarker
+
+    @clusterize()
+
+    #replace old markers with new markers on an existing map
+  replaceMarkers : (new_markers) ->
+    @clearMarkers()
+    #reset previous markers
+    @markers = []
+    #reset current bounds
+    @boundsObject = @createLatLngBounds()
+    #add new markers
+    @addMarkers(new_markers)
+
+  #clear markers
+  clearMarkers : ->
+    @clearClusterer() if @markerClusterer?
+    for marker in @markers
+      marker.clear()
+    @markers = []
+
+  #show and hide markers
+  showMarkers : ->
+    for marker in @markers
+      marker.show()
+
+  hideMarkers : ->
+    for marker in @markers
+      marker.hide()
+
+  randomize : (Lat0, Lng0) ->
+    #distance in meters between 0 and max_random_distance (positive or negative)
+    dx = @markers_conf.max_random_distance * @random()
+    dy = @markers_conf.max_random_distance * @random()
+    Lat = parseFloat(Lat0) + (180/Math.PI)*(dy/6378137)
+    Lng = parseFloat(Lng0) + ( 90/Math.PI)*(dx/6378137)/Math.cos(Lat0)
+    return [Lat, Lng]

data/vendor/assets/javascripts/gmaps4rails/base/main_controller_extensions/polygon_controller.coffee

@@ -0,0 +1,29 @@
+@Gmaps4Rails.PolygonController =
+
+  #polygons is an array of arrays. It loops.
+  addPolygons: (polygonData)->
+    for polygonArgs in polygonData
+      @polygons.push @createPolygon(polygonArgs)
+
+  replacePolygons : (polylineData) ->
+    #reset previous polylines and kill them from map
+    @clearPolygons()
+    #set new polylines
+    @addPolygons(polylineData)
+    #.... and adjust map boundaries
+    @adjustMapToBounds()
+
+  clearPolygons : ->
+    for polygon in @polygons
+      #delete polylines from map
+      polygon.clear()
+    #empty array
+    @polygons = []
+
+  showPolygons : ->
+    for polygon in @polygons
+      polygon.show()
+
+  hidePolygons : ->
+    for polygon in @polygons
+      polygon.hide()

data/vendor/assets/javascripts/gmaps4rails/base/main_controller_extensions/polyline_controller.coffee

@@ -0,0 +1,29 @@
+@Gmaps4Rails.PolylineController =
+
+  replacePolylines : (polylineData) ->
+    #reset previous polylines and kill them from map
+    @clearPolylines()
+    #set new polylines
+    @addPolylines(polylineData)
+    #.... and adjust map boundaries
+    @adjustMapToBounds()
+
+  clearPolylines : ->
+    for polyline in @polylines
+      #delete polylines from map
+      polyline.clear()
+    #empty array
+    @polylines = []
+
+  #polylines is an array of arrays. It loops.
+  addPolylines: (polylineData)->
+    for polylineArgs in polylineData
+      @polylines.push @createPolyline(polylineArgs)
+
+  showPolylines : ->
+    for polyline in @polylines
+      polyline.show()
+
+  hidePolylines : ->
+    for polyline in @polylines
+      polyline.hide()

data/vendor/assets/javascripts/gmaps4rails/base/objects/circle.coffee

@@ -0,0 +1,12 @@
+@Gmaps4Rails.Circle = { } 
+
+@Gmaps4Rails.Circle.Class =
+
+  DEFAULT_CONF:
+    fillColor: "#00AAFF"
+    fillOpacity: 0.35
+    strokeColor: "#FFAA00"
+    strokeOpacity: 0.8
+    strokeWeight: 2
+    clickable: false
+    zIndex: null

data/vendor/assets/javascripts/gmaps4rails/base/objects/kml.coffee

@@ -0,0 +1,8 @@
+@Gmaps4Rails.Kml = { } 
+
+@Gmaps4Rails.Kml.Instance =
+
+  DEFAULT_CONF:
+    clickable: true
+    preserveViewport: false
+    suppressInfoWindows: false

data/vendor/assets/javascripts/gmaps4rails/base/objects/map.coffee

@@ -0,0 +1,62 @@
+@Gmaps4Rails.Map =
+
+  DEFAULT_CONF:
+    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": }]
+    raw: {}                  # raw json to pass additional options
+
+  #to make the map fit the different LatLng points
+  adjustToBounds : ->
+    #reset previous bounds
+    @boundsObject = @createLatLngBounds()
+
+    #from markers
+    @extendBoundsWithMarkers()
+
+    #from polylines:
+    @extendBoundsWithPolylines()
+
+    #from polygons:
+    @extendBoundsWithPolygons()
+
+    #from circles
+    @extendBoundsWithCircles()
+
+    #in every case, I've to take into account the bounds set up by the user
+    @extendBoundsWithLatLng()
+
+    #SECOND_STEP: ajust the map to the bounds
+    @adaptToBounds()
+
+  extendBoundsWithMarkers : ->
+    for marker in @controller.markers
+      @extendBoundsWithMarker(marker) if marker.isVisible()
+        
+  extendBoundsWithPolylines: ()->
+    for polyline in @controller.polylines
+      @extendBoundsWithPolyline(polyline) #if polyline.isVisible()
+
+  extendBoundsWithPolygons: ()->
+    for polygon in @controller.polygons
+      @extendBoundsWithPolygon(polygon) #if polygon.isVisible()
+
+  extendBoundsWithCircles: ()->
+    for circle in @controller.circles
+      @extendBoundsWithCircle(circle) #if circle.isVisible()
+
+  extendBoundsWithLatLng: ()->
+    for bound in @options.bounds
+      @extendBound bound
+
+  autoAdjustRequested: ->
+    @options.auto_adjust or @options.bounds.length > 0