awv3/build/plugins/sketcher/handlers/draw.js

⚡ AWV3 embedded CAD

'use strict';

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

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _freeze = require('babel-runtime/core-js/object/freeze');

var _freeze2 = _interopRequireDefault(_freeze);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

var _object2 = _interopRequireDefault(_object);

var _ccfuturef = require('../ccfuturef');

var _ccfuturef2 = _interopRequireDefault(_ccfuturef);

var _ccref = require('../ccref');

var _ccref2 = _interopRequireDefault(_ccref);

var _highlevel = require('../command/highlevel');

var _lowlevel = require('../command/lowlevel');

var _type = require('../constraint/type');

var _geomutils = require('../geomutils');

var _preview = require('../preview');

var _base = require('./base');

var _base2 = _interopRequireDefault(_base);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

var Mode = (0, _freeze2.default)({ point: 'point', line: 'line', arccenter: 'arccenter', arcmiddle: 'arcmiddle', arctangent: 'arctangent', circle: 'circle' });

var DrawHandler = function (_BaseHandler) {
    (0, _inherits3.default)(DrawHandler, _BaseHandler);

    function DrawHandler(sketcher, name) {
        (0, _classCallCheck3.default)(this, DrawHandler);

        var _this = (0, _possibleConstructorReturn3.default)(this, (DrawHandler.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler)).call(this, sketcher, name));

        _this.endPoint = null; // ccref of the last point of the polyline
        _this.endTangent = null; // normalized THREE.Vector3() tangent of the last edge
        _this.positions = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
        _this.preview = new THREE.Group();
        _this.sketcher.pool.add(_this.preview);
        _this.queue = new PromiseQueue();
        _this.restrictions = {};
        _this.startPoint = null; // ccref of the first point of the polyline
        _this.state = 0; // number of element filled in this.positions
        _this.statesCount = 2; // number of states needed to create an edge
        return _this;
    }

    (0, _createClass3.default)(DrawHandler, [{
        key: 'destroy',
        value: function destroy() {
            this.preview.destroy();
            this.sketcher.setCursorCoordinates(undefined);
            (0, _get3.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'destroy', this).call(this);
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return object.id === this.sketch.id;
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            var _this2 = this;

            var ray = hitObject.ray.clone().applyMatrix4(new THREE.Matrix4().getInverse(this.sketch.matrixWorld));
            var position = ray.intersectPlane(new THREE.Plane(new THREE.Vector3(0, 0, 1)));
            return this.queue.run(function () {
                return _this2.afterEdgeAdded(_this2.click(position));
            });
        }
    }, {
        key: 'afterEdgeAdded',
        value: function () {
            var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(geomParams) {
                var object, manualConstrCommand, command, p, ccref;
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                if (geomParams) {
                                    _context.next = 2;
                                    break;
                                }

                                return _context.abrupt('return');

                            case 2:
                                object = new _ccfuturef2.default((0, _lowlevel.Variable)(), geomParams);

                                if (!(!object.isLine() && !object.isArc())) {
                                    _context.next = 6;
                                    break;
                                }

                                this.endPolyline();
                                return _context.abrupt('return', this.sketcher.run((0, _highlevel.addCommand)(this.sketch, geomParams)));

                            case 6:
                                manualConstrCommand = this.endPoint && !this.sketcher.autoconstraintIncremental ? (0, _highlevel.addCommand)(this.sketch, {
                                    class: _type.incidence.type,
                                    entities: [this.endPoint, object.startPoint],
                                    value: {}
                                }) : null;
                                command = _lowlevel.Sequence.apply(undefined, [(0, _lowlevel.Assign)(object, (0, _highlevel.addCommand)(this.sketch, geomParams))].concat((0, _toConsumableArray3.default)(this.sketcher.autoconstraintCommands(object)), (0, _toConsumableArray3.default)((0, _highlevel.restrictionCommands)(this.sketch, object, this.restrictions)), [manualConstrCommand, (0, _lowlevel.Return)((0, _lowlevel.IdToReal)(object))]));

                                this.restrictions = {};
                                p = this.sketcher.run(command);

                                this.sketcher.incrementalSolveConstraints();
                                _context.t0 = _ccref2.default;
                                _context.t1 = this.sketcher;
                                _context.next = 15;
                                return p;

                            case 15:
                                _context.t2 = _context.sent;
                                ccref = new _context.t0(_context.t1, _context.t2);

                                this.startPoint = this.startPoint || ccref.startPoint;
                                this.endPoint = ccref.endPoint || this.endPoint;
                                this.endTangent = (0, _geomutils.getTangent)(ccref.geomParams, this.endPoint.pos);
                                this.click(this.endPoint.pos);

                            case 21:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, this);
            }));

            function afterEdgeAdded(_x) {
                return _ref.apply(this, arguments);
            }

            return afterEdgeAdded;
        }()
    }, {
        key: 'cancel',
        value: function cancel() {
            if (this.state !== 0) this.endPolyline();else (0, _get3.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'cancel', this).call(this);
        }
    }, {
        key: 'endPolyline',
        value: function endPolyline() {
            this.endPoint = null;
            this.endTangent = null;
            this.restrictions = {};
            this.startPoint = null;
            this.state = 0;
            this.onMouseMove();
        }
    }, {
        key: 'closePolyline',
        value: function () {
            var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2() {
                var geomParams, object, command;
                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                if (!(!this.startPoint || !this.endPoint)) {
                                    _context2.next = 2;
                                    break;
                                }

                                return _context2.abrupt('return');

                            case 2:
                                geomParams = { start: this.startPoint.pos, end: this.endPoint.pos };
                                object = new _ccfuturef2.default((0, _lowlevel.Variable)(), geomParams);
                                command = (0, _lowlevel.Sequence)((0, _lowlevel.Assign)(object, (0, _highlevel.addCommand)(this.sketch, geomParams)), (0, _highlevel.addCommand)(this.sketch, { class: _type.incidence.type, entities: [this.endPoint, object.startPoint], value: {} }), (0, _highlevel.addCommand)(this.sketch, { class: _type.incidence.type, entities: [object.endPoint, this.startPoint], value: {} }));
                                _context2.next = 7;
                                return this.sketcher.run(command);

                            case 7:
                                this.endPolyline();

                            case 8:
                            case 'end':
                                return _context2.stop();
                        }
                    }
                }, _callee2, this);
            }));

            function closePolyline() {
                return _ref2.apply(this, arguments);
            }

            return closePolyline;
        }()
    }, {
        key: 'click',
        value: function click(position) {
            var doSnapping = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

            var geomParams = this.move(position, true, doSnapping);
            if (!this.handleClick(this.positions[this.state])) return;
            if (++this.state === this.statesCount) {
                this.state = 0;
                return geomParams;
            }
        }
    }, {
        key: 'getPreviewGeomParams',
        value: function getPreviewGeomParams() {
            if (this.state === 0) return (0, _geomutils.drawPointBy_S)(this.positions, this.restrictions);
            switch (this.name) {
                case Mode.point:
                    return (0, _geomutils.drawPointBy_S)(this.positions, this.restrictions);
                case Mode.line:
                    return (0, _geomutils.drawLineBy_S_E)(this.positions, this.restrictions);
                case Mode.arccenter:
                    return (0, _geomutils.drawArcBy_S_E_C)(this.positions, this.restrictions);
                case Mode.arcmiddle:
                    return (0, _geomutils.drawArcBy_S_E_M)(this.positions, this.restrictions);
                case Mode.arctangent:
                    return (0, _geomutils.drawArcBy_S_T_E)([this.positions[0], this.endTangent, this.positions[1]], this.restrictions);
                case Mode.circle:
                    return (0, _geomutils.drawCircleBy_C_E)(this.positions, this.restrictions);
            }
        }
    }, {
        key: 'move',
        value: function move(position, force) {
            var doSnapping = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

            if (!force && this.queue.isBusy()) return;
            if (doSnapping) position.copy(this.doSnapping(position));
            this.sketcher.setCursorCoordinates(position);
            for (var i = this.state; i < this.positions.length; ++i) {
                this.positions[i].copy(position);
            }var previewParams = this.getPreviewGeomParams();
            if (this.state === 0) this.positions[0].copy(previewParams.start);
            (0, _preview.updateGeomObjectContainer)(this.preview, (0, _extends3.default)({
                coordinateSystem: this.sketch.graphics.matrix,
                scale: this.sketcher.graphicScale
            }, previewParams));
            return previewParams;
        }
    }, {
        key: 'onMouseMove',
        value: function onMouseMove() {
            this.move(this.getRecentMousePosition());
            this.sketcher.refresh();
        }
    }, {
        key: 'switchMode',
        value: function switchMode(mode) {
            if (this.state > 1) this.state = 1;
            this.statesCount = mode === Mode.point ? 1 : mode === Mode.arccenter || mode === Mode.arcmiddle ? 3 : 2;
            // handler switching logic in handler/index.js expects mode to be stored in this.name
            this.name = mode;
        }
    }, {
        key: 'consoleComplete',
        value: function consoleComplete(cmd) {
            cmd = cmd.trim();
            var tokens = cmd === '' ? [] : cmd.split(/\s+/);
            var completions = (0, _get3.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'consoleComplete', this).call(this, cmd);
            if (completions.indexOf(cmd) !== -1) return completions;
            return [cmd].concat(this.name.startsWith('point') ? [cmd + ' ax', cmd + ' ay'] : this.name.startsWith('line') ? [cmd + ' l', cmd + ' a', cmd + ' x', cmd + ' y'] : this.name.startsWith('arc') ? [cmd + ' a', cmd + ' r', cmd + ' cw', cmd + ' ccw'] : [], completions);
        }
    }, {
        key: 'consoleExecute',
        value: function consoleExecute(cmd) {
            if ((0, _get3.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'consoleExecute', this).call(this, cmd)) return; // switch handlers
            if (cmd === 'cl') return this.closePolyline();else return this.afterEdgeAdded(this.click(this.getRecentMousePosition(), false));
        }
    }, {
        key: 'parseRestrictions',
        value: function parseRestrictions(cmd) {
            var tokens = cmd.trim().split(/\s+/);
            this.restrictions = {};
            while (tokens.length !== 0) {
                var name = tokens.shift();
                var value = Number.NaN;
                switch (name) {
                    case 'x':
                        name = 'xoffset';
                        value = Number(tokens.shift());
                        break;
                    case 'y':
                        name = 'yoffset';
                        value = Number(tokens.shift());
                        break;
                    case 'ax':
                        name = 'xabsolute';
                        value = Number(tokens.shift());
                        break;
                    case 'ay':
                        name = 'yabsolute';
                        value = Number(tokens.shift());
                        break;
                    case 'l':
                        name = 'length';
                        value = Number(tokens.shift());
                        break;
                    case 'a':
                        name = 'angle';
                        value = Math.PI / 180 * Number(tokens.shift());
                        break;
                    case 'r':
                        name = 'radius';
                        value = Number(tokens.shift());
                        break;
                    case 'cw':
                        name = 'clockwise';
                        value = true;
                        break;
                    case 'ccw':
                        name = 'clockwise';
                        value = false;
                        break;
                }
                if (!isFinite(value)) continue;
                this.restrictions[name] = value;
            }
            // update priview
            this.onMouseMove();
        }
    }, {
        key: 'doSnapping',
        value: function doSnapping(position) {
            if (this.preview.geomType === 'CC_Point') return this.createSnapper().snapPoint(position).position;
            if (this.preview.geomType === 'CC_Line') return this.createSnapper().snapPoint(position).position;
            if (this.preview.geomType === 'CC_Arc') return this.createSnapper().snapPoint(position).position;
            return position;
        }
    }, {
        key: 'handleClick',
        value: function handleClick(position) {
            if (!this.endTangent) {
                var variants = [];
                // for all lines/arcs on the sketch
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    for (var _iterator = (0, _getIterator3.default)(this.sketch.children), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var object = _step.value;

                        if (!object.isLine() && !object.isArc()) continue;
                        // for their endpoint matching position
                        var _arr = ['startPoint', 'endPoint'];
                        for (var _i = 0; _i < _arr.length; _i++) {
                            var end = _arr[_i];
                            if (!object[end].pos.equals(position)) continue;
                            var tangent = (0, _geomutils.getTangent)(object.geomParams, position);
                            if (tangent.lengthSq() === 0) continue;
                            if (end === 'startPoint') tangent.negate();
                            variants.push(tangent);
                        }
                    }
                    // deny click in arctangent mode if doesn't uniquely determine the tangent
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }

                if (this.name === 'arctangent' && variants.length !== 1) return false;
                this.endTangent = variants[0] || new THREE.Vector3();
                return true;
            }
            return true;
        }
    }]);
    return DrawHandler;
}(_base2.default);

exports.default = DrawHandler;

var PromiseQueue = function () {
    function PromiseQueue() {
        (0, _classCallCheck3.default)(this, PromiseQueue);

        this.nPending = 0;
        this.promise = _promise2.default.resolve();
    }

    (0, _createClass3.default)(PromiseQueue, [{
        key: 'run',
        value: function run(functor) {
            var _this3 = this;

            this.promise = function () {
                var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(promise) {
                    return _regenerator2.default.wrap(function _callee3$(_context3) {
                        while (1) {
                            switch (_context3.prev = _context3.next) {
                                case 0:
                                    ++_this3.nPending;
                                    _context3.next = 3;
                                    return promise;

                                case 3:
                                    _context3.next = 5;
                                    return functor();

                                case 5:
                                    --_this3.nPending;

                                case 6:
                                case 'end':
                                    return _context3.stop();
                            }
                        }
                    }, _callee3, _this3);
                }));

                return function (_x4) {
                    return _ref3.apply(this, arguments);
                };
            }()(this.promise);
            return this.promise;
        }
    }, {
        key: 'isBusy',
        value: function isBusy() {
            return this.nPending > 0;
        }
    }]);
    return PromiseQueue;
}();