Ticket #1401: WFSTile.patch

tests/Layer/test_WFS.html

@@ -28 +28 @@
-            g_MarkersDestroyed = true;
-        }
-
+        var tGridDestroy = OpenLayers.Layer.Grid.prototype.destroy;
+        OpenLayers.Layer.Grid.prototype.destroy = function() {
+            g_GridDestroyed = true;
+        }
+
-        var layer = {
-            'vectorMode': true,
-            'tile': {
-                'destroy': function() {
-                    t.ok(true, "wfs layer's tile is destroyed");
-                }
-            },
-            'ratio': {},
-            'featureClass': {},
-            'format': {},
-            'formatObject': {
-                'destroy': function() {
-                    t.ok(true, "wfs layer's format object is destroyed");
-                }
-            },
-            'formatOptions': {},
-            'encodeBBOX': {},
-            'extractAttributes': {}
-        };
-        
-        //this call should set off two tests (destroys for tile and format object)
-        g_VectorDestroyed = null;
-
+
+
-        OpenLayers.Layer.WFS.prototype.destroy.apply(layer, []);        
-
-        t.ok(g_VectorDestroyed && !g_MarkersDestroyed, "when vector mode is set to true, the default vector layer's destroy() method is called");

lib/OpenLayers/Tile/WFS.js

@@ -114 +114 @@
-            this.request.transport.abort();
-            //this.request.destroy();
-        }
-
+
+
+
+
-    },
-    
-    /**
@@ -133 +136 @@
-                doc = OpenLayers.parseXMLString(request.responseText);
-            }
-            if (this.layer.vectorMode) {
-
+
+
-            } else {
-                var resultFeatures = OpenLayers.Ajax.getElementsByTagNameNS(
-                    doc, "http://www.opengis.net/gml", "gml", "featureMember"
@@ -173 +177 @@
-     *   the local array
-     */
-    destroyAllFeatures: function() {
-
-
-
+
+
+
+
-        }
+        else
+        {
+            while(this.features.length > 0) {
+                var feature = this.features.shift();
+                feature.destroy();
+            }
+        }
-    },
-
-    CLASS_NAME: "OpenLayers.Tile.WFS"

lib/OpenLayers/Layer/WFSTile.js

@@ +1 @@
+/* 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/Layer/Vector.js
+ * @requires OpenLayers/Layer/Grid.js
+ */
+
+/**
+ * Class: OpenLayers.Layer.WFSTile
+ * 
+ * Inherits from:
+ *  - <OpenLayers.Layer.Vector>
+ *  - <OpenLayers.Layer.Grid>
+ */
+OpenLayers.Layer.WFSTile = OpenLayers.Class(
+  OpenLayers.Layer.Vector, OpenLayers.Layer.Grid, {
+
+    /**
+     * APIProperty: isBaseLayer
+     * {Boolean} WFS layer is not a base layer by default. 
+     */
+    isBaseLayer: false,
+    
+    /**
+     * APIProperty: tileSize
+     * {<OpenLayers.Size>}
+     */
+    tileSize: new OpenLayers.Size(512,512),
+    
+    /**  
+     * Property: DEFAULT_PARAMS
+     * {Object} Hashtable of default key/value parameters
+     */
+    DEFAULT_PARAMS: { service: "WFS",
+                      version: "1.0.0",
+                      request: "GetFeature"
+                    },
+    
+    /**
+      * APIProperty: format
+      * {<OpenLayers.Format>} The format you want the data to be parsed with.
+      * Must be passed in the constructor. Should be a class, not an instance.
+      */
+    format: null,
+
+    /** 
+     * Property: formatObject
+     * {<OpenLayers.Format>} Internally created/managed format object, used by
+     * the Tile to parse data.
+     */
+    formatObject: null,
+
+    /**
+     * APIProperty: formatOptions
+     * {Object} Hash of options which should be passed to the format when it is
+     * created. Must be passed in the constructor.
+     */
+    formatOptions: null, 
+
+    /**
+     * APIProperty: encodeBBOX
+     * {Boolean} Should the BBOX commas be encoded? The WMS spec says 'no', 
+     *     but some services want it that way. Default false.
+     */
+    encodeBBOX: false,
+    
+    /**
+     * APIProperty: extractAttributes 
+     * {Boolean} Should the WFS layer parse attributes from the retrieved
+     *     GML? Defaults to false. If enabled, parsing is slower, but 
+     *     attributes are available in the attributes property of 
+     *     layer features.
+     */
+    extractAttributes: false,
+
+    /* Needed to control how the Tiles pass up the features */
+    vectorMode: true,
+    buffer: 0,
+
+    /**
+     * Constructor: OpenLayers.Layer.WFSTile
+     *
+     * Parameters:
+     * name - {String} 
+     * url - {String} 
+     * params - {Object} 
+     * options - {Object} Hashtable of extra options to tag onto the layer
+     */
+    initialize: function(name, url, params, options) {
+        if (options == undefined) { options = {}; } 
+        
+        // Turn off error reporting, browsers like Safari may work
+        // depending on the setup, and we don't want an unneccesary alert.
+        OpenLayers.Util.extend(options, {'reportError': false});
+        var newArguments = [];
+        newArguments.push(name, options);
+        OpenLayers.Layer.Vector.prototype.initialize.apply(this, newArguments);
+        OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name, url, params, options]);
+        
+        if (this.params && this.params.typename && !this.options.typename) {
+            this.options.typename = this.params.typename;
+        }
+        
+        if (!this.options.geometry_column) {
+            this.options.geometry_column = "the_geom";
+        }    
+        
+        this.params = params;
+        OpenLayers.Util.applyDefaults(
+                       this.params, 
+                       OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
+                       );
+        this.url = url;
+    this.featureIndex = {};
+    },    
+    
+
+    /**
+     * APIMethod: destroy
+     */
+    destroy: function() {
+        OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments);
+        OpenLayers.Layer.Vector.prototype.destroy.apply(this, arguments);
+
+        this.ratio = null;
+        this.format = null;
+
+        if (this.formatObject && this.formatObject.destroy) {
+            this.formatObject.destroy();
+        }
+        this.formatObject = null;
+        
+        this.formatOptions = null;
+        this.encodeBBOX = null;
+        this.extractAttributes = null;
+    },
+    
+    /**
+     * Method: setMap
+     * 
+     * Parameters:
+     * map - {<OpenLayers.Map>} 
+     */
+    setMap: function(map) {
+          OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments);
+          OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments);
+          
+          var options = {
+            'extractAttributes': this.extractAttributes
+          };
+          
+          OpenLayers.Util.extend(options, this.formatOptions);
+          if (this.map && !this.projection.equals(this.map.getProjectionObject())) {
+              options.externalProjection = this.projection;
+              options.internalProjection = this.map.getProjectionObject();
+          }    
+          
+          this.formatObject = this.format ? new this.format(options) : new OpenLayers.Format.GML(options);
+    },
+    
+    /** 
+     * Method: moveTo
+     * 
+     * Parameters:
+     * bounds - {<OpenLayers.Bounds>} 
+     * zoomChanged - {Boolean} 
+     * dragging - {Boolean} 
+     */
+    moveTo:function(bounds, zoomChanged, dragging) {
+        OpenLayers.Layer.Vector.prototype.moveTo.apply(this, arguments);
+        OpenLayers.Layer.Grid.prototype.moveTo.apply(this, arguments);
+    },
+
+    /** 
+     * Method: addTileMonitoringHooks
+     * This function takes a tile as input and adds the appropriate hooks to 
+     *     the tile so that the layer can keep track of the loading tile
+     *     (making sure to check that the tile is always the layer's current
+     *     tile before taking any action).
+     * 
+     * Parameters: 
+     * tile - {<OpenLayers.Tile>}
+     */
+    addTileMonitoringHooks: function(tile) {
+        tile.onLoadStart = function() {
+            //if this is the the layer's current tile, then trigger 
+            // a 'loadstart'
+            if (this == this.layer.tile) {
+                this.layer.events.triggerEvent("loadstart");
+            }
+        };
+        tile.events.register("loadstart", tile, tile.onLoadStart);
+      
+        tile.onLoadEnd = function() {
+            //if this is the the layer's current tile, then trigger 
+            // a 'tileloaded' and 'loadend'
+            if (this == this.layer.tile) {
+                this.layer.events.triggerEvent("tileloaded");
+                this.layer.events.triggerEvent("loadend");
+            }
+        };
+        tile.events.register("loadend", tile, tile.onLoadEnd);
+    },
+
+    /**
+     * Method: addTile
+     * addTile creates a tile, initializes it, and adds it to the layer div.
+     *
+     * Parameters:
+     * bounds - {<OpenLayers.Bounds>}
+     *
+     * Returns:
+     * {<OpenLayers.Tile.Image>} The added OpenLayers.Tile.Image
+     */
+    addTile:function(bounds,position) {
+        return new OpenLayers.Tile.WFS(this, position, bounds,
+                                         null, this.tileSize);
+    },
+    
+    /** 
+     * Method: removeTileMonitoringHooks
+     * This function takes a tile as input and removes the tile hooks 
+     *     that were added in addTileMonitoringHooks()
+     * 
+     * Parameters: 
+     * tile - {<OpenLayers.Tile>}
+     */
+    removeTileMonitoringHooks: function(tile) {
+        tile.events.unregister("loadstart", tile, tile.onLoadStart);
+        tile.events.unregister("loadend", tile, tile.onLoadEnd);
+    },
+
+    /**
+     * Method: onMapResize
+     * Call the onMapResize method of the appropriate parent class. 
+     */
+    onMapResize: function() {
+        OpenLayers.Layer.Vector.prototype.onMapResize.apply(this, 
+                                                                arguments);
+    },
+    
+    /**
+     * APIMethod: mergeNewParams
+     * Modify parameters for the layer and redraw.
+     * 
+     * Parameters:
+     * newParams - {Object}
+     */
+    mergeNewParams:function(newParams) {
+        var upperParams = OpenLayers.Util.upperCaseObject(newParams);
+        var newArguments = [upperParams];
+        OpenLayers.Layer.HTTPRequest.prototype.mergeNewParams.apply(this, 
+                                                                 newArguments);
+    },
+
+    /**
+     * APIMethod: clone
+     *
+     * Parameters:
+     * obj - {Object} 
+     * 
+     * Returns:
+     * {<OpenLayers.Layer.WFSTile>} An exact clone of this OpenLayers.Layer.WFS
+     */
+    clone: function (obj) {
+        
+        if (obj == null) {
+            obj = new OpenLayers.Layer.WFSTile(this.name,
+                                           this.url,
+                                           this.params,
+                                           this.options);
+        }
+
+        //get all additions from superclasses
+        obj = OpenLayers.Layer.Vector.prototype.clone.apply(this, [obj]);
+
+        // copy/set any non-init, non-simple values here
+
+        return obj;
+    },
+
+    /** 
+     * APIMethod: getFullRequestString
+     * combine the layer's url with its params and these newParams. 
+     *   
+     *    Add the SRS parameter from 'projection' -- this is probably
+     *     more eloquently done via a setProjection() method, but this 
+     *     works for now and always.
+     *
+     * Parameters:
+     * newParams - {Object} 
+     * altUrl - {String} Use this as the url instead of the layer's url
+     */
+    getFullRequestString:function(newParams, altUrl) {
+        var projectionCode = this.formatOptions.externalProjection ? this.formatOptions.externalProjection.projCode : this.map.getProjection();
+        this.params.SRS = (projectionCode == "none") ? null : projectionCode;
+
+        return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(
+                                                    this, arguments);
+    },
+
+    getURL: function(bounds) {
+        //formulate request url string
+        var url = this.getFullRequestString();
+
+        if( this.formatOptions.externalProjection )
+            bounds.transform( this.formatOptions.internalProjection, this.formatOptions.externalProjection );
+
+        var params = {BBOX: this.encodeBBOX ? bounds.toBBOX()
+                                            : bounds.toArray()};
+        url += "&" + OpenLayers.Util.getParameterString(params);
+
+    return url;
+    },
+   
+    /* We override the addFeatures here to index them by fid. If we find
+     * them we just increment the ref count and skip it. */
+    addFeatures: function(features, options) {
+        if (!(features instanceof Array)) {
+            features = [features];
+        }
+        var newfeatures = [];
+
+        for (var i = 0; i < features.length; i++) {
+            var feature = features[i];
+            
+            if( feature.fid == null )
+                newfeatures.push(feature);
+            else if( this.featureIndex[feature.fid] != null )
+                this.featureIndex[feature.fid][0]++;
+            else
+            {
+                this.featureIndex[feature.fid] = [1,feature];
+                newfeatures.push(feature);
+            }
+        }
+        if( newfeatures.length )
+            OpenLayers.Layer.Vector.prototype.addFeatures.apply(this, [newfeatures, options]);
+    },
+
+    removeFeatures: function(features, options) {
+        if (!(features instanceof Array)) {
+            features = [features];
+        }
+        var oldfeatures = [];
+
+        for (var i = 0; i < features.length; i++) {
+            var feature = features[i];
+            
+            if( feature.fid == null || this.featureIndex[feature.fid] == null )
+                newfeatures.push(feature);
+            else if( this.featureIndex[feature.fid][0] > 1 )
+                this.featureIndex[feature.fid][0]--;
+            else
+            {
+                oldfeatures.push(this.featureIndex[feature.fid][1]);
+                delete this.featureIndex[feature.fid];
+            }
+        }
+        if( oldfeatures.length )
+            OpenLayers.Layer.Vector.prototype.removeFeatures.apply(this, [oldfeatures, options]);
+    },
+
+    /**
+     * APIMethod: commit
+     * Write out the data to a WFS server.
+     */
+    commit: function() {
+        if (!this.writer) {
+            this.writer = new OpenLayers.Format.WFS({},this);
+        }
+
+        var data = this.writer.write(this.features);
+        
+        var url = this.url;
+        if (OpenLayers.ProxyHost &&
+            OpenLayers.String.startsWith(this.url, "http")) {
+            url = OpenLayers.ProxyHost + escape(this.url);
+        }
+
+        var success = OpenLayers.Function.bind(this.commitSuccess, this);
+
+        var failure = OpenLayers.Function.bind(this.commitFailure, this);
+        
+        data = OpenLayers.Ajax.serializeXMLToString(data);
+        
+        // from prototype.js
+        new OpenLayers.Ajax.Request(url, 
+                         {   method: 'post', 
+                             postBody: data,
+                             onComplete: success, 
+                             onFailure: failure
+                          }
+                         );
+    },
+
+    /**
+     * Method: commitSuccess
+     * Called when the Ajax request returns a response
+     *
+     * Parameters:
+     * response - {XmlNode} from server
+     */
+    commitSuccess: function(request) {
+        var response = request.responseText;
+        if (response.indexOf('SUCCESS') != -1) {
+            this.commitReport('WFS Transaction: SUCCESS', response);
+            
+            for(var i = 0; i < this.features.length; i++) {
+                this.features[i].state = null;
+            }    
+            // TBD redraw the layer or reset the state of features
+            // foreach features: set state to null
+        } else if (response.indexOf('FAILED') != -1 ||
+            response.indexOf('Exception') != -1) {
+            this.commitReport('WFS Transaction: FAILED', response);
+        }
+    },
+    
+    /**
+     * Method: commitFailure
+     * Called when the Ajax request fails
+     *
+     * Parameters:
+     * response - {XmlNode} from server
+     */
+    commitFailure: function(request) {},
+    
+    /**
+     * APIMethod: commitReport 
+     * Called with a 'success' message if the commit succeeded, otherwise
+     *     a failure message, and the full request text as a second parameter.
+     *     Override this function to provide custom transaction reporting.
+     *
+     * string - {String} reporting string
+     * response - {String} full XML response
+     */
+    commitReport: function(string, response) {
+        alert(string);
+    },
+
+    
+    /**
+     * APIMethod: refresh
+     * Refreshes all the features of the layer
+     */
+    refresh: function() {
+        /* TODO: What shoud happen here? */
+    },
+
+    CLASS_NAME: "OpenLayers.Layer.WFSTile"
+});

lib/OpenLayers/Layer/WFS.js

@@ -6 +6 @@
-/**
- * @requires OpenLayers/Layer/Vector.js
- * @requires OpenLayers/Layer/Markers.js
+ * @requires OpenLayers/Layer/Grid.js
- */
-
-/**
@@ -14 +15 @@
- * Inherits from:
- *  - <OpenLayers.Layer.Vector>
- *  - <OpenLayers.Layer.Markers>
+ *  - <OpenLayers.Layer.Grid>
- */
-OpenLayers.Layer.WFS = OpenLayers.Class(
-
+OpenLayers.Layer.Grid, 
-
-    /**
-     * APIProperty: isBaseLayer
@@ -31 +33 @@
-    tile: null,    
-    
-    /**
+     * Property: tileSize
+     * {<OpenLayers.Size>}
+     */
+    tileSize: new OpenLayers.Size(512,512),    
+    
+    /**
-     * APIProperty: ratio
-     * {Float} the ratio of image/tile size to map size (this is the untiled
-     *     buffer)
-     */
-    ratio: 2,
+    buffer: 0,
+    singleTile: true,
-
-    /**  
-     * Property: DEFAULT_PARAMS
@@ -129 +139 @@
-            OpenLayers.Layer.Markers.prototype.initialize.apply(this, 
-                                                                newArguments);
-        }
+        OpenLayers.Layer.Grid.prototype.initialize.apply(this, [name, url, params, options]);
-        
-        if (this.params && this.params.typename && !this.options.typename) {
-            this.options.typename = this.params.typename;
@@ -144 +155 @@
-                       OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
-                       );
-        this.url = url;
+    this.featureIndex = {};
-    },    
-    
-
@@ -151 +163 @@
-     * APIMethod: destroy
-     */
-    destroy: function() {
+        OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments);
-        if (this.vectorMode) {
-            OpenLayers.Layer.Vector.prototype.destroy.apply(this, arguments);
-        } else {    
-            OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments);
-        }    
-        if (this.tile) {
-            this.tile.destroy();
-        }
-        this.tile = null;
-
-        this.ratio = null;
-        this.featureClass = null;
@@ -174 +183 @@
-        this.vectorMode = null;
-        this.encodeBBOX = null;
-        this.extractAttributes = null;
+        this.featureIndex = null;
-    },
-    
-    /**
@@ -200 +210 @@
-        } else {    
-            OpenLayers.Layer.Markers.prototype.setMap.apply(this, arguments);
-        }    
+        OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments);
-    },
-    
-    /** 
@@ -211 +222 @@
-     * dragging - {Boolean} 
-     */
-    moveTo:function(bounds, zoomChanged, dragging) {
+        OpenLayers.Layer.Grid.prototype.moveTo.apply(this, arguments);
-        if (this.vectorMode) {
-            OpenLayers.Layer.Vector.prototype.moveTo.apply(this, arguments);
-        } else {
-            OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments);
-        }    
-
-        // don't load wfs features while dragging, wait for drag end
-        if (dragging) {
-            // TBD try to hide the vector layer while dragging
-            // this.setVisibility(false);
-            // this will probably help for panning performances
-            return false;
-        }
-        
-        if ( zoomChanged ) {
-            if (this.vectorMode) {
-                this.renderer.clear();
-            }
-        }
-        
-    //DEPRECATED - REMOVE IN 3.0
-        // don't load data if current zoom level doesn't match
-        if (this.options.minZoomLevel) {
-            
-            var err = "The minZoomLevel property is only intended for use " +
-                    "with the FixedZoomLevels-descendent layers. That this " +
-                    "wfs layer checks for minZoomLevel is a relic of the" +
-                    "past. We cannot, however, remove it without possibly " +
-                    "breaking OL based applications that may depend on it." +
-                    " Therefore we are deprecating it -- the minZoomLevel " +
-                    "check below will be removed at 3.0. Please instead " +
-                    "use min/max resolution setting as described here: " +
-                    "http://trac.openlayers.org/wiki/SettingZoomLevels";
-            OpenLayers.Console.warn(err);
-            
-            if (this.map.getZoom() < this.options.minZoomLevel) {
-                return null;
-            }
-        }
-        
-        if (bounds == null) {
-            bounds = this.map.getExtent();
-        }
-
-        var firstRendering = (this.tile == null);
-
-        //does the new bounds to which we need to move fall outside of the 
-        // current tile's bounds?
-        var outOfBounds = (!firstRendering &&
-                           !this.tile.bounds.containsBounds(bounds));
-
-        if (zoomChanged || firstRendering || (!dragging && outOfBounds)) {
-            //determine new tile bounds
-            var center = bounds.getCenterLonLat();
-            var tileWidth = bounds.getWidth() * this.ratio;
-            var tileHeight = bounds.getHeight() * this.ratio;
-            var tileBounds = 
-                new OpenLayers.Bounds(center.lon - (tileWidth / 2),
-                                      center.lat - (tileHeight / 2),
-                                      center.lon + (tileWidth / 2),
-                                      center.lat + (tileHeight / 2));
-
-            //determine new tile size
-            var tileSize = this.map.getSize();
-            tileSize.w = tileSize.w * this.ratio;
-            tileSize.h = tileSize.h * this.ratio;
-
-            //determine new position (upper left corner of new bounds)
-            var ul = new OpenLayers.LonLat(tileBounds.left, tileBounds.top);
-            var pos = this.map.getLayerPxFromLonLat(ul);
-
-            //formulate request url string
-            var url = this.getFullRequestString();
-        
-            var params = {BBOX: this.encodeBBOX ? tileBounds.toBBOX() 
-                                                : tileBounds.toArray()};
-            url += "&" + OpenLayers.Util.getParameterString(params);
-
-            if (!this.tile) {
-                this.tile = new OpenLayers.Tile.WFS(this, pos, tileBounds, 
-                                                     url, tileSize);
-                this.addTileMonitoringHooks(this.tile);
-                this.tile.draw();
-            } else {
-                if (this.vectorMode) {
-                    this.destroyFeatures();
-                    this.renderer.clear();
-                } else {
-                    this.clearMarkers();
-                }    
-                this.removeTileMonitoringHooks(this.tile);
-                this.tile.destroy();
-                
-                this.tile = null;
-                this.tile = new OpenLayers.Tile.WFS(this, pos, tileBounds, 
-                                                     url, tileSize);
-                this.addTileMonitoringHooks(this.tile);
-                this.tile.draw();
-            } 
-        }
-    },
-
-    /** 
-     * Method: addTileMonitoringHooks
-     * This function takes a tile as input and adds the appropriate hooks to 
-     *     the tile so that the layer can keep track of the loading tile
-     *     (making sure to check that the tile is always the layer's current
-     *     tile before taking any action).
-     * 
-     * Parameters: 
-     * tile - {<OpenLayers.Tile>}
-     */
-    addTileMonitoringHooks: function(tile) {
-        tile.onLoadStart = function() {
-            //if this is the the layer's current tile, then trigger 
-            // a 'loadstart'
-            if (this == this.layer.tile) {
-                this.layer.events.triggerEvent("loadstart");
-            }
-        };
-        tile.events.register("loadstart", tile, tile.onLoadStart);
-      
-        tile.onLoadEnd = function() {
-            //if this is the the layer's current tile, then trigger 
-            // a 'tileloaded' and 'loadend'
-            if (this == this.layer.tile) {
-                this.layer.events.triggerEvent("tileloaded");
-                this.layer.events.triggerEvent("loadend");
-            }
-        };
-        tile.events.register("loadend", tile, tile.onLoadEnd);
-    },
-    
-    /** 
-     * Method: removeTileMonitoringHooks
-     * This function takes a tile as input and removes the tile hooks 
-     *     that were added in addTileMonitoringHooks()
-     * 
-     * Parameters: 
-     * tile - {<OpenLayers.Tile>}
-     */
-    removeTileMonitoringHooks: function(tile) {
-        tile.events.un({
-            "loadstart": tile.onLoadStart,
-            "loadend": tile.onLoadEnd,
-            scope: tile
-        });
-    },
-
-    /**
-     * Method: onMapResize
-     * Call the onMapResize method of the appropriate parent class. 
-     */
-    onMapResize: function() {
+        OpenLayers.Layer.Grid.prototype.onMapResize.apply(this, arguments);
-        if(this.vectorMode) {
-            OpenLayers.Layer.Vector.prototype.onMapResize.apply(this, 
-                                                                arguments);
@@ -412 +283 @@
-        } else {
-            obj = OpenLayers.Layer.Markers.prototype.clone.apply(this, [obj]);
-        }    
+        obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
-
-        // copy/set any non-init, non-simple values here
-
-        return obj;
-    },
-
+    /**
+     * Method: addTile
+     * addTile creates a tile, initializes it, and adds it to the layer div.
+     *
+     * Parameters:
+     * bounds - {<OpenLayers.Bounds>}
+     *
+     * Returns:
+     * {<OpenLayers.Tile.Image>} The added OpenLayers.Tile.Image
+     */
+    addTile:function(bounds,position) {
+        return new OpenLayers.Tile.WFS(this, position, bounds,
+                                         null, this.tileSize);
+    },
+    
-    /** 
-     * APIMethod: getFullRequestString
-     * combine the layer's url with its params and these newParams. 
@@ -431 +318 @@
-     * altUrl - {String} Use this as the url instead of the layer's url
-     */
-    getFullRequestString:function(newParams, altUrl) {
-
+(this.formatOptions && this.formatOptions.externalProjection) ? this.formatOptions.externalProjection.projCode : 
-        this.params.SRS = (projectionCode == "none") ? null : projectionCode;
-
-        return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(
-                                                    this, arguments);
-    },
-   
+    getURL: function(bounds) {
+        //formulate request url string
+        var url = this.getFullRequestString();
+
+        if( this.formatOptions.externalProjection )
+            bounds = bounds.clone().transform( this.formatOptions.internalProjection, this.formatOptions.externalProjection );
+
+        var params = {BBOX: this.encodeBBOX ? bounds.toBBOX()
+                                            : bounds.toArray()};
+        url += "&" + OpenLayers.Util.getParameterString(params);
+
+    return url;
+    },
+   
+    /* We override the addFeatures here to index them by fid. If we find
+     * them we just increment the ref count and skip it. */
+    addFeatures: function(features, options) {
+        if (!(features instanceof Array)) {
+            features = [features];
+        }
+        var newfeatures = [];
+
+        for (var i = 0; i < features.length; i++) {
+            var feature = features[i];
+            
+            if( feature.fid == null )
+                newfeatures.push(feature);
+            else if( this.featureIndex[feature.fid] != null )
+                this.featureIndex[feature.fid][0]++;
+            else
+            {
+                this.featureIndex[feature.fid] = [1,feature];
+                newfeatures.push(feature);
+            }
+        }
+        if( newfeatures.length )
+            OpenLayers.Layer.Vector.prototype.addFeatures.apply(this, [newfeatures, options]);
+    },
+
+    removeFeatures: function(features, options) {
+        if (!(features instanceof Array)) {
+            features = [features];
+        }
+        var oldfeatures = [];
+
+        for (var i = 0; i < features.length; i++) {
+            var feature = features[i];
+            
+            if( feature.fid == null || this.featureIndex[feature.fid] == null )
+                newfeatures.push(feature);
+            else if( this.featureIndex[feature.fid][0] > 1 )
+                this.featureIndex[feature.fid][0]--;
+            else
+            {
+                oldfeatures.push(this.featureIndex[feature.fid][1]);
+                delete this.featureIndex[feature.fid];
+            }
+        }
+        if( oldfeatures.length )
+            OpenLayers.Layer.Vector.prototype.removeFeatures.apply(this, [oldfeatures, options]);
+    },
+
-    /**
-     * APIMethod: commit
-     * Write out the data to a WFS server.
@@ -522 +471 @@
-     * Refreshes all the features of the layer
-     */
-    refresh: function() {
-
-
-
-
-
-
-
-
-
-
+
-    },
-
-    CLASS_NAME: "OpenLayers.Layer.WFS"