root/sandbox/tschaub/wfsv/lib/OpenLayers/Control/FeatureEditor.js

/* Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD license.
 * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
 * for the full text of the license. */

/**
 * @requires OpenLayers/Control/Panel.js
 * 
 * Class: OpenLayers.Control.FeatureEditor
 *
 * Inherits from:
 *  - <OpenLayers.Control.Panel>
 */
OpenLayers.Control.FeatureEditor = OpenLayers.Class(OpenLayers.Control.Panel, {
    
    /**
     * Property: vectorLayer
     * {<OpenLayers.Layer.Vector>} Layer for rendering features.
     */
    vectorLayer: null,

    /**
     * Property: xml
     * {<OpenLayers.Format.XML>} XML parser
     */
    xml: null,
    
    /**
     * Property: gml
     * {<OpenLayers.Format.GML>} GML parser
     */
    gml: null,
    
    /**
     * Property: layerOptions
     * {Object} Any options to be set on the vector layer.
     */
    layerOptions: null,
    
    /**
     * Property: transId
     * {Integer}
     */
    transId: 0,
    
    /**
     * Property: modified
     * {Boolean} Modifications have been made.
     */
    modified: false,
    
    /**
     * Property: staticLayer
     * {<OpenLayers.Layer>}
     */
    staticLayer: null,
    
    /**
     * Constructor: OpenLayers.Control.FeatureEditor
     * Create a new FeatureEditor panel.
     * 
     * Parameters:
     * url - {String} URL for service.
     * featureType - {String} Name of the FeatureType.
     * geometryType - {String} Geometry type for the features.  One of
     *     "Point", "MultiPoint", "LineString", "MultiLineString",
     *     "Polygon", and "MultiPolygon".
     * options - {Object} An optional object whose properties will be used
     *     to extend the control.
     */
    initialize: function(url, featureType, geometryType, options) {
        OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]);
        OpenLayers.Util.applyDefaults(this.layerOptions, {
            displayInLayerSwitcher: false,
            geometry_column: "the_geom",
            typename: featureType.substring(featureType.lastIndexOf(":") + 1)
        });
        this.url = url;
        this.featureType = featureType;
        this.geometryType = geometryType;
        this.vectorLayer = new OpenLayers.Layer.Vector(this.id + "Layer",
                                                       this.layerOptions);
        this.xml = new OpenLayers.Format.XML();
        this.gml = new OpenLayers.Format.GML();
        
        this.navigationControl = new OpenLayers.Control.Navigation();
        this.defaultControl = this.navigationControl;
        
        // TODO: better handling of changes flag
        var panel = this;  // alternatively bind this to callbacks

        // draw control
        var handlerName = this.geometryType.replace("Multi", "");
        handlerName = (handlerName == "LineString") ? "Path" : handlerName;

        var handlerOptions = (this.geometryType.indexOf("Multi") == 0) ?
                                                {forceMulti: true} : {};
        
        this.drawControl = new OpenLayers.Control.DrawFeature(
                            this.vectorLayer,
                            OpenLayers.Handler[handlerName],
                            {displayClass: "olControlDrawFeature",
                            handlerOptions: handlerOptions});
        this.drawControl.featureAdded = function(feature) {
            feature.state = OpenLayers.State.INSERT;
            panel.modified = true;
        };
        
        // getFeature request control
        this.featuresControl = new OpenLayers.Control.BoundsBox(
                                                this.prepareRequest, this);

        // modify control
        this.modifyControl = new OpenLayers.Control.ModifyFeature(
                this.vectorLayer,
                {displayClass: "olControlModifyFeature",
                 onModificationStart: this.onModificationStart,
                 onModificationEnd: this.onModificationEnd}
        );
        this.modifyControl.onModification = function(feature) {
            if(feature.state != OpenLayers.State.INSERT) {
                feature.state = OpenLayers.State.UPDATE;
            }
            panel.modified = true;
        };

        // save control
        var saveOptions = {
            onSuccess: OpenLayers.Function.bind(this.saveSuccess, this),
            onFailure: OpenLayers.Function.bind(this.saveFailure, this),
            formatOptions: {
                layerName: this.featureType
            }
        };
        if(this.confirmSave) {
            saveOptions.condition = this.confirmSave;
        }
        this.saveControl = new OpenLayers.Control.SaveFeatures(
                                        this.vectorLayer,
                                        this.url,
                                        OpenLayers.Format.WFSV,
                                        saveOptions);
        
        this.addControls([this.saveControl,
                          this.modifyControl,
                          this.featuresControl,
                          this.drawControl,
                          this.navigationControl]);
    },
    
    /**
     * Method: changeLayer
     */
    changeLayer: function(featureType, geometryType, layerOptions) {
        var activeTool = this.activeTool;
        if(activeTool) {
            activeTool.deactivate();
        }
        this.clearFeatures();
        this.modified = false;
        this.featureType = featureType;
        if(layerOptions) {
            OpenLayers.Util.extend(this.vectorLayer, layerOptions);
        }
        if(geometryType && geometryType != this.geometryType) {
            // switch out the draw control's handler
            this.geometryType = geometryType;
            this.drawControl.handler.destroy();
            var handlerName = this.geometryType.replace("Multi", "");
            handlerName = (handlerName == "LineString") ? "Path" : handlerName;
            var options = (this.geometryType.indexOf("Multi") == 0) ?
                          {forceMulti: true} : {forceMulti: false};
            OpenLayers.Util.extend(this.drawControl.handlerOptions, options);

            var constructor = OpenLayers.Handler[handlerName];
            this.drawControl.handler = new constructor(this.drawControl,
                                                       this.drawControl.callbacks,
                                                       this.drawControl.handlerOptions);
        }
        // set relevant WFS parser properties
        this.saveControl.format.featureName = this.featureType.substring(this.featureType.lastIndexOf(":") + 1);
        this.saveControl.format.layerName = this.featureType;
        if(activeTool) {
            activeTool.activate();
        }
    },
    
    /**
     * Method: clearFeatures
     */
    clearFeatures: function() {
        this.vectorLayer.removeFeatures(this.vectorLayer.features);
    },
    
    /**
     * Method: saveSuccess
     */
    saveSuccess: function(response) {
        this.transId += 1;
        this.modified = false;
        this.activateControl(this.defaultControl);
        this.clearFeatures();
        if(this.staticLayer) {
            this.staticLayer.mergeNewParams({transaction_id: this.transId});
        }
    },
    
    /**
     * Method: saveFailure
     */
    saveFailure: function(response) {
        this.modified = false;
        this.activateControl(this.defaultControl);
        this.clearFeatures();
        OpenLayers.Console.log('failed', response);
    },

    /**
     * Method: draw
     *
     * Returns: {DOMElement}
     */    
    draw: function() {
        this.map.addLayer(this.vectorLayer);
        return OpenLayers.Control.Panel.prototype.draw.apply(this, arguments);
    },
    
    /**
     * APIMethod: prepareRequest
     * Prepare the request to get features.  Prepares a WFS getFeature request
     *     but can be overridden for other service types.  Calls requestFeatures
     *     prior to returning.
     *
     * Parameters:
     * bounds - {<OpenLayers.Bounds>}
     */
    prepareRequest: function(bounds) {
        var params = {
            service: "WFS",
            request: "getFeature",
            version: "1.0.0",
            srsName: this.map.projection,
            typeName: this.featureType,
            bbox: [bounds.left, bounds.bottom, bounds.right, bounds.top, this.map.projection]
        };
        
        // TODO: put HTTPRequest.getFullRequestString in Util
        var url = this.url + "?" + OpenLayers.Util.getParameterString(params);
        
        this.requestFeatures(url);
    },
    
    /**
     * Method: requestFeatures
     * Issue a request and register listeners for response.
     *
     * Parameters:
     * url - {String}
     */
    requestFeatures: function(url) {
        var callback;
        var evt = this.featuresControl.handler.evt;
        if(evt.shiftKey) {
            callback = this.addFeatures;
        } else if(evt.ctrlKey) {
            callback = this.removeFeatures;
        } else {
            callback = this.resetFeatures;
        }
        
        OpenLayers.loadURL(url, null, this, callback);
    },
    
    /**
     * Method: addFeatures
     */
    addFeatures: function(request) {
        var features = this.gml.read(request.responseXML);
        this.vectorLayer.addFeatures(features, {unique: true});
    },
    
    /**
     * Method: removeFeatures
     */
    removeFeatures: function(request) {
        var features = this.gml.read(request.responseXML);
        var forRemoval = [];
        var fid, potentialFeature;
        for(var i=0; i<features.length; ++i) {
            potentialFeature = this.vectorLayer.fids[features[i].fid];
            if(potentialFeature) {
                forRemoval.push(potentialFeature);
            }
        }
        this.vectorLayer.removeFeatures(forRemoval);
    },
    
    /**
     * Method: resetFeatures
     */
    resetFeatures: function(request) {
        var features = this.gml.read(request.responseXML);
        // remove current features and add new ones
        // TODO: modify layer.destroyFeatures for use here
        this.vectorLayer.removeFeatures(this.vectorLayer.features);
        this.vectorLayer.addFeatures(features);
    },    
    
    CLASS_NAME: "OpenLayers.Control.FeatureEditor"
    
});