[Pkg-javascript-commits] [leaflet-markercluster] 211/479: Refactoring EVERYTHING to work towards #43
Jonas Smedegaard
dr at jones.dk
Thu Oct 16 16:00:30 UTC 2014
This is an automated email from the git hooks/post-receive script.
js pushed a commit to branch master
in repository leaflet-markercluster.
commit 824a31deaf963eeaf85918f38829e0c5761732d5
Author: danzel <danzel at localhost.geek.nz>
Date: Mon Sep 10 17:11:41 2012 +1200
Refactoring EVERYTHING to work towards #43
DistanceGrid no longer messes with the things added to it, means that markers can be in multiple DistanceGrids without trouble.
Heaps of dead code left in, only the basics work at the moment.
Cluster icon position is wrong at the bottom zoom level (real world 388), needs fixing.
---
src/DistanceGrid.js | 39 ++++++----
src/MarkerCluster.js | 119 ++++++++++++++++++++---------
src/MarkerClusterGroup.js | 187 ++++++++++++++++++++++++++++++----------------
3 files changed, 232 insertions(+), 113 deletions(-)
diff --git a/src/DistanceGrid.js b/src/DistanceGrid.js
index e7632fd..8235c61 100644
--- a/src/DistanceGrid.js
+++ b/src/DistanceGrid.js
@@ -3,6 +3,7 @@ L.DistanceGrid = function (cellSize) {
this._cellSize = cellSize;
this._sqCellSize = cellSize * cellSize;
this._grid = {};
+ this._objectPoint = { };
};
L.DistanceGrid.prototype = {
@@ -12,10 +13,10 @@ L.DistanceGrid.prototype = {
y = this._getCoord(point.y),
grid = this._grid,
row = grid[y] = grid[y] || {},
- cell = row[x] = row[x] || [];
+ cell = row[x] = row[x] || [],
+ stamp = L.Util.stamp(obj);
- obj._dGridCell = cell;
- obj._dGridPoint = point;
+ this._objectPoint[stamp] = point;
cell.push(obj);
},
@@ -25,25 +26,30 @@ L.DistanceGrid.prototype = {
this.addObject(obj, point);
},
- removeObject: function (obj) {
- var oldCell = obj._dGridCell,
- point = obj._dGridPoint,
- i, len, x, y;
+ //Returns true if the object was found
+ removeObject: function (obj, point) {
+ var x = this._getCoord(point.x),
+ y = this._getCoord(point.y),
+ grid = this._grid,
+ row = grid[y] = grid[y] || {},
+ cell = row[x] = row[x] || [],
+ i, len;
+
+ delete this._objectPoint[L.Util.stamp(obj)];
- for (i = 0, len = oldCell.length; i < len; i++) {
- if (oldCell[i] === obj) {
+ for (i = 0, len = cell.length; i < len; i++) {
+ if (cell[i] === obj) {
- oldCell.splice(i, 1);
+ cell.splice(i, 1);
if (len === 1) {
- x = this._getCoord(point.x);
- y = this._getCoord(point.y);
- delete this._grid[y][x];
+ delete row[x];
}
- break;
+ return true;
}
}
+
},
eachObject: function (fn, context) {
@@ -75,8 +81,9 @@ L.DistanceGrid.prototype = {
var x = this._getCoord(point.x),
y = this._getCoord(point.y),
i, j, k, row, cell, len, obj, dist,
+ objectPoint = this._objectPoint,
closestDistSq = this._sqCellSize,
- closest = null;
+ closest = null;
for (i = y - 1; i <= y + 1; i++) {
row = this._grid[i];
@@ -88,7 +95,7 @@ L.DistanceGrid.prototype = {
for (k = 0, len = cell.length; k < len; k++) {
obj = cell[k];
- dist = this._sqDist(obj._dGridPoint, point);
+ dist = this._sqDist(objectPoint[L.Util.stamp(obj)], point);
if (dist < closestDistSq) {
closestDistSq = dist;
closest = obj;
diff --git a/src/MarkerCluster.js b/src/MarkerCluster.js
index 3106840..f381404 100644
--- a/src/MarkerCluster.js
+++ b/src/MarkerCluster.js
@@ -1,6 +1,11 @@
L.MarkerCluster = L.Marker.extend({
- initialize: function (group, a, b) {
+ initialize: function (group, zoom, a, b) {
+
+ L.Marker.prototype.initialize.call(this, a ? (a._cLatLng || a.getLatLng()) : new L.LatLng(0, 0), { icon: this });
+
+
this._group = group;
+ this._zoom = zoom;
this._markers = [];
this._childClusters = [];
@@ -41,29 +46,75 @@ L.MarkerCluster = L.Marker.extend({
this._group._map.fitBounds(this._bounds);
},
- _baseInit: function () {
- this._latlng = this._wLatLng;
- L.Marker.prototype.initialize.call(this, this._latlng, { icon: this._group.options.iconCreateFunction(this) });
+ //Cludge for Icon
+ createIcon: function () {
+ if (!this._latlng) {
+ this._latlng = this._wLatLng;
+ }
+ return this._group.options.iconCreateFunction(this).createIcon();
+ },
+ createShadow: function () {
+ return this._group.options.iconCreateFunction(this).createShadow(); //FIXME: Should be saving this
},
- _addChild: function (new1) {
+ _addChild: function (new1, isNotificationFromChild) {
this._expandBounds(new1);
if (new1 instanceof L.MarkerCluster) {
- this._childClusters.push(new1);
+ if (!isNotificationFromChild) {
+ this._childClusters.push(new1);
+ new1._parent = this;
+ }
this._childCount += new1._childCount;
} else {
- this._markers.push(new1);
+ if (!isNotificationFromChild) {
+ this._markers.push(new1);
+ }
this._childCount++;
}
+ if (this._childCount > 10)
+ //debugger;
+
if (this._icon) {
this.setIcon(this._group.options.iconCreateFunction(this));
}
+ if (this._parent) {
+ this._parent._addChild(new1, true);
+ }
},
- _expandBounds: function (marker) {
+ _removeChildMarker: function (marker) {
+ var markers = this._markers,
+ group = this._group, i;
+ for (i = markers.length - 1; i >= 0; i--) {
+ if (markers[i] === marker) {
+ if (markers[i]._icon) {
+ L.FeatureGroup.prototype.removeLayer.call(group, markers[i]);
+ }
+
+ markers.splice(i, 1);
+
+ var p = this;
+ while (p) {
+ p._childCount--;
+ p._recalculateBounds();
+ p = p._parent;
+ }
+
+ //TODO?
+ //if (!('_zoom' in this)) {
+ // this.setIcon(group.options.iconCreateFunction(this));
+ //}
+ return true;
+ }
+ }
+
+ },
+
+ //Expand our bounds and tell our parent to
+ _expandBounds: function (marker) {
var addedCount,
addedLatLng = marker._wLatLng || marker._latlng;
@@ -311,16 +362,16 @@ L.MarkerCluster = L.Marker.extend({
);
},
- _recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, depthToStartAt, depthToAnimateIn) {
- this._recursively(bounds, depthToStartAt, 0,
+ _recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, previousZoomLevel, newZoomLevel) {
+ this._recursively(bounds, newZoomLevel, 0,
function (c) {
- c._recursivelyAnimateChildrenIn(bounds, c._group._map.latLngToLayerPoint(c.getLatLng()).round(), depthToAnimateIn);
+ c._recursivelyAnimateChildrenIn(bounds, c._group._map.latLngToLayerPoint(c.getLatLng()).round(), previousZoomLevel);
//TODO: depthToAnimateIn affects _isSingleParent, if there is a multizoom we may/may not be.
//As a hack we only do a animation free zoom on a single level zoom, if someone does multiple levels then we always animate
- if (c._isSingleParent() && depthToAnimateIn === 1) {
+ if (c._isSingleParent() && previousZoomLevel - 1 === newZoomLevel) {
c.setOpacity(1);
- c._recursivelyRemoveChildrenFromMap(bounds, depthToAnimateIn - 1); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
+ c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
} else {
c.setOpacity(0);
}
@@ -330,16 +381,16 @@ L.MarkerCluster = L.Marker.extend({
);
},
- _recursivelyBecomeVisible: function (bounds, depth) {
- this._recursively(bounds, 0, depth, null, function (c) {
+ _recursivelyBecomeVisible: function (bounds, zoomLevel) {
+ this._recursively(bounds, 0, zoomLevel, null, function (c) {
c.setOpacity(1);
});
},
- _recursivelyAddChildrenToMap: function (startPos, depth, bounds) {
- this._recursively(bounds, 0, depth,
- function (c, recursionDepth) {
- if (recursionDepth === 0) {
+ _recursivelyAddChildrenToMap: function (startPos, zoomLevel, bounds) {
+ this._recursively(bounds, 0, zoomLevel,
+ function (c) {
+ if (zoomLevel === c._zoom) {
return;
}
@@ -363,12 +414,11 @@ L.MarkerCluster = L.Marker.extend({
},
function (c) {
c._addToMap(startPos);
-
}
);
},
- _recursivelyRestoreChildPositions: function (depth) {
+ _recursivelyRestoreChildPositions: function (zoomLevel) {
//Fix positions of child markers
for (var i = this._markers.length - 1; i >= 0; i--) {
var nm = this._markers[i];
@@ -378,14 +428,14 @@ L.MarkerCluster = L.Marker.extend({
}
}
- if (depth === 1) {
+ if (zoomLevel - 1 == this._zoom) {
//Reposition child clusters
for (var j = this._childClusters.length - 1; j >= 0; j--) {
this._childClusters[j]._restorePosition();
}
} else {
for (var k = this._childClusters.length - 1; k >= 0; k--) {
- this._childClusters[k]._recursivelyRestoreChildPositions(depth - 1);
+ this._childClusters[k]._recursivelyRestoreChildPositions(zoomLevel);
}
}
},
@@ -398,9 +448,9 @@ L.MarkerCluster = L.Marker.extend({
},
//exceptBounds: If set, don't remove any markers/clusters in it
- _recursivelyRemoveChildrenFromMap: function (previousBounds, depth, exceptBounds) {
+ _recursivelyRemoveChildrenFromMap: function (previousBounds, zoomLevel, exceptBounds) {
var m, i;
- this._recursively(previousBounds, 0, depth,
+ this._recursively(previousBounds, -1, zoomLevel - 1,
function (c) {
//Remove markers at every level
for (i = c._markers.length - 1; i >= 0; i--) {
@@ -426,36 +476,37 @@ L.MarkerCluster = L.Marker.extend({
//Run the given functions recursively to this and child clusters
// boundsToApplyTo: a L.LatLngBounds representing the bounds of what clusters to recurse in to
- // depthToStartAt: the depth to start calling the given functions
- // timesToRecurse: how many layers deep to recurse in to after hitting depthToStartAt, bottom level: depthToRunFor == 0
+ // zoomLevelToStart: zoom level to start running functions (inclusive)
+ // zoomLevelToStop: zoom level to stop running functions (inclusive)
// runAtEveryLevel: function that takes an L.MarkerCluster as an argument that should be applied on every level
// runAtBottomLevel: function that takes an L.MarkerCluster as an argument that should be applied at only the bottom level
- _recursively: function (boundsToApplyTo, depthToStartAt, timesToRecurse, runAtEveryLevel, runAtBottomLevel) {
+ _recursively: function (boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel) {
var childClusters = this._childClusters,
+ zoom = this._zoom,
i, c;
- if (depthToStartAt > 0) { //Still going down to required depth, just recurse to child clusters
+ if (zoomLevelToStart > zoom) { //Still going down to required depth, just recurse to child clusters
for (i = childClusters.length - 1; i >= 0; i--) {
c = childClusters[i];
if (boundsToApplyTo.intersects(c._bounds)) {
- c._recursively(boundsToApplyTo, depthToStartAt - 1, timesToRecurse, runAtEveryLevel, runAtBottomLevel);
+ c._recursively(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel);
}
}
} else { //In required depth
if (runAtEveryLevel) {
- runAtEveryLevel(this, timesToRecurse);
+ runAtEveryLevel(this);
}
- if (timesToRecurse === 0 && runAtBottomLevel) {
+ if (runAtBottomLevel && this._zoom == zoomLevelToStop) {
runAtBottomLevel(this);
}
//TODO: This loop is almost the same as above
- if (timesToRecurse > 0) {
+ if (zoomLevelToStop > zoom) {
for (i = childClusters.length - 1; i >= 0; i--) {
c = childClusters[i];
if (boundsToApplyTo.intersects(c._bounds)) {
- c._recursively(boundsToApplyTo, depthToStartAt, timesToRecurse - 1, runAtEveryLevel, runAtBottomLevel);
+ c._recursively(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel);
}
}
}
diff --git a/src/MarkerClusterGroup.js b/src/MarkerClusterGroup.js
index a1a2b15..56a8e67 100644
--- a/src/MarkerClusterGroup.js
+++ b/src/MarkerClusterGroup.js
@@ -35,6 +35,8 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
this._needsClustering = [];
//The bounds of the currently shown area (from _getExpandedVisibleBounds) Updated on zoom/move
this._currentShownBounds = null;
+
+ this._topClusterLevel = new L.MarkerCluster(this, -1);
},
addLayer: function (layer) {
@@ -74,7 +76,9 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
this._unspiderfy();
}
- var newCluster = this._topClusterLevel._recursivelyAddLayer(layer, this._topClusterLevel._zoom - 1);
+ var newCluster = this._addLayer(layer, this._maxZoom);
+
+ //TODO: Find the highest visible blah
if (this.options.animateAddingMarkers) {
this._animationAddLayer(layer, newCluster);
@@ -120,6 +124,10 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
}
}
+ //Clear the DistanceGrids
+ this._gridClusters = { };
+ this._gridUnclustered = { };
+
//Reset _topClusterLevel
this._generateInitialClusters();
@@ -144,15 +152,14 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
onAdd: function (map) {
L.FeatureGroup.prototype.onAdd.call(this, map);
- if (!this._topClusterLevel) {
+ if (!this._gridClusters) {
this._generateInitialClusters();
- } else if (this._needsClustering.length > 0) {
- for (var i = this._needsClustering.length - 1; i >= 0; i--) {
- this.addLayer(this._needsClustering[i]);
- }
- this._needsClustering = [];
}
+ for (var i = this._needsClustering.length - 1; i >= 0; i--) {
+ this._addLayer(this._needsClustering[i], this._maxZoom);
+ }
+ this._needsClustering = [];
this._map.on('zoomend', this._zoomEnd, this);
this._map.on('moveend', this._moveEnd, this);
@@ -162,6 +169,16 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
}
this._bindEvents();
+
+
+ //Actually add our markers to the map:
+
+ //Remember the current zoom level and bounds
+ this._zoom = this._map.getZoom();
+ this._currentShownBounds = this._getExpandedVisibleBounds();
+
+ //Make things appear on the map
+ this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
},
//Overrides FeatureGroup.onRemove
@@ -259,12 +276,6 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
}
},
- _sqDist: function (p1, p2) {
- var dx = p2.x - p1.x,
- dy = p2.y - p1.y;
- return dx * dx + dy * dy;
- },
-
_zoomEnd: function () {
if (!this._map) { //May have been removed from the map by a zoomEnd handler
return;
@@ -280,50 +291,98 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
return;
}
- var newBounds = this._getExpandedVisibleBounds(),
- depth = this._zoom - this._topClusterLevel._zoom;
+ var newBounds = this._getExpandedVisibleBounds();
- this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, depth, newBounds);
- this._topClusterLevel._recursivelyAddChildrenToMap(null, depth + 1, newBounds);
+ this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, newBounds);
+ this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, newBounds);
this._currentShownBounds = newBounds;
return;
},
_generateInitialClusters: function () {
- var minZoom = this._map.getMinZoom(),
- maxZoom = this._map.getMaxZoom(),
- currentZoom = this._map.getZoom();
+ var maxZoom = this._map.getMaxZoom(),
+ radius = this.options.maxClusterRadius;
if (this.options.disableClusteringAtZoom) {
maxZoom = this.options.disableClusteringAtZoom - 1;
}
+ this._maxZoom = maxZoom;
+ this._gridClusters = {};
+ this._gridUnclustered = {};
+
+ //Set up DistanceGrids for each zoom
+ for (var zoom = maxZoom; zoom >= 0; zoom--) {
+ this._gridClusters[zoom] = new L.DistanceGrid(radius);
+ this._gridUnclustered[zoom] = new L.DistanceGrid(radius);
+ }
+ },
- //console.time('cluster');
- this._topClusterLevel = this._clusterToMarkerCluster(this._needsClustering, maxZoom);
- this._needsClustering = [];
+ //Zoom: Zoom to start adding at (Pass this._maxZoom to start at the bottom)
+ _addLayer: function (layer, zoom) {
+ var gridClusters = this._gridClusters,
+ gridUnclustered = this._gridUnclustered, markerPoint;
+
+ //Find the lowest zoom level to slot this one in
+ for (; zoom >= 0; zoom--) {
+ markerPoint = this._map.project(layer.getLatLng(), zoom); // calculate pixel position
+
+ //Try find a cluster close by
+ var closest = gridClusters[zoom].getNearObject(markerPoint);
+ if (closest) {
+ closest._addChild(layer);
+ layer.__cluster = closest;
+ return closest;
+ }
- //Generate to the top
- while (minZoom < this._topClusterLevel._zoom) {
- this._topClusterLevel = this._clusterToMarkerCluster(this._topClusterLevel._childClusters.concat(this._topClusterLevel._markers), this._topClusterLevel._zoom - 1);
- }
- //console.timeEnd('cluster');
+ //Try find a marker close by to form a new cluster with
+ closest = gridUnclustered[zoom].getNearObject(markerPoint);
+ if (closest) {
+ if (closest.__cluster) {
+ closest.__cluster._removeChildMarker(closest);
+ }
+ var parent = closest.__cluster || this._topClusterLevel;
- //Remember the current zoom level and bounds
- this._zoom = currentZoom;
- this._currentShownBounds = this._getExpandedVisibleBounds();
+ //Create new cluster with these 2 in it
+ console.log('creating new cluster with 2 markers at zoom ' + zoom);
- //Make things appear on the map
- this._topClusterLevel._recursivelyAddChildrenToMap(null, currentZoom - minZoom + 1, this._currentShownBounds);
+ var newCluster = new L.MarkerCluster(this, zoom, closest, layer);
+ gridClusters[zoom].addObject(newCluster, this._map.project(closest.getLatLng(), zoom));
+ closest.__cluster = newCluster;
+ layer.__cluster = newCluster;
+
+ //First create any new intermediate parent clusters that don't exist
+ var lastParent = newCluster;
+ for (var z = zoom - 1; z > parent._zoom; z--) {
+ lastParent = new L.MarkerCluster(this, z, lastParent);
+ gridClusters[z].addObject(lastParent, this._map.project(closest.getLatLng(), z));
+ }
+ parent._addChild(lastParent);
+
+ //Remove closest from this zoom level and any above that it is in, replace with newCluster
+ for (var z = zoom; z >= 0; z--) {
+ if (!gridUnclustered[z].removeObject(closest, this._map.project(closest.getLatLng(), z))) {
+ break;
+ }
+ }
+
+ return newCluster;
+ }
+
+ //Didn't manage to cluster in at this zoom, record us as a marker here and continue upwards
+ gridUnclustered[zoom].addObject(layer, markerPoint);
+ }
+
+ return layer;
},
//Merge and split any existing clusters that are too big or small
_mergeSplitClusters: function () {
-
+ console.log('mergesplit ' + this._zoom + ' -> ' + map._zoom);
if (this._zoom < this._map._zoom) { //Zoom in, split
this._animationStart();
//Remove clusters now off screen
- this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom - this._topClusterLevel._zoom, this._getExpandedVisibleBounds());
+ this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, this._getExpandedVisibleBounds());
this._animationZoomIn(this._zoom, this._map._zoom);
@@ -349,17 +408,24 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
return null;
},
-
+
//Takes a list of objects that have a 'getLatLng()' function (Marker / MarkerCluster)
//Performs clustering on them (using a greedy algorithm) and returns those clusters.
//markers: List of Markers/MarkerClusters to cluster
//Returns { 'clusters': [new clusters], 'unclustered': [unclustered markers] }
_cluster: function (markers, zoom) {
var radius = this.options.maxClusterRadius,
- clusters = new L.DistanceGrid(radius),
- unclustered = new L.DistanceGrid(radius),
+ clusters = this._gridClusters[zoom],
+ unclustered = this._gridUnclustered[zoom],
i, j, marker, markerPoint, cluster, newCluster;
+ if (!clusters) {
+ clusters = new L.DistanceGrid(radius);
+ unclustered = new L.DistanceGrid(radius);
+ this._gridClusters[zoom] = clusters;
+ this._gridUnclustered[zoom] = unclustered;
+ }
+
// go through each point
for (i = markers.length - 1; i >= 0; i--) {
marker = markers[i];
@@ -456,12 +522,12 @@ L.MarkerClusterGroup.include(!L.DomUtil.TRANSITION ? {
//Do nothing...
},
_animationZoomIn: function (previousZoomLevel, newZoomLevel) {
- this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel - this._topClusterLevel._zoom);
- this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel - this._topClusterLevel._zoom + 1, this._getExpandedVisibleBounds());
+ this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
+ this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
},
_animationZoomOut: function (previousZoomLevel, newZoomLevel) {
- this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel - this._topClusterLevel._zoom);
- this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel - this._topClusterLevel._zoom + 1, this._getExpandedVisibleBounds());
+ this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
+ this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
},
_animationAddLayer: function (layer, newCluster) {
this._animationAddLayerNonAnimated(layer, newCluster);
@@ -482,23 +548,21 @@ L.MarkerClusterGroup.include(!L.DomUtil.TRANSITION ? {
_animationZoomIn: function (previousZoomLevel, newZoomLevel) {
var me = this,
bounds = this._getExpandedVisibleBounds(),
- i,
- depthToStartAt = 1 + previousZoomLevel - this._topClusterLevel._zoom,
- depthToDescend = newZoomLevel - previousZoomLevel;
+ i;
//Add all children of current clusters to map and remove those clusters from map
- this._topClusterLevel._recursively(bounds, depthToStartAt, 0, function (c) {
+ this._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
var startPos = c._latlng,
markers = c._markers,
m;
- if (c._isSingleParent() && depthToDescend === 1) { //Immediately add the new child and remove us
+ if (c._isSingleParent() && previousZoomLevel + 1 === newZoomLevel) { //Immediately add the new child and remove us
L.FeatureGroup.prototype.removeLayer.call(me, c);
- c._recursivelyAddChildrenToMap(null, depthToDescend, bounds);
+ c._recursivelyAddChildrenToMap(null, newZoomLevel, bounds);
} else {
//Fade out old cluster
c.setOpacity(0);
- c._recursivelyAddChildrenToMap(startPos, depthToDescend, bounds);
+ c._recursivelyAddChildrenToMap(startPos, newZoomLevel, bounds);
}
//Remove all markers that aren't visible any more
@@ -516,7 +580,7 @@ L.MarkerClusterGroup.include(!L.DomUtil.TRANSITION ? {
var j, n;
//Update opacities
- me._topClusterLevel._recursivelyBecomeVisible(bounds, depthToStartAt + depthToDescend);
+ me._topClusterLevel._recursivelyBecomeVisible(bounds, newZoomLevel);
//TODO Maybe? Update markers in _recursivelyBecomeVisible
for (j in me._layers) {
if (me._layers.hasOwnProperty(j)) {
@@ -529,15 +593,15 @@ L.MarkerClusterGroup.include(!L.DomUtil.TRANSITION ? {
}
//update the positions of the just added clusters/markers
- me._topClusterLevel._recursively(bounds, depthToStartAt, 0, function (c) {
- c._recursivelyRestoreChildPositions(depthToDescend);
+ me._topClusterLevel._recursively(bounds, previousZoomLevel, newZoomLevel, function (c) {
+ c._recursivelyRestoreChildPositions(newZoomLevel);
});
//Remove the old clusters and close the zoom animation
setTimeout(function () {
//update the positions of the just added clusters/markers
- me._topClusterLevel._recursively(bounds, depthToStartAt, 0, function (c) {
+ me._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
L.FeatureGroup.prototype.removeLayer.call(me, c);
});
@@ -546,32 +610,29 @@ L.MarkerClusterGroup.include(!L.DomUtil.TRANSITION ? {
},
_animationZoomOut: function (previousZoomLevel, newZoomLevel) {
- var depthToStartAt = 1 + newZoomLevel - this._topClusterLevel._zoom,
- depthToAnimateIn = previousZoomLevel - newZoomLevel;
-
- this._animationZoomOutSingle(this._topClusterLevel, depthToStartAt, depthToAnimateIn);
+ this._animationZoomOutSingle(this._topClusterLevel, previousZoomLevel, newZoomLevel);
//Need to add markers for those that weren't on the map before but are now
- this._topClusterLevel._recursivelyAddChildrenToMap(null, depthToStartAt, this._getExpandedVisibleBounds());
+ this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
},
- _animationZoomOutSingle: function (marker, depthToStartAt, depthToAnimateIn) {
+ _animationZoomOutSingle: function (marker, previousZoomLevel, newZoomLevel) {
var bounds = this._getExpandedVisibleBounds();
//Animate all of the markers in the clusters to move to their cluster center point
- marker._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, depthToStartAt, depthToAnimateIn);
+ marker._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, previousZoomLevel, newZoomLevel);
var me = this;
//Update the opacity (If we immediately set it they won't animate)
this._forceLayout();
- marker._recursivelyBecomeVisible(bounds, depthToStartAt);
+ marker._recursivelyBecomeVisible(bounds, newZoomLevel);
//TODO: Maybe use the transition timing stuff to make this more reliable
//When the animations are done, tidy up
setTimeout(function () {
- marker._recursively(bounds, depthToStartAt, 0, null, function (c) {
- c._recursivelyRemoveChildrenFromMap(bounds, depthToAnimateIn - 1);
+ marker._recursively(bounds, newZoomLevel, 0, function (c) {
+ c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel);
});
me._animationEnd();
}, 250);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/leaflet-markercluster.git
More information about the Pkg-javascript-commits
mailing list