awv3/plugins/sketcher/handlers/base.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _values = require('babel-runtime/core-js/object/values');

var _values2 = _interopRequireDefault(_values);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _object = require('../../../three/object3');

var _object2 = _interopRequireDefault(_object);

var _snapper = require('../snapper');

var _snapper2 = _interopRequireDefault(_snapper);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var BaseHandler = function () {
    function BaseHandler(sketcher, name) {
        (0, _classCallCheck3.default)(this, BaseHandler);

        this.sketcher = sketcher;
        this.sketch = sketcher.activeSketch;
        this.name = name;
        this.interactions = new _map2.default();
        this.addInteractions();
    }

    (0, _createClass3.default)(BaseHandler, [{
        key: 'destroy',
        value: function destroy(options) {
            this.removeInteractions(options);
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return false;
        }
    }, {
        key: 'addInteraction',
        value: function addInteraction(object, interactionListeners) {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)((0, _values2.default)(_object2.default.Events.Interaction)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var event = _step.value;

                    if (this[event]) interactionListeners[event] = this[event].bind(this, object);
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            object.graphics.createInteraction({ recursive: true, types: ['InfinitePlane', 'SketcherMesh'] }).on(interactionListeners);
            // prioritize sketch points in interaction if there is overlapping
            if (object.state.class === "CC_Point") object.graphics.interaction.priority = 1;
        }
    }, {
        key: 'addInteractions',
        value: function addInteractions() {
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = (0, _getIterator3.default)(this.sketch.descendants), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var object = _step2.value;

                    if (this.filterObjectsWithInteraction(object)) {
                        this.interactions.set(object, {});
                        this.addInteraction(object, this.interactions.get(object));
                    }
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }
        }
    }, {
        key: 'removeInteraction',
        value: function removeInteraction(object, interactionListeners) {
            var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
                _ref$interaction = _ref.interaction,
                interaction = _ref$interaction === undefined ? true : _ref$interaction;

            if (object.graphics) {
                object.graphics.removeListener(interactionListeners);
                if (interaction) object.graphics.removeInteraction();
            }
        }
    }, {
        key: 'removeInteractions',
        value: function removeInteractions(options) {
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = (0, _getIterator3.default)(this.interactions), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var _step3$value = (0, _slicedToArray3.default)(_step3.value, 2),
                        object = _step3$value[0],
                        interactionListeners = _step3$value[1];

                    this.removeInteraction(object, interactionListeners, options);
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }

            this.interactions.clear();
        }
    }, {
        key: 'createSnapper',
        value: function createSnapper() {
            return new _snapper2.default({
                sketch: this.sketch,
                gridStep: this.sketcher.gridStep,
                pointRadius: this.sketcher.graphicScale
            });
        }
    }, {
        key: 'consoleComplete',
        value: function consoleComplete(cmd) {
            return commands;
        }
    }, {
        key: 'consoleExecute',
        value: function consoleExecute(cmd, preview) {
            if (preview) return;
            if (commands.includes(cmd)) this.sketcher.namedElements.handlers[cmd].value = true;
        }
    }]);
    return BaseHandler;
}();

exports.default = BaseHandler;


var commands = ['point', 'line', 'arccenter', 'arccontrol', 'arcmiddle', 'arctangent', 'polyline', 'drag', 'delete'];