awv3/plugins/sketcher/handlers/drag.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _get4 = _interopRequireDefault(_get3);

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

var _inherits3 = _interopRequireDefault(_inherits2);

var _delay = require('delay');

var _delay2 = _interopRequireDefault(_delay);

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

var _object2 = _interopRequireDefault(_object);

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

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

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

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

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

var _hover2 = _interopRequireDefault(_hover);

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 sketch object currently being dragged
        _this.dragObject = undefined;
        //promise of the MUC task currently being solve on server
        _this.mucPromise = undefined;
        //array of snapped sketch coordinates of mouse during mousemove events
        //note: during dragging 0-th point is always present:
        //it is located at where the last processed movement finished
        _this.dragPositions = [];
        _this.sketcher.selector.activate(_this.sketcher.namedElements.selection);
        return _this;
    }

    (0, _createClass3.default)(DragHandler, [{
        key: 'destroy',
        value: function destroy() {
            var _get2;

            this.sketcher.selector.removeAll();
            this.sketcher.selector.deactivate();

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

            (_get2 = (0, _get4.default)(DragHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DragHandler.prototype), 'destroy', this)).call.apply(_get2, [this].concat(args));
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return object !== this.sketch && object.graphics !== undefined;
        }
    }, {
        key: 'startMuc',
        value: function startMuc() {
            var _this2 = this;

            //check that there was at least one mousemove after the last MUC request
            if (this.dragPositions.length <= 1) return;

            //look at start/end points of saved drag sequence
            var dragFrom = this.dragPositions[0];
            var dragTo = this.dragPositions[this.dragPositions.length - 1];
            //reset drag sequence
            this.dragPositions = this.dragPositions.slice(-1);

            //calculate object move vector for MUC
            var displacement = void 0;
            if (this.dragObject.state.class === "CC_Point") displacement = dragTo.clone().sub(this.dragObject.pos);else displacement = dragTo.clone().sub(dragFrom);

            //avoid doing trivial MUC requests
            if (displacement.length() === 0.0) return;

            //start solving MUC problem on server
            this.mucPromise = this.sketcher.moveUnderConstraints(this.dragObject, displacement);
            this.mucPromise = this.mucPromise.then((0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return (0, _delay2.default)(MucDelayTime);

                            case 2:

                                //forget this MUC request (no MUC in progress)
                                _this2.mucPromise = undefined;
                                //start new MUC request (note: no wait here)
                                _this2.startMuc();

                            case 4:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, _this2);
            })));
        }

        //in order to make sure that drag is finished, write:
        //  await handler.waitMuc();

    }, {
        key: 'waitMuc',
        value: function waitMuc() {
            return this.mucPromise; // && Promise.resolve();
        }
    }, {
        key: _object2.default.Events.Interaction.Hovered,
        value: function value(object, hitObject) {
            this.sketcher.selector.hover(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Unhovered,
        value: function value(object, hitObject) {
            this.sketcher.selector.unhover(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            this.sketcher.selector.clicked(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Missed,
        value: function value(object, hitObject) {
            this.sketcher.selector.missed(hitObject);
        }
    }, {
        key: _object2.default.Events.Interaction.Picked,
        value: function value(object, hitObject) {
            this.sketcher.view.controls.enabled = false; //do not update camera when dragging
        }
    }, {
        key: _object2.default.Events.Interaction.Dropped,
        value: function () {
            var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(object, hitObject) {
                var encompassing;
                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                this.sketcher.view.controls.enabled = true;

                                if (this.dragObject) {
                                    _context2.next = 3;
                                    break;
                                }

                                return _context2.abrupt('return');

                            case 3:
                                this.snapper = undefined;

                                //finish MUC in progress (if present)
                                _context2.next = 6;
                                return this.waitMuc();

                            case 6:
                                this.dragPositions = [];
                                this.dragObject = undefined;

                                encompassing = object.encompassing;

                                this.sketcher.run((0, _highlevel.updateCommand)(this.sketch, encompassing, encompassing.geomParams));
                                this.sketcher.run(this.sketcher.autoconstraintCommands(object));
                                this.sketcher.incrementalSolveConstraints();
                                this.sketcher.run((0, _lowlevel.UpdateDimensions)(this.sketch));

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

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

            return value;
        }()
    }, {
        key: _object2.default.Events.Interaction.Dragged,
        value: function value(object, hitObject) {
            var sketchCoords = (0, _viewutils.calcSketchPos)(hitObject.ray, this.sketch);
            if (!this.dragObject) {
                this.snapper = this.createSnapper();
                this.snapper.setDraggedObject(object, sketchCoords);
                this.dragObject = object;
                this.dragPositions = [sketchCoords.clone()];
                return;
            }
            var snapOffset = this.snapper.snapDraggedObject(sketchCoords).displacement;
            var position = sketchCoords.clone().add(snapOffset);

            this.dragPositions.push(position.clone());
            if (this.sketcher.solveIncremental) {
                if (!this.mucPromise) this.startMuc();
            } else {
                //TODO: refactor this as a special case of startMuc?
                var dragFrom = this.dragPositions[0];
                this.dragPositions = [position];
                var displacement = position.clone().sub(object.isPoint() ? object.geomParams.start : dragFrom);
                var encompassing = object.encompassing;
                encompassing.geomParams = (0, _geomutils.move)(encompassing.geomParams, object === encompassing ? '' : object.pointType(), displacement);
                encompassing.updateGraphicsRecursive();
            }
        }
    }]);
    return DragHandler;
}(_hover2.default);

exports.default = DragHandler;