modifyfeature.js

来自「用来在地图上做操作GIS,在地图上做标记」· JavaScript 代码 · 共 562 行 · 第 1/2 页

            this.vertices = [];
            this.dragControl.deactivate();
            if(this.feature) {
                this.selectControl.unselect.apply(this.selectControl,
                                                  [this.feature]);
            }
            this.selectControl.deactivate();
            this.keyboardHandler.deactivate();
            deactivated = true;
        }
        return deactivated;
    },
    
    /***
    


    /**
     * Method: selectFeature
     * Called when the select feature control selects a feature.
     *
     * Parameters:
     * feature - {<OpenLayers.Feature.Vector>} The selected feature.
     */
    selectFeature: function(feature) {
        
        this.feature = feature;
        this.resetVertices();
        this.dragControl.activate();
        this.onModificationStart(this.feature);
    },

    /**
     * Method: unselectFeature
     * Called when the select feature control unselects a feature.
     *
     * Parameters:
     * feature - {<OpenLayers.Feature.Vector>} The unselected feature.
     */
    unselectFeature: function(feature) {
        this.layer.removeFeatures(this.vertices);
        this.layer.removeFeatures(this.virtualVertices);
        this.vertices = [];
        this.virtualVertices = [];
        this.feature = null;
        this.dragControl.deactivate();
        this.onModificationEnd(feature);
    },

    /**
     * Method: dragStart
     * Called by the drag feature control with before a feature is dragged.
     *     This method is used to differentiate between points and vertices
     *     of higher order geometries.  This respects the <geometryTypes>
     *     property and forces a select of points when the drag control is
     *     already active (and stops events from propagating to the select
     *     control).
     *
     * Parameters:
     * feature - {<OpenLayers.Feature.Vector>} The point or vertex about to be
     *     dragged.
     * pixel - {<OpenLayers.Pixel>} Pixel location of the mouse event.
     */
    dragStart: function(feature, pixel) {
        // only change behavior if the feature is not in the vertices array
        if(feature != this.feature &&
           OpenLayers.Util.indexOf(this.vertices, feature) == -1 &&
           OpenLayers.Util.indexOf(this.virtualVertices, feature) == -1) {
            if(this.feature) {
                // unselect the currently selected feature
                this.selectControl.clickFeature.apply(this.selectControl,
                                                      [this.feature]);
            }
            // check any constraints on the geometry type
            if(this.geometryTypes == null ||
               OpenLayers.Util.indexOf(this.geometryTypes,
                                       feature.geometry.CLASS_NAME) != -1) {
                // select the point
                this.selectControl.clickFeature.apply(this.selectControl,
                                                      [feature]);
                /**
                 * TBD: These lines improve workflow by letting the user
                 *     immediately start dragging after the mouse down.
                 *     However, it is very ugly to be messing with controls
                 *     and their handlers in this way.  I'd like a better
                 *     solution if the workflow change is necessary.
                 */
                // prepare the point for dragging
                this.dragControl.overFeature.apply(this.dragControl,
                                                   [feature]);
                this.dragControl.lastPixel = pixel;
                this.dragControl.dragHandler.started = true;
                this.dragControl.dragHandler.start = pixel;
                this.dragControl.dragHandler.last = pixel;
                
            }
        }
    },
    
    /**
     * Method: dragVertex
     * Called by the drag feature control with each drag move of a vertex.
     *
     * Parameters:
     * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged.
     */
    dragVertex: function(vertex) {
        if(this.feature.geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
            if(this.feature != vertex) {
                this.feature = vertex;
            }
        } else {
            if(OpenLayers.Util.indexOf(this.virtualVertices, vertex) != -1) {
                vertex.geometry.parent.addComponent(vertex.geometry,
                                                    vertex._index);
                delete vertex._index;
                OpenLayers.Util.removeItem(this.virtualVertices, vertex);
                this.layer.removeFeatures(vertex);
            }
        }
        this.layer.drawFeature(this.feature, this.selectControl.selectStyle);
        this.layer.removeFeatures(this.virtualVertices);
        // keep the vertex on top so it gets the mouseout after dragging
        // this should be removed in favor of an option to draw under or
        // maintain node z-index
        this.layer.drawFeature(vertex);
    },
    
    /**
     * Method: dragComplete
     * Called by the drag feature control when the feature dragging is complete.
     *
     * Parameters:
     * vertex - {<OpenLayers.Feature.Vector>} The vertex being dragged.
     */
    dragComplete: function(vertex) {
        this.resetVertices();
        this.onModification(this.feature);
    },
    
    /**
     * Method: resetVertices
     */
    resetVertices: function() {
        if(this.vertices.length > 0) {
            this.layer.removeFeatures(this.vertices);
            this.vertices = [];
        }
        if(this.virtualVertices.length > 0) {
            this.layer.removeFeatures(this.virtualVertices);
            this.virtualVertices = [];
        }
        if(this.feature &&
           this.feature.geometry.CLASS_NAME != "OpenLayers.Geometry.Point") {
           this.collectVertices(this.feature.geometry);
           this.layer.addFeatures(this.vertices);
           this.layer.addFeatures(this.virtualVertices);
        }
    },
    
    /**
     * Method: handleKeypress
     * Called by the feature handler on keypress.  This is used to delete
     *     vertices and point features.  If the <deleteCode> property is set,
     *     vertices and points will be deleted when a feature is selected
     *     for modification and the mouse is over a vertex.
     *
     * Parameters:
     * {Integer} Key code corresponding to the keypress event.
     */
    handleKeypress: function(code) {
        // check for delete key
        if(this.feature &&
           OpenLayers.Util.indexOf(this.deleteCodes, code) != -1) {
            var vertex = this.dragControl.feature;
            if(vertex &&
               OpenLayers.Util.indexOf(this.vertices, vertex) != -1) {
                // remove the vertex
                vertex.geometry.parent.removeComponent(vertex.geometry);
                this.layer.drawFeature(this.feature,
                                       this.selectControl.selectStyle);
                this.resetVertices();
                this.onModification(this.feature);
            }
        }
    },


    factorradius : function(){
       
       alert(this.feature.id+ "  "+this.feature.geometry.getBounds().radius);
    },
    /**
     * Method: collectVertices
     * Collect the vertices from the modifiable feature's geometry and push
     *     them on to the control's vertices array.
     */
    collectVertices: function() {
        this.vertices = [];
        this.virtualVirtices = [];        
        var control = this;
        function collectComponentVertices(geometry) {
            var i, vertex, component;
            if(geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
                vertex = new OpenLayers.Feature.Vector(geometry);
                control.vertices.push(vertex);
            } else {
                for(i=0; i<geometry.components.length; ++i) {
                    component = geometry.components[i];
                    if(component.CLASS_NAME == "OpenLayers.Geometry.Point") {
                        vertex = new OpenLayers.Feature.Vector(component);
                        control.vertices.push(vertex);
                    } else {
                        collectComponentVertices(component);
                    }
                }
                
                // add virtual vertices in the middle of each edge
                if(geometry.CLASS_NAME != "OpenLayers.Geometry.MultiPoint") {
                    for(i=0; i<geometry.components.length-1; ++i) {
                        var prevVertex = geometry.components[i];
                        var nextVertex = geometry.components[i + 1];
                        if(prevVertex.CLASS_NAME == "OpenLayers.Geometry.Point" &&
                           nextVertex.CLASS_NAME == "OpenLayers.Geometry.Point") {
                            var x = (prevVertex.x + nextVertex.x) / 2;
                            var y = (prevVertex.y + nextVertex.y) / 2;
                            var point = new OpenLayers.Feature.Vector(
                                new OpenLayers.Geometry.Point(x, y),
                                null, control.styleVirtual
                            );
                            // set the virtual parent and intended index
                            point.geometry.parent = geometry;
                            point._index = i + 1;
                            control.virtualVertices.push(point);
                        }
                    }
                }
            }
        }       
        collectComponentVertices(this.feature.geometry);
    },

    /**
     * Method: setMap
     * Set the map property for the control and all handlers.
     *
     * Parameters:
     * map - {<OpenLayers.Map>} The control's map.
     */
    setMap: function(map) {
        this.selectControl.setMap(map);
        this.dragControl.setMap(map);
        OpenLayers.Control.prototype.setMap.apply(this, arguments);
    },

    CLASS_NAME: "OpenLayers.Control.ModifyFeature"
});

 /**
     修改
     ***/
    
    OpenLayers.Control.ModifyFeature.modifyGeometry=function() {
    
        var angle, dx, dy, point,sides;
        sides=OpenLayers.Control.ModifyFeature.feature.geometry.getBounds().sides;
        var ring = OpenLayers.Control.ModifyFeature.feature.geometry.components[0];
        // if the number of sides ever changes, create a new geometry
        if(ring.components.length != (sides + 1)) {
            this.createGeometry();
        }
        
        for(var i=0; i<this.sides; ++i) {
            point = ring.components[i];
            angle = OpenLayers.Control.ModifyFeature.feature.angle + (i * 2 * Math.PI /sides);
            point.x = OpenLayers.Control.ModifyFeature.feature.origin.x + (OpenLayers.Control.ModifyFeature.feature.radius * Math.cos(angle));
            point.y = OpenLayers.Control.ModifyFeature.feature.origin.y + (OpenLayers.Control.ModifyFeature.feature.radius * Math.sin(angle));
            point.clearBounds();
        }
        
    }