'+h.label+"
"}}else"image"===c&&(a.innerHTML=''+a.labels[d]+"
";return L.Browser.touch?L.DomEvent.on(c,"click",L.DomEvent.stopPropagation):(L.DomEvent.disableClickPropagation(c),L.DomEvent.on(c,"mousewheel",L.DomEvent.stopPropagation)),c}};return{getOnAddLegend:b,getOnAddArrayLegend:c,updateLegend:a}}),angular.module("leaflet-directive").factory("leafletMapDefaults",["$q","leafletHelpers",function(a,b){function c(){return{keyboard:!0,dragging:!0,worldCopyJump:!1,doubleClickZoom:!0,scrollWheelZoom:!0,tap:!0,touchZoom:!0,zoomControl:!0,zoomsliderControl:!1,zoomControlPosition:"topleft",attributionControl:!0,controls:{layers:{visible:!0,position:"topright",collapsed:!0}},nominatim:{server:" http://nominatim.openstreetmap.org/search"},crs:L.CRS.EPSG3857,tileLayer:"//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",tileLayerOptions:{attribution:'© OpenStreetMap contributors'},path:{weight:10,opacity:1,color:"#0000ff"},center:{lat:0,lng:0,zoom:1}}}var d=b.isDefined,e=b.isObject,f=b.obtainEffectiveMapId,g={};return{reset:function(){g={}},getDefaults:function(a){var b=f(g,a);return g[b]},getMapCreationDefaults:function(a){var b=f(g,a),c=g[b],e={maxZoom:c.maxZoom,keyboard:c.keyboard,dragging:c.dragging,zoomControl:c.zoomControl,doubleClickZoom:c.doubleClickZoom,scrollWheelZoom:c.scrollWheelZoom,tap:c.tap,touchZoom:c.touchZoom,attributionControl:c.attributionControl,worldCopyJump:c.worldCopyJump,crs:c.crs};if(d(c.minZoom)&&(e.minZoom=c.minZoom),d(c.zoomAnimation)&&(e.zoomAnimation=c.zoomAnimation),d(c.fadeAnimation)&&(e.fadeAnimation=c.fadeAnimation),d(c.markerZoomAnimation)&&(e.markerZoomAnimation=c.markerZoomAnimation),c.map)for(var h in c.map)e[h]=c.map[h];return e},setDefaults:function(a,b){var h=c();d(a)&&(h.doubleClickZoom=d(a.doubleClickZoom)?a.doubleClickZoom:h.doubleClickZoom,h.scrollWheelZoom=d(a.scrollWheelZoom)?a.scrollWheelZoom:h.doubleClickZoom,h.tap=d(a.tap)?a.tap:h.tap,h.touchZoom=d(a.touchZoom)?a.touchZoom:h.doubleClickZoom,h.zoomControl=d(a.zoomControl)?a.zoomControl:h.zoomControl,h.zoomsliderControl=d(a.zoomsliderControl)?a.zoomsliderControl:h.zoomsliderControl,h.attributionControl=d(a.attributionControl)?a.attributionControl:h.attributionControl,h.tileLayer=d(a.tileLayer)?a.tileLayer:h.tileLayer,h.zoomControlPosition=d(a.zoomControlPosition)?a.zoomControlPosition:h.zoomControlPosition,h.keyboard=d(a.keyboard)?a.keyboard:h.keyboard,h.dragging=d(a.dragging)?a.dragging:h.dragging,d(a.controls)&&angular.extend(h.controls,a.controls),e(a.crs)?h.crs=a.crs:d(L.CRS[a.crs])&&(h.crs=L.CRS[a.crs]),d(a.center)&&angular.copy(a.center,h.center),d(a.tileLayerOptions)&&angular.copy(a.tileLayerOptions,h.tileLayerOptions),d(a.maxZoom)&&(h.maxZoom=a.maxZoom),d(a.minZoom)&&(h.minZoom=a.minZoom),d(a.zoomAnimation)&&(h.zoomAnimation=a.zoomAnimation),d(a.fadeAnimation)&&(h.fadeAnimation=a.fadeAnimation),d(a.markerZoomAnimation)&&(h.markerZoomAnimation=a.markerZoomAnimation),d(a.worldCopyJump)&&(h.worldCopyJump=a.worldCopyJump),d(a.map)&&(h.map=a.map),d(a.path)&&(h.path=a.path));var i=f(g,b);return g[i]=h,h}}}]),angular.module("leaflet-directive").service("leafletMarkersHelpers",["$rootScope","$timeout","leafletHelpers","$log","$compile","leafletGeoJsonHelpers",function(a,b,c,d,e,f){var g=c.isDefined,h=c.defaultTo,i=c.MarkerClusterPlugin,j=c.AwesomeMarkersPlugin,k=c.VectorMarkersPlugin,l=c.MakiMarkersPlugin,m=c.ExtraMarkersPlugin,n=c.DomMarkersPlugin,o=c.safeApply,p=c,q=c.isString,r=c.isNumber,s=c.isObject,t={},u=f,v=c.errorHeader,w=function(a){
var b="";return["_icon","_latlng","_leaflet_id","_map","_shadow"].forEach(function(c){b+=c+": "+h(a[c],"undefined")+" \n"}),"[leafletMarker] : \n"+b},x=function(a,b){var c=b?console:d;c.debug(w(a))},y=function(b){if(g(b)&&g(b.type)&&"awesomeMarker"===b.type)return j.isLoaded()||d.error(v+" The AwesomeMarkers Plugin is not loaded."),new L.AwesomeMarkers.icon(b);if(g(b)&&g(b.type)&&"vectorMarker"===b.type)return k.isLoaded()||d.error(v+" The VectorMarkers Plugin is not loaded."),new L.VectorMarkers.icon(b);if(g(b)&&g(b.type)&&"makiMarker"===b.type)return l.isLoaded()||d.error(v+"The MakiMarkers Plugin is not loaded."),new L.MakiMarkers.icon(b);if(g(b)&&g(b.type)&&"extraMarker"===b.type)return m.isLoaded()||d.error(v+"The ExtraMarkers Plugin is not loaded."),new L.ExtraMarkers.icon(b);if(g(b)&&g(b.type)&&"div"===b.type)return new L.divIcon(b);if(g(b)&&g(b.type)&&"dom"===b.type){n.isLoaded()||d.error(v+"The DomMarkers Plugin is not loaded.");var c=angular.isFunction(b.getMarkerScope)?b.getMarkerScope():a,f=e(b.template)(c),h=angular.copy(b);return h.element=f[0],new L.DomMarkers.icon(h)}if(g(b)&&g(b.type)&&"icon"===b.type)return b.icon;var i="data:image/png;base64,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",o="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACkAAAApCAYAAACoYAD2AAAC5ElEQVRYw+2YW4/TMBCF45S0S1luXZCABy5CgLQgwf//S4BYBLTdJLax0fFqmB07nnQfEGqkIydpVH85M+NLjPe++dcPc4Q8Qh4hj5D/AaQJx6H/4TMwB0PeBNwU7EGQAmAtsNfAzoZkgIa0ZgLMa4Aj6CxIAsjhjOCoL5z7Glg1JAOkaicgvQBXuncwJAWjksLtBTWZe04CnYRktUGdilALppZBOgHGZcBzL6OClABvMSVIzyBjazOgrvACf1ydC5mguqAVg6RhdkSWQFj2uxfaq/BrIZOLEWgZdALIDvcMcZLD8ZbLC9de4yR1sYMi4G20S4Q/PWeJYxTOZn5zJXANZHIxAd4JWhPIloTJZhzMQduM89WQ3MUVAE/RnhAXpTycqys3NZALOBbB7kFrgLesQl2h45Fcj8L1tTSohUwuxhy8H/Qg6K7gIs+3kkaigQCOcyEXCHN07wyQazhrmIulvKMQAwMcmLNqyCVyMAI+BuxSMeTk3OPikLY2J1uE+VHQk6ANrhds+tNARqBeaGc72cK550FP4WhXmFmcMGhTwAR1ifOe3EvPqIegFmF+C8gVy0OfAaWQPMR7gF1OQKqGoBjq90HPMP01BUjPOqGFksC4emE48tWQAH0YmvOgF3DST6xieJgHAWxPAHMuNhrImIdvoNOKNWIOcE+UXE0pYAnkX6uhWsgVXDxHdTfCmrEEmMB2zMFimLVOtiiajxiGWrbU52EeCdyOwPEQD8LqyPH9Ti2kgYMf4OhSKB7qYILbBv3CuVTJ11Y80oaseiMWOONc/Y7kJYe0xL2f0BaiFTxknHO5HaMGMublKwxFGzYdWsBF174H/QDknhTHmHHN39iWFnkZx8lPyM8WHfYELmlLKtgWNmFNzQcC1b47gJ4hL19i7o65dhH0Negbca8vONZoP7doIeOC9zXm8RjuL0Gf4d4OYaU5ljo3GYiqzrWQHfJxA6ALhDpVKv9qYeZA8eM3EhfPSCmpuD0AAAAASUVORK5CYII=";return g(b)&&g(b.iconUrl)?new L.Icon(b):new L.Icon.Default({iconUrl:i,shadowUrl:o,iconSize:[25,41],iconAnchor:[12,41],popupAnchor:[1,-34],shadowSize:[41,41]})},z=function(a){g(t[a])&&t.splice(a,1)},A=function(){t={}},B=function(a,b,c){if(a.closePopup(),g(c)&&g(c.overlays))for(var d in c.overlays)if((c.overlays[d]instanceof L.LayerGroup||c.overlays[d]instanceof L.FeatureGroup)&&c.overlays[d].hasLayer(a))return void c.overlays[d].removeLayer(a);if(g(t))for(var e in t)t[e].hasLayer(a)&&t[e].removeLayer(a);b.hasLayer(a)&&b.removeLayer(a)},C=function(a,b){var c=a._popup._container.offsetHeight,d=new L.Point(a._popup._containerLeft,-c-a._popup._containerBottom),e=b.layerPointToContainerPoint(d);null!==e&&a._popup._adjustPan()},D=function(a,b){e(a._popup._contentNode)(b)},E=function(a,c,d){var e=a._popup._contentNode.innerText||a._popup._contentNode.textContent;e.length<1&&b(function(){E(a,c,d)});var f=a._popup._contentNode.offsetWidth;return a._popup._updateLayout(),a._popup._updatePosition(),a._popup.options.autoPan&&C(a,d),f},F=function(b,c,e){var f=angular.isFunction(c.getMessageScope)?c.getMessageScope():a,h=g(c.compileMessage)?c.compileMessage:!0;if(h){if(!g(b._popup)||!g(b._popup._contentNode))return d.error(v+"Popup is invalid or does not have any content."),!1;D(b,f),E(b,c,e)}},G=function(b,c){var d=angular.isFunction(c.getMessageScope)?c.getMessageScope():a,f=angular.isFunction(c.getLabelScope)?c.getLabelScope():d,h=g(c.compileMessage)?c.compileMessage:!0;p.LabelPlugin.isLoaded()&&g(c.label)&&(g(c.label.options)&&c.label.options.noHide===!0&&b.showLabel(),h&&g(b.label)&&e(b.label._container)(f))},H=function(a,b,c,e,f,h,i){if(g(b)){if(!u.validateCoords(a))return d.warn("There are problems with lat-lng data, please verify your marker model"),void B(c,i,h);var j=a===b;if(g(a.iconAngle)&&b.iconAngle!==a.iconAngle&&c.setIconAngle(a.iconAngle),q(a.layer)||q(b.layer)&&(g(h.overlays[b.layer])&&h.overlays[b.layer].hasLayer(c)&&(h.overlays[b.layer].removeLayer(c),c.closePopup()),i.hasLayer(c)||i.addLayer(c)),(r(a.opacity)||r(parseFloat(a.opacity)))&&a.opacity!==b.opacity&&c.setOpacity(a.opacity),q(a.layer)&&b.layer!==a.layer){if(q(b.layer)&&g(h.overlays[b.layer])&&h.overlays[b.layer].hasLayer(c)&&h.overlays[b.layer].removeLayer(c),c.closePopup(),i.hasLayer(c)&&i.removeLayer(c),!g(h.overlays[a.layer]))return void d.error(v+"You must use a name of an existing layer");var k=h.overlays[a.layer];if(!(k instanceof L.LayerGroup||k instanceof L.FeatureGroup))return void d.error(v+'A marker can only be added to a layer of type "group" or "featureGroup"');k.addLayer(c),i.hasLayer(c)&&a.focus===!0&&c.openPopup()}if(a.draggable!==!0&&b.draggable===!0&&g(c.dragging)&&c.dragging.disable(),a.draggable===!0&&b.draggable!==!0&&(c.dragging?c.dragging.enable():L.Handler.MarkerDrag&&(c.dragging=new L.Handler.MarkerDrag(c),c.options.draggable=!0,c.dragging.enable())),s(a.icon)||s(b.icon)&&(c.setIcon(y()),c.closePopup(),c.unbindPopup(),q(a.message)&&c.bindPopup(a.message,a.popupOptions)),s(a.icon)&&s(b.icon)&&!angular.equals(a.icon,b.icon)){var l=!1;c.dragging&&(l=c.dragging.enabled()),c.setIcon(y(a.icon)),l&&c.dragging.enable(),c.closePopup(),c.unbindPopup(),q(a.message)&&(c.bindPopup(a.message,a.popupOptions),i.hasLayer(c)&&a.focus===!0&&c.openPopup())}!q(a.message)&&q(b.message)&&(c.closePopup(),c.unbindPopup()),p.LabelPlugin.isLoaded()&&(g(a.label)&&g(a.label.message)?"label"in b&&"message"in b.label&&!angular.equals(a.label.message,b.label.message)?c.updateLabelContent(a.label.message):!angular.isFunction(c.getLabel)||angular.isFunction(c.getLabel)&&!g(c.getLabel())?(c.bindLabel(a.label.message,a.label.options),G(c,a)):G(c,a):(!("label"in a)||"message"in a.label)&&angular.isFunction(c.unbindLabel)&&c.unbindLabel()),q(a.message)&&!q(b.message)&&c.bindPopup(a.message,a.popupOptions),q(a.message)&&q(b.message)&&a.message!==b.message&&c.setPopupContent(a.message);var m=!1;a.focus!==!0&&b.focus===!0&&(c.closePopup(),m=!0),(a.focus===!0&&(!g(b.focus)||b.focus===!1)||j&&a.focus===!0)&&(c.openPopup(),m=!0),b.zIndexOffset!==a.zIndexOffset&&c.setZIndexOffset(a.zIndexOffset);var n=c.getLatLng(),o=q(a.layer)&&p.MarkerClusterPlugin.is(h.overlays[a.layer]);o?m?(a.lat!==b.lat||a.lng!==b.lng)&&(h.overlays[a.layer].removeLayer(c),c.setLatLng([a.lat,a.lng]),h.overlays[a.layer].addLayer(c)):n.lat!==a.lat||n.lng!==a.lng?(h.overlays[a.layer].removeLayer(c),c.setLatLng([a.lat,a.lng]),h.overlays[a.layer].addLayer(c)):a.lat!==b.lat||a.lng!==b.lng?(h.overlays[a.layer].removeLayer(c),c.setLatLng([a.lat,a.lng]),h.overlays[a.layer].addLayer(c)):s(a.icon)&&s(b.icon)&&!angular.equals(a.icon,b.icon)&&(h.overlays[a.layer].removeLayer(c),h.overlays[a.layer].addLayer(c)):(n.lat!==a.lat||n.lng!==a.lng)&&c.setLatLng([a.lat,a.lng])}};return{resetMarkerGroup:z,resetMarkerGroups:A,deleteMarker:B,manageOpenPopup:F,manageOpenLabel:G,createMarker:function(a){if(!g(a)||!u.validateCoords(a))return void d.error(v+"The marker definition is not valid.");var b=u.getCoords(a);if(!g(b))return void d.error(v+"Unable to get coordinates from markerData.");var c={icon:y(a.icon),title:g(a.title)?a.title:"",draggable:g(a.draggable)?a.draggable:!1,clickable:g(a.clickable)?a.clickable:!0,riseOnHover:g(a.riseOnHover)?a.riseOnHover:!1,zIndexOffset:g(a.zIndexOffset)?a.zIndexOffset:0,iconAngle:g(a.iconAngle)?a.iconAngle:0};for(var e in a)a.hasOwnProperty(e)&&!c.hasOwnProperty(e)&&(c[e]=a[e]);var f=new L.marker(b,c);return q(a.message)||f.unbindPopup(),f},addMarkerToGroup:function(a,b,c,e){return q(b)?i.isLoaded()?(g(t[b])||(t[b]=new L.MarkerClusterGroup(c),e.addLayer(t[b])),void t[b].addLayer(a)):void d.error(v+"The MarkerCluster plugin is not loaded."):void d.error(v+"The marker group you have specified is invalid.")},listenMarkerEvents:function(a,b,c,d,e){a.on("popupopen",function(){o(c,function(){(g(a._popup)||g(a._popup._contentNode))&&(b.focus=!0,F(a,b,e))})}),a.on("popupclose",function(){o(c,function(){b.focus=!1})}),a.on("add",function(){o(c,function(){"label"in b&&G(a,b)})})},updateMarker:H,addMarkerWatcher:function(a,b,c,d,e,f){var i=p.getObjectArrayPath("markers."+b);f=h(f,!0);var j=c.$watch(i,function(f,h){return g(f)?void H(f,h,a,b,c,d,e):(B(a,e,d),void j())},f)},string:w,log:x}}]),angular.module("leaflet-directive").factory("leafletPathsHelpers",["$rootScope","$log","leafletHelpers",function(a,b,c){function d(a){return a.filter(function(a){return k(a)}).map(function(a){return e(a)})}function e(a){return i(a)?new L.LatLng(a[0],a[1]):new L.LatLng(a.lat,a.lng)}function f(a){return a.map(function(a){return d(a)})}function g(a,b){for(var c={},d=0;d{{ title }}
{{ baseTitle }}
' + legendData.error.message + '
';
+ } else {
+ if (type === 'arcgis') {
+ for (var i = 0; i < legendData.layers.length; i++) {
+ var layer = legendData.layers[i];
+ div.innerHTML += '' + layer.layerName + '
';
+ for(var j = 0; j < layer.legend.length; j++) {
+ var leg = layer.legend[j];
+ div.innerHTML +=
+ '' + leg.label + '
';
+ }
+ }
+ }
+ else if (type === 'image') {
+ div.innerHTML = '' +
+ '
' + legend.labels[i] + '
';
+ }
+ if (!L.Browser.touch) {
+ L.DomEvent.disableClickPropagation(div);
+ L.DomEvent.on(div, 'mousewheel', L.DomEvent.stopPropagation);
+ } else {
+ L.DomEvent.on(div, 'click', L.DomEvent.stopPropagation);
+ }
+ return div;
+ };
+ };
+
+ return {
+ getOnAddLegend: _getOnAddLegend,
+ getOnAddArrayLegend: _getOnAddArrayLegend,
+ updateLegend: _updateLegend
+ };
+});
+
+angular.module("leaflet-directive").factory('leafletMapDefaults', ["$q", "leafletHelpers", function ($q, leafletHelpers) {
+ function _getDefaults() {
+ return {
+ keyboard: true,
+ dragging: true,
+ worldCopyJump: false,
+ doubleClickZoom: true,
+ scrollWheelZoom: true,
+ tap: true,
+ touchZoom: true,
+ zoomControl: true,
+ zoomsliderControl: false,
+ zoomControlPosition: 'topleft',
+ attributionControl: true,
+ controls: {
+ layers: {
+ visible: true,
+ position: 'topright',
+ collapsed: true
+ }
+ },
+ nominatim: {
+ server: ' http://nominatim.openstreetmap.org/search'
+ },
+ crs: L.CRS.EPSG3857,
+ tileLayer: '//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+ tileLayerOptions: {
+ attribution: '© OpenStreetMap contributors'
+ },
+ path: {
+ weight: 10,
+ opacity: 1,
+ color: '#0000ff'
+ },
+ center: {
+ lat: 0,
+ lng: 0,
+ zoom: 1
+ }
+ };
+ }
+
+ var isDefined = leafletHelpers.isDefined,
+ isObject = leafletHelpers.isObject,
+ obtainEffectiveMapId = leafletHelpers.obtainEffectiveMapId,
+ defaults = {};
+
+ // Get the _defaults dictionary, and override the properties defined by the user
+ return {
+ reset: function () {
+ defaults = {};
+ },
+ getDefaults: function (scopeId) {
+ var mapId = obtainEffectiveMapId(defaults, scopeId);
+ return defaults[mapId];
+ },
+
+ getMapCreationDefaults: function (scopeId) {
+ var mapId = obtainEffectiveMapId(defaults, scopeId);
+ var d = defaults[mapId];
+
+ var mapDefaults = {
+ maxZoom: d.maxZoom,
+ keyboard: d.keyboard,
+ dragging: d.dragging,
+ zoomControl: d.zoomControl,
+ doubleClickZoom: d.doubleClickZoom,
+ scrollWheelZoom: d.scrollWheelZoom,
+ tap: d.tap,
+ touchZoom: d.touchZoom,
+ attributionControl: d.attributionControl,
+ worldCopyJump: d.worldCopyJump,
+ crs: d.crs
+ };
+
+ if (isDefined(d.minZoom)) {
+ mapDefaults.minZoom = d.minZoom;
+ }
+
+ if (isDefined(d.zoomAnimation)) {
+ mapDefaults.zoomAnimation = d.zoomAnimation;
+ }
+
+ if (isDefined(d.fadeAnimation)) {
+ mapDefaults.fadeAnimation = d.fadeAnimation;
+ }
+
+ if (isDefined(d.markerZoomAnimation)) {
+ mapDefaults.markerZoomAnimation = d.markerZoomAnimation;
+ }
+
+ if (d.map) {
+ for (var option in d.map) {
+ mapDefaults[option] = d.map[option];
+ }
+ }
+
+ return mapDefaults;
+ },
+
+ setDefaults: function (userDefaults, scopeId) {
+ var newDefaults = _getDefaults();
+
+ if (isDefined(userDefaults)) {
+ newDefaults.doubleClickZoom = isDefined(userDefaults.doubleClickZoom) ? userDefaults.doubleClickZoom : newDefaults.doubleClickZoom;
+ newDefaults.scrollWheelZoom = isDefined(userDefaults.scrollWheelZoom) ? userDefaults.scrollWheelZoom : newDefaults.doubleClickZoom;
+ newDefaults.tap = isDefined(userDefaults.tap) ? userDefaults.tap : newDefaults.tap;
+ newDefaults.touchZoom = isDefined(userDefaults.touchZoom) ? userDefaults.touchZoom : newDefaults.doubleClickZoom;
+ newDefaults.zoomControl = isDefined(userDefaults.zoomControl) ? userDefaults.zoomControl : newDefaults.zoomControl;
+ newDefaults.zoomsliderControl = isDefined(userDefaults.zoomsliderControl) ? userDefaults.zoomsliderControl : newDefaults.zoomsliderControl;
+ newDefaults.attributionControl = isDefined(userDefaults.attributionControl) ? userDefaults.attributionControl : newDefaults.attributionControl;
+ newDefaults.tileLayer = isDefined(userDefaults.tileLayer) ? userDefaults.tileLayer : newDefaults.tileLayer;
+ newDefaults.zoomControlPosition = isDefined(userDefaults.zoomControlPosition) ? userDefaults.zoomControlPosition : newDefaults.zoomControlPosition;
+ newDefaults.keyboard = isDefined(userDefaults.keyboard) ? userDefaults.keyboard : newDefaults.keyboard;
+ newDefaults.dragging = isDefined(userDefaults.dragging) ? userDefaults.dragging : newDefaults.dragging;
+
+ if (isDefined(userDefaults.controls)) {
+ angular.extend(newDefaults.controls, userDefaults.controls);
+ }
+
+ if (isObject(userDefaults.crs)) {
+ newDefaults.crs = userDefaults.crs;
+ } else if (isDefined(L.CRS[userDefaults.crs])) {
+ newDefaults.crs = L.CRS[userDefaults.crs];
+ }
+
+ if (isDefined(userDefaults.center)) {
+ angular.copy(userDefaults.center, newDefaults.center);
+ }
+
+ if (isDefined(userDefaults.tileLayerOptions)) {
+ angular.copy(userDefaults.tileLayerOptions, newDefaults.tileLayerOptions);
+ }
+
+ if (isDefined(userDefaults.maxZoom)) {
+ newDefaults.maxZoom = userDefaults.maxZoom;
+ }
+
+ if (isDefined(userDefaults.minZoom)) {
+ newDefaults.minZoom = userDefaults.minZoom;
+ }
+
+ if (isDefined(userDefaults.zoomAnimation)) {
+ newDefaults.zoomAnimation = userDefaults.zoomAnimation;
+ }
+
+ if (isDefined(userDefaults.fadeAnimation)) {
+ newDefaults.fadeAnimation = userDefaults.fadeAnimation;
+ }
+
+ if (isDefined(userDefaults.markerZoomAnimation)) {
+ newDefaults.markerZoomAnimation = userDefaults.markerZoomAnimation;
+ }
+
+ if (isDefined(userDefaults.worldCopyJump)) {
+ newDefaults.worldCopyJump = userDefaults.worldCopyJump;
+ }
+
+ if (isDefined(userDefaults.map)) {
+ newDefaults.map = userDefaults.map;
+ }
+
+ if (isDefined(userDefaults.path)) {
+ newDefaults.path = userDefaults.path;
+ }
+ }
+
+ var mapId = obtainEffectiveMapId(defaults, scopeId);
+ defaults[mapId] = newDefaults;
+ return newDefaults;
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").service('leafletMarkersHelpers', ["$rootScope", "$timeout", "leafletHelpers", "$log", "$compile", "leafletGeoJsonHelpers", function ($rootScope, $timeout, leafletHelpers, $log, $compile, leafletGeoJsonHelpers) {
+ var isDefined = leafletHelpers.isDefined,
+ defaultTo = leafletHelpers.defaultTo,
+ MarkerClusterPlugin = leafletHelpers.MarkerClusterPlugin,
+ AwesomeMarkersPlugin = leafletHelpers.AwesomeMarkersPlugin,
+ VectorMarkersPlugin = leafletHelpers.VectorMarkersPlugin,
+ MakiMarkersPlugin = leafletHelpers.MakiMarkersPlugin,
+ ExtraMarkersPlugin = leafletHelpers.ExtraMarkersPlugin,
+ DomMarkersPlugin = leafletHelpers.DomMarkersPlugin,
+ safeApply = leafletHelpers.safeApply,
+ Helpers = leafletHelpers,
+ isString = leafletHelpers.isString,
+ isNumber = leafletHelpers.isNumber,
+ isObject = leafletHelpers.isObject,
+ groups = {},
+ geoHlp = leafletGeoJsonHelpers,
+ errorHeader = leafletHelpers.errorHeader;
+
+ var _string = function (marker) {
+ //this exists since JSON.stringify barfs on cyclic
+ var retStr = '';
+ ['_icon', '_latlng', '_leaflet_id', '_map', '_shadow'].forEach(function (prop) {
+ retStr += prop + ': ' + defaultTo(marker[prop], 'undefined') + ' \n';
+ });
+ return '[leafletMarker] : \n' + retStr;
+ };
+ var _log = function (marker, useConsole) {
+ var logger = useConsole ? console : $log;
+ logger.debug(_string(marker));
+ };
+
+ var createLeafletIcon = function (iconData) {
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'awesomeMarker') {
+ if (!AwesomeMarkersPlugin.isLoaded()) {
+ $log.error(errorHeader + ' The AwesomeMarkers Plugin is not loaded.');
+ }
+
+ return new L.AwesomeMarkers.icon(iconData);
+ }
+
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'vectorMarker') {
+ if (!VectorMarkersPlugin.isLoaded()) {
+ $log.error(errorHeader + ' The VectorMarkers Plugin is not loaded.');
+ }
+
+ return new L.VectorMarkers.icon(iconData);
+ }
+
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'makiMarker') {
+ if (!MakiMarkersPlugin.isLoaded()) {
+ $log.error(errorHeader + 'The MakiMarkers Plugin is not loaded.');
+ }
+
+ return new L.MakiMarkers.icon(iconData);
+ }
+
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'extraMarker') {
+ if (!ExtraMarkersPlugin.isLoaded()) {
+ $log.error(errorHeader + 'The ExtraMarkers Plugin is not loaded.');
+ }
+ return new L.ExtraMarkers.icon(iconData);
+ }
+
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'div') {
+ return new L.divIcon(iconData);
+ }
+
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'dom') {
+ if (!DomMarkersPlugin.isLoaded()) {
+ $log.error(errorHeader + 'The DomMarkers Plugin is not loaded.');
+ }
+ var markerScope = angular.isFunction(iconData.getMarkerScope) ? iconData.getMarkerScope() : $rootScope,
+ template = $compile(iconData.template)(markerScope),
+ iconDataCopy = angular.copy(iconData);
+ iconDataCopy.element = template[0];
+ return new L.DomMarkers.icon(iconDataCopy);
+ }
+
+ // allow for any custom icon to be used... assumes the icon has already been initialized
+ if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'icon') {
+ return iconData.icon;
+ }
+
+ var base64icon = "data:image/png;base64,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";
+ var base64shadow = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACkAAAApCAYAAACoYAD2AAAC5ElEQVRYw+2YW4/TMBCF45S0S1luXZCABy5CgLQgwf//S4BYBLTdJLax0fFqmB07nnQfEGqkIydpVH85M+NLjPe++dcPc4Q8Qh4hj5D/AaQJx6H/4TMwB0PeBNwU7EGQAmAtsNfAzoZkgIa0ZgLMa4Aj6CxIAsjhjOCoL5z7Glg1JAOkaicgvQBXuncwJAWjksLtBTWZe04CnYRktUGdilALppZBOgHGZcBzL6OClABvMSVIzyBjazOgrvACf1ydC5mguqAVg6RhdkSWQFj2uxfaq/BrIZOLEWgZdALIDvcMcZLD8ZbLC9de4yR1sYMi4G20S4Q/PWeJYxTOZn5zJXANZHIxAd4JWhPIloTJZhzMQduM89WQ3MUVAE/RnhAXpTycqys3NZALOBbB7kFrgLesQl2h45Fcj8L1tTSohUwuxhy8H/Qg6K7gIs+3kkaigQCOcyEXCHN07wyQazhrmIulvKMQAwMcmLNqyCVyMAI+BuxSMeTk3OPikLY2J1uE+VHQk6ANrhds+tNARqBeaGc72cK550FP4WhXmFmcMGhTwAR1ifOe3EvPqIegFmF+C8gVy0OfAaWQPMR7gF1OQKqGoBjq90HPMP01BUjPOqGFksC4emE48tWQAH0YmvOgF3DST6xieJgHAWxPAHMuNhrImIdvoNOKNWIOcE+UXE0pYAnkX6uhWsgVXDxHdTfCmrEEmMB2zMFimLVOtiiajxiGWrbU52EeCdyOwPEQD8LqyPH9Ti2kgYMf4OhSKB7qYILbBv3CuVTJ11Y80oaseiMWOONc/Y7kJYe0xL2f0BaiFTxknHO5HaMGMublKwxFGzYdWsBF174H/QDknhTHmHHN39iWFnkZx8lPyM8WHfYELmlLKtgWNmFNzQcC1b47gJ4hL19i7o65dhH0Negbca8vONZoP7doIeOC9zXm8RjuL0Gf4d4OYaU5ljo3GYiqzrWQHfJxA6ALhDpVKv9qYeZA8eM3EhfPSCmpuD0AAAAASUVORK5CYII=";
+
+ if (!isDefined(iconData) || !isDefined(iconData.iconUrl)) {
+ return new L.Icon.Default({
+ iconUrl: base64icon,
+ shadowUrl: base64shadow,
+ iconSize: [25, 41],
+ iconAnchor: [12, 41],
+ popupAnchor: [1, -34],
+ shadowSize: [41, 41]
+ });
+ }
+
+ return new L.Icon(iconData);
+ };
+
+ var _resetMarkerGroup = function (groupName) {
+ if (isDefined(groups[groupName])) {
+ groups.splice(groupName, 1);
+ }
+ };
+
+ var _resetMarkerGroups = function () {
+ groups = {};
+ };
+
+ var _deleteMarker = function (marker, map, layers) {
+ marker.closePopup();
+ // There is no easy way to know if a marker is added to a layer, so we search for it
+ // if there are overlays
+ if (isDefined(layers) && isDefined(layers.overlays)) {
+ for (var key in layers.overlays) {
+ if (layers.overlays[key] instanceof L.LayerGroup || layers.overlays[key] instanceof L.FeatureGroup) {
+ if (layers.overlays[key].hasLayer(marker)) {
+ layers.overlays[key].removeLayer(marker);
+ return;
+ }
+ }
+ }
+ }
+
+ if (isDefined(groups)) {
+ for (var groupKey in groups) {
+ if (groups[groupKey].hasLayer(marker)) {
+ groups[groupKey].removeLayer(marker);
+ }
+ }
+ }
+
+ if (map.hasLayer(marker)) {
+ map.removeLayer(marker);
+ }
+ };
+
+ var adjustPopupPan = function(marker, map) {
+ var containerHeight = marker._popup._container.offsetHeight,
+ layerPos = new L.Point(marker._popup._containerLeft, -containerHeight - marker._popup._containerBottom),
+ containerPos = map.layerPointToContainerPoint(layerPos);
+ if (containerPos !== null) {
+ marker._popup._adjustPan();
+ }
+ };
+
+ var compilePopup = function(marker, markerScope) {
+ $compile(marker._popup._contentNode)(markerScope);
+ };
+
+ var updatePopup = function (marker, markerScope, map) {
+ //The innerText should be more than 1 once angular has compiled.
+ //We need to keep trying until angular has compiled before we _updateLayout and _updatePosition
+ //This should take care of any scenario , eg ngincludes, whatever.
+ //Is there a better way to check for this?
+ var innerText = marker._popup._contentNode.innerText || marker._popup._contentNode.textContent;
+ if (innerText.length < 1) {
+ $timeout(function () {
+ updatePopup(marker, markerScope, map);
+ });
+ }
+
+ //cause a reflow - this is also very important - if we don't do this then the widths are from before $compile
+ var reflow = marker._popup._contentNode.offsetWidth;
+
+ marker._popup._updateLayout();
+ marker._popup._updatePosition();
+
+ if (marker._popup.options.autoPan) {
+ adjustPopupPan(marker, map);
+ }
+
+ //using / returning reflow so jshint doesn't moan
+ return reflow;
+ };
+
+ var _manageOpenPopup = function (marker, markerData, map) {
+ // The marker may provide a scope returning function used to compile the message
+ // default to $rootScope otherwise
+ var markerScope = angular.isFunction(markerData.getMessageScope) ? markerData.getMessageScope() : $rootScope,
+ compileMessage = isDefined(markerData.compileMessage) ? markerData.compileMessage : true;
+
+ if (compileMessage) {
+ if (!isDefined(marker._popup) || !isDefined(marker._popup._contentNode)) {
+ $log.error(errorHeader + 'Popup is invalid or does not have any content.');
+ return false;
+ }
+
+ compilePopup(marker, markerScope);
+ updatePopup(marker, markerData, map);
+ }
+ };
+
+
+ var _manageOpenLabel = function (marker, markerData) {
+ var markerScope = angular.isFunction(markerData.getMessageScope) ? markerData.getMessageScope() : $rootScope,
+ labelScope = angular.isFunction(markerData.getLabelScope) ? markerData.getLabelScope() : markerScope,
+ compileMessage = isDefined(markerData.compileMessage) ? markerData.compileMessage : true;
+
+ if (Helpers.LabelPlugin.isLoaded() && isDefined(markerData.label)) {
+ if (isDefined(markerData.label.options) && markerData.label.options.noHide === true) {
+ marker.showLabel();
+ }
+ if (compileMessage && isDefined(marker.label)) {
+ $compile(marker.label._container)(labelScope);
+ }
+ }
+ };
+
+ var _updateMarker = function (markerData, oldMarkerData, marker, name, leafletScope, layers, map) {
+ if (!isDefined(oldMarkerData)) {
+ return;
+ }
+
+ // Update the lat-lng property (always present in marker properties)
+ if (!geoHlp.validateCoords(markerData)) {
+ $log.warn('There are problems with lat-lng data, please verify your marker model');
+ _deleteMarker(marker, map, layers);
+ return;
+ }
+
+ // watch is being initialized if old and new object is the same
+ var isInitializing = markerData === oldMarkerData;
+
+ // Update marker rotation
+ if (isDefined(markerData.iconAngle) && oldMarkerData.iconAngle !== markerData.iconAngle) {
+ marker.setIconAngle(markerData.iconAngle);
+ }
+
+ // It is possible that the layer has been removed or the layer marker does not exist
+ // Update the layer group if present or move it to the map if not
+ if (!isString(markerData.layer)) {
+ // There is no layer information, we move the marker to the map if it was in a layer group
+ if (isString(oldMarkerData.layer)) {
+ // Remove from the layer group that is supposed to be
+ if (isDefined(layers.overlays[oldMarkerData.layer]) && layers.overlays[oldMarkerData.layer].hasLayer(marker)) {
+ layers.overlays[oldMarkerData.layer].removeLayer(marker);
+ marker.closePopup();
+ }
+ // Test if it is not on the map and add it
+ if (!map.hasLayer(marker)) {
+ map.addLayer(marker);
+ }
+ }
+ }
+
+ if ((isNumber(markerData.opacity) || isNumber(parseFloat(markerData.opacity))) && markerData.opacity !== oldMarkerData.opacity) {
+ // There was a different opacity so we update it
+ marker.setOpacity(markerData.opacity);
+ }
+
+ if (isString(markerData.layer) && oldMarkerData.layer !== markerData.layer) {
+ // If it was on a layer group we have to remove it
+ if (isString(oldMarkerData.layer) && isDefined(layers.overlays[oldMarkerData.layer]) && layers.overlays[oldMarkerData.layer].hasLayer(marker)) {
+ layers.overlays[oldMarkerData.layer].removeLayer(marker);
+ }
+ marker.closePopup();
+
+ // Remove it from the map in case the new layer is hidden or there is an error in the new layer
+ if (map.hasLayer(marker)) {
+ map.removeLayer(marker);
+ }
+
+ // The markerData.layer is defined so we add the marker to the layer if it is different from the old data
+ if (!isDefined(layers.overlays[markerData.layer])) {
+ $log.error(errorHeader + 'You must use a name of an existing layer');
+ return;
+ }
+ // Is a group layer?
+ var layerGroup = layers.overlays[markerData.layer];
+ if (!(layerGroup instanceof L.LayerGroup || layerGroup instanceof L.FeatureGroup)) {
+ $log.error(errorHeader + 'A marker can only be added to a layer of type "group" or "featureGroup"');
+ return;
+ }
+ // The marker goes to a correct layer group, so first of all we add it
+ layerGroup.addLayer(marker);
+ // The marker is automatically added to the map depending on the visibility
+ // of the layer, so we only have to open the popup if the marker is in the map
+ if (map.hasLayer(marker) && markerData.focus === true) {
+ marker.openPopup();
+ }
+ }
+
+ // Update the draggable property
+ if (markerData.draggable !== true && oldMarkerData.draggable === true && (isDefined(marker.dragging))) {
+ marker.dragging.disable();
+ }
+
+ if (markerData.draggable === true && oldMarkerData.draggable !== true) {
+ // The markerData.draggable property must be true so we update if there wasn't a previous value or it wasn't true
+ if (marker.dragging) {
+ marker.dragging.enable();
+ } else {
+ if (L.Handler.MarkerDrag) {
+ marker.dragging = new L.Handler.MarkerDrag(marker);
+ marker.options.draggable = true;
+ marker.dragging.enable();
+ }
+ }
+ }
+
+ // Update the icon property
+ if (!isObject(markerData.icon)) {
+ // If there is no icon property or it's not an object
+ if (isObject(oldMarkerData.icon)) {
+ // If there was an icon before restore to the default
+ marker.setIcon(createLeafletIcon());
+ marker.closePopup();
+ marker.unbindPopup();
+ if (isString(markerData.message)) {
+ marker.bindPopup(markerData.message, markerData.popupOptions);
+ }
+ }
+ }
+
+ if (isObject(markerData.icon) && isObject(oldMarkerData.icon) && !angular.equals(markerData.icon, oldMarkerData.icon)) {
+ var dragG = false;
+ if (marker.dragging) {
+ dragG = marker.dragging.enabled();
+ }
+ marker.setIcon(createLeafletIcon(markerData.icon));
+ if (dragG) {
+ marker.dragging.enable();
+ }
+ marker.closePopup();
+ marker.unbindPopup();
+ if (isString(markerData.message)) {
+ marker.bindPopup(markerData.message, markerData.popupOptions);
+ // if marker has been already focused, reopen popup
+ if (map.hasLayer(marker) && markerData.focus === true) {
+ marker.openPopup();
+ }
+ }
+ }
+
+ // Update the Popup message property
+ if (!isString(markerData.message) && isString(oldMarkerData.message)) {
+ marker.closePopup();
+ marker.unbindPopup();
+ }
+
+ // Update the label content or bind a new label if the old one has been removed.
+ if (Helpers.LabelPlugin.isLoaded()) {
+ if (isDefined(markerData.label) && isDefined(markerData.label.message)) {
+ if ('label' in oldMarkerData && 'message' in oldMarkerData.label && !angular.equals(markerData.label.message, oldMarkerData.label.message)) {
+ marker.updateLabelContent(markerData.label.message);
+ } else if (!angular.isFunction(marker.getLabel) || angular.isFunction(marker.getLabel) && !isDefined(marker.getLabel())) {
+ marker.bindLabel(markerData.label.message, markerData.label.options);
+ _manageOpenLabel(marker, markerData);
+ } else {
+ _manageOpenLabel(marker, markerData);
+ }
+ } else if (!('label' in markerData && !('message' in markerData.label))) {
+ if (angular.isFunction(marker.unbindLabel)) {
+ marker.unbindLabel();
+ }
+ }
+ }
+
+ // There is some text in the popup, so we must show the text or update existing
+ if (isString(markerData.message) && !isString(oldMarkerData.message)) {
+ // There was no message before so we create it
+ marker.bindPopup(markerData.message, markerData.popupOptions);
+ }
+
+ if (isString(markerData.message) && isString(oldMarkerData.message) && markerData.message !== oldMarkerData.message) {
+ // There was a different previous message so we update it
+ marker.setPopupContent(markerData.message);
+ }
+
+ // Update the focus property
+ var updatedFocus = false;
+ if (markerData.focus !== true && oldMarkerData.focus === true) {
+ // If there was a focus property and was true we turn it off
+ marker.closePopup();
+ updatedFocus = true;
+ }
+
+ // The markerData.focus property must be true so we update if there wasn't a previous value or it wasn't true
+ if (markerData.focus === true && ( !isDefined(oldMarkerData.focus) || oldMarkerData.focus === false) || (isInitializing && markerData.focus === true)) {
+ // Reopen the popup when focus is still true
+ marker.openPopup();
+ updatedFocus = true;
+ }
+
+ // zIndexOffset adjustment
+ if (oldMarkerData.zIndexOffset !== markerData.zIndexOffset) {
+ marker.setZIndexOffset(markerData.zIndexOffset);
+ }
+
+ var markerLatLng = marker.getLatLng();
+ var isCluster = (isString(markerData.layer) && Helpers.MarkerClusterPlugin.is(layers.overlays[markerData.layer]));
+ // If the marker is in a cluster it has to be removed and added to the layer when the location is changed
+ if (isCluster) {
+ // The focus has changed even by a user click or programatically
+ if (updatedFocus) {
+ // We only have to update the location if it was changed programatically, because it was
+ // changed by a user drag the marker data has already been updated by the internal event
+ // listened by the directive
+ if ((markerData.lat !== oldMarkerData.lat) || (markerData.lng !== oldMarkerData.lng)) {
+ layers.overlays[markerData.layer].removeLayer(marker);
+ marker.setLatLng([markerData.lat, markerData.lng]);
+ layers.overlays[markerData.layer].addLayer(marker);
+ }
+ } else {
+ // The marker has possibly moved. It can be moved by a user drag (marker location and data are equal but old
+ // data is diferent) or programatically (marker location and data are diferent)
+ if ((markerLatLng.lat !== markerData.lat) || (markerLatLng.lng !== markerData.lng)) {
+ // The marker was moved by a user drag
+ layers.overlays[markerData.layer].removeLayer(marker);
+ marker.setLatLng([markerData.lat, markerData.lng]);
+ layers.overlays[markerData.layer].addLayer(marker);
+ } else if ((markerData.lat !== oldMarkerData.lat) || (markerData.lng !== oldMarkerData.lng)) {
+ // The marker was moved programatically
+ layers.overlays[markerData.layer].removeLayer(marker);
+ marker.setLatLng([markerData.lat, markerData.lng]);
+ layers.overlays[markerData.layer].addLayer(marker);
+ } else if (isObject(markerData.icon) && isObject(oldMarkerData.icon) && !angular.equals(markerData.icon, oldMarkerData.icon)) {
+ layers.overlays[markerData.layer].removeLayer(marker);
+ layers.overlays[markerData.layer].addLayer(marker);
+ }
+ }
+ } else if (markerLatLng.lat !== markerData.lat || markerLatLng.lng !== markerData.lng) {
+ marker.setLatLng([markerData.lat, markerData.lng]);
+ }
+ };
+ return {
+ resetMarkerGroup: _resetMarkerGroup,
+
+ resetMarkerGroups: _resetMarkerGroups,
+
+ deleteMarker: _deleteMarker,
+
+ manageOpenPopup: _manageOpenPopup,
+
+ manageOpenLabel: _manageOpenLabel,
+
+ createMarker: function (markerData) {
+ if (!isDefined(markerData) || !geoHlp.validateCoords(markerData)) {
+ $log.error(errorHeader + 'The marker definition is not valid.');
+ return;
+ }
+ var coords = geoHlp.getCoords(markerData);
+
+ if (!isDefined(coords)) {
+ $log.error(errorHeader + 'Unable to get coordinates from markerData.');
+ return;
+ }
+
+ var markerOptions = {
+ icon: createLeafletIcon(markerData.icon),
+ title: isDefined(markerData.title) ? markerData.title : '',
+ draggable: isDefined(markerData.draggable) ? markerData.draggable : false,
+ clickable: isDefined(markerData.clickable) ? markerData.clickable : true,
+ riseOnHover: isDefined(markerData.riseOnHover) ? markerData.riseOnHover : false,
+ zIndexOffset: isDefined(markerData.zIndexOffset) ? markerData.zIndexOffset : 0,
+ iconAngle: isDefined(markerData.iconAngle) ? markerData.iconAngle : 0
+ };
+ // Add any other options not added above to markerOptions
+ for (var markerDatum in markerData) {
+ if (markerData.hasOwnProperty(markerDatum) && !markerOptions.hasOwnProperty(markerDatum)) {
+ markerOptions[markerDatum] = markerData[markerDatum];
+ }
+ }
+
+ var marker = new L.marker(coords, markerOptions);
+
+ if (!isString(markerData.message)) {
+ marker.unbindPopup();
+ }
+
+ return marker;
+ },
+
+ addMarkerToGroup: function (marker, groupName, groupOptions, map) {
+ if (!isString(groupName)) {
+ $log.error(errorHeader + 'The marker group you have specified is invalid.');
+ return;
+ }
+
+ if (!MarkerClusterPlugin.isLoaded()) {
+ $log.error(errorHeader + "The MarkerCluster plugin is not loaded.");
+ return;
+ }
+ if (!isDefined(groups[groupName])) {
+ groups[groupName] = new L.MarkerClusterGroup(groupOptions);
+ map.addLayer(groups[groupName]);
+ }
+ groups[groupName].addLayer(marker);
+ },
+
+ listenMarkerEvents: function (marker, markerData, leafletScope, doWatch, map) {
+ marker.on("popupopen", function (/* event */) {
+ safeApply(leafletScope, function () {
+ if (isDefined(marker._popup) || isDefined(marker._popup._contentNode)) {
+ markerData.focus = true;
+ _manageOpenPopup(marker, markerData, map);//needed since markerData is now a copy
+ }
+ });
+ });
+ marker.on("popupclose", function (/* event */) {
+ safeApply(leafletScope, function () {
+ markerData.focus = false;
+ });
+ });
+ marker.on("add", function (/* event */) {
+ safeApply(leafletScope, function () {
+ if ('label' in markerData)
+ _manageOpenLabel(marker, markerData);
+ });
+ });
+ },
+
+ updateMarker: _updateMarker,
+
+ addMarkerWatcher: function (marker, name, leafletScope, layers, map, isDeepWatch) {
+ var markerWatchPath = Helpers.getObjectArrayPath("markers." + name);
+ isDeepWatch = defaultTo(isDeepWatch, true);
+
+ var clearWatch = leafletScope.$watch(markerWatchPath, function(markerData, oldMarkerData) {
+ if (!isDefined(markerData)) {
+ _deleteMarker(marker, map, layers);
+ clearWatch();
+ return;
+ }
+ _updateMarker(markerData, oldMarkerData, marker, name, leafletScope, layers, map);
+ } , isDeepWatch);
+ },
+ string: _string,
+ log: _log
+ };
+}]);
+
+angular.module("leaflet-directive").factory('leafletPathsHelpers', ["$rootScope", "$log", "leafletHelpers", function ($rootScope, $log, leafletHelpers) {
+ var isDefined = leafletHelpers.isDefined,
+ isArray = leafletHelpers.isArray,
+ isNumber = leafletHelpers.isNumber,
+ isValidPoint = leafletHelpers.isValidPoint;
+
+ var availableOptions = [
+ // Path options
+ 'stroke', 'weight', 'color', 'opacity',
+ 'fill', 'fillColor', 'fillOpacity',
+ 'dashArray', 'lineCap', 'lineJoin', 'clickable',
+ 'pointerEvents', 'className',
+
+ // Polyline options
+ 'smoothFactor', 'noClip'
+ ];
+ function _convertToLeafletLatLngs(latlngs) {
+ return latlngs.filter(function(latlng) {
+ return isValidPoint(latlng);
+ }).map(function (latlng) {
+ return _convertToLeafletLatLng(latlng);
+ });
+ }
+
+ function _convertToLeafletLatLng(latlng) {
+ if (isArray(latlng)) {
+ return new L.LatLng(latlng[0], latlng[1]);
+ } else {
+ return new L.LatLng(latlng.lat, latlng.lng);
+ }
+ }
+
+ function _convertToLeafletMultiLatLngs(paths) {
+ return paths.map(function(latlngs) {
+ return _convertToLeafletLatLngs(latlngs);
+ });
+ }
+
+ function _getOptions(path, defaults) {
+ var options = {};
+ for (var i = 0; i < availableOptions.length; i++) {
+ var optionName = availableOptions[i];
+
+ if (isDefined(path[optionName])) {
+ options[optionName] = path[optionName];
+ } else if (isDefined(defaults.path[optionName])) {
+ options[optionName] = defaults.path[optionName];
+ }
+ }
+
+ return options;
+ }
+
+ var _updatePathOptions = function (path, data) {
+ var updatedStyle = {};
+ for (var i = 0; i < availableOptions.length; i++) {
+ var optionName = availableOptions[i];
+ if (isDefined(data[optionName])) {
+ updatedStyle[optionName] = data[optionName];
+ }
+ }
+ path.setStyle(data);
+ };
+
+ var _isValidPolyline = function(latlngs) {
+ if (!isArray(latlngs)) {
+ return false;
+ }
+ for (var i = 0; i < latlngs.length; i++) {
+ var point = latlngs[i];
+ if (!isValidPoint(point)) {
+ return false;
+ }
+ }
+ return true;
+ };
+
+ var pathTypes = {
+ polyline: {
+ isValid: function(pathData) {
+ var latlngs = pathData.latlngs;
+ return _isValidPolyline(latlngs);
+ },
+ createPath: function(options) {
+ return new L.Polyline([], options);
+ },
+ setPath: function(path, data) {
+ path.setLatLngs(_convertToLeafletLatLngs(data.latlngs));
+ _updatePathOptions(path, data);
+ return;
+ }
+ },
+ multiPolyline: {
+ isValid: function(pathData) {
+ var latlngs = pathData.latlngs;
+ if (!isArray(latlngs)) {
+ return false;
+ }
+
+ for (var i in latlngs) {
+ var polyline = latlngs[i];
+ if (!_isValidPolyline(polyline)) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+ createPath: function(options) {
+ return new L.multiPolyline([[[0,0],[1,1]]], options);
+ },
+ setPath: function(path, data) {
+ path.setLatLngs(_convertToLeafletMultiLatLngs(data.latlngs));
+ _updatePathOptions(path, data);
+ return;
+ }
+ } ,
+ polygon: {
+ isValid: function(pathData) {
+ var latlngs = pathData.latlngs;
+ return _isValidPolyline(latlngs);
+ },
+ createPath: function(options) {
+ return new L.Polygon([], options);
+ },
+ setPath: function(path, data) {
+ path.setLatLngs(_convertToLeafletLatLngs(data.latlngs));
+ _updatePathOptions(path, data);
+ return;
+ }
+ },
+ multiPolygon: {
+ isValid: function(pathData) {
+ var latlngs = pathData.latlngs;
+
+ if (!isArray(latlngs)) {
+ return false;
+ }
+
+ for (var i in latlngs) {
+ var polyline = latlngs[i];
+ if (!_isValidPolyline(polyline)) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+ createPath: function(options) {
+ return new L.MultiPolygon([[[0,0],[1,1],[0,1]]], options);
+ },
+ setPath: function(path, data) {
+ path.setLatLngs(_convertToLeafletMultiLatLngs(data.latlngs));
+ _updatePathOptions(path, data);
+ return;
+ }
+ },
+ rectangle: {
+ isValid: function(pathData) {
+ var latlngs = pathData.latlngs;
+
+ if (!isArray(latlngs) || latlngs.length !== 2) {
+ return false;
+ }
+
+ for (var i in latlngs) {
+ var point = latlngs[i];
+ if (!isValidPoint(point)) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+ createPath: function(options) {
+ return new L.Rectangle([[0,0],[1,1]], options);
+ },
+ setPath: function(path, data) {
+ path.setBounds(new L.LatLngBounds(_convertToLeafletLatLngs(data.latlngs)));
+ _updatePathOptions(path, data);
+ }
+ },
+ circle: {
+ isValid: function(pathData) {
+ var point= pathData.latlngs;
+ return isValidPoint(point) && isNumber(pathData.radius);
+ },
+ createPath: function(options) {
+ return new L.Circle([0,0], 1, options);
+ },
+ setPath: function(path, data) {
+ path.setLatLng(_convertToLeafletLatLng(data.latlngs));
+ if (isDefined(data.radius)) {
+ path.setRadius(data.radius);
+ }
+ _updatePathOptions(path, data);
+ }
+ },
+ circleMarker: {
+ isValid: function(pathData) {
+ var point= pathData.latlngs;
+ return isValidPoint(point) && isNumber(pathData.radius);
+ },
+ createPath: function(options) {
+ return new L.CircleMarker([0,0], options);
+ },
+ setPath: function(path, data) {
+ path.setLatLng(_convertToLeafletLatLng(data.latlngs));
+ if (isDefined(data.radius)) {
+ path.setRadius(data.radius);
+ }
+ _updatePathOptions(path, data);
+ }
+ }
+ };
+
+ var _getPathData = function(path) {
+ var pathData = {};
+ if (path.latlngs) {
+ pathData.latlngs = path.latlngs;
+ }
+
+ if (path.radius) {
+ pathData.radius = path.radius;
+ }
+
+ return pathData;
+ };
+
+ return {
+ setPathOptions: function(leafletPath, pathType, data) {
+ if(!isDefined(pathType)) {
+ pathType = "polyline";
+ }
+ pathTypes[pathType].setPath(leafletPath, data);
+ },
+ createPath: function(name, path, defaults) {
+ if(!isDefined(path.type)) {
+ path.type = "polyline";
+ }
+ var options = _getOptions(path, defaults);
+ var pathData = _getPathData(path);
+
+ if (!pathTypes[path.type].isValid(pathData)) {
+ $log.error("[AngularJS - Leaflet] Invalid data passed to the " + path.type + " path");
+ return;
+ }
+
+ return pathTypes[path.type].createPath(options);
+ }
+ };
+}]);
+
+angular.module("leaflet-directive")
+.service('leafletWatchHelpers', function (){
+
+ var _maybe = function(scope, watchFunctionName, thingToWatchStr, watchOptions, initCb){
+ //watchOptions.isDeep is/should be ignored in $watchCollection
+ var unWatch = scope[watchFunctionName](thingToWatchStr, function(newValue, oldValue) {
+ initCb(newValue, oldValue);
+ if(!watchOptions.doWatch)
+ unWatch();
+ }, watchOptions.isDeep);
+
+ return unWatch;
+ };
+
+ /*
+ @name: maybeWatch
+ @description: Utility to watch something once or forever.
+ @returns unWatch function
+ @param watchOptions - see markersWatchOptions and or derrivatives. This object is used
+ to set watching to once and its watch depth.
+ */
+ var _maybeWatch = function(scope, thingToWatchStr, watchOptions, initCb){
+ return _maybe(scope, '$watch', thingToWatchStr, watchOptions, initCb);
+ };
+
+ /*
+ @name: _maybeWatchCollection
+ @description: Utility to watch something once or forever.
+ @returns unWatch function
+ @param watchOptions - see markersWatchOptions and or derrivatives. This object is used
+ to set watching to once and its watch depth.
+ */
+ var _maybeWatchCollection = function(scope, thingToWatchStr, watchOptions, initCb){
+ return _maybe(scope, '$watchCollection', thingToWatchStr, watchOptions, initCb);
+ };
+
+ return {
+ maybeWatch: _maybeWatch,
+ maybeWatchCollection: _maybeWatchCollection
+ };
+});
+
+angular.module("leaflet-directive").factory('nominatimService', ["$q", "$http", "leafletHelpers", "leafletMapDefaults", function ($q, $http, leafletHelpers, leafletMapDefaults) {
+ var isDefined = leafletHelpers.isDefined;
+
+ return {
+ query: function(address, mapId) {
+ var defaults = leafletMapDefaults.getDefaults(mapId);
+ var url = defaults.nominatim.server;
+ var df = $q.defer();
+
+ $http.get(url, { params: { format: 'json', limit: 1, q: address } }).success(function(data) {
+ if (data.length > 0 && isDefined(data[0].boundingbox)) {
+ df.resolve(data[0]);
+ } else {
+ df.reject('[Nominatim] Invalid address');
+ }
+ });
+
+ return df.promise;
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('bounds', ["$log", "$timeout", "$http", "leafletHelpers", "nominatimService", "leafletBoundsHelpers", function ($log, $timeout, $http, leafletHelpers, nominatimService, leafletBoundsHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: [ 'leaflet' ],
+
+ link: function(scope, element, attrs, controller) {
+ var isDefined = leafletHelpers.isDefined;
+ var createLeafletBounds = leafletBoundsHelpers.createLeafletBounds;
+ var leafletScope = controller[0].getLeafletScope();
+ var mapController = controller[0];
+ var errorHeader = leafletHelpers.errorHeader + ' [Bounds] ';
+
+ var emptyBounds = function(bounds) {
+ return (bounds._southWest.lat === 0 && bounds._southWest.lng === 0 &&
+ bounds._northEast.lat === 0 && bounds._northEast.lng === 0);
+ };
+
+ mapController.getMap().then(function (map) {
+ leafletScope.$on('boundsChanged', function (event) {
+ var scope = event.currentScope;
+ var bounds = map.getBounds();
+
+ if (emptyBounds(bounds) || scope.settingBoundsFromScope) {
+ return;
+ }
+ scope.settingBoundsFromLeaflet = true;
+ var newScopeBounds = {
+ northEast: {
+ lat: bounds._northEast.lat,
+ lng: bounds._northEast.lng
+ },
+ southWest: {
+ lat: bounds._southWest.lat,
+ lng: bounds._southWest.lng
+ },
+ options: bounds.options
+ };
+ if (!angular.equals(scope.bounds, newScopeBounds)) {
+ scope.bounds = newScopeBounds;
+ }
+ $timeout( function() {
+ scope.settingBoundsFromLeaflet = false;
+ });
+ });
+
+ var lastNominatimQuery;
+ leafletScope.$watch('bounds', function (bounds) {
+ if (scope.settingBoundsFromLeaflet)
+ return;
+ if (isDefined(bounds.address) && bounds.address !== lastNominatimQuery) {
+ scope.settingBoundsFromScope = true;
+ nominatimService.query(bounds.address, attrs.id).then(function(data) {
+ var b = data.boundingbox;
+ var newBounds = [ [ b[0], b[2]], [ b[1], b[3]] ];
+ map.fitBounds(newBounds);
+ }, function(errMsg) {
+ $log.error(errorHeader + ' ' + errMsg + '.');
+ });
+ lastNominatimQuery = bounds.address;
+ $timeout( function() {
+ scope.settingBoundsFromScope = false;
+ });
+ return;
+ }
+
+ var leafletBounds = createLeafletBounds(bounds);
+ if (leafletBounds && !map.getBounds().equals(leafletBounds)) {
+ scope.settingBoundsFromScope = true;
+ map.fitBounds(leafletBounds, bounds.options);
+ $timeout( function() {
+ scope.settingBoundsFromScope = false;
+ });
+ }
+ }, true);
+ });
+ }
+ };
+}]);
+
+var centerDirectiveTypes = ['center', 'lfCenter'],
+ centerDirectives = {};
+
+centerDirectiveTypes.forEach(function(directiveName) {
+ centerDirectives[directiveName] = [ '$log', '$q', '$location', '$timeout', 'leafletMapDefaults', 'leafletHelpers',
+ 'leafletBoundsHelpers', 'leafletMapEvents',
+ function($log, $q, $location, $timeout, leafletMapDefaults, leafletHelpers,
+ leafletBoundsHelpers, leafletMapEvents) {
+
+ var isDefined = leafletHelpers.isDefined,
+ isNumber = leafletHelpers.isNumber,
+ isSameCenterOnMap = leafletHelpers.isSameCenterOnMap,
+ safeApply = leafletHelpers.safeApply,
+ isValidCenter = leafletHelpers.isValidCenter,
+ isValidBounds = leafletBoundsHelpers.isValidBounds,
+ isUndefinedOrEmpty = leafletHelpers.isUndefinedOrEmpty,
+ errorHeader = leafletHelpers.errorHeader;
+
+ var shouldInitializeMapWithBounds = function(bounds, center) {
+ return isDefined(bounds) && isValidBounds(bounds) && isUndefinedOrEmpty(center);
+ };
+
+ var _leafletCenter;
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+ controller: function() {
+ _leafletCenter = $q.defer();
+ this.getCenter = function() {
+ return _leafletCenter.promise;
+ };
+ },
+ link: function(scope, element, attrs, controller) {
+ var leafletScope = controller.getLeafletScope(),
+ centerModel = leafletScope[directiveName];
+
+ controller.getMap().then(function(map) {
+ var defaults = leafletMapDefaults.getDefaults(attrs.id);
+
+ if (attrs[directiveName].search("-") !== -1) {
+ $log.error(errorHeader + ' The "center" variable can\'t use a "-" on its key name: "' + attrs[directiveName] + '".');
+ map.setView([defaults.center.lat, defaults.center.lng], defaults.center.zoom);
+ return;
+ } else if (shouldInitializeMapWithBounds(leafletScope.bounds, centerModel)) {
+ map.fitBounds(leafletBoundsHelpers.createLeafletBounds(leafletScope.bounds), leafletScope.bounds.options);
+ centerModel = map.getCenter();
+ safeApply(leafletScope, function(scope) {
+ angular.extend(scope[directiveName], {
+ lat: map.getCenter().lat,
+ lng: map.getCenter().lng,
+ zoom: map.getZoom(),
+ autoDiscover: false
+ });
+ });
+ safeApply(leafletScope, function(scope) {
+ var mapBounds = map.getBounds();
+ scope.bounds = {
+ northEast: {
+ lat: mapBounds._northEast.lat,
+ lng: mapBounds._northEast.lng
+ },
+ southWest: {
+ lat: mapBounds._southWest.lat,
+ lng: mapBounds._southWest.lng
+ }
+ };
+ });
+ } else if (!isDefined(centerModel)) {
+ $log.error(errorHeader + ' The "center" property is not defined in the main scope');
+ map.setView([defaults.center.lat, defaults.center.lng], defaults.center.zoom);
+ return;
+ } else if (!(isDefined(centerModel.lat) && isDefined(centerModel.lng)) && !isDefined(centerModel.autoDiscover)) {
+ angular.copy(defaults.center, centerModel);
+ }
+
+ var urlCenterHash, mapReady;
+ if (attrs.urlHashCenter === "yes") {
+ var extractCenterFromUrl = function() {
+ var search = $location.search();
+ var centerParam;
+ if (isDefined(search.c)) {
+ var cParam = search.c.split(":");
+ if (cParam.length === 3) {
+ centerParam = {
+ lat: parseFloat(cParam[0]),
+ lng: parseFloat(cParam[1]),
+ zoom: parseInt(cParam[2], 10)
+ };
+ }
+ }
+ return centerParam;
+ };
+ urlCenterHash = extractCenterFromUrl();
+
+ leafletScope.$on('$locationChangeSuccess', function(event) {
+ var scope = event.currentScope;
+ //$log.debug("updated location...");
+ var urlCenter = extractCenterFromUrl();
+ if (isDefined(urlCenter) && !isSameCenterOnMap(urlCenter, map)) {
+ //$log.debug("updating center model...", urlCenter);
+ angular.extend(scope[directiveName], {
+ lat: urlCenter.lat,
+ lng: urlCenter.lng,
+ zoom: urlCenter.zoom
+ });
+ }
+ });
+ }
+
+ leafletScope.$watch(directiveName, function(center) {
+ if (leafletScope.settingCenterFromLeaflet)
+ return;
+ //$log.debug("updated center model...");
+ // The center from the URL has priority
+ if (isDefined(urlCenterHash)) {
+ angular.copy(urlCenterHash, center);
+ urlCenterHash = undefined;
+ }
+
+ if (!isValidCenter(center) && center.autoDiscover !== true) {
+ $log.warn(errorHeader + " invalid 'center'");
+ //map.setView([defaults.center.lat, defaults.center.lng], defaults.center.zoom);
+ return;
+ }
+
+ if (center.autoDiscover === true) {
+ if (!isNumber(center.zoom)) {
+ map.setView([defaults.center.lat, defaults.center.lng], defaults.center.zoom);
+ }
+ if (isNumber(center.zoom) && center.zoom > defaults.center.zoom) {
+ map.locate({
+ setView: true,
+ maxZoom: center.zoom
+ });
+ } else if (isDefined(defaults.maxZoom)) {
+ map.locate({
+ setView: true,
+ maxZoom: defaults.maxZoom
+ });
+ } else {
+ map.locate({
+ setView: true
+ });
+ }
+ return;
+ }
+
+ if (mapReady && isSameCenterOnMap(center, map)) {
+ //$log.debug("no need to update map again.");
+ return;
+ }
+
+ //$log.debug("updating map center...", center);
+ leafletScope.settingCenterFromScope = true;
+ map.setView([center.lat, center.lng], center.zoom);
+ leafletMapEvents.notifyCenterChangedToBounds(leafletScope, map);
+ $timeout(function() {
+ leafletScope.settingCenterFromScope = false;
+ //$log.debug("allow center scope updates");
+ });
+ }, true);
+
+ map.whenReady(function() {
+ mapReady = true;
+ });
+
+ map.on('moveend', function( /* event */ ) {
+ // Resolve the center after the first map position
+ _leafletCenter.resolve();
+ leafletMapEvents.notifyCenterUrlHashChanged(leafletScope, map, attrs, $location.search());
+ //$log.debug("updated center on map...");
+ if (isSameCenterOnMap(centerModel, map) || leafletScope.settingCenterFromScope) {
+ //$log.debug("same center in model, no need to update again.");
+ return;
+ }
+ leafletScope.settingCenterFromLeaflet = true;
+ safeApply(leafletScope, function(scope) {
+ if (!leafletScope.settingCenterFromScope) {
+ //$log.debug("updating center model...", map.getCenter(), map.getZoom());
+ angular.extend(scope[directiveName], {
+ lat: map.getCenter().lat,
+ lng: map.getCenter().lng,
+ zoom: map.getZoom(),
+ autoDiscover: false
+ });
+ }
+ leafletMapEvents.notifyCenterChangedToBounds(leafletScope, map);
+ $timeout(function() {
+ leafletScope.settingCenterFromLeaflet = false;
+ });
+ });
+ });
+
+ if (centerModel.autoDiscover === true) {
+ map.on('locationerror', function() {
+ $log.warn(errorHeader + " The Geolocation API is unauthorized on this page.");
+ if (isValidCenter(centerModel)) {
+ map.setView([centerModel.lat, centerModel.lng], centerModel.zoom);
+ leafletMapEvents.notifyCenterChangedToBounds(leafletScope, map);
+ } else {
+ map.setView([defaults.center.lat, defaults.center.lng], defaults.center.zoom);
+ leafletMapEvents.notifyCenterChangedToBounds(leafletScope, map);
+ }
+ });
+ }
+ });
+ }
+ };
+ }
+ ];
+});
+
+centerDirectiveTypes.forEach(function(dirType){
+ angular.module("leaflet-directive").directive(dirType, centerDirectives[dirType]);
+});
+
+angular.module("leaflet-directive").directive('controls', ["$log", "leafletHelpers", "leafletControlHelpers", function ($log, leafletHelpers, leafletControlHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: '?^leaflet',
+
+ link: function(scope, element, attrs, controller) {
+ if(!controller) {
+ return;
+ }
+
+ var createControl = leafletControlHelpers.createControl;
+ var isValidControlType = leafletControlHelpers.isValidControlType;
+ var leafletScope = controller.getLeafletScope();
+ var isDefined = leafletHelpers.isDefined;
+ var isArray = leafletHelpers.isArray;
+ var leafletControls = {};
+ var errorHeader = leafletHelpers.errorHeader + ' [Controls] ';
+
+ controller.getMap().then(function(map) {
+
+ leafletScope.$watchCollection('controls', function(newControls) {
+
+ // Delete controls from the array
+ for (var name in leafletControls) {
+ if (!isDefined(newControls[name])) {
+ if (map.hasControl(leafletControls[name])) {
+ map.removeControl(leafletControls[name]);
+ }
+ delete leafletControls[name];
+ }
+ }
+
+ for (var newName in newControls) {
+ var control;
+
+ var controlType = isDefined(newControls[newName].type) ? newControls[newName].type : newName;
+
+ if (!isValidControlType(controlType)) {
+ $log.error(errorHeader + ' Invalid control type: ' + controlType + '.');
+ return;
+ }
+
+ if (controlType !== 'custom') {
+ control = createControl(controlType, newControls[newName]);
+ map.addControl(control);
+ leafletControls[newName] = control;
+ } else {
+ var customControlValue = newControls[newName];
+ if (isArray(customControlValue)) {
+ for (var i in customControlValue) {
+ var customControl = customControlValue[i];
+ map.addControl(customControl);
+ leafletControls[newName] = !isDefined(leafletControls[newName]) ? [customControl] : leafletControls[newName].concat([customControl]);
+ }
+ } else {
+ map.addControl(customControlValue);
+ leafletControls[newName] = customControlValue;
+ }
+ }
+ }
+
+ });
+
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive("decorations", ["$log", "leafletHelpers", function($log, leafletHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+
+ link: function(scope, element, attrs, controller) {
+ var leafletScope = controller.getLeafletScope(),
+ PolylineDecoratorPlugin = leafletHelpers.PolylineDecoratorPlugin,
+ isDefined = leafletHelpers.isDefined,
+ leafletDecorations = {};
+
+ /* Creates an "empty" decoration with a set of coordinates, but no pattern. */
+ function createDecoration(options) {
+ if (isDefined(options) && isDefined(options.coordinates)) {
+ if (!PolylineDecoratorPlugin.isLoaded()) {
+ $log.error('[AngularJS - Leaflet] The PolylineDecorator Plugin is not loaded.');
+ }
+ }
+
+ return L.polylineDecorator(options.coordinates);
+ }
+
+ /* Updates the path and the patterns for the provided decoration, and returns the decoration. */
+ function setDecorationOptions(decoration, options) {
+ if (isDefined(decoration) && isDefined(options)) {
+ if (isDefined(options.coordinates) && isDefined(options.patterns)) {
+ decoration.setPaths(options.coordinates);
+ decoration.setPatterns(options.patterns);
+ return decoration;
+ }
+ }
+ }
+
+ controller.getMap().then(function(map) {
+ leafletScope.$watch("decorations", function(newDecorations) {
+ for (var name in leafletDecorations) {
+ if (!isDefined(newDecorations[name]) || !angular.equals(newDecorations[name], leafletDecorations)) {
+ map.removeLayer(leafletDecorations[name]);
+ delete leafletDecorations[name];
+ }
+ }
+
+ for (var newName in newDecorations) {
+ var decorationData = newDecorations[newName],
+ newDecoration = createDecoration(decorationData);
+
+ if (isDefined(newDecoration)) {
+ leafletDecorations[newName] = newDecoration;
+ map.addLayer(newDecoration);
+ setDecorationOptions(newDecoration, decorationData);
+ }
+ }
+ }, true);
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('eventBroadcast', ["$log", "$rootScope", "leafletHelpers", "leafletMapEvents", "leafletIterators", function ($log, $rootScope, leafletHelpers, leafletMapEvents, leafletIterators) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+
+ link: function(scope, element, attrs, controller) {
+ var isObject = leafletHelpers.isObject,
+ isDefined = leafletHelpers.isDefined,
+ leafletScope = controller.getLeafletScope(),
+ eventBroadcast = leafletScope.eventBroadcast,
+ availableMapEvents = leafletMapEvents.getAvailableMapEvents(),
+ addEvents = leafletMapEvents.addEvents;
+
+ controller.getMap().then(function(map) {
+
+ var mapEvents = [],
+ logic = "broadcast";
+
+ // We have a possible valid object
+ if (!isDefined(eventBroadcast.map)) {
+ // We do not have events enable/disable do we do nothing (all enabled by default)
+ mapEvents = availableMapEvents;
+ } else if (!isObject(eventBroadcast.map)) {
+ // Not a valid object
+ $log.warn("[AngularJS - Leaflet] event-broadcast.map must be an object check your model.");
+ } else {
+ // We have a possible valid map object
+ // Event propadation logic
+ if (eventBroadcast.map.logic !== "emit" && eventBroadcast.map.logic !== "broadcast") {
+ // This is an error
+ $log.warn("[AngularJS - Leaflet] Available event propagation logic are: 'emit' or 'broadcast'.");
+ } else {
+ logic = eventBroadcast.map.logic;
+ }
+
+ if (!(isObject(eventBroadcast.map.enable) && eventBroadcast.map.enable.length >= 0)) {
+ $log.warn("[AngularJS - Leaflet] event-broadcast.map.enable must be an object check your model.");
+ } else {
+ // Enable events
+ leafletIterators.each(eventBroadcast.map.enable, function(eventName) {
+ // Do we have already the event enabled?
+ if (mapEvents.indexOf(eventName) === -1 && availableMapEvents.indexOf(eventName) !== -1) {
+ mapEvents.push(eventName);
+ }
+ });
+ }
+
+ }
+ // as long as the map is removed in the root leaflet directive we
+ // do not need ot clean up the events as leaflet does it itself
+ addEvents(map, mapEvents, "eventName", leafletScope, logic);
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive")
+.directive('geojson', ["$log", "$rootScope", "leafletData", "leafletHelpers", "leafletWatchHelpers", "leafletDirectiveControlsHelpers", "leafletIterators", "leafletGeoJsonEvents", function ($log, $rootScope, leafletData, leafletHelpers,
+ leafletWatchHelpers, leafletDirectiveControlsHelpers,leafletIterators, leafletGeoJsonEvents) {
+ var _maybeWatch = leafletWatchHelpers.maybeWatch,
+ _watchOptions = leafletHelpers.watchOptions,
+ _extendDirectiveControls = leafletDirectiveControlsHelpers.extend,
+ hlp = leafletHelpers,
+ $it = leafletIterators;
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+
+ link: function(scope, element, attrs, controller) {
+ var isDefined = leafletHelpers.isDefined,
+ leafletScope = controller.getLeafletScope(),
+ leafletGeoJSON = {},
+ _hasSetLeafletData = false;
+
+ controller.getMap().then(function(map) {
+ var watchOptions = leafletScope.geojsonWatchOptions || _watchOptions;
+
+ var _hookUpEvents = function(geojson, maybeName){
+ var onEachFeature;
+
+ if (angular.isFunction(geojson.onEachFeature)) {
+ onEachFeature = geojson.onEachFeature;
+ } else {
+ onEachFeature = function(feature, layer) {
+ if (leafletHelpers.LabelPlugin.isLoaded() && isDefined(feature.properties.description)) {
+ layer.bindLabel(feature.properties.description);
+ }
+
+ leafletGeoJsonEvents.bindEvents(attrs.id, layer, null, feature,
+ leafletScope, maybeName,
+ {resetStyleOnMouseout: geojson.resetStyleOnMouseout,
+ mapId: attrs.id});
+ };
+ }
+ return onEachFeature;
+ };
+
+ var isNested = (hlp.isDefined(attrs.geojsonNested) &&
+ hlp.isTruthy(attrs.geojsonNested));
+
+ var _clean = function(){
+ if(!leafletGeoJSON)
+ return;
+ var _remove = function(lObject) {
+ if (isDefined(lObject) && map.hasLayer(lObject)) {
+ map.removeLayer(lObject);
+ }
+ };
+ if(isNested) {
+ $it.each(leafletGeoJSON, function(lObject) {
+ _remove(lObject);
+ });
+ return;
+ }
+ _remove(leafletGeoJSON);
+ };
+
+ var _addGeojson = function(model, maybeName){
+ var geojson = angular.copy(model);
+ if (!(isDefined(geojson) && isDefined(geojson.data))) {
+ return;
+ }
+ var onEachFeature = _hookUpEvents(geojson, maybeName);
+
+ if (!isDefined(geojson.options)) {
+ //right here is why we use a clone / copy (we modify and thus)
+ //would kick of a watcher.. we need to be more careful everywhere
+ //for stuff like this
+ geojson.options = {
+ style: geojson.style,
+ filter: geojson.filter,
+ onEachFeature: onEachFeature,
+ pointToLayer: geojson.pointToLayer
+ };
+ }
+
+ var lObject = L.geoJson(geojson.data, geojson.options);
+
+ if(maybeName && hlp.isString(maybeName)){
+ leafletGeoJSON[maybeName] = lObject;
+ }
+ else{
+ leafletGeoJSON = lObject;
+ }
+
+ lObject.addTo(map);
+
+ if(!_hasSetLeafletData){//only do this once and play with the same ref forever
+ _hasSetLeafletData = true;
+ leafletData.setGeoJSON(leafletGeoJSON, attrs.id);
+ }
+ };
+
+ var _create = function(model){
+ _clean();
+ if(isNested) {
+ if(!model || !Object.keys(model).length)
+ return;
+ $it.each(model, function(m, name) {
+ //name could be layerName and or groupName
+ //for now it is not tied to a layer
+ _addGeojson(m,name);
+ });
+ return;
+ }
+ _addGeojson(model);
+ };
+
+ _extendDirectiveControls(attrs.id, 'geojson', _create, _clean);
+
+ _maybeWatch(leafletScope,'geojson', watchOptions, function(geojson){
+ _create(geojson);
+ });
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('layercontrol', ["$filter", "$log", "leafletData", "leafletHelpers", function ($filter, $log, leafletData, leafletHelpers) {
+
+ return {
+ restrict: "E",
+ scope: {
+ icons: '=?',
+ autoHideOpacity: '=?', // Hide other opacity controls when one is activated.
+ showGroups: '=?', // Hide other opacity controls when one is activated.
+ title: '@',
+ baseTitle: '@',
+ overlaysTitle: '@'
+ },
+ replace: true,
+ transclude: false,
+ require: '^leaflet',
+ controller: ["$scope", "$element", "$sce", function ($scope, $element, $sce) {
+ $log.debug('[Angular Directive - Layers] layers', $scope, $element);
+ var safeApply = leafletHelpers.safeApply,
+ isDefined = leafletHelpers.isDefined;
+ angular.extend($scope, {
+ baselayer: '',
+ oldGroup: '',
+ layerProperties: {},
+ groupProperties: {},
+ rangeIsSupported: leafletHelpers.rangeIsSupported(),
+ changeBaseLayer: function(key, e) {
+ leafletHelpers.safeApply($scope, function(scp) {
+ scp.baselayer = key;
+ leafletData.getMap().then(function(map) {
+ leafletData.getLayers().then(function(leafletLayers) {
+ if(map.hasLayer(leafletLayers.baselayers[key])) {
+ return;
+ }
+ for(var i in scp.layers.baselayers) {
+ scp.layers.baselayers[i].icon = scp.icons.unradio;
+ if(map.hasLayer(leafletLayers.baselayers[i])) {
+ map.removeLayer(leafletLayers.baselayers[i]);
+ }
+ }
+ map.addLayer(leafletLayers.baselayers[key]);
+ scp.layers.baselayers[key].icon = $scope.icons.radio;
+ });
+ });
+ });
+ e.preventDefault();
+ },
+ moveLayer: function(ly, newIndex, e) {
+ var delta = Object.keys($scope.layers.baselayers).length;
+ if(newIndex >= (1+delta) && newIndex <= ($scope.overlaysArray.length+delta)) {
+ var oldLy;
+ for(var key in $scope.layers.overlays) {
+ if($scope.layers.overlays[key].index === newIndex) {
+ oldLy = $scope.layers.overlays[key];
+ break;
+ }
+ }
+ if(oldLy) {
+ safeApply($scope, function() {
+ oldLy.index = ly.index;
+ ly.index = newIndex;
+ });
+ }
+ }
+ e.stopPropagation();
+ e.preventDefault();
+ },
+ initIndex: function(layer, idx) {
+ var delta = Object.keys($scope.layers.baselayers).length;
+ layer.index = isDefined(layer.index)? layer.index:idx+delta+1;
+ },
+ initGroup: function(groupName) {
+ $scope.groupProperties[groupName] = $scope.groupProperties[groupName]? $scope.groupProperties[groupName]:{};
+ },
+ toggleOpacity: function(e, layer) {
+ if(layer.visible) {
+ if($scope.autoHideOpacity && !$scope.layerProperties[layer.name].opacityControl) {
+ for(var k in $scope.layerProperties) {
+ $scope.layerProperties[k].opacityControl = false;
+ }
+ }
+ $scope.layerProperties[layer.name].opacityControl = !$scope.layerProperties[layer.name].opacityControl;
+ }
+ e.stopPropagation();
+ e.preventDefault();
+ },
+ toggleLegend: function(layer) {
+ $scope.layerProperties[layer.name].showLegend = !$scope.layerProperties[layer.name].showLegend;
+ },
+ showLegend: function(layer) {
+ return layer.legend && $scope.layerProperties[layer.name].showLegend;
+ },
+ unsafeHTML: function(html) {
+ return $sce.trustAsHtml(html);
+ },
+ getOpacityIcon: function(layer) {
+ return layer.visible && $scope.layerProperties[layer.name].opacityControl? $scope.icons.close:$scope.icons.open;
+ },
+ getGroupIcon: function(group) {
+ return group.visible? $scope.icons.check:$scope.icons.uncheck;
+ },
+ changeOpacity: function(layer) {
+ var op = $scope.layerProperties[layer.name].opacity;
+ leafletData.getMap().then(function(map) {
+ leafletData.getLayers().then(function(leafletLayers) {
+ var ly;
+ for(var k in $scope.layers.overlays) {
+ if($scope.layers.overlays[k] === layer) {
+ ly = leafletLayers.overlays[k];
+ break;
+ }
+ }
+
+ if(map.hasLayer(ly)) {
+ if(ly.setOpacity) {
+ ly.setOpacity(op/100);
+ }
+ if(ly.getLayers && ly.eachLayer) {
+ ly.eachLayer(function(lay) {
+ if(lay.setOpacity) {
+ lay.setOpacity(op/100);
+ }
+ });
+ }
+ }
+ });
+ });
+ },
+ changeGroupVisibility: function(groupName) {
+ if(!isDefined($scope.groupProperties[groupName])) {
+ return;
+ }
+ var visible = $scope.groupProperties[groupName].visible;
+ for(var k in $scope.layers.overlays) {
+ var layer = $scope.layers.overlays[k];
+ if(layer.group === groupName) {
+ layer.visible = visible;
+ }
+ }
+ }
+ });
+
+ var div = $element.get(0);
+ if (!L.Browser.touch) {
+ L.DomEvent.disableClickPropagation(div);
+ L.DomEvent.on(div, 'mousewheel', L.DomEvent.stopPropagation);
+ } else {
+ L.DomEvent.on(div, 'click', L.DomEvent.stopPropagation);
+ }
+ }],
+ template:
+ '' +
+ '
',
+ link: function(scope, element, attrs, controller) {
+ var isDefined = leafletHelpers.isDefined,
+ leafletScope = controller.getLeafletScope(),
+ layers = leafletScope.layers;
+
+ scope.$watch('icons', function() {
+ var defaultIcons = {
+ uncheck: 'fa fa-square-o',
+ check: 'fa fa-check-square-o',
+ radio: 'fa fa-dot-circle-o',
+ unradio: 'fa fa-circle-o',
+ up: 'fa fa-angle-up',
+ down: 'fa fa-angle-down',
+ open: 'fa fa-angle-double-down',
+ close: 'fa fa-angle-double-up',
+ toggleLegend: 'fa fa-pencil-square-o'
+ };
+ if(isDefined(scope.icons)) {
+ angular.extend(defaultIcons, scope.icons);
+ angular.extend(scope.icons, defaultIcons);
+ } else {
+ scope.icons = defaultIcons;
+ }
+ });
+
+ // Setting layer stack order.
+ attrs.order = (isDefined(attrs.order) && (attrs.order === 'normal' || attrs.order === 'reverse'))? attrs.order:'normal';
+ scope.order = attrs.order === 'normal';
+ scope.orderNumber = attrs.order === 'normal'? -1:1;
+
+ scope.layers = layers;
+ controller.getMap().then(function(map) {
+ leafletScope.$watch('layers.baselayers', function(newBaseLayers) {
+ var baselayersArray = {};
+ leafletData.getLayers().then(function(leafletLayers) {
+ var key;
+ for(key in newBaseLayers) {
+ var layer = newBaseLayers[key];
+ layer.icon = scope.icons[map.hasLayer(leafletLayers.baselayers[key])? 'radio':'unradio'];
+ baselayersArray[key] = layer;
+ }
+ scope.baselayersArray = baselayersArray;
+ });
+ });
+
+ leafletScope.$watch('layers.overlays', function(newOverlayLayers) {
+ var overlaysArray = [];
+ var groupVisibleCount = {};
+ leafletData.getLayers().then(function(leafletLayers) {
+ var key;
+ for(key in newOverlayLayers) {
+ var layer = newOverlayLayers[key];
+ layer.icon = scope.icons[(layer.visible? 'check':'uncheck')];
+ overlaysArray.push(layer);
+ if(!isDefined(scope.layerProperties[layer.name])) {
+ scope.layerProperties[layer.name] = {
+ opacity: isDefined(layer.layerOptions.opacity)? layer.layerOptions.opacity*100:100,
+ opacityControl: false,
+ showLegend: true
+ };
+ }
+ if(isDefined(layer.group)) {
+ if(!isDefined(scope.groupProperties[layer.group])) {
+ scope.groupProperties[layer.group] = {
+ visible: false
+ };
+ }
+ groupVisibleCount[layer.group] = isDefined(groupVisibleCount[layer.group])? groupVisibleCount[layer.group]:{
+ count: 0,
+ visibles: 0
+ };
+ groupVisibleCount[layer.group].count++;
+ if(layer.visible) {
+ groupVisibleCount[layer.group].visibles++;
+ }
+ }
+ if(isDefined(layer.index) && leafletLayers.overlays[key].setZIndex) {
+ leafletLayers.overlays[key].setZIndex(newOverlayLayers[key].index);
+ }
+ }
+
+ for(key in groupVisibleCount) {
+ scope.groupProperties[key].visible = groupVisibleCount[key].visibles === groupVisibleCount[key].count;
+ }
+ scope.overlaysArray = overlaysArray;
+ });
+ }, true);
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('layers', ["$log", "$q", "leafletData", "leafletHelpers", "leafletLayerHelpers", "leafletControlHelpers", function ($log, $q, leafletData, leafletHelpers, leafletLayerHelpers, leafletControlHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+ controller: ["$scope", function ($scope) {
+ $scope._leafletLayers = $q.defer();
+ this.getLayers = function () {
+ return $scope._leafletLayers.promise;
+ };
+ }],
+ link: function(scope, element, attrs, controller){
+ var isDefined = leafletHelpers.isDefined,
+ leafletLayers = {},
+ leafletScope = controller.getLeafletScope(),
+ layers = leafletScope.layers,
+ createLayer = leafletLayerHelpers.createLayer,
+ safeAddLayer = leafletLayerHelpers.safeAddLayer,
+ safeRemoveLayer = leafletLayerHelpers.safeRemoveLayer,
+ updateLayersControl = leafletControlHelpers.updateLayersControl,
+ isLayersControlVisible = false;
+
+ controller.getMap().then(function(map) {
+
+ // We have baselayers to add to the map
+ scope._leafletLayers.resolve(leafletLayers);
+ leafletData.setLayers(leafletLayers, attrs.id);
+
+ leafletLayers.baselayers = {};
+ leafletLayers.overlays = {};
+
+ var mapId = attrs.id;
+
+ // Setup all baselayers definitions
+ var oneVisibleLayer = false;
+ for (var layerName in layers.baselayers) {
+ var newBaseLayer = createLayer(layers.baselayers[layerName]);
+ if (!isDefined(newBaseLayer)) {
+ delete layers.baselayers[layerName];
+ continue;
+ }
+ leafletLayers.baselayers[layerName] = newBaseLayer;
+ // Only add the visible layer to the map, layer control manages the addition to the map
+ // of layers in its control
+ if (layers.baselayers[layerName].top === true) {
+ safeAddLayer(map, leafletLayers.baselayers[layerName]);
+ oneVisibleLayer = true;
+ }
+ }
+
+ // If there is no visible layer add first to the map
+ if (!oneVisibleLayer && Object.keys(leafletLayers.baselayers).length > 0) {
+ safeAddLayer(map, leafletLayers.baselayers[Object.keys(layers.baselayers)[0]]);
+ }
+
+ // Setup the Overlays
+ for (layerName in layers.overlays) {
+ if(layers.overlays[layerName].type === 'cartodb') {
+
+ }
+ var newOverlayLayer = createLayer(layers.overlays[layerName]);
+ if (!isDefined(newOverlayLayer)) {
+ delete layers.overlays[layerName];
+ continue;
+ }
+ leafletLayers.overlays[layerName] = newOverlayLayer;
+ // Only add the visible overlays to the map
+ if (layers.overlays[layerName].visible === true) {
+ safeAddLayer(map, leafletLayers.overlays[layerName]);
+ }
+ }
+
+ // Watch for the base layers
+ leafletScope.$watch('layers.baselayers', function(newBaseLayers, oldBaseLayers) {
+ if(angular.equals(newBaseLayers, oldBaseLayers)) {
+ isLayersControlVisible = updateLayersControl(map, mapId, isLayersControlVisible, newBaseLayers, layers.overlays, leafletLayers);
+ return true;
+ }
+ // Delete layers from the array
+ for (var name in leafletLayers.baselayers) {
+ if (!isDefined(newBaseLayers[name]) || newBaseLayers[name].doRefresh) {
+ // Remove from the map if it's on it
+ if (map.hasLayer(leafletLayers.baselayers[name])) {
+ map.removeLayer(leafletLayers.baselayers[name]);
+ }
+ delete leafletLayers.baselayers[name];
+
+ if (newBaseLayers[name] && newBaseLayers[name].doRefresh) {
+ newBaseLayers[name].doRefresh = false;
+ }
+ }
+ }
+ // add new layers
+ for (var newName in newBaseLayers) {
+ if (!isDefined(leafletLayers.baselayers[newName])) {
+ var testBaseLayer = createLayer(newBaseLayers[newName]);
+ if (isDefined(testBaseLayer)) {
+ leafletLayers.baselayers[newName] = testBaseLayer;
+ // Only add the visible layer to the map
+ if (newBaseLayers[newName].top === true) {
+ safeAddLayer(map, leafletLayers.baselayers[newName]);
+ }
+ }
+ } else {
+ if (newBaseLayers[newName].top === true && !map.hasLayer(leafletLayers.baselayers[newName])) {
+ safeAddLayer(map, leafletLayers.baselayers[newName]);
+ } else if (newBaseLayers[newName].top === false && map.hasLayer(leafletLayers.baselayers[newName])) {
+ map.removeLayer(leafletLayers.baselayers[newName]);
+ }
+ }
+ }
+
+ //we have layers, so we need to make, at least, one active
+ var found = false;
+ // search for an active layer
+ for (var key in leafletLayers.baselayers) {
+ if (map.hasLayer(leafletLayers.baselayers[key])) {
+ found = true;
+ break;
+ }
+ }
+ // If there is no active layer make one active
+ if (!found && Object.keys(leafletLayers.baselayers).length > 0) {
+ safeAddLayer(map, leafletLayers.baselayers[Object.keys(leafletLayers.baselayers)[0]]);
+ }
+
+ // Only show the layers switch selector control if we have more than one baselayer + overlay
+ isLayersControlVisible = updateLayersControl(map, mapId, isLayersControlVisible, newBaseLayers, layers.overlays, leafletLayers);
+ }, true);
+
+ // Watch for the overlay layers
+ leafletScope.$watch('layers.overlays', function(newOverlayLayers, oldOverlayLayers) {
+ if(angular.equals(newOverlayLayers, oldOverlayLayers)) {
+ isLayersControlVisible = updateLayersControl(map, mapId, isLayersControlVisible, layers.baselayers, newOverlayLayers, leafletLayers);
+ return true;
+ }
+
+ // Delete layers from the array
+ for (var name in leafletLayers.overlays) {
+ if (!isDefined(newOverlayLayers[name]) || newOverlayLayers[name].doRefresh) {
+ // Remove from the map if it's on it
+ if (map.hasLayer(leafletLayers.overlays[name])) {
+ // Safe remove when ArcGIS layers is loading.
+ var options = isDefined(newOverlayLayers[name])?
+ newOverlayLayers[name].layerOptions:null;
+ safeRemoveLayer(map, leafletLayers.overlays[name], options);
+ }
+ // TODO: Depending on the layer type we will have to delete what's included on it
+ delete leafletLayers.overlays[name];
+
+ if (newOverlayLayers[name] && newOverlayLayers[name].doRefresh) {
+ newOverlayLayers[name].doRefresh = false;
+ }
+ }
+ }
+
+ // add new overlays
+ for (var newName in newOverlayLayers) {
+ if (!isDefined(leafletLayers.overlays[newName])) {
+ var testOverlayLayer = createLayer(newOverlayLayers[newName]);
+ if (!isDefined(testOverlayLayer)) {
+ // If the layer creation fails, continue to the next overlay
+ continue;
+ }
+ leafletLayers.overlays[newName] = testOverlayLayer;
+ if (newOverlayLayers[newName].visible === true) {
+ safeAddLayer(map, leafletLayers.overlays[newName]);
+ }
+ } else {
+ // check for the .visible property to hide/show overLayers
+ if (newOverlayLayers[newName].visible && !map.hasLayer(leafletLayers.overlays[newName])) {
+ safeAddLayer(map, leafletLayers.overlays[newName]);
+ } else if (newOverlayLayers[newName].visible === false && map.hasLayer(leafletLayers.overlays[newName])) {
+ // Safe remove when ArcGIS layers is loading.
+ safeRemoveLayer(map, leafletLayers.overlays[newName], newOverlayLayers[newName].layerOptions);
+ }
+ }
+
+ //refresh heatmap data if present
+ if (newOverlayLayers[newName].visible && map._loaded && newOverlayLayers[newName].data && newOverlayLayers[newName].type === "heatmap") {
+ leafletLayers.overlays[newName].setData(newOverlayLayers[newName].data);
+ leafletLayers.overlays[newName].update();
+ }
+ }
+
+ // Only add the layers switch selector control if we have more than one baselayer + overlay
+ isLayersControlVisible = updateLayersControl(map, mapId, isLayersControlVisible, layers.baselayers, newOverlayLayers, leafletLayers);
+ }, true);
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('legend', ["$log", "$http", "leafletHelpers", "leafletLegendHelpers", function ($log, $http, leafletHelpers, leafletLegendHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+
+ link: function (scope, element, attrs, controller) {
+
+ var isArray = leafletHelpers.isArray,
+ isDefined = leafletHelpers.isDefined,
+ isFunction = leafletHelpers.isFunction,
+ leafletScope = controller.getLeafletScope(),
+ legend = leafletScope.legend;
+
+ var legendClass;
+ var position;
+ var leafletLegend;
+ var type;
+
+ leafletScope.$watch('legend', function (newLegend) {
+
+ if (isDefined(newLegend)) {
+
+ legendClass = newLegend.legendClass ? newLegend.legendClass : "legend";
+
+ position = newLegend.position || 'bottomright';
+
+ // default to arcgis
+ type = newLegend.type || 'arcgis';
+ }
+
+ }, true);
+
+ controller.getMap().then(function (map) {
+
+ leafletScope.$watch('legend', function (newLegend) {
+
+ if (!isDefined(newLegend)) {
+
+ if (isDefined(leafletLegend)) {
+ leafletLegend.removeFrom(map);
+ leafletLegend= null;
+ }
+
+ return;
+ }
+
+ if (!isDefined(newLegend.url) && (type === 'arcgis') && (!isArray(newLegend.colors) || !isArray(newLegend.labels) || newLegend.colors.length !== newLegend.labels.length)) {
+
+ $log.warn("[AngularJS - Leaflet] legend.colors and legend.labels must be set.");
+
+ return;
+ }
+
+ if (isDefined(newLegend.url)) {
+
+ $log.info("[AngularJS - Leaflet] loading legend service.");
+
+ return;
+ }
+
+ if (isDefined(leafletLegend)) {
+ leafletLegend.removeFrom(map);
+ leafletLegend= null;
+ }
+
+ leafletLegend = L.control({
+ position: position
+ });
+ if (type === 'arcgis') {
+ leafletLegend.onAdd = leafletLegendHelpers.getOnAddArrayLegend(newLegend, legendClass);
+ }
+ leafletLegend.addTo(map);
+
+ });
+
+ leafletScope.$watch('legend.url', function (newURL) {
+
+ if (!isDefined(newURL)) {
+ return;
+ }
+ $http.get(newURL)
+ .success(function (legendData) {
+
+ if (isDefined(leafletLegend)) {
+
+ leafletLegendHelpers.updateLegend(leafletLegend.getContainer(), legendData, type, newURL);
+
+ } else {
+
+ leafletLegend = L.control({
+ position: position
+ });
+ leafletLegend.onAdd = leafletLegendHelpers.getOnAddLegend(legendData, legendClass, type, newURL);
+ leafletLegend.addTo(map);
+ }
+
+ if (isDefined(legend.loadedData) && isFunction(legend.loadedData)) {
+ legend.loadedData();
+ }
+ })
+ .error(function () {
+ $log.warn('[AngularJS - Leaflet] legend.url not loaded.');
+ });
+ });
+
+ });
+ }
+ };
+ }]);
+
+angular.module("leaflet-directive").directive('markers',
+ ["$log", "$rootScope", "$q", "leafletData", "leafletHelpers", "leafletMapDefaults", "leafletMarkersHelpers", "leafletMarkerEvents", "leafletIterators", "leafletWatchHelpers", "leafletDirectiveControlsHelpers", function ($log, $rootScope, $q, leafletData, leafletHelpers, leafletMapDefaults,
+ leafletMarkersHelpers, leafletMarkerEvents, leafletIterators, leafletWatchHelpers,
+ leafletDirectiveControlsHelpers) {
+ //less terse vars to helpers
+ var isDefined = leafletHelpers.isDefined,
+ errorHeader = leafletHelpers.errorHeader,
+ Helpers = leafletHelpers,
+ isString = leafletHelpers.isString,
+ addMarkerWatcher = leafletMarkersHelpers.addMarkerWatcher,
+ updateMarker = leafletMarkersHelpers.updateMarker,
+ listenMarkerEvents = leafletMarkersHelpers.listenMarkerEvents,
+ addMarkerToGroup = leafletMarkersHelpers.addMarkerToGroup,
+ createMarker = leafletMarkersHelpers.createMarker,
+ deleteMarker = leafletMarkersHelpers.deleteMarker,
+ $it = leafletIterators,
+ _markersWatchOptions = leafletHelpers.watchOptions,
+ maybeWatch = leafletWatchHelpers.maybeWatch,
+ extendDirectiveControls = leafletDirectiveControlsHelpers.extend;
+
+ var _getLMarker = function(leafletMarkers, name, maybeLayerName){
+ if(!Object.keys(leafletMarkers).length) return;
+ if(maybeLayerName && isString(maybeLayerName)){
+ if(!leafletMarkers[maybeLayerName] || !Object.keys(leafletMarkers[maybeLayerName]).length)
+ return;
+ return leafletMarkers[maybeLayerName][name];
+ }
+ return leafletMarkers[name];
+ };
+
+ var _setLMarker = function(lObject, leafletMarkers, name, maybeLayerName){
+ if(maybeLayerName && isString(maybeLayerName)){
+ if(!isDefined(leafletMarkers[maybeLayerName]))
+ leafletMarkers[maybeLayerName] = {};
+ leafletMarkers[maybeLayerName][name] = lObject;
+ }
+ else
+ leafletMarkers[name] = lObject;
+ return lObject;
+ };
+
+ var _maybeAddMarkerToLayer = function(layerName, layers, model, marker, doIndividualWatch, map){
+
+ if (!isString(layerName)) {
+ $log.error(errorHeader + ' A layername must be a string');
+ return false;
+ }
+
+ if (!isDefined(layers)) {
+ $log.error(errorHeader + ' You must add layers to the directive if the markers are going to use this functionality.');
+ return false;
+ }
+
+ if (!isDefined(layers.overlays) || !isDefined(layers.overlays[layerName])) {
+ $log.error(errorHeader +' A marker can only be added to a layer of type "group"');
+ return false;
+ }
+ var layerGroup = layers.overlays[layerName];
+ if (!(layerGroup instanceof L.LayerGroup || layerGroup instanceof L.FeatureGroup)) {
+ $log.error(errorHeader + ' Adding a marker to an overlay needs a overlay of the type "group" or "featureGroup"');
+ return false;
+ }
+
+ // The marker goes to a correct layer group, so first of all we add it
+ layerGroup.addLayer(marker);
+
+ // The marker is automatically added to the map depending on the visibility
+ // of the layer, so we only have to open the popup if the marker is in the map
+ if (!doIndividualWatch && map.hasLayer(marker) && model.focus === true) {
+ marker.openPopup();
+ }
+ return true;
+ };
+ //TODO: move to leafletMarkersHelpers??? or make a new class/function file (leafletMarkersHelpers is large already)
+ var _addMarkers = function(mapId, markersToRender, oldModels, map, layers, leafletMarkers, leafletScope,
+ watchOptions, maybeLayerName, skips){
+ for (var newName in markersToRender) {
+ if(skips[newName])
+ continue;
+
+ if (newName.search("-") !== -1) {
+ $log.error('The marker can\'t use a "-" on his key name: "' + newName + '".');
+ continue;
+ }
+
+ var model = Helpers.copy(markersToRender[newName]);
+ var pathToMarker = Helpers.getObjectDotPath(maybeLayerName? [maybeLayerName, newName]: [newName]);
+ var maybeLMarker = _getLMarker(leafletMarkers,newName, maybeLayerName);
+ if (!isDefined(maybeLMarker)) {
+ //(nmccready) very important to not have model changes when lObject is changed
+ //this might be desirable in some cases but it causes two-way binding to lObject which is not ideal
+ //if it is left as the reference then all changes from oldModel vs newModel are ignored
+ //see _destroy (where modelDiff becomes meaningless if we do not copy here)
+ var marker = createMarker(model);
+ var layerName = (model? model.layer : undefined) || maybeLayerName; //original way takes pref
+ if (!isDefined(marker)) {
+ $log.error(errorHeader + ' Received invalid data on the marker ' + newName + '.');
+ continue;
+ }
+ _setLMarker(marker, leafletMarkers, newName, maybeLayerName);
+
+ // Bind message
+ if (isDefined(model.message)) {
+ marker.bindPopup(model.message, model.popupOptions);
+ }
+
+ // Add the marker to a cluster group if needed
+ if (isDefined(model.group)) {
+ var groupOptions = isDefined(model.groupOption) ? model.groupOption : null;
+ addMarkerToGroup(marker, model.group, groupOptions, map);
+ }
+
+ // Show label if defined
+ if (Helpers.LabelPlugin.isLoaded() && isDefined(model.label) && isDefined(model.label.message)) {
+ marker.bindLabel(model.label.message, model.label.options);
+ }
+
+ // Check if the marker should be added to a layer
+ if (isDefined(model) && (isDefined(model.layer) || isDefined(maybeLayerName))){
+
+ var pass = _maybeAddMarkerToLayer(layerName, layers, model, marker,
+ watchOptions.individual.doWatch, map);
+ if(!pass)
+ continue; //something went wrong move on in the loop
+ } else if (!isDefined(model.group)) {
+ // We do not have a layer attr, so the marker goes to the map layer
+ map.addLayer(marker);
+ if (!watchOptions.individual.doWatch && model.focus === true) {
+ marker.openPopup();
+ }
+ }
+
+ if (watchOptions.individual.doWatch) {
+ addMarkerWatcher(marker, pathToMarker, leafletScope, layers, map,
+ watchOptions.individual.isDeep);
+ }
+
+ listenMarkerEvents(marker, model, leafletScope, watchOptions.individual.doWatch, map);
+ leafletMarkerEvents.bindEvents(mapId, marker, pathToMarker, model, leafletScope, layerName);
+ }
+ else {
+ var oldModel = isDefined(oldModel)? oldModels[newName] : undefined;
+ updateMarker(model, oldModel, maybeLMarker, pathToMarker, leafletScope, layers, map);
+ }
+ }
+ };
+ var _seeWhatWeAlreadyHave = function(markerModels, oldMarkerModels, lMarkers, isEqual, cb){
+ var hasLogged = false,
+ equals = false,
+ oldMarker,
+ newMarker;
+
+ var doCheckOldModel = isDefined(oldMarkerModels);
+ for (var name in lMarkers) {
+ if(!hasLogged) {
+ $log.debug(errorHeader + "[markers] destroy: ");
+ hasLogged = true;
+ }
+
+ if(doCheckOldModel){
+ //might want to make the option (in watch options) to disable deep checking
+ //ie the options to only check !== (reference check) instead of angular.equals (slow)
+ newMarker = markerModels[name];
+ oldMarker = oldMarkerModels[name];
+ equals = angular.equals(newMarker,oldMarker) && isEqual;
+ }
+ if (!isDefined(markerModels) ||
+ !Object.keys(markerModels).length ||
+ !isDefined(markerModels[name]) ||
+ !Object.keys(markerModels[name]).length ||
+ equals) {
+ if(cb && Helpers.isFunction(cb))
+ cb(newMarker, oldMarker, name);
+ }
+ }
+ };
+ var _destroy = function(markerModels, oldMarkerModels, lMarkers, map, layers){
+ _seeWhatWeAlreadyHave(markerModels, oldMarkerModels, lMarkers, false,
+ function(newMarker, oldMarker, lMarkerName){
+ $log.debug(errorHeader + '[marker] is deleting marker: ' + lMarkerName);
+ deleteMarker(lMarkers[lMarkerName], map, layers);
+ delete lMarkers[lMarkerName];
+ });
+ };
+
+ var _getNewModelsToSkipp = function(newModels, oldModels, lMarkers){
+ var skips = {};
+ _seeWhatWeAlreadyHave(newModels, oldModels, lMarkers, true,
+ function(newMarker, oldMarker, lMarkerName){
+ $log.debug(errorHeader + '[marker] is already rendered, marker: ' + lMarkerName);
+ skips[lMarkerName] = newMarker;
+ });
+ return skips;
+ };
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: ['leaflet', '?layers'],
+
+ link: function(scope, element, attrs, controller) {
+ var mapController = controller[0],
+ leafletScope = mapController.getLeafletScope();
+
+ mapController.getMap().then(function(map) {
+ var leafletMarkers = {}, getLayers;
+
+ // If the layers attribute is used, we must wait until the layers are created
+ if (isDefined(controller[1])) {
+ getLayers = controller[1].getLayers;
+ } else {
+ getLayers = function() {
+ var deferred = $q.defer();
+ deferred.resolve();
+ return deferred.promise;
+ };
+ }
+
+ var watchOptions = leafletScope.markersWatchOptions || _markersWatchOptions;
+
+ // backwards compat
+ if(isDefined(attrs.watchMarkers))
+ watchOptions.doWatch = watchOptions.individual.doWatch =
+ (!isDefined(attrs.watchMarkers) || Helpers.isTruthy(attrs.watchMarkers));
+
+ var isNested = (isDefined(attrs.markersNested) && Helpers.isTruthy(attrs.markersNested));
+
+ getLayers().then(function(layers) {
+ var _clean = function(models, oldModels){
+ if(isNested) {
+ $it.each(models, function(markerToMaybeDel, layerName) {
+ var oldModel = isDefined(oldModel)? oldModels[layerName] : undefined;
+ _destroy(markerToMaybeDel, oldModel, leafletMarkers[layerName], map, layers);
+ });
+ return;
+ }
+ _destroy(models, oldModels, leafletMarkers, map, layers);
+ };
+
+ var _create = function(models, oldModels){
+ _clean(models, oldModels);
+ var skips = null;
+ if(isNested) {
+ $it.each(models, function(markersToAdd, layerName) {
+ var oldModel = isDefined(oldModel)? oldModels[layerName] : undefined;
+ skips = _getNewModelsToSkipp(models[layerName], oldModel, leafletMarkers[layerName]);
+ _addMarkers(attrs.id, markersToAdd, oldModels, map, layers, leafletMarkers, leafletScope,
+ watchOptions, layerName, skips);
+ });
+ return;
+ }
+ skips = _getNewModelsToSkipp(models, oldModels, leafletMarkers);
+ _addMarkers(attrs.id, models, oldModels, map, layers, leafletMarkers, leafletScope,
+ watchOptions, undefined, skips);
+ };
+ extendDirectiveControls(attrs.id, 'markers', _create, _clean);
+ leafletData.setMarkers(leafletMarkers, attrs.id);
+
+ maybeWatch(leafletScope,'markers', watchOptions, function(newMarkers, oldMarkers){
+ _create(newMarkers, oldMarkers);
+ });
+ });
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('maxbounds', ["$log", "leafletMapDefaults", "leafletBoundsHelpers", "leafletHelpers", function ($log, leafletMapDefaults, leafletBoundsHelpers, leafletHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+
+ link: function(scope, element, attrs, controller) {
+ var leafletScope = controller.getLeafletScope(),
+ isValidBounds = leafletBoundsHelpers.isValidBounds,
+ isNumber = leafletHelpers.isNumber;
+
+
+ controller.getMap().then(function(map) {
+ leafletScope.$watch("maxbounds", function (maxbounds) {
+ if (!isValidBounds(maxbounds)) {
+ // Unset any previous maxbounds
+ map.setMaxBounds();
+ return;
+ }
+
+ var leafletBounds = leafletBoundsHelpers.createLeafletBounds(maxbounds);
+ if(isNumber(maxbounds.pad)) {
+ leafletBounds = leafletBounds.pad(maxbounds.pad);
+ }
+
+ map.setMaxBounds(leafletBounds);
+ if (!attrs.center && !attrs.lfCenter) {
+ map.fitBounds(leafletBounds);
+ }
+ });
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('paths', ["$log", "$q", "leafletData", "leafletMapDefaults", "leafletHelpers", "leafletPathsHelpers", "leafletPathEvents", function ($log, $q, leafletData, leafletMapDefaults, leafletHelpers, leafletPathsHelpers, leafletPathEvents) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: ['leaflet', '?layers'],
+
+ link: function(scope, element, attrs, controller) {
+ var mapController = controller[0],
+ isDefined = leafletHelpers.isDefined,
+ isString = leafletHelpers.isString,
+ leafletScope = mapController.getLeafletScope(),
+ paths = leafletScope.paths,
+ createPath = leafletPathsHelpers.createPath,
+ bindPathEvents = leafletPathEvents.bindPathEvents,
+ setPathOptions = leafletPathsHelpers.setPathOptions;
+
+ mapController.getMap().then(function(map) {
+ var defaults = leafletMapDefaults.getDefaults(attrs.id),
+ getLayers;
+
+ // If the layers attribute is used, we must wait until the layers are created
+ if (isDefined(controller[1])) {
+ getLayers = controller[1].getLayers;
+ } else {
+ getLayers = function() {
+ var deferred = $q.defer();
+ deferred.resolve();
+ return deferred.promise;
+ };
+ }
+
+ if (!isDefined(paths)) {
+ return;
+ }
+
+ getLayers().then(function(layers) {
+
+ var leafletPaths = {};
+ leafletData.setPaths(leafletPaths, attrs.id);
+
+ // Should we watch for every specific marker on the map?
+ var shouldWatch = (!isDefined(attrs.watchPaths) || attrs.watchPaths === 'true');
+
+ // Function for listening every single path once created
+ var watchPathFn = function(leafletPath, name) {
+ var clearWatch = leafletScope.$watch("paths[\""+name+"\"]", function(pathData, old) {
+ if (!isDefined(pathData)) {
+ if (isDefined(old.layer)) {
+ for (var i in layers.overlays) {
+ var overlay = layers.overlays[i];
+ overlay.removeLayer(leafletPath);
+ }
+ }
+ map.removeLayer(leafletPath);
+ clearWatch();
+ return;
+ }
+ setPathOptions(leafletPath, pathData.type, pathData);
+ }, true);
+ };
+
+ leafletScope.$watchCollection("paths", function (newPaths) {
+
+ // Delete paths (by name) from the array
+ for (var name in leafletPaths) {
+ if (!isDefined(newPaths[name])) {
+ map.removeLayer(leafletPaths[name]);
+ delete leafletPaths[name];
+ }
+ }
+
+ // Create the new paths
+ for (var newName in newPaths) {
+ if (newName.search('\\$') === 0) {
+ continue;
+ }
+ if (newName.search("-") !== -1) {
+ $log.error('[AngularJS - Leaflet] The path name "' + newName + '" is not valid. It must not include "-" and a number.');
+ continue;
+ }
+
+ if (!isDefined(leafletPaths[newName])) {
+ var pathData = newPaths[newName];
+ var newPath = createPath(newName, newPaths[newName], defaults);
+
+ // bind popup if defined
+ if (isDefined(newPath) && isDefined(pathData.message)) {
+ newPath.bindPopup(pathData.message, pathData.popupOptions);
+ }
+
+ // Show label if defined
+ if (leafletHelpers.LabelPlugin.isLoaded() && isDefined(pathData.label) && isDefined(pathData.label.message)) {
+ newPath.bindLabel(pathData.label.message, pathData.label.options);
+ }
+
+ // Check if the marker should be added to a layer
+ if (isDefined(pathData) && isDefined(pathData.layer)) {
+
+ if (!isString(pathData.layer)) {
+ $log.error('[AngularJS - Leaflet] A layername must be a string');
+ continue;
+ }
+ if (!isDefined(layers)) {
+ $log.error('[AngularJS - Leaflet] You must add layers to the directive if the markers are going to use this functionality.');
+ continue;
+ }
+
+ if (!isDefined(layers.overlays) || !isDefined(layers.overlays[pathData.layer])) {
+ $log.error('[AngularJS - Leaflet] A path can only be added to a layer of type "group"');
+ continue;
+ }
+ var layerGroup = layers.overlays[pathData.layer];
+ if (!(layerGroup instanceof L.LayerGroup || layerGroup instanceof L.FeatureGroup)) {
+ $log.error('[AngularJS - Leaflet] Adding a path to an overlay needs a overlay of the type "group" or "featureGroup"');
+ continue;
+ }
+
+ // Listen for changes on the new path
+ leafletPaths[newName] = newPath;
+ // The path goes to a correct layer group, so first of all we add it
+ layerGroup.addLayer(newPath);
+
+ if (shouldWatch) {
+ watchPathFn(newPath, newName);
+ } else {
+ setPathOptions(newPath, pathData.type, pathData);
+ }
+ } else if (isDefined(newPath)) {
+ // Listen for changes on the new path
+ leafletPaths[newName] = newPath;
+ map.addLayer(newPath);
+
+ if (shouldWatch) {
+ watchPathFn(newPath, newName);
+ } else {
+ setPathOptions(newPath, pathData.type, pathData);
+ }
+ }
+
+ bindPathEvents(attrs.id, newPath, newName, pathData, leafletScope);
+ }
+ }
+ });
+ });
+ });
+ }
+ };
+}]);
+
+angular.module("leaflet-directive").directive('tiles', ["$log", "leafletData", "leafletMapDefaults", "leafletHelpers", function ($log, leafletData, leafletMapDefaults, leafletHelpers) {
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: 'leaflet',
+
+ link: function(scope, element, attrs, controller) {
+ var isDefined = leafletHelpers.isDefined,
+ leafletScope = controller.getLeafletScope(),
+ tiles = leafletScope.tiles;
+
+ if (!isDefined(tiles) || !isDefined(tiles.url)) {
+ $log.warn("[AngularJS - Leaflet] The 'tiles' definition doesn't have the 'url' property.");
+ return;
+ }
+
+ controller.getMap().then(function(map) {
+ var defaults = leafletMapDefaults.getDefaults(attrs.id);
+ var tileLayerObj;
+ leafletScope.$watch("tiles", function(tiles, oldtiles) {
+ var tileLayerOptions = defaults.tileLayerOptions;
+ var tileLayerUrl = defaults.tileLayer;
+
+ // If no valid tiles are in the scope, remove the last layer
+ if (!isDefined(tiles.url) && isDefined(tileLayerObj)) {
+ map.removeLayer(tileLayerObj);
+ return;
+ }
+
+ // No leafletTiles object defined yet
+ if (!isDefined(tileLayerObj)) {
+ if (isDefined(tiles.options)) {
+ angular.copy(tiles.options, tileLayerOptions);
+ }
+
+ if (isDefined(tiles.url)) {
+ tileLayerUrl = tiles.url;
+ }
+
+ if (tiles.type === 'wms') {
+ tileLayerObj = L.tileLayer.wms(tileLayerUrl, tileLayerOptions);
+ } else {
+ tileLayerObj = L.tileLayer(tileLayerUrl, tileLayerOptions);
+ }
+
+ tileLayerObj.addTo(map);
+ leafletData.setTiles(tileLayerObj, attrs.id);
+ return;
+ }
+
+ // If the options of the tilelayer is changed, we need to redraw the layer
+ if (isDefined(tiles.url) && isDefined(tiles.options) &&
+ (tiles.type !== oldtiles.type || !angular.equals(tiles.options, tileLayerOptions))) {
+ map.removeLayer(tileLayerObj);
+ tileLayerOptions = defaults.tileLayerOptions;
+ angular.copy(tiles.options, tileLayerOptions);
+ tileLayerUrl = tiles.url;
+
+ if (tiles.type === 'wms') {
+ tileLayerObj = L.tileLayer.wms(tileLayerUrl, tileLayerOptions);
+ } else {
+ tileLayerObj = L.tileLayer(tileLayerUrl, tileLayerOptions);
+ }
+
+ tileLayerObj.addTo(map);
+ leafletData.setTiles(tileLayerObj, attrs.id);
+ return;
+ }
+
+ // Only the URL of the layer is changed, update the tiles object
+ if (isDefined(tiles.url)) {
+ tileLayerObj.setUrl(tiles.url);
+ }
+ }, true);
+ });
+ }
+ };
+}]);
+
+/*
+ Create multiple similar directives for watchOptions to support directiveControl
+ instead. (when watches are disabled)
+ NgAnnotate does not work here due to the functional creation
+*/
+['markers', 'geojson'].forEach(function(name){
+ angular.module("leaflet-directive").directive(name + 'WatchOptions', [
+ '$log', '$rootScope', '$q', 'leafletData', 'leafletHelpers',
+ function ($log, $rootScope, $q, leafletData, leafletHelpers) {
+
+ var isDefined = leafletHelpers.isDefined,
+ errorHeader = leafletHelpers.errorHeader,
+ isObject = leafletHelpers.isObject,
+ _watchOptions = leafletHelpers.watchOptions;
+
+ return {
+ restrict: "A",
+ scope: false,
+ replace: false,
+ require: ['leaflet'],
+
+ link: function (scope, element, attrs, controller) {
+ var mapController = controller[0],
+ leafletScope = mapController.getLeafletScope();
+
+ mapController.getMap().then(function () {
+ if (isDefined(scope[name + 'WatchOptions'])) {
+ if (isObject(scope[name + 'WatchOptions']))
+ angular.extend(_watchOptions, scope[name + 'WatchOptions']);
+ else
+ $log.error(errorHeader + '[' + name + 'WatchOptions] is not an object');
+ leafletScope[name + 'WatchOptions'] = _watchOptions;
+ }
+ });
+ }
+ };
+ }]);
+});
+
+angular.module("leaflet-directive")
+.factory('leafletEventsHelpersFactory', ["$rootScope", "$q", "$log", "leafletHelpers", function ($rootScope, $q, $log, leafletHelpers) {
+ var safeApply = leafletHelpers.safeApply,
+ isDefined = leafletHelpers.isDefined,
+ isObject = leafletHelpers.isObject,
+ isArray = leafletHelpers.isArray,
+ errorHeader = leafletHelpers.errorHeader;
+
+ var EventsHelper = function(rootBroadcastName, lObjectType){
+ this.rootBroadcastName = rootBroadcastName;
+ $log.debug("leafletEventsHelpersFactory: lObjectType: " + lObjectType + "rootBroadcastName: " + rootBroadcastName);
+ //used to path/key out certain properties based on the type , "markers", "geojson"
+ this.lObjectType = lObjectType;
+ };
+
+ EventsHelper.prototype.getAvailableEvents = function(){return [];};
+
+ /*
+ argument: name: Note this can be a single string or dot notation
+ Example:
+ markerModel : {
+ m1: { lat:_, lon: _}
+ }
+ //would yield name of
+ name = "m1"
+
+ If nested:
+ markerModel : {
+ cars: {
+ m1: { lat:_, lon: _}
+ }
+ }
+ //would yield name of
+ name = "cars.m1"
+ */
+ EventsHelper.prototype.genDispatchEvent = function(maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName, extra) {
+ var _this = this;
+
+ maybeMapId = maybeMapId || '';
+ if (maybeMapId)
+ maybeMapId = '.' + maybeMapId;
+
+ return function (e) {
+ var broadcastName = _this.rootBroadcastName + maybeMapId + '.' + eventName;
+ $log.debug(broadcastName);
+ _this.fire(leafletScope, broadcastName, logic, e, e.target || lObject, model, name, layerName, extra);
+ };
+ };
+
+ EventsHelper.prototype.fire = function(scope, broadcastName, logic, event, lObject, model, modelName, layerName, extra){
+ // Safely broadcast the event
+ safeApply(scope, function(){
+ var toSend = {
+ leafletEvent: event,
+ leafletObject: lObject,
+ modelName: modelName,
+ model: model
+ };
+ if (isDefined(layerName))
+ angular.extend(toSend, {layerName: layerName});
+
+ if (logic === "emit") {
+ scope.$emit(broadcastName, toSend);
+ } else {
+ $rootScope.$broadcast(broadcastName, toSend);
+ }
+ });
+ };
+
+ EventsHelper.prototype.bindEvents = function (maybeMapId, lObject, name, model, leafletScope, layerName, extra) {
+ var events = [];
+ var logic = 'emit';
+ var _this = this;
+
+ if (!isDefined(leafletScope.eventBroadcast)) {
+ // Backward compatibility, if no event-broadcast attribute, all events are broadcasted
+ events = this.getAvailableEvents();
+ } else if (!isObject(leafletScope.eventBroadcast)) {
+ // Not a valid object
+ $log.error(errorHeader + "event-broadcast must be an object check your model.");
+ } else {
+ // We have a possible valid object
+ if (!isDefined(leafletScope.eventBroadcast[_this.lObjectType])) {
+ // We do not have events enable/disable do we do nothing (all enabled by default)
+ events = this.getAvailableEvents();
+ } else if (!isObject(leafletScope.eventBroadcast[_this.lObjectType])) {
+ // Not a valid object
+ $log.warn(errorHeader + 'event-broadcast.' + [_this.lObjectType] + ' must be an object check your model.');
+ } else {
+ // We have a possible valid map object
+ // Event propadation logic
+ if (isDefined(leafletScope.eventBroadcast[this.lObjectType].logic)) {
+ // We take care of possible propagation logic
+ if (leafletScope.eventBroadcast[_this.lObjectType].logic !== "emit" &&
+ leafletScope.eventBroadcast[_this.lObjectType].logic !== "broadcast")
+ $log.warn(errorHeader + "Available event propagation logic are: 'emit' or 'broadcast'.");
+ }
+ // Enable / Disable
+ var eventsEnable = false, eventsDisable = false;
+ if (isDefined(leafletScope.eventBroadcast[_this.lObjectType].enable) &&
+ isArray(leafletScope.eventBroadcast[_this.lObjectType].enable))
+ eventsEnable = true;
+ if (isDefined(leafletScope.eventBroadcast[_this.lObjectType].disable) &&
+ isArray(leafletScope.eventBroadcast[_this.lObjectType].disable))
+ eventsDisable = true;
+
+ if (eventsEnable && eventsDisable) {
+ // Both are active, this is an error
+ $log.warn(errorHeader + "can not enable and disable events at the same time");
+ } else if (!eventsEnable && !eventsDisable) {
+ // Both are inactive, this is an error
+ $log.warn(errorHeader + "must enable or disable events");
+ } else {
+ // At this point the object is OK, lets enable or disable events
+ if (eventsEnable) {
+ // Enable events
+ leafletScope.eventBroadcast[this.lObjectType].enable.forEach(function(eventName){
+ // Do we have already the event enabled?
+ if (events.indexOf(eventName) !== -1) {
+ // Repeated event, this is an error
+ $log.warn(errorHeader + "This event " + eventName + " is already enabled");
+ } else {
+ // Does the event exists?
+ if (_this.getAvailableEvents().indexOf(eventName) === -1) {
+ // The event does not exists, this is an error
+ $log.warn(errorHeader + "This event " + eventName + " does not exist");
+ } else {
+ // All ok enable the event
+ events.push(eventName);
+ }
+ }
+ });
+ } else {
+ // Disable events
+ events = this.getAvailableEvents();
+ leafletScope.eventBroadcast[_this.lObjectType].disable.forEach(function(eventName) {
+ var index = events.indexOf(eventName);
+ if (index === -1) {
+ // The event does not exist
+ $log.warn(errorHeader + "This event " + eventName + " does not exist or has been already disabled");
+
+ } else {
+ events.splice(index, 1);
+ }
+ });
+ }
+ }
+ }
+ }
+
+ events.forEach(function(eventName){
+ lObject.on(eventName,_this.genDispatchEvent(maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName, extra));
+ });
+ return logic;
+ };
+
+ return EventsHelper;
+}])
+.service('leafletEventsHelpers', ["leafletEventsHelpersFactory", function(leafletEventsHelpersFactory){
+ return new leafletEventsHelpersFactory();
+}]);
+
+angular.module("leaflet-directive")
+.factory('leafletGeoJsonEvents', ["$rootScope", "$q", "$log", "leafletHelpers", "leafletEventsHelpersFactory", "leafletData", function ($rootScope, $q, $log, leafletHelpers,
+ leafletEventsHelpersFactory, leafletData) {
+ var safeApply = leafletHelpers.safeApply,
+ EventsHelper = leafletEventsHelpersFactory;
+
+ var GeoJsonEvents = function(){
+ EventsHelper.call(this,'leafletDirectiveGeoJson', 'geojson');
+ };
+
+ GeoJsonEvents.prototype = new EventsHelper();
+
+ GeoJsonEvents.prototype.genDispatchEvent = function(maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName, extra) {
+ var base = EventsHelper.prototype.genDispatchEvent.call(this, maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName),
+ _this = this;
+
+ return function(e){
+ if (eventName === 'mouseout') {
+ if (extra.resetStyleOnMouseout) {
+ leafletData.getGeoJSON(extra.mapId)
+ .then(function(leafletGeoJSON){
+ //this is broken on nested needs to traverse or user layerName (nested)
+ var lobj = layerName? leafletGeoJSON[layerName]: leafletGeoJSON;
+ lobj.resetStyle(e.target);
+ });
+
+ }
+ safeApply(leafletScope, function() {
+ $rootScope.$broadcast(_this.rootBroadcastName + '.mouseout', e);
+ });
+ }
+ base(e); //common
+ };
+ };
+
+ GeoJsonEvents.prototype.getAvailableEvents = function(){ return [
+ 'click',
+ 'dblclick',
+ 'mouseover',
+ 'mouseout',
+ ];
+ };
+
+ return new GeoJsonEvents();
+}]);
+
+angular.module("leaflet-directive")
+.factory('leafletLabelEvents', ["$rootScope", "$q", "$log", "leafletHelpers", "leafletEventsHelpersFactory", function ($rootScope, $q, $log, leafletHelpers, leafletEventsHelpersFactory) {
+ var Helpers = leafletHelpers,
+ EventsHelper = leafletEventsHelpersFactory;
+
+ var LabelEvents = function(){
+ EventsHelper.call(this,'leafletDirectiveLabel', 'markers');
+ };
+ LabelEvents.prototype = new EventsHelper();
+
+ LabelEvents.prototype.genDispatchEvent = function(maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName) {
+ var markerName = name.replace('markers.', '');
+ return EventsHelper.prototype
+ .genDispatchEvent.call(this, maybeMapId, eventName, logic, leafletScope, lObject, markerName, model, layerName);
+ };
+
+ LabelEvents.prototype.getAvailableEvents = function(){
+ return [
+ 'click',
+ 'dblclick',
+ 'mousedown',
+ 'mouseover',
+ 'mouseout',
+ 'contextmenu'
+ ];
+ };
+
+ LabelEvents.prototype.genEvents = function (maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName) {
+ var _this = this;
+ var labelEvents = this.getAvailableEvents();
+ var scopeWatchName = Helpers.getObjectArrayPath("markers." + name);
+ labelEvents.forEach(function(eventName) {
+ lObject.label.on(eventName, _this.genDispatchEvent(
+ maybeMapId, eventName, logic, leafletScope, lObject.label, scopeWatchName, model, layerName));
+ });
+ };
+
+ LabelEvents.prototype.bindEvents = function (maybeMapId, lObject, name, model, leafletScope, layerName) {};
+
+ return new LabelEvents();
+}]);
+
+angular.module("leaflet-directive")
+.factory('leafletMapEvents', ["$rootScope", "$q", "$log", "leafletHelpers", "leafletEventsHelpers", "leafletIterators", function ($rootScope, $q, $log, leafletHelpers, leafletEventsHelpers, leafletIterators) {
+ var isDefined = leafletHelpers.isDefined,
+ fire = leafletEventsHelpers.fire;
+
+ var _getAvailableMapEvents = function() {
+ return [
+ 'click',
+ 'dblclick',
+ 'mousedown',
+ 'mouseup',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ 'contextmenu',
+ 'focus',
+ 'blur',
+ 'preclick',
+ 'load',
+ 'unload',
+ 'viewreset',
+ 'movestart',
+ 'move',
+ 'moveend',
+ 'dragstart',
+ 'drag',
+ 'dragend',
+ 'zoomstart',
+ 'zoomanim',
+ 'zoomend',
+ 'zoomlevelschange',
+ 'resize',
+ 'autopanstart',
+ 'layeradd',
+ 'layerremove',
+ 'baselayerchange',
+ 'overlayadd',
+ 'overlayremove',
+ 'locationfound',
+ 'locationerror',
+ 'popupopen',
+ 'popupclose',
+ 'draw:created',
+ 'draw:edited',
+ 'draw:deleted',
+ 'draw:drawstart',
+ 'draw:drawstop',
+ 'draw:editstart',
+ 'draw:editstop',
+ 'draw:deletestart',
+ 'draw:deletestop'
+ ];
+ };
+
+ var _genDispatchMapEvent = function(scope, eventName, logic, maybeMapId) {
+ if (maybeMapId)
+ maybeMapId = maybeMapId + '.';
+ return function(e) {
+ // Put together broadcast name
+ var broadcastName = 'leafletDirectiveMap.' + maybeMapId + eventName;
+ $log.debug(broadcastName);
+ // Safely broadcast the event
+ fire(scope, broadcastName, logic, e, e.target, scope);
+ };
+ };
+
+ var _notifyCenterChangedToBounds = function(scope) {
+ scope.$broadcast("boundsChanged");
+ };
+
+ var _notifyCenterUrlHashChanged = function(scope, map, attrs, search) {
+ if (!isDefined(attrs.urlHashCenter)) {
+ return;
+ }
+ var center = map.getCenter();
+ var centerUrlHash = (center.lat).toFixed(4) + ":" + (center.lng).toFixed(4) + ":" + map.getZoom();
+ if (!isDefined(search.c) || search.c !== centerUrlHash) {
+ //$log.debug("notified new center...");
+ scope.$emit("centerUrlHash", centerUrlHash);
+ }
+ };
+
+ var _addEvents = function(map, mapEvents, contextName, scope, logic){
+ leafletIterators.each(mapEvents, function(eventName) {
+ var context = {};
+ context[contextName] = eventName;
+ map.on(eventName, _genDispatchMapEvent(scope, eventName, logic, map._container.id || ''), context);
+ });
+ };
+
+ return {
+ getAvailableMapEvents: _getAvailableMapEvents,
+ genDispatchMapEvent: _genDispatchMapEvent,
+ notifyCenterChangedToBounds: _notifyCenterChangedToBounds,
+ notifyCenterUrlHashChanged: _notifyCenterUrlHashChanged,
+ addEvents: _addEvents
+ };
+}]);
+
+angular.module("leaflet-directive")
+.factory('leafletMarkerEvents', ["$rootScope", "$q", "$log", "leafletHelpers", "leafletEventsHelpersFactory", "leafletLabelEvents", function ($rootScope, $q, $log, leafletHelpers, leafletEventsHelpersFactory, leafletLabelEvents) {
+ var safeApply = leafletHelpers.safeApply,
+ isDefined = leafletHelpers.isDefined,
+ Helpers = leafletHelpers,
+ lblHelp = leafletLabelEvents,
+ EventsHelper = leafletEventsHelpersFactory;
+
+ var MarkerEvents = function(){
+ EventsHelper.call(this,'leafletDirectiveMarker', 'markers');
+ };
+
+ MarkerEvents.prototype = new EventsHelper();
+
+ MarkerEvents.prototype.genDispatchEvent = function(maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName) {
+ var handle = EventsHelper.prototype
+ .genDispatchEvent.call(this, maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName);
+ return function(e){
+ // Broadcast old marker click name for backwards compatibility
+ if (eventName === "click") {
+ safeApply(leafletScope, function () {
+ $rootScope.$broadcast('leafletDirectiveMarkersClick', name);
+ });
+ } else if (eventName === 'dragend') {
+ safeApply(leafletScope, function () {
+ model.lat = lObject.getLatLng().lat;
+ model.lng = lObject.getLatLng().lng;
+ });
+ if (model.message && model.focus === true) {
+ lObject.openPopup();
+ }
+ }
+ handle(e); //common
+ };
+ };
+
+ MarkerEvents.prototype.getAvailableEvents = function(){ return [
+ 'click',
+ 'dblclick',
+ 'mousedown',
+ 'mouseover',
+ 'mouseout',
+ 'contextmenu',
+ 'dragstart',
+ 'drag',
+ 'dragend',
+ 'move',
+ 'remove',
+ 'popupopen',
+ 'popupclose',
+ 'touchend',
+ 'touchstart',
+ 'touchmove',
+ 'touchcancel',
+ 'touchleave'
+ ];
+ };
+
+ MarkerEvents.prototype.bindEvents = function (maybeMapId, lObject, name, model, leafletScope, layerName) {
+ var logic = EventsHelper.prototype.bindEvents.call(this, maybeMapId, lObject, name, model, leafletScope, layerName);
+
+ if (Helpers.LabelPlugin.isLoaded() && isDefined(lObject.label)) {
+ lblHelp.genEvents(maybeMapId, name, logic, leafletScope, lObject, model, layerName);
+ }
+ };
+
+ return new MarkerEvents();
+}]);
+
+angular.module("leaflet-directive")
+.factory('leafletPathEvents', ["$rootScope", "$q", "$log", "leafletHelpers", "leafletLabelEvents", "leafletEventsHelpers", function ($rootScope, $q, $log, leafletHelpers, leafletLabelEvents, leafletEventsHelpers) {
+ var isDefined = leafletHelpers.isDefined,
+ isObject = leafletHelpers.isObject,
+ Helpers = leafletHelpers,
+ errorHeader = leafletHelpers.errorHeader,
+ lblHelp = leafletLabelEvents,
+ fire = leafletEventsHelpers.fire;
+
+ /*
+ TODO (nmccready) This EventsHelper needs to be derrived from leafletEventsHelpers to elminate copy and paste code.
+ */
+
+ var _genDispatchPathEvent = function (maybeMapId, eventName, logic, leafletScope, lObject, name, model, layerName) {
+ maybeMapId = maybeMapId || '';
+
+ if (maybeMapId)
+ maybeMapId = '.' + maybeMapId;
+
+ return function (e) {
+ var broadcastName = 'leafletDirectivePath' + maybeMapId + '.' + eventName;
+ $log.debug(broadcastName);
+ fire(leafletScope, broadcastName, logic, e, e.target || lObject, model, name, layerName);
+ };
+ };
+
+ var _bindPathEvents = function (maybeMapId, lObject, name, model, leafletScope) {
+ var pathEvents = [],
+ i,
+ eventName,
+ logic = "broadcast";
+
+ if (!isDefined(leafletScope.eventBroadcast)) {
+ // Backward compatibility, if no event-broadcast attribute, all events are broadcasted
+ pathEvents = _getAvailablePathEvents();
+ } else if (!isObject(leafletScope.eventBroadcast)) {
+ // Not a valid object
+ $log.error(errorHeader + "event-broadcast must be an object check your model.");
+ } else {
+ // We have a possible valid object
+ if (!isDefined(leafletScope.eventBroadcast.path)) {
+ // We do not have events enable/disable do we do nothing (all enabled by default)
+ pathEvents = _getAvailablePathEvents();
+ } else if (isObject(leafletScope.eventBroadcast.paths)) {
+ // Not a valid object
+ $log.warn(errorHeader + "event-broadcast.path must be an object check your model.");
+ } else {
+ // We have a possible valid map object
+ // Event propadation logic
+ if (leafletScope.eventBroadcast.path.logic !== undefined && leafletScope.eventBroadcast.path.logic !== null) {
+ // We take care of possible propagation logic
+ if (leafletScope.eventBroadcast.path.logic !== "emit" && leafletScope.eventBroadcast.path.logic !== "broadcast") {
+ // This is an error
+ $log.warn(errorHeader + "Available event propagation logic are: 'emit' or 'broadcast'.");
+ } else if (leafletScope.eventBroadcast.path.logic === "emit") {
+ logic = "emit";
+ }
+ }
+ // Enable / Disable
+ var pathEventsEnable = false, pathEventsDisable = false;
+ if (leafletScope.eventBroadcast.path.enable !== undefined && leafletScope.eventBroadcast.path.enable !== null) {
+ if (typeof leafletScope.eventBroadcast.path.enable === 'object') {
+ pathEventsEnable = true;
+ }
+ }
+ if (leafletScope.eventBroadcast.path.disable !== undefined && leafletScope.eventBroadcast.path.disable !== null) {
+ if (typeof leafletScope.eventBroadcast.path.disable === 'object') {
+ pathEventsDisable = true;
+ }
+ }
+ if (pathEventsEnable && pathEventsDisable) {
+ // Both are active, this is an error
+ $log.warn(errorHeader + "can not enable and disable events at the same time");
+ } else if (!pathEventsEnable && !pathEventsDisable) {
+ // Both are inactive, this is an error
+ $log.warn(errorHeader + "must enable or disable events");
+ } else {
+ // At this point the path object is OK, lets enable or disable events
+ if (pathEventsEnable) {
+ // Enable events
+ for (i = 0; i < leafletScope.eventBroadcast.path.enable.length; i++) {
+ eventName = leafletScope.eventBroadcast.path.enable[i];
+ // Do we have already the event enabled?
+ if (pathEvents.indexOf(eventName) !== -1) {
+ // Repeated event, this is an error
+ $log.warn(errorHeader + "This event " + eventName + " is already enabled");
+ } else {
+ // Does the event exists?
+ if (_getAvailablePathEvents().indexOf(eventName) === -1) {
+ // The event does not exists, this is an error
+ $log.warn(errorHeader + "This event " + eventName + " does not exist");
+ } else {
+ // All ok enable the event
+ pathEvents.push(eventName);
+ }
+ }
+ }
+ } else {
+ // Disable events
+ pathEvents = _getAvailablePathEvents();
+ for (i = 0; i < leafletScope.eventBroadcast.path.disable.length; i++) {
+ eventName = leafletScope.eventBroadcast.path.disable[i];
+ var index = pathEvents.indexOf(eventName);
+ if (index === -1) {
+ // The event does not exist
+ $log.warn(errorHeader + "This event " + eventName + " does not exist or has been already disabled");
+
+ } else {
+ pathEvents.splice(index, 1);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < pathEvents.length; i++) {
+ eventName = pathEvents[i];
+ lObject.on(eventName, _genDispatchPathEvent(maybeMapId, eventName, logic, leafletScope, pathEvents, name));
+ }
+
+ if (Helpers.LabelPlugin.isLoaded() && isDefined(lObject.label)) {
+ lblHelp.genEvents(maybeMapId, name, logic, leafletScope, lObject, model);
+ }
+ };
+
+ var _getAvailablePathEvents = function () {
+ return [
+ 'click',
+ 'dblclick',
+ 'mousedown',
+ 'mouseover',
+ 'mouseout',
+ 'contextmenu',
+ 'add',
+ 'remove',
+ 'popupopen',
+ 'popupclose'
+ ];
+ };
+
+ return {
+ getAvailablePathEvents: _getAvailablePathEvents,
+ bindPathEvents: _bindPathEvents
+ };
+}]);
+
+}(angular));
\ No newline at end of file
diff --git a/grunt/aliases.yaml b/grunt/aliases.yaml
index 0c368458..3872906c 100644
--- a/grunt/aliases.yaml
+++ b/grunt/aliases.yaml
@@ -35,12 +35,12 @@ fast-build:
- 'concat:dist'
- 'ngAnnotate'
- 'uglify'
+ - 'concat:license'
+ - 'concat:license-minified'
build:
- 'fast-build'
- - 'uglify'
- 'test-unit'
- - 'concat:license'
- 'clean:pre'
travis:
diff --git a/grunt/concat.json b/grunt/concat.json
index 7dece7b3..cbb62244 100644
--- a/grunt/concat.json
+++ b/grunt/concat.json
@@ -8,11 +8,17 @@
"src/directives/leaflet.js",
"src/services/*.js",
"src/**/*.js"
-
],
"dest": "dist/angular-leaflet-directive.pre.js"
},
"license": {
+ "src": [
+ "src/header-MIT-license.txt",
+ "dist/angular-leaflet-directive.no-header.js"
+ ],
+ "dest": "dist/angular-leaflet-directive.js"
+ },
+ "license-minified": {
"src": [
"src/header-MIT-license.txt",
"dist/angular-leaflet-directive.min.no-header.js"
diff --git a/grunt/ngAnnotate.json b/grunt/ngAnnotate.json
index f9fc860d..2522a73d 100644
--- a/grunt/ngAnnotate.json
+++ b/grunt/ngAnnotate.json
@@ -2,7 +2,7 @@
"options": {},
"dist": {
"files": {
- "dist/angular-leaflet-directive.js": [ "dist/angular-leaflet-directive.pre.js" ]
+ "dist/angular-leaflet-directive.no-header.js": [ "dist/angular-leaflet-directive.pre.js" ]
}
}
}
diff --git a/grunt/uglify.json b/grunt/uglify.json
index f257af49..f53aa71c 100644
--- a/grunt/uglify.json
+++ b/grunt/uglify.json
@@ -1,10 +1,11 @@
{
- "options": {
- "banner": "/*!\n* <%= pkg.name %> <%= pkg.version %> <%= grunt.template.today(\"yyyy-mm-dd\") %>\n* <%= pkg.description %>\n* <%= pkg.repository.type %>: <%= pkg.repository.url %>\n*/\n(function(angular){\n'use strict';\n"
- },
"dist": {
+ "options": {
+ "banner": "/*!\n* <%= pkg.name %> <%= pkg.version %> <%= grunt.template.today(\"yyyy-mm-dd\") %>\n* <%= pkg.description %>\n* <%= pkg.repository.type %>: <%= pkg.repository.url %>\n*/\n(function(angular){\n'use strict';\n",
+ "footer": "\n}(angular));"
+ },
"files": {
- "dist/<%= pkg.name %>.min.no-header.js": ["dist/angular-leaflet-directive.js"]
+ "dist/<%= pkg.name %>.min.no-header.js": ["dist/<%= pkg.name %>.no-header.js"]
}
}
}
{{ title }}
' + + '' +
+ '
' +
+ '' +
+ '{{ baseTitle }}
' + + '' +
+ '' +
+ '
' +
+ '