awv3/dist/plugins/dimension/index.js

⚡ AWV3 embedded CAD

'use strict';

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

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

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

var _map2 = _interopRequireDefault(_map);

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

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _extends4 = _interopRequireDefault(_extends3);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

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

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

var _plugin2 = _interopRequireDefault(_plugin);

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

var _object2 = _interopRequireDefault(_object);

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 resources = ['dimension', 'fixation'].reduce(function (prev, item) {
    return (0, _extends4.default)({}, prev, (0, _defineProperty3.default)({}, item, require('!!url-loader!awv3-icons/32x32/' + item + '.png')));
}, {});

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

    function Dimension(session) {
        var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        var _ref$createDimensions = _ref.createDimensions,
            createDimensions = _ref$createDimensions === undefined ? true : _ref$createDimensions,
            _ref$recalc = _ref.recalc,
            recalc = _ref$recalc === undefined ? true : _ref$recalc,
            _ref$handlePrototypes = _ref.handlePrototypes,
            handlePrototypes = _ref$handlePrototypes === undefined ? [_handle.PositionHandle, _handle.ValueHandle] : _ref$handlePrototypes,
            args = (0, _objectWithoutProperties3.default)(_ref, ['createDimensions', 'recalc', 'handlePrototypes']);
        (0, _classCallCheck3.default)(this, Dimension);

        var _this = (0, _possibleConstructorReturn3.default)(this, (Dimension.__proto__ || (0, _getPrototypeOf2.default)(Dimension)).call(this, session, (0, _extends4.default)({
            type: 'Dimensions',
            icon: 'dimension',
            createDimensions: createDimensions,
            handlePrototypes: handlePrototypes,
            recalc: recalc,
            resources: resources
        }, args)));

        _this.onChange = function (dimension) {
            var id = dimension.id;
            var element = void 0,
                graphics = void 0;
            if (_this.dimensions.has(id)) {
                var _this$dimensions$get = _this.dimensions.get(id);

                element = _this$dimensions$get.element;
                graphics = _this$dimensions$get.graphics;
            } else {
                element = _this.makeDimensionElement(id);
                _this.addElement(element);
                graphics = (0, _graphics2.default)(dimension.class, _this);
                _this.hud.scene.add(graphics);
                _this.dimensions.set(id, { element: element, graphics: graphics });
            }
            graphics.updateFromState(dimension);
            graphics.onRender();
        };

        _this.onRemove = function (dimension, unsubscribe) {
            var id = dimension.id;

            var _this$dimensions$get2 = _this.dimensions.get(id),
                element = _this$dimensions$get2.element,
                graphics = _this$dimensions$get2.graphics;

            _this.dimensions.delete(id);
            element.removeSubscriptions();
            _this.removeElement(element);
            graphics.destroy();
            _this.removeSubscription(unsubscribe);
        };

        _this.dimensions = new _map2.default();
        //note: set manually by sketcher plugin
        _this.selector = undefined;
        _this.afterSetCallback = function () {};

        _this.valueHandleTexturePromise = new _promise2.default(function (resolve, reject) {
            return new THREE.TextureLoader().load(resources['dimension'], resolve, undefined, reject);
        });
        return _this;
    }

    (0, _createClass3.default)(Dimension, [{
        key: 'CreateDimensions',
        value: function CreateDimensions(feature) {
            this.connection.execute('VAR obj, set;\n            obj = CADH_RealToId(' + feature + ');\n            set = @BaseModelingCommonFuncs.GetDimensionSet(obj);\n            set.CreateDimensions(obj);');
        }
    }, {
        key: 'onEnabled',
        value: function onEnabled() {
            var _this2 = this;

            // Init new heads up display, add it to the view
            this.hud = new _hud2.default(this.view);
            this.view.addHud(this.hud);

            this.filter = new _elements.Input(this, { name: 'Filter', value: '', hint: 'filter' });
            this.addElement(this.filter);

            if (!this.connection) {
                console.log('dimensions called without active connection');
                return;
            }

            var observerConfig = {
                manager: this.addSubscription.bind(this),
                fireOnStart: true,
                unsubscribeOnUndefined: true
            };

            var featureParent = (this.session.plugins[this.parent] || {}).feature;
            // Watch current root for changes

            this.rootUnsubscribe = this.session.observe(function (state) {
                var tree = state.connections[state.globals.activeConnection].tree;
                return tree[tree.root].item || tree.root;
            }, function (root) {
                _this2.removeSubscriptions();
                var tree = _this2.connection.tree;
                var itemRef = (tree[tree.root].instances || []).find(function (instance) {
                    return tree[instance].link === root;
                }) || root;

                // Only react to parts and assemblies
                if (!tree[itemRef].class) return;

                var csys = tree[itemRef].coordinateSystem.map(function (row) {
                    return new THREE.Vector3().fromArray(row);
                });
                _this2.hud.scene.matrix.makeBasis(csys[1], csys[2], csys[3]).setPosition(csys[0]).decompose(_this2.hud.scene.position, _this2.hud.scene.quaternion, _this2.hud.scene.scale);
                _this2.hud.scene.matrixWorldNeedsUpdate = true;

                // Observe features and create dimensions on them
                if (featureParent) {
                    _this2.createDimensions && _this2.CreateDimensions(featureParent);
                } else {
                    _this2.createDimensions && _this2.connection.observe(function (state) {
                        return state.tree[root].features;
                    }, function (features) {
                        return features.forEach(function (feature) {
                            return _this2.CreateDimensions(feature);
                        });
                    }, observerConfig);
                }

                // Fetch expressionset
                _this2.expressionSet = tree[root].expressionSet;

                _this2.connection.observe(function (state) {
                    return state.tree[root].dimensions;
                }, function (next, prev) {
                    return (0, _helpers.arrayDiff)(next, prev, function (newDims) {
                        return newDims.forEach(function (id) {
                            var tree = _this2.connection.tree;
                            if (featureParent && featureParent !== tree[tree[id].parent].members.owner.value) return; // skip dimensions of different features
                            _this2.connection.observe(function (state) {
                                return state.tree[id];
                            }, _this2.onChange, {
                                manager: _this2.addSubscription.bind(_this2),
                                onRemove: _this2.onRemove,
                                fireOnStart: true,
                                unsubscribeOnUndefined: true
                            });
                        });
                    });
                }, observerConfig);

                //update all graphics on expression set changes
                //note: this is necessary to update dimension value in non-incremental sketcher mode
                _this2.connection.observe(function (state) {
                    return state.tree[_this2.expressionSet];
                }, function () {
                    var _iteratorNormalCompletion = true;
                    var _didIteratorError = false;
                    var _iteratorError = undefined;

                    try {
                        for (var _iterator = (0, _getIterator3.default)(_this2.dimensions.keys()), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                            var id = _step.value;

                            _this2.onChange(_this2.connection.tree[id]);
                        }
                    } catch (err) {
                        _didIteratorError = true;
                        _iteratorError = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion && _iterator.return) {
                                _iterator.return();
                            }
                        } finally {
                            if (_didIteratorError) {
                                throw _iteratorError;
                            }
                        }
                    }
                }, observerConfig);

                if (_this2.selector) {
                    //update visual representation of GUI element when selection changes
                    _this2.selector.element.observe(function (s) {
                        return s.children;
                    }, function (x) {
                        var selectedIds = _this2.selector.getSelectedIds();
                        var _iteratorNormalCompletion2 = true;
                        var _didIteratorError2 = false;
                        var _iteratorError2 = undefined;

                        try {
                            for (var _iterator2 = (0, _getIterator3.default)(_this2.dimensions.entries()), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                var _step2$value = (0, _slicedToArray3.default)(_step2.value, 2),
                                    id = _step2$value[0],
                                    element = _step2$value[1].element;

                                var highlight = selectedIds.indexOf(id) !== -1;
                                //TODO: set some other property which affects visual style
                                element.visible = highlight ? true : false;
                                //console.log("Changed selection: " + id + " := " + highlight);
                            }
                        } catch (err) {
                            _didIteratorError2 = true;
                            _iteratorError2 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                    _iterator2.return();
                                }
                            } finally {
                                if (_didIteratorError2) {
                                    throw _iteratorError2;
                                }
                            }
                        }
                    }, observerConfig);
                }
            },
            // no manager so that this sub won't be unsubscribed by removeSubscriptions when root changes
            (0, _extends4.default)({}, observerConfig, { manager: undefined }));
        }
    }, {
        key: 'onDisabled',
        value: function onDisabled() {
            // Remove and destroy heads up display
            this.view.removeHud(this.hud);
            this.hud.destroy();

            this.rootUnsubscribe();
            this.destroyElements();
        }
    }, {
        key: 'makeDimensionElement',
        value: function makeDimensionElement(id) {
            var _this3 = this;

            var isDriven = Number((this.tree[id].members.isDriven || { value: 0 }).value);
            var readonly = isDriven !== 0;
            var nameDescriptor = this.getMemberDescriptor(id, 'paramName');
            var nameElement = this.makeInputElement(nameDescriptor, 'value', { readonly: readonly, hint: 'name' });
            var descriptor = this.getDimensionDescriptor(id);
            var expressionElement = this.makeInputElement(descriptor, 'expression', { readonly: readonly, hint: 'expression' });
            var fixation = new _elements.Button(this, {
                icon: 'fixation',
                hint: 'fixation',
                format: _elements.Button.Format.Toggle,
                color: 'blue',
                flex: 0,
                value: isDriven === 0,
                readonly: isDriven === -1
            });
            fixation.observe(function (state) {
                return state.value;
            }, function (value) {
                _this3.connection.execute('VAR o;\n                    o = CADH_RealToId(' + id + ');\n                    o.SetIsDriven(' + Number(!value) + ');');
                nameElement.readonly = !value;
                expressionElement.readonly = !value;
            });
            var element = new _elements.Group(this, {
                format: _elements.Group.Format.Rows,
                children: [nameElement, expressionElement, fixation]
            });
            this.filter.observe(function (state) {
                return state.value;
            }, function (value) {
                return element.visible = nameElement.value.includes(value);
            }, {
                fireOnStart: true,
                manager: element.addSubscription.bind(element)
            });
            return element;
        }
    }, {
        key: 'makeInputElement',
        value: function makeInputElement(descriptor, descriptorMember) {
            var _this4 = this;

            var props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

            var element = new _elements.Input(this, props);
            element.observe(function (state) {
                return state.lastEvent;
            }, function (event) {
                if (event.key === 'Enter') {
                    descriptor[descriptorMember] = element.value;
                    _this4.afterSetCallback();
                }
            });
            descriptor.observeExpression(function (value) {
                return element.value = value;
            }, {
                fireOnStart: true,
                unsubscribeOnUndefined: true,
                manager: element.addSubscription.bind(element)
            });
            return element;
        }
    }, {
        key: 'getDimensionDescriptor',
        value: function getDimensionDescriptor(id) {
            var tree = this.connection.tree,
                dimension = tree[id];
            var master = tree[dimension.members.master.value]; // extrusion or constraint
            var masterLinkName = master.class === 'CC_Extrusion' ? dimension.name : master.members.userValue ? 'userValue' : 'value';
            var expression = master.members[masterLinkName].expression;
            // supported expression forms: "a_r( ExpressionSet.taper_angle )", "ExpressionSet.limit2", "everything + else"
            var matchA_R = expression.match(/^ *a_r\((.*)\) *$/);
            if (matchA_R) expression = matchA_R[1];
            var matchES = expression.match(/^ *ExpressionSet\.(\w+) *$/);
            if (matchES) return this.getMemberDescriptor(this.expressionSet, matchES[1], { hasA_R: Boolean(matchA_R) });else return this.getMemberDescriptor(dimension.members.master.value, masterLinkName);
        }
    }, {
        key: 'getMemberDescriptor',
        value: function getMemberDescriptor(id, memberName) {
            var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

            var scope = this;
            return (0, _extends4.default)({
                get value() {
                    return scope.connection.tree[id] && scope.connection.tree[id].members[memberName].value;
                },
                set value(value) {
                    scope.connection.execute('VAR o;\n                    o = CADH_RealToId(' + id + ');\n                    o.' + memberName + ' = ' + (0, _stringify2.default)(value) + ';');
                },
                get expression() {
                    return scope.connection.tree[id] && (scope.connection.tree[id].members[memberName].expression || scope.connection.tree[id].members[memberName].value);
                },
                set expression(value) {
                    var expressionSet = scope.connection.tree[id].class === 'CC_ExpressionSet';
                    var flag = scope.recalc && expressionSet ? 1 : 2;
                    var command = '_C.CADApplication.SetExpressions(' + id + ',["' + memberName + '"],[' + (0, _stringify2.default)(value) + '],' + flag + ');';
                    scope.connection.execute(command);
                },
                observeExpression: function observeExpression(onChange, options) {
                    var _this5 = this;

                    return scope.connection.observe(function (state) {
                        return state.tree[id] && _this5.expression;
                    }, onChange, options);
                }
            }, options);
        }
    }]);
    return Dimension;
}(_plugin2.default);

exports.default = Dimension;