your_platform 0.0.1 → 0.0.2

data/vendor/assets/javascripts/gmaps4rails/google/objects/marker.coffee

@@ -0,0 +1,114 @@
+class Gmaps4Rails.Google.Marker extends Gmaps4Rails.Common
+
+  @include Gmaps4Rails.Interfaces.Marker
+  
+  @include Gmaps4Rails.Google.Shared
+  @include Gmaps4Rails.Marker.Instance
+  @extend  Gmaps4Rails.Marker.Class
+  @extend  Gmaps4Rails.Configuration
+  
+  @CONF:
+    clusterer_gridSize:      50
+    clusterer_maxZoom:       5
+    custom_cluster_pictures: null
+    custom_infowindow_class: null
+    raw:                     {}
+
+  constructor: (args, controller)->
+    @controller = controller
+
+    markerLatLng = @createLatLng(args.lat, args.lng)
+    #Marker sizes are expressed as a Size of X,Y
+    if @_isBasicMarker(args)
+      @_createBasicMarker(markerLatLng, args)
+        
+    else 
+      if args.rich_marker?
+        @_createRichMarker(markerLatLng, args)
+      else
+        @_createMarker(markerLatLng, args)
+    
+    #// creates infowindows
+  createInfoWindow : () ->
+    if typeof(@controller.jsTemplate) == "function" or @description?
+      @description = @controller.jsTemplate(@) if typeof(@controller.jsTemplate) == "function"
+      if @controller.markers_conf.custom_infowindow_class?
+        #creating custom infowindow
+        boxText = document.createElement("div")
+        boxText.setAttribute("class", @controller.markers_conf.custom_infowindow_class) #to customize
+        boxText.innerHTML = @description
+        @infowindow = new InfoBox(@infobox(boxText))
+        google.maps.event.addListener(@serviceObject, 'click', @_openInfowindow())
+      else
+        #create default infowindow
+        @infowindow = new google.maps.InfoWindow({content: @description })
+        #add the listener associated
+        google.maps.event.addListener(@serviceObject, 'click', @_openInfowindow())
+
+  _createBasicMarker:(markerLatLng, args)->
+    defaultOptions = {position: markerLatLng, map: @getMap(), title: args.marker_title, draggable: args.marker_draggable, zIndex: args.zindex}
+    mergedOptions  = @mergeObjects @controller.markers_conf.raw, defaultOptions
+    @serviceObject = new google.maps.Marker mergedOptions
+
+  _createRichMarker: (markerLatLng, args)->
+    @serviceObject = new RichMarker({
+      position:  markerLatLng
+      map:       @getMap()
+      draggable: args.marker_draggable
+      content:   args.rich_marker
+      flat:      if args.marker_anchor? then args.marker_anchor[1] else false
+      anchor:    if args.marker_anchor? then args.marker_anchor[0] else null
+      zIndex:    args.zindex
+    })
+
+  _createMarker: (markerLatLng, args)->
+    #calculate MarkerImage anchor location
+    imageAnchorPosition  = @_createImageAnchorPosition args.marker_anchor
+    shadowAnchorPosition = @_createImageAnchorPosition args.shadow_anchor
+    #create or retrieve existing MarkerImages
+    markerImage = @_createOrRetrieveImage(args.marker_picture, args.marker_width, args.marker_height, imageAnchorPosition)
+    shadowImage = @_createOrRetrieveImage(args.shadow_picture, args.shadow_width, args.shadow_height, shadowAnchorPosition)
+    defaultOptions = {position: markerLatLng, map: @getMap(), icon: markerImage, title: args.marker_title, draggable: args.marker_draggable, shadow: shadowImage,  zIndex: args.zindex}
+    mergedOptions  = @mergeObjects @controller.markers_conf.raw, defaultOptions
+    @serviceObject = new google.maps.Marker mergedOptions
+
+  #checks if obj is included in arr Array and returns the position or false
+  _includeMarkerImage : (obj) ->
+    for object, index in @controller.markerImages
+      return index if object.url == obj
+    return false
+
+  #checks if MarkerImage exists before creating a new one
+  #returns a MarkerImage or false if ever something wrong is passed as argument
+  _createOrRetrieveImage : (currentMarkerPicture, markerWidth, markerHeight, imageAnchorPosition) ->
+    return null if (typeof(currentMarkerPicture) == "undefined" or currentMarkerPicture == "" or currentMarkerPicture == null )
+
+    if !(test_image_index = @_includeMarkerImage(currentMarkerPicture))
+      markerImage = @_createMarkerImage(currentMarkerPicture, @createSize(markerWidth, markerHeight), null, imageAnchorPosition, null )
+      @controller.markerImages.push(markerImage)
+      return markerImage
+    else
+      return @controller.markerImages[test_image_index] if typeof test_image_index == 'number'
+      return false
+
+  _isBasicMarker: (args)->
+    !args.marker_picture? and !args.rich_marker?
+  
+  _createMarkerImage : (markerPicture, markerSize, origin, anchor, scaledSize) ->
+    new google.maps.MarkerImage(markerPicture, markerSize, origin, anchor, scaledSize)
+
+  #creates Image Anchor Position or return null if nothing passed
+  _createImageAnchorPosition : (anchorLocation) ->
+    if (anchorLocation == null)
+      return null
+    else
+      return @createPoint(anchorLocation[0], anchorLocation[1])
+
+  _openInfowindow : () ->
+    that = @
+    return ->
+      # Close the latest selected marker before opening the current one.
+      that.controller._closeVisibleInfoWindow()
+      that.infowindow.open(that.getMap(), that.serviceObject)
+      that.controller._setVisibleInfoWindow that.infowindow
+  

data/vendor/assets/javascripts/gmaps4rails/google/objects/polygon.coffee

@@ -0,0 +1,38 @@
+class @Gmaps4Rails.Google.Polygon extends Gmaps4Rails.Common
+
+  @include Gmaps4Rails.Interfaces.Basic
+
+  @include Gmaps4Rails.Google.Shared
+  @extend  Gmaps4Rails.Polygon.Class
+  @extend  Gmaps4Rails.Configuration
+
+  constructor : (polygon, controller) ->
+    @controller = controller
+    polygon_coordinates = []
+
+    #Polygon points are in an Array, that's why looping is necessary
+    for point in polygon
+      latlng = @createLatLng(point.lat, point.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 point == polygon[0]
+        strokeColor   = point.strokeColor   || @controller.polygons_conf.strokeColor
+        strokeOpacity = point.strokeOpacity || @controller.polygons_conf.strokeOpacity
+        strokeWeight  = point.strokeWeight  || @controller.polygons_conf.strokeWeight
+        fillColor     = point.fillColor     || @controller.polygons_conf.fillColor
+        fillOpacity   = point.fillOpacity   || @controller.polygons_conf.fillOpacity
+        clickable     = point.clickable     || @controller.polygons_conf.clickable
+        zIndex        = point.zIndex        || @controller.polygons_conf.zIndex
+
+    polyOptions = 
+      path:          polygon_coordinates
+      strokeColor:   strokeColor
+      strokeOpacity: strokeOpacity
+      strokeWeight:  strokeWeight
+      clickable:     clickable
+      zIndex:        zIndex
+
+    mergedOptions = @mergeObjects controller.polygons_conf.raw, polyOptions
+
+    @serviceObject = new google.maps.Polygon mergedOptions
+    @serviceObject.setMap(controller.getMapObject())

data/vendor/assets/javascripts/gmaps4rails/google/objects/polyline.coffee

@@ -0,0 +1,49 @@
+class @Gmaps4Rails.Google.Polyline extends Gmaps4Rails.Common
+
+  @include Gmaps4Rails.Interfaces.Basic
+
+  @include Gmaps4Rails.Google.Shared
+  @extend  Gmaps4Rails.Polyline.Class
+  @extend  Gmaps4Rails.Configuration
+
+ #creates a single polyline, triggered by create_polylines
+  constructor : (polyline, controller) ->
+    polyline_coordinates = []
+    #2 cases here, either we have a coded array of LatLng or we have an Array of LatLng
+    for element in polyline
+      #if we have a coded array
+      if element.coded_array?
+        decoded_array = new google.maps.geometry.encoding.decodePath(element.coded_array)
+        #loop through every point in the array
+        for point in decoded_array
+          polyline_coordinates.push(point)
+
+      #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 element == polyline[0]
+          strokeColor   = element.strokeColor   || controller.polylines_conf.strokeColor
+          strokeOpacity = element.strokeOpacity || controller.polylines_conf.strokeOpacity
+          strokeWeight  = element.strokeWeight  || controller.polylines_conf.strokeWeight
+          clickable     = element.clickable     || controller.polylines_conf.clickable
+          zIndex        = element.zIndex        || controller.polylines_conf.zIndex
+          icons         = element.icons         || controller.polylines_conf.icons
+
+        #add latlng if positions provided
+        if element.lat? && element.lng?
+          polyline_coordinates.push @createLatLng(element.lat, element.lng)
+
+    polyOptions = 
+      path:          polyline_coordinates
+      strokeColor:   strokeColor
+      strokeOpacity: strokeOpacity
+      strokeWeight:  strokeWeight
+      clickable:     clickable
+      zIndex:        zIndex
+      icons:         icons
+
+    mergedOptions = @mergeObjects controller.polylines_conf.raw, polyOptions
+
+    # Construct the polyline
+    @serviceObject = new google.maps.Polyline mergedOptions
+    @serviceObject.setMap(controller.getMapObject())

data/vendor/assets/javascripts/gmaps4rails/google/shared.coffee

@@ -0,0 +1,27 @@
+Gmaps4Rails.Google = {}
+
+Gmaps4Rails.Google.Shared = 
+  
+  createPoint : (lat, lng) ->
+    new google.maps.Point(lat, lng)
+    
+  createSize : (width, height) ->
+    new google.maps.Size(width, height)
+  
+  createLatLng : (lat, lng) ->
+    new google.maps.LatLng(lat, lng)
+
+  createLatLngBounds : ->
+    new google.maps.LatLngBounds()
+
+  clear: ()->
+    @serviceObject.setMap(null)
+
+  show: () ->
+    @serviceObject.setVisible(true)
+
+  hide: () ->
+    @serviceObject.setVisible(false)
+
+  isVisible: ->
+    @serviceObject.getVisible()

data/vendor/assets/javascripts/gmaps4rails/openlayers.coffee

@@ -0,0 +1 @@
+#= require './openlayers/main'

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

@@ -0,0 +1,138 @@
+#= require './shared'
+
+#= require_tree './objects'
+
+class @Gmaps4RailsOpenlayers extends Gmaps4Rails.BaseController
+
+  @include Gmaps4Rails.Openlayers.Shared
+  
+  constructor: ->
+    super
+
+    @markersControl = null
+    @markersLayer   = null
+
+    @polylinesLayer = null
+
+  getModule: ->
+    Gmaps4Rails.Openlayers
+
+  #////////////////////////////////////////////////////
+  #/////////////////// Clusterer //////////////////////
+  #////////////////////////////////////////////////////
+  
+  createClusterer: (marker_serviceObject_array)->
+    style    = new OpenLayers.Style @_clustererOptions, @_clustererFunctions
+
+    strategy = new OpenLayers.Strategy.Cluster
+    @_clearMarkersLayer()
+
+    @clusterLayer = new OpenLayers.Layer.Vector "Clusters", 
+      strategies: [strategy]
+      styleMap: new OpenLayers.StyleMap
+        "default": style
+        "select": 
+            fillColor: "#8aeeef"
+            strokeColor: "#32a8a9"
+      
+    @getMapObject().addLayer @clusterLayer
+    @clusterLayer.addFeatures marker_serviceObject_array
+    @clusterLayer
+
+  clearClusterer: ->
+    @getMapObject().removeLayer @markerClusterer if @clusterLayer? and @getMapObject().getLayer(@clusterLayer.id)?
+    @clusterLayer = null
+
+  #overwriting method from base controller since it doesn't fit here
+  clearMarkers: ->
+    @_clearMarkersLayer()
+    @clearClusterer()
+    @markers = []
+
+  #////////////////////////////////////////////////////
+  #/////////////// Private methods ////////////////////
+  #////////////////////////////////////////////////////
+
+  _createPolylinesLayer: ->  
+
+    return if @polylinesLayer?
+    @polylinesLayer = new OpenLayers.Layer.Vector("Polylines", null)
+    @polylinesLayer.events.register("featureselected", @polylinesLayer, @_onFeatureSelect)
+    @polylinesLayer.events.register("featureunselected", @polylinesLayer, @_onFeatureUnselect)
+    @polylinesControl = new OpenLayers.Control.DrawFeature(@polylinesLayer, OpenLayers.Handler.Path)
+    @getMapObject().addLayer(@polylinesLayer)
+
+    @getMapObject().addControl(@polylinesControl)
+
+  _createMarkersLayer: ->  
+    return if @markersLayer?
+
+    @markersLayer = new OpenLayers.Layer.Vector("Markers", null)
+    @getMapObject().addLayer @markersLayer
+
+    @markersLayer.events.register("featureselected", @markersLayer, @_onFeatureSelect())
+    @markersLayer.events.register("featureunselected", @markersLayer, @_onFeatureUnselect())
+    
+    @markersControl = new OpenLayers.Control.SelectFeature @markersLayer
+    
+    @getMapObject().addControl @markersControl
+    @markersControl.activate()
+
+  _clearMarkersLayer: -> 
+    @getMapObject().removeLayer(@markersLayer) if @markersLayer? and @getMapObject().getLayer(@markersLayer.id)?
+    @markersLayer = null
+  
+  _onFeatureSelect: ->
+    controller = @
+    return (evt) ->
+      feature = evt.feature
+   
+      popup = new OpenLayers.Popup.FramedCloud(
+        "featurePopup",
+        feature.geometry.getBounds().getCenterLonLat(),
+        new OpenLayers.Size(300,200),
+        feature.infoWindow,
+        null, 
+        true,
+        controller._onPopupClose(controller, feature)
+      )
+      feature.popup = popup
+      popup.feature = feature
+      controller.getMapObject().addPopup popup
+
+  _onFeatureUnselect: ->
+    controller = @
+
+    return (evt)->
+      feature = evt.feature
+
+      if feature.popup?
+        controller.getMapObject().removePopup feature.popup
+        feature.popup.destroy()
+        feature.popup = null
+  
+  _onPopupClose: (controller, feature) ->
+    return ->
+      controller.markersControl.unselect feature
+
+  _clustererFunctions:
+    context:
+      width:  (feature) ->
+        return (feature.cluster) ? 2 : 1
+      radius: (feature) ->
+        pix = 2
+        pix = feature.cluster.length + 10 if feature.cluster
+        return pix
+      label: (feature) ->
+        if feature.cluster 
+          return feature.cluster.length
+        else
+          return ""
+
+  _clustererOptions:  
+    pointRadius:   "${radius}"
+    fillColor:     "#ffcc66"
+    fillOpacity:   0.8
+    strokeColor:   "#cc6633"
+    strokeWidth:   "${width}"
+    label:         "${label}"

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

@@ -0,0 +1,49 @@
+class @Gmaps4Rails.Openlayers.Map extends Gmaps4Rails.Common
+
+  @include Gmaps4Rails.Interfaces.Map
+
+  @include  Gmaps4Rails.Map
+  @include  Gmaps4Rails.Openlayers.Shared
+  @include  Gmaps4Rails.Configuration
+
+  CONF:
+    disableDefaultUI:       false
+    disableDoubleClickZoom: false
+    type:                   "ROADMAP" # HYBRID, ROADMAP, SATELLITE, TERRAIN
+    mapTypeControl:         null
+
+  constructor:(map_options, controller) ->
+    @controller    = controller
+
+    defaultOptions = @setConf()
+    @options  = @mergeObjects map_options, defaultOptions
+    
+    openlayersOptions = 
+      center: @createLatLng(@options.center_latitude, @options.center_longitude)
+      zoom:   @options.zoom
+
+    mergedOpenlayersOptions = @mergeObjects map_options.raw, openlayersOptions
+
+    @serviceObject = new OpenLayers.Map(@options.id, mergedOpenlayersOptions)
+    
+    @serviceObject.addLayer(new OpenLayers.Layer.OSM())
+
+  extendBoundsWithMarker : (marker)->
+    @boundsObject.extend(@createLatLng(marker.lat,marker.lng))
+
+  extendBoundsWithPolyline: (polyline)->
+
+  extendBoundsWithPolygon: (polygon)->
+
+  extendBoundsWithCircle: (circle)->
+
+  extendBound: (bound)->
+
+  fitBounds: ->
+    @serviceObject.zoomToExtent(@boundsObject, true)
+  
+  adaptToBounds: ->
+    @fitBounds()
+
+  centerMapOnUser : (position)->
+    @serviceObject.setCenter position

data/vendor/assets/javascripts/gmaps4rails/openlayers/objects/marker.coffee

@@ -0,0 +1,68 @@
+class @Gmaps4Rails.Openlayers.Marker extends Gmaps4Rails.Common
+
+  @include Gmaps4Rails.Interfaces.Marker
+
+  @include Gmaps4Rails.Openlayers.Shared
+  @include Gmaps4Rails.Marker.Instance
+  @extend  Gmaps4Rails.Marker.Class
+  @extend  Gmaps4Rails.Configuration
+  
+
+  constructor: (args, controller)->
+    @controller = controller
+
+    @controller._createMarkersLayer()
+
+    @_createMarkerStyle(args)
+
+    if @_isBasicMarker(args)
+      @_styleForBasicMarker(args)
+    else
+      @_styleForCustomMarker(args)
+      
+    @serviceObject = new OpenLayers.Feature.Vector(
+      @createPoint(args.lat, args.lng),
+      null,
+      @style_mark
+    )
+    #//changing coordinates so that it actually appears on the map!
+    @serviceObject.geometry.transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"))
+    #//adding layer to the map
+    @controller.markersLayer.addFeatures([@serviceObject])
+    
+  createInfoWindow : () ->
+    @serviceObject.infoWindow = @description if @description?
+
+  #cheap integration, I admit
+  isVisible: ->
+    true
+
+  _isBasicMarker: (args)->
+    !args.marker_picture?
+
+  _createMarkerStyle: (args) ->
+    @style_mark = OpenLayers.Util.extend({}, OpenLayers.Feature.Vector.style['default'])
+    @style_mark.fillOpacity = 1
+    @style_mark.graphicTitle = args.marker_title
+
+  _styleForBasicMarker: (args)->
+    @style_mark.graphicHeight = 30
+    @style_mark.externalGraphic = "http://openlayers.org/dev/img/marker-blue.png"
+
+  _styleForCustomMarker: (args)->
+    @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?
+      @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?
+        @style_mark.backgroundXOffset = args.shadow_anchor[0]
+        @style_mark.backgroundYOffset = args.shadow_anchor[1]