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

⚡ AWV3 embedded CAD

'use strict';

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

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

var _extends3 = _interopRequireDefault(_extends2);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

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

var _get3 = _interopRequireDefault(_get2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

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

var _inherits3 = _interopRequireDefault(_inherits2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

var _base2 = _interopRequireDefault(_base);

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

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

var _object2 = _interopRequireDefault(_object);

var _snapper = require('../snapper');

var _snapper2 = _interopRequireDefault(_snapper);

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 DuplicateHandler = function (_BaseHandler) {
    (0, _inherits3.default)(DuplicateHandler, _BaseHandler);
    (0, _createClass3.default)(DuplicateHandler, null, [{
        key: 'normalizeSelection',
        value: function normalizeSelection(selectedObjects) {
            return selectedObjects.filter(function (obj) {
                if (obj.isConstraint()) return false; //constraints need renaming, so they are copied on server
                if (!obj.parent.isSketch()) return false; //server does not expect subobjects (e.g. endpoints of a curve)
                return true;
            });
        }
    }]);

    function DuplicateHandler() {
        var _ref;

        (0, _classCallCheck3.default)(this, DuplicateHandler);

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

        var _this = (0, _possibleConstructorReturn3.default)(this, (_ref = DuplicateHandler.__proto__ || (0, _getPrototypeOf2.default)(DuplicateHandler)).call.apply(_ref, [this].concat(args)));

        _this.objects = [];
        _this.keyPos = new THREE.Vector3();
        _this.currentOffset = new THREE.Vector3();
        _this.previewHolder = new THREE.Object3D();
        _this.sketcher.pool.add(_this.previewHolder);
        _this.snapper = _this.createSnapper();
        return _this;
    }

    (0, _createClass3.default)(DuplicateHandler, [{
        key: 'init',
        value: function init(duplicatedObjects) {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)(duplicatedObjects), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var obj = _step.value;

                    var preview = new THREE.Object3D();
                    (0, _preview.updateGeomObjectContainer)(preview, (0, _extends3.default)({}, obj.geomParams, {
                        coordinateSystem: new THREE.Matrix4() //drop sketch transformation
                    }));
                    this.objects.push({ obj: obj, preview: preview });
                    this.previewHolder.add(preview);
                }
                //get bounding box in local sketch coordinates
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            var bbox = new THREE.Box3().setFromObject(this.previewHolder);
            this.keyPos = bbox.getCenter();
            this.snapper.setDraggedObjects(duplicatedObjects, this.keyPos);
            //update preview again, so that they get sketch transformation
            this.move(this.keyPos);
        }
    }, {
        key: 'onMouseMove',
        value: function onMouseMove() {
            this.move(this.getRecentMousePosition());
        }
    }, {
        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;

            this.onMouseMove();
            var offset = this.currentOffset;
            var objects = this.objects.map(function (v) {
                return v.obj;
            });
            this.sketcher.copyObjects(objects, offset).then(function () {
                //update set of sketch points in snapper
                _this2.snapper.sketchPoints = undefined;
            });
        }
    }, {
        key: 'destroy',
        value: function destroy(options) {
            this.previewHolder.destroy();
            (0, _get3.default)(DuplicateHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(DuplicateHandler.prototype), 'destroy', this).call(this, options);
        }
    }, {
        key: 'move',
        value: function move(point) {
            var snapOffset = this.snapper.snapDraggedObject(point).displacement;
            this.currentOffset = point.clone().add(snapOffset).sub(this.keyPos);
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = (0, _getIterator3.default)(this.objects), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var data = _step2.value;
                    var obj = data.obj,
                        preview = data.preview;

                    var params = obj.geomParams;
                    var _arr = ['start', 'end', 'center'];
                    for (var _i = 0; _i < _arr.length; _i++) {
                        name = _arr[_i];

                        if (params[name] instanceof THREE.Vector3) params[name].add(this.currentOffset);
                    }(0, _preview.updateGeomObjectContainer)(preview, (0, _extends3.default)({
                        coordinateSystem: this.sketch.matrixWorld,
                        scale: this.sketcher.graphicScale
                    }, params));
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            this.sketcher.refresh();
        }
    }]);
    return DuplicateHandler;
}(_base2.default);

exports.default = DuplicateHandler;