Changeset 81559 in spip-zone


Ignore:
Timestamp:
Mar 21, 2014, 3:15:09 PM (5 years ago)
Author:
kent1@…
Message:

revert de r81557 qui en a trop fait

Location:
_plugins_/gis/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/gis/trunk/action/gis_geocoder_rechercher.php

    r81558 r81559  
    2020
    2121        /* On filtre les arguments à renvoyer à Nomatim (liste blanche) */     
    22         $arguments = collecter_requests(array("json_callback", "format", "q", "limit", "addressdetails", "accept-language", "lat", "lon"),array());
     22        $arguments = collecter_requests(array("json_callback", "format", "q", "limit", "addressdetails", "accept-language", "lat", "lon"));
    2323
    2424        if(!empty($arguments)) {
  • _plugins_/gis/trunk/lib/leaflet/plugins/leaflet.markercluster-src.js

    r81558 r81559  
    44 (c) 2012-2013, Dave Leaver, smartrak
    55*/
    6 (function (window, document, undefined) {
    7 /*
     6(function (window, document, undefined) {/*
    87 * L.MarkerClusterGroup extends L.FeatureGroup by clustering the markers contained within
    98 */
     
    3231                //Increase to increase the distance away that spiderfied markers appear from the center
    3332                spiderfyDistanceMultiplier: 1,
     33
     34                // When bulk adding layers, adds markers in chunks. Means addLayers may not add all the layers in the call, others will be loaded during setTimeouts
     35                chunkedLoading: false,
     36                chunkInterval: 200, // process markers for a maximum of ~ n milliseconds (then trigger the chunkProgress callback)
     37                chunkDelay: 50, // at the end of each interval, give n milliseconds back to system/browser
     38                chunkProgress: null, // progress callback: function(processed, total, elapsed) (e.g. for a progress indicator)
    3439
    3540                //Options to pass to the L.Polygon constructor
     
    159164        //Takes an array of markers and adds them in bulk
    160165        addLayers: function (layersArray) {
    161                 var i, l, m,
    162                         onMap = this._map,
    163                         fg = this._featureGroup,
    164                         npg = this._nonPointGroup;
    165 
    166                 for (i = 0, l = layersArray.length; i < l; i++) {
    167                         m = layersArray[i];
    168 
    169                         //Not point data, can't be clustered
    170                         if (!m.getLatLng) {
    171                                 npg.addLayer(m);
    172                                 continue;
    173                         }
    174 
    175                         if (this.hasLayer(m)) {
    176                                 continue;
    177                         }
    178 
    179                         if (!onMap) {
    180                                 this._needsClustering.push(m);
    181                                 continue;
    182                         }
    183 
    184                         this._addLayer(m, this._maxZoom);
    185 
    186                         //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
    187                         if (m.__parent) {
    188                                 if (m.__parent.getChildCount() === 2) {
    189                                         var markers = m.__parent.getAllChildMarkers(),
    190                                                 otherMarker = markers[0] === m ? markers[1] : markers[0];
    191                                         fg.removeLayer(otherMarker);
    192                                 }
    193                         }
    194                 }
    195 
    196                 if (onMap) {
    197                         //Update the icons of all those visible clusters that were affected
    198                         fg.eachLayer(function (c) {
    199                                 if (c instanceof L.MarkerCluster && c._iconNeedsUpdate) {
    200                                         c._updateIcon();
    201                                 }
    202                         });
    203 
    204                         this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
    205                 }
    206 
     166                var fg = this._featureGroup,
     167                        npg = this._nonPointGroup,
     168                        chunkInterval = this.options.chunkInterval,
     169                        chunkProgress = this.options.chunkProgress,
     170                        newMarkers, i, l, m;
     171
     172                if (this._map) {
     173                        var offset = 0,
     174                                started = (new Date()).getTime();
     175                        var process = L.bind(function () {
     176                                var start = (new Date()).getTime();
     177                                for (; offset < layersArray.length; offset++) {
     178                                        if (offset % 200 === 0) {
     179                                                // every couple hundred markers, instrument the time elapsed since processing started:
     180                                                var elapsed = (new Date()).getTime() - start;
     181                                                if (elapsed > chunkInterval) {
     182                                                        break; // been working too hard, time to take a break :-)
     183                                                }
     184                                        }
     185
     186                                        m = layersArray[offset];
     187
     188                                        //Not point data, can't be clustered
     189                                        if (!m.getLatLng) {
     190                                                npg.addLayer(m);
     191                                                continue;
     192                                        }
     193
     194                                        if (this.hasLayer(m)) {
     195                                                continue;
     196                                        }
     197
     198                                        this._addLayer(m, this._maxZoom);
     199
     200                                        //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
     201                                        if (m.__parent) {
     202                                                if (m.__parent.getChildCount() === 2) {
     203                                                        var markers = m.__parent.getAllChildMarkers(),
     204                                                                otherMarker = markers[0] === m ? markers[1] : markers[0];
     205                                                        fg.removeLayer(otherMarker);
     206                                                }
     207                                        }
     208                                }
     209
     210                                if (chunkProgress) {
     211                                        // report progress and time elapsed:
     212                                        chunkProgress(offset, layersArray.length, (new Date()).getTime() - started);
     213                                }
     214
     215                                if (offset === layersArray.length) {
     216                                        //Update the icons of all those visible clusters that were affected
     217                                        this._featureGroup.eachLayer(function (c) {
     218                                                if (c instanceof L.MarkerCluster && c._iconNeedsUpdate) {
     219                                                        c._updateIcon();
     220                                                }
     221                                        });
     222
     223                                        this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
     224                                } else {
     225                                        setTimeout(process, this.options.chunkDelay);
     226                                }
     227                        }, this);
     228
     229                        process();
     230                } else {
     231                        newMarkers = [];
     232                        for (i = 0, l = layersArray.length; i < l; i++) {
     233                                m = layersArray[i];
     234
     235                                //Not point data, can't be clustered
     236                                if (!m.getLatLng) {
     237                                        npg.addLayer(m);
     238                                        continue;
     239                                }
     240
     241                                if (this.hasLayer(m)) {
     242                                        continue;
     243                                }
     244
     245                                newMarkers.push(m);
     246                        }
     247                        this._needsClustering = this._needsClustering.concat(newMarkers);
     248                }
    207249                return this;
    208250        },
     
    303345        eachLayer: function (method, context) {
    304346                var markers = this._needsClustering.slice(),
    305                     i;
     347                        i;
    306348
    307349                if (this._topClusterLevel) {
     
    420462                this._needsRemoving = [];
    421463
    422                 for (i = 0, l = this._needsClustering.length; i < l; i++) {
    423                         layer = this._needsClustering[i];
    424 
    425                         //If the layer doesn't have a getLatLng then we can't cluster it, so add it to our child featureGroup
    426                         if (!layer.getLatLng) {
    427                                 this._featureGroup.addLayer(layer);
    428                                 continue;
    429                         }
    430 
    431 
    432                         if (layer.__parent) {
    433                                 continue;
    434                         }
    435                         this._addLayer(layer, this._maxZoom);
    436                 }
    437                 this._needsClustering = [];
    438 
    439 
    440                 this._map.on('zoomend', this._zoomEnd, this);
    441                 this._map.on('moveend', this._moveEnd, this);
    442 
    443                 if (this._spiderfierOnAdd) { //TODO FIXME: Not sure how to have spiderfier add something on here nicely
    444                         this._spiderfierOnAdd();
    445                 }
    446 
    447                 this._bindEvents();
    448 
    449 
    450                 //Actually add our markers to the map:
    451 
    452464                //Remember the current zoom level and bounds
    453465                this._zoom = this._map.getZoom();
    454466                this._currentShownBounds = this._getExpandedVisibleBounds();
    455467
    456                 //Make things appear on the map
    457                 this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
     468                this._map.on('zoomend', this._zoomEnd, this);
     469                this._map.on('moveend', this._moveEnd, this);
     470
     471                if (this._spiderfierOnAdd) { //TODO FIXME: Not sure how to have spiderfier add something on here nicely
     472                        this._spiderfierOnAdd();
     473                }
     474
     475                this._bindEvents();
     476
     477                //Actually add our markers to the map:
     478                l = this._needsClustering;
     479                this._needsClustering = [];
     480                this.addLayers(l);
    458481        },
    459482
     
    633656                }
    634657
    635     // Focus the map again for keyboard users.
     658                // Focus the map again for keyboard users.
    636659                if (e.originalEvent && e.originalEvent.keyCode === 13) {
    637660                        map._container.focus();
     
    702725        _generateInitialClusters: function () {
    703726                var maxZoom = this._map.getMaxZoom(),
    704                         radius = this.options.maxClusterRadius;
     727                        radius = this.options.maxClusterRadius,
     728                        radiusFn = radius;
     729       
     730                //If we just set maxClusterRadius to a single number, we need to create
     731                //a simple function to return that number. Otherwise, we just have to
     732                //use the function we've passed in.
     733                if (typeof radius !== "function") {
     734                        radiusFn = function () { return radius; };
     735                }
    705736
    706737                if (this.options.disableClusteringAtZoom) {
     
    710741                this._gridClusters = {};
    711742                this._gridUnclustered = {};
    712 
     743       
    713744                //Set up DistanceGrids for each zoom
    714745                for (var zoom = maxZoom; zoom >= 0; zoom--) {
    715                         this._gridClusters[zoom] = new L.DistanceGrid(radius);
    716                         this._gridUnclustered[zoom] = new L.DistanceGrid(radius);
     746                        this._gridClusters[zoom] = new L.DistanceGrid(radiusFn(zoom));
     747                        this._gridUnclustered[zoom] = new L.DistanceGrid(radiusFn(zoom));
    717748                }
    718749
     
    9871018                                //If we were in a cluster animation at the time then the opacity and position of our child could be wrong now, so fix it
    9881019                                m.setLatLng(m.getLatLng());
    989                                 m.setOpacity(1);
     1020                                if (m.setOpacity) {
     1021                                        m.setOpacity(1);
     1022                                }
    9901023                        } else {
    9911024                                cluster._recursively(bounds, newZoomLevel, 0, function (c) {
  • _plugins_/gis/trunk/paquet.xml

    r81558 r81559  
    22        prefix="gis"
    33        categorie="divers"
    4         version="4.19.7"
     4        version="4.19.6"
    55        schema="2.0.5"
    66        etat="stable"
Note: See TracChangeset for help on using the changeset viewer.