awv3/session/plugin.js

⚡ AWV3 embedded CAD

'use strict';

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

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 _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 _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');

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 = 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);

        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
        }, props)));

        if (feature) {
            Object.defineProperty(_this, "feature", { get: function get() {
                    return feature.id;
                } });
            Object.defineProperty(_this, "connection", { get: function get() {
                    return connection;
                } });
            _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.Object3D();
            _this.pool.updateParentMaterials = false;
            _this.pool.measurable = false;
            _this.pool.name = 'pool_' + _this.name + '_' + _this.type;
            _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;
            } });

        // 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();
                } else {
                    _this.onDisabled();
                }
            }
            !enabled && _this.removeSubscriptions();
        },
        // options
        { manager: undefined });
        return _this;
    }

    (0, _createClass3.default)(Plugin, [{
        key: 'addElement',
        value: function addElement(element) {
            this.store.dispatch(_plugins.actions.addElement(this.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 _this2 = this;

            this.store.dispatch(_elements.actions.unregister((0, _keys2.default)(this.session.elements).filter(function (id) {
                return _this2.session.elements[id].plugin === _this2.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.pool && this.pool.destroy();
            this.__enabledUnsubscribe();
            this.__enabled && this.onDisabled();
        }
    }]);
    return Plugin;
}((0, _lifecycle2.default)());

exports.default = Plugin;