mirror of
https://github.com/sakitam-fdd/maptalks.plot.git
synced 2025-12-08 20:35:49 +00:00
792 lines
20 KiB
JavaScript
792 lines
20 KiB
JavaScript
/*!
|
|
* maptalks.plot v0.0.0
|
|
* LICENSE : MIT
|
|
* (c) 2017-2017 https://sakitam-fdd.github.io/maptalks.plot
|
|
*/
|
|
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('maptalks')) :
|
|
typeof define === 'function' && define.amd ? define(['exports', 'maptalks'], factory) :
|
|
(factory((global.MaptalksPlot = {}),global.maptalks));
|
|
}(this, (function (exports,maptalks) { 'use strict';
|
|
|
|
var TextArea = 'TextArea';
|
|
var ARC = 'Arc';
|
|
var CURVE = 'Curve';
|
|
var GATHERING_PLACE = 'GatheringPlace';
|
|
var POLYLINE = 'Polyline';
|
|
var FREE_LINE = 'FreeLine';
|
|
var POINT = 'Point';
|
|
var PENNANT = 'Pennant';
|
|
var RECTANGLE = 'RectAngle';
|
|
var CIRCLE = 'Circle';
|
|
var ELLIPSE = 'Ellipse';
|
|
var LUNE = 'Lune';
|
|
var SECTOR = 'Sector';
|
|
var CLOSED_CURVE = 'ClosedCurve';
|
|
var POLYGON = 'Polygon';
|
|
var FREE_POLYGON = 'FreePolygon';
|
|
var ATTACK_ARROW = 'AttackArrow';
|
|
var DOUBLE_ARROW = 'DoubleArrow';
|
|
var STRAIGHT_ARROW = 'StraightArrow';
|
|
var FINE_ARROW = 'FineArrow';
|
|
var ASSAULT_DIRECTION = 'AssaultDirection';
|
|
var TAILED_ATTACK_ARROW = 'TailedAttackArrow';
|
|
var SQUAD_COMBAT = 'SquadCombat';
|
|
var TAILED_SQUAD_COMBAT = 'TailedSquadCombat';
|
|
var RECTFLAG = 'RectFlag';
|
|
var TRIANGLEFLAG = 'TriangleFlag';
|
|
var CURVEFLAG = 'CurveFlag';
|
|
|
|
|
|
var PlotTypes = Object.freeze({
|
|
TextArea: TextArea,
|
|
ARC: ARC,
|
|
CURVE: CURVE,
|
|
GATHERING_PLACE: GATHERING_PLACE,
|
|
POLYLINE: POLYLINE,
|
|
FREE_LINE: FREE_LINE,
|
|
POINT: POINT,
|
|
PENNANT: PENNANT,
|
|
RECTANGLE: RECTANGLE,
|
|
CIRCLE: CIRCLE,
|
|
ELLIPSE: ELLIPSE,
|
|
LUNE: LUNE,
|
|
SECTOR: SECTOR,
|
|
CLOSED_CURVE: CLOSED_CURVE,
|
|
POLYGON: POLYGON,
|
|
FREE_POLYGON: FREE_POLYGON,
|
|
ATTACK_ARROW: ATTACK_ARROW,
|
|
DOUBLE_ARROW: DOUBLE_ARROW,
|
|
STRAIGHT_ARROW: STRAIGHT_ARROW,
|
|
FINE_ARROW: FINE_ARROW,
|
|
ASSAULT_DIRECTION: ASSAULT_DIRECTION,
|
|
TAILED_SQUAD_COMBAT: TAILED_SQUAD_COMBAT,
|
|
TAILED_ATTACK_ARROW: TAILED_ATTACK_ARROW,
|
|
SQUAD_COMBAT: SQUAD_COMBAT,
|
|
RECTFLAG: RECTFLAG,
|
|
TRIANGLEFLAG: TRIANGLEFLAG,
|
|
CURVEFLAG: CURVEFLAG
|
|
});
|
|
|
|
var BASE_LAYERNAME = 'maptalks-plot-vector-layer';
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
|
return typeof obj;
|
|
} : function (obj) {
|
|
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
var asyncGenerator = function () {
|
|
function AwaitValue(value) {
|
|
this.value = value;
|
|
}
|
|
|
|
function AsyncGenerator(gen) {
|
|
var front, back;
|
|
|
|
function send(key, arg) {
|
|
return new Promise(function (resolve, reject) {
|
|
var request = {
|
|
key: key,
|
|
arg: arg,
|
|
resolve: resolve,
|
|
reject: reject,
|
|
next: null
|
|
};
|
|
|
|
if (back) {
|
|
back = back.next = request;
|
|
} else {
|
|
front = back = request;
|
|
resume(key, arg);
|
|
}
|
|
});
|
|
}
|
|
|
|
function resume(key, arg) {
|
|
try {
|
|
var result = gen[key](arg);
|
|
var value = result.value;
|
|
|
|
if (value instanceof AwaitValue) {
|
|
Promise.resolve(value.value).then(function (arg) {
|
|
resume("next", arg);
|
|
}, function (arg) {
|
|
resume("throw", arg);
|
|
});
|
|
} else {
|
|
settle(result.done ? "return" : "normal", result.value);
|
|
}
|
|
} catch (err) {
|
|
settle("throw", err);
|
|
}
|
|
}
|
|
|
|
function settle(type, value) {
|
|
switch (type) {
|
|
case "return":
|
|
front.resolve({
|
|
value: value,
|
|
done: true
|
|
});
|
|
break;
|
|
|
|
case "throw":
|
|
front.reject(value);
|
|
break;
|
|
|
|
default:
|
|
front.resolve({
|
|
value: value,
|
|
done: false
|
|
});
|
|
break;
|
|
}
|
|
|
|
front = front.next;
|
|
|
|
if (front) {
|
|
resume(front.key, front.arg);
|
|
} else {
|
|
back = null;
|
|
}
|
|
}
|
|
|
|
this._invoke = send;
|
|
|
|
if (typeof gen.return !== "function") {
|
|
this.return = undefined;
|
|
}
|
|
}
|
|
|
|
if (typeof Symbol === "function" && Symbol.asyncIterator) {
|
|
AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
|
|
return this;
|
|
};
|
|
}
|
|
|
|
AsyncGenerator.prototype.next = function (arg) {
|
|
return this._invoke("next", arg);
|
|
};
|
|
|
|
AsyncGenerator.prototype.throw = function (arg) {
|
|
return this._invoke("throw", arg);
|
|
};
|
|
|
|
AsyncGenerator.prototype.return = function (arg) {
|
|
return this._invoke("return", arg);
|
|
};
|
|
|
|
return {
|
|
wrap: function (fn) {
|
|
return function () {
|
|
return new AsyncGenerator(fn.apply(this, arguments));
|
|
};
|
|
},
|
|
await: function (value) {
|
|
return new AwaitValue(value);
|
|
}
|
|
};
|
|
}();
|
|
|
|
|
|
|
|
|
|
|
|
var classCallCheck = function (instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var inherits = function (subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var possibleConstructorReturn = function (self, call) {
|
|
if (!self) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
|
|
return call && (typeof call === "object" || typeof call === "function") ? call : self;
|
|
};
|
|
|
|
var Canvas2d = maptalks.Canvas;
|
|
var options = {
|
|
'arcDegree': 90
|
|
};
|
|
|
|
var Curve = function (_maptalks$LineString) {
|
|
inherits(Curve, _maptalks$LineString);
|
|
|
|
function Curve() {
|
|
classCallCheck(this, Curve);
|
|
return possibleConstructorReturn(this, _maptalks$LineString.apply(this, arguments));
|
|
}
|
|
|
|
Curve.prototype._arc = function _arc(ctx, points, lineOpacity) {
|
|
var degree = this.options['arcDegree'] * Math.PI / 180;
|
|
for (var i = 1, l = points.length; i < l; i++) {
|
|
Canvas2d._arcBetween(ctx, points[i - 1], points[i], degree);
|
|
Canvas2d._stroke(ctx, lineOpacity);
|
|
}
|
|
};
|
|
|
|
Curve.prototype._quadraticCurve = function _quadraticCurve(ctx, points) {
|
|
if (points.length <= 2) {
|
|
Canvas2d._path(ctx, points);
|
|
return;
|
|
}
|
|
Canvas2d.quadraticCurve(ctx, points);
|
|
};
|
|
|
|
Curve.prototype._bezierCurve = function _bezierCurve(ctx, points) {
|
|
if (points.length <= 3) {
|
|
Canvas2d._path(ctx, points);
|
|
return;
|
|
}
|
|
var i = void 0,
|
|
l = void 0;
|
|
for (i = 1, l = points.length; i + 2 < l; i += 3) {
|
|
ctx.bezierCurveTo(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y, points[i + 2].x, points[i + 2].y);
|
|
}
|
|
if (i < l) {
|
|
for (; i < l; i++) {
|
|
ctx.lineTo(points[i].x, points[i].y);
|
|
}
|
|
}
|
|
};
|
|
|
|
Curve.prototype._toJSON = function _toJSON(options) {
|
|
return {
|
|
'feature': this.toGeoJSON(options),
|
|
'subType': 'Curve'
|
|
};
|
|
};
|
|
|
|
Curve.prototype._paintOn = function _paintOn(ctx, points, lineOpacity) {
|
|
ctx.beginPath();
|
|
this._arc(ctx, points, lineOpacity);
|
|
Canvas2d._stroke(ctx, lineOpacity);
|
|
this._paintArrow(ctx, points, lineOpacity);
|
|
};
|
|
|
|
Curve.fromJSON = function fromJSON(json) {
|
|
var feature = json['feature'];
|
|
var arc = new Curve(feature['geometry']['coordinates'], json['options']);
|
|
arc.setProperties(feature['properties']);
|
|
return arc;
|
|
};
|
|
|
|
return Curve;
|
|
}(maptalks.LineString);
|
|
|
|
Curve.registerJSONType('Curve');
|
|
Curve.mergeOptions(options);
|
|
|
|
var Coordinate$1 = maptalks.Coordinate;
|
|
var options$1 = {
|
|
'arrowStyle': null,
|
|
'arrowPlacement': 'vertex-last',
|
|
'clipToPaint': true
|
|
};
|
|
|
|
var Polyline = function (_maptalks$LineString) {
|
|
inherits(Polyline, _maptalks$LineString);
|
|
|
|
function Polyline(coordinates) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
classCallCheck(this, Polyline);
|
|
|
|
var _this = possibleConstructorReturn(this, _maptalks$LineString.call(this, options));
|
|
|
|
_this.type = 'Polyline';
|
|
if (coordinates) {
|
|
_this.setCoordinates(coordinates);
|
|
}
|
|
return _this;
|
|
}
|
|
|
|
Polyline.prototype._exportGeoJSONGeometry = function _exportGeoJSONGeometry() {
|
|
var points = this.getCoordinates();
|
|
var coordinates = Coordinate$1.toNumberArrays(points);
|
|
return {
|
|
'type': 'LineString',
|
|
'coordinates': coordinates
|
|
};
|
|
};
|
|
|
|
Polyline.prototype._toJSON = function _toJSON(options) {
|
|
return {
|
|
'feature': this.toGeoJSON(options)
|
|
};
|
|
};
|
|
|
|
return Polyline;
|
|
}(maptalks.LineString);
|
|
|
|
Polyline.mergeOptions(options$1);
|
|
|
|
Polyline.registerJSONType('Polyline');
|
|
|
|
var Coordinate$2 = maptalks.Coordinate;
|
|
var options$2 = {
|
|
'arrowStyle': null,
|
|
'arrowPlacement': 'vertex-last',
|
|
'clipToPaint': true
|
|
};
|
|
|
|
var FreeLine = function (_maptalks$LineString) {
|
|
inherits(FreeLine, _maptalks$LineString);
|
|
|
|
function FreeLine(coordinates) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
classCallCheck(this, FreeLine);
|
|
|
|
var _this = possibleConstructorReturn(this, _maptalks$LineString.call(this, options));
|
|
|
|
_this.type = 'FreeLine';
|
|
if (coordinates) {
|
|
_this.setCoordinates(coordinates);
|
|
}
|
|
return _this;
|
|
}
|
|
|
|
FreeLine.prototype._exportGeoJSONGeometry = function _exportGeoJSONGeometry() {
|
|
var points = this.getCoordinates();
|
|
var coordinates = Coordinate$2.toNumberArrays(points);
|
|
return {
|
|
'type': 'LineString',
|
|
'coordinates': coordinates
|
|
};
|
|
};
|
|
|
|
FreeLine.prototype._toJSON = function _toJSON(options) {
|
|
return {
|
|
'feature': this.toGeoJSON(options)
|
|
};
|
|
};
|
|
|
|
return FreeLine;
|
|
}(maptalks.LineString);
|
|
|
|
FreeLine.mergeOptions(options$2);
|
|
|
|
FreeLine.registerJSONType('FreeLine');
|
|
|
|
var RegisterModes = {};
|
|
RegisterModes[CURVE] = {
|
|
'action': ['click', 'click', 'dbclick'],
|
|
'create': function create(path) {
|
|
return new Curve(path);
|
|
},
|
|
'update': function update(path, geometry) {
|
|
geometry.setCoordinates(path);
|
|
},
|
|
'generate': function generate(geometry) {
|
|
return geometry;
|
|
}
|
|
};
|
|
RegisterModes[POLYLINE] = {
|
|
'action': ['click', 'mousemove', 'dbclick'],
|
|
'create': function create(path) {
|
|
return new Polyline(path);
|
|
},
|
|
'update': function update(path, geometry) {
|
|
geometry.setCoordinates(path);
|
|
},
|
|
'generate': function generate(geometry) {
|
|
return geometry;
|
|
}
|
|
};
|
|
RegisterModes[FREE_LINE] = {
|
|
'action': ['mousedown', 'drag', 'mouseup'],
|
|
'create': function create(path) {
|
|
return new FreeLine(path);
|
|
},
|
|
'update': function update(path, geometry) {
|
|
geometry.setCoordinates(path);
|
|
},
|
|
'generate': function generate(geometry) {
|
|
return geometry;
|
|
}
|
|
};
|
|
|
|
var isObject = function isObject(value) {
|
|
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
|
|
return value !== null && (type === 'object' || type === 'function');
|
|
};
|
|
|
|
var merge = function merge(a, b) {
|
|
for (var key in b) {
|
|
if (isObject(b[key]) && isObject(a[key])) {
|
|
merge(a[key], b[key]);
|
|
} else {
|
|
a[key] = b[key];
|
|
}
|
|
}
|
|
return a;
|
|
};
|
|
|
|
var _options = {
|
|
'symbol': {
|
|
'lineColor': '#000',
|
|
'lineWidth': 2,
|
|
'lineOpacity': 1,
|
|
'polygonFill': '#fff',
|
|
'polygonOpacity': 0.3
|
|
},
|
|
'doubleClickZoom': false,
|
|
'mode': null,
|
|
'once': false,
|
|
'ignoreMouseleave': true
|
|
};
|
|
var registeredMode = {};
|
|
var stopPropagation = function stopPropagation(e) {
|
|
if (e.stopPropagation) {
|
|
e.stopPropagation();
|
|
} else {
|
|
e.cancelBubble = true;
|
|
}
|
|
return this;
|
|
};
|
|
|
|
var PlotDraw = function (_maptalks$MapTool) {
|
|
inherits(PlotDraw, _maptalks$MapTool);
|
|
|
|
function PlotDraw() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
classCallCheck(this, PlotDraw);
|
|
|
|
var $options = merge(_options, options);
|
|
|
|
var _this = possibleConstructorReturn(this, _maptalks$MapTool.call(this, $options));
|
|
|
|
_this.options = $options;
|
|
if (_this.options['mode']) _this._getRegisterMode();
|
|
|
|
_this.layerName = _this.options && _this.options['layerName'] ? _this.options['layerName'] : BASE_LAYERNAME;
|
|
|
|
_this.drawLayer = null;
|
|
return _this;
|
|
}
|
|
|
|
PlotDraw.prototype._getRegisterMode = function _getRegisterMode() {
|
|
var mode = this.getMode();
|
|
var registerMode = PlotDraw.getRegisterMode(mode);
|
|
if (!registerMode) {
|
|
throw new Error(mode + ' is not a valid type of PlotDraw.');
|
|
}
|
|
return registerMode;
|
|
};
|
|
|
|
PlotDraw.prototype.setMode = function setMode(mode) {
|
|
this._clearStage();
|
|
this._switchEvents('off');
|
|
this.options['mode'] = mode;
|
|
this._getRegisterMode();
|
|
if (this.isEnabled()) {
|
|
this._switchEvents('on');
|
|
this._deactiveMapInteractions();
|
|
}
|
|
return this;
|
|
};
|
|
|
|
PlotDraw.prototype.getMode = function getMode() {
|
|
if (this.options['mode']) {
|
|
return this.options['mode'].toLowerCase();
|
|
}
|
|
return null;
|
|
};
|
|
|
|
PlotDraw.prototype._deactiveMapInteractions = function _deactiveMapInteractions() {
|
|
var map = this.getMap();
|
|
this._mapDoubleClickZoom = map.options['doubleClickZoom'];
|
|
map.config({
|
|
'doubleClickZoom': this.options['doubleClickZoom']
|
|
});
|
|
var action = this._getRegisterMode()['action'];
|
|
if (action.indexOf('drag') > -1) {
|
|
var _map = this.getMap();
|
|
this._mapDraggable = _map.options['draggable'];
|
|
_map.config({
|
|
'draggable': false
|
|
});
|
|
}
|
|
};
|
|
|
|
PlotDraw.prototype._activateMapInteractions = function _activateMapInteractions() {
|
|
var map = this.getMap();
|
|
map.config({
|
|
'doubleClickZoom': this._mapDoubleClickZoom
|
|
});
|
|
if (this._mapDraggable) {
|
|
map.config('draggable', this._mapDraggable);
|
|
}
|
|
delete this._mapDraggable;
|
|
delete this._mapDoubleClickZoom;
|
|
};
|
|
|
|
PlotDraw.prototype.getEvents = function getEvents() {
|
|
var action = this._getRegisterMode()['action'];
|
|
if (Array.isArray(action)) {
|
|
return {
|
|
'click': this._firstClickHandler,
|
|
'mousemove': this._mouseMoveHandler,
|
|
'dblclick': this._doubleClickHandler
|
|
};
|
|
}
|
|
return null;
|
|
};
|
|
|
|
PlotDraw.prototype._firstClickHandler = function _firstClickHandler(event) {
|
|
var registerMode = this._getRegisterMode();
|
|
var coordinate = event['coordinate'];
|
|
var symbol = this.getSymbol();
|
|
if (!this._geometry) {
|
|
this._clickCoords = [coordinate];
|
|
this._geometry = registerMode['create'](this._clickCoords, event);
|
|
if (symbol) {
|
|
this._geometry.setSymbol(symbol);
|
|
}
|
|
this._addGeometryToStage(this._geometry);
|
|
this._fireEvent('drawstart', event);
|
|
} else {
|
|
if (!(this._historyPointer === null)) {
|
|
this._clickCoords = this._clickCoords.slice(0, this._historyPointer);
|
|
}
|
|
this._clickCoords.push(coordinate);
|
|
this._historyPointer = this._clickCoords.length;
|
|
registerMode['update'](this._clickCoords, this._geometry, event);
|
|
this._fireEvent('drawvertex', event);
|
|
}
|
|
};
|
|
|
|
PlotDraw.prototype._mouseMoveHandler = function _mouseMoveHandler(event) {
|
|
var map = this.getMap();
|
|
if (!this._geometry || !map || map.isInteracting()) {
|
|
return;
|
|
}
|
|
var containerPoint = this._getMouseContainerPoint(event);
|
|
if (!this._isValidContainerPoint(containerPoint)) {
|
|
return;
|
|
}
|
|
var coordinate = event['coordinate'];
|
|
var registerMode = this._getRegisterMode();
|
|
var path = this._clickCoords.slice(0, this._historyPointer);
|
|
if (path && path.length > 0 && coordinate.equals(path[path.length - 1])) {
|
|
return;
|
|
}
|
|
registerMode['update'](path.concat([coordinate]), this._geometry, event);
|
|
this._fireEvent('mousemove', event);
|
|
};
|
|
|
|
PlotDraw.prototype._doubleClickHandler = function _doubleClickHandler(event) {
|
|
this.endDraw(event);
|
|
};
|
|
|
|
PlotDraw.prototype._getMouseContainerPoint = function _getMouseContainerPoint(event) {
|
|
var action = this._getRegisterMode()['action'];
|
|
if (action.indexOf('drag') > -1) {
|
|
stopPropagation(event['domEvent']);
|
|
}
|
|
return event['containerPoint'];
|
|
};
|
|
|
|
PlotDraw.prototype._isValidContainerPoint = function _isValidContainerPoint(containerPoint) {
|
|
var mapSize = this._map.getSize();
|
|
var w = mapSize['width'];
|
|
var h = mapSize['height'];
|
|
if (containerPoint.x < 0 || containerPoint.y < 0) {
|
|
return false;
|
|
} else if (containerPoint.x > w || containerPoint.y > h) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
PlotDraw.prototype._clearStage = function _clearStage() {
|
|
this._getDrawLayer(this.layerName).clear();
|
|
if (this._geometry) {
|
|
this._geometry.remove();
|
|
delete this._geometry;
|
|
}
|
|
delete this._clickCoords;
|
|
};
|
|
|
|
PlotDraw.prototype._addGeometryToStage = function _addGeometryToStage(geometry) {
|
|
this._getDrawLayer(this.layerName).addGeometry(geometry);
|
|
};
|
|
|
|
PlotDraw.prototype.setSymbol = function setSymbol(symbol) {
|
|
if (!symbol) {
|
|
return this;
|
|
}
|
|
this.options['symbol'] = symbol;
|
|
if (this._geometry) {
|
|
this._geometry.setSymbol(symbol);
|
|
}
|
|
return this;
|
|
};
|
|
|
|
PlotDraw.prototype.getSymbol = function getSymbol() {
|
|
var symbol = this.options['symbol'];
|
|
if (symbol) {
|
|
return maptalks.Util.extendSymbol(symbol);
|
|
} else {
|
|
return maptalks.Util.extendSymbol(this.options['symbol']);
|
|
}
|
|
};
|
|
|
|
PlotDraw.prototype._getDrawLayer = function _getDrawLayer(layerName) {
|
|
var drawToolLayer = this._map.getLayer(layerName);
|
|
if (!drawToolLayer) {
|
|
drawToolLayer = new maptalks.VectorLayer(layerName, {
|
|
'enableSimplify': false
|
|
});
|
|
this._map.addLayer(drawToolLayer);
|
|
}
|
|
return drawToolLayer;
|
|
};
|
|
|
|
PlotDraw.prototype._fireEvent = function _fireEvent(eventName) {
|
|
var param = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
if (this._geometry) {
|
|
param['geometry'] = this._getRegisterMode()['generate'](this._geometry).copy();
|
|
}
|
|
maptalks.MapTool.prototype._fireEvent.call(this, eventName, param);
|
|
};
|
|
|
|
PlotDraw.prototype.onAdd = function onAdd() {
|
|
this._getRegisterMode();
|
|
};
|
|
|
|
PlotDraw.prototype.onEnable = function onEnable() {
|
|
this._deactiveMapInteractions();
|
|
this.drawLayer = this._getDrawLayer(this.layerName);
|
|
this._clearStage();
|
|
this._loadResources();
|
|
return this;
|
|
};
|
|
|
|
PlotDraw.prototype.onDisable = function onDisable() {
|
|
var map = this.getMap();
|
|
this._activateMapInteractions();
|
|
this.endDraw();
|
|
if (this._map) {
|
|
map.removeLayer(this._getDrawLayer(this.layerName));
|
|
}
|
|
return this;
|
|
};
|
|
|
|
PlotDraw.prototype.endDraw = function endDraw() {
|
|
var param = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
if (!this._geometry || this._ending) {
|
|
return this;
|
|
}
|
|
this._ending = true;
|
|
var geometry = this._geometry;
|
|
this._clearStage();
|
|
this._geometry = geometry;
|
|
this._fireEvent('drawend', param);
|
|
delete this._geometry;
|
|
if (this.options['once']) {
|
|
this.disable();
|
|
}
|
|
delete this._ending;
|
|
return this;
|
|
};
|
|
|
|
PlotDraw.prototype._loadResources = function _loadResources() {
|
|
var symbol = this.getSymbol();
|
|
var resources = maptalks.Util.getExternalResources(symbol);
|
|
if (resources.length > 0) {
|
|
this.drawLayer._getRenderer().loadResources(resources);
|
|
}
|
|
};
|
|
|
|
PlotDraw.registerMode = function registerMode(name, modeAction) {
|
|
registeredMode[name.toLowerCase()] = modeAction;
|
|
};
|
|
|
|
PlotDraw.getRegisterMode = function getRegisterMode(name) {
|
|
return registeredMode[name.toLowerCase()];
|
|
};
|
|
|
|
PlotDraw.registeredModes = function registeredModes(modes) {
|
|
if (modes) {
|
|
for (var _iterator = Reflect.ownKeys(modes), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
|
|
var _ref;
|
|
|
|
if (_isArray) {
|
|
if (_i >= _iterator.length) break;
|
|
_ref = _iterator[_i++];
|
|
} else {
|
|
_i = _iterator.next();
|
|
if (_i.done) break;
|
|
_ref = _i.value;
|
|
}
|
|
|
|
var key = _ref;
|
|
|
|
if (!key.match(/^(?:constructor|prototype|arguments|caller|name|bind|call|apply|toString|length)$/)) {
|
|
var desc = Object.getOwnPropertyDescriptor(modes, key);
|
|
var _key = key.toLowerCase();
|
|
Object.defineProperty(registeredMode, _key, desc);
|
|
console.log(registeredMode);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
return PlotDraw;
|
|
}(maptalks.MapTool);
|
|
|
|
PlotDraw.registeredModes(RegisterModes);
|
|
|
|
exports.PlotDraw = PlotDraw;
|
|
exports.PlotTypes = PlotTypes;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|
|
//# sourceMappingURL=maptalks.plot.js.map
|