diff options
Diffstat (limited to 'misc/openlayers/lib/OpenLayers/Strategy/Save.js')
| -rw-r--r-- | misc/openlayers/lib/OpenLayers/Strategy/Save.js | 231 |
1 files changed, 231 insertions, 0 deletions
diff --git a/misc/openlayers/lib/OpenLayers/Strategy/Save.js b/misc/openlayers/lib/OpenLayers/Strategy/Save.js new file mode 100644 index 0000000..2211e95 --- /dev/null +++ b/misc/openlayers/lib/OpenLayers/Strategy/Save.js @@ -0,0 +1,231 @@ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for + * full list of contributors). Published under the 2-clause BSD license. + * See license.txt in the OpenLayers distribution or repository for the + * full text of the license. */ + +/** + * @requires OpenLayers/Strategy.js + */ + +/** + * Class: OpenLayers.Strategy.Save + * A strategy that commits newly created or modified features. By default + * the strategy waits for a call to <save> before persisting changes. By + * configuring the strategy with the <auto> option, changes can be saved + * automatically. + * + * Inherits from: + * - <OpenLayers.Strategy> + */ +OpenLayers.Strategy.Save = OpenLayers.Class(OpenLayers.Strategy, { + + /** + * APIProperty: events + * {<OpenLayers.Events>} An events object that handles all + * events on the strategy object. + * + * Register a listener for a particular event with the following syntax: + * (code) + * strategy.events.register(type, obj, listener); + * (end) + * + * Supported event types: + * start - Triggered before saving + * success - Triggered after a successful transaction + * fail - Triggered after a failed transaction + * + */ + + /** + * Property: events + * {<OpenLayers.Events>} Events instance for triggering this protocol + * events. + */ + events: null, + + /** + * APIProperty: auto + * {Boolean | Number} Auto-save. Default is false. If true, features will be + * saved immediately after being added to the layer and with each + * modification or deletion. If auto is a number, features will be + * saved on an interval provided by the value (in seconds). + */ + auto: false, + + /** + * Property: timer + * {Number} The id of the timer. + */ + timer: null, + + /** + * Constructor: OpenLayers.Strategy.Save + * Create a new Save strategy. + * + * Parameters: + * options - {Object} Optional object whose properties will be set on the + * instance. + */ + initialize: function(options) { + OpenLayers.Strategy.prototype.initialize.apply(this, [options]); + this.events = new OpenLayers.Events(this); + }, + + /** + * 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) { + if(this.auto) { + if(typeof this.auto === "number") { + this.timer = window.setInterval( + OpenLayers.Function.bind(this.save, this), + this.auto * 1000 + ); + } else { + this.layer.events.on({ + "featureadded": this.triggerSave, + "afterfeaturemodified": this.triggerSave, + 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) { + if(this.auto) { + if(typeof this.auto === "number") { + window.clearInterval(this.timer); + } else { + this.layer.events.un({ + "featureadded": this.triggerSave, + "afterfeaturemodified": this.triggerSave, + scope: this + }); + } + } + } + return deactivated; + }, + + /** + * Method: triggerSave + * Registered as a listener. Calls save if a feature has insert, update, + * or delete state. + * + * Parameters: + * event - {Object} The event this function is listening for. + */ + triggerSave: function(event) { + var feature = event.feature; + if(feature.state === OpenLayers.State.INSERT || + feature.state === OpenLayers.State.UPDATE || + feature.state === OpenLayers.State.DELETE) { + this.save([event.feature]); + } + }, + + /** + * APIMethod: save + * Tell the layer protocol to commit unsaved features. If the layer + * projection differs from the map projection, features will be + * transformed into the layer projection before being committed. + * + * Parameters: + * features - {Array} Features to be saved. If null, then default is all + * features in the layer. Features are assumed to be in the map + * projection. + */ + save: function(features) { + if(!features) { + features = this.layer.features; + } + this.events.triggerEvent("start", {features:features}); + var remote = this.layer.projection; + var local = this.layer.map.getProjectionObject(); + if(!local.equals(remote)) { + var len = features.length; + var clones = new Array(len); + var orig, clone; + for(var i=0; i<len; ++i) { + orig = features[i]; + clone = orig.clone(); + clone.fid = orig.fid; + clone.state = orig.state; + if(orig.url) { + clone.url = orig.url; + } + clone._original = orig; + clone.geometry.transform(local, remote); + clones[i] = clone; + } + features = clones; + } + this.layer.protocol.commit(features, { + callback: this.onCommit, + scope: this + }); + }, + + /** + * Method: onCommit + * Called after protocol commit. + * + * Parameters: + * response - {<OpenLayers.Protocol.Response>} A response object. + */ + onCommit: function(response) { + var evt = {"response": response}; + if(response.success()) { + var features = response.reqFeatures; + // deal with inserts, updates, and deletes + var state, feature; + var destroys = []; + var insertIds = response.insertIds || []; + var j = 0; + for(var i=0, len=features.length; i<len; ++i) { + feature = features[i]; + // if projection was different, we may be dealing with clones + feature = feature._original || feature; + state = feature.state; + if(state) { + if(state == OpenLayers.State.DELETE) { + destroys.push(feature); + } else if(state == OpenLayers.State.INSERT) { + feature.fid = insertIds[j]; + ++j; + } + feature.state = null; + } + } + + if(destroys.length > 0) { + this.layer.destroyFeatures(destroys); + } + + this.events.triggerEvent("success", evt); + + } else { + this.events.triggerEvent("fail", evt); + } + }, + + CLASS_NAME: "OpenLayers.Strategy.Save" +}); |