Changeset 108378 in spip-zone


Ignore:
Timestamp:
Jan 6, 2018, 8:17:01 PM (18 months ago)
Author:
brunobergot@…
Message:

version 1.11.1 : suivre gis, maj de la lib pour compat leaflet 1.2.0

+ utiliser le sprite du trunk car il n'est pas à jour dans le tag 0.4.11 cf https://github.com/Leaflet/Leaflet.draw/issues/814

Location:
_plugins_/gis_geometries
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/gis_geometries/lib/leaflet-draw/images/spritesheet.svg

    r100142 r108378  
    11<?xml version="1.0" encoding="UTF-8" standalone="no"?>
    2 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 540 60" height="60" width="540">
    3     <g id="enabled" fill="#464646">
    4         <g id="polyline">
    5             <path d="M18 36v6h6v-6h-6zm4 4h-2v-2h2v2z"/>
    6             <path d="M36 18v6h6v-6h-6zm4 4h-2v-2h2v2z"/>
    7             <path d="M23.142 39.145l-2.285-2.29 16-15.998 2.285 2.285z"/>
    8         </g>
    9         <path id="polygon" d="M100 24.565l-2.096 14.83L83.07 42 76 28.773 86.463 18z"/>
    10         <path id="rectangle" d="M140 20h20v20h-20z"/>
    11         <path id="circle" d="M221 30c0 6.078-4.926 11-11 11s-11-4.922-11-11c0-6.074 4.926-11 11-11s11 4.926 11 11z"/>
    12         <path id="marker" d="M270,19c-4.971,0-9,4.029-9,9c0,4.971,5.001,12,9,14c4.001-2,9-9.029,9-14C279,23.029,274.971,19,270,19z M270,31.5c-2.484,0-4.5-2.014-4.5-4.5c0-2.484,2.016-4.5,4.5-4.5c2.485,0,4.5,2.016,4.5,4.5C274.5,29.486,272.485,31.5,270,31.5z"/>
    13         <g id="edit">
    14             <path d="M337,30.156v0.407v5.604c0,1.658-1.344,3-3,3h-10c-1.655,0-3-1.342-3-3v-10c0-1.657,1.345-3,3-3h6.345 l3.19-3.17H324c-3.313,0-6,2.687-6,6v10c0,3.313,2.687,6,6,6h10c3.314,0,6-2.687,6-6v-8.809L337,30.156"/>
    15             <path d="M338.72 24.637l-8.892 8.892H327V30.7l8.89-8.89z"/>
    16             <path d="M338.697 17.826h4v4h-4z" transform="rotate(-134.99 340.703 19.817)"/>
    17         </g>
    18         <g id="remove">
    19             <path d="M381 42h18V24h-18v18zm14-16h2v14h-2V26zm-4 0h2v14h-2V26zm-4 0h2v14h-2V26zm-4 0h2v14h-2V26z"/>
    20             <path d="M395 20v-4h-10v4h-6v2h22v-2h-6zm-2 0h-6v-2h6v2z"/>
    21         </g>
     2<svg
     3   xmlns:dc="http://purl.org/dc/elements/1.1/"
     4   xmlns:cc="http://creativecommons.org/ns#"
     5   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     6   xmlns:svg="http://www.w3.org/2000/svg"
     7   xmlns="http://www.w3.org/2000/svg"
     8   xmlns:xlink="http://www.w3.org/1999/xlink"
     9   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
     10   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
     11   viewBox="0 0 600 60"
     12   height="60"
     13   width="600"
     14   id="svg4225"
     15   version="1.1"
     16   inkscape:version="0.91 r13725"
     17   sodipodi:docname="spritesheet.svg"
     18   inkscape:export-filename="/home/fpuga/development/upstream/icarto.Leaflet.draw/src/images/spritesheet-2x.png"
     19   inkscape:export-xdpi="90"
     20   inkscape:export-ydpi="90">
     21  <metadata
     22     id="metadata4258">
     23    <rdf:RDF>
     24      <cc:Work
     25         rdf:about="">
     26        <dc:format>image/svg+xml</dc:format>
     27        <dc:type
     28           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
     29        <dc:title />
     30      </cc:Work>
     31    </rdf:RDF>
     32  </metadata>
     33  <defs
     34     id="defs4256" />
     35  <sodipodi:namedview
     36     pagecolor="#ffffff"
     37     bordercolor="#666666"
     38     borderopacity="1"
     39     objecttolerance="10"
     40     gridtolerance="10"
     41     guidetolerance="10"
     42     inkscape:pageopacity="0"
     43     inkscape:pageshadow="2"
     44     inkscape:window-width="1920"
     45     inkscape:window-height="1056"
     46     id="namedview4254"
     47     showgrid="false"
     48     inkscape:zoom="1.3101852"
     49     inkscape:cx="237.56928"
     50     inkscape:cy="7.2419621"
     51     inkscape:window-x="1920"
     52     inkscape:window-y="24"
     53     inkscape:window-maximized="1"
     54     inkscape:current-layer="svg4225" />
     55  <g
     56     id="enabled"
     57     style="fill:#464646;fill-opacity:1">
     58    <g
     59       id="polyline"
     60       style="fill:#464646;fill-opacity:1">
     61      <path
     62         d="m 18,36 0,6 6,0 0,-6 -6,0 z m 4,4 -2,0 0,-2 2,0 0,2 z"
     63         id="path4229"
     64         inkscape:connector-curvature="0"
     65         style="fill:#464646;fill-opacity:1" />
     66      <path
     67         d="m 36,18 0,6 6,0 0,-6 -6,0 z m 4,4 -2,0 0,-2 2,0 0,2 z"
     68         id="path4231"
     69         inkscape:connector-curvature="0"
     70         style="fill:#464646;fill-opacity:1" />
     71      <path
     72         d="m 23.142,39.145 -2.285,-2.29 16,-15.998 2.285,2.285 z"
     73         id="path4233"
     74         inkscape:connector-curvature="0"
     75         style="fill:#464646;fill-opacity:1" />
    2276    </g>
    23     <g id="disabled" fill="#bbb" transform="translate(120)">
    24         <use xlink:href="#edit" id="edit-disabled"/>
    25         <use xlink:href="#remove" id="remove-disabled"/>
     77    <path
     78       id="polygon"
     79       d="M 100,24.565 97.904,39.395 83.07,42 76,28.773 86.463,18 Z"
     80       inkscape:connector-curvature="0"
     81       style="fill:#464646;fill-opacity:1" />
     82    <path
     83       id="rectangle"
     84       d="m 140,20 20,0 0,20 -20,0 z"
     85       inkscape:connector-curvature="0"
     86       style="fill:#464646;fill-opacity:1" />
     87    <path
     88       id="circle"
     89       d="m 221,30 c 0,6.078 -4.926,11 -11,11 -6.074,0 -11,-4.922 -11,-11 0,-6.074 4.926,-11 11,-11 6.074,0 11,4.926 11,11 z"
     90       inkscape:connector-curvature="0"
     91       style="fill:#464646;fill-opacity:1" />
     92    <path
     93       id="marker"
     94       d="m 270,19 c -4.971,0 -9,4.029 -9,9 0,4.971 5.001,12 9,14 4.001,-2 9,-9.029 9,-14 0,-4.971 -4.029,-9 -9,-9 z m 0,12.5 c -2.484,0 -4.5,-2.014 -4.5,-4.5 0,-2.484 2.016,-4.5 4.5,-4.5 2.485,0 4.5,2.016 4.5,4.5 0,2.486 -2.015,4.5 -4.5,4.5 z"
     95       inkscape:connector-curvature="0"
     96       style="fill:#464646;fill-opacity:1" />
     97    <g
     98       id="edit"
     99       style="fill:#464646;fill-opacity:1">
     100      <path
     101         d="m 337,30.156 0,0.407 0,5.604 c 0,1.658 -1.344,3 -3,3 l -10,0 c -1.655,0 -3,-1.342 -3,-3 l 0,-10 c 0,-1.657 1.345,-3 3,-3 l 6.345,0 3.19,-3.17 -9.535,0 c -3.313,0 -6,2.687 -6,6 l 0,10 c 0,3.313 2.687,6 6,6 l 10,0 c 3.314,0 6,-2.687 6,-6 l 0,-8.809 -3,2.968"
     102         id="path4240"
     103         inkscape:connector-curvature="0"
     104         style="fill:#464646;fill-opacity:1" />
     105      <path
     106         d="m 338.72,24.637 -8.892,8.892 -2.828,0 0,-2.829 8.89,-8.89 z"
     107         id="path4242"
     108         inkscape:connector-curvature="0"
     109         style="fill:#464646;fill-opacity:1" />
     110      <path
     111         d="m 338.697,17.826 4,0 0,4 -4,0 z"
     112         transform="matrix(-0.70698336,-0.70723018,0.70723018,-0.70698336,567.55917,274.78273)"
     113         id="path4244"
     114         inkscape:connector-curvature="0"
     115         style="fill:#464646;fill-opacity:1" />
    26116    </g>
     117    <g
     118       id="remove"
     119       style="fill:#464646;fill-opacity:1">
     120      <path
     121         d="m 381,42 18,0 0,-18 -18,0 0,18 z m 14,-16 2,0 0,14 -2,0 0,-14 z m -4,0 2,0 0,14 -2,0 0,-14 z m -4,0 2,0 0,14 -2,0 0,-14 z m -4,0 2,0 0,14 -2,0 0,-14 z"
     122         id="path4247"
     123         inkscape:connector-curvature="0"
     124         style="fill:#464646;fill-opacity:1" />
     125      <path
     126         d="m 395,20 0,-4 -10,0 0,4 -6,0 0,2 22,0 0,-2 -6,0 z m -2,0 -6,0 0,-2 6,0 0,2 z"
     127         id="path4249"
     128         inkscape:connector-curvature="0"
     129         style="fill:#464646;fill-opacity:1" />
     130    </g>
     131  </g>
     132  <g
     133     id="disabled"
     134     transform="translate(120,0)"
     135     style="fill:#bbbbbb">
     136    <use
     137       xlink:href="#edit"
     138       id="edit-disabled"
     139       x="0"
     140       y="0"
     141       width="100%"
     142       height="100%" />
     143    <use
     144       xlink:href="#remove"
     145       id="remove-disabled"
     146       x="0"
     147       y="0"
     148       width="100%"
     149       height="100%" />
     150  </g>
     151  <path
     152     style="fill:none;stroke:#464646;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
     153     id="circle-3"
     154     d="m 581.65725,30 c 0,6.078 -4.926,11 -11,11 -6.074,0 -11,-4.922 -11,-11 0,-6.074 4.926,-11 11,-11 6.074,0 11,4.926 11,11 z"
     155     inkscape:connector-curvature="0" />
    27156</svg>
  • _plugins_/gis_geometries/lib/leaflet-draw/leaflet.draw-src.js

    r100142 r108378  
    11/*
    2         Leaflet.draw, a plugin that adds drawing and editing tools to Leaflet powered maps.
    3         (c) 2012-2016, Jacob Toye, Smartrak, Leaflet
    4 
    5         https://github.com/Leaflet/Leaflet.draw
    6         http://leafletjs.com
    7 */
    8 (function (window, document, undefined) {/*
     2 Leaflet.draw 0.4.11, a plugin that adds drawing and editing tools to Leaflet powered maps.
     3 (c) 2012-2017, Jacob Toye, Jon West, Smartrak, Leaflet
     4
     5 https://github.com/Leaflet/Leaflet.draw
     6 http://leafletjs.com
     7 */
     8(function (window, document, undefined) {/**
    99 * Leaflet.draw assumes that you have already included the Leaflet library.
    1010 */
    11 
    12 L.drawVersion = '0.4.0';
    13 
     11L.drawVersion = "0.4.11";
     12/**
     13 * @class L.Draw
     14 * @aka Draw
     15 *
     16 *
     17 * To add the draw toolbar set the option drawControl: true in the map options.
     18 *
     19 * @example
     20 * ```js
     21 *      var map = L.map('map', {drawControl: true}).setView([51.505, -0.09], 13);
     22 *
     23 *      L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {
     24 *          attribution: '&copy; <a href="http://osm.org/copyright">OpenStreetMap</a> contributors'
     25 *      }).addTo(map);
     26 * ```
     27 *
     28 * ### Adding the edit toolbar
     29 * To use the edit toolbar you must initialise the Leaflet.draw control and manually add it to the map.
     30 *
     31 * ```js
     32 *      var map = L.map('map').setView([51.505, -0.09], 13);
     33 *
     34 *      L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {
     35 *          attribution: '&copy; <a href="http://osm.org/copyright">OpenStreetMap</a> contributors'
     36 *      }).addTo(map);
     37 *
     38 *      // FeatureGroup is to store editable layers
     39 *      var drawnItems = new L.FeatureGroup();
     40 *      map.addLayer(drawnItems);
     41 *
     42 *      var drawControl = new L.Control.Draw({
     43 *          edit: {
     44 *              featureGroup: drawnItems
     45 *          }
     46 *      });
     47 *      map.addControl(drawControl);
     48 * ```
     49 *
     50 * The key here is the featureGroup option. This tells the plugin which FeatureGroup contains the layers that
     51 * should be editable. The featureGroup can contain 0 or more features with geometry types Point, LineString, and Polygon.
     52 * Leaflet.draw does not work with multigeometry features such as MultiPoint, MultiLineString, MultiPolygon,
     53 * or GeometryCollection. If you need to add multigeometry features to the draw plugin, convert them to a
     54 * FeatureCollection of non-multigeometries (Points, LineStrings, or Polygons).
     55 */
     56L.Draw = {};
     57
     58/**
     59 * @class L.drawLocal
     60 * @aka L.drawLocal
     61 *
     62 * The core toolbar class of the API — it is used to create the toolbar ui
     63 *
     64 * @example
     65 * ```js
     66 *      var modifiedDraw = L.drawLocal.extend({
     67 *          draw: {
     68 *              toolbar: {
     69 *                  buttons: {
     70 *                      polygon: 'Draw an awesome polygon'
     71 *                  }
     72 *              }
     73 *          }
     74 *      });
     75 * ```
     76 *
     77 * The default state for the control is the draw toolbar just below the zoom control.
     78 *  This will allow map users to draw vectors and markers.
     79 *  **Please note the edit toolbar is not enabled by default.**
     80 */
    1481L.drawLocal = {
     82        // format: {
     83        //      numeric: {
     84        //              delimiters: {
     85        //                      thousands: ',',
     86        //                      decimal: '.'
     87        //              }
     88        //      }
     89        // },
    1590        draw: {
    1691                toolbar: {
     
    34109                                rectangle: 'Draw a rectangle',
    35110                                circle: 'Draw a circle',
    36                                 marker: 'Draw a marker'
     111                                marker: 'Draw a marker',
     112                                circlemarker: 'Draw a circlemarker'
    37113                        }
    38114                },
     
    43119                                },
    44120                                radius: 'Radius'
     121                        },
     122                        circlemarker: {
     123                                tooltip: {
     124                                        start: 'Click map to place circle marker.'
     125                                }
    45126                        },
    46127                        marker: {
     
    80161                        actions: {
    81162                                save: {
    82                                         title: 'Save changes.',
     163                                        title: 'Save changes',
    83164                                        text: 'Save'
    84165                                },
    85166                                cancel: {
    86                                         title: 'Cancel editing, discards all changes.',
     167                                        title: 'Cancel editing, discards all changes',
    87168                                        text: 'Cancel'
     169                                },
     170                                clearAll:{
     171                                        title: 'Clear all layers',
     172                                        text: 'Clear All'
    88173                                }
    89174                        },
    90175                        buttons: {
    91                                 edit: 'Edit layers.',
    92                                 editDisabled: 'No layers to edit.',
    93                                 remove: 'Delete layers.',
    94                                 removeDisabled: 'No layers to delete.'
     176                                edit: 'Edit layers',
     177                                editDisabled: 'No layers to edit',
     178                                remove: 'Delete layers',
     179                                removeDisabled: 'No layers to delete'
    95180                        }
    96181                },
     
    98183                        edit: {
    99184                                tooltip: {
    100                                         text: 'Drag handles, or marker to edit feature.',
     185                                        text: 'Drag handles or markers to edit features.',
    101186                                        subtext: 'Click cancel to undo changes.'
    102187                                }
     
    104189                        remove: {
    105190                                tooltip: {
    106                                         text: 'Click on a feature to remove'
     191                                        text: 'Click on a feature to remove.'
    107192                                }
    108193                        }
     
    112197
    113198
     199
     200/**
     201 * ### Events
     202 * Once you have successfully added the Leaflet.draw plugin to your map you will want to respond to the different
     203 * actions users can initiate. The following events will be triggered on the map:
     204 *
     205 * @class L.Draw.Event
     206 * @aka Draw.Event
     207 *
     208 * Use `L.Draw.Event.EVENTNAME` constants to ensure events are correct.
     209 *
     210 * @example
     211 * ```js
     212 * map.on(L.Draw.Event.CREATED; function (e) {
     213 *    var type = e.layerType,
     214 *        layer = e.layer;
     215 *
     216 *    if (type === 'marker') {
     217 *        // Do marker specific actions
     218 *    }
     219 *
     220 *    // Do whatever else you need to. (save to db; add to map etc)
     221 *    map.addLayer(layer);
     222 *});
     223 * ```
     224 */
     225L.Draw.Event = {};
     226/**
     227 * @event draw:created: PolyLine; Polygon; Rectangle; Circle; Marker | String
     228 *
     229 * Layer that was just created.
     230 * The type of layer this is. One of: `polyline`; `polygon`; `rectangle`; `circle`; `marker`
     231 * Triggered when a new vector or marker has been created.
     232 *
     233 */
     234L.Draw.Event.CREATED = 'draw:created';
     235
     236/**
     237 * @event draw:edited: LayerGroup
     238 *
     239 * List of all layers just edited on the map.
     240 *
     241 *
     242 * Triggered when layers in the FeatureGroup; initialised with the plugin; have been edited and saved.
     243 *
     244 * @example
     245 * ```js
     246 *      map.on('draw:edited', function (e) {
     247     *          var layers = e.layers;
     248     *          layers.eachLayer(function (layer) {
     249     *              //do whatever you want; most likely save back to db
     250     *          });
     251     *      });
     252 * ```
     253 */
     254L.Draw.Event.EDITED = 'draw:edited';
     255
     256/**
     257 * @event draw:deleted: LayerGroup
     258 *
     259 * List of all layers just removed from the map.
     260 *
     261 * Triggered when layers have been removed (and saved) from the FeatureGroup.
     262 */
     263L.Draw.Event.DELETED = 'draw:deleted';
     264
     265/**
     266 * @event draw:drawstart: String
     267 *
     268 * The type of layer this is. One of:`polyline`; `polygon`; `rectangle`; `circle`; `marker`
     269 *
     270 * Triggered when the user has chosen to draw a particular vector or marker.
     271 */
     272L.Draw.Event.DRAWSTART = 'draw:drawstart';
     273
     274/**
     275 * @event draw:drawstop: String
     276 *
     277 * The type of layer this is. One of: `polyline`; `polygon`; `rectangle`; `circle`; `marker`
     278 *
     279 * Triggered when the user has finished a particular vector or marker.
     280 */
     281
     282L.Draw.Event.DRAWSTOP = 'draw:drawstop';
     283
     284/**
     285 * @event draw:drawvertex: LayerGroup
     286 *
     287 * List of all layers just being added from the map.
     288 *
     289 * Triggered when a vertex is created on a polyline or polygon.
     290 */
     291L.Draw.Event.DRAWVERTEX = 'draw:drawvertex';
     292
     293/**
     294 * @event draw:editstart: String
     295 *
     296 * The type of edit this is. One of: `edit`
     297 *
     298 * Triggered when the user starts edit mode by clicking the edit tool button.
     299 */
     300
     301L.Draw.Event.EDITSTART = 'draw:editstart';
     302
     303/**
     304 * @event draw:editmove: ILayer
     305 *
     306 *  Layer that was just moved.
     307 *
     308 * Triggered as the user moves a rectangle; circle or marker.
     309 */
     310L.Draw.Event.EDITMOVE = 'draw:editmove';
     311
     312/**
     313 * @event draw:editresize: ILayer
     314 *
     315 * Layer that was just moved.
     316 *
     317 * Triggered as the user resizes a rectangle or circle.
     318 */
     319L.Draw.Event.EDITRESIZE = 'draw:editresize';
     320
     321/**
     322 * @event draw:editvertex: LayerGroup
     323 *
     324 * List of all layers just being edited from the map.
     325 *
     326 * Triggered when a vertex is edited on a polyline or polygon.
     327 */
     328L.Draw.Event.EDITVERTEX = 'draw:editvertex';
     329
     330/**
     331 * @event draw:editstop: String
     332 *
     333 * The type of edit this is. One of: `edit`
     334 *
     335 * Triggered when the user has finshed editing (edit mode) and saves edits.
     336 */
     337L.Draw.Event.EDITSTOP = 'draw:editstop';
     338
     339/**
     340 * @event draw:deletestart: String
     341 *
     342 * The type of edit this is. One of: `remove`
     343 *
     344 * Triggered when the user starts remove mode by clicking the remove tool button.
     345 */
     346L.Draw.Event.DELETESTART = 'draw:deletestart';
     347
     348/**
     349 * @event draw:deletestop: String
     350 *
     351 * The type of edit this is. One of: `remove`
     352 *
     353 * Triggered when the user has finished removing shapes (remove mode) and saves.
     354 */
     355L.Draw.Event.DELETESTOP = 'draw:deletestop';
     356
     357
     358
    114359L.Draw = L.Draw || {};
    115360
     361/**
     362 * @class L.Draw.Feature
     363 * @aka Draw.Feature
     364 */
    116365L.Draw.Feature = L.Handler.extend({
    117366        includes: L.Mixin.Events,
    118367
     368        // @method initialize(): void
    119369        initialize: function (map, options) {
    120370                this._map = map;
     
    130380        },
    131381
     382        // @method enable(): void
     383        // Enables this handler
    132384        enable: function () {
    133                 if (this._enabled) { return; }
     385                if (this._enabled) {
     386                        return;
     387                }
    134388
    135389                L.Handler.prototype.enable.call(this);
     
    137391                this.fire('enabled', { handler: this.type });
    138392
    139                 this._map.fire('draw:drawstart', { layerType: this.type });
    140         },
    141 
     393                this._map.fire(L.Draw.Event.DRAWSTART, { layerType: this.type });
     394        },
     395
     396        // @method disable(): void
    142397        disable: function () {
    143                 if (!this._enabled) { return; }
     398                if (!this._enabled) {
     399                        return;
     400                }
    144401
    145402                L.Handler.prototype.disable.call(this);
    146403
    147                 this._map.fire('draw:drawstop', { layerType: this.type });
     404                this._map.fire(L.Draw.Event.DRAWSTOP, { layerType: this.type });
    148405
    149406                this.fire('disabled', { handler: this.type });
    150407        },
    151408
     409        // @method addHooks(): void
     410        // Add's event listeners to this handler
    152411        addHooks: function () {
    153412                var map = this._map;
     
    164423        },
    165424
     425        // @method removeHooks(): void
     426        // Removes event listeners from this handler
    166427        removeHooks: function () {
    167428                if (this._map) {
     
    175436        },
    176437
     438        // @method setOptions(object): void
     439        // Sets new options to this handler
    177440        setOptions: function (options) {
    178441                L.setOptions(this, options);
     
    180443
    181444        _fireCreatedEvent: function (layer) {
    182                 this._map.fire('draw:created', { layer: layer, layerType: this.type });
     445                this._map.fire(L.Draw.Event.CREATED, { layer: layer, layerType: this.type });
    183446        },
    184447
    185448        // Cancel drawing when the escape key is pressed
    186449        _cancelDrawing: function (e) {
    187                 this._map.fire('draw:canceled', { layerType: this.type });
    188450                if (e.keyCode === 27) {
     451                        this._map.fire('draw:canceled', { layerType: this.type });
    189452                        this.disable();
    190453                }
     
    193456
    194457
     458
     459/**
     460 * @class L.Draw.Polyline
     461 * @aka Draw.Polyline
     462 * @inherits L.Draw.Feature
     463 */
    195464L.Draw.Polyline = L.Draw.Feature.extend({
    196465        statics: {
     
    219488                shapeOptions: {
    220489                        stroke: true,
    221                         color: '#f06eaa',
     490                        color: '#3388ff',
    222491                        weight: 4,
    223492                        opacity: 0.5,
     
    227496                metric: true, // Whether to use the metric measurement system or imperial
    228497                feet: true, // When not metric, to use feet instead of yards for display.
     498                nautic: false, // When not metric, not feet use nautic mile for display
    229499                showLength: true, // Whether to display distance in the tooltip
    230                 zIndexOffset: 2000 // This should be > than the highest z-index any map layers
    231         },
    232 
     500    zIndexOffset: 2000, // This should be > than the highest z-index any map layers
     501    factor: 1 // To change distance calculation
     502        },
     503
     504        // @method initialize(): void
    233505        initialize: function (map, options) {
    234506                // if touch, switch to touch icon
     
    251523        },
    252524
     525        // @method addHooks(): void
     526        // Add listener hooks to this handler
    253527        addHooks: function () {
    254528                L.Draw.Feature.prototype.addHooks.call(this);
     
    280554                        }
    281555
    282                         if (!L.Browser.touch) {
    283                                 this._map.on('mouseup', this._onMouseUp, this); // Necessary for 0.7 compatibility
    284                         }
    285 
    286556                        this._mouseMarker
     557                                .on('mouseout', this._onMouseOut, this)
     558                                .on('mousemove', this._onMouseMove, this) // Necessary to prevent 0.8 stutter
    287559                                .on('mousedown', this._onMouseDown, this)
    288                                 .on('mouseout', this._onMouseOut, this)
    289560                                .on('mouseup', this._onMouseUp, this) // Necessary for 0.8 compatibility
    290                                 .on('mousemove', this._onMouseMove, this) // Necessary to prevent 0.8 stutter
    291561                                .addTo(this._map);
    292562
     
    295565                                .on('mousemove', this._onMouseMove, this)
    296566                                .on('zoomlevelschange', this._onZoomEnd, this)
    297                                 .on('click', this._onTouch, this)
     567                                .on('touchstart', this._onTouch, this)
    298568                                .on('zoomend', this._onZoomEnd, this);
    299                 }
    300         },
    301 
     569
     570                }
     571        },
     572
     573        // @method removeHooks(): void
     574        // Remove listener hooks from this handler.
    302575        removeHooks: function () {
    303576                L.Draw.Feature.prototype.removeHooks.call(this);
     
    331604                        .off('zoomlevelschange', this._onZoomEnd, this)
    332605                        .off('zoomend', this._onZoomEnd, this)
     606                        .off('touchstart', this._onTouch, this)
    333607                        .off('click', this._onTouch, this);
    334608        },
    335609
     610        // @method deleteLastVertex(): void
     611        // Remove the last vertex from the polyline, removes polyline from map if only one point exists.
    336612        deleteLastVertex: function () {
    337613                if (this._markers.length <= 1) {
     
    355631        },
    356632
     633        // @method addVertex(): void
     634        // Add a vertex to the end of the polyline
    357635        addVertex: function (latlng) {
    358636                var markersLength = this._markers.length;
    359 
    360                 if (markersLength > 0 && !this.options.allowIntersection && this._poly.newLatLngIntersects(latlng)) {
     637                // markersLength must be greater than or equal to 2 before intersections can occur
     638                if (markersLength >= 2 && !this.options.allowIntersection && this._poly.newLatLngIntersects(latlng)) {
    361639                        this._showErrorTooltip();
    362640                        return;
     
    377655        },
    378656
     657        // @method completeShape(): void
     658        // Closes the polyline between the first and last points
    379659        completeShape: function () {
    380660                if (this._markers.length <= 1) {
     
    406686        },
    407687
    408         //Called to verify the shape is valid when the user tries to finish it
    409         //Return false if the shape is not valid
     688        // Called to verify the shape is valid when the user tries to finish it
     689        // Return false if the shape is not valid
    410690        _shapeIsValid: function () {
    411691                return true;
     
    438718
    439719        _vertexChanged: function (latlng, added) {
    440                 this._map.fire('draw:drawvertex', { layers: this._markerGroup });
     720                this._map.fire(L.Draw.Event.DRAWVERTEX, { layers: this._markerGroup });
    441721                this._updateFinishHandler();
    442722
     
    449729
    450730        _onMouseDown: function (e) {
     731                if (!this._clickHandled && !this._touchHandled && !this._disableMarkers) {
     732                        this._onMouseMove(e);
     733                        this._clickHandled = true;
     734                        this._disableNewMarkers();
     735                        var originalEvent = e.originalEvent;
     736                        var clientX = originalEvent.clientX;
     737                        var clientY = originalEvent.clientY;
     738                        this._startPoint.call(this, clientX, clientY);
     739                }
     740        },
     741
     742        _startPoint: function (clientX, clientY) {
     743                this._mouseDownOrigin = L.point(clientX, clientY);
     744        },
     745
     746        _onMouseUp: function (e) {
    451747                var originalEvent = e.originalEvent;
    452                 this._mouseDownOrigin = L.point(originalEvent.clientX, originalEvent.clientY);
    453         },
    454 
    455         _onMouseUp: function (e) {
     748                var clientX = originalEvent.clientX;
     749                var clientY = originalEvent.clientY;
     750                this._endPoint.call(this, clientX, clientY, e);
     751                this._clickHandled = null;
     752        },
     753
     754        _endPoint: function (clientX, clientY, e) {
    456755                if (this._mouseDownOrigin) {
    457                         // We detect clicks within a certain tolerance, otherwise let it
    458                         // be interpreted as a drag by the map
    459                         var distance = L.point(e.originalEvent.clientX, e.originalEvent.clientY)
     756                        var dragCheckDistance = L.point(clientX, clientY)
    460757                                .distanceTo(this._mouseDownOrigin);
    461                         if (Math.abs(distance) < 9 * (window.devicePixelRatio || 1)) {
     758                        var lastPtDistance = this._calculateFinishDistance(e.latlng);
     759                        if (lastPtDistance < 10 && L.Browser.touch) {
     760                                this._finishShape();
     761                        } else if (Math.abs(dragCheckDistance) < 9 * (window.devicePixelRatio || 1)) {
    462762                                this.addVertex(e.latlng);
    463763                        }
     764                        this._enableNewMarkers(); // after a short pause, enable new markers
    464765                }
    465766                this._mouseDownOrigin = null;
    466767        },
    467768
     769        // ontouch prevented by clickHandled flag because some browsers fire both click/touch events,
     770        // causing unwanted behavior
    468771        _onTouch: function (e) {
    469                 // #TODO: use touchstart and touchend vs using click(touch start & end).
    470                 if (L.Browser.touch) { // #TODO: get rid of this once leaflet fixes their click/touch.
    471                         this._onMouseDown(e);
    472                         this._onMouseUp(e);
    473                 }
     772                var originalEvent = e.originalEvent;
     773                var clientX;
     774                var clientY;
     775                if (originalEvent.touches && originalEvent.touches[0] && !this._clickHandled && !this._touchHandled && !this._disableMarkers) {
     776                        clientX = originalEvent.touches[0].clientX;
     777                        clientY = originalEvent.touches[0].clientY;
     778                        this._disableNewMarkers();
     779                        this._touchHandled = true;
     780                        this._startPoint.call(this, clientX, clientY);
     781                        this._endPoint.call(this, clientX, clientY, e);
     782                        this._touchHandled = null;
     783                }
     784                this._clickHandled = null;
    474785        },
    475786
     
    478789                        this._tooltip._onMouseOut.call(this._tooltip);
    479790                }
     791        },
     792
     793        // calculate if we are currently within close enough distance
     794        // of the closing point (first point for shapes, last point for lines)
     795        // this is semi-ugly code but the only reliable way i found to get the job done
     796        // note: calculating point.distanceTo between mouseDownOrigin and last marker did NOT work
     797        _calculateFinishDistance: function (potentialLatLng) {
     798                var lastPtDistance
     799                if (this._markers.length > 0) {
     800                                var finishMarker;
     801                                if (this.type === L.Draw.Polyline.TYPE) {
     802                                        finishMarker = this._markers[this._markers.length - 1];
     803                                } else if (this.type === L.Draw.Polygon.TYPE) {
     804                                        finishMarker = this._markers[0];
     805                                } else {
     806                                        return Infinity;
     807                                }
     808                                var lastMarkerPoint = this._map.latLngToContainerPoint(finishMarker.getLatLng()),
     809                                potentialMarker = new L.Marker(potentialLatLng, {
     810                                        icon: this.options.icon,
     811                                        zIndexOffset: this.options.zIndexOffset * 2
     812                                });
     813                                var potentialMarkerPint = this._map.latLngToContainerPoint(potentialMarker.getLatLng());
     814                                lastPtDistance = lastMarkerPoint.distanceTo(potentialMarkerPint);
     815                        } else {
     816                                lastPtDistance = Infinity;
     817                        }
     818                        return lastPtDistance;
    480819        },
    481820
     
    586925                var showLength = this.options.showLength,
    587926                        labelText, distanceStr;
    588 
     927                if (L.Browser.touch) {
     928                        showLength = false; // if there's a better place to put this, feel free to move it
     929                }
    589930                if (this._markers.length === 0) {
    590931                        labelText = {
     
    617958                } else {
    618959                        previousMarkerIndex = markersLength - (added ? 2 : 1);
    619                         distance = latlng.distanceTo(this._markers[previousMarkerIndex].getLatLng());
     960                        distance = this._map.distance(latlng, this._markers[previousMarkerIndex].getLatLng()) * (this.options.factor || 1);
    620961
    621962                        this._measurementRunningTotal += distance * (added ? 1 : -1);
     
    629970
    630971                // calculate the distance from the last fixed point to the mouse position
    631                 distance = this._measurementRunningTotal + currentLatLng.distanceTo(previousLatLng);
    632 
    633                 return L.GeometryUtil.readableDistance(distance, this.options.metric, this.options.feet);
     972                distance = previousLatLng && currentLatLng ? this._measurementRunningTotal + this._map.distance(currentLatLng, previousLatLng) * (this.options.factor || 1) : this._measurementRunningTotal || 0 ;
     973
     974                return L.GeometryUtil.readableDistance(distance, this.options.metric, this.options.feet, this.options.nautic, this.options.precision);
    634975        },
    635976
     
    6711012                        this._hideErrorTimeout = null;
    6721013                }
     1014        },
     1015
     1016        // disable new markers temporarily;
     1017        // this is to prevent duplicated touch/click events in some browsers
     1018        _disableNewMarkers: function () {
     1019                this._disableMarkers = true;
     1020        },
     1021
     1022        // see _disableNewMarkers
     1023        _enableNewMarkers: function () {
     1024                setTimeout(function() {
     1025                        this._disableMarkers = false;
     1026                }.bind(this), 50);
    6731027        },
    6741028
     
    6861040
    6871041
     1042
     1043/**
     1044 * @class L.Draw.Polygon
     1045 * @aka Draw.Polygon
     1046 * @inherits L.Draw.Polyline
     1047 */
    6881048L.Draw.Polygon = L.Draw.Polyline.extend({
    6891049        statics: {
     
    6951055        options: {
    6961056                showArea: false,
     1057                showLength: false,
    6971058                shapeOptions: {
    6981059                        stroke: true,
    699                         color: '#f06eaa',
     1060                        color: '#3388ff',
    7001061                        weight: 4,
    7011062                        opacity: 0.5,
     
    7051066                        clickable: true
    7061067                },
    707                 metric: true // Whether to use the metric measurement system or imperial
    708         },
    709 
     1068                // Whether to use the metric measurement system (truthy) or not (falsy).
     1069                // Also defines the units to use for the metric system as an array of
     1070                // strings (e.g. `['ha', 'm']`).
     1071                metric: true,
     1072                feet: true, // When not metric, to use feet instead of yards for display.
     1073                nautic: false, // When not metric, not feet use nautic mile for display
     1074                // Defines the precision for each type of unit (e.g. {km: 2, ft: 0}
     1075                precision: {}
     1076        },
     1077
     1078        // @method initialize(): void
    7101079        initialize: function (map, options) {
    7111080                L.Draw.Polyline.prototype.initialize.call(this, map, options);
     
    7401109                } else if (this._markers.length < 3) {
    7411110                        text = L.drawLocal.draw.handlers.polygon.tooltip.cont;
     1111                        subtext = this._getMeasurementString();
    7421112                } else {
    7431113                        text = L.drawLocal.draw.handlers.polygon.tooltip.end;
     
    7521122
    7531123        _getMeasurementString: function () {
    754                 var area = this._area;
    755 
    756                 if (!area) {
     1124                var area = this._area,
     1125                        measurementString = '';
     1126
     1127
     1128                if (!area && !this.options.showLength) {
    7571129                        return null;
    7581130                }
    7591131
    760                 return L.GeometryUtil.readableArea(area, this.options.metric);
     1132                if (this.options.showLength) {
     1133                        measurementString = L.Draw.Polyline.prototype._getMeasurementString.call(this);
     1134                }
     1135
     1136                if (area) {
     1137                        measurementString += '<br>' + L.GeometryUtil.readableArea(area, this.options.metric, this.options.precision);
     1138                }
     1139
     1140                return measurementString;
    7611141        },
    7621142
     
    7921172
    7931173
     1174
    7941175L.SimpleShape = {};
    795 
     1176/**
     1177 * @class L.Draw.SimpleShape
     1178 * @aka Draw.SimpleShape
     1179 * @inherits L.Draw.Feature
     1180 */
    7961181L.Draw.SimpleShape = L.Draw.Feature.extend({
    7971182        options: {
     
    7991184        },
    8001185
     1186        // @method initialize(): void
    8011187        initialize: function (map, options) {
    8021188                this._endLabelText = L.drawLocal.draw.handlers.simpleshape.tooltip.end;
     
    8051191        },
    8061192
     1193        // @method addHooks(): void
     1194        // Add listener hooks to this handler.
    8071195        addHooks: function () {
    8081196                L.Draw.Feature.prototype.addHooks.call(this);
     
    8271215        },
    8281216
     1217        // @method removeHooks(): void
     1218        // Remove listener hooks from this handler.
    8291219        removeHooks: function () {
    8301220                L.Draw.Feature.prototype.removeHooks.call(this);
     
    8931283});
    8941284
     1285
     1286/**
     1287 * @class L.Draw.Rectangle
     1288 * @aka Draw.Rectangle
     1289 * @inherits L.Draw.SimpleShape
     1290 */
    8951291L.Draw.Rectangle = L.Draw.SimpleShape.extend({
    8961292        statics: {
     
    9011297                shapeOptions: {
    9021298                        stroke: true,
    903                         color: '#f06eaa',
     1299                        color: '#3388ff',
    9041300                        weight: 4,
    9051301                        opacity: 0.5,
     
    9071303                        fillColor: null, //same as color by default
    9081304                        fillOpacity: 0.2,
     1305                        showArea: true,
    9091306                        clickable: true
    9101307                },
     
    9121309        },
    9131310
     1311        // @method initialize(): void
    9141312        initialize: function (map, options) {
    9151313                // Save the type so super can fire, need to do this as cannot do this.TYPE :(
     
    9201318                L.Draw.SimpleShape.prototype.initialize.call(this, map, options);
    9211319        },
    922 
     1320   
     1321        // @method disable(): void
     1322        disable: function () {
     1323                if (!this._enabled) {
     1324                        return;
     1325                }
     1326
     1327                this._isCurrentlyTwoClickDrawing = false;
     1328                L.Draw.SimpleShape.prototype.disable.call(this);
     1329        },
     1330   
     1331        _onMouseUp: function (e) {
     1332                if (!this._shape && !this._isCurrentlyTwoClickDrawing) {
     1333                        this._isCurrentlyTwoClickDrawing = true;
     1334                        return;
     1335                }
     1336               
     1337                // Make sure closing click is on map
     1338                if (this._isCurrentlyTwoClickDrawing && !_hasAncestor(e.target, 'leaflet-pane')) {
     1339                        return;
     1340                }
     1341
     1342                L.Draw.SimpleShape.prototype._onMouseUp.call(this);
     1343        },
     1344   
    9231345        _drawShape: function (latlng) {
    9241346                if (!this._shape) {
     
    9381360                var tooltipText = L.Draw.SimpleShape.prototype._getTooltipText.call(this),
    9391361                        shape = this._shape,
     1362                        showArea = this.options.showArea,
    9401363                        latLngs, area, subtext;
    9411364
     
    9431366                        latLngs = this._shape._defaultShape ? this._shape._defaultShape() : this._shape.getLatLngs();
    9441367                        area = L.GeometryUtil.geodesicArea(latLngs);
    945                         subtext = L.GeometryUtil.readableArea(area, this.options.metric);
     1368                        subtext = showArea ? L.GeometryUtil.readableArea(area, this.options.metric) : ''
    9461369                }
    9471370
     
    9531376});
    9541377
    955 
    956 L.Draw.Circle = L.Draw.SimpleShape.extend({
    957         statics: {
    958                 TYPE: 'circle'
    959         },
    960 
    961         options: {
    962                 shapeOptions: {
    963                         stroke: true,
    964                         color: '#f06eaa',
    965                         weight: 4,
    966                         opacity: 0.5,
    967                         fill: true,
    968                         fillColor: null, //same as color by default
    969                         fillOpacity: 0.2,
    970                         clickable: true
    971                 },
    972                 showRadius: true,
    973                 metric: true, // Whether to use the metric measurement system or imperial
    974                 feet: true // When not metric, use feet instead of yards for display
    975         },
    976 
    977         initialize: function (map, options) {
    978                 // Save the type so super can fire, need to do this as cannot do this.TYPE :(
    979                 this.type = L.Draw.Circle.TYPE;
    980 
    981                 this._initialLabelText = L.drawLocal.draw.handlers.circle.tooltip.start;
    982 
    983                 L.Draw.SimpleShape.prototype.initialize.call(this, map, options);
    984         },
    985 
    986         _drawShape: function (latlng) {
    987                 if (!this._shape) {
    988                         this._shape = new L.Circle(this._startLatLng, this._startLatLng.distanceTo(latlng), this.options.shapeOptions);
    989                         this._map.addLayer(this._shape);
    990                 } else {
    991                         this._shape.setRadius(this._startLatLng.distanceTo(latlng));
    992                 }
    993         },
    994 
    995         _fireCreatedEvent: function () {
    996                 var circle = new L.Circle(this._startLatLng, this._shape.getRadius(), this.options.shapeOptions);
    997                 L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, circle);
    998         },
    999 
    1000         _onMouseMove: function (e) {
    1001                 var latlng = e.latlng,
    1002                         showRadius = this.options.showRadius,
    1003                         useMetric = this.options.metric,
    1004                         radius;
    1005 
    1006                 this._tooltip.updatePosition(latlng);
    1007                 if (this._isDrawing) {
    1008                         this._drawShape(latlng);
    1009 
    1010                         // Get the new radius (rounded to 1 dp)
    1011                         radius = this._shape.getRadius().toFixed(1);
    1012 
    1013                         this._tooltip.updateContent({
    1014                                 text: this._endLabelText,
    1015                                 subtext: showRadius ? L.drawLocal.draw.handlers.circle.radius + ': ' +
    1016                                         L.GeometryUtil.readableDistance(radius, useMetric, this.options.feet) : ''
    1017                         });
    1018                 }
    1019         }
    1020 });
    1021 
    1022 
     1378function _hasAncestor (el, cls) {
     1379        while ((el = el.parentElement) && !el.classList.contains(cls));
     1380        return el;
     1381}
     1382
     1383
     1384
     1385/**
     1386 * @class L.Draw.Marker
     1387 * @aka Draw.Marker
     1388 * @inherits L.Draw.Feature
     1389 */
    10231390L.Draw.Marker = L.Draw.Feature.extend({
    10241391        statics: {
     
    10321399        },
    10331400
     1401        // @method initialize(): void
    10341402        initialize: function (map, options) {
    10351403                // Save the type so super can fire, need to do this as cannot do this.TYPE :(
    10361404                this.type = L.Draw.Marker.TYPE;
    10371405
     1406                this._initialLabelText = L.drawLocal.draw.handlers.marker.tooltip.start;
     1407
    10381408                L.Draw.Feature.prototype.initialize.call(this, map, options);
    10391409        },
    10401410
     1411        // @method addHooks(): void
     1412        // Add listener hooks to this handler.
    10411413        addHooks: function () {
    10421414                L.Draw.Feature.prototype.addHooks.call(this);
    10431415
    10441416                if (this._map) {
    1045                         this._tooltip.updateContent({ text: L.drawLocal.draw.handlers.marker.tooltip.start });
     1417                        this._tooltip.updateContent({ text: this._initialLabelText });
    10461418
    10471419                        // Same mouseMarker as in Draw.Polyline
     
    10671439        },
    10681440
     1441        // @method removeHooks(): void
     1442        // Remove listener hooks from this handler.
    10691443        removeHooks: function () {
    10701444                L.Draw.Feature.prototype.removeHooks.call(this);
     
    10951469
    10961470                if (!this._marker) {
    1097                         this._marker = new L.Marker(latlng, {
    1098                                 icon: this.options.icon,
    1099                                 zIndexOffset: this.options.zIndexOffset
    1100                         });
     1471                        this._marker = this._createMarker(latlng);
    11011472                        // Bind to both marker and map to make sure we get the click event.
    11021473                        this._marker.on('click', this._onClick, this);
     
    11111482        },
    11121483
     1484        _createMarker: function (latlng) {
     1485                return new L.Marker(latlng, {
     1486                        icon: this.options.icon,
     1487                        zIndexOffset: this.options.zIndexOffset
     1488                });
     1489        },
     1490
    11131491        _onClick: function () {
    11141492                this._fireCreatedEvent();
     
    11331511
    11341512
     1513
     1514/**
     1515 * @class L.Draw.CircleMarker
     1516 * @aka Draw.CircleMarker
     1517 * @inherits L.Draw.Marker
     1518 */
     1519L.Draw.CircleMarker = L.Draw.Marker.extend({
     1520        statics: {
     1521                TYPE: 'circlemarker'
     1522        },
     1523
     1524        options: {
     1525                stroke: true,
     1526                color: '#3388ff',
     1527                weight: 4,
     1528                opacity: 0.5,
     1529                fill: true,
     1530                fillColor: null, //same as color by default
     1531                fillOpacity: 0.2,
     1532                clickable: true,
     1533                zIndexOffset: 2000 // This should be > than the highest z-index any markers
     1534        },
     1535
     1536        // @method initialize(): void
     1537        initialize: function (map, options) {
     1538                // Save the type so super can fire, need to do this as cannot do this.TYPE :(
     1539                this.type = L.Draw.CircleMarker.TYPE;
     1540
     1541                this._initialLabelText = L.drawLocal.draw.handlers.circlemarker.tooltip.start;
     1542
     1543                L.Draw.Feature.prototype.initialize.call(this, map, options);
     1544        },
     1545
     1546
     1547        _fireCreatedEvent: function () {
     1548                var circleMarker = new L.CircleMarker(this._marker.getLatLng(), this.options);
     1549                L.Draw.Feature.prototype._fireCreatedEvent.call(this, circleMarker);
     1550        },
     1551
     1552        _createMarker: function (latlng) {
     1553                return new L.CircleMarker(latlng, this.options);
     1554        }
     1555});
     1556
     1557
     1558
     1559/**
     1560 * @class L.Draw.Circle
     1561 * @aka Draw.Circle
     1562 * @inherits L.Draw.SimpleShape
     1563 */
     1564L.Draw.Circle = L.Draw.SimpleShape.extend({
     1565        statics: {
     1566                TYPE: 'circle'
     1567        },
     1568
     1569        options: {
     1570                shapeOptions: {
     1571                        stroke: true,
     1572                        color: '#3388ff',
     1573                        weight: 4,
     1574                        opacity: 0.5,
     1575                        fill: true,
     1576                        fillColor: null, //same as color by default
     1577                        fillOpacity: 0.2,
     1578                        clickable: true
     1579                },
     1580                showRadius: true,
     1581                metric: true, // Whether to use the metric measurement system or imperial
     1582                feet: true, // When not metric, use feet instead of yards for display
     1583                nautic: false // When not metric, not feet use nautic mile for display
     1584        },
     1585
     1586        // @method initialize(): void
     1587        initialize: function (map, options) {
     1588                // Save the type so super can fire, need to do this as cannot do this.TYPE :(
     1589                this.type = L.Draw.Circle.TYPE;
     1590
     1591                this._initialLabelText = L.drawLocal.draw.handlers.circle.tooltip.start;
     1592
     1593                L.Draw.SimpleShape.prototype.initialize.call(this, map, options);
     1594        },
     1595
     1596        _drawShape: function (latlng) {
     1597    var distance = this._map.distance(this._startLatLng, latlng);
     1598                if (!this._shape) {
     1599                        this._shape = new L.Circle(this._startLatLng, distance, this.options.shapeOptions);
     1600                        this._map.addLayer(this._shape);
     1601                } else {
     1602                        this._shape.setRadius(distance);
     1603                }
     1604        },
     1605
     1606        _fireCreatedEvent: function () {
     1607                var circle = new L.Circle(this._startLatLng, this._shape.getRadius(), this.options.shapeOptions);
     1608                L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, circle);
     1609        },
     1610
     1611        _onMouseMove: function (e) {
     1612                var latlng = e.latlng,
     1613                        showRadius = this.options.showRadius,
     1614                        useMetric = this.options.metric,
     1615                        radius;
     1616
     1617                this._tooltip.updatePosition(latlng);
     1618                if (this._isDrawing) {
     1619                        this._drawShape(latlng);
     1620
     1621                        // Get the new radius (rounded to 1 dp)
     1622                        radius = this._shape.getRadius().toFixed(1);
     1623
     1624                        var subtext = '';
     1625                        if (showRadius) {
     1626                                subtext = L.drawLocal.draw.handlers.circle.radius + ': ' +
     1627                                                  L.GeometryUtil.readableDistance(radius, useMetric, this.options.feet, this.options.nautic);
     1628                        }
     1629                        this._tooltip.updateContent({
     1630                                text: this._endLabelText,
     1631                                subtext: subtext
     1632                        });
     1633                }
     1634        }
     1635});
     1636
     1637
     1638
    11351639L.Edit = L.Edit || {};
    11361640
     1641/**
     1642 * @class L.Edit.Marker
     1643 * @aka Edit.Marker
     1644 */
    11371645L.Edit.Marker = L.Handler.extend({
     1646        // @method initialize(): void
    11381647        initialize: function (marker, options) {
    11391648                this._marker = marker;
     
    11411650        },
    11421651
     1652        // @method addHooks(): void
     1653        // Add listener hooks to this handler
    11431654        addHooks: function () {
    11441655                var marker = this._marker;
     
    11491660        },
    11501661
     1662        // @method removeHooks(): void
     1663        // Remove listener hooks from this handler
    11511664        removeHooks: function () {
    11521665                var marker = this._marker;
     
    11601673                var layer = e.target;
    11611674                layer.edited = true;
    1162                 this._map.fire('draw:editmove', {layer: layer});
     1675                this._map.fire(L.Draw.Event.EDITMOVE, { layer: layer });
    11631676        },
    11641677
    11651678        _toggleMarkerHighlight: function () {
    11661679                var icon = this._marker._icon;
    1167 
    11681680
    11691681                // Don't do anything if this layer is a marker but doesn't have an icon. Markers
     
    12111723
    12121724
     1725
    12131726L.Edit = L.Edit || {};
    12141727
    1215 /*
    1216  * L.Edit.Poly is an editing handler for polylines and polygons.
     1728/**
     1729 * @class L.Edit.Polyline
     1730 * @aka L.Edit.Poly
     1731 * @aka Edit.Poly
    12171732 */
    12181733L.Edit.Poly = L.Handler.extend({
    12191734        options: {},
    12201735
     1736        // @method initialize(): void
    12211737        initialize: function (poly, options) {
    12221738
     
    12351751        // between 0.7.x and 1.0+
    12361752        _defaultShape: function () {
    1237                 if (!L.Polyline._flat) { return this._poly._latlngs; }
     1753                if (!L.Polyline._flat) {
     1754                        return this._poly._latlngs;
     1755                }
    12381756                return L.Polyline._flat(this._poly._latlngs) ? this._poly._latlngs : this._poly._latlngs[0];
    12391757        },
     
    12451763        },
    12461764
     1765        // @method addHooks(): void
     1766        // Add listener hooks to this handler
    12471767        addHooks: function () {
    12481768                this._initHandlers();
     
    12521772        },
    12531773
     1774        // @method removeHooks(): void
     1775        // Remove listener hooks from this handler
    12541776        removeHooks: function () {
    12551777                this._eachVertexHandler(function (handler) {
     
    12581780        },
    12591781
     1782        // @method updateMarkers(): void
     1783        // Fire an update for each vertex handler
    12601784        updateMarkers: function () {
    12611785                this._eachVertexHandler(function (handler) {
     
    12801804});
    12811805
     1806/**
     1807 * @class L.Edit.PolyVerticesEdit
     1808 * @aka Edit.PolyVerticesEdit
     1809 */
    12821810L.Edit.PolyVerticesEdit = L.Handler.extend({
    12831811        options: {
     
    12981826        },
    12991827
     1828        // @method intialize(): void
    13001829        initialize: function (poly, latlngs, options) {
    13011830                // if touch, switch to touch icon
     
    13171846        // between 0.7.x and 1.0+
    13181847        _defaultShape: function () {
    1319                 if (!L.Polyline._flat) { return this._latlngs; }
     1848                if (!L.Polyline._flat) {
     1849                        return this._latlngs;
     1850                }
    13201851                return L.Polyline._flat(this._latlngs) ? this._latlngs : this._latlngs[0];
    13211852        },
    13221853
     1854        // @method addHooks(): void
     1855        // Add listener hooks to this handler.
    13231856        addHooks: function () {
    13241857                var poly = this._poly;
     
    13441877        },
    13451878
     1879        // @method removeHooks(): void
     1880        // Remove listener hooks from this handler.
    13461881        removeHooks: function () {
    13471882                var poly = this._poly;
     
    13561891        },
    13571892
     1893        // @method updateMarkers(): void
     1894        // Clear markers and update their location
    13581895        updateMarkers: function () {
    13591896                this._markerGroup.clearLayers();
     
    14501987                this._poly.edited = true;
    14511988                this._poly.fire('edit');
    1452                 this._poly._map.fire('draw:editvertex', { layers: this._markerGroup });
     1989                this._poly._map.fire(L.Draw.Event.EDITVERTEX, { layers: this._markerGroup, poly: this._poly });
    14531990        },
    14541991
     
    14942031                                        if (tooltip) {
    14952032                                                tooltip.updateContent({
    1496                                                         text:  L.drawLocal.edit.handlers.edit.tooltip.text,
    1497                                                         subtext:  L.drawLocal.edit.handlers.edit.tooltip.subtext
     2033                                                        text: L.drawLocal.edit.handlers.edit.tooltip.text,
     2034                                                        subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext
    14982035                                                });
    14992036                                        }
     
    16792216
    16802217
     2218
    16812219L.Edit = L.Edit || {};
    1682 
     2220/**
     2221 * @class L.Edit.SimpleShape
     2222 * @aka Edit.SimpleShape
     2223 */
    16832224L.Edit.SimpleShape = L.Handler.extend({
    16842225        options: {
     
    17012242        },
    17022243
     2244        // @method intialize(): void
    17032245        initialize: function (shape, options) {
    17042246                // if touch, switch to touch icon
     
    17122254        },
    17132255
     2256        // @method addHooks(): void
     2257        // Add listener hooks to this handler
    17142258        addHooks: function () {
    17152259                var shape = this._shape;
     
    17282272        },
    17292273
     2274        // @method removeHooks(): void
     2275        // Remove listener hooks from this handler
    17302276        removeHooks: function () {
    17312277                var shape = this._shape;
     
    17482294        },
    17492295
     2296        // @method updateMarkers(): void
     2297        // Remove the edit markers from this layer
    17502298        updateMarkers: function () {
    17512299                this._markerGroup.clearLayers();
     
    18532401                                marker = e.target,
    18542402                                currentCornerIndex = marker._cornerIndex;
    1855                        
     2403
    18562404                        marker.setOpacity(0);
    18572405
     
    18612409                        this._toggleCornerMarkers(0, currentCornerIndex);
    18622410                }
    1863        
     2411
    18642412                this._shape.fire('editstart');
    18652413        },
     
    18772425
    18782426                this._shape.redraw();
    1879                
     2427
    18802428                // prevent touchcancel in IOS
    18812429                // e.preventDefault();
     
    19002448
    19012449
     2450
    19022451L.Edit = L.Edit || {};
    1903 
     2452/**
     2453 * @class L.Edit.Rectangle
     2454 * @aka Edit.Rectangle
     2455 * @inherits L.Edit.SimpleShape
     2456 */
    19042457L.Edit.Rectangle = L.Edit.SimpleShape.extend({
    19052458        _createMoveMarker: function () {
     
    19712524                this._repositionCornerMarkers();
    19722525
    1973                 this._map.fire('draw:editmove', {layer: this._shape});
     2526                this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
    19742527        },
    19752528
     
    19842537                this._moveMarker.setLatLng(bounds.getCenter());
    19852538
    1986                 this._map.fire('draw:editresize', {layer: this._shape});
     2539                this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
    19872540        },
    19882541
     
    20232576
    20242577
     2578
    20252579L.Edit = L.Edit || {};
    2026 
    2027 L.Edit.Circle = L.Edit.SimpleShape.extend({
     2580/**
     2581 * @class L.Edit.CircleMarker
     2582 * @aka Edit.Circle
     2583 * @inherits L.Edit.SimpleShape
     2584 */
     2585L.Edit.CircleMarker = L.Edit.SimpleShape.extend({
    20282586        _createMoveMarker: function () {
    20292587                var center = this._shape.getLatLng();
     
    20312589                this._moveMarker = this._createMarker(center, this.options.moveIcon);
    20322590        },
     2591
     2592        _createResizeMarker: function () {
     2593                // To avoid an undefined check in L.Edit.SimpleShape.removeHooks
     2594                this._resizeMarkers = [];
     2595        },
     2596
     2597        _move: function (latlng) {
     2598                if (this._resizeMarkers.length) {
     2599                                var resizemarkerPoint = this._getResizeMarkerPoint(latlng);
     2600                                // Move the resize marker
     2601                                this._resizeMarkers[0].setLatLng(resizemarkerPoint);
     2602                }
     2603
     2604                // Move the circle
     2605                this._shape.setLatLng(latlng);
     2606
     2607                this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
     2608        },
     2609});
     2610
     2611L.CircleMarker.addInitHook(function () {
     2612        if (L.Edit.CircleMarker) {
     2613                this.editing = new L.Edit.CircleMarker(this);
     2614
     2615                if (this.options.editable) {
     2616                        this.editing.enable();
     2617                }
     2618        }
     2619
     2620        this.on('add', function () {
     2621                if (this.editing && this.editing.enabled()) {
     2622                        this.editing.addHooks();
     2623                }
     2624        });
     2625
     2626        this.on('remove', function () {
     2627                if (this.editing && this.editing.enabled()) {
     2628                        this.editing.removeHooks();
     2629                }
     2630        });
     2631});
     2632
     2633
     2634
     2635L.Edit = L.Edit || {};
     2636/**
     2637 * @class L.Edit.Circle
     2638 * @aka Edit.Circle
     2639 * @inherits L.Edit.CircleMarker
     2640 */
     2641L.Edit.Circle = L.Edit.CircleMarker.extend({
    20332642
    20342643        _createResizeMarker: function () {
     
    20472656        },
    20482657
    2049         _move: function (latlng) {
    2050                 var resizemarkerPoint = this._getResizeMarkerPoint(latlng);
    2051 
    2052                 // Move the resize marker
    2053                 this._resizeMarkers[0].setLatLng(resizemarkerPoint);
    2054 
    2055                 // Move the circle
    2056                 this._shape.setLatLng(latlng);
    2057 
    2058                 this._map.fire('draw:editmove', {layer: this._shape});
    2059         },
    2060 
    20612658        _resize: function (latlng) {
    20622659                var moveLatLng = this._moveMarker.getLatLng(),
    2063                         radius = moveLatLng.distanceTo(latlng);
     2660                        radius = this._map.distance(moveLatLng, latlng);
    20642661
    20652662                this._shape.setRadius(radius);
    20662663
    2067                 this._map.fire('draw:editresize', {layer: this._shape});
     2664                this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
    20682665        }
    20692666});
     
    20912688});
    20922689
     2690
     2691
    20932692L.Map.mergeOptions({
    20942693        touchExtend: true
    20952694});
    20962695
     2696/**
     2697 * @class L.Map.TouchExtend
     2698 * @aka TouchExtend
     2699 */
    20972700L.Map.TouchExtend = L.Handler.extend({
    20982701
     2702        // @method initialize(): void
     2703        // Sets TouchExtend private accessor variables
    20992704        initialize: function (map) {
    21002705                this._map = map;
     
    21032708        },
    21042709
     2710        // @method addHooks(): void
     2711        // Adds dom listener events to the map container
    21052712        addHooks: function () {
    21062713                L.DomEvent.on(this._container, 'touchstart', this._onTouchStart, this);
     
    21192726        },
    21202727
     2728        // @method removeHooks(): void
     2729        // Removes dom listener events from the map container
    21212730        removeHooks: function () {
    21222731                L.DomEvent.off(this._container, 'touchstart', this._onTouchStart);
     
    21472756                } else if (e.pointerType === 'touch') {
    21482757                        touchEvent = e;
    2149             if (!this._filterClick(e)) {
    2150                 return;
    2151             }
     2758                        if (!this._filterClick(e)) {
     2759                                return;
     2760                        }
    21522761                } else {
    21532762                        return;
     
    21682777        },
    21692778
    2170     /** Borrowed from Leaflet and modified for bool ops **/
    2171     _filterClick: function (e) {
    2172         var timeStamp = (e.timeStamp || e.originalEvent.timeStamp),
    2173             elapsed = L.DomEvent._lastClick && (timeStamp - L.DomEvent._lastClick);
    2174 
    2175         // are they closer together than 500ms yet more than 100ms?
    2176         // Android typically triggers them ~300ms apart while multiple listeners
    2177         // on the same event should be triggered far faster;
    2178         // or check if click is simulated on the element, and if it is, reject any non-simulated events
    2179         if ((elapsed && elapsed > 100 && elapsed < 500) || (e.target._simulatedClick && !e._simulated)) {
    2180             L.DomEvent.stop(e);
    2181             return false;
    2182         }
    2183         L.DomEvent._lastClick = timeStamp;
    2184         return true;
    2185     },
     2779        /** Borrowed from Leaflet and modified for bool ops **/
     2780        _filterClick: function (e) {
     2781                var timeStamp = (e.timeStamp || e.originalEvent.timeStamp),
     2782                        elapsed = L.DomEvent._lastClick && (timeStamp - L.DomEvent._lastClick);
     2783
     2784                // are they closer together than 500ms yet more than 100ms?
     2785                // Android typically triggers them ~300ms apart while multiple listeners
     2786                // on the same event should be triggered far faster;
     2787                // or check if click is simulated on the element, and if it is, reject any non-simulated events
     2788                if ((elapsed && elapsed > 100 && elapsed < 500) || (e.target._simulatedClick && !e._simulated)) {
     2789                        L.DomEvent.stop(e);
     2790                        return false;
     2791                }
     2792                L.DomEvent._lastClick = timeStamp;
     2793                return true;
     2794        },
    21862795
    21872796        _onTouchStart: function (e) {
     
    22632872L.Map.addInitHook('addHandler', 'touchExtend', L.Map.TouchExtend);
    22642873
    2265 // This isn't full Touch support. This is just to get makers to also support dom touch events after creation
    2266 // #TODO: find a better way of getting markers to support touch.
     2874
     2875/**
     2876 * @class L.Marker.Touch
     2877 * @aka Marker.Touch
     2878 *
     2879 * This isn't full Touch support. This is just to get markers to also support dom touch events after creation
     2880 * #TODO: find a better way of getting markers to support touch.
     2881 */
    22672882L.Marker.Touch = L.Marker.extend({
    22682883
     
    22772892
    22782893        // This is an exact copy of https://github.com/Leaflet/Leaflet/blob/v0.7/src/layer/marker/Marker.js
    2279         // with the addition of the touch events on line 15.
     2894        // with the addition of the touch events
    22802895        _initInteractionLegacy: function () {
    22812896
     
    22872902
    22882903                var icon = this._icon,
    2289                         events = ['dblclick', 'mousedown', 'mouseover', 'mouseout', 'contextmenu', 'touchstart', 'touchend', 'touchmove'];
     2904                        events = ['dblclick',
     2905                                          'mousedown',
     2906                                          'mouseover',
     2907                                          'mouseout',
     2908                                          'contextmenu',
     2909                                          'touchstart',
     2910                                          'touchend',
     2911                                          'touchmove'];
    22902912                if (this._detectIE) {
    2291                         events.concat(['MSPointerDown', 'MSPointerUp', 'MSPointerMove', 'MSPointerCancel']);
     2913                        events.concat(['MSPointerDown',
     2914                                                   'MSPointerUp',
     2915                                                   'MSPointerMove',
     2916                                                   'MSPointerCancel']);
    22922917                } else {
    22932918                        events.concat(['touchcancel']);
     
    23102935                }
    23112936        },
     2937
    23122938        _detectIE: function () {
    23132939                var ua = window.navigator.userAgent;
     
    23382964
    23392965
    2340 /*
    2341  * L.LatLngUtil contains different utility functions for LatLngs.
     2966
     2967/**
     2968 * @class L.LatLngUtil
     2969 * @aka LatLngUtil
    23422970 */
    2343 
    23442971L.LatLngUtil = {
    23452972        // Clones a LatLngs[], returns [][]
     2973
     2974        // @method cloneLatLngs(LatLngs[]): L.LatLngs[]
     2975        // Clone the latLng point or points or nested points and return an array with those points
    23462976        cloneLatLngs: function (latlngs) {
    23472977                var clone = [];
     
    23572987        },
    23582988
     2989        // @method cloneLatLng(LatLng): L.LatLng
     2990        // Clone the latLng and return a new LatLng object.
    23592991        cloneLatLng: function (latlng) {
    23602992                return L.latLng(latlng.lat, latlng.lng);
     
    23632995
    23642996
     2997
     2998(function() {
     2999
     3000var defaultPrecision = {
     3001        km: 2,
     3002        ha: 2,
     3003        m: 0,
     3004        mi: 2,
     3005        ac: 2,
     3006        yd: 0,
     3007        ft: 0,
     3008        nm: 2
     3009};
     3010
     3011
     3012/**
     3013 * @class L.GeometryUtil
     3014 * @aka GeometryUtil
     3015 */
    23653016L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
    23663017        // Ported from the OpenLayers implementation. See https://github.com/openlayers/openlayers/blob/master/lib/OpenLayers/Geometry/LinearRing.js#L270
     3018
     3019        // @method geodesicArea(): number
    23673020        geodesicArea: function (latLngs) {
    23683021                var pointsCount = latLngs.length,
     
    23843037        },
    23853038
    2386         readableArea: function (area, isMetric) {
    2387                 var areaStr;
     3039        // @method formattedNumber(n, precision): string
     3040        // Returns n in specified number format (if defined) and precision
     3041        formattedNumber: function (n, precision) {
     3042                var formatted = parseFloat(n).toFixed(precision),
     3043                        format = L.drawLocal.format && L.drawLocal.format.numeric,
     3044                        delimiters = format && format.delimiters,
     3045                        thousands = delimiters && delimiters.thousands,
     3046                        decimal = delimiters && delimiters.decimal;
     3047
     3048                if (thousands || decimal) {
     3049                        var splitValue = formatted.split('.');
     3050                        formatted = thousands ? splitValue[0].replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1' + thousands) : splitValue[0];
     3051                        decimal = decimal || '.';
     3052                        if (splitValue.length > 1) {
     3053                                formatted = formatted + decimal + splitValue[1];
     3054                        }
     3055                }
     3056
     3057                return formatted;
     3058        },
     3059
     3060        // @method readableArea(area, isMetric, precision): string
     3061        // Returns a readable area string in yards or metric.
     3062        // The value will be rounded as defined by the precision option object.
     3063        readableArea: function (area, isMetric, precision) {
     3064                var areaStr,
     3065                        units,
     3066                        precision = L.Util.extend({}, defaultPrecision, precision);
    23883067
    23893068                if (isMetric) {
    2390                         if (area >= 10000) {
    2391                                 areaStr = (area * 0.0001).toFixed(2) + ' ha';
     3069                        units = ['ha', 'm'];
     3070                        type = typeof isMetric;
     3071                        if (type === 'string') {
     3072                                units = [isMetric];
     3073                        } else if (type !== 'boolean') {
     3074                                units = isMetric;
     3075                        }
     3076
     3077                        if (area >= 1000000 && units.indexOf('km') !== -1) {
     3078                                areaStr = L.GeometryUtil.formattedNumber(area * 0.000001, precision['km']) + ' km²';
     3079                        } else if (area >= 10000 && units.indexOf('ha') !== -1) {
     3080                                areaStr = L.GeometryUtil.formattedNumber(area * 0.0001, precision['ha']) + ' ha';
    23923081                        } else {
    2393                                 areaStr = area.toFixed(2) + ' m&sup2;';
     3082                                areaStr = L.GeometryUtil.formattedNumber(area, precision['m']) + ' m²';
    23943083                        }
    23953084                } else {
     
    23973086
    23983087                        if (area >= 3097600) { //3097600 square yards in 1 square mile
    2399                                 areaStr = (area / 3097600).toFixed(2) + ' mi&sup2;';
    2400                         } else if (area >= 4840) {//48040 square yards in 1 acre
    2401                                 areaStr = (area / 4840).toFixed(2) + ' acres';
     3088                                areaStr = L.GeometryUtil.formattedNumber(area / 3097600, precision['mi']) + ' mi²';
     3089                        } else if (area >= 4840) { //4840 square yards in 1 acre
     3090                                areaStr = L.GeometryUtil.formattedNumber(area / 4840, precision['ac']) + ' acres';
    24023091                        } else {
    2403                                 areaStr = Math.ceil(area) + ' yd&sup2;';
     3092                                areaStr = L.GeometryUtil.formattedNumber(area, precision['yd']) + ' yd²';
    24043093                        }
    24053094                }
     
    24083097        },
    24093098
    2410         readableDistance: function (distance, isMetric, useFeet) {
    2411                 var distanceStr;
     3099        // @method readableDistance(distance, units): string
     3100        // Converts a metric distance to one of [ feet, nauticalMile, metric or yards ] string
     3101        //
     3102        // @alternative
     3103        // @method readableDistance(distance, isMetric, useFeet, isNauticalMile, precision): string
     3104        // Converts metric distance to distance string.
     3105        // The value will be rounded as defined by the precision option object.
     3106        readableDistance: function (distance, isMetric, isFeet, isNauticalMile, precision) {
     3107                var distanceStr,
     3108                        units,
     3109                        precision = L.Util.extend({}, defaultPrecision, precision);
    24123110
    24133111                if (isMetric) {
     3112                        units = typeof isMetric == 'string' ? isMetric : 'metric';
     3113                } else if (isFeet) {
     3114                        units = 'feet';
     3115                } else if (isNauticalMile) {
     3116                        units = 'nauticalMile';
     3117                } else {
     3118                        units = 'yards';
     3119                }
     3120
     3121                switch (units) {
     3122                case 'metric':
    24143123                        // show metres when distance is < 1km, then show km
    24153124                        if (distance > 1000) {
    2416                                 distanceStr = (distance  / 1000).toFixed(2) + ' km';
     3125                                distanceStr = L.GeometryUtil.formattedNumber(distance / 1000, precision['km']) + ' km';
    24173126                        } else {
    2418                                 distanceStr = Math.ceil(distance) + ' m';
    2419                         }
    2420                 } else {
     3127                                distanceStr = L.GeometryUtil.formattedNumber(distance, precision['m']) + ' m';
     3128                        }
     3129                        break;
     3130                case 'feet':
     3131                        distance *= 1.09361 * 3;
     3132                        distanceStr = L.GeometryUtil.formattedNumber(distance, precision['ft']) + ' ft';
     3133
     3134                        break;
     3135                case 'nauticalMile':
     3136                        distance *= 0.53996;
     3137                        distanceStr = L.GeometryUtil.formattedNumber(distance / 1000, precision['nm']) + ' nm';
     3138                        break;
     3139                case 'yards':
     3140                default:
    24213141                        distance *= 1.09361;
    24223142
    24233143                        if (distance > 1760) {
    2424                                 distanceStr = (distance / 1760).toFixed(2) + ' miles';
     3144                                distanceStr = L.GeometryUtil.formattedNumber(distance / 1760, precision['mi']) + ' miles';
    24253145                        } else {
    2426                                 var suffix = ' yd';
    2427                                 if (useFeet) {
    2428                                         distance = distance * 3;
    2429                                         suffix = ' ft';
    2430                                 }
    2431                                 distanceStr = Math.ceil(distance) + suffix;
    2432                         }
    2433                 }
    2434 
     3146                                distanceStr = L.GeometryUtil.formattedNumber(distance, precision['yd']) + ' yd';
     3147                        }
     3148                        break;
     3149                }
    24353150                return distanceStr;
    24363151        }
    24373152});
    24383153
    2439 
     3154})();
     3155
     3156
     3157
     3158/**
     3159 * @class L.LineUtil
     3160 * @aka Util
     3161 * @aka L.Utils
     3162 */
    24403163L.Util.extend(L.LineUtil, {
     3164
     3165        // @method segmentsIntersect(): boolean
    24413166        // Checks to see if two line segments intersect. Does not handle degenerate cases.
    24423167        // http://compgeom.cs.uiuc.edu/~jeffe/teaching/373/notes/x06-sweepline.pdf
    24433168        segmentsIntersect: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2, /*Point*/ p3) {
    2444                 return  this._checkCounterclockwise(p, p2, p3) !==
    2445                                 this._checkCounterclockwise(p1, p2, p3) &&
    2446                                 this._checkCounterclockwise(p, p1, p2) !==
    2447                                 this._checkCounterclockwise(p, p1, p3);
     3169                return this._checkCounterclockwise(p, p2, p3) !==
     3170                           this._checkCounterclockwise(p1, p2, p3) &&
     3171                           this._checkCounterclockwise(p, p1, p2) !==
     3172                           this._checkCounterclockwise(p, p1, p3);
    24483173        },
    24493174
     
    24543179});
    24553180
     3181
     3182/**
     3183 * @class L.Polyline
     3184 * @aka Polyline
     3185 */
    24563186L.Polyline.include({
     3187
     3188        // @method intersects(): boolean
    24573189        // Check to see if this polyline has any linesegments that intersect.
    24583190        // NOTE: does not support detecting intersection for degenerate cases.
     
    24793211        },
    24803212
     3213        // @method newLatLngIntersects(): boolean
    24813214        // Check for intersection if new latlng was added to this polyline.
    24823215        // NOTE: does not support detecting intersection for degenerate cases.
     
    24903223        },
    24913224
     3225        // @method newPointIntersects(): boolean
    24923226        // Check for intersection if new point was added to this polyline.
    24933227        // newPoint must be a layer point.
     
    25543288
    25553289
     3290
     3291/**
     3292 * @class L.Polygon
     3293 * @aka Polygon
     3294 */
    25563295L.Polygon.include({
     3296
     3297        // @method intersects(): boolean
    25573298        // Checks a polygon for any intersecting line segments. Ignores holes.
    25583299        intersects: function () {
     
    25833324
    25843325
     3326
     3327/**
     3328 * @class L.Control.Draw
     3329 * @aka L.Draw
     3330 */
    25853331L.Control.Draw = L.Control.extend({
    25863332
     3333        // Options
    25873334        options: {
    25883335                position: 'topleft',
     
    25913338        },
    25923339
     3340        // @method initialize(): void
     3341        // Initializes draw control, toolbars from the options
    25933342        initialize: function (options) {
    25943343                if (L.version < '0.7') {
     
    26233372        },
    26243373
     3374        // @method onAdd(): container
     3375        // Adds the toolbar container to the map
    26253376        onAdd: function (map) {
    26263377                var container = L.DomUtil.create('div', 'leaflet-draw'),
     
    26503401        },
    26513402
     3403        // @method onRemove(): void
     3404        // Removes the toolbars from the map toolbar container
    26523405        onRemove: function () {
    26533406                for (var toolbarId in this._toolbars) {
     
    26583411        },
    26593412
     3413        // @method setDrawingOptions(options): void
     3414        // Sets options to all toolbar instances
    26603415        setDrawingOptions: function (options) {
    26613416                for (var toolbarId in this._toolbars) {
     
    26903445
    26913446
     3447
     3448/**
     3449 * @class L.Draw.Toolbar
     3450 * @aka Toolbar
     3451 *
     3452 * The toolbar class of the API — it is used to create the ui
     3453 * This will be depreciated
     3454 *
     3455 * @example
     3456 *
     3457 * ```js
     3458 *    var toolbar = L.Toolbar();
     3459 *    toolbar.addToolbar(map);
     3460 * ```
     3461 *
     3462 * ### Disabling a toolbar
     3463 *
     3464 * If you do not want a particular toolbar in your app you can turn it off by setting the toolbar to false.
     3465 *
     3466 * ```js
     3467 *      var drawControl = new L.Control.Draw({
     3468 *          draw: false,
     3469 *          edit: {
     3470 *              featureGroup: editableLayers
     3471 *          }
     3472 *      });
     3473 * ```
     3474 *
     3475 * ### Disabling a toolbar item
     3476 *
     3477 * If you want to turn off a particular toolbar item, set it to false. The following disables drawing polygons and
     3478 * markers. It also turns off the ability to edit layers.
     3479 *
     3480 * ```js
     3481 *      var drawControl = new L.Control.Draw({
     3482 *          draw: {
     3483 *              polygon: false,
     3484 *              marker: false
     3485 *          },
     3486 *          edit: {
     3487 *              featureGroup: editableLayers,
     3488 *              edit: false
     3489 *          }
     3490 *      });
     3491 * ```
     3492 */
    26923493L.Toolbar = L.Class.extend({
    26933494        includes: [L.Mixin.Events],
    26943495
     3496        // @section Methods for modifying the toolbar
     3497
     3498        // @method initialize(options): void
     3499        // Toolbar constructor
    26953500        initialize: function (options) {
    26963501                L.setOptions(this, options);
     
    27013506        },
    27023507
     3508        // @method enabled(): boolean
     3509        // Gets a true/false of whether the toolbar is enabled
    27033510        enabled: function () {
    27043511                return this._activeMode !== null;
    27053512        },
    27063513
     3514        // @method disable(): void
     3515        // Disables the toolbar
    27073516        disable: function () {
    2708                 if (!this.enabled()) { return; }
     3517                if (!this.enabled()) {
     3518                        return;
     3519                }
    27093520
    27103521                this._activeMode.handler.disable();
    27113522        },
    27123523
     3524        // @method addToolbar(map): L.DomUtil
     3525        // Adds the toolbar to the map and returns the toolbar dom element
    27133526        addToolbar: function (map) {
    27143527                var container = L.DomUtil.create('div', 'leaflet-draw-section'),
     
    27513564        },
    27523565
     3566        // @method removeToolbar(): void
     3567        // Removes the toolbar and drops the handler event listeners
    27533568        removeToolbar: function () {
    27543569                // Dispose each handler
     
    28083623        },
    28093624
     3625        /* Detect iOS based on browser User Agent, based on:
     3626         * http://stackoverflow.com/a/9039885 */
     3627        _detectIOS: function () {
     3628                var iOS = (/iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream);
     3629                return iOS;
     3630        },
     3631
    28103632        _createButton: function (options) {
    28113633
    28123634                var link = L.DomUtil.create('a', options.className || '', options.container);
     3635                // Screen reader tag
     3636                var sr = L.DomUtil.create('span', 'sr-only', options.container);
     3637
    28133638                link.href = '#';
     3639                link.appendChild(sr);
     3640
     3641                if (options.title) {
     3642                        link.title = options.title;
     3643                        sr.innerHTML = options.title;
     3644                }
    28143645
    28153646                if (options.text) {
    28163647                        link.innerHTML = options.text;
    2817                 }
    2818 
    2819                 if (options.title) {
    2820                         link.title = options.title;
    2821                 }
     3648                        sr.innerHTML = options.text;
     3649                }
     3650
     3651                /* iOS does not use click events */
     3652                var buttonEvent = this._detectIOS() ? 'touchstart' : 'click';
    28223653
    28233654                L.DomEvent
     
    28253656                        .on(link, 'mousedown', L.DomEvent.stopPropagation)
    28263657                        .on(link, 'dblclick', L.DomEvent.stopPropagation)
     3658                        .on(link, 'touchstart', L.DomEvent.stopPropagation)
    28273659                        .on(link, 'click', L.DomEvent.preventDefault)
    2828                         .on(link, 'click', options.callback, options.context);
     3660                        .on(link, buttonEvent, options.callback, options.context);
    28293661
    28303662                return link;
     
    28323664
    28333665        _disposeButton: function (button, callback) {
     3666                /* iOS does not use click events */
     3667                var buttonEvent = this._detectIOS() ? 'touchstart' : 'click';
     3668
    28343669                L.DomEvent
    28353670                        .off(button, 'click', L.DomEvent.stopPropagation)
    28363671                        .off(button, 'mousedown', L.DomEvent.stopPropagation)
    28373672                        .off(button, 'dblclick', L.DomEvent.stopPropagation)
     3673                        .off(button, 'touchstart', L.DomEvent.stopPropagation)
    28383674                        .off(button, 'click', L.DomEvent.preventDefault)
    2839                         .off(button, 'click', callback);
     3675                        .off(button, buttonEvent, callback);
    28403676        },
    28413677
     
    29383774
    29393775
     3776
    29403777L.Draw = L.Draw || {};
     3778/**
     3779 * @class L.Draw.Tooltip
     3780 * @aka Tooltip
     3781 *
     3782 * The tooltip class — it is used to display the tooltip while drawing
     3783 * This will be depreciated
     3784 *
     3785 * @example
     3786 *
     3787 * ```js
     3788 *    var tooltip = L.Draw.Tooltip();
     3789 * ```
     3790 *
     3791 */
    29413792L.Draw.Tooltip = L.Class.extend({
     3793
     3794        // @section Methods for modifying draw state
     3795
     3796        // @method initialize(map): void
     3797        // Tooltip constructor
    29423798        initialize: function (map) {
    29433799                this._map = map;
    29443800                this._popupPane = map._panes.popupPane;
    2945 
    2946                 this._container = map.options.drawControlTooltips ? L.DomUtil.create('div', 'leaflet-draw-tooltip', this._popupPane) : null;
     3801                this._visible = false;
     3802
     3803                this._container = map.options.drawControlTooltips ?
     3804                        L.DomUtil.create('div', 'leaflet-draw-tooltip', this._popupPane) : null;
    29473805                this._singleLineLabel = false;
    29483806
     
    29503808        },
    29513809
     3810        // @method dispose(): void
     3811        // Remove Tooltip DOM and unbind events
    29523812        dispose: function () {
    29533813                this._map.off('mouseout', this._onMouseOut, this);
     
    29593819        },
    29603820
     3821        // @method updateContent(labelText): this
     3822        // Changes the tooltip text to string in function call
    29613823        updateContent: function (labelText) {
    29623824                if (!this._container) {
     
    29763838
    29773839                this._container.innerHTML =
    2978                         (labelText.subtext.length > 0 ? '<span class="leaflet-draw-tooltip-subtext">' + labelText.subtext + '</span>' + '<br />' : '') +
     3840                        (labelText.subtext.length > 0 ?
     3841                        '<span class="leaflet-draw-tooltip-subtext">' + labelText.subtext + '</span>' + '<br />' : '') +
    29793842                        '<span>' + labelText.text + '</span>';
    29803843
     3844                if (!labelText.text && !labelText.subtext) {
     3845                        this._visible = false;
     3846                        this._container.style.visibility = 'hidden';
     3847                } else {
     3848                        this._visible = true;
     3849                        this._container.style.visibility = 'inherit';
     3850                }
     3851
    29813852                return this;
    29823853        },
    29833854
     3855        // @method updatePosition(latlng): this
     3856        // Changes the location of the tooltip
    29843857        updatePosition: function (latlng) {
    29853858                var pos = this._map.latLngToLayerPoint(latlng),
     
    29873860
    29883861                if (this._container) {
    2989                         tooltipContainer.style.visibility = 'inherit';
     3862                        if (this._visible) {
     3863                                tooltipContainer.style.visibility = 'inherit';
     3864                        }
    29903865                        L.DomUtil.setPosition(tooltipContainer, pos);
    29913866                }
     
    29943869        },
    29953870
     3871        // @method showAsError(): this
     3872        // Applies error class to tooltip
    29963873        showAsError: function () {
    29973874                if (this._container) {
     
    30013878        },
    30023879
     3880        // @method removeError(): this
     3881        // Removes the error class from the tooltip
    30033882        removeError: function () {
    30043883                if (this._container) {
     
    30163895
    30173896
     3897
     3898/**
     3899 * @class L.DrawToolbar
     3900 * @aka Toolbar
     3901 */
    30183902L.DrawToolbar = L.Toolbar.extend({
    30193903
     
    30273911                rectangle: {},
    30283912                circle: {},
    3029                 marker: {}
    3030         },
    3031 
     3913                marker: {},
     3914                circlemarker: {}
     3915        },
     3916
     3917        // @method initialize(): void
    30323918        initialize: function (options) {
    30333919                // Ensure that the options are merged correctly since L.extend is only shallow
     
    30443930        },
    30453931
     3932        // @method getModeHandlers(): object
     3933        // Get mode handlers information
    30463934        getModeHandlers: function (map) {
    30473935                return [
     
    30703958                                handler: new L.Draw.Marker(map, this.options.marker),
    30713959                                title: L.drawLocal.draw.toolbar.buttons.marker
     3960                        },
     3961                        {
     3962                                enabled: this.options.circlemarker,
     3963                                handler: new L.Draw.CircleMarker(map, this.options.circlemarker),
     3964                                title: L.drawLocal.draw.toolbar.buttons.circlemarker
    30723965                        }
    30733966                ];
    30743967        },
    30753968
    3076         // Get the actions part of the toolbar
     3969        // @method getActions(): object
     3970        // Get action information
    30773971        getActions: function (handler) {
    30783972                return [
     
    31003994        },
    31013995
     3996        // @method setOptions(): void
     3997        // Sets the options to the toolbar
    31023998        setOptions: function (options) {
    31033999                L.setOptions(this, options);
     
    31124008
    31134009
     4010
    31144011/*L.Map.mergeOptions({
    3115         editControl: true
    3116 });*/
    3117 
     4012 editControl: true
     4013 });*/
     4014/**
     4015 * @class L.EditToolbar
     4016 * @aka EditToolbar
     4017 */
    31184018L.EditToolbar = L.Toolbar.extend({
    31194019        statics: {
     
    31394039        },
    31404040
     4041        // @method intialize(): void
    31414042        initialize: function (options) {
    31424043                // Need to set this manually since null is an acceptable value here
     
    31624063        },
    31634064
     4065        // @method getModeHandlers(): object
     4066        // Get mode handlers information
    31644067        getModeHandlers: function (map) {
    31654068                var featureGroup = this.options.featureGroup;
     
    31704073                                        featureGroup: featureGroup,
    31714074                                        selectedPathOptions: this.options.edit.selectedPathOptions,
    3172                                         poly : this.options.poly
     4075                                        poly: this.options.poly
    31734076                                }),
    31744077                                title: L.drawLocal.edit.toolbar.buttons.edit
     
    31844087        },
    31854088
    3186         getActions: function () {
    3187                 return [
     4089        // @method getActions(): object
     4090        // Get actions information
     4091        getActions: function (handler) {
     4092                var actions = [
    31884093                        {
    31894094                                title: L.drawLocal.edit.toolbar.actions.save.title,
     
    31994104                        }
    32004105                ];
    3201         },
    3202 
     4106
     4107                if (handler.removeAllLayers) {
     4108                         actions.push({
     4109                 title: L.drawLocal.edit.toolbar.actions.clearAll.title,
     4110                 text: L.drawLocal.edit.toolbar.actions.clearAll.text,
     4111                 callback: this._clearAllLayers,
     4112                 context: this
     4113             });
     4114                }
     4115
     4116                return actions;
     4117        },
     4118
     4119        // @method addToolbar(map): L.DomUtil
     4120        // Adds the toolbar to the map
    32034121        addToolbar: function (map) {
    32044122                var container = L.Toolbar.prototype.addToolbar.call(this, map);
     
    32114129        },
    32124130
     4131        // @method removeToolbar(): void
     4132        // Removes the toolbar from the map
    32134133        removeToolbar: function () {
    32144134                this.options.featureGroup.off('layeradd layerremove', this._checkDisabled, this);
     
    32174137        },
    32184138
     4139        // @method disable(): void
     4140        // Disables the toolbar
    32194141        disable: function () {
    3220                 if (!this.enabled()) { return; }
     4142                if (!this.enabled()) {
     4143                        return;
     4144                }
    32214145
    32224146                this._activeMode.handler.revertLayers();
     
    32324156        },
    32334157
     4158        _clearAllLayers:function(){
     4159                this._activeMode.handler.removeAllLayers();
     4160                if (this._activeMode) {
     4161                        this._activeMode.handler.disable();
     4162                }
     4163        },
     4164
    32344165        _checkDisabled: function () {
    32354166                var featureGroup = this.options.featureGroup,
     
    32494180                                'title',
    32504181                                hasLayers ?
    3251                                 L.drawLocal.edit.toolbar.buttons.edit
    3252                                 : L.drawLocal.edit.toolbar.buttons.editDisabled
     4182                                        L.drawLocal.edit.toolbar.buttons.edit
     4183                                        : L.drawLocal.edit.toolbar.buttons.editDisabled
    32534184                        );
    32544185                }
     
    32664197                                'title',
    32674198                                hasLayers ?
    3268                                 L.drawLocal.edit.toolbar.buttons.remove
    3269                                 : L.drawLocal.edit.toolbar.buttons.removeDisabled
     4199                                        L.drawLocal.edit.toolbar.buttons.remove
     4200                                        : L.drawLocal.edit.toolbar.buttons.removeDisabled
    32704201                        );
    32714202                }
     
    32744205
    32754206
     4207
     4208/**
     4209 * @class L.EditToolbar.Edit
     4210 * @aka EditToolbar.Edit
     4211 */
    32764212L.EditToolbar.Edit = L.Handler.extend({
    32774213        statics: {
     
    32814217        includes: L.Mixin.Events,
    32824218
     4219        // @method intialize(): void
    32834220        initialize: function (map, options) {
    32844221                L.Handler.prototype.initialize.call(this, map);
     
    32994236        },
    33004237
     4238        // @method enable(): void
     4239        // Enable the edit toolbar
    33014240        enable: function () {
    33024241                if (this._enabled || !this._hasAvailableLayers()) {
    33034242                        return;
    33044243                }
    3305                 this.fire('enabled', {handler: this.type});
    3306                         //this disable other handlers
    3307 
    3308                 this._map.fire('draw:editstart', { handler: this.type });
    3309                         //allow drawLayer to be updated before beginning edition.
     4244                this.fire('enabled', { handler: this.type });
     4245                //this disable other handlers
     4246
     4247                this._map.fire(L.Draw.Event.EDITSTART, { handler: this.type });
     4248                //allow drawLayer to be updated before beginning edition.
    33104249
    33114250                L.Handler.prototype.enable.call(this);
     
    33154254        },
    33164255
     4256        // @method disable(): void
     4257        // Disable the edit toolbar
    33174258        disable: function () {
    3318                 if (!this._enabled) { return; }
     4259                if (!this._enabled) {
     4260                        return;
     4261                }
    33194262                this._featureGroup
    33204263                        .off('layeradd', this._enableLayerEdit, this)
    33214264                        .off('layerremove', this._disableLayerEdit, this);
    33224265                L.Handler.prototype.disable.call(this);
    3323                 this._map.fire('draw:editstop', { handler: this.type });
    3324                 this.fire('disabled', {handler: this.type});
    3325         },
    3326 
     4266                this._map.fire(L.Draw.Event.EDITSTOP, { handler: this.type });
     4267                this.fire('disabled', { handler: this.type });
     4268        },
     4269
     4270        // @method addHooks(): void
     4271        // Add listener hooks for this handler
    33274272        addHooks: function () {
    33284273                var map = this._map;
     
    33484293                                .on('touchmove', this._onMouseMove, this)
    33494294                                .on('MSPointerMove', this._onMouseMove, this)
    3350                                 .on('draw:editvertex', this._updateTooltip, this);
    3351                 }
    3352         },
    3353 
     4295                                .on(L.Draw.Event.EDITVERTEX, this._updateTooltip, this);
     4296                }
     4297        },
     4298
     4299        // @method removeHooks(): void
     4300        // Remove listener hooks for this handler
    33544301        removeHooks: function () {
    33554302                if (this._map) {
     
    33674314                                .off('touchmove', this._onMouseMove, this)
    33684315                                .off('MSPointerMove', this._onMouseMove, this)
    3369                                 .off('draw:editvertex', this._updateTooltip, this);
    3370                 }
    3371         },
    3372 
     4316                                .off(L.Draw.Event.EDITVERTEX, this._updateTooltip, this);
     4317                }
     4318        },
     4319
     4320        // @method revertLayers(): void
     4321        // Revert each layer's geometry changes
    33734322        revertLayers: function () {
    33744323                this._featureGroup.eachLayer(function (layer) {
     
    33774326        },
    33784327
     4328        // @method save(): void
     4329        // Save the layer geometries
    33794330        save: function () {
    33804331                var editedLayers = new L.LayerGroup();
     
    33854336                        }
    33864337                });
    3387                 this._map.fire('draw:edited', {layers: editedLayers});
     4338                this._map.fire(L.Draw.Event.EDITED, { layers: editedLayers });
    33884339        },
    33894340
     
    34024353                                        radius: layer.getRadius()
    34034354                                };
    3404                         } else if (layer instanceof L.Marker) { // Marker
     4355                        } else if (layer instanceof L.Marker || layer instanceof L.CircleMarker) { // Marker
    34054356                                this._uneditedLayerProps[id] = {
    34064357                                        latlng: L.LatLngUtil.cloneLatLng(layer.getLatLng())
     
    34314382                                layer.setLatLng(this._uneditedLayerProps[id].latlng);
    34324383                                layer.setRadius(this._uneditedLayerProps[id].radius);
    3433                         } else if (layer instanceof L.Marker) { // Marker
     4384                        } else if (layer instanceof L.Marker || layer instanceof L.CircleMarker) { // Marker or CircleMarker
    34344385                                layer.setLatLng(this._uneditedLayerProps[id].latlng);
    34354386                        }
     
    35254476                var layer = e.target;
    35264477                layer.edited = true;
    3527                 this._map.fire('draw:editmove', {layer: layer});
     4478                this._map.fire(L.Draw.Event.EDITMOVE, { layer: layer });
    35284479        },
    35294480
     
    35414492
    35424493
     4494
     4495/**
     4496 * @class L.EditToolbar.Delete
     4497 * @aka EditToolbar.Delete
     4498 */
    35434499L.EditToolbar.Delete = L.Handler.extend({
    35444500        statics: {
     
    35484504        includes: L.Mixin.Events,
    35494505
     4506        // @method intialize(): void
    35504507        initialize: function (map, options) {
    35514508                L.Handler.prototype.initialize.call(this, map);
     
    35644521        },
    35654522
     4523        // @method enable(): void
     4524        // Enable the delete toolbar
    35664525        enable: function () {
    35674526                if (this._enabled || !this._hasAvailableLayers()) {
    35684527                        return;
    35694528                }
    3570                 this.fire('enabled', { handler: this.type});
    3571 
    3572                 this._map.fire('draw:deletestart', { handler: this.type });
     4529                this.fire('enabled', { handler: this.type });
     4530
     4531                this._map.fire(L.Draw.Event.DELETESTART, { handler: this.type });
    35734532
    35744533                L.Handler.prototype.enable.call(this);
     
    35794538        },
    35804539
     4540        // @method disable(): void
     4541        // Disable the delete toolbar
    35814542        disable: function () {
    3582                 if (!this._enabled) { return; }
     4543                if (!this._enabled) {
     4544                        return;
     4545                }
    35834546
    35844547                this._deletableLayers
     
    35884551                L.Handler.prototype.disable.call(this);
    35894552
    3590                 this._map.fire('draw:deletestop', { handler: this.type });
    3591 
    3592                 this.fire('disabled', { handler: this.type});
    3593         },
    3594 
     4553                this._map.fire(L.Draw.Event.DELETESTOP, { handler: this.type });
     4554
     4555                this.fire('disabled', { handler: this.type });
     4556        },
     4557
     4558        // @method addHooks(): void
     4559        // Add listener hooks to this handler
    35954560        addHooks: function () {
    35964561                var map = this._map;
     
    36094574        },
    36104575
     4576        // @method removeHooks(): void
     4577        // Remove listener hooks from this handler
    36114578        removeHooks: function () {
    36124579                if (this._map) {
     
    36214588        },
    36224589
     4590        // @method revertLayers(): void
     4591        // Revert the deleted layers back to their prior state.
    36234592        revertLayers: function () {
    36244593                // Iterate of the deleted layers and add them back into the featureGroup
     
    36294598        },
    36304599
     4600        // @method save(): void
     4601        // Save deleted layers
    36314602        save: function () {
    3632                 this._map.fire('draw:deleted', { layers: this._deletedLayers });
     4603                this._map.fire(L.Draw.Event.DELETED, { layers: this._deletedLayers });
     4604        },
     4605
     4606        // @method removeAllLayers(): void
     4607        // Remove all delateable layers
     4608        removeAllLayers: function(){
     4609                // Iterate of the delateable layers and add remove them
     4610                this._deletableLayers.eachLayer(function (layer) {
     4611                        this._removeLayer({layer:layer});
     4612                }, this);
     4613                this.save();
    36334614        },
    36344615
     
    36684649
    36694650
     4651
    36704652}(window, document));
     4653//# sourceMappingURL=leaflet.draw-src.map
  • _plugins_/gis_geometries/lib/leaflet-draw/leaflet.draw.css

    r100142 r108378  
    1 /* ================================================================== */
    2 /* Toolbars
    3 /* ================================================================== */
    4 
    5 .leaflet-draw-section {
    6         position: relative;
    7 }
    8 
    9 .leaflet-draw-toolbar {
    10         margin-top: 12px;
    11 }
    12 
    13 .leaflet-draw-toolbar-top {
    14         margin-top: 0;
    15 }
    16 
    17 .leaflet-draw-toolbar-notop a:first-child {
    18         border-top-right-radius: 0;
    19 }
    20 
    21 .leaflet-draw-toolbar-nobottom a:last-child {
    22         border-bottom-right-radius: 0;
    23 }
    24 
    25 .leaflet-draw-toolbar a {
    26         background-image: url('images/spritesheet.png');
    27         background-image: linear-gradient(transparent, transparent), url('images/spritesheet.svg');
    28         background-repeat: no-repeat;
    29         background-size: 270px 30px;
    30 }
    31 
    32 .leaflet-retina .leaflet-draw-toolbar a {
    33         background-image: url('images/spritesheet-2x.png');
    34         background-image: linear-gradient(transparent, transparent), url('images/spritesheet.svg');
    35 }
    36 
    37 .leaflet-draw a {
    38         display: block;
    39         text-align: center;
    40         text-decoration: none;
    41 }
    42 
    43 /* ================================================================== */
    44 /* Toolbar actions menu
    45 /* ================================================================== */
    46 
    47 .leaflet-draw-actions {
    48         display: none;
    49         list-style: none;
    50         margin: 0;
    51         padding: 0;
    52         position: absolute;
    53         left: 26px; /* leaflet-draw-toolbar.left + leaflet-draw-toolbar.width */
    54         top: 0;
    55         white-space: nowrap;
    56 }
    57 
    58 .leaflet-touch .leaflet-draw-actions {
    59         left: 32px;
    60 }
    61 
    62 .leaflet-right .leaflet-draw-actions {
    63         right:26px;
    64         left:auto;
    65 }
    66 
    67 .leaflet-touch .leaflet-right .leaflet-draw-actions {
    68         right:32px;
    69         left:auto;
    70 }
    71 
    72 .leaflet-draw-actions li {
    73         display: inline-block;
    74 }
    75 
    76 .leaflet-draw-actions li:first-child a {
    77         border-left: none;
    78 }
    79 
    80 .leaflet-draw-actions li:last-child a {
    81         -webkit-border-radius: 0 4px 4px 0;
    82                 border-radius: 0 4px 4px 0;
    83 }
    84 
    85 .leaflet-right .leaflet-draw-actions li:last-child a {
    86         -webkit-border-radius: 0;
    87                 border-radius: 0;
    88 }
    89 
    90 .leaflet-right .leaflet-draw-actions li:first-child a {
    91         -webkit-border-radius: 4px 0 0 4px;
    92                 border-radius: 4px 0 0 4px;
    93 }
    94 
    95 .leaflet-draw-actions a {
    96         background-color: #919187;
    97         border-left: 1px solid #AAA;
    98         color: #FFF;
    99         font: 11px/19px "Helvetica Neue", Arial, Helvetica, sans-serif;
    100         line-height: 28px;
    101         text-decoration: none;
    102         padding-left: 10px;
    103         padding-right: 10px;
    104         height: 28px;
    105 }
    106 
    107 .leaflet-touch .leaflet-draw-actions a {
    108         font-size: 12px;
    109         line-height: 30px;
    110         height: 30px;
    111 }
    112 
    113 .leaflet-draw-actions-bottom {
    114         margin-top: 0;
    115 }
    116 
    117 .leaflet-draw-actions-top {
    118         margin-top: 1px;
    119 }
    120 
    121 .leaflet-draw-actions-top a,
    122 .leaflet-draw-actions-bottom a {
    123         height: 27px;
    124         line-height: 27px;
    125 }
    126 
    127 .leaflet-draw-actions a:hover {
    128         background-color: #A0A098;
    129 }
    130 
    131 .leaflet-draw-actions-top.leaflet-draw-actions-bottom a {
    132         height: 26px;
    133         line-height: 26px;
    134 }
    135 
    136 /* ================================================================== */
    137 /* Draw toolbar
    138 /* ================================================================== */
    139 
    140 .leaflet-draw-toolbar .leaflet-draw-draw-polyline {
    141         background-position: -2px -2px;
    142 }
    143 
    144 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-polyline {
    145         background-position: 0 -1px;
    146 }
    147 
    148 .leaflet-draw-toolbar .leaflet-draw-draw-polygon {
    149         background-position: -31px -2px;
    150 }
    151 
    152 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-polygon {
    153         background-position: -29px -1px;
    154 }
    155 
    156 .leaflet-draw-toolbar .leaflet-draw-draw-rectangle {
    157         background-position: -62px -2px;
    158 }
    159 
    160 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-rectangle {
    161         background-position: -60px -1px;
    162 }
    163 
    164 .leaflet-draw-toolbar .leaflet-draw-draw-circle {
    165         background-position: -92px -2px;
    166 }
    167 
    168 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-circle {
    169         background-position: -90px -1px;
    170 }
    171 
    172 .leaflet-draw-toolbar .leaflet-draw-draw-marker {
    173         background-position: -122px -2px;
    174 }
    175 
    176 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-marker {
    177         background-position: -120px -1px;
    178 }
    179 
    180 /* ================================================================== */
    181 /* Edit toolbar
    182 /* ================================================================== */
    183 
    184 .leaflet-draw-toolbar .leaflet-draw-edit-edit {
    185         background-position: -152px -2px;
    186 }
    187 
    188 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-edit {
    189         background-position: -150px -1px;
    190 }
    191 
    192 .leaflet-draw-toolbar .leaflet-draw-edit-remove {
    193         background-position: -182px -2px;
    194 }
    195 
    196 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-remove {
    197         background-position: -180px -1px;
    198 }
    199 
    200 .leaflet-draw-toolbar .leaflet-draw-edit-edit.leaflet-disabled {
    201         background-position: -212px -2px;
    202 }
    203 
    204 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-edit.leaflet-disabled {
    205         background-position: -210px -1px;
    206 }
    207 
    208 .leaflet-draw-toolbar .leaflet-draw-edit-remove.leaflet-disabled {
    209         background-position: -242px -2px;
    210 }
    211 
    212 .leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-remove.leaflet-disabled {
    213         background-position: -240px -2px;
    214 }
    215 
    216 /* ================================================================== */
    217 /* Drawing styles
    218 /* ================================================================== */
    219 
    220 .leaflet-mouse-marker {
    221         background-color: #fff;
    222         cursor: crosshair;
    223 }
    224 
    225 .leaflet-draw-tooltip {
    226         background: rgb(54, 54, 54);
    227         background: rgba(0, 0, 0, 0.5);
    228         border: 1px solid transparent;
    229         -webkit-border-radius: 4px;
    230                 border-radius: 4px;
    231         color: #fff;
    232         font: 12px/18px "Helvetica Neue", Arial, Helvetica, sans-serif;
    233         margin-left: 20px;
    234         margin-top: -21px;
    235         padding: 4px 8px;
    236         position: absolute;
    237         visibility: hidden;
    238         white-space: nowrap;
    239         z-index: 6;
    240 }
    241 
    242 .leaflet-draw-tooltip:before {
    243         border-right: 6px solid black;
    244         border-right-color: rgba(0, 0, 0, 0.5);
    245         border-top: 6px solid transparent;
    246         border-bottom: 6px solid transparent;
    247         content: "";
    248         position: absolute;
    249         top: 7px;
    250         left: -7px;
    251 }
    252 
    253 .leaflet-error-draw-tooltip {
    254         background-color: #F2DEDE;
    255         border: 1px solid #E6B6BD;
    256         color: #B94A48;
    257 }
    258 
    259 .leaflet-error-draw-tooltip:before {
    260         border-right-color: #E6B6BD;
    261 }
    262 
    263 .leaflet-draw-tooltip-single {
    264         margin-top: -12px
    265 }
    266 
    267 .leaflet-draw-tooltip-subtext {
    268         color: #f8d5e4;
    269 }
    270 
    271 .leaflet-draw-guide-dash {
    272         font-size: 1%;
    273         opacity: 0.6;
    274         position: absolute;
    275         width: 5px;
    276         height: 5px;
    277 }
    278 
    279 /* ================================================================== */
    280 /* Edit styles
    281 /* ================================================================== */
    282 
    283 .leaflet-edit-marker-selected {
    284         background-color: rgba(254, 87, 161, 0.1);
    285         border: 4px dashed rgba(254, 87, 161, 0.6);
    286         -webkit-border-radius: 4px;
    287                 border-radius: 4px;
    288         box-sizing: content-box;
    289 }
    290 
    291 .leaflet-edit-move {
    292         cursor: move;
    293 }
    294 
    295 .leaflet-edit-resize {
    296         cursor: pointer;
    297 }
    298 
    299 /* ================================================================== */
    300 /* Old IE styles
    301 /* ================================================================== */
    302 
    303 .leaflet-oldie .leaflet-draw-toolbar {
    304         border: 1px solid #999;
    305 }
     1.leaflet-draw-section{position:relative}.leaflet-draw-toolbar{margin-top:12px}.leaflet-draw-toolbar-top{margin-top:0}.leaflet-draw-toolbar-notop a:first-child{border-top-right-radius:0}.leaflet-draw-toolbar-nobottom a:last-child{border-bottom-right-radius:0}.leaflet-draw-toolbar a{background-image:url('images/spritesheet.png');background-image:linear-gradient(transparent,transparent),url('images/spritesheet.svg');background-repeat:no-repeat;background-size:300px 30px;background-clip:padding-box}.leaflet-retina .leaflet-draw-toolbar a{background-image:url('images/spritesheet-2x.png');background-image:linear-gradient(transparent,transparent),url('images/spritesheet.svg')}
     2.leaflet-draw a{display:block;text-align:center;text-decoration:none}.leaflet-draw a .sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.leaflet-draw-actions{display:none;list-style:none;margin:0;padding:0;position:absolute;left:26px;top:0;white-space:nowrap}.leaflet-touch .leaflet-draw-actions{left:32px}.leaflet-right .leaflet-draw-actions{right:26px;left:auto}.leaflet-touch .leaflet-right .leaflet-draw-actions{right:32px;left:auto}.leaflet-draw-actions li{display:inline-block}
     3.leaflet-draw-actions li:first-child a{border-left:0}.leaflet-draw-actions li:last-child a{-webkit-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.leaflet-right .leaflet-draw-actions li:last-child a{-webkit-border-radius:0;border-radius:0}.leaflet-right .leaflet-draw-actions li:first-child a{-webkit-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.leaflet-draw-actions a{background-color:#919187;border-left:1px solid #AAA;color:#FFF;font:11px/19px "Helvetica Neue",Arial,Helvetica,sans-serif;line-height:28px;text-decoration:none;padding-left:10px;padding-right:10px;height:28px}
     4.leaflet-touch .leaflet-draw-actions a{font-size:12px;line-height:30px;height:30px}.leaflet-draw-actions-bottom{margin-top:0}.leaflet-draw-actions-top{margin-top:1px}.leaflet-draw-actions-top a,.leaflet-draw-actions-bottom a{height:27px;line-height:27px}.leaflet-draw-actions a:hover{background-color:#a0a098}.leaflet-draw-actions-top.leaflet-draw-actions-bottom a{height:26px;line-height:26px}.leaflet-draw-toolbar .leaflet-draw-draw-polyline{background-position:-2px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-polyline{background-position:0 -1px}
     5.leaflet-draw-toolbar .leaflet-draw-draw-polygon{background-position:-31px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-polygon{background-position:-29px -1px}.leaflet-draw-toolbar .leaflet-draw-draw-rectangle{background-position:-62px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-rectangle{background-position:-60px -1px}.leaflet-draw-toolbar .leaflet-draw-draw-circle{background-position:-92px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-circle{background-position:-90px -1px}
     6.leaflet-draw-toolbar .leaflet-draw-draw-marker{background-position:-122px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-marker{background-position:-120px -1px}.leaflet-draw-toolbar .leaflet-draw-draw-circlemarker{background-position:-273px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-draw-circlemarker{background-position:-271px -1px}.leaflet-draw-toolbar .leaflet-draw-edit-edit{background-position:-152px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-edit{background-position:-150px -1px}
     7.leaflet-draw-toolbar .leaflet-draw-edit-remove{background-position:-182px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-remove{background-position:-180px -1px}.leaflet-draw-toolbar .leaflet-draw-edit-edit.leaflet-disabled{background-position:-212px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-edit.leaflet-disabled{background-position:-210px -1px}.leaflet-draw-toolbar .leaflet-draw-edit-remove.leaflet-disabled{background-position:-242px -2px}.leaflet-touch .leaflet-draw-toolbar .leaflet-draw-edit-remove.leaflet-disabled{background-position:-240px -2px}
     8.leaflet-mouse-marker{background-color:#fff;cursor:crosshair}.leaflet-draw-tooltip{background:#363636;background:rgba(0,0,0,0.5);border:1px solid transparent;-webkit-border-radius:4px;border-radius:4px;color:#fff;font:12px/18px "Helvetica Neue",Arial,Helvetica,sans-serif;margin-left:20px;margin-top:-21px;padding:4px 8px;position:absolute;visibility:hidden;white-space:nowrap;z-index:6}.leaflet-draw-tooltip:before{border-right:6px solid black;border-right-color:rgba(0,0,0,0.5);border-top:6px solid transparent;border-bottom:6px solid transparent;content:"";position:absolute;top:7px;left:-7px}
     9.leaflet-error-draw-tooltip{background-color:#f2dede;border:1px solid #e6b6bd;color:#b94a48}.leaflet-error-draw-tooltip:before{border-right-color:#e6b6bd}.leaflet-draw-tooltip-single{margin-top:-12px}.leaflet-draw-tooltip-subtext{color:#f8d5e4}.leaflet-draw-guide-dash{font-size:1%;opacity:.6;position:absolute;width:5px;height:5px}.leaflet-edit-marker-selected{background-color:rgba(254,87,161,0.1);border:4px dashed rgba(254,87,161,0.6);-webkit-border-radius:4px;border-radius:4px;box-sizing:content-box}
     10.leaflet-edit-move{cursor:move}.leaflet-edit-resize{cursor:pointer}.leaflet-oldie .leaflet-draw-toolbar{border:1px solid #999}
  • _plugins_/gis_geometries/paquet.xml

    r104890 r108378  
    22        prefix="gisgeom"
    33        categorie="divers"
    4         version="1.11.0"
     4        version="1.11.1"
    55        etat="stable"
    66        compatibilite="[3.0.0;3.2.*]"
  • _plugins_/gis_geometries/saisies/carte.html

    r107764 r108378  
    386386                                marker: [(#ENV{boutons}|table_valeur{marker}|=={non}|?{false,true})],
    387387                                circle: false,
     388                                circlemarker: false,
    388389                                rectangle: [(#ENV{boutons}|table_valeur{rectangle}|=={non}|?{false,''})][
    389390                                (#ENV{boutons}|table_valeur{rectangle}|=={non}|non){
Note: See TracChangeset for help on using the changeset viewer.