awv3/plugins/sketcher/handlers/drag.js

⚡ AWV3 embedded CAD

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _createClass from "@babel/runtime/helpers/createClass";
import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
import * as THREE from 'three';
import Object3 from '../../../three/object3';
import { updateCommand } from '../command/highlevel';
import { UpdateDimensions } from '../command/lowlevel';
import { move } from '../geomutils';
import HoverHandler from './hover';
import Ccref from '../ccref'; //minimal time between MUC solves (in milliseconds)
//note: 16ms delay is VERY SMALL

var MucDelayTime = 16.66;

var DragHandler =
/*#__PURE__*/
function (_HoverHandler) {
  _inheritsLoose(DragHandler, _HoverHandler);

  function DragHandler(sketcher, name) {
    var _this;

    _this = _HoverHandler.call(this, sketcher, name) || this; // allows to snap currently dragged object

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

  var _proto = DragHandler.prototype;

  _proto.filterObjectsWithInteraction = function filterObjectsWithInteraction(object) {
    return object.id !== this.sketch.id && object.graphics !== undefined;
  };

  _proto.startMuc =
  /*#__PURE__*/
  function () {
    var _startMuc = _asyncToGenerator(
    /*#__PURE__*/
    _regeneratorRuntime.mark(function _callee() {
      return _regeneratorRuntime.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 Promise(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);
    }));

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

  _proto[Object3.Events.Interaction.Clicked] = function (object, hitObject) {
    if (!hitObject.first) return;
    this.sketcher.selector.clicked(hitObject);
  };

  _proto[Object3.Events.Interaction.Missed] = function (object) {
    //called once per sketch object
    this.sketcher.constraintVisualizer.unhoverAll(); //if (this.sketcher.selector.selectedIds.length !== 0)    //perfo: avoid calling many times

    this.sketcher.selector.missed();
  };

  _proto[Object3.Events.Interaction.Picked] = function (object, hitObject) {
    if (!hitObject.first) return;
    this.sketcher.view.controls.enabled = false;
  };

  _proto[Object3.Events.Interaction.Dropped] =
  /*#__PURE__*/
  function () {
    var _ref = _asyncToGenerator(
    /*#__PURE__*/
    _regeneratorRuntime.mark(function _callee2(object, hitObject) {
      var _iterator, _isArray, _i, _ref2, _draggedObject2, encompassing, _iterator2, _isArray2, _i2, _ref3, _draggedObject3;

      return _regeneratorRuntime.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:
              _iterator = this.draggedObjects, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();

            case 9:
              if (!_isArray) {
                _context2.next = 15;
                break;
              }

              if (!(_i >= _iterator.length)) {
                _context2.next = 12;
                break;
              }

              return _context2.abrupt("break", 25);

            case 12:
              _ref2 = _iterator[_i++];
              _context2.next = 19;
              break;

            case 15:
              _i = _iterator.next();

              if (!_i.done) {
                _context2.next = 18;
                break;
              }

              return _context2.abrupt("break", 25);

            case 18:
              _ref2 = _i.value;

            case 19:
              _draggedObject2 = _ref2;
              encompassing = _draggedObject2.encompassing;
              this.sketcher.run(updateCommand(this.sketch, encompassing, encompassing.geomParams));
              this.sketcher.run(this.sketcher.autoconstraintCommands(_draggedObject2));

            case 23:
              _context2.next = 9;
              break;

            case 25:
              this.sketcher.incrementalSolveConstraints();
              this.sketcher.run(UpdateDimensions(this.sketch)); // clear possibly overriding transient geomParams after all updates

              _iterator2 = this.draggedObjects, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();

            case 28:
              if (!_isArray2) {
                _context2.next = 34;
                break;
              }

              if (!(_i2 >= _iterator2.length)) {
                _context2.next = 31;
                break;
              }

              return _context2.abrupt("break", 42);

            case 31:
              _ref3 = _iterator2[_i2++];
              _context2.next = 38;
              break;

            case 34:
              _i2 = _iterator2.next();

              if (!_i2.done) {
                _context2.next = 37;
                break;
              }

              return _context2.abrupt("break", 42);

            case 37:
              _ref3 = _i2.value;

            case 38:
              _draggedObject3 = _ref3;
              _draggedObject3.encompassing.geomParams = undefined;

            case 40:
              _context2.next = 28;
              break;

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

            case 44:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, this);
    }));

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

  _proto[Object3.Events.Interaction.Dragged] = function (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, 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) {
      var hasConstraint = false;
      var tree = this.sketcher.tree;

      for (var key in tree) {
        if (tree.hasOwnProperty(key) && typeof tree[key] === 'object') {
          if (hasConstraint = new Ccref(this.sketcher, key).isConstraint()) break;
        }
      }

      if (hasConstraint) {
        if (!this.mucPromise) this.startMuc();
        return;
      }
    }

    var displacement = this.displacement;

    for (var _iterator3 = this.draggedObjects, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
      var _ref4;

      if (_isArray3) {
        if (_i3 >= _iterator3.length) break;
        _ref4 = _iterator3[_i3++];
      } else {
        _i3 = _iterator3.next();
        if (_i3.done) break;
        _ref4 = _i3.value;
      }

      var _draggedObject4 = _ref4;
      var encompassing = _draggedObject4.encompassing; // override geomParams from the state by transient geomParams

      encompassing.geomParams = move(encompassing.geomParams, _draggedObject4 === encompassing ? '' : _draggedObject4.pointType, displacement);
      encompassing.updateGraphicsRecursive();
    }

    this.dragFrom.copy(this.dragTo);
  };

  _createClass(DragHandler, [{
    key: "displacement",
    get: function get() {
      return this.dragTo.clone().sub(this.draggedPoint ? this.draggedPoint.geomParams.start : this.dragFrom);
    }
  }]);

  return DragHandler;
}(HoverHandler);

export { DragHandler as default };