2876 lines
120 KiB
JavaScript
2876 lines
120 KiB
JavaScript
(function () {
|
|
'use strict';
|
|
angular.module('leaflet-directive', []).directive('leaflet', [
|
|
'$q',
|
|
'leafletData',
|
|
'leafletMapDefaults',
|
|
'leafletHelpers',
|
|
'leafletEvents',
|
|
function ($q, leafletData, leafletMapDefaults, leafletHelpers, leafletEvents) {
|
|
var _leafletMap;
|
|
return {
|
|
restrict: 'EA',
|
|
replace: true,
|
|
scope: {
|
|
center: '=center',
|
|
defaults: '=defaults',
|
|
maxbounds: '=maxbounds',
|
|
bounds: '=bounds',
|
|
markers: '=markers',
|
|
legend: '=legend',
|
|
geojson: '=geojson',
|
|
paths: '=paths',
|
|
tiles: '=tiles',
|
|
layers: '=layers',
|
|
controls: '=controls',
|
|
eventBroadcast: '=eventBroadcast'
|
|
},
|
|
template: '<div class="angular-leaflet-map"></div>',
|
|
controller: [
|
|
'$scope',
|
|
function ($scope) {
|
|
_leafletMap = $q.defer();
|
|
this.getMap = function () {
|
|
return _leafletMap.promise;
|
|
};
|
|
this.getLeafletScope = function () {
|
|
return $scope;
|
|
};
|
|
}
|
|
],
|
|
link: function (scope, element, attrs) {
|
|
var isDefined = leafletHelpers.isDefined, defaults = leafletMapDefaults.setDefaults(scope.defaults, attrs.id), genDispatchMapEvent = leafletEvents.genDispatchMapEvent, mapEvents = leafletEvents.getAvailableMapEvents();
|
|
// Set width and height if they are defined
|
|
if (isDefined(attrs.width)) {
|
|
if (isNaN(attrs.width)) {
|
|
element.css('width', attrs.width);
|
|
} else {
|
|
element.css('width', attrs.width + 'px');
|
|
}
|
|
}
|
|
if (isDefined(attrs.height)) {
|
|
if (isNaN(attrs.height)) {
|
|
element.css('height', attrs.height);
|
|
} else {
|
|
element.css('height', attrs.height + 'px');
|
|
}
|
|
}
|
|
// Create the Leaflet Map Object with the options
|
|
var map = new L.Map(element[0], leafletMapDefaults.getMapCreationDefaults(attrs.id));
|
|
_leafletMap.resolve(map);
|
|
if (!isDefined(attrs.center)) {
|
|
map.setView([
|
|
defaults.center.lat,
|
|
defaults.center.lng
|
|
], defaults.center.zoom);
|
|
}
|
|
// If no layers nor tiles defined, set the default tileLayer
|
|
if (!isDefined(attrs.tiles) && !isDefined(attrs.layers)) {
|
|
var tileLayerObj = L.tileLayer(defaults.tileLayer, defaults.tileLayerOptions);
|
|
tileLayerObj.addTo(map);
|
|
leafletData.setTiles(tileLayerObj, attrs.id);
|
|
}
|
|
// Set zoom control configuration
|
|
if (isDefined(map.zoomControl) && isDefined(defaults.zoomControlPosition)) {
|
|
map.zoomControl.setPosition(defaults.zoomControlPosition);
|
|
}
|
|
if (isDefined(map.zoomControl) && defaults.zoomControl === false) {
|
|
map.zoomControl.removeFrom(map);
|
|
}
|
|
if (isDefined(map.zoomsliderControl) && isDefined(defaults.zoomsliderControl) && defaults.zoomsliderControl === false) {
|
|
map.zoomsliderControl.removeFrom(map);
|
|
}
|
|
// if no event-broadcast attribute, all events are broadcasted
|
|
if (!isDefined(attrs.eventBroadcast)) {
|
|
var logic = 'broadcast';
|
|
for (var i = 0; i < mapEvents.length; i++) {
|
|
var eventName = mapEvents[i];
|
|
map.on(eventName, genDispatchMapEvent(scope, eventName, logic), { eventName: eventName });
|
|
}
|
|
}
|
|
// Resolve the map object to the promises
|
|
map.whenReady(function () {
|
|
leafletData.setMap(map, attrs.id);
|
|
});
|
|
scope.$on('$destroy', function () {
|
|
leafletData.unresolveMap(attrs.id);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('center', [
|
|
'$log',
|
|
'$q',
|
|
'$location',
|
|
'leafletMapDefaults',
|
|
'leafletHelpers',
|
|
'leafletBoundsHelpers',
|
|
'leafletEvents',
|
|
function ($log, $q, $location, leafletMapDefaults, leafletHelpers, leafletBoundsHelpers, leafletEvents) {
|
|
var isDefined = leafletHelpers.isDefined, isNumber = leafletHelpers.isNumber, isSameCenterOnMap = leafletHelpers.isSameCenterOnMap, safeApply = leafletHelpers.safeApply, isValidCenter = leafletHelpers.isValidCenter, isEmpty = leafletHelpers.isEmpty, isUndefinedOrEmpty = leafletHelpers.isUndefinedOrEmpty;
|
|
var shouldInitializeMapWithBounds = function (bounds, center) {
|
|
return isDefined(bounds) && !isEmpty(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.center;
|
|
controller.getMap().then(function (map) {
|
|
var defaults = leafletMapDefaults.getDefaults(attrs.id);
|
|
if (attrs.center.search('-') !== -1) {
|
|
$log.error('The "center" variable can\'t use a "-" on his key name: "' + attrs.center + '".');
|
|
map.setView([
|
|
defaults.center.lat,
|
|
defaults.center.lng
|
|
], defaults.center.zoom);
|
|
return;
|
|
} else if (shouldInitializeMapWithBounds(leafletScope.bounds, centerModel)) {
|
|
map.fitBounds(leafletBoundsHelpers.createLeafletBounds(leafletScope.bounds));
|
|
centerModel = map.getCenter();
|
|
safeApply(leafletScope, function (scope) {
|
|
scope.center = {
|
|
lat: map.getCenter().lat,
|
|
lng: map.getCenter().lng,
|
|
zoom: map.getZoom(),
|
|
autoDiscover: false
|
|
};
|
|
});
|
|
safeApply(leafletScope, function (scope) {
|
|
var mapBounds = map.getBounds();
|
|
var newScopeBounds = {
|
|
northEast: {
|
|
lat: mapBounds._northEast.lat,
|
|
lng: mapBounds._northEast.lng
|
|
},
|
|
southWest: {
|
|
lat: mapBounds._southWest.lat,
|
|
lng: mapBounds._southWest.lng
|
|
}
|
|
};
|
|
scope.bounds = newScopeBounds;
|
|
});
|
|
} else if (!isDefined(centerModel)) {
|
|
$log.error('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);
|
|
scope.center = {
|
|
lat: urlCenter.lat,
|
|
lng: urlCenter.lng,
|
|
zoom: urlCenter.zoom
|
|
};
|
|
}
|
|
});
|
|
}
|
|
leafletScope.$watch('center', function (center) {
|
|
//$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('[AngularJS - Leaflet] 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);
|
|
map.setView([
|
|
center.lat,
|
|
center.lng
|
|
], center.zoom);
|
|
leafletEvents.notifyCenterChangedToBounds(leafletScope, map);
|
|
}, true);
|
|
map.whenReady(function () {
|
|
mapReady = true;
|
|
});
|
|
map.on('moveend', function () {
|
|
// Resolve the center after the first map position
|
|
_leafletCenter.resolve();
|
|
leafletEvents.notifyCenterUrlHashChanged(leafletScope, map, attrs, $location.search());
|
|
//$log.debug("updated center on map...");
|
|
if (isSameCenterOnMap(centerModel, map)) {
|
|
//$log.debug("same center in model, no need to update again.");
|
|
return;
|
|
}
|
|
safeApply(leafletScope, function (scope) {
|
|
//$log.debug("updating center model...", map.getCenter(), map.getZoom());
|
|
scope.center = {
|
|
lat: map.getCenter().lat,
|
|
lng: map.getCenter().lng,
|
|
zoom: map.getZoom(),
|
|
autoDiscover: false
|
|
};
|
|
leafletEvents.notifyCenterChangedToBounds(leafletScope, map);
|
|
});
|
|
});
|
|
if (centerModel.autoDiscover === true) {
|
|
map.on('locationerror', function () {
|
|
$log.warn('[AngularJS - Leaflet] The Geolocation API is unauthorized on this page.');
|
|
if (isValidCenter(centerModel)) {
|
|
map.setView([
|
|
centerModel.lat,
|
|
centerModel.lng
|
|
], centerModel.zoom);
|
|
leafletEvents.notifyCenterChangedToBounds(leafletScope, map);
|
|
} else {
|
|
map.setView([
|
|
defaults.center.lat,
|
|
defaults.center.lng
|
|
], defaults.center.zoom);
|
|
leafletEvents.notifyCenterChangedToBounds(leafletScope, map);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
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) {
|
|
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;
|
|
}
|
|
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) && !angular.equals(tiles.options, tileLayerOptions)) {
|
|
map.removeLayer(tileLayerObj);
|
|
tileLayerOptions = defaults.tileLayerOptions;
|
|
angular.copy(tiles.options, tileLayerOptions);
|
|
tileLayerUrl = tiles.url;
|
|
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);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
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 = legend.legendClass ? legend.legendClass : 'legend';
|
|
var position = legend.position || 'bottomright';
|
|
var leafletLegend;
|
|
controller.getMap().then(function (map) {
|
|
if (!isDefined(legend.url) && (!isArray(legend.colors) || !isArray(legend.labels) || legend.colors.length !== legend.labels.length)) {
|
|
$log.warn('[AngularJS - Leaflet] legend.colors and legend.labels must be set.');
|
|
} else if (isDefined(legend.url)) {
|
|
$log.info('[AngularJS - Leaflet] loading arcgis legend service.');
|
|
} else {
|
|
// TODO: Watch array legend.
|
|
leafletLegend = L.control({ position: position });
|
|
leafletLegend.onAdd = leafletLegendHelpers.getOnAddArrayLegend(legend, legendClass);
|
|
leafletLegend.addTo(map);
|
|
}
|
|
leafletScope.$watch('legend.url', function (newURL) {
|
|
if (!isDefined(newURL)) {
|
|
return;
|
|
}
|
|
$http.get(newURL).success(function (legendData) {
|
|
if (isDefined(leafletLegend)) {
|
|
leafletLegendHelpers.updateArcGISLegend(leafletLegend.getContainer(), legendData);
|
|
} else {
|
|
leafletLegend = L.control({ position: position });
|
|
leafletLegend.onAdd = leafletLegendHelpers.getOnAddArcGISLegend(legendData, legendClass);
|
|
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('geojson', [
|
|
'$log',
|
|
'$rootScope',
|
|
'leafletData',
|
|
'leafletHelpers',
|
|
function ($log, $rootScope, leafletData, leafletHelpers) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: 'leaflet',
|
|
link: function (scope, element, attrs, controller) {
|
|
var safeApply = leafletHelpers.safeApply, isDefined = leafletHelpers.isDefined, leafletScope = controller.getLeafletScope(), leafletGeoJSON = {};
|
|
controller.getMap().then(function (map) {
|
|
leafletScope.$watch('geojson', function (geojson) {
|
|
if (isDefined(leafletGeoJSON) && map.hasLayer(leafletGeoJSON)) {
|
|
map.removeLayer(leafletGeoJSON);
|
|
}
|
|
if (!(isDefined(geojson) && isDefined(geojson.data))) {
|
|
return;
|
|
}
|
|
var resetStyleOnMouseout = geojson.resetStyleOnMouseout, onEachFeature = geojson.onEachFeature;
|
|
if (!onEachFeature) {
|
|
onEachFeature = function (feature, layer) {
|
|
if (leafletHelpers.LabelPlugin.isLoaded() && isDefined(geojson.label)) {
|
|
layer.bindLabel(feature.properties.description);
|
|
}
|
|
layer.on({
|
|
mouseover: function (e) {
|
|
safeApply(leafletScope, function () {
|
|
geojson.selected = feature;
|
|
$rootScope.$broadcast('leafletDirectiveMap.geojsonMouseover', e);
|
|
});
|
|
},
|
|
mouseout: function (e) {
|
|
if (resetStyleOnMouseout) {
|
|
leafletGeoJSON.resetStyle(e.target);
|
|
}
|
|
safeApply(leafletScope, function () {
|
|
geojson.selected = undefined;
|
|
$rootScope.$broadcast('leafletDirectiveMap.geojsonMouseout', e);
|
|
});
|
|
},
|
|
click: function (e) {
|
|
safeApply(leafletScope, function () {
|
|
geojson.selected = feature;
|
|
$rootScope.$broadcast('leafletDirectiveMap.geojsonClick', geojson.selected, e);
|
|
});
|
|
}
|
|
});
|
|
};
|
|
}
|
|
geojson.options = {
|
|
style: geojson.style,
|
|
filter: geojson.filter,
|
|
onEachFeature: onEachFeature,
|
|
pointToLayer: geojson.pointToLayer
|
|
};
|
|
leafletGeoJSON = L.geoJson(geojson.data, geojson.options);
|
|
leafletData.setGeoJSON(leafletGeoJSON);
|
|
leafletGeoJSON.addTo(map);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('layers', [
|
|
'$log',
|
|
'$q',
|
|
'leafletData',
|
|
'leafletHelpers',
|
|
'leafletLayerHelpers',
|
|
'leafletControlHelpers',
|
|
function ($log, $q, leafletData, leafletHelpers, leafletLayerHelpers, leafletControlHelpers) {
|
|
var _leafletLayers;
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: 'leaflet',
|
|
controller: function () {
|
|
_leafletLayers = $q.defer();
|
|
this.getLayers = function () {
|
|
return _leafletLayers.promise;
|
|
};
|
|
},
|
|
link: function (scope, element, attrs, controller) {
|
|
var isDefined = leafletHelpers.isDefined, leafletLayers = {}, leafletScope = controller.getLeafletScope(), layers = leafletScope.layers, createLayer = leafletLayerHelpers.createLayer, updateLayersControl = leafletControlHelpers.updateLayersControl, isLayersControlVisible = false;
|
|
controller.getMap().then(function (map) {
|
|
// Do we have a baselayers property?
|
|
if (!isDefined(layers) || !isDefined(layers.baselayers) || Object.keys(layers.baselayers).length === 0) {
|
|
// No baselayers property
|
|
$log.error('[AngularJS - Leaflet] At least one baselayer has to be defined');
|
|
return;
|
|
}
|
|
// We have baselayers to add to the map
|
|
_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) {
|
|
map.addLayer(leafletLayers.baselayers[layerName]);
|
|
oneVisibleLayer = true;
|
|
}
|
|
}
|
|
// If there is no visible layer add first to the map
|
|
if (!oneVisibleLayer && Object.keys(leafletLayers.baselayers).length > 0) {
|
|
map.addLayer(leafletLayers.baselayers[Object.keys(layers.baselayers)[0]]);
|
|
}
|
|
// Setup the Overlays
|
|
for (layerName in layers.overlays) {
|
|
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) {
|
|
map.addLayer(leafletLayers.overlays[layerName]);
|
|
}
|
|
}
|
|
// Watch for the base layers
|
|
leafletScope.$watch('layers.baselayers', function (newBaseLayers) {
|
|
// Delete layers from the array
|
|
for (var name in leafletLayers.baselayers) {
|
|
if (!isDefined(newBaseLayers[name])) {
|
|
// Remove from the map if it's on it
|
|
if (map.hasLayer(leafletLayers.baselayers[name])) {
|
|
map.removeLayer(leafletLayers.baselayers[name]);
|
|
}
|
|
delete leafletLayers.baselayers[name];
|
|
}
|
|
}
|
|
// 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) {
|
|
map.addLayer(leafletLayers.baselayers[newName]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (Object.keys(leafletLayers.baselayers).length === 0) {
|
|
$log.error('[AngularJS - Leaflet] At least one baselayer has to be defined');
|
|
return;
|
|
}
|
|
//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) {
|
|
map.addLayer(leafletLayers.baselayers[Object.keys(layers.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) {
|
|
// Delete layers from the array
|
|
for (var name in leafletLayers.overlays) {
|
|
if (!isDefined(newOverlayLayers[name])) {
|
|
// Remove from the map if it's on it
|
|
if (map.hasLayer(leafletLayers.overlays[name])) {
|
|
map.removeLayer(leafletLayers.overlays[name]);
|
|
}
|
|
// TODO: Depending on the layer type we will have to delete what's included on it
|
|
delete leafletLayers.overlays[name];
|
|
}
|
|
}
|
|
// add new overlays
|
|
for (var newName in newOverlayLayers) {
|
|
if (!isDefined(leafletLayers.overlays[newName])) {
|
|
var testOverlayLayer = createLayer(newOverlayLayers[newName]);
|
|
if (isDefined(testOverlayLayer)) {
|
|
leafletLayers.overlays[newName] = testOverlayLayer;
|
|
if (newOverlayLayers[newName].visible === true) {
|
|
map.addLayer(leafletLayers.overlays[newName]);
|
|
}
|
|
}
|
|
}
|
|
// check for the .visible property to hide/show overLayers
|
|
if (newOverlayLayers[newName].visible && !map.hasLayer(leafletLayers.overlays[newName])) {
|
|
map.addLayer(leafletLayers.overlays[newName]);
|
|
} else if (newOverlayLayers[newName].visible === false && map.hasLayer(leafletLayers.overlays[newName])) {
|
|
map.removeLayer(leafletLayers.overlays[newName]);
|
|
}
|
|
}
|
|
// 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('bounds', [
|
|
'$log',
|
|
'$timeout',
|
|
'leafletHelpers',
|
|
'leafletBoundsHelpers',
|
|
function ($log, $timeout, leafletHelpers, leafletBoundsHelpers) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: [
|
|
'leaflet',
|
|
'center'
|
|
],
|
|
link: function (scope, element, attrs, controller) {
|
|
var isDefined = leafletHelpers.isDefined, createLeafletBounds = leafletBoundsHelpers.createLeafletBounds, leafletScope = controller[0].getLeafletScope(), mapController = controller[0];
|
|
var emptyBounds = function (bounds) {
|
|
if (bounds._southWest.lat === 0 && bounds._southWest.lng === 0 && bounds._northEast.lat === 0 && bounds._northEast.lng === 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
mapController.getMap().then(function (map) {
|
|
leafletScope.$on('boundsChanged', function (event) {
|
|
var scope = event.currentScope;
|
|
var bounds = map.getBounds();
|
|
//$log.debug('updated map bounds...', bounds);
|
|
if (emptyBounds(bounds)) {
|
|
return;
|
|
}
|
|
var newScopeBounds = {
|
|
northEast: {
|
|
lat: bounds._northEast.lat,
|
|
lng: bounds._northEast.lng
|
|
},
|
|
southWest: {
|
|
lat: bounds._southWest.lat,
|
|
lng: bounds._southWest.lng
|
|
}
|
|
};
|
|
if (!angular.equals(scope.bounds, newScopeBounds)) {
|
|
//$log.debug('Need to update scope bounds.');
|
|
scope.bounds = newScopeBounds;
|
|
}
|
|
});
|
|
leafletScope.$watch('bounds', function (bounds) {
|
|
//$log.debug('updated bounds...', bounds);
|
|
if (!isDefined(bounds)) {
|
|
$log.error('[AngularJS - Leaflet] Invalid bounds');
|
|
return;
|
|
}
|
|
var leafletBounds = createLeafletBounds(bounds);
|
|
if (leafletBounds && !map.getBounds().equals(leafletBounds)) {
|
|
//$log.debug('Need to update map bounds.');
|
|
map.fitBounds(leafletBounds);
|
|
}
|
|
}, true);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('markers', [
|
|
'$log',
|
|
'$rootScope',
|
|
'$q',
|
|
'leafletData',
|
|
'leafletHelpers',
|
|
'leafletMapDefaults',
|
|
'leafletMarkersHelpers',
|
|
'leafletEvents',
|
|
function ($log, $rootScope, $q, leafletData, leafletHelpers, leafletMapDefaults, leafletMarkersHelpers, leafletEvents) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: [
|
|
'leaflet',
|
|
'?layers'
|
|
],
|
|
link: function (scope, element, attrs, controller) {
|
|
var mapController = controller[0], Helpers = leafletHelpers, isDefined = leafletHelpers.isDefined, isString = leafletHelpers.isString, leafletScope = mapController.getLeafletScope(), markers = leafletScope.markers, deleteMarker = leafletMarkersHelpers.deleteMarker, addMarkerWatcher = leafletMarkersHelpers.addMarkerWatcher, listenMarkerEvents = leafletMarkersHelpers.listenMarkerEvents, addMarkerToGroup = leafletMarkersHelpers.addMarkerToGroup, bindMarkerEvents = leafletEvents.bindMarkerEvents, createMarker = leafletMarkersHelpers.createMarker;
|
|
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;
|
|
};
|
|
}
|
|
if (!isDefined(markers)) {
|
|
return;
|
|
}
|
|
getLayers().then(function (layers) {
|
|
leafletData.setMarkers(leafletMarkers, attrs.id);
|
|
leafletScope.$watch('markers', function (newMarkers) {
|
|
// Delete markers from the array
|
|
for (var name in leafletMarkers) {
|
|
if (!isDefined(newMarkers) || !isDefined(newMarkers[name])) {
|
|
deleteMarker(leafletMarkers[name], map, layers);
|
|
delete leafletMarkers[name];
|
|
}
|
|
}
|
|
// add new markers
|
|
for (var newName in newMarkers) {
|
|
if (newName.search('-') !== -1) {
|
|
$log.error('The marker can\'t use a "-" on his key name: "' + newName + '".');
|
|
continue;
|
|
}
|
|
if (!isDefined(leafletMarkers[newName])) {
|
|
var markerData = newMarkers[newName];
|
|
var marker = createMarker(markerData);
|
|
if (!isDefined(marker)) {
|
|
$log.error('[AngularJS - Leaflet] Received invalid data on the marker ' + newName + '.');
|
|
continue;
|
|
}
|
|
leafletMarkers[newName] = marker;
|
|
// Bind message
|
|
if (isDefined(markerData.message)) {
|
|
marker.bindPopup(markerData.message, markerData.popupOptions);
|
|
}
|
|
// Add the marker to a cluster group if needed
|
|
if (isDefined(markerData.group)) {
|
|
addMarkerToGroup(marker, markerData.group, map);
|
|
}
|
|
// Show label if defined
|
|
if (Helpers.LabelPlugin.isLoaded() && isDefined(markerData.label) && isDefined(markerData.label.message)) {
|
|
marker.bindLabel(markerData.label.message, markerData.label.options);
|
|
}
|
|
// Check if the marker should be added to a layer
|
|
if (isDefined(markerData) && isDefined(markerData.layer)) {
|
|
if (!isString(markerData.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[markerData.layer])) {
|
|
$log.error('[AngularJS - Leaflet] A marker can only be added to a layer of type "group"');
|
|
continue;
|
|
}
|
|
var layerGroup = layers.overlays[markerData.layer];
|
|
if (!(layerGroup instanceof L.LayerGroup)) {
|
|
$log.error('[AngularJS - Leaflet] Adding a marker to an overlay needs a overlay of the type "group"');
|
|
continue;
|
|
}
|
|
// 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();
|
|
} // Add the marker to the map if it hasn't been added to a layer or to a group
|
|
} else if (!isDefined(markerData.group)) {
|
|
// We do not have a layer attr, so the marker goes to the map layer
|
|
map.addLayer(marker);
|
|
if (markerData.focus === true) {
|
|
marker.openPopup();
|
|
}
|
|
if (Helpers.LabelPlugin.isLoaded() && isDefined(markerData.label) && isDefined(markerData.label.options) && markerData.label.options.noHide === true) {
|
|
marker.showLabel();
|
|
}
|
|
}
|
|
// Should we watch for every specific marker on the map?
|
|
var shouldWatch = !isDefined(attrs.watchMarkers) || attrs.watchMarkers === 'true';
|
|
if (shouldWatch) {
|
|
addMarkerWatcher(marker, newName, leafletScope, layers, map);
|
|
listenMarkerEvents(marker, markerData, leafletScope);
|
|
}
|
|
bindMarkerEvents(marker, newName, markerData, leafletScope);
|
|
}
|
|
}
|
|
}, true);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('paths', [
|
|
'$log',
|
|
'leafletData',
|
|
'leafletMapDefaults',
|
|
'leafletHelpers',
|
|
'leafletPathsHelpers',
|
|
'leafletEvents',
|
|
function ($log, leafletData, leafletMapDefaults, leafletHelpers, leafletPathsHelpers, leafletEvents) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: 'leaflet',
|
|
link: function (scope, element, attrs, controller) {
|
|
var isDefined = leafletHelpers.isDefined, leafletScope = controller.getLeafletScope(), paths = leafletScope.paths, createPath = leafletPathsHelpers.createPath, bindPathEvents = leafletEvents.bindPathEvents, setPathOptions = leafletPathsHelpers.setPathOptions;
|
|
controller.getMap().then(function (map) {
|
|
var defaults = leafletMapDefaults.getDefaults(attrs.id);
|
|
if (!isDefined(paths)) {
|
|
return;
|
|
}
|
|
var leafletPaths = {};
|
|
leafletData.setPaths(leafletPaths, attrs.id);
|
|
// Function for listening every single path once created
|
|
var watchPathFn = function (leafletPath, name) {
|
|
var clearWatch = leafletScope.$watch('paths.' + name, function (pathData) {
|
|
if (!isDefined(pathData)) {
|
|
map.removeLayer(leafletPath);
|
|
clearWatch();
|
|
return;
|
|
}
|
|
setPathOptions(leafletPath, pathData.type, pathData);
|
|
}, true);
|
|
};
|
|
leafletScope.$watch('paths', function (newPaths) {
|
|
// Create the new paths
|
|
for (var newName in newPaths) {
|
|
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);
|
|
}
|
|
// Show label if defined
|
|
if (leafletHelpers.LabelPlugin.isLoaded() && isDefined(pathData.label) && isDefined(pathData.label.message)) {
|
|
newPath.bindLabel(pathData.label.message, pathData.label.options);
|
|
}
|
|
// Listen for changes on the new path
|
|
if (isDefined(newPath)) {
|
|
leafletPaths[newName] = newPath;
|
|
map.addLayer(newPath);
|
|
watchPathFn(newPath, newName);
|
|
}
|
|
bindPathEvents(newPath, newName, pathData, leafletScope);
|
|
}
|
|
}
|
|
// Delete paths (by name) from the array
|
|
for (var name in leafletPaths) {
|
|
if (!isDefined(newPaths[name])) {
|
|
delete leafletPaths[name];
|
|
}
|
|
}
|
|
}, true);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('controls', [
|
|
'$log',
|
|
'leafletHelpers',
|
|
function ($log, leafletHelpers) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: '?^leaflet',
|
|
link: function (scope, element, attrs, controller) {
|
|
if (!controller) {
|
|
return;
|
|
}
|
|
var isDefined = leafletHelpers.isDefined, leafletScope = controller.getLeafletScope(), controls = leafletScope.controls;
|
|
controller.getMap().then(function (map) {
|
|
if (isDefined(L.Control.Draw) && isDefined(controls.draw)) {
|
|
var drawnItems = new L.FeatureGroup();
|
|
map.addLayer(drawnItems);
|
|
var options = { edit: { featureGroup: drawnItems } };
|
|
angular.extend(options, controls.draw.options);
|
|
var drawControl = new L.Control.Draw(options);
|
|
map.addControl(drawControl);
|
|
}
|
|
if (isDefined(controls.custom)) {
|
|
for (var i in controls.custom) {
|
|
map.addControl(controls.custom[i]);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('eventBroadcast', [
|
|
'$log',
|
|
'$rootScope',
|
|
'leafletHelpers',
|
|
'leafletEvents',
|
|
function ($log, $rootScope, leafletHelpers, leafletEvents) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: 'leaflet',
|
|
link: function (scope, element, attrs, controller) {
|
|
var isObject = leafletHelpers.isObject, leafletScope = controller.getLeafletScope(), eventBroadcast = leafletScope.eventBroadcast, availableMapEvents = leafletEvents.getAvailableMapEvents(), genDispatchMapEvent = leafletEvents.genDispatchMapEvent;
|
|
controller.getMap().then(function (map) {
|
|
var mapEvents = [];
|
|
var i;
|
|
var eventName;
|
|
var logic = 'broadcast';
|
|
if (isObject(eventBroadcast)) {
|
|
// We have a possible valid object
|
|
if (eventBroadcast.map === undefined || eventBroadcast.map === null) {
|
|
// We do not have events enable/disable do we do nothing (all enabled by default)
|
|
mapEvents = availableMapEvents;
|
|
} else if (typeof eventBroadcast.map !== 'object') {
|
|
// 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 !== undefined && eventBroadcast.map.logic !== null) {
|
|
// We take care of possible propagation 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 if (eventBroadcast.map.logic === 'emit') {
|
|
logic = 'emit';
|
|
}
|
|
}
|
|
// Enable / Disable
|
|
var mapEventsEnable = false, mapEventsDisable = false;
|
|
if (eventBroadcast.map.enable !== undefined && eventBroadcast.map.enable !== null) {
|
|
if (typeof eventBroadcast.map.enable === 'object') {
|
|
mapEventsEnable = true;
|
|
}
|
|
}
|
|
if (eventBroadcast.map.disable !== undefined && eventBroadcast.map.disable !== null) {
|
|
if (typeof eventBroadcast.map.disable === 'object') {
|
|
mapEventsDisable = true;
|
|
}
|
|
}
|
|
if (mapEventsEnable && mapEventsDisable) {
|
|
// Both are active, this is an error
|
|
$log.warn('[AngularJS - Leaflet] can not enable and disable events at the time');
|
|
} else if (!mapEventsEnable && !mapEventsDisable) {
|
|
// Both are inactive, this is an error
|
|
$log.warn('[AngularJS - Leaflet] must enable or disable events');
|
|
} else {
|
|
// At this point the map object is OK, lets enable or disable events
|
|
if (mapEventsEnable) {
|
|
// Enable events
|
|
for (i = 0; i < eventBroadcast.map.enable.length; i++) {
|
|
eventName = eventBroadcast.map.enable[i];
|
|
// Do we have already the event enabled?
|
|
if (mapEvents.indexOf(eventName) !== -1) {
|
|
// Repeated event, this is an error
|
|
$log.warn('[AngularJS - Leaflet] This event ' + eventName + ' is already enabled');
|
|
} else {
|
|
// Does the event exists?
|
|
if (availableMapEvents.indexOf(eventName) === -1) {
|
|
// The event does not exists, this is an error
|
|
$log.warn('[AngularJS - Leaflet] This event ' + eventName + ' does not exist');
|
|
} else {
|
|
// All ok enable the event
|
|
mapEvents.push(eventName);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Disable events
|
|
mapEvents = availableMapEvents;
|
|
for (i = 0; i < eventBroadcast.map.disable.length; i++) {
|
|
eventName = eventBroadcast.map.disable[i];
|
|
var index = mapEvents.indexOf(eventName);
|
|
if (index === -1) {
|
|
// The event does not exist
|
|
$log.warn('[AngularJS - Leaflet] This event ' + eventName + ' does not exist or has been already disabled');
|
|
} else {
|
|
mapEvents.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < mapEvents.length; i++) {
|
|
eventName = mapEvents[i];
|
|
map.on(eventName, genDispatchMapEvent(leafletScope, eventName, logic), { eventName: eventName });
|
|
}
|
|
} else {
|
|
// Not a valid object
|
|
$log.warn('[AngularJS - Leaflet] event-broadcast must be an object, check your model.');
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').directive('maxbounds', [
|
|
'$log',
|
|
'leafletMapDefaults',
|
|
'leafletBoundsHelpers',
|
|
function ($log, leafletMapDefaults, leafletBoundsHelpers) {
|
|
return {
|
|
restrict: 'A',
|
|
scope: false,
|
|
replace: false,
|
|
require: 'leaflet',
|
|
link: function (scope, element, attrs, controller) {
|
|
var leafletScope = controller.getLeafletScope(), isValidBounds = leafletBoundsHelpers.isValidBounds;
|
|
controller.getMap().then(function (map) {
|
|
leafletScope.$watch('maxbounds', function (maxbounds) {
|
|
if (!isValidBounds(maxbounds)) {
|
|
// Unset any previous maxbounds
|
|
map.setMaxBounds();
|
|
return;
|
|
}
|
|
var bounds = [
|
|
[
|
|
maxbounds.southWest.lat,
|
|
maxbounds.southWest.lng
|
|
],
|
|
[
|
|
maxbounds.northEast.lat,
|
|
maxbounds.northEast.lng
|
|
]
|
|
];
|
|
map.setMaxBounds(bounds);
|
|
map.fitBounds(bounds);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').service('leafletData', [
|
|
'$log',
|
|
'$q',
|
|
'leafletHelpers',
|
|
function ($log, $q, leafletHelpers) {
|
|
var getDefer = leafletHelpers.getDefer, getUnresolvedDefer = leafletHelpers.getUnresolvedDefer, setResolvedDefer = leafletHelpers.setResolvedDefer;
|
|
var maps = {};
|
|
var tiles = {};
|
|
var layers = {};
|
|
var paths = {};
|
|
var markers = {};
|
|
var geoJSON = {};
|
|
this.setMap = function (leafletMap, scopeId) {
|
|
var defer = getUnresolvedDefer(maps, scopeId);
|
|
defer.resolve(leafletMap);
|
|
setResolvedDefer(maps, scopeId);
|
|
};
|
|
this.getMap = function (scopeId) {
|
|
var defer = getDefer(maps, scopeId);
|
|
return defer.promise;
|
|
};
|
|
this.unresolveMap = function (scopeId) {
|
|
var id = leafletHelpers.obtainEffectiveMapId(maps, scopeId);
|
|
maps[id] = undefined;
|
|
};
|
|
this.getPaths = function (scopeId) {
|
|
var defer = getDefer(paths, scopeId);
|
|
return defer.promise;
|
|
};
|
|
this.setPaths = function (leafletPaths, scopeId) {
|
|
var defer = getUnresolvedDefer(paths, scopeId);
|
|
defer.resolve(leafletPaths);
|
|
setResolvedDefer(paths, scopeId);
|
|
};
|
|
this.getMarkers = function (scopeId) {
|
|
var defer = getDefer(markers, scopeId);
|
|
return defer.promise;
|
|
};
|
|
this.setMarkers = function (leafletMarkers, scopeId) {
|
|
var defer = getUnresolvedDefer(markers, scopeId);
|
|
defer.resolve(leafletMarkers);
|
|
setResolvedDefer(markers, scopeId);
|
|
};
|
|
this.getLayers = function (scopeId) {
|
|
var defer = getDefer(layers, scopeId);
|
|
return defer.promise;
|
|
};
|
|
this.setLayers = function (leafletLayers, scopeId) {
|
|
var defer = getUnresolvedDefer(layers, scopeId);
|
|
defer.resolve(leafletLayers);
|
|
setResolvedDefer(layers, scopeId);
|
|
};
|
|
this.setTiles = function (leafletTiles, scopeId) {
|
|
var defer = getUnresolvedDefer(tiles, scopeId);
|
|
defer.resolve(leafletTiles);
|
|
setResolvedDefer(tiles, scopeId);
|
|
};
|
|
this.getTiles = function (scopeId) {
|
|
var defer = getDefer(tiles, scopeId);
|
|
return defer.promise;
|
|
};
|
|
this.setGeoJSON = function (leafletGeoJSON, scopeId) {
|
|
var defer = getUnresolvedDefer(geoJSON, scopeId);
|
|
defer.resolve(leafletGeoJSON);
|
|
setResolvedDefer(geoJSON, scopeId);
|
|
};
|
|
this.getGeoJSON = function (scopeId) {
|
|
var defer = getDefer(geoJSON, scopeId);
|
|
return defer.promise;
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletMapDefaults', [
|
|
'$q',
|
|
'leafletHelpers',
|
|
function ($q, leafletHelpers) {
|
|
function _getDefaults() {
|
|
return {
|
|
keyboard: true,
|
|
dragging: true,
|
|
worldCopyJump: false,
|
|
doubleClickZoom: true,
|
|
scrollWheelZoom: true,
|
|
zoomControl: true,
|
|
zoomsliderControl: false,
|
|
zoomControlPosition: 'topleft',
|
|
attributionControl: true,
|
|
controls: {
|
|
layers: {
|
|
visible: true,
|
|
position: 'topright',
|
|
collapsed: true
|
|
}
|
|
},
|
|
crs: L.CRS.EPSG3857,
|
|
tileLayer: 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
|
|
tileLayerOptions: { attribution: '© <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors' },
|
|
path: {
|
|
weight: 10,
|
|
opacity: 1,
|
|
color: '#0000ff'
|
|
},
|
|
center: {
|
|
lat: 0,
|
|
lng: 0,
|
|
zoom: 1
|
|
}
|
|
};
|
|
}
|
|
var isDefined = leafletHelpers.isDefined, obtainEffectiveMapId = leafletHelpers.obtainEffectiveMapId, defaults = {};
|
|
// Get the _defaults dictionary, and override the properties defined by the user
|
|
return {
|
|
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,
|
|
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.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 (isDefined(userDefaults.crs) && isDefined(L.CRS[userDefaults.crs])) {
|
|
newDefaults.crs = L.CRS[userDefaults.crs];
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
var mapId = obtainEffectiveMapId(defaults, scopeId);
|
|
defaults[mapId] = newDefaults;
|
|
return newDefaults;
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletEvents', [
|
|
'$rootScope',
|
|
'$q',
|
|
'$log',
|
|
'leafletHelpers',
|
|
function ($rootScope, $q, $log, leafletHelpers) {
|
|
var safeApply = leafletHelpers.safeApply, isDefined = leafletHelpers.isDefined, isObject = leafletHelpers.isObject, Helpers = leafletHelpers;
|
|
var _getAvailableLabelEvents = function () {
|
|
return [
|
|
'click',
|
|
'dblclick',
|
|
'mousedown',
|
|
'mouseover',
|
|
'mouseout',
|
|
'contextmenu'
|
|
];
|
|
};
|
|
var genLabelEvents = function (leafletScope, logic, marker, name) {
|
|
var labelEvents = _getAvailableLabelEvents();
|
|
var scopeWatchName = 'markers.' + name;
|
|
for (var i = 0; i < labelEvents.length; i++) {
|
|
var eventName = labelEvents[i];
|
|
marker.label.on(eventName, genDispatchLabelEvent(leafletScope, eventName, logic, marker.label, scopeWatchName));
|
|
}
|
|
};
|
|
var genDispatchMarkerEvent = function (eventName, logic, leafletScope, marker, name, markerData) {
|
|
return function (e) {
|
|
var broadcastName = 'leafletDirectiveMarker.' + eventName;
|
|
// 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 () {
|
|
markerData.lat = marker.getLatLng().lat;
|
|
markerData.lng = marker.getLatLng().lng;
|
|
});
|
|
if (markerData.message && markerData.focus === true) {
|
|
marker.openPopup();
|
|
}
|
|
}
|
|
safeApply(leafletScope, function (scope) {
|
|
if (logic === 'emit') {
|
|
scope.$emit(broadcastName, {
|
|
markerName: name,
|
|
leafletEvent: e
|
|
});
|
|
} else {
|
|
$rootScope.$broadcast(broadcastName, {
|
|
markerName: name,
|
|
leafletEvent: e
|
|
});
|
|
}
|
|
});
|
|
};
|
|
};
|
|
var genDispatchPathEvent = function (eventName, logic, leafletScope, marker, name) {
|
|
return function (e) {
|
|
var broadcastName = 'leafletDirectivePath.' + eventName;
|
|
safeApply(leafletScope, function (scope) {
|
|
if (logic === 'emit') {
|
|
scope.$emit(broadcastName, {
|
|
pathName: name,
|
|
leafletEvent: e
|
|
});
|
|
} else {
|
|
$rootScope.$broadcast(broadcastName, {
|
|
pathName: name,
|
|
leafletEvent: e
|
|
});
|
|
}
|
|
});
|
|
};
|
|
};
|
|
var genDispatchLabelEvent = function (scope, eventName, logic, label, scope_watch_name) {
|
|
return function (e) {
|
|
// Put together broadcast name
|
|
var broadcastName = 'leafletDirectiveLabel.' + eventName;
|
|
var markerName = scope_watch_name.replace('markers.', '');
|
|
// Safely broadcast the event
|
|
safeApply(scope, function (scope) {
|
|
if (logic === 'emit') {
|
|
scope.$emit(broadcastName, {
|
|
leafletEvent: e,
|
|
label: label,
|
|
markerName: markerName
|
|
});
|
|
} else if (logic === 'broadcast') {
|
|
$rootScope.$broadcast(broadcastName, {
|
|
leafletEvent: e,
|
|
label: label,
|
|
markerName: markerName
|
|
});
|
|
}
|
|
});
|
|
};
|
|
};
|
|
var _getAvailableMarkerEvents = function () {
|
|
return [
|
|
'click',
|
|
'dblclick',
|
|
'mousedown',
|
|
'mouseover',
|
|
'mouseout',
|
|
'contextmenu',
|
|
'dragstart',
|
|
'drag',
|
|
'dragend',
|
|
'move',
|
|
'remove',
|
|
'popupopen',
|
|
'popupclose'
|
|
];
|
|
};
|
|
var _getAvailablePathEvents = function () {
|
|
return [
|
|
'click',
|
|
'dblclick',
|
|
'mousedown',
|
|
'mouseover',
|
|
'mouseout',
|
|
'contextmenu',
|
|
'add',
|
|
'remove',
|
|
'popupopen',
|
|
'popupclose'
|
|
];
|
|
};
|
|
return {
|
|
getAvailableMapEvents: function () {
|
|
return [
|
|
'click',
|
|
'dblclick',
|
|
'mousedown',
|
|
'mouseup',
|
|
'mouseover',
|
|
'mouseout',
|
|
'mousemove',
|
|
'contextmenu',
|
|
'focus',
|
|
'blur',
|
|
'preclick',
|
|
'load',
|
|
'unload',
|
|
'viewreset',
|
|
'movestart',
|
|
'move',
|
|
'moveend',
|
|
'dragstart',
|
|
'drag',
|
|
'dragend',
|
|
'zoomstart',
|
|
'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'
|
|
];
|
|
},
|
|
genDispatchMapEvent: function (scope, eventName, logic) {
|
|
return function (e) {
|
|
// Put together broadcast name
|
|
var broadcastName = 'leafletDirectiveMap.' + eventName;
|
|
// Safely broadcast the event
|
|
safeApply(scope, function (scope) {
|
|
if (logic === 'emit') {
|
|
scope.$emit(broadcastName, { leafletEvent: e });
|
|
} else if (logic === 'broadcast') {
|
|
$rootScope.$broadcast(broadcastName, { leafletEvent: e });
|
|
}
|
|
});
|
|
};
|
|
},
|
|
getAvailableMarkerEvents: _getAvailableMarkerEvents,
|
|
getAvailablePathEvents: _getAvailablePathEvents,
|
|
notifyCenterChangedToBounds: function (scope) {
|
|
scope.$broadcast('boundsChanged');
|
|
},
|
|
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);
|
|
}
|
|
},
|
|
bindMarkerEvents: function (marker, name, markerData, leafletScope) {
|
|
var markerEvents = [];
|
|
var i;
|
|
var eventName;
|
|
var logic = 'broadcast';
|
|
if (!isDefined(leafletScope.eventBroadcast)) {
|
|
// Backward compatibility, if no event-broadcast attribute, all events are broadcasted
|
|
markerEvents = _getAvailableMarkerEvents();
|
|
} else if (!isObject(leafletScope.eventBroadcast)) {
|
|
// Not a valid object
|
|
$log.error('[AngularJS - Leaflet] event-broadcast must be an object check your model.');
|
|
} else {
|
|
// We have a possible valid object
|
|
if (!isDefined(leafletScope.eventBroadcast.marker)) {
|
|
// We do not have events enable/disable do we do nothing (all enabled by default)
|
|
markerEvents = _getAvailableMarkerEvents();
|
|
} else if (!isObject(leafletScope.eventBroadcast.marker)) {
|
|
// Not a valid object
|
|
$log.warn('[AngularJS - Leaflet] event-broadcast.marker must be an object check your model.');
|
|
} else {
|
|
// We have a possible valid map object
|
|
// Event propadation logic
|
|
if (leafletScope.eventBroadcast.marker.logic !== undefined && leafletScope.eventBroadcast.marker.logic !== null) {
|
|
// We take care of possible propagation logic
|
|
if (leafletScope.eventBroadcast.marker.logic !== 'emit' && leafletScope.eventBroadcast.marker.logic !== 'broadcast') {
|
|
// This is an error
|
|
$log.warn('[AngularJS - Leaflet] Available event propagation logic are: \'emit\' or \'broadcast\'.');
|
|
} else if (leafletScope.eventBroadcast.marker.logic === 'emit') {
|
|
logic = 'emit';
|
|
}
|
|
}
|
|
// Enable / Disable
|
|
var markerEventsEnable = false, markerEventsDisable = false;
|
|
if (leafletScope.eventBroadcast.marker.enable !== undefined && leafletScope.eventBroadcast.marker.enable !== null) {
|
|
if (typeof leafletScope.eventBroadcast.marker.enable === 'object') {
|
|
markerEventsEnable = true;
|
|
}
|
|
}
|
|
if (leafletScope.eventBroadcast.marker.disable !== undefined && leafletScope.eventBroadcast.marker.disable !== null) {
|
|
if (typeof leafletScope.eventBroadcast.marker.disable === 'object') {
|
|
markerEventsDisable = true;
|
|
}
|
|
}
|
|
if (markerEventsEnable && markerEventsDisable) {
|
|
// Both are active, this is an error
|
|
$log.warn('[AngularJS - Leaflet] can not enable and disable events at the same time');
|
|
} else if (!markerEventsEnable && !markerEventsDisable) {
|
|
// Both are inactive, this is an error
|
|
$log.warn('[AngularJS - Leaflet] must enable or disable events');
|
|
} else {
|
|
// At this point the marker object is OK, lets enable or disable events
|
|
if (markerEventsEnable) {
|
|
// Enable events
|
|
for (i = 0; i < leafletScope.eventBroadcast.marker.enable.length; i++) {
|
|
eventName = leafletScope.eventBroadcast.marker.enable[i];
|
|
// Do we have already the event enabled?
|
|
if (markerEvents.indexOf(eventName) !== -1) {
|
|
// Repeated event, this is an error
|
|
$log.warn('[AngularJS - Leaflet] This event ' + eventName + ' is already enabled');
|
|
} else {
|
|
// Does the event exists?
|
|
if (_getAvailableMarkerEvents().indexOf(eventName) === -1) {
|
|
// The event does not exists, this is an error
|
|
$log.warn('[AngularJS - Leaflet] This event ' + eventName + ' does not exist');
|
|
} else {
|
|
// All ok enable the event
|
|
markerEvents.push(eventName);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Disable events
|
|
markerEvents = _getAvailableMarkerEvents();
|
|
for (i = 0; i < leafletScope.eventBroadcast.marker.disable.length; i++) {
|
|
eventName = leafletScope.eventBroadcast.marker.disable[i];
|
|
var index = markerEvents.indexOf(eventName);
|
|
if (index === -1) {
|
|
// The event does not exist
|
|
$log.warn('[AngularJS - Leaflet] This event ' + eventName + ' does not exist or has been already disabled');
|
|
} else {
|
|
markerEvents.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < markerEvents.length; i++) {
|
|
eventName = markerEvents[i];
|
|
marker.on(eventName, genDispatchMarkerEvent(eventName, logic, leafletScope, marker, name, markerData));
|
|
}
|
|
if (Helpers.LabelPlugin.isLoaded() && isDefined(marker.label)) {
|
|
genLabelEvents(leafletScope, logic, marker, name);
|
|
}
|
|
},
|
|
bindPathEvents: function (path, name, pathData, leafletScope) {
|
|
var pathEvents = [];
|
|
var i;
|
|
var eventName;
|
|
var logic = 'broadcast';
|
|
window.lls = leafletScope;
|
|
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('[AngularJS - Leaflet] 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('[AngularJS - Leaflet] 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('[AngularJS - Leaflet] 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('[AngularJS - Leaflet] can not enable and disable events at the same time');
|
|
} else if (!pathEventsEnable && !pathEventsDisable) {
|
|
// Both are inactive, this is an error
|
|
$log.warn('[AngularJS - Leaflet] 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('[AngularJS - Leaflet] 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('[AngularJS - Leaflet] 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('[AngularJS - Leaflet] 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];
|
|
path.on(eventName, genDispatchPathEvent(eventName, logic, leafletScope, pathEvents, name));
|
|
}
|
|
if (Helpers.LabelPlugin.isLoaded() && isDefined(path.label)) {
|
|
genLabelEvents(leafletScope, logic, path, name);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletLayerHelpers', [
|
|
'$rootScope',
|
|
'$log',
|
|
'leafletHelpers',
|
|
function ($rootScope, $log, leafletHelpers) {
|
|
var Helpers = leafletHelpers, isString = leafletHelpers.isString, isObject = leafletHelpers.isObject, isDefined = leafletHelpers.isDefined;
|
|
var layerTypes = {
|
|
xyz: {
|
|
mustHaveUrl: true,
|
|
createLayer: function (params) {
|
|
return L.tileLayer(params.url, params.options);
|
|
}
|
|
},
|
|
geoJSON: {
|
|
mustHaveUrl: true,
|
|
createLayer: function (params) {
|
|
if (!Helpers.GeoJSONPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
return new L.TileLayer.GeoJSON(params.url, params.pluginOptions, params.options);
|
|
}
|
|
},
|
|
wms: {
|
|
mustHaveUrl: true,
|
|
createLayer: function (params) {
|
|
return L.tileLayer.wms(params.url, params.options);
|
|
}
|
|
},
|
|
wmts: {
|
|
mustHaveUrl: true,
|
|
createLayer: function (params) {
|
|
return L.tileLayer.wmts(params.url, params.options);
|
|
}
|
|
},
|
|
wfs: {
|
|
mustHaveUrl: true,
|
|
mustHaveLayer: true,
|
|
createLayer: function (params) {
|
|
if (!Helpers.WFSLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
var options = angular.copy(params.options);
|
|
if (options.crs && 'string' === typeof options.crs) {
|
|
/*jshint -W061 */
|
|
options.crs = eval(options.crs);
|
|
}
|
|
return new L.GeoJSON.WFS(params.url, params.layer, options);
|
|
}
|
|
},
|
|
group: {
|
|
mustHaveUrl: false,
|
|
createLayer: function () {
|
|
return L.layerGroup();
|
|
}
|
|
},
|
|
google: {
|
|
mustHaveUrl: false,
|
|
createLayer: function (params) {
|
|
var type = params.type || 'SATELLITE';
|
|
if (!Helpers.GoogleLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
return new L.Google(type, params.options);
|
|
}
|
|
},
|
|
china: {
|
|
mustHaveUrl: false,
|
|
createLayer: function (params) {
|
|
var type = params.type || '';
|
|
if (!Helpers.ChinaLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
return L.tileLayer.chinaProvider(type, params.options);
|
|
}
|
|
},
|
|
ags: {
|
|
mustHaveUrl: true,
|
|
createLayer: function (params) {
|
|
if (!Helpers.AGSLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
var options = angular.copy(params.options);
|
|
angular.extend(options, { url: params.url });
|
|
var layer = new lvector.AGS(options);
|
|
layer.onAdd = function (map) {
|
|
this.setMap(map);
|
|
};
|
|
layer.onRemove = function () {
|
|
this.setMap(null);
|
|
};
|
|
return layer;
|
|
}
|
|
},
|
|
dynamic: {
|
|
mustHaveUrl: true,
|
|
createLayer: function (params) {
|
|
if (!Helpers.DynamicMapLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
return L.esri.dynamicMapLayer(params.url, params.options);
|
|
}
|
|
},
|
|
markercluster: {
|
|
mustHaveUrl: false,
|
|
createLayer: function (params) {
|
|
if (!Helpers.MarkerClusterPlugin.isLoaded()) {
|
|
$log.error('[AngularJS - Leaflet] The markercluster plugin is not loaded.');
|
|
return;
|
|
}
|
|
return new L.MarkerClusterGroup(params.options);
|
|
}
|
|
},
|
|
bing: {
|
|
mustHaveUrl: false,
|
|
createLayer: function (params) {
|
|
if (!Helpers.BingLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
return new L.BingLayer(params.key, params.options);
|
|
}
|
|
},
|
|
heatmap: {
|
|
mustHaveUrl: false,
|
|
mustHaveData: true,
|
|
createLayer: function (params) {
|
|
if (!Helpers.HeatMapLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
var layer = new L.TileLayer.WebGLHeatMap(params.options);
|
|
if (isDefined(params.data)) {
|
|
layer.setData(params.data);
|
|
}
|
|
return layer;
|
|
}
|
|
},
|
|
yandex: {
|
|
mustHaveUrl: false,
|
|
createLayer: function (params) {
|
|
var type = params.type || 'map';
|
|
if (!Helpers.YandexLayerPlugin.isLoaded()) {
|
|
return;
|
|
}
|
|
return new L.Yandex(type, params.options);
|
|
}
|
|
},
|
|
imageOverlay: {
|
|
mustHaveUrl: true,
|
|
mustHaveBounds: true,
|
|
createLayer: function (params) {
|
|
return L.imageOverlay(params.url, params.bounds, params.options);
|
|
}
|
|
}
|
|
};
|
|
function isValidLayerType(layerDefinition) {
|
|
// Check if the baselayer has a valid type
|
|
if (!isString(layerDefinition.type)) {
|
|
return false;
|
|
}
|
|
if (Object.keys(layerTypes).indexOf(layerDefinition.type) === -1) {
|
|
$log.error('[AngularJS - Leaflet] A layer must have a valid type: ' + Object.keys(layerTypes));
|
|
return false;
|
|
}
|
|
// Check if the layer must have an URL
|
|
if (layerTypes[layerDefinition.type].mustHaveUrl && !isString(layerDefinition.url)) {
|
|
$log.error('[AngularJS - Leaflet] A base layer must have an url');
|
|
return false;
|
|
}
|
|
if (layerTypes[layerDefinition.type].mustHaveData && !isDefined(layerDefinition.data)) {
|
|
$log.error('[AngularJS - Leaflet] The base layer must have a "data" array attribute');
|
|
return false;
|
|
}
|
|
if (layerTypes[layerDefinition.type].mustHaveLayer && !isDefined(layerDefinition.layer)) {
|
|
$log.error('[AngularJS - Leaflet] The type of layer ' + layerDefinition.type + ' must have an layer defined');
|
|
return false;
|
|
}
|
|
if (layerTypes[layerDefinition.type].mustHaveBounds && !isDefined(layerDefinition.bounds)) {
|
|
$log.error('[AngularJS - Leaflet] The type of layer ' + layerDefinition.type + ' must have bounds defined');
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return {
|
|
createLayer: function (layerDefinition) {
|
|
if (!isValidLayerType(layerDefinition)) {
|
|
return;
|
|
}
|
|
if (!isString(layerDefinition.name)) {
|
|
$log.error('[AngularJS - Leaflet] A base layer must have a name');
|
|
return;
|
|
}
|
|
if (!isObject(layerDefinition.layerParams)) {
|
|
layerDefinition.layerParams = {};
|
|
}
|
|
if (!isObject(layerDefinition.layerOptions)) {
|
|
layerDefinition.layerOptions = {};
|
|
}
|
|
// Mix the layer specific parameters with the general Leaflet options. Although this is an overhead
|
|
// the definition of a base layers is more 'clean' if the two types of parameters are differentiated
|
|
for (var attrname in layerDefinition.layerParams) {
|
|
layerDefinition.layerOptions[attrname] = layerDefinition.layerParams[attrname];
|
|
}
|
|
var params = {
|
|
url: layerDefinition.url,
|
|
data: layerDefinition.data,
|
|
options: layerDefinition.layerOptions,
|
|
layer: layerDefinition.layer,
|
|
type: layerDefinition.layerType,
|
|
bounds: layerDefinition.bounds,
|
|
key: layerDefinition.key,
|
|
pluginOptions: layerDefinition.pluginOptions
|
|
};
|
|
//TODO Add $watch to the layer properties
|
|
return layerTypes[layerDefinition.type].createLayer(params);
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletControlHelpers', [
|
|
'$rootScope',
|
|
'$log',
|
|
'leafletHelpers',
|
|
'leafletMapDefaults',
|
|
function ($rootScope, $log, leafletHelpers, leafletMapDefaults) {
|
|
var isObject = leafletHelpers.isObject, isDefined = leafletHelpers.isDefined;
|
|
var _layersControl;
|
|
var _controlLayersMustBeVisible = function (baselayers, overlays) {
|
|
var numberOfLayers = 0;
|
|
if (isObject(baselayers)) {
|
|
numberOfLayers += Object.keys(baselayers).length;
|
|
}
|
|
if (isObject(overlays)) {
|
|
numberOfLayers += Object.keys(overlays).length;
|
|
}
|
|
return numberOfLayers > 1;
|
|
};
|
|
var _createLayersControl = function (mapId) {
|
|
var defaults = leafletMapDefaults.getDefaults(mapId);
|
|
var controlOptions = {
|
|
collapsed: defaults.controls.layers.collapsed,
|
|
position: defaults.controls.layers.position
|
|
};
|
|
var control;
|
|
if (defaults.controls.layers && isDefined(defaults.controls.layers.control)) {
|
|
control = defaults.controls.layers.control.apply(this, [
|
|
[],
|
|
[],
|
|
controlOptions
|
|
]);
|
|
} else {
|
|
control = new L.control.layers([], [], controlOptions);
|
|
}
|
|
return control;
|
|
};
|
|
return {
|
|
layersControlMustBeVisible: _controlLayersMustBeVisible,
|
|
updateLayersControl: function (map, mapId, loaded, baselayers, overlays, leafletLayers) {
|
|
var i;
|
|
var mustBeLoaded = _controlLayersMustBeVisible(baselayers, overlays);
|
|
if (isDefined(_layersControl) && loaded) {
|
|
for (i in leafletLayers.baselayers) {
|
|
_layersControl.removeLayer(leafletLayers.baselayers[i]);
|
|
}
|
|
for (i in leafletLayers.overlays) {
|
|
_layersControl.removeLayer(leafletLayers.overlays[i]);
|
|
}
|
|
_layersControl.removeFrom(map);
|
|
}
|
|
if (mustBeLoaded) {
|
|
_layersControl = _createLayersControl(mapId);
|
|
for (i in baselayers) {
|
|
if (isDefined(leafletLayers.baselayers[i])) {
|
|
_layersControl.addBaseLayer(leafletLayers.baselayers[i], baselayers[i].name);
|
|
}
|
|
}
|
|
for (i in overlays) {
|
|
if (isDefined(leafletLayers.overlays[i])) {
|
|
_layersControl.addOverlay(leafletLayers.overlays[i], overlays[i].name);
|
|
}
|
|
}
|
|
_layersControl.addTo(map);
|
|
}
|
|
return mustBeLoaded;
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletLegendHelpers', function () {
|
|
var _updateArcGISLegend = function (div, legendData) {
|
|
div.innerHTML = '';
|
|
if (legendData.error) {
|
|
div.innerHTML += '<div class="info-title alert alert-danger">' + legendData.error.message + '</div>';
|
|
} else {
|
|
for (var i = 0; i < legendData.layers.length; i++) {
|
|
var layer = legendData.layers[i];
|
|
div.innerHTML += '<div class="info-title">' + layer.layerName + '</div>';
|
|
for (var j = 0; j < layer.legend.length; j++) {
|
|
var leg = layer.legend[j];
|
|
div.innerHTML += '<div class="inline"><img src="data:' + leg.contentType + ';base64,' + leg.imageData + '" /></div>' + '<div class="info-label">' + leg.label + '</div>';
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var _getOnAddArcGISLegend = function (legendData, legendClass) {
|
|
return function () {
|
|
var div = L.DomUtil.create('div', legendClass);
|
|
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);
|
|
}
|
|
_updateArcGISLegend(div, legendData);
|
|
return div;
|
|
};
|
|
};
|
|
var _getOnAddArrayLegend = function (legend, legendClass) {
|
|
return function () {
|
|
var div = L.DomUtil.create('div', legendClass);
|
|
for (var i = 0; i < legend.colors.length; i++) {
|
|
div.innerHTML += '<div class="outline"><i style="background:' + legend.colors[i] + '"></i></div>' + '<div class="info-label">' + legend.labels[i] + '</div>';
|
|
}
|
|
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 {
|
|
getOnAddArcGISLegend: _getOnAddArcGISLegend,
|
|
getOnAddArrayLegend: _getOnAddArrayLegend,
|
|
updateArcGISLegend: _updateArcGISLegend
|
|
};
|
|
});
|
|
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;
|
|
function _convertToLeafletLatLngs(latlngs) {
|
|
return latlngs.filter(function (latlng) {
|
|
return isValidPoint(latlng);
|
|
}).map(function (latlng) {
|
|
return new L.LatLng(latlng.lat, latlng.lng);
|
|
});
|
|
}
|
|
function _convertToLeafletLatLng(latlng) {
|
|
return new L.LatLng(latlng.lat, latlng.lng);
|
|
}
|
|
function _convertToLeafletMultiLatLngs(paths) {
|
|
return paths.map(function (latlngs) {
|
|
return _convertToLeafletLatLngs(latlngs);
|
|
});
|
|
}
|
|
function _getOptions(path, defaults) {
|
|
var availableOptions = [
|
|
'stroke',
|
|
'weight',
|
|
'color',
|
|
'opacity',
|
|
'fill',
|
|
'fillColor',
|
|
'fillOpacity',
|
|
'dashArray',
|
|
'lineCap',
|
|
'lineJoin',
|
|
'clickable',
|
|
'pointerEvents',
|
|
'className',
|
|
'smoothFactor',
|
|
'noClip'
|
|
];
|
|
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) {
|
|
if (isDefined(data.weight)) {
|
|
path.setStyle({ weight: data.weight });
|
|
}
|
|
if (isDefined(data.color)) {
|
|
path.setStyle({ color: data.color });
|
|
}
|
|
if (isDefined(data.opacity)) {
|
|
path.setStyle({ opacity: data.opacity });
|
|
}
|
|
};
|
|
var _isValidPolyline = function (latlngs) {
|
|
if (!isArray(latlngs)) {
|
|
return false;
|
|
}
|
|
for (var i in latlngs) {
|
|
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').factory('leafletBoundsHelpers', [
|
|
'$log',
|
|
'leafletHelpers',
|
|
function ($log, leafletHelpers) {
|
|
var isArray = leafletHelpers.isArray, isNumber = leafletHelpers.isNumber;
|
|
function _isValidBounds(bounds) {
|
|
return angular.isDefined(bounds) && angular.isDefined(bounds.southWest) && angular.isDefined(bounds.northEast) && angular.isNumber(bounds.southWest.lat) && angular.isNumber(bounds.southWest.lng) && angular.isNumber(bounds.northEast.lat) && angular.isNumber(bounds.northEast.lng);
|
|
}
|
|
return {
|
|
createLeafletBounds: function (bounds) {
|
|
if (_isValidBounds(bounds)) {
|
|
return L.latLngBounds([
|
|
bounds.southWest.lat,
|
|
bounds.southWest.lng
|
|
], [
|
|
bounds.northEast.lat,
|
|
bounds.northEast.lng
|
|
]);
|
|
}
|
|
},
|
|
isValidBounds: _isValidBounds,
|
|
createBoundsFromArray: function (boundsArray) {
|
|
if (!(isArray(boundsArray) && boundsArray.length === 2 && isArray(boundsArray[0]) && isArray(boundsArray[1]) && boundsArray[0].length === 2 && boundsArray[1].length === 2 && isNumber(boundsArray[0][0]) && isNumber(boundsArray[0][1]) && isNumber(boundsArray[1][0]) && isNumber(boundsArray[1][1]))) {
|
|
$log.error('[AngularJS - Leaflet] The bounds array is not valid.');
|
|
return;
|
|
}
|
|
return {
|
|
northEast: {
|
|
lat: boundsArray[0][0],
|
|
lng: boundsArray[0][1]
|
|
},
|
|
southWest: {
|
|
lat: boundsArray[1][0],
|
|
lng: boundsArray[1][1]
|
|
}
|
|
};
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletMarkersHelpers', [
|
|
'$rootScope',
|
|
'leafletHelpers',
|
|
'$log',
|
|
function ($rootScope, leafletHelpers, $log) {
|
|
var isDefined = leafletHelpers.isDefined, MarkerClusterPlugin = leafletHelpers.MarkerClusterPlugin, AwesomeMarkersPlugin = leafletHelpers.AwesomeMarkersPlugin, safeApply = leafletHelpers.safeApply, Helpers = leafletHelpers, isString = leafletHelpers.isString, isNumber = leafletHelpers.isNumber, isObject = leafletHelpers.isObject, groups = {};
|
|
var createLeafletIcon = function (iconData) {
|
|
if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'awesomeMarker') {
|
|
if (!AwesomeMarkersPlugin.isLoaded()) {
|
|
$log.error('[AngularJS - Leaflet] The AwesomeMarkers Plugin is not loaded.');
|
|
}
|
|
return new L.AwesomeMarkers.icon(iconData);
|
|
}
|
|
if (isDefined(iconData) && isDefined(iconData.type) && iconData.type === 'div') {
|
|
return new L.divIcon(iconData);
|
|
}
|
|
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)) {
|
|
return new L.Icon.Default({
|
|
iconUrl: base64icon,
|
|
shadowUrl: base64shadow
|
|
});
|
|
}
|
|
if (!isDefined(iconData.iconUrl)) {
|
|
iconData.iconUrl = base64icon;
|
|
iconData.shadowUrl = base64shadow;
|
|
}
|
|
return new L.Icon.Default(iconData);
|
|
};
|
|
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) {
|
|
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);
|
|
}
|
|
};
|
|
return {
|
|
deleteMarker: _deleteMarker,
|
|
createMarker: function (markerData) {
|
|
if (!isDefined(markerData)) {
|
|
$log.error('[AngularJS - Leaflet] The marker definition is not valid.');
|
|
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
|
|
};
|
|
return new L.marker(markerData, markerOptions);
|
|
},
|
|
addMarkerToGroup: function (marker, groupName, map) {
|
|
if (!isString(groupName)) {
|
|
$log.error('[AngularJS - Leaflet] The marker group you have specified is invalid.');
|
|
return;
|
|
}
|
|
if (!MarkerClusterPlugin.isLoaded()) {
|
|
$log.error('[AngularJS - Leaflet] The MarkerCluster plugin is not loaded.');
|
|
return;
|
|
}
|
|
if (!isDefined(groups[groupName])) {
|
|
groups[groupName] = new L.MarkerClusterGroup();
|
|
map.addLayer(groups[groupName]);
|
|
}
|
|
groups[groupName].addLayer(marker);
|
|
},
|
|
listenMarkerEvents: function (marker, markerData, leafletScope) {
|
|
marker.on('popupopen', function () {
|
|
safeApply(leafletScope, function () {
|
|
markerData.focus = true;
|
|
});
|
|
});
|
|
marker.on('popupclose', function () {
|
|
safeApply(leafletScope, function () {
|
|
markerData.focus = false;
|
|
});
|
|
});
|
|
},
|
|
addMarkerWatcher: function (marker, name, leafletScope, layers, map) {
|
|
var clearWatch = leafletScope.$watch('markers.' + name, function (markerData, oldMarkerData) {
|
|
if (!isDefined(markerData)) {
|
|
_deleteMarker(marker, map, layers);
|
|
clearWatch();
|
|
return;
|
|
}
|
|
if (!isDefined(oldMarkerData)) {
|
|
return;
|
|
}
|
|
// Update the lat-lng property (always present in marker properties)
|
|
if (!(isNumber(markerData.lat) && isNumber(markerData.lng))) {
|
|
$log.warn('There are problems with lat-lng data, please verify your marker model');
|
|
_deleteMarker(marker, map, layers);
|
|
return;
|
|
}
|
|
// 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 (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('[AngularJS - Leaflet] 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)) {
|
|
$log.error('[AngularJS - Leaflet] A marker can only be added to a layer of type "group"');
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
// Update the Popup message property
|
|
if (!isString(markerData.message) && isString(oldMarkerData.message)) {
|
|
marker.closePopup();
|
|
marker.unbindPopup();
|
|
}
|
|
// Update the label content
|
|
if (Helpers.LabelPlugin.isLoaded() && isDefined(markerData.label) && isDefined(markerData.label.message) && !angular.equals(markerData.label.message, oldMarkerData.label.message)) {
|
|
marker.updateLabelContent(markerData.label.message);
|
|
}
|
|
// 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);
|
|
if (markerData.focus === true) {
|
|
// If the focus is set, we must open the popup, because we do not know if it was opened before
|
|
marker.openPopup();
|
|
}
|
|
}
|
|
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 && oldMarkerData.focus !== true) {
|
|
marker.openPopup();
|
|
updatedFocus = true;
|
|
}
|
|
if (oldMarkerData.focus === true && markerData.focus === true) {
|
|
// Reopen the popup when focus is still true
|
|
marker.openPopup();
|
|
updatedFocus = true;
|
|
}
|
|
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 (markerLatLng.lat !== markerData.lat || markerLatLng.lng !== markerData.lng) {
|
|
marker.setLatLng([
|
|
markerData.lat,
|
|
markerData.lng
|
|
]);
|
|
}
|
|
}, true);
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
angular.module('leaflet-directive').factory('leafletHelpers', [
|
|
'$q',
|
|
'$log',
|
|
function ($q, $log) {
|
|
function _obtainEffectiveMapId(d, mapId) {
|
|
var id, i;
|
|
if (!angular.isDefined(mapId)) {
|
|
if (Object.keys(d).length === 1) {
|
|
for (i in d) {
|
|
if (d.hasOwnProperty(i)) {
|
|
id = i;
|
|
}
|
|
}
|
|
} else if (Object.keys(d).length === 0) {
|
|
id = 'main';
|
|
} else {
|
|
$log.error('[AngularJS - Leaflet] - You have more than 1 map on the DOM, you must provide the map ID to the leafletData.getXXX call');
|
|
}
|
|
} else {
|
|
id = mapId;
|
|
}
|
|
return id;
|
|
}
|
|
function _getUnresolvedDefer(d, mapId) {
|
|
var id = _obtainEffectiveMapId(d, mapId), defer;
|
|
if (!angular.isDefined(d[id]) || d[id].resolvedDefer === true) {
|
|
defer = $q.defer();
|
|
d[id] = {
|
|
defer: defer,
|
|
resolvedDefer: false
|
|
};
|
|
} else {
|
|
defer = d[id].defer;
|
|
}
|
|
return defer;
|
|
}
|
|
return {
|
|
isEmpty: function (value) {
|
|
return Object.keys(value).length === 0;
|
|
},
|
|
isUndefinedOrEmpty: function (value) {
|
|
return angular.isUndefined(value) || value === null || Object.keys(value).length === 0;
|
|
},
|
|
isDefined: function (value) {
|
|
return angular.isDefined(value) && value !== null;
|
|
},
|
|
isNumber: function (value) {
|
|
return angular.isNumber(value);
|
|
},
|
|
isString: function (value) {
|
|
return angular.isString(value);
|
|
},
|
|
isArray: function (value) {
|
|
return angular.isArray(value);
|
|
},
|
|
isObject: function (value) {
|
|
return angular.isObject(value);
|
|
},
|
|
isFunction: function (value) {
|
|
return angular.isFunction(value);
|
|
},
|
|
equals: function (o1, o2) {
|
|
return angular.equals(o1, o2);
|
|
},
|
|
isValidCenter: function (center) {
|
|
return angular.isDefined(center) && angular.isNumber(center.lat) && angular.isNumber(center.lng) && angular.isNumber(center.zoom);
|
|
},
|
|
isValidPoint: function (point) {
|
|
return angular.isDefined(point) && angular.isNumber(point.lat) && angular.isNumber(point.lng);
|
|
},
|
|
isSameCenterOnMap: function (centerModel, map) {
|
|
var mapCenter = map.getCenter();
|
|
var zoom = map.getZoom();
|
|
if (mapCenter.lat === centerModel.lat && mapCenter.lng === centerModel.lng && zoom === centerModel.zoom) {
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
safeApply: function ($scope, fn) {
|
|
var phase = $scope.$root.$$phase;
|
|
if (phase === '$apply' || phase === '$digest') {
|
|
$scope.$eval(fn);
|
|
} else {
|
|
$scope.$apply(fn);
|
|
}
|
|
},
|
|
obtainEffectiveMapId: _obtainEffectiveMapId,
|
|
getDefer: function (d, mapId) {
|
|
var id = _obtainEffectiveMapId(d, mapId), defer;
|
|
if (!angular.isDefined(d[id]) || d[id].resolvedDefer === false) {
|
|
defer = _getUnresolvedDefer(d, mapId);
|
|
} else {
|
|
defer = d[id].defer;
|
|
}
|
|
return defer;
|
|
},
|
|
getUnresolvedDefer: _getUnresolvedDefer,
|
|
setResolvedDefer: function (d, mapId) {
|
|
var id = _obtainEffectiveMapId(d, mapId);
|
|
d[id].resolvedDefer = true;
|
|
},
|
|
AwesomeMarkersPlugin: {
|
|
isLoaded: function () {
|
|
if (angular.isDefined(L.AwesomeMarkers) && angular.isDefined(L.AwesomeMarkers.Icon)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
is: function (icon) {
|
|
if (this.isLoaded()) {
|
|
return icon instanceof L.AwesomeMarkers.Icon;
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
equal: function (iconA, iconB) {
|
|
if (!this.isLoaded()) {
|
|
return false;
|
|
}
|
|
if (this.is(iconA)) {
|
|
return angular.equals(iconA, iconB);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
LabelPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.Label);
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.MarkerClusterGroup;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
MarkerClusterPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.MarkerClusterGroup);
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.MarkerClusterGroup;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
GoogleLayerPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.Google);
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.Google;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
ChinaLayerPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.tileLayer.chinaProvider);
|
|
}
|
|
},
|
|
HeatMapLayerPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.TileLayer.WebGLHeatMap);
|
|
}
|
|
},
|
|
BingLayerPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.BingLayer);
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.BingLayer;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
WFSLayerPlugin: {
|
|
isLoaded: function () {
|
|
return L.GeoJSON.WFS !== undefined;
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.GeoJSON.WFS;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
AGSLayerPlugin: {
|
|
isLoaded: function () {
|
|
return lvector !== undefined && lvector.AGS !== undefined;
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof lvector.AGS;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
YandexLayerPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.Yandex);
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.Yandex;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
DynamicMapLayerPlugin: {
|
|
isLoaded: function () {
|
|
return L.esri !== undefined && L.esri.dynamicMapLayer !== undefined;
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.esri.dynamicMapLayer;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
GeoJSONPlugin: {
|
|
isLoaded: function () {
|
|
return angular.isDefined(L.TileLayer.GeoJSON);
|
|
},
|
|
is: function (layer) {
|
|
if (this.isLoaded()) {
|
|
return layer instanceof L.TileLayer.GeoJSON;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
Leaflet: {
|
|
DivIcon: {
|
|
is: function (icon) {
|
|
return icon instanceof L.DivIcon;
|
|
},
|
|
equal: function (iconA, iconB) {
|
|
if (this.is(iconA)) {
|
|
return angular.equals(iconA, iconB);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
Icon: {
|
|
is: function (icon) {
|
|
return icon instanceof L.Icon;
|
|
},
|
|
equal: function (iconA, iconB) {
|
|
if (this.is(iconA)) {
|
|
return angular.equals(iconA, iconB);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
]);
|
|
}()); |