awv3
Version:
⚡ AWV3 embedded CAD
1,109 lines (939 loc) • 48.6 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = undefined;
var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
var _log = require('babel-runtime/core-js/math/log10');
var _log2 = _interopRequireDefault(_log);
var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
var _defineProperty3 = _interopRequireDefault(_defineProperty2);
var _promise = require('babel-runtime/core-js/promise');
var _promise2 = _interopRequireDefault(_promise);
var _regenerator = require('babel-runtime/regenerator');
var _regenerator2 = _interopRequireDefault(_regenerator);
var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
var _getIterator2 = require('babel-runtime/core-js/get-iterator');
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
var _entries = require('babel-runtime/core-js/object/entries');
var _entries2 = _interopRequireDefault(_entries);
var _values = require('babel-runtime/core-js/object/values');
var _values2 = _interopRequireDefault(_values);
var _map = require('babel-runtime/core-js/map');
var _map2 = _interopRequireDefault(_map);
var _extends2 = require('babel-runtime/helpers/extends');
var _extends3 = _interopRequireDefault(_extends2);
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 _class, _temp;
var _three = require('three');
var THREE = _interopRequireWildcard(_three);
var _orbit = require('../../controls/orbit');
var _orbit2 = _interopRequireDefault(_orbit);
var _elements = require('../../session/elements');
var _helpers = require('../../session/helpers');
var _materialselector = require('../../session/selection/materialselector');
var _plugin = require('../../session/plugin');
var _plugin2 = _interopRequireDefault(_plugin);
var _connections = require('../../session/store/connections');
var _object = require('../../three/object3');
var _object2 = _interopRequireDefault(_object);
var _dimension = require('../dimension/');
var _dimension2 = _interopRequireDefault(_dimension);
var _ccref = require('./ccref');
var _ccref2 = _interopRequireDefault(_ccref);
var _generator = require('./constraint/generator');
var _generator2 = _interopRequireDefault(_generator);
var _type = require('./constraint/type');
var ConstraintType = _interopRequireWildcard(_type);
var _visualizer = require('./constraint/visualizer');
var _visualizer2 = _interopRequireDefault(_visualizer);
var _commandrunner = require('./command/commandrunner');
var _commandrunner2 = _interopRequireDefault(_commandrunner);
var _highlevel = require('./command/highlevel');
var _lowlevel = require('./command/lowlevel');
var _multirunner = require('./command/multirunner');
var _multirunner2 = _interopRequireDefault(_multirunner);
var _graphics = require('./graphics');
var _graphics2 = _interopRequireDefault(_graphics);
var _handlers = require('./handlers');
var _handlers2 = _interopRequireDefault(_handlers);
var _duplicate = require('./handlers/duplicate');
var _duplicate2 = _interopRequireDefault(_duplicate);
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 }; }
//import help from './help';
var resourcesPaths = {
'help': 'help.png',
'cancel': 'cancel.png',
's': 's.png',
'ac': 'ac.png',
'duplicate': 'duplicate.png',
'line': 'line.png',
'point': 'point.png',
'arc-center': 'TODO/arc-center.png',
'arc-3points': 'arc-3points.png',
'arc-tangential': 'arc-tangential.png',
'circle-center-radius': 'circle-center-radius.png',
'fillet-sketch': 'fillet-sketch.png',
'fixation': 'fixation.png',
'horizontality': 'horizontality.png',
'verticality': 'verticality.png',
'incidence': 'coincident.png',
'tangency': 'tangency.png',
'parallelity': 'parallelity.png',
'perpendicularity': 'perpendicularity.png',
'colinear': 'colinear.png',
'concentric': 'concentric.png',
'midpoint': 'midpoint.png',
'symmetric': 'symmetric.png',
'equalDistance': 'equal.png',
'equalRadius': 'equal.png',
'horizontalDistance': 'hdimension.png',
'verticalDistance': 'vdimension.png',
'distance': 'dimension.png',
'radius': 'TODO/radius.png',
'diameter': 'dimension.png',
'angle': 'TODO/angle.png',
'angleox': 'TODO/angleox.png'
};
var resources = {};
for (var name in resourcesPaths) {
var path = resourcesPaths[name];
resources[name] = require('!!url-loader!awv3-icons/32x32/' + path);
}
var textures = {},
textureLoader = new THREE.TextureLoader();
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
var _loop4 = function _loop4() {
var _step$value = (0, _slicedToArray3.default)(_step.value, 2),
name = _step$value[0],
url = _step$value[1];
textures[name] = new _promise2.default(function (resolve, reject) {
return textureLoader.load(url, resolve, undefined, reject);
});
};
for (var _iterator = (0, _getIterator3.default)((0, _entries2.default)(resources)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
_loop4();
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var Sketcher = (_temp = _class = function (_Plugin) {
(0, _inherits3.default)(Sketcher, _Plugin);
function Sketcher(session, args) {
(0, _classCallCheck3.default)(this, Sketcher);
var _this = (0, _possibleConstructorReturn3.default)(this, (Sketcher.__proto__ || (0, _getPrototypeOf2.default)(Sketcher)).call(this, session, (0, _extends3.default)({ type: 'Sketch', icon: 'sketch', resources: resources }, args)));
_this.activeSketch = new _ccref2.default(_this, _this.feature);
_this.autoconstraintIncremental = true;
_this.constraintVisualizer = new _visualizer2.default(_this);
_this.dimension = new _dimension2.default(_this.session, {
name: 'Dimensions',
recalc: false,
collapsed: true,
closeable: false,
parent: _this.id
});
_this.dimension.afterSetCallback = _this.incrementalSolveConstraints.bind(_this);
_this.dependencies.push(_this.dimension);
_this.graphics = new _map2.default();
_this.graphicScale = 0.1; //radius of a sketch point
_this.gridStep = 0.1; //size of grid cell
_this.multiRunner = new _multirunner2.default(_commandrunner2.default.bind(undefined, _this.connection));
_this.onPlaneChange = _this.onPlaneChange.bind(_this);
_this.onSketchObjectChange = _this.onSketchObjectChange.bind(_this);
_this.onSketchObjectRemove = _this.onSketchObjectRemove.bind(_this);
_this.recalcIncremental = false;
_this.selector = new _materialselector.MaterialSelector(session);
_this.selector.hoveredProps = (0, _extends3.default)({}, _this.selector.hoveredProps, {
polygonOffsetFactor: -10,
polygonOffsetUnits: -50
});
_this.selector.selectedProps = (0, _extends3.default)({}, _this.selector.selectedProps, {
polygonOffsetFactor: -5,
polygonOffsetUnits: -25
});
_this.dimension.selector = _this.selector;
_this.solveIncremental = false;
_this.textures = textures;
_this.transientGeomParams = new _map2.default();
_this.addElements();
return _this;
}
(0, _createClass3.default)(Sketcher, [{
key: 'addElements',
value: function addElements() {
var GF = _elements.Group.Format,
BF = _elements.Button.Format;
this.namedElements = {
plane: new _elements.Selection(this, { name: 'plane', active: false, types: ['Object', 'Workplane'] }),
selection: new _elements.Selection(this, { name: 'Selection', types: ['SketcherMesh', 'DimensionHandle'] }),
console: new _elements.Console(this, { name: 'Console' }),
dimension: new _elements.Link(this, { name: 'Dimensions', value: this.dimension.id, collapsable: true }),
incremental: new _elements.Slider(this, {
name: 'Increment',
value: Math.max(1 * this.solveIncremental, 2 * this.recalcIncremental),
max: 2,
positions: { 0: 'None', 1: 'Solve', 2: 'Recalc' }
}),
constrvis: new _elements.Slider(this, {
name: 'Constraints',
value: this.constraintVisualizer.mode,
max: 2,
positions: { 0: 'Never', 1: 'Hover', 2: 'Always' }
}),
handlers: {
drag: new _elements.Button(this, { format: BF.Toggle, name: 'drag' }),
point: new _elements.Button(this, { format: BF.Toggle, name: 'point', icon: 'point' }),
line: new _elements.Button(this, { format: BF.Toggle, name: 'line', icon: 'line' }),
arccenter: new _elements.Button(this, { format: BF.Toggle, name: 'arc center', icon: 'arc-center' }),
arcmiddle: new _elements.Button(this, { format: BF.Toggle, name: 'arc middle', icon: 'arc-3points' }),
arctangent: new _elements.Button(this, { format: BF.Toggle, name: 'arc tangent', icon: 'arc-tangential' }),
circle: new _elements.Button(this, { format: BF.Toggle, name: 'circle', icon: 'circle-center-radius' }),
fillet: new _elements.Button(this, { format: BF.Toggle, name: 'fillet', icon: 'fillet-sketch' }),
duplicate: new _elements.Button(this, { format: BF.Toggle, name: 'Duplicate', icon: 'duplicate' })
},
constraints: {
incidence: new _elements.Button(this, { name: 'incidence', icon: 'incidence' }),
tangency: new _elements.Button(this, { name: 'tangency', icon: 'tangency' }),
verticality: new _elements.Button(this, { name: 'verticality', icon: 'verticality' }),
horizontality: new _elements.Button(this, { name: 'horizontality', icon: 'horizontality' }),
parallelity: new _elements.Button(this, { name: 'parallelity', icon: 'parallelity' }),
perpendicularity: new _elements.Button(this, { name: 'perpendicularity', icon: 'perpendicularity' }),
fixation: new _elements.Button(this, { name: 'fixation', icon: 'fixation' }),
colinear: new _elements.Button(this, { name: 'colinear', icon: 'colinear' }),
concentric: new _elements.Button(this, { name: 'concentric', icon: 'concentric' }),
midpoint: new _elements.Button(this, { name: 'midpoint', icon: 'midpoint' }),
symmetric: new _elements.Button(this, { name: 'symmetric', icon: 'symmetric' }),
equalDistance: new _elements.Button(this, { name: 'equal length', icon: 'equalDistance' }),
equalRadius: new _elements.Button(this, { name: 'equal radius', icon: 'equalRadius' }),
distance: new _elements.Button(this, { name: 'distance', icon: 'distance' }),
horizontalDistance: new _elements.Button(this, { name: 'horizontal distance', icon: 'horizontalDistance' }),
verticalDistance: new _elements.Button(this, { name: 'vertical distance', icon: 'verticalDistance' }),
radius: new _elements.Button(this, { name: 'radius', icon: 'radius' }),
diameter: new _elements.Button(this, { name: 'diameter', icon: 'diameter' }),
angle: new _elements.Button(this, { name: 'angle', icon: 'angle' }),
angleox: new _elements.Button(this, { name: 'angleox', icon: 'angleox' })
},
actions: {
solve: new _elements.Button(this, { name: 'Solve', icon: 's' }),
autoconstr: new _elements.Button(this, { name: 'Autoconstr', icon: 'ac' }),
delete: new _elements.Button(this, { name: 'Delete', icon: 'cancel' }),
help: new _elements.Button(this, { name: /*help*/'Help', icon: 'help' })
},
coordinateShower: {
xLabel: new _elements.Label(this, { value: 'X', header: true, flex: 'inherit' }),
xCoord: new _elements.Label(this, { value: 0, flex: 1 }),
yLabel: new _elements.Label(this, { value: 'Y', header: true, flex: 'inherit' }),
yCoord: new _elements.Label(this, { value: 0, flex: 1 })
}
};
this.namedElements.arcs = new _elements.Button(this, {
format: BF.Menu,
name: 'arctangent',
icon: 'arc-tangential',
children: [new _elements.Group(this, {
name: 'arc group',
format: GF.Buttons,
children: [this.namedElements.handlers.arctangent, this.namedElements.handlers.arccenter, this.namedElements.handlers.arcmiddle, this.namedElements.handlers.circle]
})]
});
this.namedElements.toolsGroup = new _elements.Group(this, {
name: 'Tools',
format: GF.Buttons,
children: [this.namedElements.handlers.point, this.namedElements.handlers.line, this.namedElements.arcs, this.namedElements.handlers.fillet, this.namedElements.handlers.duplicate],
limit: 4
});
this.namedElements.actionsGroup = new _elements.Group(this, {
name: 'Actions',
format: GF.Buttons,
children: (0, _values2.default)(this.namedElements.actions),
limit: 4
});
(0, _values2.default)(this.namedElements.constraints).forEach(function (item) {
return item.visible = false;
});
this.namedElements.constraintsGroup = new _elements.Group(this, {
name: 'Constraints',
format: GF.Buttons,
children: (0, _values2.default)(this.namedElements.constraints),
limit: 4,
visible: false
});
this.namedElements.mouseGroup = new _elements.Group(this, {
name: 'Mouse',
format: GF.Rows,
children: [this.namedElements.coordinateShower.xLabel, this.namedElements.coordinateShower.xCoord, this.namedElements.coordinateShower.yLabel, this.namedElements.coordinateShower.yCoord]
});
this.addElement(new _elements.Group(this, {
format: GF.Table,
children: [this.namedElements.plane, this.namedElements.incremental, this.namedElements.constrvis, this.namedElements.toolsGroup, this.namedElements.actionsGroup, this.namedElements.constraintsGroup, this.namedElements.console, this.namedElements.mouseGroup]
}));
this.setCursorCoordinates(undefined);
this.addElement(this.namedElements.dimension);
}
}, {
key: 'getSelected',
value: function getSelected() {
var _this2 = this;
return this.selector.getSelectedIds().map(function (id) {
return new _ccref2.default(_this2, id);
});
}
}, {
key: 'observeElements',
value: function observeElements() {
var _this3 = this;
var value = function value(s) {
return s.value;
},
click = function click(s) {
return s.lastEvent;
},
children = function children(s) {
return s.children;
};
this.namedElements.plane.observe(children, function (x) {
return _this3.setPlaneFromSelection();
});
this.namedElements.selection.observe(children, function (x) {
var entities = _this3.getSelected();
var items = (0, _entries2.default)(_this3.namedElements.constraints);
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = (0, _getIterator3.default)(items), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _step2$value = (0, _slicedToArray3.default)(_step2.value, 2),
_name = _step2$value[0],
element = _step2$value[1];
element.visible = Boolean(ConstraintType[_name].adapt(entities));
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
_this3.namedElements.constraintsGroup.visible = items.some(function (_ref) {
var _ref2 = (0, _slicedToArray3.default)(_ref, 2),
name = _ref2[0],
element = _ref2[1];
return element.visible;
});
});
this.namedElements.console.observe(click, function () {
var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(event) {
return _regenerator2.default.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (!(event.key === 'Enter' && event.target)) {
_context.next = 5;
break;
}
_context.next = 3;
return _this3.activeHandler.consoleExecute(event.target.value);
case 3:
_this3.namedElements.console.value = '';
_this3.refresh();
case 5:
case 'end':
return _context.stop();
}
}
}, _callee, _this3);
}));
return function (_x) {
return _ref3.apply(this, arguments);
};
}());
this.namedElements.console.observe(value, function () {
var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(x) {
var completions;
return _regenerator2.default.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
completions = _this3.activeHandler.consoleComplete(x);
_this3.namedElements.console.children = completions.filter(function (c) {
return c.trim() !== '';
});
_this3.activeHandler.parseRestrictions(x);
_this3.refresh();
case 4:
case 'end':
return _context2.stop();
}
}
}, _callee2, _this3);
}));
return function (_x2) {
return _ref4.apply(this, arguments);
};
}());
this.namedElements.incremental.observe(value, function (x) {
_this3.solveIncremental = x >= 1;
_this3.recalcIncremental = x >= 2;
_this3.incrementalSolveConstraints();
});
this.namedElements.constrvis.observe(value, function (x) {
return _this3.constraintVisualizer.updateAll(x);
});
this.namedElements.arcs.observe(click, function (x) {
var button = _this3.namedElements.handlers[_this3.namedElements.arcs.name];
button.value = !button.value;
});
var _arr = ['arctangent', 'arccenter', 'arcmiddle', 'circle'];
var _loop = function _loop() {
var archandler = _arr[_i];
var arcelement = _this3.namedElements.handlers[archandler];
arcelement.observe(click, function (x) {
_this3.namedElements.arcs.name = archandler;
_this3.namedElements.arcs.icon = arcelement.icon;
});
};
for (var _i = 0; _i < _arr.length; _i++) {
_loop();
}
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
var _loop2 = function _loop2() {
var _step3$value = (0, _slicedToArray3.default)(_step3.value, 2),
handler = _step3$value[0],
element = _step3$value[1];
if (handler !== 'duplicate') element.observe(value, function (flag) {
return _this3.onHandlerToggle(handler, flag);
});
};
for (var _iterator3 = (0, _getIterator3.default)((0, _entries2.default)(this.namedElements.handlers)), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
_loop2();
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
this.namedElements.handlers.duplicate.observe(value, function (flag) {
if (flag) {
var objects = _this3.getSelected();
objects = _duplicate2.default.normalizeSelection(objects);
if (objects.length > 0) {
_this3.onHandlerToggle('duplicate', true);
_this3.activeHandler.init(objects);
} else _this3.namedElements.handlers.duplicate.value = false;
} else _this3.onHandlerToggle('duplicate', false);
});
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
var _loop3 = function _loop3() {
var _step4$value = (0, _slicedToArray3.default)(_step4.value, 2),
constraint = _step4$value[0],
element = _step4$value[1];
element.observe(click, function () {
var _ref5 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(x) {
var ct, entities, value, oldHandler, cmd, dimId;
return _regenerator2.default.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
ct = ConstraintType[constraint];
entities = ct.adapt(_this3.getSelected()), value = {};
if (!(ct.type === 'CC_2DAngleConstraint')) {
_context3.next = 13;
break;
}
_this3.activeHandler.removeInteractions();
oldHandler = _this3.activeHandler;
_this3.activeHandler = (0, _handlers2.default)(_this3, 'angle');
_this3.activeHandler.setLines(entities);
_context3.next = 9;
return new _promise2.default(function (resolve) {
return _this3.activeHandler.resolve = resolve;
});
case 9:
value = _context3.sent;
_this3.activeHandler.destroy();
_this3.activeHandler = oldHandler;
_this3.activeHandler.addInteractions();
case 13:
if (entities) {
_context3.next = 15;
break;
}
return _context3.abrupt('return');
case 15:
_this3.selector.removeAll();
if (value) {
_context3.next = 18;
break;
}
return _context3.abrupt('return');
case 18:
// cancelled angle
cmd = (0, _highlevel.addCommand)(_this3.activeSketch, { class: ct.type, entities: entities, value: value });
if (ct.isParametric) cmd = (0, _lowlevel.IdToReal)(cmd);
dimId = _this3.run(cmd);
_this3.incrementalSolveConstraints();
case 22:
case 'end':
return _context3.stop();
}
}
}, _callee3, _this3);
}));
return function (_x3) {
return _ref5.apply(this, arguments);
};
}());
};
for (var _iterator4 = (0, _getIterator3.default)((0, _entries2.default)(this.namedElements.constraints)), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
_loop3();
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
this.namedElements.actions.solve.observe(click, function (x) {
return _this3.solveConstraints();
});
this.namedElements.actions.autoconstr.observe(click, function (x) {
return _this3.run(_this3.generateConstraints(_this3.activeSketch));
});
this.namedElements.actions.delete.observe(click, function (x) {
return _this3.deleteSelected();
});
}
}, {
key: 'onEnabled',
value: function onEnabled() {
var _this4 = this;
this.session.pool.fadeOut();
this.pool.createInteraction().on((0, _defineProperty3.default)({}, _object2.default.Events.Lifecycle.Rendered, this.onRender.bind(this)), { sync: true });
this.observeElements();
this.namedElements.handlers['drag'].value = true;
this.dimension.enabled = true;
this.connection.observe(function (state) {
return state.tree[_this4.activeSketch.id];
}, this.onSketchObjectChange, {
fireOnStart: true,
unsubscribeOnUndefined: true,
onRemove: this.onSketchObjectRemove,
manager: this.addSubscription.bind(this)
});
this.connection.observe(function (state) {
return state.tree[_this4.activeSketch.id].members.planeReference.value;
}, this.onPlaneChange, {
fireOnStart: true,
manager: this.addSubscription.bind(this)
});
this.constraintVisualizer.updateAll();
//this.session.pool.view.controls.noRotate = true;
this.view.controls.focus().zoom();
this.zoomMode_old = this.view.controls.zoomMode;
this.view.controls.zoomMode = _orbit2.default.ZoomMode.Mouse;
}
}, {
key: 'onDisabled',
value: function onDisabled() {
this.session.pool.fadeIn();
// Unlock controls, fade in pool
//this.session.pool.view.controls.noRotate = false;
this.view.controls.focus().zoom();
this.dimension.enabled = false;
if (this.activeHandler) {
// disable possible complex handler (polyline) first, then disable drag
this.namedElements.handlers[this.activeHandler.name].value = false;
this.onHandlerToggleRecursion = true;
this.namedElements.handlers['drag'].value = false;
this.onHandlerToggleRecursion = false;
}
this.view.controls.zoomMode = this.zoomMode_old;
}
}, {
key: 'onSketchObjectChange',
value: function onSketchObjectChange(object, oldObject) {
var _this5 = this;
var id = object.id,
ccref = new _ccref2.default(this, id);
// create graphics
if (!this.graphics.has(id)) {
var g = (0, _graphics2.default)(object.class);
if (!g) return;
this.pool.add(g);
this.graphics.set(id, g);
this.activeHandler.addInteraction(ccref);
this.constraintVisualizer.addConstraint(ccref);
}
// create new children subscriptions
(0, _helpers.arrayDiff)(object.children, (oldObject || {}).children, function (newChildren) {
return newChildren.forEach(function (child) {
return _this5.connection.observe(function (state) {
return state.tree[child];
}, _this5.onSketchObjectChange, {
fireOnStart: true,
unsubscribeOnUndefined: true,
onRemove: _this5.onSketchObjectRemove,
manager: _this5.addSubscription.bind(_this5)
});
});
});
// update graphics
ccref.updateGraphics();
// update parent line/arc graphics if this was an endpoint change or similar
if (object.id !== this.activeSketch.id && object.parent !== this.activeSketch.id) new _ccref2.default(this, object.parent).updateGraphics();
}
}, {
key: 'onPlaneChange',
value: function onPlaneChange(planeId) {
var isCorrect = Boolean(planeId);
this.namedElements.incremental.visible = isCorrect;
this.namedElements.constrvis.visible = isCorrect;
this.namedElements.toolsGroup.visible = isCorrect;
this.namedElements.actionsGroup.visible = isCorrect;
this.namedElements.constraintsGroup.visible = isCorrect;
this.namedElements.console.visible = isCorrect;
this.namedElements.mouseGroup.visible = isCorrect;
this.namedElements.dimension.visible = isCorrect;
this.pool.visible = isCorrect;
}
}, {
key: 'onSketchObjectRemove',
value: function onSketchObjectRemove(object, unsubscribe) {
var id = object.id;
// destroy graphics
if (this.graphics.has(id)) {
var ccref = new _ccref2.default(this, id);
// pass object too because ccref.state can be undefined
this.constraintVisualizer.removeConstraint(ccref, object);
this.activeHandler.removeInteraction(ccref);
this.graphics.get(id).destroy();
this.graphics.delete(id);
}
// free transient info
if (this.transientGeomParams.has(id)) this.transientGeomParams.delete(id);
// remove a reference added by addSubscription
this.removeSubscription(unsubscribe);
}
}, {
key: 'onHandlerToggle',
value: function onHandlerToggle(handler, value) {
if (this.onHandlerToggleRecursion) return;
this.onHandlerToggleRecursion = true;
if (value) {
if (this.activeHandler) this.namedElements.handlers[this.activeHandler.name].value = false;
this.activeHandler = (0, _handlers2.default)(this, handler, this.activeHandler);
} else {
this.namedElements.handlers['drag'].value = true;
this.activeHandler = (0, _handlers2.default)(this, 'drag', this.activeHandler);
}
this.activeHandler.parseRestrictions(this.namedElements.console.value);
this.onHandlerToggleRecursion = false;
}
}, {
key: 'onRender',
value: function onRender() {
var graphicDirty = this.updateGraphicScale();
if (graphicDirty) this.activeSketch.updateGraphicsRecursive();
this.constraintVisualizer.render();
}
}, {
key: 'updateGraphicScale',
value: function updateGraphicScale() {
// just take sketch origin as scaling point
var globalPnt = new THREE.Vector3(0, 0, 0).applyMatrix4(this.activeSketch.matrixWorld);
// get length-to-pixels local scaling at this point
var approxScale = this.view.calculateScaleFactor(globalPnt, 7);
// adjust to a good number
var newScale = Math.pow(10.0, Math.floor((0, _log2.default)(approxScale) * 5) / 5);
// set grid step
var newStep = Math.pow(10.0, Math.floor((0, _log2.default)(approxScale * 30) + 1e-3));
//change scale and grid atep
var changed = newStep !== this.gridStep || newScale !== this.graphicScale;
this.gridStep = newStep;
this.graphicScale = newScale;
return changed;
}
//only for showing them in GUI
}, {
key: 'setCursorCoordinates',
value: function setCursorCoordinates(pos) {
if (pos) {
this.namedElements.coordinateShower.xCoord.visible = true;
this.namedElements.coordinateShower.yCoord.visible = true;
this.namedElements.coordinateShower.xCoord.value = pos.x;
this.namedElements.coordinateShower.yCoord.value = pos.y;
} else {
this.namedElements.coordinateShower.xCoord.visible = false;
this.namedElements.coordinateShower.yCoord.visible = false;
}
}
}, {
key: 'refresh',
value: function refresh() {
this.view.invalidate();
}
}, {
key: 'run',
value: function run(command) {
return this.multiRunner.run({ command: 'Execute', task: (0, _lowlevel.Sequence)(command).unparse() });
}
}, {
key: 'checkSolveResult',
value: function checkSolveResult(result) {
// result: 0 - fail, 1 - well-defined, 2 - solved
if (result === 0) {
this.namedElements.incremental.error = 'Failed to solve sketch';
this.namedElements.incremental.value = 0;
return false;
}
this.namedElements.incremental.error = undefined;
return true;
}
}, {
key: 'solveConstraints',
value: function () {
var _ref6 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4() {
var result;
return _regenerator2.default.wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
result = this.run((0, _lowlevel.Return)((0, _lowlevel.SolveConstraints)(this.activeSketch)));
this.run((0, _lowlevel.UpdateDimensions)(this.activeSketch));
_context4.t0 = this;
_context4.next = 5;
return result;
case 5:
_context4.t1 = _context4.sent;
return _context4.abrupt('return', _context4.t0.checkSolveResult.call(_context4.t0, _context4.t1));
case 7:
case 'end':
return _context4.stop();
}
}
}, _callee4, this);
}));
function solveConstraints() {
return _ref6.apply(this, arguments);
}
return solveConstraints;
}()
}, {
key: 'recalc',
value: function recalc() {
return this.run((0, _lowlevel.Recalc)());
}
}, {
key: 'incrementalSolveConstraints',
value: function () {
var _ref7 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee5() {
var solvePromise, recalcPromise;
return _regenerator2.default.wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
solvePromise = this.solveIncremental ? this.solveConstraints() : _promise2.default.resolve();
recalcPromise = this.recalcIncremental ? this.recalc() : _promise2.default.resolve();
_context5.next = 4;
return _promise2.default.all([solvePromise, recalcPromise]);
case 4:
case 'end':
return _context5.stop();
}
}
}, _callee5, this);
}));
function incrementalSolveConstraints() {
return _ref7.apply(this, arguments);
}
return incrementalSolveConstraints;
}()
}, {
key: 'generateConstraints',
value: function generateConstraints(object) {
return new _generator2.default(this.activeSketch).generateImpliedConstraints(object);
}
}, {
key: 'autoconstraintCommands',
value: function autoconstraintCommands(object) {
return this.autoconstraintIncremental ? this.generateConstraints(object) : [];
}
}, {
key: 'moveUnderConstraints',
value: function () {
var _ref8 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee6(objects, delta) {
var command, result;
return _regenerator2.default.wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
if (!(delta.lengthSq() === 0)) {
_context6.next = 2;
break;
}
return _context6.abrupt('return');
case 2:
if (!this.solveInProgress) {
_context6.next = 4;
break;
}
return _context6.abrupt('return');
case 4:
this.solveInProgress = true; // hack: prevent multiple concurrent requests to the server
command = (0, _lowlevel.Return)((0, _lowlevel.MoveObjects)(this.activeSketch, this.noMultiMoveSupport ? objects[0] : objects, delta));
_context6.prev = 6;
_context6.next = 9;
return this.run(command);
case 9:
result = _context6.sent;
this.checkSolveResult(result);
_context6.next = 21;
break;
case 13:
_context6.prev = 13;
_context6.t0 = _context6['catch'](6);
if (!(!this.noMultiMoveSupport && _context6.t0.errorCode === 0 && _context6.t0.errorState === 2 && _context6.t0.errorMessage === '[Evaluationsfehler in SketcherCloudInterop.MoveObjects:[CCVM::callsf: objId not found]] ')) {
_context6.next = 20;
break;
}
console.warn('No support for moving multiple objects, update server classes');
this.noMultiMoveSupport = true;
_context6.next = 21;
break;
case 20:
throw _context6.t0;
case 21:
_context6.prev = 21;
this.solveInProgress = false;
return _context6.finish(21);
case 24:
case 'end':
return _context6.stop();
}
}
}, _callee6, this, [[6, 13, 21, 24]]);
}));
function moveUnderConstraints(_x4, _x5) {
return _ref8.apply(this, arguments);
}
return moveUnderConstraints;
}()
}, {
key: 'copyObjects',
value: function copyObjects(objects, translate, rotate) {
return this.run((0, _lowlevel.CopyObjects)(this.activeSketch, objects, translate, rotate));
}
}, {
key: 'deleteSelected',
value: function deleteSelected() {
var _ref9 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
onlyIfConsoleIsEmpty = _ref9.onlyIfConsoleIsEmpty;
if (onlyIfConsoleIsEmpty && this.namedElements.console.value !== '') return;
var selected = this.getSelected();
// replace selected dimensions with their master constraints
for (var i = 0; i < selected.length; i++) {
var ent = selected[i];
if (ent.isDimension()) selected[i] = new _ccref2.default(this, this.connection.tree[ent.id].members.master.value);
}
selected = selected.filter(function (ent) {
return ent;
});
if (selected.length !== 0) {
// delete sketch objects
this.selector.removeAll();
this.run(_highlevel.removeCommands.apply(undefined, [this.activeSketch].concat((0, _toConsumableArray3.default)(selected))));
this.incrementalSolveConstraints();
}
}
}, {
key: 'setPlaneFromSelection',
value: function setPlaneFromSelection() {
var object = this.session.selector.getSelectedElements()[0];
if (object === undefined) return;
var plane = new _ccref2.default(this, object.userData.meta.id);
this.run((0, _highlevel.setPlaneCommands)(this.activeSketch, plane));
this.namedElements.plane.active = false;
this.session.selector.deactivate();
}
}, {
key: 'switchToOrthographicCamera',
value: function switchToOrthographicCamera(view, sketch) {
view.perspectiveControls = view.controls;
view.camera = new THREE.OrthographicCamera(0, 1, 1, 0);
sketch.localToWorld(view.camera.position.set(0, 0, 1000));
view.camera.up.transformDirection(sketch.matrixWorld);
view.camera.size = 1;
view.controls = view.controls.clone();
view.controls.noRotate = true;
view.controls.zoomMode = _orbit2.default.ZoomMode.Mouse;
view.controls.focus(sketch).zoom(200).now();
}
}, {
key: 'switchToPerspectiveCamera',
value: function switchToPerspectiveCamera(view) {
view.controls = view.perspectiveControls;
view.camera = view.controls.camera;
view.perspectiveControls = undefined;
}
}]);
return Sketcher;
}(_plugin2.default), _class.measurable = true, _temp);
exports.default = Sketcher;