awv3/dist/session/plugin.js

⚡ AWV3 embedded CAD

'use strict';

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

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _keys2 = _interopRequireDefault(_keys);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _extends4 = _interopRequireDefault(_extends3);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

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 _class, _temp;

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _lifecycle = require('./lifecycle.js');

var _lifecycle2 = _interopRequireDefault(_lifecycle);

var _error = require('../core/error');

var _plugins = require('./store/plugins');

var _elements = require('./store/elements');

var _globals = require('./store/globals');

var _connections = require('./store/connections');

var _helpers = require('./helpers');

var _element = require('./element');

var _element2 = _interopRequireDefault(_element);

var _elements2 = require('./elements');

var _renderer = require('./renderer');

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 Plugin = (_temp = _class = function (_Lifecycle) {
    (0, _inherits3.default)(Plugin, _Lifecycle);

    function Plugin() {
        var session = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _error.halt)('plugin must be initialized with a session');
        var _ref = arguments[1];
        var feature = _ref.feature,
            connection = _ref.connection,
            pool = _ref.pool,
            props = (0, _objectWithoutProperties3.default)(_ref, ['feature', 'connection', 'pool']);
        (0, _classCallCheck3.default)(this, Plugin);

        // If a parent exists (which mean this is a linked plugin, invoked by a parent plugin)
        var _this = (0, _possibleConstructorReturn3.default)(this, (Plugin.__proto__ || (0, _getPrototypeOf2.default)(Plugin)).call(this, session, _plugins.actions, function (state) {
            return state.plugins[_this.id];
        }, (0, _extends4.default)({
            type: '',
            name: '',
            title: '',
            resources: {},
            icon: undefined,
            enabled: false,
            active: false,
            collapsed: true,
            closeable: true,
            parent: undefined,
            elements: [],
            feature: feature ? feature.id : false,
            connection: connection ? connection.id : undefined,
            managed: true
        }, props)));

        if (_this.parent) {
            var parentPlugin = _plugins.base.references[_this.parent];
            // And if the parent is a feature, it gets to store its own pool under the parent, while
            // it is allowed to pose as a feature plugin itself
            if (parentPlugin.feature) {
                feature = parentPlugin;
                connection = parentPlugin.connection;
                _this.pool = new THREE.Group();
                _this.pool.updateParentMaterials = false;
                _this.pool.measurable = false;
                _this.pool.name = 'plugin.linked_pool.' + _this.type + (_this.name ? '+' + _this.name : '');
                feature.pool.add(_this.pool);
            }
        }

        if (feature) {
            Object.defineProperty(_this, 'feature', { get: function get() {
                    return feature.id;
                } });
            Object.defineProperty(_this, 'connection', { get: function get() {
                    return connection;
                } });
            if (!_this.parent) {
                _this.pool = pool;
                _this.reset = new _elements2.Button(_this, { name: 'Reset', color: 'black', flex: 0 });
                _this.apply = new _elements2.Button(_this, { name: 'Apply', color: 'blue', flex: 0 });
                _this.addElement(new _elements2.Group(_this, {
                    index: 10000000,
                    children: [new _elements2.Divider(_this), new _elements2.Spacer(_this), new _elements2.Group(_this, {
                        format: _elements2.Group.Format.Rows,
                        flexDirection: 'row-reverse',
                        children: [_this.apply, new _elements2.Spacer(_this), _this.reset]
                    })]
                }));
            }
        } else {
            Object.defineProperty(_this, 'connection', {
                get: function get() {
                    return _connections.base.references[_this.session.globals.activeConnection];
                }
            });
            _this.pool = new THREE.Group();
            _this.pool.updateParentMaterials = false;
            _this.pool.measurable = false;
            _this.pool.name = 'plugin.pool.' + _this.type + (_this.name ? '+' + _this.name : '');
            _this.session.pool.temporary.add(_this.pool);
        }

        // this.tree refers to the connections tree
        Object.defineProperty(_this, 'tree', { get: function get() {
                return _this.connection.tree;
            } });
        Object.defineProperty(_this, 'root', { get: function get() {
                return _this.tree[_this.tree.root];
            } });
        Object.defineProperty(_this, 'view', { get: function get() {
                return _this.pool.view;
            } });

        // Internal observer for enabled state, gets cleared after destroy
        // The enabled flag has to be kept locally as the destroyed event can be dispatched
        // without calling destroy() directly, leaving the linked state empty
        _this.__enabled = _this.enabled;
        _this.__enabledUnsubscribe = _this.observe(
        // selector
        function (state) {
            return state.enabled;
        },
        // onChanged
        function (enabled, prev) {
            _this.__enabled = enabled;
            if (enabled !== prev) {
                if (enabled) {
                    _this.onEnabled();
                    if (_this.render) {
                        (0, _renderer.render)(_this, _this.render.bind(_this));
                    }
                } else {
                    _this.onDisabled();
                    if (_this.render) {
                        (0, _renderer.destroy)(_this.id);
                    }
                }
            }
            !enabled && _this.removeSubscriptions();
        },
        // options
        { manager: undefined });
        return _this;
    }

    (0, _createClass3.default)(Plugin, [{
        key: 'findElement',
        value: function findElement(condition) {
            var elements = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.elements;
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

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

                    var el = this.session.elements[key];
                    var test = el.plugin === this.id && condition(el);
                    if (test) {
                        return el.id;
                    } else if (el.children.length) {
                        return this.findElement(condition, el.children);
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: 'findElementClass',
        value: function findElementClass(condition) {
            return _elements.base.references[this.findElement(condition)];
        }
    }, {
        key: 'addElement',
        value: function addElement() {
            var _this2 = this;

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

            elements.forEach(function (element) {
                return _this2.store.dispatch(_plugins.actions.addElement(_this2.id, element instanceof _element2.default ? element.id : element));
            });
        }
    }, {
        key: 'removeElement',
        value: function removeElement(element) {
            this.store.dispatch(_plugins.actions.removeElement(this.id, element instanceof _element2.default ? element.id : element));
        }
    }, {
        key: 'destroyElements',
        value: function destroyElements() {
            var _this3 = this;

            this.store.dispatch(_elements.actions.unregister((0, _keys2.default)(this.session.elements).filter(function (id) {
                return _this3.session.elements[id].plugin === _this3.id;
            })));
        }
    }, {
        key: 'resetElements',
        value: function resetElements() {
            this.store.dispatch(_elements.actions.merge(this.dependencies.reduce(function (prev, obj) {
                return (0, _extends4.default)({}, prev, (0, _defineProperty3.default)({}, obj.id, obj.props));
            }, {})));
        }
    }, {
        key: 'createToolbar',
        value: function createToolbar(keys, cb) {
            var columns = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 7;

            var children = [];
            for (var count = 0; count < keys.length / columns; count++) {
                children.push(new _elements2.Group(this, {
                    format: _elements2.Group.Format.Buttons,
                    margin: count == keys.length / columns - 1,
                    children: cb(keys.slice(count * columns, Math.min(count * columns + columns, keys.length)))
                }));
            }
            return new _elements2.Group(this, { children: children });
        }
    }, {
        key: 'onEnabled',
        value: function onEnabled() {}
    }, {
        key: 'onDisabled',
        value: function onDisabled() {}
    }, {
        key: '__onDestroyed',
        value: function __onDestroyed() {
            this.store.dispatch(_globals.actions.unlinkPlugins(this.id));
            if (this.connection) this.store.dispatch(_connections.actions.unlinkPlugins(this.connection.id, this.id));
            this.__enabledUnsubscribe();
            this.__enabled && this.onDisabled();
            this.pool && this.pool.destroy();
        }
    }]);
    return Plugin;
}((0, _lifecycle2.default)()), _class.persistent = false, _class.measurable = false, _temp);
exports.default = Plugin;