ekylibre-cartography 0.0.1

data/app/assets/javascripts/cartography/events.coffee

@@ -0,0 +1,36 @@
+((C) ->
+  "use strict"
+
+  C.Events = {}
+  C.Events.new = {}
+  C.Events.new.start = "cartography:events:new:start"
+  C.Events.new.complete = "cartography:events:new:complete"
+  C.Events.new.cancel = "cartography:events:new:cancel"
+  C.Events.new.change = "cartography:events:new:change"
+  C.Events.shapeDraw = {}
+  C.Events.shapeDraw.start = "cartography:events:shapeDraw:start"
+  C.Events.shapeDraw.draw = "cartography:events:shapeDraw:draw"
+  C.Events.shapeDraw.edit = "cartography:events:shapeDraw:edit"
+  C.Events.shapeDraw.warn = "cartography:events:shapeDraw:warn"
+  C.Events.split = {}
+  C.Events.split.start = "cartography:events:split:start"
+  C.Events.split.complete = "cartography:events:split:complete"
+  C.Events.split.cancel = "cartography:events:split:cancel"
+  C.Events.split.change = "cartography:events:split:change"
+  C.Events.split.select = "cartography:events:split:select"
+  C.Events.split.cutting = "cartography:events:split:cutting"
+  C.Events.edit = {}
+  C.Events.edit.start = "cartography:events:edit:start"
+  C.Events.edit.complete = "cartography:events:edit:complete"
+  C.Events.edit.cancel = "cartography:events:edit:cancel"
+  C.Events.edit.change = "cartography:events:edit:change"
+  C.Events.select = {}
+  C.Events.select.select = "cartography:events:select:select"
+  C.Events.select.unselect = "cartography:events:select:unselect"
+  C.Events.select.selected = "cartography:events:select:selected"
+  C.Events.select.start = "cartography:events:select:start"
+  C.Events.select.stop = "cartography:events:select:stop"
+
+  L.Draw.Event.INVALIDATED = 'draw:invalidated'
+
+)(window.Cartography = window.Cartography || {})

data/app/assets/javascripts/cartography/layers.coffee

@@ -0,0 +1,127 @@
+((C, $) ->
+  "use strict"
+
+  class C.Layer extends C.BaseClass
+    @LAYER_TYPES : {}
+    constructor: (map, layer = undefined, data = undefined, options = {}) ->
+      super(map)
+
+      if layer and data and type = @constructor.LAYER_TYPES[layer.type]
+        return new type(map, layer, data, options)
+
+    @registerLayerType: (name, klass) ->
+      @LAYER_TYPES[name] = klass
+
+  class C.Layers extends C.Layer
+    constructor: (map) ->
+      super(map)
+      @layers = {}
+
+    getLayers: ->
+      @layers
+
+    getMainLayer: ->
+      Object.values(@layers).filter((l) ->
+        l.renderedLayer.layer.serie == "main")[0]
+
+  class C.BaseLayers extends C.Layers
+    options:
+      backgrounds: []
+
+    constructor: ( map, options = {} ) ->
+      C.Util.setOptions @, options
+      super(map)
+
+    add: (layers) ->
+      layers = [layers] unless layers.constructor.name is "Array"
+
+      newLayers = {}
+
+      for layer in layers
+        if layer.constructor.name is "Array"
+          newLayers[layer] = L.tileLayer.provider(layer[0], layer[1])
+        else
+          newLayers[layer] = L.tileLayer.provider(layer)
+
+      L.Util.extend(@layers, newLayers)
+      newLayers
+
+  class C.OverlayLayers extends C.Layers
+    options:
+      overlays: []
+      series: {}
+      properties:
+        color: "#FAEBD7"
+        fillOpacity: 0.35
+
+    constructor: ( map, options = {} ) ->
+      C.Util.setOptions @, options
+
+      super(map)
+
+    add: (layers, type) ->
+      @["add#{type}"](layers)
+
+    addtiles: (layers) ->
+      layers = [layers] unless layers.constructor.name is "Array"
+
+      newLayers = {}
+
+      for layer in layers
+        opts = {}
+        opts.attribution = layer.attribution if layer.attribution?
+        opts.minZoom = layer.minZoom || @options.minZoom
+        opts.maxZoom = layer.maxZoom || @options.maxZoom
+        opts.subdomains = layer.subdomains if layer.subdomains?
+        opts.opacity = (layer.opacity / 100).toFixed(1) if layer.opacity? and !isNaN(layer.opacity)
+        opts.tms = true if layer.tms
+        newLayers[layer.name] =  L.tileLayer(layer.url, opts)
+        newLayers[layer.name].addTo(@getMap())
+
+      L.Util.extend(@layers, newLayers)
+      newLayers
+
+    addseries: (data) ->
+      series = data[0]
+      layers = data[1]
+
+      newLayers = {}
+
+      for layer in layers
+        serie = series[layer.serie]
+        renderedLayer = new C.Layer(@getMap(), layer, serie)
+
+        if renderedLayer and renderedLayer.valid()
+          layerGroup = renderedLayer.buildLayerGroup(@options.properties)
+          layerGroup.name = layer.name
+          layerGroup.renderedLayer = renderedLayer
+
+          newLayers[layer.name] = layerGroup
+          newLayers[layer.name].addTo(@getMap())
+
+      L.Util.extend(@layers, newLayers)
+      newLayers
+
+    updateSerie: (layerGroup, serie) ->
+
+      newLayers = new L.GeoJSON(serie)
+
+      if layerGroup.getLayers().length
+        removeList = layerGroup.getLayers().filter (layer) ->
+          !newLayers.hasIDLayer layer
+
+        if removeList.length
+          for l in removeList
+            layerGroup.removeLayer l
+
+        updateList = newLayers.getLayers().filter (layer) ->
+          !layerGroup.hasIDLayer layer
+
+      else
+        updateList = newLayers.getLayers()
+
+      for layer in updateList
+        layerGroup.addData(layer.toGeoJSON())
+
+
+)(window.Cartography = window.Cartography || {}, jQuery)

data/app/assets/javascripts/cartography/layers/simple.coffee

@@ -0,0 +1,37 @@
+#= require cartography/layers
+
+((C, $) ->
+  "use strict"
+
+  class C.Layer.Simple extends C.Layer
+    constructor: (map, @layer, @data, @options = {}) ->
+      super(map)
+
+    buildLayerGroup: (style = {}) ->
+      klass = if @layer.index then L.IndexedGeoJSON else L.GeoJSON
+
+      new klass @data,
+        style: (feature) =>
+          if @layer.style
+            @layer.style.apply @, arguments
+          else
+            C.Util.extend style, feature.properties
+
+        onEachFeature: (feature, layer) =>
+          feature.properties ||= {}
+
+          feature.properties.uuid ||= new UUID(4).format()
+
+          layer.feature.properties = feature.properties
+
+          if @layer.onEachFeature
+            @layer.onEachFeature.apply @, arguments
+
+
+
+    valid: () ->  true
+
+  C.Layer.registerLayerType("simple", C.Layer.Simple)
+
+
+)(window.Cartography = window.Cartography || {}, jQuery)

data/app/assets/javascripts/cartography/leaflet/controls.coffee

@@ -0,0 +1,420 @@
+((C) ->
+  "use strict"
+
+  class L.Control.Home extends L.Control
+    options:
+      position: 'topleft'
+      featureGroup: null
+
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super options
+
+      if L.HomeToolbar && !@_toolbar
+        @_toolbar = new L.HomeToolbar @options
+
+    onAdd: (map) ->
+      container = L.DomUtil.create('div', 'leaflet-draw leaflet-control-cut')
+      topClassName = 'leaflet-draw-toolbar-top'
+      toolbarContainer = @_toolbar.addToolbar(map)
+      if toolbarContainer
+        L.DomUtil.addClass toolbarContainer.childNodes[0], topClassName
+      container.appendChild toolbarContainer
+      container
+
+    onRemove: ->
+      @_toolbar.removeToolbar()
+
+  class L.Control.SnapEdit extends L.Control
+    options:
+      position: 'topleft'
+      draw: {}
+      edit:
+        panel:
+          position: 'bottomleft'
+
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super options
+      toolbar = undefined
+      @_toolbar = {}
+      if L.SnapEditToolbar
+        @options.snap.guideLayers = @options.snap.polygon.guideLayers
+
+        @_toolbar = new L.SnapEditToolbar @options
+
+      if @options.edit.panel
+        new L.Control.ControlPanel.SnapEdit @_toolbar, @options.edit.panel
+
+      L.toolbar = this
+      return
+
+    onAdd: (map) ->
+      container = L.DomUtil.create('div', 'leaflet-draw')
+      topClassName = 'leaflet-draw-toolbar-top'
+      toolbarContainer = @_toolbar.addToolbar(map)
+      if toolbarContainer
+        L.DomUtil.addClass toolbarContainer.childNodes[0], topClassName
+        container.appendChild toolbarContainer
+      container
+
+    onRemove: ->
+      @_toolbar.removeToolbar()
+
+  class L.Control.ControlPanel.SnapEdit extends L.Control.ControlPanel
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super
+
+    onAdd: (map) ->
+      super map
+
+      @_container
+
+    addProperties: ->
+      super
+      @_addEditPolygon()
+
+    _addEditPolygon: ->
+      container = L.DomUtil.create 'div', 'property', @_propertiesContainer
+
+      containerTitle = L.DomUtil.create 'div', 'property-title', container
+      containerTitle.innerHTML = @options.surfaceProperty
+
+      @_areaContainer = L.DomUtil.create 'div', 'property-content', container
+
+      @_onEditingPolygon()
+      @_map.on L.ReactiveMeasure.Edit.Event.MOVE, @_onEditingPolygon, @
+
+    _onEditingPolygon: (e) ->
+      area = if e and e.measure then e.measure.area else 0
+
+      L.DomUtil.empty(@_areaContainer)
+
+      surface = L.DomUtil.create 'div', 'surface-row', @_areaContainer
+      surface.innerHTML = L.GeometryUtil.readableArea(area, true)
+
+  class L.Control.LayerSelection extends L.Control
+    @_toolbar: {}
+
+    options:
+      position: 'topleft'
+      featureGroup: undefined
+
+    constructor: (map, options) ->
+      C.Util.setOptions @, options
+      super options
+
+      @_handler = new L.LayerSelection map, featureGroup: @options.featureGroup
+
+      return
+
+    enable: ->
+      @_handler.enable()
+
+  class L.Control.LayerLocking extends L.Control
+    @_toolbar: {}
+
+    options:
+      position: 'topleft'
+      featureGroup: undefined
+
+    constructor: (map, options) ->
+      C.Util.setOptions @, options
+      super options
+
+      @_handler = new L.LayerLocking map, featureGroup: @options.featureGroup
+
+      return
+
+    enable: ->
+      @_handler.enable()
+
+  class L.Control.Cut extends L.Control
+    @_toolbar: {}
+
+    options:
+      position: 'topleft'
+      featureGroup: undefined
+      panel:
+        position: 'bottomleft'
+
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super options
+
+      if L.CutToolbar && !@_toolbar
+        @_toolbar = new L.CutToolbar @options
+
+      if @options.panel
+        new L.Control.ControlPanel.Cut @_toolbar, @options.panel
+
+    onAdd: (map) ->
+      container = L.DomUtil.create('div', 'leaflet-draw leaflet-control-cut')
+      topClassName = 'leaflet-draw-toolbar-top'
+      toolbarContainer = @_toolbar.addToolbar(map)
+      if toolbarContainer
+        L.DomUtil.addClass toolbarContainer.childNodes[0], topClassName
+      container.appendChild toolbarContainer
+      container
+
+    onRemove: ->
+      @_toolbar.removeToolbar()
+
+  class L.Control.ControlPanel.Cut extends L.Control.ControlPanel
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super
+
+    onAdd: (map) ->
+      super map
+      @_container
+
+    addProperties: ->
+      @_addSubtitle() if @options.subtitleProperty
+      super
+      @_map.on L.Cutting.Polyline.Event.CREATED, @_addCreatedPolygons, @
+
+    _addSubtitle: ->
+      container = L.DomUtil.create 'div', 'property', @_propertiesContainer
+      containerTitle = L.DomUtil.create 'div', 'property-title', container
+      containerTitle.innerHTML = @options.subtitleProperty
+
+    _addCreatedPolygons: (e) ->
+
+      container = L.DomUtil.create 'div', 'property', @_propertiesContainer
+
+      containerTitle = L.DomUtil.create 'div', 'property-title', container
+      containerTitle.innerHTML = @options.surfacesProperty
+
+      @_areaContainer = L.DomUtil.create 'div', 'property-content', container
+
+      @_onUpdateArea(e)
+
+      @_map.on L.Cutting.Polyline.Event.UPDATED, @_onUpdateArea, @
+
+    _onUpdateArea: (e) ->
+      layers = e.layers
+
+      L.DomUtil.empty(@_areaContainer)
+
+      for layer in layers
+        if layer
+          legendRow = L.DomUtil.create 'div', 'legend-row', @_areaContainer
+          legend = L.DomUtil.create 'div', 'legend', legendRow
+          area = L.DomUtil.create("div", 'legend-area', legendRow)
+          # layer.options.fillColor
+
+          if typeof layer.getLatLngs is 'function'
+            legend.style.backgroundColor = layer.options.fillColor
+            latlngs = layer.getLatLngs()
+          else
+            legend.style.backgroundColor = layer.getLayers()[0].options.fillColor
+            latlngs = layer.getLayers()[0].getLatLngs()
+
+          area.innerHTML = L.GeometryUtil.readableArea(L.GeometryUtil.geodesicArea(latlngs[0]), true)
+
+
+  class L.Control.ControlPanel.Draw extends L.Control.ControlPanel
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super
+
+    onAdd: (map) ->
+      super map
+      @_container
+
+    addProperties: ->
+      super
+      @_addDrawingPolygon()
+
+    _addDrawingPolygon: ->
+
+      container = L.DomUtil.create 'div', 'property', @_propertiesContainer
+
+      containerTitle = L.DomUtil.create 'div', 'property-title', container
+      containerTitle.innerHTML = "Surface"
+
+      @_areaContainer = L.DomUtil.create 'div', 'property-content', container
+
+      @_onDrawingPolygon()
+      @_map.on L.ReactiveMeasure.Draw.Event.MOVE, @_onDrawingPolygon, @
+
+    _onDrawingPolygon: (e) ->
+      area = if e and e.measure then e.measure.area else 0
+
+      L.DomUtil.empty(@_areaContainer)
+
+      surface = L.DomUtil.create 'div', 'surface-row', @_areaContainer
+      surface.innerHTML = L.GeometryUtil.readableArea(area, true)
+
+  class L.Control.Merge extends L.Control
+    @_toolbar: {}
+
+    options:
+      position: 'topleft'
+      featureGroup: undefined
+      panel:
+        position: 'bottomleft'
+
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super options
+
+      if L.MergeToolbar && !@_toolbar
+        @_toolbar = new L.MergeToolbar @options
+
+      if @options.panel
+        new L.Control.ControlPanel.Merge @_toolbar, @options.panel
+
+    onAdd: (map) ->
+      container = L.DomUtil.create('div', 'leaflet-draw leaflet-control-merge')
+      topClassName = 'leaflet-draw-toolbar-top'
+      toolbarContainer = @_toolbar.addToolbar(map)
+      if toolbarContainer
+        L.DomUtil.addClass toolbarContainer.childNodes[0], topClassName
+      container.appendChild toolbarContainer
+      container
+
+    onRemove: ->
+      @_toolbar.removeToolbar()
+
+
+  class L.Control.ControlPanel.Merge extends L.Control.ControlPanel
+    constructor: (options) ->
+      C.Util.setOptions @, options
+      super
+
+    onAdd: (map) ->
+      super map
+      @_container
+
+    addProperties: ->
+      super
+      # @_map.on L.Cutting.Polyline.Event.CREATED, @_addCreatedPolygons, @
+
+    _addCreatedPolygons: (e) ->
+
+      container = L.DomUtil.create 'div', 'property', @_propertiesContainer
+
+      containerTitle = L.DomUtil.create 'div', 'property-title', container
+      containerTitle.innerHTML = "Surfaces"
+
+      @_areaContainer = L.DomUtil.create 'div', 'property-content', container
+
+      @_onUpdateArea(e)
+
+      @_map.on L.Cutting.Polyline.Event.UPDATED, @_onUpdateArea, @
+
+    _onUpdateArea: (e) ->
+      layers = e.layers
+
+      L.DomUtil.empty(@_areaContainer)
+
+      for layer in layers
+        legendRow = L.DomUtil.create 'div', 'legend-row', @_areaContainer
+        legend = L.DomUtil.create 'div', 'legend', legendRow
+        area = L.DomUtil.create("div", 'legend-area', legendRow)
+        # layer.options.fillColor
+
+        if typeof layer.getLatLngs is 'function'
+          legend.style.backgroundColor = layer.options.fillColor
+          latlngs = layer.getLatLngs()
+        else
+          legend.style.backgroundColor = layer.getLayers()[0].options.fillColor
+          latlngs = layer.getLayers()[0].getLatLngs()
+
+        area.innerHTML = L.GeometryUtil.readableArea(L.GeometryUtil.geodesicArea(latlngs[0]), true)
+
+
+  class L.Control.ShapeDraw extends L.Control
+    options:
+      featureGroup: undefined
+      snapDistance: 15
+      shapeOptions:
+        color: '#FF6226'
+        className: 'leaflet-polygon-drawer'
+
+    constructor: (map, options) ->
+      C.Util.setOptions @, options
+      super options
+
+      @_handler = new L.Draw.Polygon map, @options
+
+      @_map = map
+      return
+
+    _onDrawVertex: (e) ->
+      @_map.fire C.Events.shapeDraw.start
+      @_map.off "draw:drawvertex", @_onDrawVertex, @
+
+    _onDrawingPolygon: (e) ->
+      measure = {
+        area: e.measure.extrapolatedArea,
+        perimeter: if @_handler._poly.getLatLngs().length == 1 then e.measure.perimeter else e.measure.extrapolatedPerimeter
+      }
+      @_map.fire C.Events.shapeDraw.draw, data: { measure: measure }
+
+    _onInvalidDrawingPolygon: (e) ->
+      @_map.fire C.Events.shapeDraw.warn, data: { message: e.error }
+
+    enable: ->
+      @_map.on "draw:drawvertex", @_onDrawVertex, @
+      @_map.on L.ReactiveMeasure.Draw.Event.MOVE, @_onDrawingPolygon, @
+      @_map.on L.Draw.Event.INVALIDATED, @_onInvalidDrawingPolygon, @
+      @_handler.enable()
+
+    disable: ->
+      @_map.off "draw:drawvertex", @_onDrawVertex, @
+      @_map.off L.ReactiveMeasure.Draw.Event.MOVE, @_onDrawingPolygon, @
+      @_map.off L.Draw.Event.INVALIDATED, @_onInvalidDrawingPolygon, @
+      @_handler.disable()
+
+  class L.Control.ShapeCut extends L.Control
+    options:
+      featureGroup: undefined
+      disabledPathOptions:
+        dashArray: null
+        fill: true
+        color: '#263238'
+        fillColor: '#263238'
+        opacity: 1
+        fillOpacity: 0.4
+        maintainColor: false
+      editablePathOptions:
+        dashArray: null
+        fill: true
+        color: '#1195F5'
+        fillColor: '#1195F5'
+        opacity: 1
+        fillOpacity: 0.35
+        maintainColor: false
+      selectedPathOptions:
+        dashArray: null
+        fill: true
+        fillColor: '#fe57a1'
+        opacity: 1
+        fillOpacity: 1
+        maintainColor: true
+        weight: 3
+      cuttingPathOptions:
+        color: '#FF6226'
+        className: 'leaflet-polygon-splitter'
+      cycling: 2
+
+    constructor: (map, options) ->
+      C.Util.setOptions @, options
+      super options
+
+      @_handler = new L.Cut.Polyline map, @options
+
+      @_map = map
+      return
+
+    enable: ->
+      @_handler.enable()
+
+    disable: ->
+      @_handler.disable()
+
+)(window.Cartography = window.Cartography || {})