awv3/dist/plugins/dimensions/index.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 _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

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 _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 _dec, _class, _dec2, _class2;

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _plugin = require('../../session/plugin');

var _plugin2 = _interopRequireDefault(_plugin);

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

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

var _renderer2 = _interopRequireDefault(_renderer);

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

var _hud = require('../../core/hud');

var _hud2 = _interopRequireDefault(_hud);

var _graphics = require('./graphics');

var _graphics2 = _interopRequireDefault(_graphics);

var _handle = require('./handle');

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 Dimension = (_dec = (0, _renderer.connect)(function (state, _ref) {
    var connection = _ref.connection,
        key = _ref.key;
    return {
        day: state.globals.day,
        dimension: state.connections[connection] && state.connections[connection].tree[key]
    };
}), _dec(_class = function (_Component) {
    (0, _inherits3.default)(Dimension, _Component);

    function Dimension() {
        (0, _classCallCheck3.default)(this, Dimension);
        return (0, _possibleConstructorReturn3.default)(this, (Dimension.__proto__ || (0, _getPrototypeOf2.default)(Dimension)).apply(this, arguments));
    }

    (0, _createClass3.default)(Dimension, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            this.info = this.getDimensionInfo(this.props);
            this.state = { inputValue: this.info.value, inputName: this.info.name };
            this.graphics = (0, _graphics2.default)(this.info.dimension.class, this.plugin);
            this.plugin.hud.scene.add(this.graphics);
            this.graphics.updateFromState(this.info);
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            this.graphics && this.graphics.destroy();
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(props) {
            if (props.dimension) {
                this.info = this.getDimensionInfo(props);
                if (!this.graphics) this.graphics = (0, _graphics2.default)(this.info.dimension.class, this.plugin);
                this.graphics.updateFromState(this.info);
            } else {
                this.graphics.destroy();
                this.graphics = undefined;
            }
            // This is kind of a hack. Which value should "win"? The one that the user typed, or the one
            // that comes through the wire from ClassCAD? The current solution overrides the input value.
            this.state = (0, _extends4.default)({}, this.state, { inputValue: this.info.value });
        }
    }, {
        key: 'setExpression',
        value: function setExpression(target, name, expression) {
            var expressionSet = target.class === 'CC_ExpressionSet';
            var flag = this.plugin.recalc && expressionSet ? 1 : 2;
            this.plugin.connection.execute('_C.CADApplication.SetExpressions(' + target.id + ',["' + name + '"],[' + (0, _stringify2.default)(expression) + '],' + flag + ');');
            this.plugin.afterSetCallback();
        }
    }, {
        key: 'setMember',
        value: function setMember(target, name, value) {
            this.plugin.connection.execute('VAR o; o = CADH_RealToId(' + target.id + '); o.' + name + ' = ' + (0, _stringify2.default)(value) + ';');
        }
    }, {
        key: 'getDimensionInfo',
        value: function getDimensionInfo(props) {
            var scope = this;
            var dimension = props.dimension,
                expressions = props.expressions,
                feature = props.feature,
                search = props.search;

            dimension.previewValue = undefined;
            var master = dimension.members.master ? this.plugin.tree[dimension.members.master.value] : dimension;
            var driven = (dimension.members.isDriven || {}).value;
            var linkName = master.class === 'CC_Extrusion' ? dimension.name : master.members.userValue ? 'userValue' : 'value';
            var expression = master.members[linkName].expression;
            var angle = expression.match(/^ *a_r\((.*)\) *$/);
            if (angle) expression = angle[1];
            var matches = expression.match(/^ *ExpressionSet\.(\w+) *$/);
            var target = matches ? expressions : master;
            var memberName = matches ? matches[1] : linkName;
            var owner = (this.plugin.tree[dimension.parent].members.owner || {}).value;
            var visible = (!search || dimension.members.paramName.value.toLowerCase().indexOf(search) != -1) && (!feature || owner === feature);
            var setMember = this.setMember.bind(this);
            var setExpression = this.setExpression.bind(this);
            return {
                dimension: dimension,
                angle: angle,
                driven: driven,
                visible: visible,
                get name() {
                    return dimension.members.paramName.value;
                },
                set name(value) {
                    setMember(dimension, 'paramName', value);
                },
                get value() {
                    return target.members[memberName].value;
                },
                set value(value) {
                    setMember(target, memberName, value);
                },
                get expression() {
                    return target.members[memberName].expression || target.members[memberName].value;
                },
                set expression(value) {
                    setExpression(target, memberName, value);
                },
                set dimPt(value) {
                    setExpression(dimension, 'dimPt', value);
                }
            };
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

            if (!this.info) return null;
            var _info = this.info,
                dimension = _info.dimension,
                visible = _info.visible,
                name = _info.name,
                value = _info.value,
                driven = _info.driven;

            return _renderer2.default.createElement(
                _elements.Group,
                { visible: visible, format: _elements.Group.Format.Rows },
                _renderer2.default.createElement(_elements.Input, {
                    value: this.state.inputName,
                    onValue: function onValue(inputName) {
                        return _this2.setState({ inputName: inputName });
                    },
                    onLastEvent: function onLastEvent(e) {
                        return e.key === 'Enter' && (_this2.info.name = _this2.state.inputName);
                    },
                    readonly: !!driven,
                    flex: 1
                }),
                _renderer2.default.createElement(_elements.Input, {
                    format: _elements.Input.Format.Number,
                    value: this.state.inputValue,
                    onValue: function onValue(inputValue) {
                        return _this2.setState({ inputValue: inputValue });
                    },
                    onLastEvent: function onLastEvent(e) {
                        return e.key === 'Enter' && (_this2.info.expression = _this2.state.inputValue);
                    },
                    readonly: !!driven,
                    flex: 2
                }),
                _renderer2.default.createElement(_elements.Button, {
                    name: driven ? '🔒' : '🔓',
                    disabled: driven === undefined,
                    onLastEvent: function onLastEvent() {
                        return _this2.setMember(dimension, 'isDriven', !!driven ? 0 : 1);
                    },
                    flex: 0
                })
            );
        }
    }]);
    return Dimension;
}(_renderer.Component)) || _class);
var Root = (_dec2 = (0, _renderer.connect)(function (state, props) {
    var connection = state.globals.activeConnection;
    if (!state.globals.activeConnection) return {};
    var tree = state.connections[connection].tree;
    var root = tree[tree.root].item || tree.root;
    var expressions = tree[root].expressionSet;
    var parent = state.plugins[props.id] && state.plugins[props.id].parent;
    var feature = parent && state.plugins[parent] && state.plugins[parent].feature;
    return { connection: connection, root: root, feature: feature, dimensions: tree[root].dimensions, expressions: tree[expressions] };
}), _dec2(_class2 = function (_Component2) {
    (0, _inherits3.default)(Root, _Component2);

    function Root() {
        var _ref2;

        var _temp, _this3, _ret;

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

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

        return _ret = (_temp = (_this3 = (0, _possibleConstructorReturn3.default)(this, (_ref2 = Root.__proto__ || (0, _getPrototypeOf2.default)(Root)).call.apply(_ref2, [this].concat(args))), _this3), _this3.state = { search: '' }, _temp), (0, _possibleConstructorReturn3.default)(_this3, _ret);
    }

    (0, _createClass3.default)(Root, [{
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(props) {
            var hud = this.plugin.hud;
            var tree = this.plugin.tree;
            var itemRef = (tree[tree.root].instances || []).find(function (instance) {
                return tree[instance].link === props.root;
            }) || props.root;
            var csys = tree[itemRef].coordinateSystem.map(function (row) {
                return new THREE.Vector3().fromArray(row);
            });
            hud.scene.matrix.makeBasis(csys[1], csys[2], csys[3]).setPosition(csys[0]).decompose(hud.scene.position, hud.scene.quaternion, hud.scene.scale);
            hud.scene.matrixWorldNeedsUpdate = true;
        }
    }, {
        key: 'render',
        value: function render() {
            var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                connection = _ref4.connection,
                root = _ref4.root,
                feature = _ref4.feature,
                expressions = _ref4.expressions,
                _ref4$dimensions = _ref4.dimensions,
                dimensions = _ref4$dimensions === undefined ? [] : _ref4$dimensions;

            var _ref3 = arguments[1];
            var search = _ref3.search;
            var set = arguments[2];

            var commons = { feature: feature, search: search, expressions: expressions, connection: connection };
            return _renderer2.default.createElement(
                _elements.Group,
                null,
                _renderer2.default.createElement(
                    _elements.Group,
                    { format: _elements.Group.Format.Rows },
                    _renderer2.default.createElement(_elements.Input, { value: search, placeholder: 'Search...', onValue: function onValue(search) {
                            return set({ search: search });
                        } }),
                    _renderer2.default.createElement(_elements.Button, { name: '\u2718', flex: 0, disabled: !search, onLastEvent: function onLastEvent() {
                            return set({ search: '' });
                        } })
                ),
                _renderer2.default.createElement(_elements.Spacer, null),
                dimensions.map(function (id) {
                    return _renderer2.default.createElement(Dimension, (0, _extends4.default)({ key: id }, commons));
                })
            );
        }
    }]);
    return Root;
}(_renderer.Component)) || _class2);


var resources = ['dimension'].reduce(function (prev, item) {
    return (0, _extends4.default)({}, prev, (0, _defineProperty3.default)({}, item, require('!!url-loader!awv3-icons/32x32/' + item + '.png')));
}, {});

var _default = function (_Plugin) {
    (0, _inherits3.default)(_default, _Plugin);

    function _default(session, args) {
        (0, _classCallCheck3.default)(this, _default);

        var _this4 = (0, _possibleConstructorReturn3.default)(this, (_default.__proto__ || (0, _getPrototypeOf2.default)(_default)).call(this, session, (0, _extends4.default)({
            type: 'Dimensions',
            icon: 'dimension',
            recalc: true,
            handlePrototypes: [_handle.PositionHandle, _handle.ValueHandle],
            resources: resources
        }, args)));

        _this4.selector = undefined;
        _this4.afterSetCallback = function () {};
        return _this4;
    }

    (0, _createClass3.default)(_default, [{
        key: 'render',
        value: function render() {
            return _renderer2.default.createElement(Root, { id: this.id });
        }
    }, {
        key: 'onEnabled',
        value: function onEnabled() {
            this.hud = new _hud2.default(this.view);
            this.view.addHud(this.hud);
        }
    }, {
        key: 'onDisabled',
        value: function onDisabled() {
            this.view.removeHud(this.hud);
            this.hud.destroy();
        }
    }]);
    return _default;
}(_plugin2.default);

exports.default = _default;