summaryrefslogtreecommitdiff
path: root/misc/openlayers/lib/OpenLayers/Handler/Point.js
diff options
context:
space:
mode:
Diffstat (limited to 'misc/openlayers/lib/OpenLayers/Handler/Point.js')
-rw-r--r--misc/openlayers/lib/OpenLayers/Handler/Point.js556
1 files changed, 556 insertions, 0 deletions
diff --git a/misc/openlayers/lib/OpenLayers/Handler/Point.js b/misc/openlayers/lib/OpenLayers/Handler/Point.js
new file mode 100644
index 0000000..b4bb17c
--- /dev/null
+++ b/misc/openlayers/lib/OpenLayers/Handler/Point.js
@@ -0,0 +1,556 @@
+/* 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/Handler.js
+ * @requires OpenLayers/Geometry/Point.js
+ */
+
+/**
+ * Class: OpenLayers.Handler.Point
+ * Handler to draw a point on the map. Point is displayed on activation,
+ * moves on mouse move, and is finished on mouse up. The handler triggers
+ * callbacks for 'done', 'cancel', and 'modify'. The modify callback is
+ * called with each change in the sketch and will receive the latest point
+ * drawn. Create a new instance with the <OpenLayers.Handler.Point>
+ * constructor.
+ *
+ * Inherits from:
+ * - <OpenLayers.Handler>
+ */
+OpenLayers.Handler.Point = OpenLayers.Class(OpenLayers.Handler, {
+
+ /**
+ * Property: point
+ * {<OpenLayers.Feature.Vector>} The currently drawn point
+ */
+ point: null,
+
+ /**
+ * Property: layer
+ * {<OpenLayers.Layer.Vector>} The temporary drawing layer
+ */
+ layer: null,
+
+ /**
+ * APIProperty: multi
+ * {Boolean} Cast features to multi-part geometries before passing to the
+ * layer. Default is false.
+ */
+ multi: false,
+
+ /**
+ * APIProperty: citeCompliant
+ * {Boolean} If set to true, coordinates of features drawn in a map extent
+ * crossing the date line won't exceed the world bounds. Default is false.
+ */
+ citeCompliant: false,
+
+ /**
+ * Property: mouseDown
+ * {Boolean} The mouse is down
+ */
+ mouseDown: false,
+
+ /**
+ * Property: stoppedDown
+ * {Boolean} Indicate whether the last mousedown stopped the event
+ * propagation.
+ */
+ stoppedDown: null,
+
+ /**
+ * Property: lastDown
+ * {<OpenLayers.Pixel>} Location of the last mouse down
+ */
+ lastDown: null,
+
+ /**
+ * Property: lastUp
+ * {<OpenLayers.Pixel>}
+ */
+ lastUp: null,
+
+ /**
+ * APIProperty: persist
+ * {Boolean} Leave the feature rendered until destroyFeature is called.
+ * Default is false. If set to true, the feature remains rendered until
+ * destroyFeature is called, typically by deactivating the handler or
+ * starting another drawing.
+ */
+ persist: false,
+
+ /**
+ * APIProperty: stopDown
+ * {Boolean} Stop event propagation on mousedown. Must be false to
+ * allow "pan while drawing". Defaults to false.
+ */
+ stopDown: false,
+
+ /**
+ * APIPropery: stopUp
+ * {Boolean} Stop event propagation on mouse. Must be false to
+ * allow "pan while dragging". Defaults to fase.
+ */
+ stopUp: false,
+
+ /**
+ * Property: layerOptions
+ * {Object} Any optional properties to be set on the sketch layer.
+ */
+ layerOptions: null,
+
+ /**
+ * APIProperty: pixelTolerance
+ * {Number} Maximum number of pixels between down and up (mousedown
+ * and mouseup, or touchstart and touchend) for the handler to
+ * add a new point. If set to an integer value, if the
+ * displacement between down and up is great to this value
+ * no point will be added. Default value is 5.
+ */
+ pixelTolerance: 5,
+
+ /**
+ * Property: lastTouchPx
+ * {<OpenLayers.Pixel>} The last pixel used to know the distance between
+ * two touches (for double touch).
+ */
+ lastTouchPx: null,
+
+ /**
+ * Constructor: OpenLayers.Handler.Point
+ * Create a new point handler.
+ *
+ * Parameters:
+ * control - {<OpenLayers.Control>} The control that owns this handler
+ * callbacks - {Object} An object with a properties whose values are
+ * functions. Various callbacks described below.
+ * options - {Object} An optional object with properties to be set on the
+ * handler
+ *
+ * Named callbacks:
+ * create - Called when a sketch is first created. Callback called with
+ * the creation point geometry and sketch feature.
+ * modify - Called with each move of a vertex with the vertex (point)
+ * geometry and the sketch feature.
+ * done - Called when the point drawing is finished. The callback will
+ * recieve a single argument, the point geometry.
+ * cancel - Called when the handler is deactivated while drawing. The
+ * cancel callback will receive a geometry.
+ */
+ initialize: function(control, callbacks, options) {
+ if(!(options && options.layerOptions && options.layerOptions.styleMap)) {
+ this.style = OpenLayers.Util.extend(OpenLayers.Feature.Vector.style['default'], {});
+ }
+
+ OpenLayers.Handler.prototype.initialize.apply(this, arguments);
+ },
+
+ /**
+ * APIMethod: activate
+ * turn on the handler
+ */
+ activate: function() {
+ if(!OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
+ return false;
+ }
+ // create temporary vector layer for rendering geometry sketch
+ // TBD: this could be moved to initialize/destroy - setting visibility here
+ var options = OpenLayers.Util.extend({
+ displayInLayerSwitcher: false,
+ // indicate that the temp vector layer will never be out of range
+ // without this, resolution properties must be specified at the
+ // map-level for this temporary layer to init its resolutions
+ // correctly
+ calculateInRange: OpenLayers.Function.True,
+ wrapDateLine: this.citeCompliant
+ }, this.layerOptions);
+ this.layer = new OpenLayers.Layer.Vector(this.CLASS_NAME, options);
+ this.map.addLayer(this.layer);
+ return true;
+ },
+
+ /**
+ * Method: createFeature
+ * Add temporary features
+ *
+ * Parameters:
+ * pixel - {<OpenLayers.Pixel>} A pixel location on the map.
+ */
+ createFeature: function(pixel) {
+ var lonlat = this.layer.getLonLatFromViewPortPx(pixel);
+ var geometry = new OpenLayers.Geometry.Point(
+ lonlat.lon, lonlat.lat
+ );
+ this.point = new OpenLayers.Feature.Vector(geometry);
+ this.callback("create", [this.point.geometry, this.point]);
+ this.point.geometry.clearBounds();
+ this.layer.addFeatures([this.point], {silent: true});
+ },
+
+ /**
+ * APIMethod: deactivate
+ * turn off the handler
+ */
+ deactivate: function() {
+ if(!OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
+ return false;
+ }
+ this.cancel();
+ // If a layer's map property is set to null, it means that that layer
+ // isn't added to the map. Since we ourself added the layer to the map
+ // in activate(), we can assume that if this.layer.map is null it means
+ // that the layer has been destroyed (as a result of map.destroy() for
+ // example.
+ if (this.layer.map != null) {
+ this.destroyFeature(true);
+ this.layer.destroy(false);
+ }
+ this.layer = null;
+ return true;
+ },
+
+ /**
+ * Method: destroyFeature
+ * Destroy the temporary geometries
+ *
+ * Parameters:
+ * force - {Boolean} Destroy even if persist is true.
+ */
+ destroyFeature: function(force) {
+ if(this.layer && (force || !this.persist)) {
+ this.layer.destroyFeatures();
+ }
+ this.point = null;
+ },
+
+ /**
+ * Method: destroyPersistedFeature
+ * Destroy the persisted feature.
+ */
+ destroyPersistedFeature: function() {
+ var layer = this.layer;
+ if(layer && layer.features.length > 1) {
+ this.layer.features[0].destroy();
+ }
+ },
+
+ /**
+ * Method: finalize
+ * Finish the geometry and call the "done" callback.
+ *
+ * Parameters:
+ * cancel - {Boolean} Call cancel instead of done callback. Default
+ * is false.
+ */
+ finalize: function(cancel) {
+ var key = cancel ? "cancel" : "done";
+ this.mouseDown = false;
+ this.lastDown = null;
+ this.lastUp = null;
+ this.lastTouchPx = null;
+ this.callback(key, [this.geometryClone()]);
+ this.destroyFeature(cancel);
+ },
+
+ /**
+ * APIMethod: cancel
+ * Finish the geometry and call the "cancel" callback.
+ */
+ cancel: function() {
+ this.finalize(true);
+ },
+
+ /**
+ * Method: click
+ * Handle clicks. Clicks are stopped from propagating to other listeners
+ * on map.events or other dom elements.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ click: function(evt) {
+ OpenLayers.Event.stop(evt);
+ return false;
+ },
+
+ /**
+ * Method: dblclick
+ * Handle double-clicks. Double-clicks are stopped from propagating to other
+ * listeners on map.events or other dom elements.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ dblclick: function(evt) {
+ OpenLayers.Event.stop(evt);
+ return false;
+ },
+
+ /**
+ * Method: modifyFeature
+ * Modify the existing geometry given a pixel location.
+ *
+ * Parameters:
+ * pixel - {<OpenLayers.Pixel>} A pixel location on the map.
+ */
+ modifyFeature: function(pixel) {
+ if(!this.point) {
+ this.createFeature(pixel);
+ }
+ var lonlat = this.layer.getLonLatFromViewPortPx(pixel);
+ this.point.geometry.x = lonlat.lon;
+ this.point.geometry.y = lonlat.lat;
+ this.callback("modify", [this.point.geometry, this.point, false]);
+ this.point.geometry.clearBounds();
+ this.drawFeature();
+ },
+
+ /**
+ * Method: drawFeature
+ * Render features on the temporary layer.
+ */
+ drawFeature: function() {
+ this.layer.drawFeature(this.point, this.style);
+ },
+
+ /**
+ * Method: getGeometry
+ * Return the sketch geometry. If <multi> is true, this will return
+ * a multi-part geometry.
+ *
+ * Returns:
+ * {<OpenLayers.Geometry.Point>}
+ */
+ getGeometry: function() {
+ var geometry = this.point && this.point.geometry;
+ if(geometry && this.multi) {
+ geometry = new OpenLayers.Geometry.MultiPoint([geometry]);
+ }
+ return geometry;
+ },
+
+ /**
+ * Method: geometryClone
+ * Return a clone of the relevant geometry.
+ *
+ * Returns:
+ * {<OpenLayers.Geometry>}
+ */
+ geometryClone: function() {
+ var geom = this.getGeometry();
+ return geom && geom.clone();
+ },
+
+ /**
+ * Method: mousedown
+ * Handle mousedown.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ mousedown: function(evt) {
+ return this.down(evt);
+ },
+
+ /**
+ * Method: touchstart
+ * Handle touchstart.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ touchstart: function(evt) {
+ this.startTouch();
+ this.lastTouchPx = evt.xy;
+ return this.down(evt);
+ },
+
+ /**
+ * Method: mousemove
+ * Handle mousemove.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ mousemove: function(evt) {
+ return this.move(evt);
+ },
+
+ /**
+ * Method: touchmove
+ * Handle touchmove.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ touchmove: function(evt) {
+ this.lastTouchPx = evt.xy;
+ return this.move(evt);
+ },
+
+ /**
+ * Method: mouseup
+ * Handle mouseup.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ mouseup: function(evt) {
+ return this.up(evt);
+ },
+
+ /**
+ * Method: touchend
+ * Handle touchend.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ touchend: function(evt) {
+ evt.xy = this.lastTouchPx;
+ return this.up(evt);
+ },
+
+ /**
+ * Method: down
+ * Handle mousedown and touchstart. Adjust the geometry and redraw.
+ * Return determines whether to propagate the event on the map.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ down: function(evt) {
+ this.mouseDown = true;
+ this.lastDown = evt.xy;
+ if(!this.touch) { // no point displayed until up on touch devices
+ this.modifyFeature(evt.xy);
+ }
+ this.stoppedDown = this.stopDown;
+ return !this.stopDown;
+ },
+
+ /**
+ * Method: move
+ * Handle mousemove and touchmove. Adjust the geometry and redraw.
+ * Return determines whether to propagate the event on the map.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ move: function (evt) {
+ if(!this.touch // no point displayed until up on touch devices
+ && (!this.mouseDown || this.stoppedDown)) {
+ this.modifyFeature(evt.xy);
+ }
+ return true;
+ },
+
+ /**
+ * Method: up
+ * Handle mouseup and touchend. Send the latest point in the geometry to the control.
+ * Return determines whether to propagate the event on the map.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ *
+ * Returns:
+ * {Boolean} Allow event propagation
+ */
+ up: function (evt) {
+ this.mouseDown = false;
+ this.stoppedDown = this.stopDown;
+
+ // check keyboard modifiers
+ if(!this.checkModifiers(evt)) {
+ return true;
+ }
+ // ignore double-clicks
+ if (this.lastUp && this.lastUp.equals(evt.xy)) {
+ return true;
+ }
+ if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy,
+ this.pixelTolerance)) {
+ if (this.touch) {
+ this.modifyFeature(evt.xy);
+ }
+ if(this.persist) {
+ this.destroyPersistedFeature();
+ }
+ this.lastUp = evt.xy;
+ this.finalize();
+ return !this.stopUp;
+ } else {
+ return true;
+ }
+ },
+
+ /**
+ * Method: mouseout
+ * Handle mouse out. For better user experience reset mouseDown
+ * and stoppedDown when the mouse leaves the map viewport.
+ *
+ * Parameters:
+ * evt - {Event} The browser event
+ */
+ mouseout: function(evt) {
+ if(OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) {
+ this.stoppedDown = this.stopDown;
+ this.mouseDown = false;
+ }
+ },
+
+ /**
+ * Method: passesTolerance
+ * Determine whether the event is within the optional pixel tolerance.
+ *
+ * Returns:
+ * {Boolean} The event is within the pixel tolerance (if specified).
+ */
+ passesTolerance: function(pixel1, pixel2, tolerance) {
+ var passes = true;
+
+ if (tolerance != null && pixel1 && pixel2) {
+ var dist = pixel1.distanceTo(pixel2);
+ if (dist > tolerance) {
+ passes = false;
+ }
+ }
+ return passes;
+ },
+
+ CLASS_NAME: "OpenLayers.Handler.Point"
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-22 20:27:43 +0000