314 lines
8.0 KiB
JavaScript
314 lines
8.0 KiB
JavaScript
goog.provide('ol.interaction.Draw');
|
|
goog.provide('ol.interaction.DrawMode');
|
|
|
|
goog.require('goog.asserts');
|
|
|
|
goog.require('ol.Coordinate');
|
|
goog.require('ol.Feature');
|
|
goog.require('ol.Map');
|
|
goog.require('ol.MapBrowserEvent');
|
|
goog.require('ol.MapBrowserEvent.EventType');
|
|
goog.require('ol.geom.LineString');
|
|
goog.require('ol.geom.Point');
|
|
goog.require('ol.geom.Polygon');
|
|
goog.require('ol.interaction.Interaction');
|
|
goog.require('ol.layer.Vector');
|
|
goog.require('ol.layer.VectorLayerRenderIntent');
|
|
goog.require('ol.source.Vector');
|
|
|
|
|
|
|
|
/**
|
|
* Interaction that allows drawing geometries.
|
|
* @param {ol.interaction.DrawOptions} options Options.
|
|
* @constructor
|
|
* @extends {ol.interaction.Interaction}
|
|
*/
|
|
ol.interaction.Draw = function(options) {
|
|
goog.base(this);
|
|
|
|
/**
|
|
* Target layer for drawn features.
|
|
* @type {ol.layer.Vector}
|
|
* @private
|
|
*/
|
|
this.layer_ = options.layer;
|
|
|
|
/**
|
|
* Temporary sketch layer.
|
|
* @type {ol.layer.Vector}
|
|
* @private
|
|
*/
|
|
this.sketchLayer_ = null;
|
|
|
|
/**
|
|
* Pixel distance for snapping.
|
|
* @type {number}
|
|
* @private
|
|
*/
|
|
this.snapTolerance_ = 15;
|
|
|
|
/**
|
|
* Draw mode.
|
|
* @type {ol.interaction.DrawMode}
|
|
* @private
|
|
*/
|
|
this.mode_ = options.mode;
|
|
|
|
/**
|
|
* Finish coordinate for the feature (first point for polygons, last point for
|
|
* linestrings).
|
|
* @type {ol.Coordinate}
|
|
* @private
|
|
*/
|
|
this.finishCoordinate_ = null;
|
|
|
|
/**
|
|
* Sketch feature.
|
|
* @type {ol.Feature}
|
|
* @private
|
|
*/
|
|
this.sketchFeature_ = null;
|
|
|
|
/**
|
|
* Sketch point.
|
|
* @type {ol.Feature}
|
|
* @private
|
|
*/
|
|
this.sketchPoint_ = null;
|
|
|
|
};
|
|
goog.inherits(ol.interaction.Draw, ol.interaction.Interaction);
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.interaction.Draw.prototype.setMap = function(map) {
|
|
var oldMap = this.getMap();
|
|
if (!goog.isNull(oldMap)) {
|
|
oldMap.removeLayer(this.sketchLayer_);
|
|
}
|
|
|
|
if (!goog.isNull(map)) {
|
|
if (goog.isNull(this.sketchLayer_)) {
|
|
var layer = new ol.layer.Vector({
|
|
source: new ol.source.Vector({parser: null}),
|
|
style: this.layer_.getStyle()
|
|
});
|
|
layer.setTemporary(true);
|
|
this.sketchLayer_ = layer;
|
|
}
|
|
map.addLayer(this.sketchLayer_);
|
|
} else {
|
|
// removing from a map, clean up
|
|
this.sketchLayer_ = null;
|
|
this.finishCoordinate_ = null;
|
|
this.sketchFeature_ = null;
|
|
}
|
|
|
|
goog.base(this, 'setMap', map);
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.interaction.Draw.prototype.handleMapBrowserEvent = function(event) {
|
|
var map = event.map;
|
|
if (!map.isDef()) {
|
|
return true;
|
|
}
|
|
var pass = true;
|
|
if (event.type === ol.MapBrowserEvent.EventType.CLICK) {
|
|
pass = this.handleClick_(event);
|
|
} else if (event.type === ol.MapBrowserEvent.EventType.MOUSEMOVE) {
|
|
pass = this.handleMove_(event);
|
|
}
|
|
return pass;
|
|
};
|
|
|
|
|
|
/**
|
|
* Handle click events.
|
|
* @param {ol.MapBrowserEvent} event A click event.
|
|
* @return {boolean} Pass the event to other interactions.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.handleClick_ = function(event) {
|
|
if (goog.isNull(this.finishCoordinate_)) {
|
|
this.startDrawing_(event);
|
|
} else if (this.mode_ === ol.interaction.DrawMode.POINT ||
|
|
this.atFinish_(event)) {
|
|
this.finishDrawing_(event);
|
|
} else {
|
|
this.addToDrawing_(event);
|
|
}
|
|
return false;
|
|
};
|
|
|
|
|
|
/**
|
|
* Handle mousemove events.
|
|
* @param {ol.MapBrowserEvent} event A mousemove event.
|
|
* @return {boolean} Pass the event to other interactions.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.handleMove_ = function(event) {
|
|
if (this.mode_ === ol.interaction.DrawMode.POINT &&
|
|
goog.isNull(this.finishCoordinate_)) {
|
|
this.startDrawing_(event);
|
|
} else if (!goog.isNull(this.finishCoordinate_)) {
|
|
this.modifyDrawing_(event);
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
/**
|
|
* Determine if an event is within the snapping tolerance of the start coord.
|
|
* @param {ol.MapBrowserEvent} event Event.
|
|
* @return {boolean} The event is within the snapping tolerance of the start.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.atFinish_ = function(event) {
|
|
var map = event.map;
|
|
var finishPixel = map.getPixelFromCoordinate(this.finishCoordinate_);
|
|
var pixel = event.getPixel();
|
|
var dx = pixel[0] - finishPixel[0];
|
|
var dy = pixel[1] - finishPixel[1];
|
|
return Math.sqrt(dx * dx + dy * dy) <= this.snapTolerance_;
|
|
};
|
|
|
|
|
|
/**
|
|
* Start the drawing.
|
|
* @param {ol.MapBrowserEvent} event Event.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.startDrawing_ = function(event) {
|
|
var start = event.getCoordinate();
|
|
this.finishCoordinate_ = start;
|
|
var sketchFeature = new ol.Feature();
|
|
sketchFeature.setRenderIntent(ol.layer.VectorLayerRenderIntent.SELECTED);
|
|
var features = [sketchFeature];
|
|
var geometry;
|
|
if (this.mode_ === ol.interaction.DrawMode.POINT) {
|
|
geometry = new ol.geom.Point(start.slice());
|
|
} else {
|
|
var sketchPoint = new ol.Feature({
|
|
geom: new ol.geom.Point(start.slice())
|
|
});
|
|
sketchPoint.setRenderIntent(ol.layer.VectorLayerRenderIntent.FUTURE);
|
|
this.sketchPoint_ = sketchPoint;
|
|
features.push(sketchPoint);
|
|
|
|
if (this.mode_ === ol.interaction.DrawMode.LINESTRING) {
|
|
geometry = new ol.geom.LineString([start.slice(), start.slice()]);
|
|
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
|
|
geometry = new ol.geom.Polygon([[start.slice(), start.slice()]]);
|
|
}
|
|
}
|
|
goog.asserts.assert(goog.isDef(geometry));
|
|
sketchFeature.setGeometry(geometry);
|
|
this.sketchFeature_ = sketchFeature;
|
|
|
|
this.sketchLayer_.addFeatures(features);
|
|
};
|
|
|
|
|
|
/**
|
|
* Modify the drawing.
|
|
* @param {ol.MapBrowserEvent} event Event.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.modifyDrawing_ = function(event) {
|
|
var coordinate = event.getCoordinate();
|
|
var geometry = this.sketchFeature_.getGeometry();
|
|
var coordinates, last;
|
|
if (this.mode_ === ol.interaction.DrawMode.POINT) {
|
|
last = geometry.getCoordinates();
|
|
last[0] = coordinate[0];
|
|
last[1] = coordinate[1];
|
|
geometry.setCoordinates(last);
|
|
} else {
|
|
this.sketchPoint_.getGeometry().setCoordinates(coordinate);
|
|
if (this.mode_ === ol.interaction.DrawMode.LINESTRING) {
|
|
coordinates = geometry.getCoordinates();
|
|
last = coordinates[coordinates.length - 1];
|
|
last[0] = coordinate[0];
|
|
last[1] = coordinate[1];
|
|
geometry.setCoordinates(coordinates);
|
|
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
|
|
var ring = geometry.getRings()[0];
|
|
coordinates = ring.getCoordinates();
|
|
last = coordinates[coordinates.length - 1];
|
|
last[0] = coordinate[0];
|
|
last[1] = coordinate[1];
|
|
ring.setCoordinates(coordinates);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Add a new coordinate to the drawing.
|
|
* @param {ol.MapBrowserEvent} event Event.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.addToDrawing_ = function(event) {
|
|
var coordinate = event.getCoordinate();
|
|
var geometry = this.sketchFeature_.getGeometry();
|
|
var coordinates, last;
|
|
if (this.mode_ === ol.interaction.DrawMode.LINESTRING) {
|
|
this.finishCoordinate_ = coordinate.slice();
|
|
coordinates = geometry.getCoordinates();
|
|
coordinates.push(coordinate.slice());
|
|
geometry.setCoordinates(coordinates);
|
|
} else if (this.mode_ === ol.interaction.DrawMode.POLYGON) {
|
|
var ring = geometry.getRings()[0];
|
|
coordinates = ring.getCoordinates();
|
|
coordinates.push(coordinate.slice());
|
|
ring.setCoordinates(coordinates);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Finish the drawing.
|
|
* @param {ol.MapBrowserEvent} event Event.
|
|
* @private
|
|
*/
|
|
ol.interaction.Draw.prototype.finishDrawing_ = function(event) {
|
|
this.finishCoordinate_ = null;
|
|
var sketchFeature = this.sketchFeature_;
|
|
var features = [sketchFeature];
|
|
if (this.mode_ !== ol.interaction.DrawMode.POINT) {
|
|
features.push(this.sketchPoint_);
|
|
}
|
|
this.sketchLayer_.removeFeatures(features);
|
|
sketchFeature.setRenderIntent(ol.layer.VectorLayerRenderIntent.DEFAULT);
|
|
this.layer_.addFeatures([sketchFeature]);
|
|
};
|
|
|
|
|
|
/**
|
|
* Set the drawing mode.
|
|
* @param {ol.interaction.DrawMode} mode Draw mode ('point', 'linestring', or
|
|
* 'polygon').
|
|
*/
|
|
ol.interaction.Draw.prototype.setMode = function(mode) {
|
|
this.mode_ = mode;
|
|
};
|
|
|
|
|
|
/**
|
|
* Draw mode.
|
|
* @enum {string}
|
|
*/
|
|
ol.interaction.DrawMode = {
|
|
POINT: 'point',
|
|
LINESTRING: 'linestring',
|
|
POLYGON: 'polygon'
|
|
};
|