Ticket #954: Point.js-diff

--- Handler/Point.js    2007-09-03 08:03:57.174606707 +0200
+++ /home/jachym/public_html/openlayers/HSLayers/Point.js   2007-09-03 13:43:14.062679646 +0200
@@ -55,6 +55,12 @@
     lastUp: null,
 
     /**
+     * Property: snapDist
+     * {Integer} Snapping distance in pixel. If <= 0, no snapping is done
+     */
+    snapDist: 0,
+
+    /**
      * Constructor: OpenLayers.Handler.Point
      * Create a new point handler.
      *
@@ -75,6 +81,9 @@
         this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {});
 
         OpenLayers.Handler.prototype.initialize.apply(this, arguments);
+        if (this.snapDist) {
+            this.style.pointRadius = this.snapDist;
+        }
     },
     
     /**
@@ -90,6 +99,19 @@
         var options = {displayInLayerSwitcher: false};
         this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options);
         this.map.addLayer(this.layer);
+
+        // cursor
+        this.map.div.style.cursor = "crosshair";
+
+        // snap circle
+        if (this.snapDist) {
+            this.drawing = true;
+            var lonlat = this.map.getLonLatFromPixel({x:0,y:0});
+            this.createFeature();
+            this.point.geometry.x = lonlat.lon;
+            this.point.geometry.y = lonlat.lat;
+        }
+
         return true;
     },
     
@@ -117,6 +139,7 @@
         this.map.removeLayer(this.layer, false);
         this.layer.destroy();
         this.layer = null;
+        this.map.div.style.cursor = "auto";
         return true;
     },
     
@@ -141,6 +164,14 @@
         this.mouseDown = false;
         this.lastDown = null;
         this.lastUp = null;
+
+        if (this.snapDist) {
+            this.drawing = true;
+            var lonlat = this.map.getLonLatFromPixel({x:0,y:0});
+            this.createFeature();
+            this.point.geometry.x = lonlat.lon;
+            this.point.geometry.y = lonlat.lat;
+        }
     },
 
     /**
@@ -203,6 +234,11 @@
      * {Boolean} Allow event propagation
      */
     mousedown: function(evt) {
+
+        evt = this.snap(evt);
+
+        this.layer.redraw();
+
         // check keyboard modifiers
         if(!this.checkModifiers(evt)) {
             return true;
@@ -265,5 +301,165 @@
         }
     },
 
+
+    /**
+     * Method: snap
+     * Snap digitized point to nearest vertex/underlying data
+     * Return new event
+     *
+     * Parameters:
+     * evt - {Event} The browser event
+     * 
+     * Return:
+     * {Event} Original event with new coordinates
+     */
+    snap: function(evt) {
+            var diff = Math.pow(this.snapDist,2); // minimal difference (initialized to power of snap distance)
+            var pixel = null;                // temporary OpenLayers.Pixel
+            var maxidx = 1;                  // maximal value geometry index - 1 for lines, 2 for polygons
+
+            /* 
+             * Are we supposed to snap? 
+             */
+            if (this.snapDist <= 0) {
+                return evt;
+            }
+
+            /*
+             * Set maximal index of vertex for polygons
+             */
+            if (this.layer.name == "OpenLayers.Handler.Polygon") {
+                maxidx = 2;
+            }
+
+            /*
+             * Snap to current digitized line or polygon to itself
+             */
+            if (this.line && this.line.geometry) {
+
+                /* for each point in current feature */
+                for (var i = 0; i < this.line.geometry.components.length-maxidx; ++i) {
+                    var tmppixel = this.map.getPixelFromLonLat(
+                                            new OpenLayers.LonLat(
+                                                        this.line.geometry.components[i].x,
+                                                        this.line.geometry.components[i].y));
+
+
+                    /* does it fit to threshold */
+                    if (Math.abs(tmppixel.x-evt.xy.x) < this.snapDist &&
+                        Math.abs(tmppixel.y-evt.xy.y)< this.snapDist) {
+
+                        /* search for smallest difference */
+                        var tmpdiff = Math.sqrt(Math.pow(Math.abs(tmppixel.x-evt.xy.x),2)+Math.pow(Math.abs(tmppixel.y-evt.xy.y),2));
+                        if ( tmpdiff <Â diff) {
+                            pixel = tmppixel;
+                            diff = tmpdiff;
+                        }
+                    }
+                }
+            }
+
+            /* Return this event, if snaped */
+            if (pixel) {
+                evt.xy = pixel;
+                this.mousemove(evt);
+                return evt;
+            }
+
+            /*
+             * Snap to existing featuers in same layer
+             */
+            for (var i in this.control.layer.features) {
+                this.diff = Math.pow(this.snapDist,2);
+                var feature = this.control.layer.features[i];
+                var pixel = this.findVertex(feature.geometry,evt);
+            }
+
+            if (pixel) {
+                evt.xy = pixel;
+                this.mousemove(evt);
+                return evt;
+            }
+
+            evt = this.customSnap(evt); 
+
+            return evt;
+    },
+
+    /**
+     * Method: findVertex
+     * Finds closesed vertex/point according to event's xy coordinatates
+     * Return pixel
+     *
+     * Parameters:
+     * evt - {Event} The browser event
+     * geometry - {Geometry} Geometry, in the vertex is to be searched (polygon/line/point)
+     * 
+     * Return:
+     * {Pixel} OpenLayers.Pixel of closesed vertex
+     */
+    findVertex: function (geometry,evt,pixel) {
+        
+        if (geometry.componentTypes) {
+            for (var i = 0; i < geometry.components.length; i++) {
+               pixel =  this.findVertex(geometry.components[i],evt,pixel);
+            }
+            return pixel;
+        }
+
+        var lonlat = new OpenLayers.LonLat();
+        var tmppixel = this.layer.map.getPixelFromLonLat(new OpenLayers.LonLat(
+                                geometry.x,geometry.y
+                                ));
+        /* does it fit to threshold? */
+        if (Math.abs(tmppixel.x-evt.xy.x) < this.snapDist &&
+            Math.abs(tmppixel.y-evt.xy.y)< this.snapDist) {
+
+            /* search for smallest difference */
+            var tmpdiff = Math.sqrt(Math.pow(Math.abs(tmppixel.x-evt.xy.x),2)+Math.pow(Math.abs(tmppixel.y-evt.xy.y),2));
+            if ( tmpdiff <Â this.diff) {
+                pixel = tmppixel;
+                this.diff = tmpdiff;
+            }
+        }   
+        return pixel; 
+
+    },
+
+    /**
+     * Method: customSnap
+     * This method gives you possibility to add custom snapping function, like requesting nearest points using e.g. server scripts
+     * Return The browser event
+     *
+     * Parameters:
+     * evt - {Event} The browser event
+     * 
+     * Return:
+     * {Event} The browser event
+     */
+    customSnap: function (evt) {
+        
+        return evt;
+
+    },
+            
+    /**
+     * Method: setSnapDist
+     * Return The browser event
+     *
+     * Parameters:
+     * evt - {Event} The browser event
+     * 
+     * Return:
+     * {Event} The browser event
+     */
+    setSnapDist: function (dist) {
+        
+        this.snapDist = dist;
+        this.style.pointRadius = this.snapDist;
+        return evt;
+
+    },
+
     CLASS_NAME: "OpenLayers.Handler.Point"
 });