Changeset 81558 in spip-zone


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

La balise collecter_requests() doit avoir un second argument "array()" ici

Version 4.19.7

Location:
_plugins_/gis/trunk
Files:
3 edited

Legend:

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

    r81545 r81558  
    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"));
     22        $arguments = collecter_requests(array("json_callback", "format", "q", "limit", "addressdetails", "accept-language", "lat", "lon"),array());
    2323
    2424        if(!empty($arguments)) {
  • _plugins_/gis/trunk/lib/leaflet/plugins/leaflet.markercluster-src.js

    r80230 r81558  
    44 (c) 2012-2013, Dave Leaver, smartrak
    55*/
    6 (function (window, document, undefined) {/*
     6(function (window, document, undefined) {
     7/*
    78 * L.MarkerClusterGroup extends L.FeatureGroup by clustering the markers contained within
    89 */
     
    3132                //Increase to increase the distance away that spiderfied markers appear from the center
    3233                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)
    3934
    4035                //Options to pass to the L.Polygon constructor
     
    164159        //Takes an array of markers and adds them in bulk
    165160        addLayers: function (layersArray) {
    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                 }
     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
    249207                return this;
    250208        },
     
    345303        eachLayer: function (method, context) {
    346304                var markers = this._needsClustering.slice(),
    347                         i;
     305                    i;
    348306
    349307                if (this._topClusterLevel) {
     
    462420                this._needsRemoving = [];
    463421
     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
    464452                //Remember the current zoom level and bounds
    465453                this._zoom = this._map.getZoom();
    466454                this._currentShownBounds = this._getExpandedVisibleBounds();
    467455
    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);
     456                //Make things appear on the map
     457                this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
    481458        },
    482459
     
    656633                }
    657634
    658                 // Focus the map again for keyboard users.
     635    // Focus the map again for keyboard users.
    659636                if (e.originalEvent && e.originalEvent.keyCode === 13) {
    660637                        map._container.focus();
     
    725702        _generateInitialClusters: function () {
    726703                var maxZoom = this._map.getMaxZoom(),
    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                 }
     704                        radius = this.options.maxClusterRadius;
    736705
    737706                if (this.options.disableClusteringAtZoom) {
     
    741710                this._gridClusters = {};
    742711                this._gridUnclustered = {};
    743        
     712
    744713                //Set up DistanceGrids for each zoom
    745714                for (var zoom = maxZoom; zoom >= 0; zoom--) {
    746                         this._gridClusters[zoom] = new L.DistanceGrid(radiusFn(zoom));
    747                         this._gridUnclustered[zoom] = new L.DistanceGrid(radiusFn(zoom));
     715                        this._gridClusters[zoom] = new L.DistanceGrid(radius);
     716                        this._gridUnclustered[zoom] = new L.DistanceGrid(radius);
    748717                }
    749718
     
    1018987                                //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
    1019988                                m.setLatLng(m.getLatLng());
    1020                                 if (m.setOpacity) {
    1021                                         m.setOpacity(1);
    1022                                 }
     989                                m.setOpacity(1);
    1023990                        } else {
    1024991                                cluster._recursively(bounds, newZoomLevel, 0, function (c) {
  • _plugins_/gis/trunk/paquet.xml

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