Changeset 103986 in spip-zone


Ignore:
Timestamp:
Apr 17, 2017, 6:01:42 PM (2 years ago)
Author:
kent1@…
Message:

Mise à jour de la libe leaflet.markerclusterer à la version 1.0.4

Ajoute deux évènements layeradd et layerremove et divers bugfixes

Permettre à la fonction gis_focus_marker de faire son travail si le marker est dans un MarkerClusterGroup?.

On active donc la fonction openId du modèle carte_gis en mode cluster qui ne l'était pas

Version 4.43.3

Location:
_plugins_/gis/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/gis/trunk/javascript/gis_utils.js

    r96592 r103986  
    33        var i, count = 0;
    44        for (i in carte._layers) {
    5                 if ((carte._layers[i].feature) && (carte._layers[i].feature.id == id)) {
     5                if (L.MarkerClusterGroup && carte._layers[i] instanceof L.MarkerClusterGroup) {
     6                        carte._layers[i].eachLayer(function(layer) {
     7                                if (layer.id && layer.id == id) {
     8                                        carte._layers[i].zoomToShowLayer(layer);
     9                                        layer.openPopup();
     10                                        count++;
     11                                }
     12                        });
     13                        if (count > 0) {
     14                                break;
     15                        }
     16                } else if (((carte._layers[i].feature) && (carte._layers[i].feature.id == id)) || (carte._layers[i].id && carte._layers[i].id == id)) {
    617                        carte.panTo(carte._layers[i].getLatLng());
    718                        carte._layers[i].openPopup();
     19                        break;
    820                }
    921                count++;
  • _plugins_/gis/trunk/javascript/leaflet.gis.js

    r98977 r103986  
    252252                                        map.setView(map.markerCluster.getBounds().getCenter(), map.options.zoom);
    253253                        }
     254                        if (map.options.openId) {
     255                                gis_focus_marker(map.options.openId,map.options.mapId);
     256                        }
    254257                }
    255258        },
  • _plugins_/gis/trunk/lib/leaflet/plugins/leaflet.markercluster-src.js

    r100141 r103986  
    7070                this._queue = [];
    7171
     72                this._childMarkerEventHandlers = {
     73                        'dragstart': this._childMarkerDragStart,
     74                        'move': this._childMarkerMoved,
     75                        'dragend': this._childMarkerDragEnd,
     76                };
     77
    7278                // Hook the appropriate animation methods.
    7379                var animate = L.DomUtil.TRANSITION && this.options.animate;
     
    8692                if (!layer.getLatLng) {
    8793                        this._nonPointGroup.addLayer(layer);
     94                        this.fire('layeradd', { layer: layer });
    8895                        return this;
    8996                }
     
    9198                if (!this._map) {
    9299                        this._needsClustering.push(layer);
     100                        this.fire('layeradd', { layer: layer });
    93101                        return this;
    94102                }
     
    106114
    107115                this._addLayer(layer, this._maxZoom);
     116                this.fire('layeradd', { layer: layer });
    108117
    109118                // Refresh bounds and weighted positions.
     
    140149                if (!layer.getLatLng) {
    141150                        this._nonPointGroup.removeLayer(layer);
     151                        this.fire('layerremove', { layer: layer });
    142152                        return this;
    143153                }
     
    145155                if (!this._map) {
    146156                        if (!this._arraySplice(this._needsClustering, layer) && this.hasLayer(layer)) {
    147                                 this._needsRemoving.push(layer);
    148                         }
     157                                this._needsRemoving.push({ layer: layer, latlng: layer._latlng });
     158                        }
     159                        this.fire('layerremove', { layer: layer });
    149160                        return this;
    150161                }
     
    161172                //Remove the marker from clusters
    162173                this._removeLayer(layer, true);
     174                this.fire('layerremove', { layer: layer });
    163175
    164176                // Refresh bounds and weighted positions.
     
    167179                this._refreshClustersIcons();
    168180
    169                 layer.off('move', this._childMarkerMoved, this);
     181                layer.off(this._childMarkerEventHandlers, this);
    170182
    171183                if (this._featureGroup.hasLayer(layer)) {
     
    180192
    181193        //Takes an array of markers and adds them in bulk
    182         addLayers: function (layersArray) {
     194        addLayers: function (layersArray, skipLayerAddEvent) {
    183195                if (!L.Util.isArray(layersArray)) {
    184196                        return this.addLayer(layersArray);
     
    229241                                        if (!m.getLatLng) {
    230242                                                npg.addLayer(m);
     243                                                if (!skipLayerAddEvent) {
     244                                                        this.fire('layeradd', { layer: m });
     245                                                }
    231246                                                continue;
    232247                                        }
     
    237252
    238253                                        this._addLayer(m, this._maxZoom);
     254                                        if (!skipLayerAddEvent) {
     255                                                this.fire('layeradd', { layer: m });
     256                                        }
    239257
    240258                                        //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
     
    327345                                npg.removeLayer(m);
    328346                                if (this.hasLayer(m)) {
    329                                         this._needsRemoving.push(m);
    330                                 }
     347                                        this._needsRemoving.push({ layer: m, latlng: m._latlng });
     348                                }
     349                                this.fire('layerremove', { layer: m });
    331350                        }
    332351                        return this;
     
    369388                        if (!m.__parent) {
    370389                                npg.removeLayer(m);
     390                                this.fire('layerremove', { layer: m });
    371391                                continue;
    372392                        }
    373393
    374394                        this._removeLayer(m, true, true);
     395                        this.fire('layerremove', { layer: m });
    375396
    376397                        if (fg.hasLayer(m)) {
     
    413434
    414435                this.eachLayer(function (marker) {
    415                         marker.off('move', this._childMarkerMoved, this);
     436                        marker.off(this._childMarkerEventHandlers, this);
    416437                        delete marker.__parent;
    417                 });
     438                }, this);
    418439
    419440                if (this._map) {
     
    446467                var markers = this._needsClustering.slice(),
    447468                        needsRemoving = this._needsRemoving,
    448                         i;
     469                        thisNeedsRemoving, i, j;
    449470
    450471                if (this._topClusterLevel) {
     
    453474
    454475                for (i = markers.length - 1; i >= 0; i--) {
    455                         if (needsRemoving.indexOf(markers[i]) === -1) {
     476                        thisNeedsRemoving = true;
     477
     478                        for (j = needsRemoving.length - 1; j >= 0; j--) {
     479                                if (needsRemoving[j].layer === markers[i]) {
     480                                        thisNeedsRemoving = false;
     481                                        break;
     482                                }
     483                        }
     484
     485                        if (thisNeedsRemoving) {
    456486                                method.call(context, markers[i]);
    457487                        }
     
    501531                anArray = this._needsRemoving;
    502532                for (i = anArray.length - 1; i >= 0; i--) {
    503                         if (anArray[i] === layer) {
     533                        if (anArray[i].layer === layer) {
    504534                                return false;
    505535                        }
     
    511541        //Zoom down to show the given layer (spiderfying if necessary) then calls the callback
    512542        zoomToShowLayer: function (layer, callback) {
    513                
     543
    514544                if (typeof callback !== 'function') {
    515545                        callback = function () {};
     
    538568                        this._map.panTo(layer.getLatLng());
    539569                } else {
    540                         var moveStart = function () {
    541                                 this._map.off('movestart', moveStart, this);
    542                                 moveStart = null;
    543                         };
    544 
    545                         this._map.on('movestart', moveStart, this);
    546570                        this._map.on('moveend', showMarker, this);
    547571                        this.on('animationend', showMarker, this);
    548572                        layer.__parent.zoomToBounds();
    549 
    550                         if (moveStart) {
    551                                 //Never started moving, must already be there, probably need clustering however
    552                                 showMarker.call(this);
    553                         }
    554573                }
    555574        },
     
    573592                this._maxLat = map.options.crs.projection.MAX_LATITUDE;
    574593
     594                //Restore all the positions as they are in the MCG before removing them
    575595                for (i = 0, l = this._needsRemoving.length; i < l; i++) {
    576596                        layer = this._needsRemoving[i];
    577                         this._removeLayer(layer, true);
     597                        layer.newlatlng = layer.layer._latlng;
     598                        layer.layer._latlng = layer.latlng;
     599                }
     600                //Remove them, then restore their new positions
     601                for (i = 0, l = this._needsRemoving.length; i < l; i++) {
     602                        layer = this._needsRemoving[i];
     603                        this._removeLayer(layer.layer, true);
     604                        layer.layer._latlng = layer.newlatlng;
    578605                }
    579606                this._needsRemoving = [];
     
    595622                l = this._needsClustering;
    596623                this._needsClustering = [];
    597                 this.addLayers(l);
     624                this.addLayers(l, true);
    598625        },
    599626
     
    649676         */
    650677        _removeFromGridUnclustered: function (marker, z) {
    651                 var map             = this._map,
    652                     gridUnclustered = this._gridUnclustered;
    653 
    654                 for (; z >= 0; z--) {
     678                var map = this._map,
     679                    gridUnclustered = this._gridUnclustered,
     680                        minZoom = this._map.getMinZoom();
     681
     682                for (; z >= minZoom; z--) {
    655683                        if (!gridUnclustered[z].removeObject(marker, map.project(marker.getLatLng(), z))) {
    656684                                break;
     
    659687        },
    660688
     689        _childMarkerDragStart: function (e) {
     690                e.target.__dragStart = e.target._latlng;
     691        },
     692
    661693        _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         },
     694                if (!this._ignoreMove && !e.target.__dragStart) {
     695                        var isPopupOpen = e.target._popup && e.target._popup.isOpen();
     696
     697                        this._moveChild(e.target, e.oldLatLng, e.latlng);
     698
     699                        if (isPopupOpen) {
     700                                e.target.openPopup();
     701                        }
     702                }
     703        },
     704
     705        _moveChild: function (layer, from, to) {
     706                layer._latlng = from;
     707                this.removeLayer(layer);
     708
     709                layer._latlng = to;
     710                this.addLayer(layer);
     711        },
     712
     713        _childMarkerDragEnd: function (e) {
     714                if (e.target.__dragStart) {
     715                        this._moveChild(e.target, e.target.__dragStart, e.target._latlng);
     716                }
     717                delete e.target.__dragStart;
     718        },
     719       
    670720
    671721        //Internal function for removing a marker from everything.
     
    675725                        gridUnclustered = this._gridUnclustered,
    676726                        fg = this._featureGroup,
    677                         map = this._map;
     727                        map = this._map,
     728                        minZoom = this._map.getMinZoom();
    678729
    679730                //Remove the marker from distance clusters it might be in
     
    694745                        cluster._boundsNeedUpdate = true;
    695746
    696                         if (cluster._zoom < 0) {
     747                        if (cluster._zoom < minZoom) {
    697748                                //Top level, do nothing
    698749                                break;
     
    868919                var newBounds = this._getExpandedVisibleBounds();
    869920
    870                 this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, newBounds);
     921                this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._map.getMinZoom(), this._zoom, newBounds);
    871922                this._topClusterLevel._recursivelyAddChildrenToMap(null, Math.round(this._map._zoom), newBounds);
    872923
     
    877928        _generateInitialClusters: function () {
    878929                var maxZoom = this._map.getMaxZoom(),
     930                        minZoom = this._map.getMinZoom(),
    879931                        radius = this.options.maxClusterRadius,
    880932                        radiusFn = radius;
     
    895947       
    896948                //Set up DistanceGrids for each zoom
    897                 for (var zoom = maxZoom; zoom >= 0; zoom--) {
     949                for (var zoom = maxZoom; zoom >= minZoom; zoom--) {
    898950                        this._gridClusters[zoom] = new L.DistanceGrid(radiusFn(zoom));
    899951                        this._gridUnclustered[zoom] = new L.DistanceGrid(radiusFn(zoom));
     
    901953
    902954                // Instantiate the appropriate L.MarkerCluster class (animated or not).
    903                 this._topClusterLevel = new this._markerCluster(this, -1);
     955                this._topClusterLevel = new this._markerCluster(this, minZoom - 1);
    904956        },
    905957
     
    908960                var gridClusters = this._gridClusters,
    909961                    gridUnclustered = this._gridUnclustered,
     962                        minZoom = this._map.getMinZoom(),
    910963                    markerPoint, z;
    911964
     
    914967                }
    915968
    916                 layer.on('move', this._childMarkerMoved, this);
     969                layer.on(this._childMarkerEventHandlers, this);
    917970
    918971                //Find the lowest zoom level to slot this one in
    919                 for (; zoom >= 0; zoom--) {
     972                for (; zoom >= minZoom; zoom--) {
    920973                        markerPoint = this._map.project(layer.getLatLng(), zoom); // calculate pixel position
    921974
     
    10061059                        this._animationStart();
    10071060                        //Remove clusters now off screen
    1008                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, this._getExpandedVisibleBounds());
     1061                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._map.getMinZoom(), this._zoom, this._getExpandedVisibleBounds());
    10091062
    10101063                        this._animationZoomIn(this._zoom, mapZoom);
     
    11301183                },
    11311184                _animationZoomIn: function (previousZoomLevel, newZoomLevel) {
    1132                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
     1185                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._map.getMinZoom(), previousZoomLevel);
    11331186                        this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
    11341187
     
    11371190                },
    11381191                _animationZoomOut: function (previousZoomLevel, newZoomLevel) {
    1139                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
     1192                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._map.getMinZoom(), previousZoomLevel);
    11401193                        this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
    11411194
     
    11571210                _animationZoomIn: function (previousZoomLevel, newZoomLevel) {
    11581211                        var bounds = this._getExpandedVisibleBounds(),
    1159                             fg     = this._featureGroup,
     1212                            fg = this._featureGroup,
     1213                                minZoom = this._map.getMinZoom(),
    11601214                            i;
    11611215
     
    11631217
    11641218                        //Add all children of current clusters to map and remove those clusters from map
    1165                         this._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
     1219                        this._topClusterLevel._recursively(bounds, previousZoomLevel, minZoom, function (c) {
    11661220                                var startPos = c._latlng,
    11671221                                    markers  = c._markers,
     
    12131267                        this._enqueue(function () {
    12141268                                //update the positions of the just added clusters/markers
    1215                                 this._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
     1269                                this._topClusterLevel._recursively(bounds, previousZoomLevel, minZoom, function (c) {
    12161270                                        fg.removeLayer(c);
    12171271                                        c.clusterShow();
     
    12281282                        this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
    12291283                        //Remove markers that were on the map before but won't be now
    1230                         this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel, this._getExpandedVisibleBounds());
     1284                        this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._map.getMinZoom(), previousZoomLevel, this._getExpandedVisibleBounds());
    12311285                },
    12321286
     
    12651319        // Private methods for animated versions.
    12661320        _animationZoomOutSingle: function (cluster, previousZoomLevel, newZoomLevel) {
    1267                 var bounds = this._getExpandedVisibleBounds();
     1321                var bounds = this._getExpandedVisibleBounds(),
     1322                        minZoom = this._map.getMinZoom();
    12681323
    12691324                //Animate all of the markers in the clusters to move to their cluster center point
    1270                 cluster._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, previousZoomLevel + 1, newZoomLevel);
     1325                cluster._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, minZoom, previousZoomLevel + 1, newZoomLevel);
    12711326
    12721327                var me = this;
     
    12911346                                }
    12921347                        } else {
    1293                                 cluster._recursively(bounds, newZoomLevel, 0, function (c) {
    1294                                         c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel + 1);
     1348                                cluster._recursively(bounds, newZoomLevel, minZoom, function (c) {
     1349                                        c._recursivelyRemoveChildrenFromMap(bounds, minZoom, previousZoomLevel + 1);
    12951350                                });
    12961351                        }
     
    15371592
    15381593        _recursivelyAnimateChildrenIn: function (bounds, center, maxZoom) {
    1539                 this._recursively(bounds, 0, maxZoom - 1,
     1594                this._recursively(bounds, this._group._map.getMinZoom(), maxZoom - 1,
    15401595                        function (c) {
    15411596                                var markers = c._markers,
     
    15651620        },
    15661621
    1567         _recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, previousZoomLevel, newZoomLevel) {
    1568                 this._recursively(bounds, newZoomLevel, 0,
     1622        _recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, mapMinZoom, previousZoomLevel, newZoomLevel) {
     1623                this._recursively(bounds, newZoomLevel, mapMinZoom,
    15691624                        function (c) {
    15701625                                c._recursivelyAnimateChildrenIn(bounds, c._group._map.latLngToLayerPoint(c.getLatLng()).round(), previousZoomLevel);
     
    15741629                                if (c._isSingleParent() && previousZoomLevel - 1 === newZoomLevel) {
    15751630                                        c.clusterShow();
    1576                                         c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
     1631                                        c._recursivelyRemoveChildrenFromMap(bounds, mapMinZoom, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
    15771632                                } else {
    15781633                                        c.clusterHide();
     
    15851640
    15861641        _recursivelyBecomeVisible: function (bounds, zoomLevel) {
    1587                 this._recursively(bounds, 0, zoomLevel, null, function (c) {
     1642                this._recursively(bounds, this._group._map.getMinZoom(), zoomLevel, null, function (c) {
    15881643                        c.clusterShow();
    15891644                });
     
    15911646
    15921647        _recursivelyAddChildrenToMap: function (startPos, zoomLevel, bounds) {
    1593                 this._recursively(bounds, -1, zoomLevel,
     1648                this._recursively(bounds, this._group._map.getMinZoom() - 1, zoomLevel,
    15941649                        function (c) {
    15951650                                if (zoomLevel === c._zoom) {
     
    16531708
    16541709        //exceptBounds: If set, don't remove any markers/clusters in it
    1655         _recursivelyRemoveChildrenFromMap: function (previousBounds, zoomLevel, exceptBounds) {
     1710        _recursivelyRemoveChildrenFromMap: function (previousBounds, mapMinZoom, zoomLevel, exceptBounds) {
    16561711                var m, i;
    1657                 this._recursively(previousBounds, -1, zoomLevel - 1,
     1712                this._recursively(previousBounds, mapMinZoom - 1, zoomLevel - 1,
    16581713                        function (c) {
    16591714                                //Remove markers at every level
     
    23362391                                continue;
    23372392                        }
     2393
     2394                        //Close any popup on the marker first, otherwise setting the location of the marker will make the map scroll
     2395                        m.closePopup();
    23382396
    23392397                        //Fix up the location to the real one
  • _plugins_/gis/trunk/paquet.xml

    r103720 r103986  
    22        prefix="gis"
    33        categorie="divers"
    4         version="4.43.2"
     4        version="4.43.3"
    55        schema="2.1.0"
    66        etat="stable"
Note: See TracChangeset for help on using the changeset viewer.