awv3/plugins/sketcher/handlers/draw.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _promise2 = _interopRequireDefault(_promise);

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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

var _extends3 = _interopRequireDefault(_extends2);

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 _get4 = require('babel-runtime/helpers/get');

var _get5 = _interopRequireDefault(_get4);

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

var _inherits3 = _interopRequireDefault(_inherits2);

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 _highlevel = require('../command/highlevel');

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

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

var _viewutils = require('../viewutils');

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 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.queue = new PromiseQueue();
        _this.preview = new THREE.Object3D();
        _this.sketcher.pool.add(_this.preview);
        _this.clicksPos = [];
        return _this;
    }

    (0, _createClass3.default)(DrawHandler, [{
        key: 'destroy',
        value: function destroy() {
            this.clicksPos = [];
            this.preview.destroy();
            this.sketcher.setCursorCoordinates(undefined);
            (0, _get5.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'destroy', this).call(this);
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return object === this.sketch;
        }
    }, {
        key: 'addInteraction',
        value: function addInteraction() {
            var _get2,
                _this2 = this;

            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }

            (_get2 = (0, _get5.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'addInteraction', this)).call.apply(_get2, [this].concat(args));
            this.onMouseMove = function (event) {
                var mousemove = _this2.sketcher.view.input.recent.mousemove;
                var point2 = new THREE.Vector2(mousemove.offsetX, mousemove.offsetY);
                var line3 = _this2.sketcher.view.getViewLine3(point2);
                var worldToLocal = new THREE.Matrix4().getInverse(_this2.sketch.getMatrixWorld());
                line3.applyMatrix4(worldToLocal);
                var param = (0 - line3.start.z) / (line3.end.z - line3.start.z);
                var sketchPoint = line3.at(param);
                sketchPoint.z = 0;
                _this2.move(sketchPoint);
                _this2.sketcher.refresh();
            };
            this.sketcher.view.input.on('mousemove', this.onMouseMove);
        }
    }, {
        key: 'removeInteraction',
        value: function removeInteraction() {
            var _get3;

            this.sketcher.view.input.removeListener('mousemove', this.onMouseMove);

            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                args[_key2] = arguments[_key2];
            }

            (_get3 = (0, _get5.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'removeInteraction', this)).call.apply(_get3, [this].concat(args));
        }
    }, {
        key: 'move',
        value: function move(position, force) {
            var doSnapping = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

            //check queue contains any unprocessed actions
            if (!force && this.queue.isBusy()) return;

            //perform all sort of snapping
            if (doSnapping) position.copy(this.doSnapping(position));

            this.sketcher.setCursorCoordinates(position);

            //update preview geometry
            var clickPositions = this.clicksPos.slice();
            if (position !== undefined) clickPositions.push(position);
            var previewParams = this.getPreviewGeomParams(clickPositions);
            (0, _preview.updateGeomObjectContainer)(this.preview, (0, _extends3.default)({ coordinateSystem: this.sketch.graphics.matrix, scale: this.sketcher.graphicScale }, previewParams));
        }
    }, {
        key: 'click',
        value: function click(position) {
            var doSnapping = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

            this.move(position, true, doSnapping); // update preview

            //check if a click is allowed and notify about it
            if (!this.handleClick(position)) return;

            //save point, change state
            this.clicksPos.push(position);

            if (this.clicksPos.length === this.statesCount) {
                var geomParams = this.getPreviewGeomParams(this.clicksPos);
                this.clicksPos = [];
                return geomParams;
            } else {
                this.move(undefined, true, false); // update preview
            }
        }
    }, {
        key: 'afterEdgeAdded',
        value: function afterEdgeAdded(geomParams) {
            var _this3 = this;

            if (!geomParams) return;
            var object = new _ccfuturef2.default((0, _lowlevel.Variable)(), geomParams);
            var command = _lowlevel.Sequence.apply(undefined, [(0, _lowlevel.Assign)(object, (0, _highlevel.addCommand)(this.sketch, geomParams))].concat((0, _toConsumableArray3.default)(this.sketcher.autoconstraintCommands(object))));
            var p = this.sketcher.run(command);
            this.sketcher.incrementalSolveConstraints();
            return p.then(function () {
                return _this3.move(undefined, true, false);
            }); // update preview
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            var _this4 = this;

            var position = (0, _viewutils.calcSketchPos)(hitObject.ray, this.sketch);
            //note: all clicks are enqueued into a promise
            return this.queue.run(function () {
                return _this4.afterEdgeAdded(_this4.click(position));
            });
        }
    }, {
        key: 'isClickDuplicate',
        value: function isClickDuplicate(position) {
            return this.clicksPos.some(function (click) {
                return click.equals(position);
            });
        }
    }, {
        key: 'consoleComplete',
        value: function consoleComplete(cmd) {
            var tokens = cmd.trim().split(/\s+/);

            var _tokens = (0, _slicedToArray3.default)(tokens, 4),
                c0 = _tokens[0],
                n0 = _tokens[1],
                c1 = _tokens[2],
                n1 = _tokens[3];

            var cn0 = isFinite(parseFloat(c0)) ? c0 : "0";
            n0 = isFinite(parseFloat(n0)) ? n0 : "0";
            n1 = isFinite(parseFloat(n1)) ? n1 : "0";
            return [cn0 + ' ' + n0, 'x ' + n0, 'x ' + n0 + ' y ' + n1, 'x ' + n0 + ' a ' + n1, 'y ' + n0, 'y ' + n0 + ' x ' + n1, 'y ' + n0 + ' a ' + n1, 'l ' + n0 + ' a ' + n1].concat((0, _get5.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'consoleComplete', this).call(this, cmd));
        }
    }, {
        key: 'consoleExec',
        value: function consoleExec(cmd, preview) {
            var _this5 = this;

            var tokens = cmd.trim().split(/\s+/);

            var _tokens2 = (0, _slicedToArray3.default)(tokens, 4),
                c0 = _tokens2[0],
                n0 = _tokens2[1],
                c1 = _tokens2[2],
                n1 = _tokens2[3];

            var _ref = [parseFloat(n0), parseFloat(n1)];
            n0 = _ref[0];
            n1 = _ref[1];

            var forbidRelative = this.clicksPos.length === 0;

            var _ref2 = this.clicksPos[this.clicksPos.length - 1] || new THREE.Vector3(),
                x = _ref2.x,
                y = _ref2.y;

            var setPoint = function setPoint(x, y) {
                var pos = new THREE.Vector3(x, y, 0);
                if (preview) return _this5.move(pos, false, false);else return _this5.click(pos, false);
            };

            if (tokens.length === 2 && isFinite(parseFloat(c0)) && isFinite(n0)) {
                // absolute coordinates: 1 2
                return setPoint(parseFloat(c0), n0);
            } else if (!forbidRelative) {
                if (c0 === 'x' && isFinite(n0)) {
                    if (tokens.length === 4 && c1 === 'a' && isFinite(n1)) // x offset and an angle: x 1 a 2
                        return setPoint(x + n0, y + n0 * Math.tan(n1 * Math.PI / 180));else if (tokens.length === 4 && c1 === 'y' && isFinite(n1)) // relative coordinates: x 1 y 2
                        return setPoint(x + n0, y + n1);else if (tokens.length === 2) // x offset: x 1
                        return setPoint(x + n0, y);
                } else if (c0 === 'y' && isFinite(n0)) {
                    if (tokens.length === 4 && c1 === 'a' && isFinite(n1)) // y offset and an angle: y 1 a 2
                        return setPoint(x + n0 / Math.tan(n1 * Math.PI / 180), y + n0);else if (tokens.length === 4 && c1 === 'x' && isFinite(n1)) // relative coordinates: y 2 x 1
                        return setPoint(x + n1, y + n0);else if (tokens.length === 2) // y offset: y 1
                        return setPoint(x, y + n0);
                } else if (c0 === 'l' && isFinite(n0)) {
                    if (tokens.length === 4 && c1 === 'a' && isFinite(n1)) // length and an angle: l 1 a 2
                        return setPoint(x + n0 * Math.cos(n1 * Math.PI / 180), y + n0 * Math.sin(n1 * Math.PI / 180));
                }
            }
            //reset preview without point-under-cursor
            this.move(undefined, false, false);

            return (0, _get5.default)(DrawHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DrawHandler.prototype), 'consoleExecute', this).call(this, cmd, preview);
        }
    }, {
        key: 'consoleExecute',
        value: function () {
            var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(cmd, preview) {
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return this.afterEdgeAdded(this.consoleExec(cmd, preview));

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

            function consoleExecute(_x3, _x4) {
                return _ref3.apply(this, arguments);
            }

            return consoleExecute;
        }()

        //default: snap to everything except preview

    }, {
        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;
        }

        //default: do nothing, allow all clicks

    }, {
        key: 'handleClick',
        value: function handleClick(position) {
            return !this.isClickDuplicate(position);
        }
    }]);
    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 _this6 = this;

            this.promise = function () {
                var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(promise) {
                    return _regenerator2.default.wrap(function _callee2$(_context2) {
                        while (1) {
                            switch (_context2.prev = _context2.next) {
                                case 0:
                                    ++_this6.nPending;
                                    _context2.next = 3;
                                    return promise;

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

                                case 5:
                                    --_this6.nPending;

                                case 6:
                                case 'end':
                                    return _context2.stop();
                            }
                        }
                    }, _callee2, _this6);
                }));

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