awv3/dist/plugins/sketcher/handlers/drag.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _promise2 = _interopRequireDefault(_promise);

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

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

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

var _hover = require('./hover');

var _hover2 = _interopRequireDefault(_hover);

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

//minimal time between MUC solves (in milliseconds)
//note: 16ms delay is VERY SMALL
var MucDelayTime = 16.66;

var DragHandler = function (_HoverHandler) {
    (0, _inherits3.default)(DragHandler, _HoverHandler);

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

        // allows to snap currently dragged object
        var _this = (0, _possibleConstructorReturn3.default)(this, (DragHandler.__proto__ || (0, _getPrototypeOf2.default)(DragHandler)).call(this, sketcher, name));

        _this.snapper = undefined;
        // the point that should follow the mouse position or undefined
        _this.draggedPoint = undefined;
        // the sketch objects currently being dragged
        _this.draggedObjects = [];
        // promise of the MUC task currently being solve on server
        _this.mucPromise = undefined;
        // position where last processed movement finished
        _this.dragFrom = new THREE.Vector3();
        // target drag position
        _this.dragTo = new THREE.Vector3();
        return _this;
    }

    (0, _createClass3.default)(DragHandler, [{
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return object.id !== this.sketch.id && object.graphics !== undefined;
        }
    }, {
        key: 'startMuc',
        value: function () {
            var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                if (this.dragTo.equals(this.dragFrom)) {
                                    _context.next = 10;
                                    break;
                                }

                                this.mucPromise = this.sketcher.moveUnderConstraints(this.draggedObjects, this.displacement);

                                this.dragFrom.copy(this.dragTo);

                                _context.next = 5;
                                return this.mucPromise;

                            case 5:
                                _context.next = 7;
                                return new _promise2.default(function (resolve) {
                                    return setTimeout(resolve, MucDelayTime);
                                });

                            case 7:
                                // forget this MUC request (no MUC in progress)
                                this.mucPromise = undefined;
                                _context.next = 0;
                                break;

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

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

            return startMuc;
        }()
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            if (!hitObject.first) return;
            this.sketcher.selector.clicked(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Missed,
        value: function value(object, hitObject) {
            this.sketcher.constraintVisualizer.unhoverAll();
            this.sketcher.selector.missed(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Picked,
        value: function value(object, hitObject) {
            if (!hitObject.first) return;
            this.sketcher.view.controls.enabled = false;
        }
    }, {
        key: _object2.default.Events.Interaction.Dropped,
        value: function () {
            var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(object, hitObject) {
                var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, draggedObject, encompassing, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _draggedObject;

                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                if (hitObject.first) {
                                    _context2.next = 2;
                                    break;
                                }

                                return _context2.abrupt('return');

                            case 2:
                                this.sketcher.view.controls.enabled = true;

                                if (this.draggedObjects.length) {
                                    _context2.next = 5;
                                    break;
                                }

                                return _context2.abrupt('return');

                            case 5:

                                // finish MUC in progress (if present)
                                this.dragTo.copy(this.dragFrom);
                                _context2.next = 8;
                                return this.mucPromise;

                            case 8:

                                // update object positions on the server
                                _iteratorNormalCompletion = true;
                                _didIteratorError = false;
                                _iteratorError = undefined;
                                _context2.prev = 11;
                                for (_iterator = (0, _getIterator3.default)(this.draggedObjects); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                                    draggedObject = _step.value;
                                    encompassing = draggedObject.encompassing;

                                    this.sketcher.run((0, _highlevel.updateCommand)(this.sketch, encompassing, encompassing.geomParams));
                                    this.sketcher.run(this.sketcher.autoconstraintCommands(draggedObject));
                                }
                                _context2.next = 19;
                                break;

                            case 15:
                                _context2.prev = 15;
                                _context2.t0 = _context2['catch'](11);
                                _didIteratorError = true;
                                _iteratorError = _context2.t0;

                            case 19:
                                _context2.prev = 19;
                                _context2.prev = 20;

                                if (!_iteratorNormalCompletion && _iterator.return) {
                                    _iterator.return();
                                }

                            case 22:
                                _context2.prev = 22;

                                if (!_didIteratorError) {
                                    _context2.next = 25;
                                    break;
                                }

                                throw _iteratorError;

                            case 25:
                                return _context2.finish(22);

                            case 26:
                                return _context2.finish(19);

                            case 27:
                                this.sketcher.incrementalSolveConstraints();
                                this.sketcher.run((0, _lowlevel.UpdateDimensions)(this.sketch));

                                // clear possibly overriding transient geomParams after all updates
                                _iteratorNormalCompletion2 = true;
                                _didIteratorError2 = false;
                                _iteratorError2 = undefined;
                                _context2.prev = 32;
                                for (_iterator2 = (0, _getIterator3.default)(this.draggedObjects); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                    _draggedObject = _step2.value;

                                    _draggedObject.encompassing.geomParams = undefined;
                                }_context2.next = 40;
                                break;

                            case 36:
                                _context2.prev = 36;
                                _context2.t1 = _context2['catch'](32);
                                _didIteratorError2 = true;
                                _iteratorError2 = _context2.t1;

                            case 40:
                                _context2.prev = 40;
                                _context2.prev = 41;

                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                    _iterator2.return();
                                }

                            case 43:
                                _context2.prev = 43;

                                if (!_didIteratorError2) {
                                    _context2.next = 46;
                                    break;
                                }

                                throw _iteratorError2;

                            case 46:
                                return _context2.finish(43);

                            case 47:
                                return _context2.finish(40);

                            case 48:
                                this.draggedObjects = [];
                                this.snapper = undefined;

                            case 50:
                            case 'end':
                                return _context2.stop();
                        }
                    }
                }, _callee2, this, [[11, 15, 19, 27], [20,, 22, 26], [32, 36, 40, 48], [41,, 43, 47]]);
            }));

            function value(_x, _x2) {
                return _ref2.apply(this, arguments);
            }

            return value;
        }()
    }, {
        key: _object2.default.Events.Interaction.Dragged,
        value: function value(object, hitObject) {
            var _this2 = this;

            if (!hitObject.first) return;
            this.dragTo.copy(this.getRecentMousePosition());
            if (!this.draggedObjects.length) {
                var _draggedObjects;

                // dragged objects are this object and all selected objects
                // avoid double dragging when e.g. this object is selected or both object and its child are selected
                var objects = this.sketcher.getSelected();
                if (!objects.some(function (o) {
                    return o.id === object.id;
                })) objects.push(object);
                this.draggedObjects = objects.filter(function (o) {
                    return o === o.encompassing;
                });
                (_draggedObjects = this.draggedObjects).push.apply(_draggedObjects, (0, _toConsumableArray3.default)(objects.filter(function (o) {
                    var e = o.encompassing;
                    return !_this2.draggedObjects.some(function (oo) {
                        return oo.id === e.id;
                    });
                })));
                this.draggedPoint = object.isPoint() ? object : undefined;
                this.dragFrom.copy(this.dragTo);
                this.snapper = this.createSnapper();
                this.snapper.setDraggedObjects(this.draggedObjects, this.dragFrom, object);
                this.snapper.ignoreObject(this.draggedObjects);
                return;
            }

            this.dragTo.add(this.snapper.snapDraggedObject(this.dragTo).displacement);

            if (this.sketcher.solveIncremental) {
                if (!this.mucPromise) this.startMuc();
                return;
            }
            var displacement = this.displacement;
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = (0, _getIterator3.default)(this.draggedObjects), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var draggedObject = _step3.value;

                    var encompassing = draggedObject.encompassing;
                    // override geomParams from the state by transient geomParams
                    encompassing.geomParams = (0, _geomutils.move)(encompassing.geomParams, draggedObject === encompassing ? '' : draggedObject.pointType, displacement);
                    encompassing.updateGraphicsRecursive();
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }

            this.dragFrom.copy(this.dragTo);
        }
    }, {
        key: 'displacement',
        get: function get() {
            return this.dragTo.clone().sub(this.draggedPoint ? this.draggedPoint.geomParams.start : this.dragFrom);
        }
    }]);
    return DragHandler;
}(_hover2.default);

exports.default = DragHandler;