molstar
Version:
A comprehensive macromolecular library.
255 lines • 15.4 kB
JavaScript
"use strict";
/**
* Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.tryCreateAssemblySymmetry = exports.AssemblySymmetryPreset = exports.AssemblySymmetryPresetParams = exports.AssemblySymmetry3D = exports.InitAssemblySymmetry3D = exports.RCSBAssemblySymmetry = void 0;
var tslib_1 = require("tslib");
var param_definition_1 = require("../../../mol-util/param-definition");
var prop_1 = require("./prop");
var behavior_1 = require("../../../mol-plugin/behavior/behavior");
var representation_1 = require("./representation");
var color_1 = require("./color");
var objects_1 = require("../../../mol-plugin-state/objects");
var mol_task_1 = require("../../../mol-task");
var mol_state_1 = require("../../../mol-state");
var ui_1 = require("./ui");
var representation_preset_1 = require("../../../mol-plugin-state/builder/structure/representation-preset");
var Tag = prop_1.AssemblySymmetry.Tag;
exports.RCSBAssemblySymmetry = behavior_1.PluginBehavior.create({
name: 'rcsb-assembly-symmetry-prop',
category: 'custom-props',
display: {
name: 'Assembly Symmetry',
description: 'Assembly Symmetry data calculated with BioJava, obtained via RCSB PDB.'
},
ctor: /** @class */ (function (_super) {
(0, tslib_1.__extends)(class_1, _super);
function class_1() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.provider = prop_1.AssemblySymmetryProvider;
return _this;
}
class_1.prototype.register = function () {
this.ctx.state.data.actions.add(exports.InitAssemblySymmetry3D);
this.ctx.customStructureProperties.register(this.provider, this.params.autoAttach);
this.ctx.representation.structure.themes.colorThemeRegistry.add(color_1.AssemblySymmetryClusterColorThemeProvider);
this.ctx.genericRepresentationControls.set(Tag.Representation, function (selection) {
var refs = [];
selection.structures.forEach(function (structure) {
var _a;
var symmRepr = (_a = structure.genericRepresentations) === null || _a === void 0 ? void 0 : _a.filter(function (r) { return r.cell.transform.transformer.id === AssemblySymmetry3D.id; })[0];
if (symmRepr)
refs.push(symmRepr);
});
return [refs, 'Symmetries'];
});
this.ctx.customStructureControls.set(Tag.Representation, ui_1.AssemblySymmetryControls);
this.ctx.builders.structure.representation.registerPreset(exports.AssemblySymmetryPreset);
};
class_1.prototype.update = function (p) {
var updated = this.params.autoAttach !== p.autoAttach;
this.params.autoAttach = p.autoAttach;
this.ctx.customStructureProperties.setDefaultAutoAttach(this.provider.descriptor.name, this.params.autoAttach);
return updated;
};
class_1.prototype.unregister = function () {
this.ctx.state.data.actions.remove(exports.InitAssemblySymmetry3D);
this.ctx.customStructureProperties.unregister(this.provider.descriptor.name);
this.ctx.representation.structure.themes.colorThemeRegistry.remove(color_1.AssemblySymmetryClusterColorThemeProvider);
this.ctx.genericRepresentationControls.delete(Tag.Representation);
this.ctx.customStructureControls.delete(Tag.Representation);
this.ctx.builders.structure.representation.unregisterPreset(exports.AssemblySymmetryPreset);
};
return class_1;
}(behavior_1.PluginBehavior.Handler)),
params: function () { return ({
autoAttach: param_definition_1.ParamDefinition.Boolean(false),
serverUrl: param_definition_1.ParamDefinition.Text(prop_1.AssemblySymmetry.DefaultServerUrl)
}); }
});
//
exports.InitAssemblySymmetry3D = mol_state_1.StateAction.build({
display: {
name: 'Assembly Symmetry',
description: 'Initialize Assembly Symmetry axes and cage. Data calculated with BioJava, obtained via RCSB PDB.'
},
from: objects_1.PluginStateObject.Molecule.Structure,
isApplicable: function (a) { return prop_1.AssemblySymmetry.isApplicable(a.data); }
})(function (_a, plugin) {
var a = _a.a, ref = _a.ref, state = _a.state;
return mol_task_1.Task.create('Init Assembly Symmetry', function (ctx) { return (0, tslib_1.__awaiter)(void 0, void 0, void 0, function () {
var propCtx, assemblySymmetryData, symmetryIndex, e_1, tree;
return (0, tslib_1.__generator)(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
propCtx = { runtime: ctx, assetManager: plugin.managers.asset };
return [4 /*yield*/, prop_1.AssemblySymmetryDataProvider.attach(propCtx, a.data)];
case 1:
_a.sent();
assemblySymmetryData = prop_1.AssemblySymmetryDataProvider.get(a.data).value;
symmetryIndex = assemblySymmetryData ? prop_1.AssemblySymmetry.firstNonC1(assemblySymmetryData) : -1;
return [4 /*yield*/, prop_1.AssemblySymmetryProvider.attach(propCtx, a.data, { symmetryIndex: symmetryIndex })];
case 2:
_a.sent();
return [3 /*break*/, 4];
case 3:
e_1 = _a.sent();
plugin.log.error("Assembly Symmetry: " + e_1);
return [2 /*return*/];
case 4:
tree = state.build().to(ref)
.applyOrUpdateTagged(prop_1.AssemblySymmetry.Tag.Representation, AssemblySymmetry3D);
return [4 /*yield*/, state.updateTree(tree).runInContext(ctx)];
case 5:
_a.sent();
return [2 /*return*/];
}
});
}); });
});
var AssemblySymmetry3D = objects_1.PluginStateTransform.BuiltIn({
name: Tag.Representation,
display: {
name: 'Assembly Symmetry',
description: 'Assembly Symmetry axes and cage. Data calculated with BioJava, obtained via RCSB PDB.'
},
from: objects_1.PluginStateObject.Molecule.Structure,
to: objects_1.PluginStateObject.Shape.Representation3D,
params: function (a) {
return (0, tslib_1.__assign)({}, representation_1.AssemblySymmetryParams);
}
})({
canAutoUpdate: function (_a) {
var oldParams = _a.oldParams, newParams = _a.newParams;
return true;
},
apply: function (_a, plugin) {
var _this = this;
var a = _a.a, params = _a.params;
return mol_task_1.Task.create('Assembly Symmetry', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
var assemblySymmetry, repr, type, kind, symbol;
var _a;
return (0, tslib_1.__generator)(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, prop_1.AssemblySymmetryProvider.attach({ runtime: ctx, assetManager: plugin.managers.asset }, a.data)];
case 1:
_b.sent();
assemblySymmetry = prop_1.AssemblySymmetryProvider.get(a.data).value;
if (!assemblySymmetry || assemblySymmetry.symbol === 'C1') {
return [2 /*return*/, mol_state_1.StateObject.Null];
}
repr = (0, representation_1.AssemblySymmetryRepresentation)((0, tslib_1.__assign)({ webgl: (_a = plugin.canvas3d) === null || _a === void 0 ? void 0 : _a.webgl }, plugin.representation.structure.themes), function () { return representation_1.AssemblySymmetryParams; });
return [4 /*yield*/, repr.createOrUpdate(params, a.data).runInContext(ctx)];
case 2:
_b.sent();
type = assemblySymmetry.type, kind = assemblySymmetry.kind, symbol = assemblySymmetry.symbol;
return [2 /*return*/, new objects_1.PluginStateObject.Shape.Representation3D({ repr: repr, sourceData: a.data }, { label: kind, description: type + " (" + symbol + ")" })];
}
});
}); });
},
update: function (_a, plugin) {
var _this = this;
var a = _a.a, b = _a.b, newParams = _a.newParams;
return mol_task_1.Task.create('Assembly Symmetry', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
var assemblySymmetry, props, type, kind, symbol;
return (0, tslib_1.__generator)(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, prop_1.AssemblySymmetryProvider.attach({ runtime: ctx, assetManager: plugin.managers.asset }, a.data)];
case 1:
_a.sent();
assemblySymmetry = prop_1.AssemblySymmetryProvider.get(a.data).value;
if (!assemblySymmetry || assemblySymmetry.symbol === 'C1') {
// this should NOT be StateTransformer.UpdateResult.Null
// because that keeps the old object
return [2 /*return*/, mol_state_1.StateTransformer.UpdateResult.Recreate];
}
props = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, b.data.repr.props), newParams);
return [4 /*yield*/, b.data.repr.createOrUpdate(props, a.data).runInContext(ctx)];
case 2:
_a.sent();
b.data.sourceData = a.data;
type = assemblySymmetry.type, kind = assemblySymmetry.kind, symbol = assemblySymmetry.symbol;
b.label = kind;
b.description = type + " (" + symbol + ")";
return [2 /*return*/, mol_state_1.StateTransformer.UpdateResult.Updated];
}
});
}); });
},
isApplicable: function (a) {
return prop_1.AssemblySymmetry.isApplicable(a.data);
}
});
exports.AssemblySymmetry3D = AssemblySymmetry3D;
//
exports.AssemblySymmetryPresetParams = (0, tslib_1.__assign)({}, representation_preset_1.StructureRepresentationPresetProvider.CommonParams);
exports.AssemblySymmetryPreset = (0, representation_preset_1.StructureRepresentationPresetProvider)({
id: 'preset-structure-representation-rcsb-assembly-symmetry',
display: {
name: 'Assembly Symmetry', group: 'Annotation',
description: 'Shows Assembly Symmetry axes and cage; colors structure according to assembly symmetry cluster membership. Data calculated with BioJava, obtained via RCSB PDB.'
},
isApplicable: function (a) {
return prop_1.AssemblySymmetry.isApplicable(a.data);
},
params: function () { return exports.AssemblySymmetryPresetParams; },
apply: function (ref, params, plugin) {
var _a;
return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
var structureCell, structure, assemblySymmetry, colorTheme, preset;
var _this = this;
return (0, tslib_1.__generator)(this, function (_b) {
switch (_b.label) {
case 0:
structureCell = mol_state_1.StateObjectRef.resolveAndCheck(plugin.state.data, ref);
structure = (_a = structureCell === null || structureCell === void 0 ? void 0 : structureCell.obj) === null || _a === void 0 ? void 0 : _a.data;
if (!structureCell || !structure)
return [2 /*return*/, {}];
if (!!prop_1.AssemblySymmetryDataProvider.get(structure).value) return [3 /*break*/, 2];
return [4 /*yield*/, plugin.runTask(mol_task_1.Task.create('Assembly Symmetry', function (runtime) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
var propCtx, assemblySymmetryData, symmetryIndex;
return (0, tslib_1.__generator)(this, function (_a) {
switch (_a.label) {
case 0:
propCtx = { runtime: runtime, assetManager: plugin.managers.asset };
return [4 /*yield*/, prop_1.AssemblySymmetryDataProvider.attach(propCtx, structure)];
case 1:
_a.sent();
assemblySymmetryData = prop_1.AssemblySymmetryDataProvider.get(structure).value;
symmetryIndex = assemblySymmetryData ? prop_1.AssemblySymmetry.firstNonC1(assemblySymmetryData) : -1;
return [4 /*yield*/, prop_1.AssemblySymmetryProvider.attach(propCtx, structure, { symmetryIndex: symmetryIndex })];
case 2:
_a.sent();
return [2 /*return*/];
}
});
}); }))];
case 1:
_b.sent();
_b.label = 2;
case 2: return [4 /*yield*/, tryCreateAssemblySymmetry(plugin, structureCell)];
case 3:
assemblySymmetry = _b.sent();
colorTheme = assemblySymmetry.isOk ? Tag.Cluster : undefined;
return [4 /*yield*/, representation_preset_1.PresetStructureRepresentations.auto.apply(ref, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, params), { theme: { globalName: colorTheme, focus: { name: colorTheme } } }), plugin)];
case 4:
preset = _b.sent();
return [2 /*return*/, { components: preset.components, representations: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, preset.representations), { assemblySymmetry: assemblySymmetry }) }];
}
});
});
}
});
function tryCreateAssemblySymmetry(plugin, structure, params, initialState) {
var state = plugin.state.data;
var assemblySymmetry = state.build().to(structure)
.applyOrUpdateTagged(prop_1.AssemblySymmetry.Tag.Representation, AssemblySymmetry3D, params, { state: initialState });
return assemblySymmetry.commit({ revertOnError: true });
}
exports.tryCreateAssemblySymmetry = tryCreateAssemblySymmetry;
//# sourceMappingURL=behavior.js.map