@antv/l7-draw/lib/draw_control.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DrawControl = void 0;

var _l = require("@antv/l7");

require("./css/draw.css");

var _modes = require("./modes");

var _helpers = require("@turf/helpers");

var _constant = require("./util/constant");

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

var DrawType = {
  point: _modes.DrawPoint,
  line: _modes.DrawLine,
  polygon: _modes.DrawPolygon,
  circle: _modes.DrawCircle,
  rect: _modes.DrawRect
};

var DrawControl = /*#__PURE__*/function (_Control) {
  _inherits(DrawControl, _Control);

  var _super = _createSuper(DrawControl);

  function DrawControl(scene, options) {
    var _this;

    _classCallCheck(this, DrawControl);

    _this = _super.call(this, options);
    _this.draw = {};

    _this.onButtonClick = function (type, e) {
      for (var draw in _this.draw) {
        if (draw === type) {
          _this.draw[draw].enable();
        } else {
          _this.draw[draw].disable();
        }
      }
    };

    _this.onDeleteMode = function (type, e) {
      e.stopPropagation();

      if (!_this.currentDraw) {
        return;
      }

      _this.currentDraw.deleteMode.enable();

      return false;
    };

    _this.onModeChange = function (type, mode) {
      if (mode === _constant.DrawModes.SIMPLE_SELECT) {
        _this.currentDraw = _this.draw[type];
      }
    };

    _this.scene = scene;
    return _this;
  }

  _createClass(DrawControl, [{
    key: "getDefault",
    value: function getDefault() {
      return {
        position: _l.PositionType.TOPLEFT,
        controls: {
          point: true,
          line: true,
          polygon: true,
          rect: true,
          circle: true,
          delete: true
        },
        name: 'draw'
      };
    }
  }, {
    key: "onAdd",
    value: function onAdd() {
      var layout = this.controlOption.layout;
      var controlClass = 'l7-control-draw' + ' ' + layout;
      var controls = this.controlOption.controls;

      var container = _l.DOM.create('div', controlClass);

      this.addControls(controls, container); // 代理每个绘制组件的事件

      this.addControlEvent(); // 监听组件 选中, 编辑

      return container;
    }
  }, {
    key: "onRemove",
    value: function onRemove() {
      for (var draw in this.draw) {
        if (this.draw[draw]) {
          this.draw[draw].destroy();
        }
      }
    }
  }, {
    key: "getDraw",
    value: function getDraw(type) {
      var controls = this.controlOption.controls;

      if (controls[type]) {
        return this.draw[type];
      }

      return null;
    }
  }, {
    key: "getAllData",
    value: function getAllData() {
      var res = {};

      for (var draw in this.draw) {
        if (this.draw[draw]) {
          res[draw] = this.draw[draw].getData();
        }
      }

      return res;
    }
  }, {
    key: "removeAllData",
    value: function removeAllData() {
      for (var draw in this.draw) {
        if (this.draw[draw]) {
          this.draw[draw].removeAllData();
        }
      }
    }
  }, {
    key: "addControls",
    value: function addControls(controls, container) {
      var style = this.controlOption.style;

      for (var type in controls) {
        if (DrawType[type] && controls[type] !== false) {
          var drawOption = (0, _helpers.isObject)(controls[type]) ? controls[type] : {};

          if (style) {
            drawOption.style = style;
          }

          var draw = new DrawType[type](this.scene, drawOption);
          draw.on(_constant.DrawEvent.MODE_CHANGE, this.onModeChange.bind(null, type));
          this.draw[type] = draw;
          this.createButton(draw.title, 'draw-' + type, container, 'click', this.onButtonClick.bind(null, type));
        } else if (type === 'delete' && controls[type] !== false) {
          var _draw = new _modes.DrawDelete(this.scene);

          _draw.on(_constant.DrawEvent.MODE_CHANGE, this.onModeChange.bind(null, type));

          this.createButton(_draw.title, 'draw-' + type, container, 'mousedown', this.onDeleteMode.bind(null, type));
        }
      }
    }
  }, {
    key: "addControlEvent",
    value: function addControlEvent() {
      var _this2 = this;

      var _loop = function _loop(draw) {
        if (_this2.draw[draw]) {
          ['draw.create', 'draw.update', 'draw.delete'].forEach(function (type) {
            _this2.draw[draw].on(type, function (feature) {
              _this2.emit(type, {
                drawType: draw,
                feature: feature
              });
            });
          });
        }
      };

      for (var draw in this.draw) {
        _loop(draw);
      }
    }
  }, {
    key: "createButton",
    value: function createButton(tile, className, container, eventType, fn) {
      var link = _l.DOM.create('button', className, container);

      link.title = tile;
      link.addEventListener(eventType, fn, false);
      return link;
    }
  }]);

  return DrawControl;
}(_l.Control);

exports.DrawControl = DrawControl;