Changeset 118846 in spip-zone


Ignore:
Timestamp:
Dec 2, 2019, 10:29:25 AM (7 days ago)
Author:
bruno@…
Message:

version 4.47.14 : maj des libs des plugins

Location:
_plugins_/gis/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/gis/trunk/lib/leaflet/plugins/Bing.js

    r99251 r118846  
     1// Bing maps API: https://docs.microsoft.com/en-us/bingmaps/rest-services/
     2
    13L.BingLayer = L.TileLayer.extend({
    24        options: {
    3                 subdomains: [0, 1, 2, 3],
    4                 type: 'Aerial',
     5                // imagerySet: https://docs.microsoft.com/en-us/bingmaps/rest-services/imagery/get-imagery-metadata#template-parameters
     6                // supported:
     7                // - Aerial, AerialWithLabels (Deprecated), AerialWithLabelsOnDemand
     8                // - Road (Deprecated), RoadOnDemand
     9                // - CanvasDark, CanvasLight, CanvasGray
     10                // not supported: Birdseye*, Streetside
     11                imagerySet: 'Aerial', // to be changed on next major version!!
     12
     13                // https://docs.microsoft.com/en-us/bingmaps/rest-services/common-parameters-and-types/supported-culture-codes
     14                culture: '',
     15
     16                // https://docs.microsoft.com/en-us/bingmaps/articles/custom-map-styles-in-bing-maps#custom-map-styles-in-the-rest-and-tile-services
     17                style: '',
     18
     19                // https://blogs.bing.com/maps/2015/02/12/high-ppi-maps-now-available-in-the-bing-maps-ajax-control
     20                // not documented in REST API docs, but working
     21                // warning: deprecated imagery sets may not support some values (depending also on zoom level)
     22                retinaDpi: 'd2',
     23
    524                attribution: 'Bing',
    6                 culture: ''
     25                minZoom: 1,
     26                maxZoom: 21
     27                // Actual `maxZoom` value may be less, depending on imagery set / coverage area
     28                // - 19~20 for all 'Aerial*'
     29                // - 20 for 'Road' (Deprecated)
    730        },
    831
    932        initialize: function (key, options) {
    10                 L.Util.setOptions(this, options);
     33                if (typeof key === 'object') {
     34                        options = key;
     35                        key = false;
     36                }
     37                L.TileLayer.prototype.initialize.call(this, null, options);
    1138
    12                 this._key = key;
    13                 this._url = null;
    14                 this._providers = [];
    15                 this.metaRequested = false;
     39                options = this.options;
     40                options.key = options.key || options.bingMapsKey;
     41                options.imagerySet = options.imagerySet || options.type;
     42                if (key) { options.key = key; }
    1643        },
    1744
     
    2047                for (var i = z; i > 0; i--) {
    2148                        var digit = 0;
    22                         var mask = 1 << (i - 1);
    23                         if ((x & mask) !== 0) digit += 1;
    24                         if ((y & mask) !== 0) digit += 2;
     49                        var mask = 1 << i - 1;
     50                        if ((x & mask) !== 0) { digit += 1; }
     51                        if ((y & mask) !== 0) { digit += 2; }
    2552                        quad = quad + digit;
    2653                }
     
    2855        },
    2956
    30         getTileUrl: function (tilePoint) {
    31                 var zoom = this._getZoomForUrl();
    32                 var subdomains = this.options.subdomains,
    33                         s = this.options.subdomains[Math.abs((tilePoint.x + tilePoint.y) % subdomains.length)];
    34                 return this._url.replace('{subdomain}', s)
    35                                 .replace('{quadkey}', this.tile2quad(tilePoint.x, tilePoint.y, zoom))
    36                                 .replace('{culture}', this.options.culture);
     57        getTileUrl: function (coords) {
     58                var data = {
     59                        subdomain: this._getSubdomain(coords),
     60                        quadkey: this.tile2quad(coords.x, coords.y, this._getZoomForUrl()),
     61                        culture: this.options.culture // compatibility for deprecated imagery sets ('Road' etc)
     62                };
     63                return L.Util.template(this._url, data);
     64        },
     65
     66        callRestService: function (request, callback, context) {
     67                context = context || this;
     68                var uniqueName = '_bing_metadata_' + L.Util.stamp(this);
     69                while (window[uniqueName]) { uniqueName += '_'; }
     70                request += '&jsonp=' + uniqueName;
     71                var script = document.createElement('script');
     72                script.setAttribute('type', 'text/javascript');
     73                script.setAttribute('src', request);
     74                window[uniqueName] = function (response) {
     75                        delete window[uniqueName];
     76                        script.remove();
     77                        if (response.errorDetails) {
     78                                throw new Error(response.errorDetails);
     79                        }
     80                        callback.call(context, response);
     81                };
     82                document.body.appendChild(script);
     83        },
     84
     85        _makeApiUrl: function (restApi, resourcePath, query) {
     86                var baseAPIparams = {
     87                        version: 'v1',
     88                        restApi: restApi,
     89                        resourcePath: resourcePath
     90                };
     91                query = L.extend({
     92                        // errorDetail: true, // seems no effect
     93                        key: this.options.key
     94                }, query);
     95
     96                // https://docs.microsoft.com/en-us/bingmaps/rest-services/common-parameters-and-types/base-url-structure
     97                var template = 'https://dev.virtualearth.net/REST/{version}/{restApi}/{resourcePath}'; // ?queryParameters&key=BingMapsKey
     98                return L.Util.template(template, baseAPIparams) + L.Util.getParamString(query);
    3799        },
    38100
    39101        loadMetadata: function () {
    40                 if (this.metaRequested) return;
     102                if (this.metaRequested) { return; }
    41103                this.metaRequested = true;
    42                 var _this = this;
    43                 var cbid = '_bing_metadata_' + L.Util.stamp(this);
    44                 window[cbid] = function (meta) {
    45                         window[cbid] = undefined;
    46                         var e = document.getElementById(cbid);
    47                         e.parentNode.removeChild(e);
    48                         if (meta.errorDetails) {
    49                                 throw new Error(meta.errorDetails);
    50                                 return;
     104                var options = this.options;
     105                // https://docs.microsoft.com/en-us/bingmaps/rest-services/imagery/get-imagery-metadata#complete-metadata-urls
     106                var request = this._makeApiUrl('Imagery/Metadata', options.imagerySet, {
     107                        UriScheme: 'https',
     108                        include: 'ImageryProviders',
     109                        culture: options.culture,
     110                        style: options.style
     111                });
     112                this.callRestService(request, function (meta) {
     113                        var r = meta.resourceSets[0].resources[0];
     114                        if (!r.imageUrl) { throw new Error('imageUrl not found in response'); }
     115                        if (r.imageUrlSubdomains) { options.subdomains = r.imageUrlSubdomains; }
     116                        this._providers = r.imageryProviders ? this._prepAttrBounds(r.imageryProviders) : [];
     117                        this._attributions = [];
     118                        this._url = r.imageUrl;
     119                        if (options.retinaDpi && options.detectRetina && options.zoomOffset) {
     120                                this._url += '&dpi=' + options.retinaDpi;
    51121                        }
    52                         _this.initMetadata(meta);
    53                 };
    54                 var urlScheme = (document.location.protocol === 'file:') ? 'http' : document.location.protocol.slice(0, -1);
    55                 var url = urlScheme + '://dev.virtualearth.net/REST/v1/Imagery/Metadata/'
    56                                         + this.options.type + '?include=ImageryProviders&jsonp=' + cbid +
    57                                         '&key=' + this._key + '&UriScheme=' + urlScheme;
    58                 var script = document.createElement('script');
    59                 script.type = 'text/javascript';
    60                 script.src = url;
    61                 script.id = cbid;
    62                 document.getElementsByTagName('head')[0].appendChild(script);
     122                        this.fire('load', {meta: meta});
     123                        if (this._map) { this._update(); }
     124                });
    63125        },
    64126
    65         initMetadata: function (meta) {
    66                 var r = meta.resourceSets[0].resources[0];
    67                 this.options.subdomains = r.imageUrlSubdomains;
    68                 this._url = r.imageUrl;
    69                 if (r.imageryProviders) {
    70                         for (var i = 0; i < r.imageryProviders.length; i++) {
    71                                 var p = r.imageryProviders[i];
    72                                 for (var j = 0; j < p.coverageAreas.length; j++) {
    73                                         var c = p.coverageAreas[j];
    74                                         var coverage = {zoomMin: c.zoomMin, zoomMax: c.zoomMax, active: false};
    75                                         var bounds = new L.LatLngBounds(
    76                                                         new L.LatLng(c.bbox[0]+0.01, c.bbox[1]+0.01),
    77                                                         new L.LatLng(c.bbox[2]-0.01, c.bbox[3]-0.01)
    78                                         );
    79                                         coverage.bounds = bounds;
    80                                         coverage.attrib = p.attribution;
    81                                         this._providers.push(coverage);
    82                                 }
    83                         }
    84                 }
    85                 this._update();
     127        _prepAttrBounds: function (providers) {
     128                providers.forEach(function (provider) {
     129                        provider.coverageAreas.forEach(function (area) {
     130                                area.bounds = L.latLngBounds(
     131                                        [area.bbox[0], area.bbox[1]],
     132                                        [area.bbox[2], area.bbox[3]]
     133                                );
     134                        });
     135                });
     136                return providers;
    86137        },
    87138
    88         _update: function () {
    89                 if (this._url === null || !this._map) return;
     139        _update: function (center) {
     140                if (!this._url) { return; }
     141                L.GridLayer.prototype._update.call(this, center);
    90142                this._update_attribution();
    91                 L.TileLayer.prototype._update.apply(this, []);
    92143        },
    93144
    94         _update_attribution: function () {
    95                 var bounds = L.latLngBounds(this._map.getBounds().getSouthWest().wrap(),this._map.getBounds().getNorthEast().wrap());
    96                 var zoom = this._map.getZoom();
    97                 for (var i = 0; i < this._providers.length; i++) {
    98                         var p = this._providers[i];
    99                         if ((zoom <= p.zoomMax && zoom >= p.zoomMin) &&
    100                                         bounds.intersects(p.bounds)) {
    101                                 if (!p.active && this._map.attributionControl)
    102                                         this._map.attributionControl.addAttribution(p.attrib);
    103                                 p.active = true;
     145        _update_attribution: function (remove) {
     146                var attributionControl = this._map.attributionControl;
     147                if (!attributionControl) {
     148                        this._attributions = {}; return;
     149                }
     150                var bounds = this._map.getBounds();
     151                bounds = L.latLngBounds(bounds.getSouthWest().wrap(), bounds.getNorthEast().wrap());
     152                var zoom = this._getZoomForUrl();
     153                var attributions = this._providers.map(function (provider) {
     154                        return remove ? false : provider.coverageAreas.some(function (area) {
     155                                return zoom <= area.zoomMax && zoom >= area.zoomMin &&
     156                                        bounds.intersects(area.bounds);
     157                        });
     158                });
     159                attributions.forEach(function (a,i) {
     160                        if (a == this._attributions[i]) { // eslint-disable-line eqeqeq
     161                                return;
     162                        } else if (a) {
     163                                attributionControl.addAttribution(this._providers[i].attribution);
    104164                        } else {
    105                                 if (p.active && this._map.attributionControl)
    106                                         this._map.attributionControl.removeAttribution(p.attrib);
    107                                 p.active = false;
     165                                attributionControl.removeAttribution(this._providers[i].attribution);
    108166                        }
    109                 }
     167                }, this);
     168                this._attributions = attributions;
    110169        },
    111170
    112171        onAdd: function (map) {
     172                // Note: Metadata could be loaded earlier, on layer initialize,
     173                //       but according to docs even such request is billable:
     174                //       https://docs.microsoft.com/en-us/bingmaps/getting-started/bing-maps-dev-center-help/understanding-bing-maps-transactions#rest-services
     175                //       That's why it's important to defer it till BingLayer is actually added to map
    113176                this.loadMetadata();
    114                 L.TileLayer.prototype.onAdd.apply(this, [map]);
     177                L.GridLayer.prototype.onAdd.call(this, map);
    115178        },
    116179
    117180        onRemove: function (map) {
    118                 for (var i = 0; i < this._providers.length; i++) {
    119                         var p = this._providers[i];
    120                         if (p.active && this._map.attributionControl) {
    121                                 this._map.attributionControl.removeAttribution(p.attrib);
    122                                 p.active = false;
    123                         }
    124                 }
    125                 L.TileLayer.prototype.onRemove.apply(this, [map]);
     181                if (this._providers) { this._update_attribution(true); }
     182                L.GridLayer.prototype.onRemove.call(this, map);
    126183        }
    127184});
    128185
    129186L.bingLayer = function (key, options) {
    130     return new L.BingLayer(key, options);
     187        return new L.BingLayer(key, options);
    131188};
  • _plugins_/gis/trunk/lib/leaflet/plugins/Control.FullScreen.js

    r108377 r118846  
    2727
    2828                this._createButton(this.options.title, className, content, container, this.toggleFullScreen, this);
     29                this._map.fullscreenControl = this;
    2930
    3031                this._map.on('enterFullscreen exitFullscreen', this._toggleTitle, this);
    3132
    3233                return container;
     34        },
     35       
     36        onRemove: function (map) {
     37                L.DomEvent
     38                        .off(this.link, 'click', L.DomEvent.stopPropagation)
     39                        .off(this.link, 'click', L.DomEvent.preventDefault)
     40                        .off(this.link, 'click', this.toggleFullScreen, this);
     41               
     42                L.DomEvent
     43                        .off(this._container, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
     44                        .off(this._container, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
     45                        .off(this._container, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, this);
     46               
     47                L.DomEvent
     48                        .off(document, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
     49                        .off(document, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
     50                        .off(document, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, this);
    3351        },
    3452       
     
    3957                this.link.innerHTML = content;
    4058
    41                 L.DomEvent
    42                         .addListener(this.link, 'click', L.DomEvent.stopPropagation)
    43                         .addListener(this.link, 'click', L.DomEvent.preventDefault)
    44                         .addListener(this.link, 'click', fn, context);
    45                
    46                 L.DomEvent
    47                         .addListener(container, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
    48                         .addListener(container, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
    49                         .addListener(container, fullScreenApi.fullScreenEventName, this._handleEscKey, context);
    50                
    51                 L.DomEvent
    52                         .addListener(document, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
    53                         .addListener(document, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
    54                         .addListener(document, fullScreenApi.fullScreenEventName, this._handleEscKey, context);
     59                this.link.setAttribute('role', 'button');
     60                this.link.setAttribute('aria-label', title);
     61
     62                L.DomEvent
     63                        .on(this.link, 'click', L.DomEvent.stopPropagation)
     64                        .on(this.link, 'click', L.DomEvent.preventDefault)
     65                        .on(this.link, 'click', fn, context);
     66               
     67                L.DomEvent
     68                        .on(container, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
     69                        .on(container, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
     70                        .on(container, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, context);
     71               
     72                L.DomEvent
     73                        .on(document, fullScreenApi.fullScreenEventName, L.DomEvent.stopPropagation)
     74                        .on(document, fullScreenApi.fullScreenEventName, L.DomEvent.preventDefault)
     75                        .on(document, fullScreenApi.fullScreenEventName, this._handleFullscreenChange, context);
    5576
    5677                return this.link;
     
    6283                if (map._isFullscreen) {
    6384                        if (fullScreenApi.supportsFullScreen && !this.options.forcePseudoFullscreen) {
    64                                 fullScreenApi.cancelFullScreen(this.options.fullscreenElement ? this.options.fullscreenElement : map._container);
     85                                fullScreenApi.cancelFullScreen();
    6586                        } else {
    6687                                L.DomUtil.removeClass(this.options.fullscreenElement ? this.options.fullscreenElement : map._container, 'leaflet-pseudo-fullscreen');
    6788                        }
    68                         map.invalidateSize();
    6989                        map.fire('exitFullscreen');
    7090                        map._exitFired = true;
     
    7797                                L.DomUtil.addClass(this.options.fullscreenElement ? this.options.fullscreenElement : map._container, 'leaflet-pseudo-fullscreen');
    7898                        }
    79                         map.invalidateSize();
    8099                        map.fire('enterFullscreen');
    81100                        map._isFullscreen = true;
     
    87106        },
    88107       
    89         _handleEscKey: function () {
     108        _handleFullscreenChange: function () {
    90109                var map = this._map;
    91                 if (!fullScreenApi.isFullScreen(map) && !map._exitFired) {
     110                map.invalidateSize();
     111                if (!fullScreenApi.isFullScreen() && !map._exitFired) {
    92112                        map.fire('exitFullscreen');
    93113                        map._exitFired = true;
     
    97117});
    98118
     119L.Map.include({
     120        toggleFullscreen: function () {
     121                this.fullscreenControl.toggleFullScreen();
     122        }
     123});
     124
    99125L.Map.addInitHook(function () {
    100126        if (this.options.fullscreenControl) {
    101                 this.fullscreenControl = L.control.fullscreen(this.options.fullscreenControlOptions);
    102                 this.addControl(this.fullscreenControl);
     127                this.addControl(L.control.fullscreen(this.options.fullscreenControlOptions));
    103128        }
    104129});
  • _plugins_/gis/trunk/lib/leaflet/plugins/Control.MiniMap.js

    r100141 r118846  
    2121
    2222        var MiniMap = L.Control.extend({
     23
     24                includes: L.Evented ? L.Evented.prototype : L.Mixin.Events,
     25
    2326                options: {
    2427                        position: 'bottomright',
     
    3437                        collapsedWidth: 19,
    3538                        collapsedHeight: 19,
    36                         aimingRectOptions: {color: '#ff7800', weight: 1, clickable: false},
    37                         shadowRectOptions: {color: '#000000', weight: 1, clickable: false, opacity: 0, fillOpacity: 0},
     39                        aimingRectOptions: {color: '#ff7800', weight: 1, interactive: false},
     40                        shadowRectOptions: {color: '#000000', weight: 1, interactive: false, opacity: 0, fillOpacity: 0},
    3841                        strings: {hideText: 'Hide MiniMap', showText: 'Show MiniMap'},
    3942                        mapOptions: {}  // Allows definition / override of Leaflet map options.
     
    4447                        L.Util.setOptions(this, options);
    4548                        // Make sure the aiming rects are non-clickable even if the user tries to set them clickable (most likely by forgetting to specify them false)
    46                         this.options.aimingRectOptions.clickable = false;
    47                         this.options.shadowRectOptions.clickable = false;
     49                        this.options.aimingRectOptions.interactive = false;
     50                        this.options.shadowRectOptions.interactive = false;
    4851                        this._layer = layer;
    4952                },
     
    191194                        }
    192195                        this._minimized = true;
     196                        this._onToggle();
    193197                },
    194198
     
    204208                        }
    205209                        this._minimized = false;
     210                        this._onToggle();
    206211                },
    207212
     
    314319                _isDefined: function (value) {
    315320                        return typeof value !== 'undefined';
     321                },
     322
     323                _onToggle: function () {
     324                        L.Util.requestAnimFrame(function () {
     325                                L.DomEvent.on(this._container, 'transitionend', this._fireToggleEvents, this);
     326                                if (!L.Browser.any3d) {
     327                                        L.Util.requestAnimFrame(this._fireToggleEvents, this);
     328                                }
     329                        }, this);
     330                },
     331
     332                _fireToggleEvents: function () {
     333                        L.DomEvent.off(this._container, 'transitionend', this._fireToggleEvents, this);
     334                        var data = { minimized: this._minimized };
     335                        this.fire(this._minimized ? 'minimize' : 'restore', data);
     336                        this.fire('toggle', data);
    316337                }
    317338        });
  • _plugins_/gis/trunk/lib/leaflet/plugins/Leaflet.GoogleMutant.js

    r108377 r118846  
    4848
    4949                this._imagesPerTile = (this.options.type === 'hybrid') ? 2 : 1;
     50
     51                this._boundOnMutatedImage = this._onMutatedImage.bind(this);
    5052        },
    5153
     
    6163
    6264                        map.on('viewreset', this._reset, this);
    63                         map.on('move', this._update, this);
     65                        if (this.options.updateWhenIdle) {
     66                                map.on('moveend', this._update, this);
     67                        } else {
     68                                map.on('move', this._update, this);
     69                        }
    6470                        map.on('zoomend', this._handleZoomAnim, this);
    6571                        map.on('resize', this._resize, this);
     
    8995        onRemove: function (map) {
    9096                L.GridLayer.prototype.onRemove.call(this, map);
     97                this._observer.disconnect();
    9198                map._container.removeChild(this._mutantContainer);
    92                 this._mutantContainer = undefined;
    9399
    94100                google.maps.event.clearListeners(map, 'idle');
     
    96102                map.off('viewreset', this._reset, this);
    97103                map.off('move', this._update, this);
     104                map.off('moveend', this._update, this);
    98105                map.off('zoomend', this._handleZoomAnim, this);
    99106                map.off('resize', this._resize, this);
     
    107114        getAttribution: function () {
    108115                return this.options.attribution;
    109         },
    110 
    111         setOpacity: function (opacity) {
    112                 this.options.opacity = opacity;
    113                 if (opacity < 1) {
    114                         L.DomUtil.setOpacity(this._mutantContainer, opacity);
    115                 }
    116116        },
    117117
     
    148148                        this._mutantContainer.style.zIndex = '800'; //leaflet map pane at 400, controls at 1000
    149149                        this._mutantContainer.style.pointerEvents = 'none';
    150 
    151                         this._map.getContainer().appendChild(this._mutantContainer);
    152                 }
     150                       
     151                        L.DomEvent.off(this._mutantContainer);
     152
     153                }
     154                this._map.getContainer().appendChild(this._mutantContainer);
    153155
    154156                this.setOpacity(this.options.opacity);
     
    160162        _initMutant: function () {
    161163                if (!this._ready || !this._mutantContainer) return;
     164
     165                if (this._mutant) {
     166                        // reuse old _mutant, just make sure it has the correct size
     167                        this._resize();
     168                        return;
     169                }
     170
    162171                this._mutantCenter = new google.maps.LatLng(0, 0);
    163172
     
    194203//              console.log('Gonna observe', node);
    195204
    196                 var observer = new MutationObserver(this._onMutations.bind(this));
     205                if (!this._observer)
     206                        this._observer = new MutationObserver(this._onMutations.bind(this));
    197207
    198208                // pass in the target node, as well as the observer options
    199                 observer.observe(node, { childList: true, subtree: true });
     209                this._observer.observe(node, { childList: true, subtree: true });
     210
     211                // if we are reusing an old _mutantContainer, we must manually detect
     212                // all existing tiles in it
     213                Array.prototype.forEach.call(
     214                        node.querySelectorAll('img'),
     215                        this._boundOnMutatedImage
     216                );
    200217        },
    201218
     
    209226                                        this._onMutatedImage(node);
    210227                                } else if (node instanceof HTMLElement) {
    211                                         Array.prototype.forEach.call(node.querySelectorAll('img'), this._onMutatedImage.bind(this));
     228                                        Array.prototype.forEach.call(
     229                                                node.querySelectorAll('img'),
     230                                                this._boundOnMutatedImage
     231                                        );
     232
     233                                        // Check for, and remove, the "Google Maps can't load correctly" div.
     234                                        // You *are* loading correctly, you dumbwit.
     235                                        if (node.style.backgroundColor === 'white') {
     236                                                L.DomUtil.remove(node);
     237                                        }
     238                   
     239                                        // Check for, and remove, the "For development purposes only" divs on the aerial/hybrid tiles.
     240                                        if (node.textContent.indexOf('For development purposes only') === 0) {
     241                                                L.DomUtil.remove(node);
     242                                        }
     243                   
     244                                        // Check for, and remove, the "Sorry, we have no imagery here"
     245                                        // empty <div>s. The [style*="text-align: center"] selector
     246                                        // avoids matching the attribution notice.
     247                                        // This empty div doesn't have a reference to the tile
     248                                        // coordinates, so it's not possible to mark the tile as
     249                                        // failed.
     250                                        Array.prototype.forEach.call(
     251                                                node.querySelectorAll('div[draggable=false][style*="text-align: center"]'),
     252                                                L.DomUtil.remove
     253                                        );
    212254                                }
    213255                        }
  • _plugins_/gis/trunk/lib/leaflet/plugins/leaflet-providers.js

    r115391 r118846  
    193193                                Landscape: 'landscape',
    194194                                Outdoors: 'outdoors',
    195                                 Pioneer: 'pioneer'
     195                                Pioneer: 'pioneer',
     196                                MobileAtlas: 'mobile-atlas',
     197                                Neighbourhood: 'neighbourhood'
     198                        }
     199                },
     200                CyclOSM: {
     201                        url: 'https://dev.{s}.tile.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png',
     202                        options: {
     203                                maxZoom: 20,
     204                                attribution: '<a href="https://github.com/cyclosm/cyclosm-cartocss-style/releases" title="CyclOSM - Open Bicycle render">CyclOSM</a> | Map data: {attribution.OpenStreetMap}'
    196205                        }
    197206                },
     
    314323                                        }
    315324                                },
     325                                TerrainLabels: {
     326                                        options: {
     327                                                variant: 'terrain-labels',
     328                                                minZoom: 0,
     329                                                maxZoom: 18
     330                                        }
     331                                },
    316332                                TopOSMRelief: {
    317333                                        url: 'https://stamen-tiles-{s}.a.ssl.fastly.net/{variant}/{z}/{x}/{y}.{ext}',
     
    329345                                        }
    330346                                }
     347                        }
     348                },
     349                TomTom: {
     350                        url: 'https://{s}.api.tomtom.com/map/1/tile/{variant}/{style}/{z}/{x}/{y}.{ext}?key={apikey}',
     351                        options: {
     352                                variant: 'basic',
     353                                maxZoom: 22,
     354                                attribution:
     355                                        '<a href="https://tomtom.com" target="_blank">&copy;  1992 - ' + new Date().getFullYear() + ' TomTom.</a> ',
     356                                subdomains: 'abcd',
     357                                style: 'main',
     358                                ext: 'png',
     359                                apikey: '<insert your API key here>',
     360                        },
     361                        variants: {
     362                                Basic: 'basic',
     363                                Hybrid: 'hybrid',
     364                                Labels: 'labels'
    331365                        }
    332366                },
     
    470504                                normalDayTransit: 'normal.day.transit',
    471505                                normalDayTransitMobile: 'normal.day.transit.mobile',
     506                                normalDayTraffic: {
     507                                        options: {
     508                                                variant: 'normal.traffic.day',
     509                                                base: 'traffic',
     510                                                type: 'traffictile'
     511                                        }
     512                                },
    472513                                normalNight: 'normal.night',
    473514                                normalNightMobile: 'normal.night.mobile',
     
    518559                                                base: 'aerial',
    519560                                                variant: 'hybrid.grey.day'
     561                                        }
     562                                },
     563                                hybridDayTraffic: {
     564                                        options: {
     565                                                variant: 'hybrid.traffic.day',
     566                                                base: 'traffic',
     567                                                type: 'traffictile'
    520568                                        }
    521569                                },
  • _plugins_/gis/trunk/lib/leaflet/plugins/leaflet.markercluster-src.js

    r108377 r118846  
    11/*
    2  Leaflet.markercluster, Provides Beautiful Animated Marker Clustering functionality for Leaflet, a JS library for interactive maps.
    3  https://github.com/Leaflet/Leaflet.markercluster
    4  (c) 2012-2013, Dave Leaver, smartrak
    5 */
    6 (function (window, document, undefined) {/*
     2 * Leaflet.markercluster 1.4.1+master.94f9815,
     3 * Provides Beautiful Animated Marker Clustering functionality for Leaflet, a JS library for interactive maps.
     4 * https://github.com/Leaflet/Leaflet.markercluster
     5 * (c) 2012-2017, Dave Leaver, smartrak
     6 */
     7(function (global, factory) {
     8        typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     9        typeof define === 'function' && define.amd ? define(['exports'], factory) :
     10        (factory((global.Leaflet = global.Leaflet || {}, global.Leaflet.markercluster = global.Leaflet.markercluster || {})));
     11}(this, (function (exports) { 'use strict';
     12
     13/*
    714 * L.MarkerClusterGroup extends L.FeatureGroup by clustering the markers contained within
    815 */
    916
    10 L.MarkerClusterGroup = L.FeatureGroup.extend({
     17var MarkerClusterGroup = L.MarkerClusterGroup = L.FeatureGroup.extend({
    1118
    1219        options: {
    1320                maxClusterRadius: 80, //A cluster will cover at most this many pixels from its center
    1421                iconCreateFunction: null,
     22                clusterPane: L.Marker.prototype.options.pane,
    1523
    1624                spiderfyOnMaxZoom: true,
     
    7078                this._queue = [];
    7179
     80                this._childMarkerEventHandlers = {
     81                        'dragstart': this._childMarkerDragStart,
     82                        'move': this._childMarkerMoved,
     83                        'dragend': this._childMarkerDragEnd,
     84                };
     85
    7286                // Hook the appropriate animation methods.
    7387                var animate = L.DomUtil.TRANSITION && this.options.animate;
     
    86100                if (!layer.getLatLng) {
    87101                        this._nonPointGroup.addLayer(layer);
     102                        this.fire('layeradd', { layer: layer });
    88103                        return this;
    89104                }
     
    91106                if (!this._map) {
    92107                        this._needsClustering.push(layer);
     108                        this.fire('layeradd', { layer: layer });
    93109                        return this;
    94110                }
     
    106122
    107123                this._addLayer(layer, this._maxZoom);
     124                this.fire('layeradd', { layer: layer });
    108125
    109126                // Refresh bounds and weighted positions.
     
    140157                if (!layer.getLatLng) {
    141158                        this._nonPointGroup.removeLayer(layer);
     159                        this.fire('layerremove', { layer: layer });
    142160                        return this;
    143161                }
     
    145163                if (!this._map) {
    146164                        if (!this._arraySplice(this._needsClustering, layer) && this.hasLayer(layer)) {
    147                                 this._needsRemoving.push(layer);
    148                         }
     165                                this._needsRemoving.push({ layer: layer, latlng: layer._latlng });
     166                        }
     167                        this.fire('layerremove', { layer: layer });
    149168                        return this;
    150169                }
     
    161180                //Remove the marker from clusters
    162181                this._removeLayer(layer, true);
     182                this.fire('layerremove', { layer: layer });
    163183
    164184                // Refresh bounds and weighted positions.
     
    167187                this._refreshClustersIcons();
    168188
    169                 layer.off('move', this._childMarkerMoved, this);
     189                layer.off(this._childMarkerEventHandlers, this);
    170190
    171191                if (this._featureGroup.hasLayer(layer)) {
     
    180200
    181201        //Takes an array of markers and adds them in bulk
    182         addLayers: function (layersArray) {
     202        addLayers: function (layersArray, skipLayerAddEvent) {
    183203                if (!L.Util.isArray(layersArray)) {
    184204                        return this.addLayer(layersArray);
     
    229249                                        if (!m.getLatLng) {
    230250                                                npg.addLayer(m);
     251                                                if (!skipLayerAddEvent) {
     252                                                        this.fire('layeradd', { layer: m });
     253                                                }
    231254                                                continue;
    232255                                        }
     
    237260
    238261                                        this._addLayer(m, this._maxZoom);
     262                                        if (!skipLayerAddEvent) {
     263                                                this.fire('layeradd', { layer: m });
     264                                        }
    239265
    240266                                        //If we just made a cluster of size 2 then we need to remove the other marker from the map (if it is) or we never will
     
    327353                                npg.removeLayer(m);
    328354                                if (this.hasLayer(m)) {
    329                                         this._needsRemoving.push(m);
    330                                 }
     355                                        this._needsRemoving.push({ layer: m, latlng: m._latlng });
     356                                }
     357                                this.fire('layerremove', { layer: m });
    331358                        }
    332359                        return this;
     
    369396                        if (!m.__parent) {
    370397                                npg.removeLayer(m);
     398                                this.fire('layerremove', { layer: m });
    371399                                continue;
    372400                        }
    373401
    374402                        this._removeLayer(m, true, true);
     403                        this.fire('layerremove', { layer: m });
    375404
    376405                        if (fg.hasLayer(m)) {
     
    400429                if (!this._map) {
    401430                        this._needsClustering = [];
     431                        this._needsRemoving = [];
    402432                        delete this._gridClusters;
    403433                        delete this._gridUnclustered;
     
    413443
    414444                this.eachLayer(function (marker) {
    415                         marker.off('move', this._childMarkerMoved, this);
     445                        marker.off(this._childMarkerEventHandlers, this);
    416446                        delete marker.__parent;
    417                 });
     447                }, this);
    418448
    419449                if (this._map) {
     
    446476                var markers = this._needsClustering.slice(),
    447477                        needsRemoving = this._needsRemoving,
    448                         i;
     478                        thisNeedsRemoving, i, j;
    449479
    450480                if (this._topClusterLevel) {
     
    453483
    454484                for (i = markers.length - 1; i >= 0; i--) {
    455                         if (needsRemoving.indexOf(markers[i]) === -1) {
     485                        thisNeedsRemoving = true;
     486
     487                        for (j = needsRemoving.length - 1; j >= 0; j--) {
     488                                if (needsRemoving[j].layer === markers[i]) {
     489                                        thisNeedsRemoving = false;
     490                                        break;
     491                                }
     492                        }
     493
     494                        if (thisNeedsRemoving) {
    456495                                method.call(context, markers[i]);
    457496                        }
     
    473512        getLayer: function (id) {
    474513                var result = null;
    475                
     514
    476515                id = parseInt(id, 10);
    477516
     
    501540                anArray = this._needsRemoving;
    502541                for (i = anArray.length - 1; i >= 0; i--) {
    503                         if (anArray[i] === layer) {
     542                        if (anArray[i].layer === layer) {
    504543                                return false;
    505544                        }
     
    511550        //Zoom down to show the given layer (spiderfying if necessary) then calls the callback
    512551        zoomToShowLayer: function (layer, callback) {
    513                
     552
    514553                if (typeof callback !== 'function') {
    515554                        callback = function () {};
     
    538577                        this._map.panTo(layer.getLatLng());
    539578                } else {
    540                         var moveStart = function () {
    541                                 this._map.off('movestart', moveStart, this);
    542                                 moveStart = null;
    543                         };
    544 
    545                         this._map.on('movestart', moveStart, this);
    546579                        this._map.on('moveend', showMarker, this);
    547580                        this.on('animationend', showMarker, this);
    548581                        layer.__parent.zoomToBounds();
    549 
    550                         if (moveStart) {
    551                                 //Never started moving, must already be there, probably need clustering however
    552                                 showMarker.call(this);
    553                         }
    554582                }
    555583        },
     
    573601                this._maxLat = map.options.crs.projection.MAX_LATITUDE;
    574602
     603                //Restore all the positions as they are in the MCG before removing them
    575604                for (i = 0, l = this._needsRemoving.length; i < l; i++) {
    576605                        layer = this._needsRemoving[i];
    577                         this._removeLayer(layer, true);
     606                        layer.newlatlng = layer.layer._latlng;
     607                        layer.layer._latlng = layer.latlng;
     608                }
     609                //Remove them, then restore their new positions
     610                for (i = 0, l = this._needsRemoving.length; i < l; i++) {
     611                        layer = this._needsRemoving[i];
     612                        this._removeLayer(layer.layer, true);
     613                        layer.layer._latlng = layer.newlatlng;
    578614                }
    579615                this._needsRemoving = [];
     
    595631                l = this._needsClustering;
    596632                this._needsClustering = [];
    597                 this.addLayers(l);
     633                this.addLayers(l, true);
    598634        },
    599635
     
    649685         */
    650686        _removeFromGridUnclustered: function (marker, z) {
    651                 var map             = this._map,
    652                     gridUnclustered = this._gridUnclustered;
    653 
    654                 for (; z >= 0; z--) {
     687                var map = this._map,
     688                    gridUnclustered = this._gridUnclustered,
     689                        minZoom = Math.floor(this._map.getMinZoom());
     690
     691                for (; z >= minZoom; z--) {
    655692                        if (!gridUnclustered[z].removeObject(marker, map.project(marker.getLatLng(), z))) {
    656693                                break;
     
    659696        },
    660697
     698        _childMarkerDragStart: function (e) {
     699                e.target.__dragStart = e.target._latlng;
     700        },
     701
    661702        _childMarkerMoved: function (e) {
    662                 if (!this._ignoreMove) {
    663                         e.target._latlng = e.oldLatLng;
    664                         this.removeLayer(e.target);
    665 
    666                         e.target._latlng = e.latlng;
    667                         this.addLayer(e.target);
    668                 }
    669         },
     703                if (!this._ignoreMove && !e.target.__dragStart) {
     704                        var isPopupOpen = e.target._popup && e.target._popup.isOpen();
     705
     706                        this._moveChild(e.target, e.oldLatLng, e.latlng);
     707
     708                        if (isPopupOpen) {
     709                                e.target.openPopup();
     710                        }
     711                }
     712        },
     713
     714        _moveChild: function (layer, from, to) {
     715                layer._latlng = from;
     716                this.removeLayer(layer);
     717
     718                layer._latlng = to;
     719                this.addLayer(layer);
     720        },
     721
     722        _childMarkerDragEnd: function (e) {
     723                var dragStart = e.target.__dragStart;
     724                delete e.target.__dragStart;
     725                if (dragStart) {
     726                        this._moveChild(e.target, dragStart, e.target._latlng);
     727                }               
     728        },
     729
    670730
    671731        //Internal function for removing a marker from everything.
     
    675735                        gridUnclustered = this._gridUnclustered,
    676736                        fg = this._featureGroup,
    677                         map = this._map;
     737                        map = this._map,
     738                        minZoom = Math.floor(this._map.getMinZoom());
    678739
    679740                //Remove the marker from distance clusters it might be in
     
    694755                        cluster._boundsNeedUpdate = true;
    695756
    696                         if (cluster._zoom < 0) {
     757                        if (cluster._zoom < minZoom) {
    697758                                //Top level, do nothing
    698759                                break;
     
    868929                var newBounds = this._getExpandedVisibleBounds();
    869930
    870                 this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, newBounds);
     931                this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), this._zoom, newBounds);
    871932                this._topClusterLevel._recursivelyAddChildrenToMap(null, Math.round(this._map._zoom), newBounds);
    872933
     
    876937
    877938        _generateInitialClusters: function () {
    878                 var maxZoom = this._map.getMaxZoom(),
     939                var maxZoom = Math.ceil(this._map.getMaxZoom()),
     940                        minZoom = Math.floor(this._map.getMinZoom()),
    879941                        radius = this.options.maxClusterRadius,
    880942                        radiusFn = radius;
    881        
     943
    882944                //If we just set maxClusterRadius to a single number, we need to create
    883945                //a simple function to return that number. Otherwise, we just have to
     
    887949                }
    888950
    889                 if (this.options.disableClusteringAtZoom) {
     951                if (this.options.disableClusteringAtZoom !== null) {
    890952                        maxZoom = this.options.disableClusteringAtZoom - 1;
    891953                }
     
    893955                this._gridClusters = {};
    894956                this._gridUnclustered = {};
    895        
     957
    896958                //Set up DistanceGrids for each zoom
    897                 for (var zoom = maxZoom; zoom >= 0; zoom--) {
     959                for (var zoom = maxZoom; zoom >= minZoom; zoom--) {
    898960                        this._gridClusters[zoom] = new L.DistanceGrid(radiusFn(zoom));
    899961                        this._gridUnclustered[zoom] = new L.DistanceGrid(radiusFn(zoom));
     
    901963
    902964                // Instantiate the appropriate L.MarkerCluster class (animated or not).
    903                 this._topClusterLevel = new this._markerCluster(this, -1);
     965                this._topClusterLevel = new this._markerCluster(this, minZoom - 1);
    904966        },
    905967
     
    908970                var gridClusters = this._gridClusters,
    909971                    gridUnclustered = this._gridUnclustered,
     972                        minZoom = Math.floor(this._map.getMinZoom()),
    910973                    markerPoint, z;
    911974
     
    914977                }
    915978
    916                 layer.on('move', this._childMarkerMoved, this);
     979                layer.on(this._childMarkerEventHandlers, this);
    917980
    918981                //Find the lowest zoom level to slot this one in
    919                 for (; zoom >= 0; zoom--) {
     982                for (; zoom >= minZoom; zoom--) {
    920983                        markerPoint = this._map.project(layer.getLatLng(), zoom); // calculate pixel position
    921984
     
    10061069                        this._animationStart();
    10071070                        //Remove clusters now off screen
    1008                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, this._getExpandedVisibleBounds());
     1071                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), this._zoom, this._getExpandedVisibleBounds());
    10091072
    10101073                        this._animationZoomIn(this._zoom, mapZoom);
     
    11301193                },
    11311194                _animationZoomIn: function (previousZoomLevel, newZoomLevel) {
    1132                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
     1195                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), previousZoomLevel);
    11331196                        this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
    11341197
     
    11371200                },
    11381201                _animationZoomOut: function (previousZoomLevel, newZoomLevel) {
    1139                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
     1202                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), previousZoomLevel);
    11401203                        this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
    11411204
     
    11571220                _animationZoomIn: function (previousZoomLevel, newZoomLevel) {
    11581221                        var bounds = this._getExpandedVisibleBounds(),
    1159                             fg     = this._featureGroup,
     1222                            fg = this._featureGroup,
     1223                                minZoom = Math.floor(this._map.getMinZoom()),
    11601224                            i;
    11611225
     
    11631227
    11641228                        //Add all children of current clusters to map and remove those clusters from map
    1165                         this._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
     1229                        this._topClusterLevel._recursively(bounds, previousZoomLevel, minZoom, function (c) {
    11661230                                var startPos = c._latlng,
    11671231                                    markers  = c._markers,
     
    12131277                        this._enqueue(function () {
    12141278                                //update the positions of the just added clusters/markers
    1215                                 this._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
     1279                                this._topClusterLevel._recursively(bounds, previousZoomLevel, minZoom, function (c) {
    12161280                                        fg.removeLayer(c);
    12171281                                        c.clusterShow();
     
    12281292                        this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
    12291293                        //Remove markers that were on the map before but won't be now
    1230                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel, this._getExpandedVisibleBounds());
     1294                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), previousZoomLevel, this._getExpandedVisibleBounds());
    12311295                },
    12321296
     
    12651329        // Private methods for animated versions.
    12661330        _animationZoomOutSingle: function (cluster, previousZoomLevel, newZoomLevel) {
    1267                 var bounds = this._getExpandedVisibleBounds();
     1331                var bounds = this._getExpandedVisibleBounds(),
     1332                        minZoom = Math.floor(this._map.getMinZoom());
    12681333
    12691334                //Animate all of the markers in the clusters to move to their cluster center point
    1270                 cluster._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, previousZoomLevel + 1, newZoomLevel);
     1335                cluster._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, minZoom, previousZoomLevel + 1, newZoomLevel);
    12711336
    12721337                var me = this;
     
    12911356                                }
    12921357                        } else {
    1293                                 cluster._recursively(bounds, newZoomLevel, 0, function (c) {
    1294                                         c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel + 1);
     1358                                cluster._recursively(bounds, newZoomLevel, minZoom, function (c) {
     1359                                        c._recursivelyRemoveChildrenFromMap(bounds, minZoom, previousZoomLevel + 1);
    12951360                                });
    12961361                        }
     
    13211386};
    13221387
    1323 
    1324 L.MarkerCluster = L.Marker.extend({
     1388var MarkerCluster = L.MarkerCluster = L.Marker.extend({
     1389        options: L.Icon.prototype.options,
     1390
    13251391        initialize: function (group, zoom, a, b) {
    13261392
    1327                 L.Marker.prototype.initialize.call(this, a ? (a._cLatLng || a.getLatLng()) : new L.LatLng(0, 0), { icon: this });
    1328 
     1393                L.Marker.prototype.initialize.call(this, a ? (a._cLatLng || a.getLatLng()) : new L.LatLng(0, 0),
     1394            { icon: this, pane: group.options.clusterPane });
    13291395
    13301396                this._group = group;
     
    13481414
    13491415        //Recursively retrieve all child markers of this cluster
    1350         getAllChildMarkers: function (storageArray) {
     1416        getAllChildMarkers: function (storageArray, ignoreDraggedMarker) {
    13511417                storageArray = storageArray || [];
    13521418
     
    13561422
    13571423                for (var j = this._markers.length - 1; j >= 0; j--) {
     1424                        if (ignoreDraggedMarker && this._markers[j].__dragStart) {
     1425                                continue;
     1426                        }
    13581427                        storageArray.push(this._markers[j]);
    13591428                }
     
    13681437
    13691438        //Zoom to the minimum of showing all of the child markers, or the extents of this cluster
    1370         zoomToBounds: function () {
     1439        zoomToBounds: function (fitBoundsOptions) {
    13711440                var childClusters = this._childClusters.slice(),
    13721441                        map = this._group._map,
     
    13911460                        this._group._map.setView(this._latlng, mapZoom + 1);
    13921461                } else {
    1393                         this._group._map.fitBounds(this._bounds);
     1462                        this._group._map.fitBounds(this._bounds, fitBoundsOptions);
    13941463                }
    13951464        },
     
    15371606
    15381607        _recursivelyAnimateChildrenIn: function (bounds, center, maxZoom) {
    1539                 this._recursively(bounds, 0, maxZoom - 1,
     1608                this._recursively(bounds, this._group._map.getMinZoom(), maxZoom - 1,
    15401609                        function (c) {
    15411610                                var markers = c._markers,
     
    15651634        },
    15661635
    1567         _recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, previousZoomLevel, newZoomLevel) {
    1568                 this._recursively(bounds, newZoomLevel, 0,
     1636        _recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, mapMinZoom, previousZoomLevel, newZoomLevel) {
     1637                this._recursively(bounds, newZoomLevel, mapMinZoom,
    15691638                        function (c) {
    15701639                                c._recursivelyAnimateChildrenIn(bounds, c._group._map.latLngToLayerPoint(c.getLatLng()).round(), previousZoomLevel);
     
    15741643                                if (c._isSingleParent() && previousZoomLevel - 1 === newZoomLevel) {
    15751644                                        c.clusterShow();
    1576                                         c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
     1645                                        c._recursivelyRemoveChildrenFromMap(bounds, mapMinZoom, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
    15771646                                } else {
    15781647                                        c.clusterHide();
     
    15851654
    15861655        _recursivelyBecomeVisible: function (bounds, zoomLevel) {
    1587                 this._recursively(bounds, 0, zoomLevel, null, function (c) {
     1656                this._recursively(bounds, this._group._map.getMinZoom(), zoomLevel, null, function (c) {
    15881657                        c.clusterShow();
    15891658                });
     
    15911660
    15921661        _recursivelyAddChildrenToMap: function (startPos, zoomLevel, bounds) {
    1593                 this._recursively(bounds, -1, zoomLevel,
     1662                this._recursively(bounds, this._group._map.getMinZoom() - 1, zoomLevel,
    15941663                        function (c) {
    15951664                                if (zoomLevel === c._zoom) {
     
    16531722
    16541723        //exceptBounds: If set, don't remove any markers/clusters in it
    1655         _recursivelyRemoveChildrenFromMap: function (previousBounds, zoomLevel, exceptBounds) {
     1724        _recursivelyRemoveChildrenFromMap: function (previousBounds, mapMinZoom, zoomLevel, exceptBounds) {
    16561725                var m, i;
    1657                 this._recursively(previousBounds, -1, zoomLevel - 1,
     1726                this._recursively(previousBounds, mapMinZoom - 1, zoomLevel - 1,
    16581727                        function (c) {
    16591728                                //Remove markers at every level
     
    17061775                        for (i = childClusters.length - 1; i >= 0; i--) {
    17071776                                c = childClusters[i];
     1777                                if (c._boundsNeedUpdate) {
     1778                                        c._recalculateBounds();
     1779                                }
    17081780                                if (boundsToApplyTo.intersects(c._bounds)) {
    17091781                                        c._recursively(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel);
     
    17201792});
    17211793
    1722 
    1723 
    17241794/*
    17251795* Extends L.Marker to include two extra methods: clusterHide and clusterShow.
    17261796*
    17271797* They work as setOpacity(0) and setOpacity(1) respectively, but
    1728 * they will remember the marker's opacity when hiding and showing it again.
     1798* don't overwrite the options.opacity
    17291799*
    17301800*/
    17311801
    1732 
    17331802L.Marker.include({
    1734        
    17351803        clusterHide: function () {
    1736                 this.options.opacityWhenUnclustered = this.options.opacity || 1;
    1737                 return this.setOpacity(0);
     1804                var backup = this.options.opacity;
     1805                this.setOpacity(0);
     1806                this.options.opacity = backup;
     1807                return this;
    17381808        },
    17391809       
    17401810        clusterShow: function () {
    1741                 var ret = this.setOpacity(this.options.opacity || this.options.opacityWhenUnclustered);
    1742                 delete this.options.opacityWhenUnclustered;
    1743                 return ret;
     1811                return this.setOpacity(this.options.opacity);
    17441812        }
    1745        
    17461813});
    1747 
    1748 
    1749 
    1750 
    17511814
    17521815L.DistanceGrid = function (cellSize) {
     
    18431906                                                        obj = cell[k];
    18441907                                                        dist = this._sqDist(objectPoint[L.Util.stamp(obj)], point);
    1845                                                         if (dist < closestDistSq) {
     1908                                                        if (dist < closestDistSq ||
     1909                                                                dist <= closestDistSq && closest === null) {
    18461910                                                                closestDistSq = dist;
    18471911                                                                closest = obj;
     
    18561920
    18571921        _getCoord: function (x) {
    1858                 return Math.floor(x / this._cellSize);
     1922                var coord = Math.floor(x / this._cellSize);
     1923                return isFinite(coord) ? coord : x;
    18591924        },
    18601925
     
    18651930        }
    18661931};
    1867 
    18681932
    18691933/* Copyright (c) 2012 the authors listed at the following URL, and/or
     
    20332097});
    20342098
    2035 
    20362099//This code is 100% based on https://github.com/jawj/OverlappingMarkerSpiderfier-Leaflet
    20372100//Huge thanks to jawj for implementing it first to make my job easy :-)
     
    20412104        _2PI: Math.PI * 2,
    20422105        _circleFootSeparation: 25, //related to circumference of circle
    2043         _circleStartAngle: Math.PI / 6,
     2106        _circleStartAngle: 0,
    20442107
    20452108        _spiralFootSeparation:  28, //related to size of spiral (experiment!)
     
    20552118                }
    20562119
    2057                 var childMarkers = this.getAllChildMarkers(),
     2120                var childMarkers = this.getAllChildMarkers(null, true),
    20582121                        group = this._group,
    20592122                        map = group._map,
     
    20932156                        i, angle;
    20942157
     2158                legLength = Math.max(legLength, 35); // Minimum distance to get outside the cluster icon.
     2159
    20952160                res.length = count;
    20962161
    2097                 for (i = count - 1; i >= 0; i--) {
     2162                for (i = 0; i < count; i++) { // Clockwise, like spiral.
    20982163                        angle = this._circleStartAngle + i * angleStep;
    20992164                        res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
     
    21152180
    21162181                // Higher index, closer position to cluster center.
    2117                 for (i = count - 1; i >= 0; i--) {
     2182                for (i = count; i >= 0; i--) {
     2183                        // Skip the first position, so that we are already farther from center and we avoid
     2184                        // being under the default cluster icon (especially important for Circle Markers).
     2185                        if (i < count) {
     2186                                res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
     2187                        }
    21182188                        angle += separation / legLength + i * 0.0005;
    2119                         res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
    21202189                        legLength += lengthFactor / angle;
    21212190                }
     
    21272196                        map = group._map,
    21282197                        fg = group._featureGroup,
    2129                         childMarkers = this.getAllChildMarkers(),
     2198                        childMarkers = this.getAllChildMarkers(null, true),
    21302199                        m, i;
    21312200
     
    23202389                        fg = group._featureGroup,
    23212390                        thisLayerPos = zoomDetails ? map._latLngToNewLayerPoint(this._latlng, zoomDetails.zoom, zoomDetails.center) : map.latLngToLayerPoint(this._latlng),
    2322                         childMarkers = this.getAllChildMarkers(),
     2391                        childMarkers = this.getAllChildMarkers(null, true),
    23232392                        svg = L.Path.SVG,
    23242393                        m, i, leg, legPath, legLength, nonAnimatable;
     
    23362405                                continue;
    23372406                        }
     2407
     2408                        //Close any popup on the marker first, otherwise setting the location of the marker will make the map scroll
     2409                        m.closePopup();
    23382410
    23392411                        //Fix up the location to the real one
     
    25002572        }
    25012573});
    2502 
    25032574
    25042575/**
     
    26132684});
    26142685
    2615 
    2616 }(window, document));
     2686exports.MarkerClusterGroup = MarkerClusterGroup;
     2687exports.MarkerCluster = MarkerCluster;
     2688
     2689})));
     2690//# sourceMappingURL=leaflet.markercluster-src.js.map
  • _plugins_/gis/trunk/paquet.xml

    r118680 r118846  
    22        prefix="gis"
    33        categorie="divers"
    4         version="4.47.13"
     4        version="4.47.14"
    55        schema="2.1.0"
    66        etat="stable"
Note: See TracChangeset for help on using the changeset viewer.