awv3/dist/plugins/fillet/index.js

⚡ AWV3 embedded CAD

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _extends4 = _interopRequireDefault(_extends3);

var _dec, _class, _dec2, _class3;

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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

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

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

var _plugin2 = _interopRequireDefault(_plugin);

var _dimension = require('../dimension/');

var _dimension2 = _interopRequireDefault(_dimension);

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

var _element2 = _interopRequireDefault(_element);

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

var _renderer2 = _interopRequireDefault(_renderer);

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

var _feature = require('../feature/');

var _feature2 = _interopRequireDefault(_feature);

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

var CreatePanel = function (_Component) {
    (0, _inherits3.default)(CreatePanel, _Component);

    function CreatePanel(props) {
        (0, _classCallCheck3.default)(this, CreatePanel);

        var _this = (0, _possibleConstructorReturn3.default)(this, (CreatePanel.__proto__ || (0, _getPrototypeOf2.default)(CreatePanel)).call(this, props));

        _this.state = { items: props.defaultSelection, type: 'Fillet', radius: 1, offset1: 1, offset2: 1 };
        return _this;
    }

    (0, _createClass3.default)(CreatePanel, [{
        key: 'render',
        value: function render(_ref, _ref2, set) {
            var visible = _ref.visible,
                createFillet = _ref.createFillet;

            var _this2 = this;

            var type = _ref2.type,
                items = _ref2.items,
                radius = _ref2.radius,
                offset1 = _ref2.offset1,
                offset2 = _ref2.offset2;

            return _renderer2.default.createElement(
                _elements2.Group,
                { format: _elements2.Group.Format.Table },
                _renderer2.default.createElement(
                    _elements2.Group,
                    { name: 'Target', format: _elements2.Group.Format.Rows },
                    _renderer2.default.createElement(_elements2.Selection, {
                        types: ['Mesh', 'LineSegments'],
                        limit: 1,
                        visible: visible,
                        items: items,
                        onItems: function onItems(items) {
                            return set({ items: items });
                        }
                    }),
                    _renderer2.default.createElement(_elements2.Button, {
                        name: 'Create',
                        visible: items.length != 0,
                        flex: 0,
                        onLastEvent: function onLastEvent() {
                            return createFillet(_this2.state);
                        }
                    })
                ),
                _renderer2.default.createElement(_elements2.Dropdown, { name: 'Type', items: ['Fillet', 'Chamfer'], value: type, onValue: function onValue(type) {
                        return set({ type: type });
                    } }),
                _renderer2.default.createElement(_elements2.Input, {
                    name: 'Radius',
                    visible: type === 'Fillet',
                    hint: 'expression',
                    value: radius,
                    onValue: function onValue(v) {
                        return set({ radius: parseFloat(v) || '' });
                    }
                }),
                _renderer2.default.createElement(_elements2.Input, {
                    name: 'Offset1',
                    visible: type === 'Chamfer',
                    hint: 'expression',
                    value: offset1,
                    onValue: function onValue(v) {
                        return set({ offset1: parseFloat(v) || '' });
                    }
                }),
                _renderer2.default.createElement(_elements2.Input, {
                    name: 'Offset2',
                    visible: type === 'Chamfer',
                    hint: 'expression',
                    value: offset2,
                    onValue: function onValue(v) {
                        return set({ offset2: parseFloat(v) || '' });
                    }
                })
            );
        }
    }]);
    return CreatePanel;
}(_renderer.Component);

var FeaturePlugin = (_dec = (0, _renderer.connect)(function (state, props) {
    var connection = state.connections[state.globals.activeConnection];
    return { feature: connection.tree[props.id] };
}), _dec(_class = function (_Component2) {
    (0, _inherits3.default)(FeaturePlugin, _Component2);

    function FeaturePlugin(props) {
        (0, _classCallCheck3.default)(this, FeaturePlugin);

        var _this3 = (0, _possibleConstructorReturn3.default)(this, (FeaturePlugin.__proto__ || (0, _getPrototypeOf2.default)(FeaturePlugin)).call(this, props));

        _this3.flip = function (flip) {
            _this3.setState({ flip: flip });
            var offset1 = _this3.proto.findElementClass(function (el) {
                return el.type === _element2.default.Type.Input && el.name === 'offset1';
            });
            var offset2 = _this3.proto.findElementClass(function (el) {
                return el.type === _element2.default.Type.Input && el.name === 'offset2';
            });
            if (offset1 && offset2) {
                var temp = offset1.value;
                offset1.value = offset2.value;
                offset2.value = temp;
                _this3.update(offset1, offset2);
            }
        };

        _this3.update = function () {
            var offset1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this3.proto.findElementClass(function (el) {
                return el.type === _element2.default.Type.Input && el.name === 'offset1';
            });
            var offset2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this3.proto.findElementClass(function (el) {
                return el.type === _element2.default.Type.Input && el.name === 'offset2';
            });
            var radius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _this3.proto.findElementClass(function (el) {
                return el.type === _element2.default.Type.Input && el.name === 'radius';
            });

            var isFillet = _this3.props.feature.class.indexOf('Fillet') != -1;
            var operation = _this3.props.feature.id;
            var command = '_C.CADApplication.SetFeatureParams(' + operation + ', [' + (isFillet ? parseFloat(radius.value) : parseFloat(offset1.value) + ', ' + parseFloat(offset2.value)) + '], 1);';
            console.log(command);
            _this3.plugin.connection.execute(command);
        };

        _this3.state = { flip: false };
        _this3.proto = new _feature2.default(_this3.plugin.session, {
            icon: 'isometric',
            name: props.feature.name,
            filter: ['radius', 'offset1', 'offset2'],
            collapsed: true,
            closeable: false,
            parent: _this3.plugin.id,
            feature: props.feature,
            pool: new THREE.Group(),
            connection: _this3.plugin.connection
        });
        _this3.proto.enabled = true;
        return _this3;
    }

    (0, _createClass3.default)(FeaturePlugin, [{
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            this.proto.destroy();
        }
    }, {
        key: 'render',
        value: function render(_ref3, _ref4, set) {
            var feature = _ref3.feature,
                hoverPlugins = _ref3.hoverPlugins;

            var _this4 = this;

            var flip = _ref4.flip;

            var isFillet = feature.class.indexOf('Fillet') != -1;
            var values = isFillet ? feature.members.radius.value : feature.members.offset1.value + ', ' + feature.members.offset2.value;

            this.proto.feature = feature.id;

            return _renderer2.default.createElement(
                _elements2.Group,
                {
                    name: feature.name + ' = ' + values,
                    format: _elements2.Group.Format.Collapse,
                    collapsed: true,
                    onLastEvent: function onLastEvent(event) {
                        return hoverPlugins(event, feature);
                    } },
                _renderer2.default.createElement(_elements2.Link, { value: this.proto.id, collapsable: false }),
                _renderer2.default.createElement(
                    _elements2.Group,
                    { format: _elements2.Group.Format.Table },
                    !isFillet && _renderer2.default.createElement(_elements2.Checkbox, { name: 'Flip', value: flip, onValue: this.flip }),
                    _renderer2.default.createElement(
                        _elements2.Group,
                        { name: 'Actions', format: _elements2.Group.Format.Buttons },
                        _renderer2.default.createElement(_elements2.Button, { name: 'Delete', color: 'black' }),
                        _renderer2.default.createElement(_elements2.Button, { name: 'Reset', color: 'gray' }),
                        _renderer2.default.createElement(_elements2.Button, { name: 'Apply', color: 'blue', onLastEvent: function onLastEvent() {
                                return _this4.update();
                            } })
                    )
                )
            );
        }
    }]);
    return FeaturePlugin;
}(_renderer.Component)) || _class);
var Features = (_dec2 = (0, _renderer.connect)(function (state) {
    var connection = state.connections[state.globals.activeConnection];
    var tree = connection.tree;
    var root = tree[tree.root];
    return { features: root.features };
}), _dec2(_class3 = function (_Component3) {
    (0, _inherits3.default)(Features, _Component3);

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

    (0, _createClass3.default)(Features, [{
        key: 'render',
        value: function render(_ref5) {
            var _this6 = this;

            var features = _ref5.features,
                hoverPlugins = _ref5.hoverPlugins;

            var items = (features || []).filter(function (feature) {
                return _this6.plugin.tree[feature].class.indexOf('Fillet') != -1 || _this6.plugin.tree[feature].class.indexOf('Chamfer') != -1;
            });

            return _renderer2.default.createElement(
                _elements2.Group,
                null,
                items.map(function (item) {
                    return _renderer2.default.createElement(FeaturePlugin, { id: item, hoverPlugins: hoverPlugins });
                })
            );
        }
    }]);
    return Features;
}(_renderer.Component)) || _class3);

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

    function Fillet(session, args) {
        var _this8 = this;

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

        var _this7 = (0, _possibleConstructorReturn3.default)(this, (Fillet.__proto__ || (0, _getPrototypeOf2.default)(Fillet)).call(this, session, (0, _extends4.default)({
            type: 'Fillet',
            icon: 'isometric',
            selectionVisible: true,
            defaultSelection: [],
            resources: resources
        }, args)));

        _this7.createFillet = function () {
            var _ref6 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(props) {
                var items, type, radius, offset1, offset2, hit, id, isFillet, operation;
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                items = props.items, type = props.type, radius = props.radius, offset1 = props.offset1, offset2 = props.offset2;
                                hit = _this7.connection.pool.findMaterial(function (material) {
                                    return material.meta && material.meta.id === items[0];
                                });

                                if (!(hit && radius > 0)) {
                                    _context.next = 12;
                                    break;
                                }

                                id = hit.material.meta.originalId;
                                isFillet = type === 'Fillet';
                                _context.next = 7;
                                return _this7.connection.execute('_C.CADApplication.NewFeature(' + _this7.tree.root + ', "' + (isFillet ? 'CC_ConstantRadiusFillet' : 'CC_Chamfer') + '", "' + (isFillet ? 'Fillet' : 'Chamfer') + '");');

                            case 7:
                                operation = _this7.tree[_this7.root.features[_this7.root.features.length - 1]].id;
                                _context.next = 10;
                                return _this7.connection.execute('_C.CADApplication.FeatureBuildReferences(' + operation + ', [' + id + ']);');

                            case 10:
                                _context.next = 12;
                                return _this7.connection.execute('_C.CADApplication.SetFeatureParams(' + operation + ', [' + (isFillet ? radius : offset1 + ', ' + offset2) + '], 1);');

                            case 12:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, _this8);
            }));

            return function (_x4) {
                return _ref6.apply(this, arguments);
            };
        }();

        _this7.hoverPlugins = function (event, feature) {
            var color = _this7.session.globals.colors.primary;
            var hit = _this7.connection.pool.findMaterial(function (material) {
                return material.meta && material.meta.operationId === feature.id;
            });

            if (hit) {
                if (event.type === 'mouseenter') {
                    hit.material.animate({ color: new THREE.Color(color) }).start(500);
                } else if (event.type === 'mouseleave') {
                    hit.material.animate(hit.material.meta.material).start(500);
                }
            }
        };

        return _this7;
    }

    (0, _createClass3.default)(Fillet, [{
        key: 'render',
        value: function render() {
            return _renderer2.default.createElement(
                _elements2.Group,
                null,
                _renderer2.default.createElement(CreatePanel, {
                    visible: this.selectionVisible,
                    defaultSelection: this.defaultSelection,
                    createFillet: this.createFillet
                }),
                _renderer2.default.createElement(_elements2.Spacer, null),
                _renderer2.default.createElement(Features, { hoverPlugins: this.hoverPlugins })
            );
        }
    }]);
    return Fillet;
}(_plugin2.default);

exports.default = Fillet;