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

⚡ AWV3 embedded CAD

'use strict';

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

var _freeze = require('babel-runtime/core-js/object/freeze');

var _freeze2 = _interopRequireDefault(_freeze);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _values = require('babel-runtime/core-js/object/values');

var _values2 = _interopRequireDefault(_values);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

var _object2 = _interopRequireDefault(_object);

var _ccref = require('../ccref');

var _ccref2 = _interopRequireDefault(_ccref);

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 BaseHandler = function () {
    function BaseHandler(sketcher, name) {
        var _this = this;

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

        this.sketcher = sketcher;
        this.sketch = sketcher.activeSketch;
        this.name = name;
        this.interactions = new _map2.default();
        this.destroyed = false;
        // bind this.on* to this and don't trigger event callbacks after destruction
        var onKeyUp = this.onKeyUp,
            onKeyDown = this.onKeyDown,
            onMouseMove = this.onMouseMove;
        this.onKeyUp = function (event) {
            return _this.destroyed || onKeyUp.call(_this, event);
        };
        this.onKeyDown = function (event) {
            return _this.destroyed || onKeyDown.call(_this, event);
        };
        if (this.onMouseMove) this.onMouseMove = function (event) {
            return _this.destroyed || onMouseMove.call(_this, event);
        };
    }

    (0, _createClass3.default)(BaseHandler, [{
        key: 'destroy',
        value: function destroy(options) {
            this.destroyed = true;
            this.removeInteractions(options);
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return false;
        }
    }, {
        key: 'addInteraction',
        value: function addInteraction(object) {
            if (!this.filterObjectsWithInteraction(object)) return;
            var interactionListeners = {};
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)((0, _values2.default)(_object2.default.Events.Interaction)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var event = _step.value;

                    if (this[event]) interactionListeners[event] = this[event].bind(this, object);
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            this.interactions.set(object.id, interactionListeners);
            object.graphics.createInteraction({ recursive: true, first: false, types: ['InfinitePlane', 'SketcherMesh'] }).on(interactionListeners, { sync: true });
            // prioritize sketch points in interaction if there is overlapping
            if (object.isPoint()) object.graphics.interaction.priority = 1;
        }
    }, {
        key: 'addInteractions',
        value: function addInteractions() {
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = (0, _getIterator3.default)(this.sketch.descendants), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var object = _step2.value;

                    this.addInteraction(object);
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            this.sketcher.view.input.on('keyup', this.onKeyUp);
            this.sketcher.view.input.on('keydown', this.onKeyDown);
            if (this.onMouseMove) this.sketcher.view.input.on('mousemove', this.onMouseMove);
        }
    }, {
        key: 'removeInteraction',
        value: function removeInteraction(object) {
            var interactionListeners = this.interactions.get(object.id);
            this.interactions.delete(object.id);
            if (object.graphics) {
                object.graphics.removeListener(interactionListeners);
                object.graphics.removeInteraction();
            }
        }
    }, {
        key: 'removeInteractions',
        value: function removeInteractions() {
            if (this.onMouseMove) this.sketcher.view.input.removeListener('mousemove', this.onMouseMove);
            this.sketcher.view.input.removeListener('keydown', this.onKeyDown);
            this.sketcher.view.input.removeListener('keyup', this.onKeyUp);
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

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

                    this.removeInteraction(new _ccref2.default(this.sketcher, id));
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }
        }
    }, {
        key: 'cancel',
        value: function cancel() {
            // switch to drag handler by default
            this.sketcher.namedElements.handlers.drag.value = true;
        }
    }, {
        key: 'onKeyUp',
        value: function onKeyUp(event) {
            switch (event.which) {
                case 27:
                    // escape
                    this.cancel();
                    break;
                case 46:
                    // delete
                    this.sketcher.deleteSelected({ onlyIfConsoleIsEmpty: true });
                    break;
            }
        }
    }, {
        key: 'onKeyDown',
        value: function onKeyDown(event) {}
    }, {
        key: 'createSnapper',
        value: function createSnapper() {
            return new _snapper2.default({
                sketch: this.sketch,
                gridStep: this.sketcher.gridStep,
                pointRadius: this.sketcher.graphicScale
            });
        }

        //note: can be called in (view.input.on + 'mousemove') callback
        //in order to get current sketch coordinates of the mouse

    }, {
        key: 'getRecentMousePosition',
        value: function getRecentMousePosition() {
            var mousemove = this.sketcher.view.input.recent.mousemove;
            var point2 = new THREE.Vector2(mousemove.offsetX, mousemove.offsetY);
            var line3 = this.sketcher.view.getViewLine3(point2);
            var ray = new THREE.Ray(line3.start, line3.end.sub(line3.start).normalize());
            ray.applyMatrix4(new THREE.Matrix4().getInverse(this.sketch.matrixWorld));
            var plane = new THREE.Plane(new THREE.Vector3(0, 0, 1));
            var result = new THREE.Vector3();
            ray.intersectPlane(plane, result);
            ray.direction.negate();
            ray.intersectPlane(plane, result);
            return result;
        }
    }, {
        key: 'consoleComplete',
        value: function consoleComplete(cmd) {
            return (0, _keys2.default)(commands);
        }
    }, {
        key: 'consoleExecute',
        value: function consoleExecute(cmd) {
            // watch out for cmd === '__proto__' which could access the prototype
            if (commands.hasOwnProperty(cmd)) {
                this.sketcher.namedElements.handlers[commands[cmd]].value = true;
                return true;
            } else {
                return false;
            }
        }
    }, {
        key: 'parseRestrictions',
        value: function parseRestrictions(cmd) {}
    }]);
    return BaseHandler;
}();

exports.default = BaseHandler;


var commands = (0, _freeze2.default)({
    point: 'point',
    pt: 'point',
    line: 'line',
    ln: 'line',
    arccenter: 'arccenter',
    ac: 'arccenter',
    arcmiddle: 'arcmiddle',
    am: 'arcmiddle',
    arctangent: 'arctangent',
    at: 'arctangent',
    circle: 'circle',
    cr: 'circle'
});