1 /**

     2  * @class L.EditToolbar.Delete

     3  * @aka EditToolbar.Delete

     4  */

     5 L.EditToolbar.Delete = L.Handler.extend({

     6 	statics: {

     7 		TYPE: 'remove' // not delete as delete is reserved in js

     8 	},

     9 

    10 	// @method intialize(): void

    11 	initialize: function (map, options) {

    12 		L.Handler.prototype.initialize.call(this, map);

    13 

    14 		L.Util.setOptions(this, options);

    15 

    16 		// Store the selectable layer group for ease of access

    17 		this._deletableLayers = this.options.featureGroup;

    18 

    19 		if (!(this._deletableLayers instanceof L.FeatureGroup)) {

    20 			throw new Error('options.featureGroup must be a L.FeatureGroup');

    21 		}

    22 

    23 		// Save the type so super can fire, need to do this as cannot do this.TYPE :(

    24 		this.type = L.EditToolbar.Delete.TYPE;

    25 

    26 		var version = L.version.split('.');

    27 		//If Version is >= 1.2.0

    28 		if (parseInt(version[0], 10) === 1 && parseInt(version[1], 10) >= 2) {

    29 			L.EditToolbar.Delete.include(L.Evented.prototype);

    30 		} else {

    31 			L.EditToolbar.Delete.include(L.Mixin.Events);

    32 		}

    33 

    34 	},

    35 

    36 	// @method enable(): void

    37 	// Enable the delete toolbar

    38 	enable: function () {

    39 		if (this._enabled || !this._hasAvailableLayers()) {

    40 			return;

    41 		}

    42 		this.fire('enabled', {handler: this.type});

    43 

    44 		this._map.fire(L.Draw.Event.DELETESTART, {handler: this.type});

    45 

    46 		L.Handler.prototype.enable.call(this);

    47 

    48 		this._deletableLayers

    49 			.on('layeradd', this._enableLayerDelete, this)

    50 			.on('layerremove', this._disableLayerDelete, this);

    51 	},

    52 

    53 	// @method disable(): void

    54 	// Disable the delete toolbar

    55 	disable: function () {

    56 		if (!this._enabled) {

    57 			return;

    58 		}

    59 

    60 		this._deletableLayers

    61 			.off('layeradd', this._enableLayerDelete, this)

    62 			.off('layerremove', this._disableLayerDelete, this);

    63 

    64 		L.Handler.prototype.disable.call(this);

    65 

    66 		this._map.fire(L.Draw.Event.DELETESTOP, {handler: this.type});

    67 

    68 		this.fire('disabled', {handler: this.type});

    69 	},

    70 

    71 	// @method addHooks(): void

    72 	// Add listener hooks to this handler

    73 	addHooks: function () {

    74 		var map = this._map;

    75 

    76 		if (map) {

    77 			map.getContainer().focus();

    78 

    79 			this._deletableLayers.eachLayer(this._enableLayerDelete, this);

    80 			this._deletedLayers = new L.LayerGroup();

    81 

    82 			this._tooltip = new L.Draw.Tooltip(this._map);

    83 			this._tooltip.updateContent({text: L.drawLocal.edit.handlers.remove.tooltip.text});

    84 

    85 			this._map.on('mousemove', this._onMouseMove, this);

    86 		}

    87 	},

    88 

    89 	// @method removeHooks(): void

    90 	// Remove listener hooks from this handler

    91 	removeHooks: function () {

    92 		if (this._map) {

    93 			this._deletableLayers.eachLayer(this._disableLayerDelete, this);

    94 			this._deletedLayers = null;

    95 

    96 			this._tooltip.dispose();

    97 			this._tooltip = null;

    98 

    99 			this._map.off('mousemove', this._onMouseMove, this);

   100 		}

   101 	},

   102 

   103 	// @method revertLayers(): void

   104 	// Revert the deleted layers back to their prior state.

   105 	revertLayers: function () {

   106 		// Iterate of the deleted layers and add them back into the featureGroup

   107 		this._deletedLayers.eachLayer(function (layer) {

   108 			this._deletableLayers.addLayer(layer);

   109 			layer.fire('revert-deleted', {layer: layer});

   110 		}, this);

   111 	},

   112 

   113 	// @method save(): void

   114 	// Save deleted layers

   115 	save: function () {

   116 		this._map.fire(L.Draw.Event.DELETED, {layers: this._deletedLayers});

   117 	},

   118 

   119 	// @method removeAllLayers(): void

   120 	// Remove all delateable layers

   121 	removeAllLayers: function () {

   122 		// Iterate of the delateable layers and add remove them

   123 		this._deletableLayers.eachLayer(function (layer) {

   124 			this._removeLayer({layer: layer});

   125 		}, this);

   126 		this.save();

   127 	},

   128 

   129 	_enableLayerDelete: function (e) {

   130 		var layer = e.layer || e.target || e;

   131 

   132 		layer.on('click', this._removeLayer, this);

   133 	},

   134 

   135 	_disableLayerDelete: function (e) {

   136 		var layer = e.layer || e.target || e;

   137 

   138 		layer.off('click', this._removeLayer, this);

   139 

   140 		// Remove from the deleted layers so we can't accidentally revert if the user presses cancel

   141 		this._deletedLayers.removeLayer(layer);

   142 	},

   143 

   144 	_removeLayer: function (e) {

   145 		var layer = e.layer || e.target || e;

   146 

   147 		this._deletableLayers.removeLayer(layer);

   148 

   149 		this._deletedLayers.addLayer(layer);

   150 

   151 		layer.fire('deleted');

   152 	},

   153 

   154 	_onMouseMove: function (e) {

   155 		this._tooltip.updatePosition(e.latlng);

   156 	},

   157 

   158 	_hasAvailableLayers: function () {

   159 		return this._deletableLayers.getLayers().length !== 0;

   160 	}

   161 });