awv3/plugins/fillet/index.js

⚡ AWV3 embedded CAD

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _extends from "@babel/runtime/helpers/extends";
import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";

var _dec, _class, _class2, _temp2, _dec2, _class3, _class4, _temp4, _dec3, _class5, _class6, _temp5, _dec4, _class7;

import * as THREE from 'three';
import React from 'react';
import { connect } from 'react-redux';
import PropTypes from 'prop-types';
import { actions as connectionActions } from '../../session/store/connections';
import { actions as elementActions } from '../../session/store/elements';
import { emptyArray } from '../../session/helpers';
import Plugin from '../../session/plugin';
import Element from '../../session/element';
import Members from '../members/';
var HOVERED = THREE.Object3D.Events.Interaction.Hovered;
var CLICKED = THREE.Object3D.Events.Interaction.Clicked;
var CreatePanel = (_dec = connect(function (state, props) {
  var plugin = state.plugins[props.id] || {};
  return {
    defaultSelection: plugin.defaultSelection,
    selectionVisible: plugin.selectionVisible
  };
}), _dec(_class = (_temp2 = _class2 =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(CreatePanel, _React$Component);

  function CreatePanel() {
    var _temp, _this;

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

    return (_temp = _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this, Object.defineProperty(_assertThisInitialized(_this), "state", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: {
        items: [],
        type: 'Fillet',
        radius: 1,
        offset1: 1,
        offset2: 1
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "setItems", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(items) {
        return !_this.props.defaultSelection && _this.setState({
          items: items
        });
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "setType", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(type) {
        return _this.setState({
          type: type
        });
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "setRadius", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(radius) {
        return _this.setState({
          radius: radius
        });
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "setOffset1", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(offset1) {
        return _this.setState({
          offset1: offset1
        });
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "setOffset2", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(offset2) {
        return _this.setState({
          offset2: offset2
        });
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "createFillet", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value() {
        return _this.props.createFillet(_extends({}, _this.state, {
          items: _this.props.defaultSelection || _this.state.items
        }));
      }
    }), Object.defineProperty(_assertThisInitialized(_this), "createFilletOnEnter", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(event) {
        return event.key === 'Enter' && _this.createFillet();
      }
    }), _temp) || _assertThisInitialized(_this);
  }

  var _proto = CreatePanel.prototype;

  _proto.render = function render() {
    var _Assembly, _Part, _Mesh, _LineSegments;

    var _props = this.props,
        visible = _props.visible,
        defaultSelection = _props.defaultSelection,
        selectionVisible = _props.selectionVisible;
    var _state = this.state,
        type = _state.type,
        items = _state.items,
        radius = _state.radius,
        offset1 = _state.offset1,
        offset2 = _state.offset2;
    items = defaultSelection || items;
    return React.createElement("group", {
      format: "Table"
    }, React.createElement("group", {
      name: "Target",
      format: "Rows"
    }, React.createElement("selection", {
      types: ['Assembly', 'Part', 'LineSegments'],
      basic: ['LineSegments', 'Mesh'],
      properties: {
        Assembly: (_Assembly = {}, _Assembly[HOVERED] = {
          opacity: 0.2
        }, _Assembly[CLICKED] = {
          opacity: 0.2
        }, _Assembly),
        Part: (_Part = {}, _Part[HOVERED] = {
          opacity: 0.2
        }, _Part[CLICKED] = {
          opacity: 0.2
        }, _Part),
        Mesh: (_Mesh = {}, _Mesh[HOVERED] = {
          opacity: 0.2
        }, _Mesh[CLICKED] = {
          opacity: 0.2
        }, _Mesh),
        LineSegments: (_LineSegments = {}, _LineSegments[HOVERED] = {
          color: new THREE.Color('#28d79f'),
          opacity: 1
        }, _LineSegments[CLICKED] = {
          color: new THREE.Color('#28b4d7'),
          opacity: 1
        }, _LineSegments)
      },
      limit: 1,
      active: true,
      visible: selectionVisible,
      items: items,
      onItems: this.setItems
    }), React.createElement("button", {
      name: "\u2714\uFE0E",
      visible: items.length != 0,
      flex: selectionVisible ? 0 : 1,
      onLastEvent: this.createFillet
    })), React.createElement("dropdown", {
      name: "Type",
      items: ['Fillet', 'Chamfer'],
      value: type,
      onValue: this.setType
    }), React.createElement("input", {
      name: "Radius",
      format: "Number",
      visible: type === 'Fillet',
      value: radius,
      onValue: this.setRadius,
      onLastEvent: this.createFilletOnEnter
    }), React.createElement("input", {
      name: "Offset1",
      format: "Number",
      visible: type === 'Chamfer',
      value: offset1,
      onValue: this.setOffset1,
      onLastEvent: this.createFilletOnEnter
    }), React.createElement("input", {
      name: "Offset2",
      format: "Number",
      visible: type === 'Chamfer',
      value: offset2,
      onValue: this.setOffset2,
      onLastEvent: this.createFilletOnEnter
    }));
  };

  return CreatePanel;
}(React.Component), Object.defineProperty(_class2, "contextTypes", {
  configurable: true,
  enumerable: true,
  writable: true,
  value: {
    session: PropTypes.object
  }
}), _temp2)) || _class);
var FeaturePlugin = (_dec2 = connect(function (state, _ref) {
  var connection = _ref.connection,
      itemId = _ref.itemId;
  connection = state.connections[connection] || {
    tree: {}
  };
  return {
    feature: connection.tree[itemId]
  };
}), _dec2(_class3 = (_temp4 = _class4 =
/*#__PURE__*/
function (_React$Component2) {
  _inheritsLoose(FeaturePlugin, _React$Component2);

  function FeaturePlugin() {
    var _temp3, _this2;

    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    return (_temp3 = _this2 = _React$Component2.call.apply(_React$Component2, [this].concat(args)) || this, Object.defineProperty(_assertThisInitialized(_this2), "state", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: {
        flip: false,
        color: undefined
      }
    }), Object.defineProperty(_assertThisInitialized(_this2), "flip", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(flip) {
        _this2.setState({
          flip: flip
        });

        var offset1 = _this2.proto.findElementClass(function (el) {
          return el.type === Element.Type.Input && el.name === 'offset1';
        });

        var offset2 = _this2.proto.findElementClass(function (el) {
          return el.type === Element.Type.Input && el.name === 'offset2';
        });

        if (offset1 && offset2) {
          var temp = offset1.value;
          offset1.value = offset2.value;
          offset2.value = temp;

          _this2.update(offset1, offset2);
        }
      }
    }), Object.defineProperty(_assertThisInitialized(_this2), "update", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(offset1, offset2, radius) {
        if (offset1 === void 0) {
          offset1 = _this2.proto.findElementClass(function (el) {
            return el.type === Element.Type.Input && el.name === 'offset1';
          });
        }

        if (offset2 === void 0) {
          offset2 = _this2.proto.findElementClass(function (el) {
            return el.type === Element.Type.Input && el.name === 'offset2';
          });
        }

        if (radius === void 0) {
          radius = _this2.proto.findElementClass(function (el) {
            return el.type === Element.Type.Input && el.name === 'radius';
          });
        }

        var isFillet = _this2.props.feature.class.indexOf('Fillet') != -1;
        var operation = _this2.props.feature.id;
        var names = isFillet ? '"radius"' : '"offset1", "offset2"';
        var values = isFillet ? parseFloat(radius.value) : parseFloat(offset1.value) + ", " + parseFloat(offset2.value);
        var command = "_C.CADApplication.SetExpressions(" + operation + ", [" + names + "], [" + values + "], 1);";

        _this2.context.plugin.connection.execute(command);
      }
    }), Object.defineProperty(_assertThisInitialized(_this2), "hover", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(event) {
        return _this2.props.hoverPlugins(event, _this2.props.feature);
      }
    }), Object.defineProperty(_assertThisInitialized(_this2), "remove", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value() {
        return _this2.context.plugin.connection.execute("_C.CADApplication.DeleteFeature(" + _this2.props.feature.id + ",1);");
      }
    }), _temp3) || _assertThisInitialized(_this2);
  }

  var _proto2 = FeaturePlugin.prototype;

  _proto2.componentWillMount = function componentWillMount() {
    var plugin = this.context.plugin;

    if (this.props.feature) {
      this.proto = new Members(plugin.session, {
        icon: 'isometric',
        name: this.props.feature.name,
        filter: ['radius', 'offset1', 'offset2'],
        collapsed: true,
        closeable: false,
        parent: plugin.id,
        feature: this.props.feature,
        pool: new THREE.Group(),
        connection: plugin.connection
      });
    }
  };

  _proto2.componentWillUnmount = function componentWillUnmount() {
    this.proto && this.proto.destroy();
  };

  _proto2.render = function render() {
    var _this3 = this;

    var _props2 = this.props,
        feature = _props2.feature,
        instance = _props2.instance;
    var _state2 = this.state,
        flip = _state2.flip,
        color = _state2.color;
    if (!feature) return null;
    var partInstance = this.context.plugin.tree[instance];
    var isFillet = feature.class.indexOf('Fillet') != -1;
    var values = isFillet ? feature.members.radius.value : feature.members.offset1.value + ", " + feature.members.offset2.value;
    return React.createElement("group", {
      color: color,
      name: partInstance.name + "." + feature.name + " = " + values,
      format: "Collapse",
      collapsed: true,
      onLastEvent: this.hover
    }, React.createElement("link", {
      value: this.proto.id,
      enabled: true,
      collapsable: false
    }), React.createElement("group", {
      format: "Table"
    }, !isFillet && React.createElement("checkbox", {
      name: "Flip",
      value: flip,
      onValue: this.flip
    }), React.createElement("group", {
      name: "Actions",
      format: "Rows"
    }, React.createElement("button", {
      name: "\u2718",
      onLastEvent: this.remove
    }), React.createElement("button", {
      name: "\u2714\uFE0E",
      onLastEvent: function onLastEvent() {
        return _this3.update();
      }
    }))));
  };

  return FeaturePlugin;
}(React.Component), Object.defineProperty(_class4, "contextTypes", {
  configurable: true,
  enumerable: true,
  writable: true,
  value: {
    plugin: PropTypes.object
  }
}), _temp4)) || _class3);
var Fillets = (_dec3 = connect(function (state, props) {
  var _instance$features;

  var connection = state.connections[props.connection];
  var tree = connection.tree;
  var instance = tree[tree[props.itemId].link];
  return {
    instance: props.itemId,
    features: (_instance$features = instance.features) !== null && _instance$features !== void 0 ? _instance$features : emptyArray
  };
}), _dec3(_class5 = (_temp5 = _class6 =
/*#__PURE__*/
function (_React$Component3) {
  _inheritsLoose(Fillets, _React$Component3);

  function Fillets() {
    return _React$Component3.apply(this, arguments) || this;
  }

  var _proto3 = Fillets.prototype;

  _proto3.render = function render() {
    var plugin = this.context.plugin;
    var _props3 = this.props,
        connection = _props3.connection,
        instance = _props3.instance,
        features = _props3.features,
        hoverPlugins = _props3.hoverPlugins;
    var items = features.filter(function (feature) {
      return plugin.tree[feature].class.indexOf('Fillet') != -1 || plugin.tree[feature].class.indexOf('Chamfer') != -1;
    });
    return React.createElement("group", null, items === null || items === void 0 ? void 0 : items.map(function (item) {
      return React.createElement(FeaturePlugin, {
        key: item,
        itemId: item,
        connection: connection,
        instance: instance,
        hoverPlugins: hoverPlugins
      });
    }));
  };

  return Fillets;
}(React.Component), Object.defineProperty(_class6, "contextTypes", {
  configurable: true,
  enumerable: true,
  writable: true,
  value: {
    plugin: PropTypes.object
  }
}), _temp5)) || _class5);
var AssemblyFeatures = (_dec4 = connect(function (state) {
  var activeConnection = state.globals.activeConnection;
  var connection = state.connections[activeConnection];
  if (!connection) return {};
  var tree = connection.tree;
  return {
    connection: activeConnection,
    instances: tree[tree.root].instancesNested
  };
}), _dec4(_class7 =
/*#__PURE__*/
function (_React$Component4) {
  _inheritsLoose(AssemblyFeatures, _React$Component4);

  function AssemblyFeatures() {
    return _React$Component4.apply(this, arguments) || this;
  }

  var _proto4 = AssemblyFeatures.prototype;

  _proto4.render = function render() {
    var _props4 = this.props,
        connection = _props4.connection,
        instances = _props4.instances,
        hoverPlugins = _props4.hoverPlugins;
    return React.createElement("group", null, instances === null || instances === void 0 ? void 0 : instances.map(function (id) {
      return React.createElement(Fillets, {
        key: id,
        itemId: id,
        connection: connection,
        hoverPlugins: hoverPlugins
      });
    }));
  };

  return AssemblyFeatures;
}(React.Component)) || _class7);

var Fillet =
/*#__PURE__*/
function (_Plugin) {
  _inheritsLoose(Fillet, _Plugin);

  function Fillet(session, args) {
    var _this4;

    _this4 = _Plugin.call(this, session, _extends({
      type: 'Fillet',
      icon: 'isometric',
      selectionVisible: true,
      defaultSelection: undefined,
      resources: {
        isometric: require('!!url-loader!awv3-icons/32x32/isometric.png')
      }
    }, args)) || this;
    Object.defineProperty(_assertThisInitialized(_this4), "createFillet", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function () {
        var _value = _asyncToGenerator(
        /*#__PURE__*/
        _regeneratorRuntime.mark(function _callee(props) {
          var items, type, radius, offset1, offset2, hit, id, isFillet, part, instance, root, operation;
          return _regeneratorRuntime.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 = _this4.connection.pool.findMaterial(function (material) {
                    return material.meta && material.meta.id === items[0];
                  });

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

                  id = hit.material.meta.id;
                  isFillet = type === 'Fillet';
                  part = hit.object.findReverse(function (obj) {
                    return obj.type === 'Part';
                  });
                  instance = _this4.tree[part.userData.id];
                  _context.next = 9;
                  return _this4.connection.execute("_C.CADApplication.NewFeature(" + instance.link + ", \"" + (isFillet ? 'CC_ConstantRadiusFillet' : 'CC_Chamfer') + "\", \"" + (isFillet ? 'Fillet' : 'Chamfer') + "\");");

                case 9:
                  root = _this4.tree[instance.link];
                  operation = _this4.tree[root.features[root.features.length - 1]].id;
                  _context.next = 13;
                  return _this4.connection.execute("_C.CADApplication.FeatureBuildReferences(" + operation + ", [" + id + "]);");

                case 13:
                  _context.next = 15;
                  return _this4.connection.execute("_C.CADApplication.SetFeatureParams(" + operation + ", [" + (isFillet ? radius : offset1 + ", " + offset2) + "], 1);");

                case 15:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        return function value(_x) {
          return _value.apply(this, arguments);
        };
      }()
    });
    Object.defineProperty(_assertThisInitialized(_this4), "hoverPlugins", {
      configurable: true,
      enumerable: true,
      writable: true,
      value: function value(event, feature) {
        var color = _this4.session.globals.colors.primary;

        var hit = _this4.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 _this4;
  }

  var _proto5 = Fillet.prototype;

  _proto5.render = function render() {
    return React.createElement("group", null, React.createElement(CreatePanel, {
      id: this.id,
      createFillet: this.createFillet
    }), React.createElement("spacer", null), React.createElement(AssemblyFeatures, {
      hoverPlugins: this.hoverPlugins
    }));
  };

  return Fillet;
}(Plugin);

export { Fillet as default };