ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Adding paging and cluster strategies. The paging strategy intercepts a batch of features bound for the layer and caches them, giving the layer one page at a time. The cluster strategy intercepts a batch of features and groups proximate features as clusters - giving the clusters to the layer instead. Thanks for the careful review Erik. r=euzuro (see #1606).

Browse Source 
git-svn-id: http://svn.openlayers.org/trunk/openlayers@8003 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
This commit is contained in:
Tim Schaub
2008-09-12 08:58:23 +00:00
parent 3ad82c119a
commit 4ad8f2118c
10 changed files with 1697 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/OpenLayers.js
+2
View File
@@ -185,6 +185,8 @@
"OpenLayers/Layer/Vector.js",
"OpenLayers/Strategy.js",
"OpenLayers/Strategy/Fixed.js",
"OpenLayers/Strategy/Cluster.js",
"OpenLayers/Strategy/Paging.js",
"OpenLayers/Strategy/BBOX.js",
"OpenLayers/Protocol.js",
"OpenLayers/Protocol/HTTP.js",
lib/OpenLayers/Layer/Vector.js
+21 -5
View File
@@ -38,7 +38,12 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
* Supported map event types (in addition to those from <OpenLayers.Layer>):
* - *beforefeatureadded* Triggered before a feature is added. Listeners
* will receive an object with a *feature* property referencing the
* feature to be added.
* feature to be added. To stop the feature from being added, a
* listener should return false.
* - *beforefeaturesadded* Triggered before an array of features is added.
* Listeners will receive an object with a *features* property
* referencing the feature to be added. To stop the features from
* being added, a listener should return false.
* - *featureadded* Triggered after a feature is added. The event
* object passed to listeners will have a *feature* property with a
* reference to the added feature.
@@ -72,7 +77,8 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
* - *refresh* Triggered when something wants a strategy to ask the protocol
* for a new set of features.
*/
EVENT_TYPES: ["beforefeatureadded", "featureadded", "featuresadded",
EVENT_TYPES: ["beforefeatureadded", "beforefeaturesadded",
"featureadded", "featuresadded",
"beforefeatureremoved", "featureremoved", "featuresremoved",
"beforefeatureselected", "featureselected", "featureunselected",
"beforefeaturemodified", "featuremodified", "afterfeaturemodified",
@@ -443,6 +449,15 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
}
var notify = !options || !options.silent;
if(notify) {
var event = {features: features};
var ret = this.events.triggerEvent("beforefeaturesadded", event);
if(ret === false) {
return;
}
features = event.features;
}
for (var i=0, len=features.length; i<len; i++) {
if (i != (features.length - 1)) {
@@ -469,9 +484,10 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
}
if (notify) {
this.events.triggerEvent("beforefeatureadded", {
feature: feature
});
if(this.events.triggerEvent("beforefeatureadded",
{feature: feature}) === false) {
continue;
};
this.preFeatureInsert(feature);
}
lib/OpenLayers/Strategy/Cluster.js
+261
View File
@@ -0,0 +1,261 @@
/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
* license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
* full text of the license. */
/**
* @requires OpenLayers/Strategy.js
*/
/**
* Class: OpenLayers.Strategy.Cluster
* Strategy for vector feature clustering.
*
* Inherits from:
* - <OpenLayers.Strategy>
*/
OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, {
/**
* Property: layer
* {<OpenLayers.Layer.Vector>} The layer that this strategy is assigned to.
*/
layer: null,
/**
* APIProperty: distance
* {Integer} Pixel distance between features that should be considered a
* single cluster. Default is 20 pixels.
*/
distance: 20,
/**
* Property: features
* {Array(<OpenLayers.Feature.Vector>)} Cached features.
*/
features: null,
/**
* Property: clusters
* {Array(<OpenLayers.Feature.Vector>)} Calculated clusters.
*/
clusters: null,
/**
* Property: clustering
* {Boolean} The strategy is currently clustering features.
*/
clustering: false,
/**
* Property: resolution
* {Float} The resolution (map units per pixel) of the current cluster set.
*/
resolution: null,
/**
* Constructor: OpenLayers.Strategy.Cluster
* Create a new clustering strategy.
*
* Parameters:
* options - {Object} Optional object whose properties will be set on the
* instance.
*/
initialize: function(options) {
OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: activate
* Activate the strategy. Register any listeners, do appropriate setup.
*
* Returns:
* {Boolean} The strategy was successfully activated.
*/
activate: function() {
var activated = OpenLayers.Strategy.prototype.activate.call(this);
if(activated) {
this.layer.events.on({
"beforefeaturesadded": this.cacheFeatures,
scope: this
});
this.layer.map.events.on({"zoomend": this.cluster, scope: this});
}
return activated;
},
/**
* APIMethod: deactivate
* Deactivate the strategy. Unregister any listeners, do appropriate
* tear-down.
*
* Returns:
* {Boolean} The strategy was successfully deactivated.
*/
deactivate: function() {
var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
if(deactivated) {
this.clearCache();
this.layer.events.un({
"beforefeaturesadded": this.cacheFeatures,
scope: this
});
this.layer.map.events.un({"zoomend": this.cluster, scope: this});
}
return deactivated;
},
/**
* Method: cacheFeatures
* Cache features before they are added to the layer.
*
* Parameters:
* event - {Object} The event that this was listening for. This will come
* with a batch of features to be clustered.
*
* Returns:
* {Boolean} False to stop layer from being added to the layer.
*/
cacheFeatures: function(event) {
var propagate = true;
if(!this.clustering) {
this.clearCache();
this.features = event.features;
this.cluster();
propagate = false;
}
return propagate;
},
/**
* Method: clearCache
* Clear out the cached features. This destroys features, assuming
* nothing else has a reference.
*/
clearCache: function() {
if(this.features) {
for(var i=0; i<this.features.length; ++i) {
this.features[i].destroy();
}
}
this.features = null;
},
/**
* Method: cluster
* Cluster features based on some threshold distance.
*/
cluster: function() {
if(this.features) {
var resolution = this.layer.getResolution();
if(resolution != this.resolution || !this.clustersExist()) {
this.resolution = resolution;
var clusters = [];
var feature, clustered, cluster;
for(var i=0; i<this.features.length; ++i) {
feature = this.features[i];
clustered = false;
for(var j=0; j<clusters.length; ++j) {
cluster = clusters[j];
if(this.shouldCluster(cluster, feature)) {
this.addToCluster(cluster, feature);
clustered = true;
break;
}
}
if(!clustered) {
clusters.push(this.createCluster(this.features[i]));
}
}
this.layer.destroyFeatures();
if(clusters.length > 0) {
this.clustering = true;
// A legitimate feature addition could occur during this
// addFeatures call. For clustering to behave well, features
// should be removed from a layer before requesting a new batch.
this.layer.addFeatures(clusters);
this.clustering = false;
}
this.clusters = clusters;
}
}
},
/**
* Method: clustersExist
* Determine whether calculated clusters are already on the layer.
*
* Returns:
* {Boolean} The calculated clusters are already on the layer.
*/
clustersExist: function() {
var exist = false;
if(this.clusters && this.clusters.length > 0 &&
this.clusters.length == this.layer.features.length) {
exist = true;
for(var i=0; i<this.clusters.length; ++i) {
if(this.clusters[i] != this.layer.features[i]) {
exist = false;
break;
}
}
}
return exist;
},
/**
* Method: shouldCluster
* Determine whether to include a feature in a given cluster.
*
* Parameters:
* cluster - {<OpenLayers.Feature.Vector>} A cluster.
* feature - {<OpenLayers.Feature.Vector>} A feature.
*
* Returns:
* {Boolean} The feature should be included in the cluster.
*/
shouldCluster: function(cluster, feature) {
var cc = cluster.geometry.getBounds().getCenterLonLat();
var fc = feature.geometry.getBounds().getCenterLonLat();
var distance = (
Math.sqrt(
Math.pow((cc.lon - fc.lon), 2) + Math.pow((cc.lat - fc.lat), 2)
) / this.resolution
);
return (distance <= this.distance);
},
/**
* Method: addToCluster
* Add a feature to a cluster.
*
* Parameters:
* cluster - {<OpenLayers.Feature.Vector>} A cluster.
* feature - {<OpenLayers.Feature.Vector>} A feature.
*/
addToCluster: function(cluster, feature) {
cluster.cluster.push(feature);
cluster.attributes.count += 1;
},
/**
* Method: createCluster
* Given a feature, create a cluster.
*
* Parameters:
* feature - {<OpenLayers.Feature.Vector>}
*
* Returns:
* {<OpenLayers.Feature.Vector>} A cluster.
*/
createCluster: function(feature) {
var center = feature.geometry.getBounds().getCenterLonLat();
var cluster = new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(center.lon, center.lat),
{count: 1}
);
cluster.cluster = [feature];
return cluster;
},
CLASS_NAME: "OpenLayers.Strategy.Cluster"
});
lib/OpenLayers/Strategy/Paging.js
+241
View File
@@ -0,0 +1,241 @@
/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
* license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
* full text of the license. */
/**
* @requires OpenLayers/Strategy.js
*/
/**
* Class: OpenLayers.Strategy.Paging
* Strategy for vector feature paging
*
* Inherits from:
* - <OpenLayers.Strategy>
*/
OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, {
/**
* Property: layer
* {<OpenLayers.Layer.Vector>} The layer that this strategy is assigned to.
*/
layer: null,
/**
* Property: features
* {Array(<OpenLayers.Feature.Vector>)} Cached features.
*/
features: null,
/**
* Property: length
* {Integer} Number of features per page. Default is 10.
*/
length: 10,
/**
* Property: num
* {Integer} The currently displayed page number.
*/
num: null,
/**
* Property: paging
* {Boolean} The strategy is currently changing pages.
*/
paging: false,
/**
* Constructor: OpenLayers.Strategy.Paging
* Create a new paging strategy.
*
* Parameters:
* options - {Object} Optional object whose properties will be set on the
* instance.
*/
initialize: function(options) {
OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: activate
* Activate the strategy. Register any listeners, do appropriate setup.
*
* Returns:
* {Boolean} The strategy was successfully activated.
*/
activate: function() {
var activated = OpenLayers.Strategy.prototype.activate.call(this);
if(activated) {
this.layer.events.on({
"beforefeaturesadded": this.cacheFeatures,
scope: this
});
}
return activated;
},
/**
* APIMethod: deactivate
* Deactivate the strategy. Unregister any listeners, do appropriate
* tear-down.
*
* Returns:
* {Boolean} The strategy was successfully deactivated.
*/
deactivate: function() {
var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
if(deactivated) {
this.clearCache();
this.layer.events.un({
"beforefeaturesadded": this.cacheFeatures,
scope: this
});
}
return deactivated;
},
/**
* Method: cacheFeatures
* Cache features before they are added to the layer.
*
* Parameters:
* event - {Object} The event that this was listening for. This will come
* with a batch of features to be paged.
*/
cacheFeatures: function(event) {
if(!this.paging) {
this.clearCache();
this.features = event.features;
this.pageNext(event);
}
},
/**
* Method: clearCache
* Clear out the cached features. This destroys features, assuming
* nothing else has a reference.
*/
clearCache: function() {
if(this.features) {
for(var i=0; i<this.features.length; ++i) {
this.features[i].destroy();
}
}
this.features = null;
this.num = null;
},
/**
* APIMethod: pageCount
* Get the total count of pages given the current cache of features.
*
* Returns:
* {Integer} The page count.
*/
pageCount: function() {
var numFeatures = this.features ? this.features.length : 0;
return Math.ceil(numFeatures / this.length);
},
/**
* APIMethod: pageNum
* Get the zero based page number.
*
* Returns:
* {Integer} The current page number being displayed.
*/
pageNum: function() {
return this.num;
},
/**
* APIMethod: pageLength
* Gets or sets page length.
*
* Parameters:
* newLength: {Integer} Optional length to be set.
*
* Returns:
* {Integer} The length of a page (number of features per page).
*/
pageLength: function(newLength) {
if(newLength && newLength > 0) {
this.length = newLength;
}
return this.length;
},
/**
* APIMethod: pageNext
* Display the next page of features.
*
* Returns:
* {Boolean} A new page was displayed.
*/
pageNext: function(event) {
var changed = false;
if(this.features) {
if(this.num === null) {
this.num = -1;
}
var start = (this.num + 1) * this.length;
changed = this.page(start, event);
}
return changed;
},
/**
* APIMethod: pagePrevious
* Display the previous page of features.
*
* Returns:
* {Boolean} A new page was displayed.
*/
pagePrevious: function() {
var changed = false;
if(this.features) {
if(this.num === null) {
this.num = this.pageCount();
}
var start = (this.num - 1) * this.length;
changed = this.page(start);
}
return changed;
},
/**
* Method: page
* Display the page starting at the given index from the cache.
*
* Returns:
* {Boolean} A new page was displayed.
*/
page: function(start, event) {
var changed = false;
if(this.features) {
if(start >= 0 && start < this.features.length) {
var num = Math.floor(start / this.length);
if(num != this.num) {
this.paging = true;
var features = this.features.slice(start, start + this.length);
this.layer.removeFeatures(this.layer.features);
this.num = num;
// modify the event if any
if(event && event.features) {
// this.was called by an event listener
event.features = features;
} else {
// this was called directly on the strategy
this.layer.addFeatures(features);
}
this.paging = false;
changed = true;
}
}
}
return changed;
},
CLASS_NAME: "OpenLayers.Strategy.Paging"
});