@thewtex/vtk.js-esm
Version:
Visualization Toolkit for the Web
260 lines (198 loc) • 8.84 kB
JavaScript
import _defineProperty from '@babel/runtime/helpers/defineProperty';
import macro from '../../../macro.js';
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
// Proxy Registration Handling
// ----------------------------------------------------------------------------
function addRegistrationAPI(publicAPI, model) {
function registerProxy(proxy) {
if (!proxy) {
return;
}
model.proxyIdMapping[proxy.getProxyId()] = proxy;
var group = proxy.getProxyGroup();
if (!model.proxyByGroup[group]) {
model.proxyByGroup[group] = [];
}
if (model.proxyByGroup[group].indexOf(proxy) === -1) {
model.proxyByGroup[group].push(proxy);
}
proxy.setProxyManager(publicAPI); // Make sure we invoke event after the current execution path
macro.setImmediate(function () {
publicAPI.invokeProxyRegistrationChange({
action: 'register',
proxyId: proxy.getProxyId(),
proxyName: proxy.getProxyName(),
proxyGroup: proxy.getProxyGroup(),
proxy: proxy
});
});
} // --------------------------------------------------------------------------
function unRegisterProxy(proxyOrId) {
var id = proxyOrId.getProxyId ? proxyOrId.getProxyId() : proxyOrId;
var proxy = model.proxyIdMapping[id]; // Unregister proxy in any group
Object.keys(model.proxyByGroup).forEach(function (groupName) {
var proxyList = model.proxyByGroup[groupName];
var index = proxyList.indexOf(proxy);
if (index !== -1) {
proxyList.splice(index, 1);
}
});
delete model.proxyIdMapping[id];
proxy.gcPropertyLinks('application');
proxy.gcPropertyLinks('source');
proxy.setProxyManager(null);
publicAPI.invokeProxyRegistrationChange({
action: 'unregister',
proxyId: id,
proxyName: proxy.getProxyName(),
proxyGroup: proxy.getProxyGroup(),
proxy: proxy
});
return proxy;
} // --------------------------------------------------------------------------
publicAPI.setActiveSource = function (source) {
if (model.activeSource !== source) {
if (model.activeSourceSubscription) {
model.activeSourceSubscription.unsubscribe();
model.activeSourceSubscription = null;
}
model.activeSource = source;
if (source) {
model.activeSourceSubscription = source.onModified(publicAPI.modified);
}
publicAPI.modified();
publicAPI.invokeActiveSourceChange(source);
}
};
publicAPI.setActiveView = function (view) {
if (model.activeView !== view) {
if (model.activeViewSubscription) {
model.activeViewSubscription.unsubscribe();
model.activeViewSubscription = null;
}
model.activeView = view;
if (view) {
model.activeViewSubscription = view.onModified(publicAPI.modified);
}
publicAPI.modified();
publicAPI.invokeActiveViewChange(view);
}
}; // --------------------------------------------------------------------------
publicAPI.getProxyById = function (id) {
return model.proxyIdMapping[id];
}; // --------------------------------------------------------------------------
publicAPI.getProxyGroups = function () {
return Object.keys(model.proxyByGroup);
}; // --------------------------------------------------------------------------
publicAPI.getProxyInGroup = function (name) {
return [].concat(model.proxyByGroup[name] || []);
}; // --------------------------------------------------------------------------
publicAPI.getSources = function () {
return [].concat(model.proxyByGroup.Sources || []);
};
publicAPI.getRepresentations = function () {
return [].concat(model.proxyByGroup.Representations || []);
};
publicAPI.getViews = function () {
return [].concat(model.proxyByGroup.Views || []);
}; // --------------------------------------------------------------------------
publicAPI.createProxy = function (group, name, options) {
var definitions = model.proxyConfiguration.definitions;
if (!definitions[group] || !definitions[group][name]) {
return null;
}
var definition = definitions[group][name];
var definitionOptions = _objectSpread(_objectSpread({}, definition.options), options);
var proxy = definition.class.newInstance(_objectSpread(_objectSpread({}, definitionOptions), {}, {
proxyGroup: group,
proxyName: name,
proxyManager: publicAPI
})); // Handle proxy property settings
if (definition.proxyProps) {
var proxyMap = {};
Object.keys(definition.proxyProps).forEach(function (key) {
var newProxyDef = definition.proxyProps[key];
proxyMap[key] = publicAPI.createProxy(newProxyDef.group, newProxyDef.name, newProxyDef.options);
});
proxy.set(proxyMap);
} // Handle property setting
if (definition.props) {
proxy.set(definition.props);
}
registerProxy(proxy);
if (definitionOptions.activateOnCreate) {
proxy.activate();
}
return proxy;
}; // --------------------------------------------------------------------------
publicAPI.getRepresentation = function (source, view) {
var sourceToUse = source || publicAPI.getActiveSource();
var viewToUse = view || publicAPI.getActiveView(); // Can only get a representation for a source and a view
if (!sourceToUse || !viewToUse || !sourceToUse.getType()) {
return null;
}
var sourceId = sourceToUse.getProxyId();
var viewId = viewToUse.getProxyId();
var viewRepMap = model.sv2rMapping[sourceId];
if (!viewRepMap) {
viewRepMap = {};
model.sv2rMapping[sourceId] = viewRepMap;
}
var rep = viewRepMap[viewId];
if (!rep) {
var viewName = viewToUse.getProxyName();
var sourceType = sourceToUse.getType();
var definition = model.proxyConfiguration.representations[viewName][sourceType];
if (!definition) {
vtkErrorMacro("No definition for representation of ".concat(sourceType, " in view ").concat(viewName));
return null;
}
rep = publicAPI.createProxy('Representations', definition.name, definition.options);
model.r2svMapping[rep.getProxyId()] = {
sourceId: sourceId,
viewId: viewId
};
viewRepMap[viewId] = rep;
rep.setInput(sourceToUse);
viewToUse.addRepresentation(rep);
}
return rep;
}; // --------------------------------------------------------------------------
publicAPI.deleteProxy = function (proxy) {
var group = proxy.getProxyGroup().toLowerCase();
if (group === 'views') {
proxy.getRepresentations().forEach(function (repProxy) {
publicAPI.deleteProxy(repProxy);
});
proxy.setContainer(null);
unRegisterProxy(proxy);
if (publicAPI.getActiveView() === proxy) {
publicAPI.setActiveView(publicAPI.getViews()[0]);
}
} else if (group === 'representations') {
var _model$r2svMapping$pr = model.r2svMapping[proxy.getProxyId()],
sourceId = _model$r2svMapping$pr.sourceId,
viewId = _model$r2svMapping$pr.viewId;
var view = publicAPI.getProxyById(viewId);
view.removeRepresentation(proxy);
delete model.r2svMapping[proxy.getProxyId()];
delete model.sv2rMapping[sourceId][viewId];
unRegisterProxy(proxy);
} else if (group === 'sources') {
var viewToRep = model.sv2rMapping[proxy.getProxyId()];
Object.keys(viewToRep).forEach(function (viewId) {
publicAPI.deleteProxy(viewToRep[viewId]);
});
unRegisterProxy(proxy);
if (publicAPI.getActiveSource() === proxy) {
publicAPI.setActiveSource(publicAPI.getSources()[0]);
}
} else {
unRegisterProxy(proxy);
} // Delete the object itself
proxy.delete();
};
}
export default addRegistrationAPI;