moorhen 0.8.4 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moorhen",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "private": false,
   "main": "moorhen.js",
   "types": "./types/main.d.ts",
@@ -157,6 +157,7 @@
     "nightingale-linegraph-track": "^3.8.10",
     "node-fetch": "^2.7.0",
     "nodemon": "^2.0.22",
+    "notistack": "^3.0.1",
     "pako": "^2.1.0",
     "parcel-bundler": "^1.12.5",
     "pca-js": "^1.0.2",

package/types/libcoot.d.ts

@@ -435,7 +435,6 @@ export namespace libcootApi {
         x_size: number;
         y_size: number;
         z_position: number;
-        image_data: emscriptem.vector<number>;
     }
     type textureAsFloatsJS = {
         width: number;
@@ -443,7 +442,7 @@ export namespace libcootApi {
         x_size: number;
         y_size: number;
         z_position: number;
-        image_data: number[];
+        image_data: Float32Array;
     }
     type fitLigandInfo = {
         imol: number;
@@ -463,6 +462,7 @@ export namespace libcootApi {
         getNormalsFromSimpleMesh( arg0: any ): Float32Array;
         getReversedNormalsFromSimpleMesh( arg0: any ): Float32Array;
         getColoursFromSimpleMesh( arg0: any ): Float32Array;
+        getTextureArray( arg0: any, arg1: any ): void;
         getPositionsFromSimpleMesh2( arg0: any, arg1: any ): void;
         getNormalsFromSimpleMesh2( arg0: any, arg1: any ): void;
         getReversedNormalsFromSimpleMesh2( arg0: any, arg1: any ): void;
@@ -487,6 +487,7 @@ export namespace libcootApi {
         set_refinement_is_verbose(arg0: boolean): void;
         set_use_gemmi(arg0: boolean): void;
         get_use_gemmi(): boolean;
+        export_molecular_represenation_as_gltf(imol: number, cid: string, colourScheme: string, style: string, fileName: string): void;
         export_model_molecule_as_gltf(imol: number, cid: string, mode: string, isDark: boolean, bondWidth: number, atomRadius: number, bondSmoothness: number, drawHydrogens: boolean, drawMissingResidues: boolean, fileName: string): void;
         export_map_molecule_as_gltf(imol: number, x: number, y: number, z: number, radius: number, contourLevel: number, fileName: string): void;
         set_max_number_of_threads(arg0: number): void;

package/types/main.d.ts

@@ -1,10 +1,10 @@
 import { moorhen as _moorhen } from "./moorhen"
 import { webGL } from "./mgWebGL";
-import { libcootApi } from "./libcoot";
-import { gemmi } from "./gemmi";
-import { privateer } from "./privateer";
 
 declare module 'moorhen' {
+    let MoorhenStore: any;
+    module.exports = MoorhenStore
+
     let moleculesReducer: any;
     module.exports = moleculesReducer
 
@@ -37,10 +37,7 @@ declare module 'moorhen' {
     
     let activeModalsReducer: any;
     module.exports = activeModalsReducer
-    
-    let activePopUpsReducer: any;
-    module.exports = activePopUpsReducer
-    
+
     let mapContourSettingsReducer: any;
     module.exports = mapContourSettingsReducer
     
@@ -83,285 +80,33 @@ declare module 'moorhen' {
     let MoorhenFetchOnlineSourcesForm: any;
     module.exports = MoorhenFetchOnlineSourcesForm;
 
-
-    let MoorhenReduxProvider: any;
-    module.exports = MoorhenReduxProvider;
-
-    class MoorhenPreferences implements _moorhen.Preferences {
-        name: string;
+    interface MoorhenPreferences extends _moorhen.Preferences { }
+    class MoorhenPreferences implements MoorhenPreferences {
         static defaultPreferencesValues: _moorhen.PreferencesValues;
-        localStorageInstance: {
-            clear: () => void;
-            setItem: (key: string, value: any) => Promise<string>;
-            getItem: (key: string) => Promise<any>;
-        };   
     }
     module.exports.MoorhenPreferences = MoorhenPreferences
 
-    class MoorhenColourRule implements _moorhen.ColourRule {
+    interface MoorhenColourRule extends _moorhen.ColourRule { }
+    class MoorhenColourRule implements MoorhenColourRule {
         constructor(ruleType: string, cid: string, color: string, commandCentre: React.RefObject<_moorhen.CommandCentre>, isMultiColourRule?: boolean, applyColourToNonCarbonAtoms?: boolean)
-        ruleType: string;
-        cid: string;
-        color: string;
-        args: (string | number)[];
-        label: string;
-        isMultiColourRule: boolean;
-        commandCentre: React.RefObject<_moorhen.CommandCentre>;
-        parentMolecule: _moorhen.Molecule;
-        parentRepresentation: _moorhen.MoleculeRepresentation;
-        applyColourToNonCarbonAtoms: boolean;
-        uniqueId: string;
-        initFromDataObject(data: _moorhen.ColourRuleObject, commandCentre: React.RefObject<_moorhen.CommandCentre>, molecule: _moorhen.Molecule): _moorhen.ColourRule;
-        initFromString(stringData: string, commandCentre: React.RefObject<_moorhen.CommandCentre>, molecule: _moorhen.Molecule): _moorhen.ColourRule;
-        objectify(): _moorhen.ColourRuleObject;
-        stringify(): string;
-        setLabel(label: string): void;
-        setArgs(args: (string | number)[]): void;
-        setParentMolecule(molecule: _moorhen.Molecule): void;
-        setParentRepresentation(representation: _moorhen.MoleculeRepresentation): void;    
-        setApplyColourToNonCarbonAtoms(newVal: boolean): void;
-        getUserDefinedColours(): { cid: string; rgb: [number, number, number]; applyColourToNonCarbonAtoms: boolean }[];
-        apply(style: string, ruleIndex: number): Promise<void>;
     }
     module.exports.MoorhenColourRule = MoorhenColourRule
 
-    class MoorhenMoleculeRepresentation implements _moorhen.MoleculeRepresentation {
+    interface MoorhenMoleculeRepresentation extends _moorhen.MoleculeRepresentation { }
+    class MoorhenMoleculeRepresentation implements MoorhenMoleculeRepresentation {
         constructor(style: _moorhen.RepresentationStyles, cid: string, commandCentre: React.RefObject<_moorhen.CommandCentre>, glRef: React.RefObject<webGL.MGWebGL>)
-        addColourRule(ruleType: string, cid: string, color: string, args: (string | number)[], isMultiColourRule?: boolean, applyColourToNonCarbonAtoms?: boolean, label?: string): void;
-        getBufferObjects(): Promise<any>;
-        applyColourRules(): Promise<void>;
-        exportAsGltf(): Promise<ArrayBuffer>;
-        setBondOptions(bondOptions: _moorhen.cootBondOptions): void;
-        setStyle(style: string): void;
-        setUseDefaultColourRules(arg0: boolean): void;
-        setColourRules(ruleList: _moorhen.ColourRule[]): void;
-        buildBuffers(arg0: _moorhen.DisplayObject[]): Promise<void>;
-        setBuffers(meshObjects: _moorhen.DisplayObject[]): void;
-        drawSymmetry(): void
-        deleteBuffers(): void;
-        draw(): Promise<void>;
-        redraw(): Promise<void>;
-        setParentMolecule(arg0: _moorhen.Molecule): void;
-        show(): void;
-        hide(): void;
-        setAtomBuffers(arg0: _moorhen.AtomInfo[]): void;
-        bondOptions: _moorhen.cootBondOptions;
-        useDefaultColourRules: boolean;
-        useDefaultBondOptions: boolean;
-        uniqueId: string;
-        style: string;
-        cid: string;
-        visible: boolean;
-        buffers: _moorhen.DisplayObject[];
-        commandCentre: React.RefObject<_moorhen.CommandCentre>;
-        glRef: React.RefObject<webGL.MGWebGL>;
-        parentMolecule: _moorhen.Molecule;
-        colourRules: _moorhen.ColourRule[];
-        styleHasAtomBuffers: boolean;
-        styleHasSymmetry: boolean;
-        isCustom: boolean;
-        styleHasColourRules: boolean;
-        ligandsCid: string;
-        hoverColor: number[];
-        residueSelectionColor: number[];    
     }
     module.exports.MoorhenMoleculeRepresentation = MoorhenMoleculeRepresentation
 
-    class MoorhenMolecule implements _moorhen.Molecule {
+    interface MoorhenMolecule extends _moorhen.Molecule { }
+    class MoorhenMolecule implements MoorhenMolecule {
         constructor(commandCentre: React.RefObject<_moorhen.CommandCentre>, glRef: React.RefObject<webGL.MGWebGL>, store?: any, monomerLibrary?: string)
-        transferLigandDicts(toMolecule: _moorhen.Molecule, override?: boolean): Promise<void>;
-        minimizeEnergyUsingCidAnimated(cid: string, ncyc: number, nIterations: number, useRamaRestraints: boolean, ramaWeight: number, useTorsionRestraints: boolean, torsionWeight: number): Promise<void>;
-        addColourRule(ruleType: string, cid: string, color: string, args: (string | number)[], isMultiColourRule?: boolean, applyColourToNonCarbonAtoms?: boolean, label?: string): void;
-        splitMultiModels(draw?: boolean): Promise<_moorhen.Molecule[]>;
-        exportAsGltf(representationId: string): Promise<ArrayBuffer>;
-        getNonSelectedCids(cid: string): string[];
-        getSecondaryStructInfo(modelNumber?: number): Promise<libcootApi.ResidueSpecJS[]>;
-        parseCidIntoSelection(selectedCid: string): Promise<_moorhen.ResidueSelection>;
-        animateRefine(n_cyc: number, n_iteration: number, final_n_cyc?: number): Promise<void>;
-        refineResidueRange(chainId: string, start: number, stop: number, ncyc?: number, redraw?: boolean): Promise<void>;
-        SSMSuperpose(movChainId: string, refMolNo: number, refChainId: string): Promise<_moorhen.WorkerResponse>;
-        deleteCid(cid: string, redraw?: boolean): Promise<{first: number, second: number}>;
-        getNumberOfAtoms(): Promise<number>;
-        moveMoleculeHere(x: number, y: number, z: number): Promise<void>;
-        checkHasGlycans(): Promise<boolean>;
-        fitLigand(mapMolNo: number, ligandMolNo: number, fitRightHere?: boolean, redraw?: boolean, useConformers?: boolean, conformerCount?: number): Promise<_moorhen.Molecule[]>;
-        checkIsLigand(): boolean;
-        removeRepresentation(representationId: string): void;
-        addRepresentation(style: string, cid: string, isCustom?: boolean, colour?: _moorhen.ColourRule[], bondOptions?: _moorhen.cootBondOptions): Promise<_moorhen.MoleculeRepresentation>;
-        getNeighborResiduesCids(selectionCid: string, maxDist: number): Promise<string[]>;
-        drawWithStyleFromMesh(style: string, meshObjects: any[], cid?: string, fetchAtomBuffers?: boolean): Promise<void>;
-        updateWithMovedAtoms(movedResidues: _moorhen.AtomInfo[][]): Promise<void>;
-        transformedCachedAtomsAsMovedAtoms(selectionCid?: string): _moorhen.AtomInfo[][];
-        copyFragmentUsingCid(cid: string, doRecentre?: boolean, style?: string): Promise<_moorhen.Molecule>;
-        hideCid(cid: string, redraw?: boolean): Promise<void>;
-        unhideAll(redraw?: boolean): Promise<void>;
-        drawUnitCell(): void;
-        gemmiAtomsForCid: (cid: string, omitExcludedCids?: boolean) => Promise<_moorhen.AtomInfo[]>;
-        mergeMolecules(otherMolecules: _moorhen.Molecule[], doHide?: boolean): Promise<void>;
-        setBackgroundColour(backgroundColour: [number, number, number, number]): void;
-        addDict(fileContent: string): Promise<void>;
-        addDictShim(fileContent: string): void;
-        toggleSymmetry(): Promise<void>;
-        toggleBiomolecule(): void;
-        getDict(newTlc: string): string;
-        addLigandOfType(resType: string, fromMolNo?: number): Promise<_moorhen.WorkerResponse>;
-        updateAtoms(): Promise<void>;
-        rigidBodyFit(cidsString: string, mapNo: number, redraw?: boolean): Promise<void>;
-        generateSelfRestraints(cid?: string, maxRadius?: number): Promise<void>;
-        clearExtraRestraints(): Promise<_moorhen.WorkerResponse>;
-        refineResiduesUsingAtomCid(cid: string, mode: string, ncyc?: number, redraw?: boolean): Promise<void>;
-        getNcsRelatedChains(): Promise<string[][]>;
-        getResidueBFactors(): { cid: string; bFactor: number; normalised_bFactor: number }[];
-        redo(): Promise<void>;
-        undo(): Promise<void>;
-        show(style: string, cid?: string): void;
-        setSymmetryRadius(radius: number): Promise<void>;
-        drawSymmetry: (fetchSymMatrix?: boolean) => Promise<void>;
-        drawBiomolecule (fetchSymMatrix?: boolean) : void;
-        getUnitCellParams():  { a: number; b: number; c: number; alpha: number; beta: number; gamma: number; };
-        replaceModelWithFile(fileUrl: string): Promise<void>;
-        replaceModelWithCoordData(coordData: string): Promise<void>;
-        delete(popBackImol?: boolean): Promise<_moorhen.WorkerResponse>;
-        fetchDefaultColourRules(): Promise<void>;
-        fetchIfDirtyAndDraw(arg0: string): Promise<void>;
-        drawEnvironment: (cid: string, labelled?: boolean) => Promise<void>;
-        centreOn: (selectionCid?: string, animate?: boolean, setZoom?: boolean) => Promise<void>;
-        drawHover: (cid: string) => Promise<void>;
-        drawResidueSelection: (cid: string) => Promise<void>;
-        clearBuffersOfStyle: (style: string) => void;
-        loadToCootFromURL: (inputFile: string, molName: string, options?: RequestInit) => Promise<_moorhen.Molecule>;
-        applyTransform: () => Promise<void>;
-        getAtoms(format?: string): Promise<string>;
-        hide: (style: string, cid?: string) => void;
-        redraw: () => Promise<void>;
-        setAtomsDirty: (newVal: boolean) => void;
-        isVisible: (excludeBuffers?: string[]) => boolean;
-        centreAndAlignViewOn: (selectionCid: string, alignWithCB?: boolean, zoomLevel?: number) => Promise<void>;
-        buffersInclude: (bufferIn: { id: string; }) => boolean;
-        redrawRepresentation: (id: string) => Promise<void>;
-        downloadAtoms(format?: 'mmcif' | 'pdb'): Promise<void>;
-        mergeFragmentFromRefinement(cid: string, fragmentMolecule: _moorhen.Molecule, acceptTransform?: boolean, refineAfterMerge?: boolean): Promise<void>;
-        copyFragmentForRefinement(cid: string[], refinementMap: _moorhen.Map, redraw?: boolean, readrawFragmentFirst?: boolean): Promise<_moorhen.Molecule>;
-        refineResiduesUsingAtomCidAnimated(cid: string, activeMap: _moorhen.Map, dist?: number, redraw?: boolean, redrawFragmentFirst?: boolean): Promise<void>;
-        getPrivateerValidation(useCache?: boolean): Promise<privateer.ResultsEntry[]>;
-        getLigandSVG(resName: string, useCache?: boolean): Promise<string>;
-        isValidSelection(cid: string): Promise<boolean>;
-        changeChainId(oldId: string, newId: string, redraw?: boolean, startResNo?: number, endResNo?: number): Promise<number>;
-        redrawAdaptativeBonds(selectionString?: string, maxDist?: number): Promise<void>;
-        setDrawAdaptativeBonds(newValue: boolean): Promise<void>;
-        getActiveAtom(): Promise<string>;
-        adaptativeBondsEnabled: boolean;
-        cachedLigandSVGs: {[key: string]: string};
-        cachedGemmiAtoms: _moorhen.AtomInfo[];
-        cachedPrivateerValidation: privateer.ResultsEntry[];
-        isLigand: boolean;
-        type: string;
-        excludedCids: string[];
-        commandCentre: React.RefObject<_moorhen.CommandCentre>;
-        glRef: React.RefObject<webGL.MGWebGL>;
-        store: any;
-        atomsDirty: boolean;
-        name: string;
-        molNo: number;
-        gemmiStructure: gemmi.Structure;
-        sequences: _moorhen.Sequence[];
-        ligands: _moorhen.LigandInfo[];
-        atomCount: number;
-        ligandDicts: {[comp_id: string]: string};
-        connectedToMaps: number[];
-        excludedSelections: string[];
-        symmetryOn: boolean;
-        biomolOn: boolean;
-        symmetryRadius : number;
-        symmetryMatrices: number[][][];
-        gaussianSurfaceSettings: {
-            sigma: number;
-            countourLevel: number;
-            boxRadius: number;
-            gridScale: number;
-            bFactor: number;
-        };
-        isDarkBackground: boolean;
-        representations: _moorhen.MoleculeRepresentation[];
-        defaultBondOptions: _moorhen.cootBondOptions;
-        displayObjectsTransformation: { origin: [number, number, number], quat: any, centre: [number, number, number] }
-        uniqueId: string;
-        defaultColourRules: _moorhen.ColourRule[];
-        restraints: {maxRadius: number, cid: string}[];
-        monomerLibraryPath: string;
-        adaptativeBondsRepresentation: _moorhen.MoleculeRepresentation;
-        hoverRepresentation: _moorhen.MoleculeRepresentation;
-        unitCellRepresentation: _moorhen.MoleculeRepresentation;
-        environmentRepresentation: _moorhen.MoleculeRepresentation;
-        selectionRepresentation: _moorhen.MoleculeRepresentation;
-        hasDNA: boolean;
-        hasGlycans: boolean;
-        coordsFormat: _moorhen.coorFormats;
-        moleculeDiameter: number;
     }
     module.exports.MoorhenMolecule = MoorhenMolecule
     
-    class MoorhenMap implements _moorhen.Map {
+    interface MoorhenMap extends _moorhen.Map { }
+    class MoorhenMap implements MoorhenMap {
         constructor(commandCentre: React.RefObject<_moorhen.CommandCentre>, glRef: React.RefObject<webGL.MGWebGL>, store?: any)
-        exportAsGltf(): Promise<ArrayBuffer>;
-        getHistogram(nBins?: number, zoomFactor?: number): Promise<libcootApi.HistogramInfoJS>;
-        setMapWeight(weight?: number): Promise<_moorhen.WorkerResponse>;
-        estimateMapWeight(): Promise<void>;
-        fetchMapAlphaAndRedraw(): Promise<void>;
-        centreOnMap(): Promise<void>;
-        getSuggestedSettings(): Promise<void>;
-        copyMap(): Promise<_moorhen.Map>;
-        hideMapContour(): void;
-        drawMapContour(): Promise<void>;
-        getMapContourParams(): { 
-            mapRadius: number; 
-            contourLevel: number; 
-            mapAlpha: number; 
-            mapStyle: "lines" | "solid" | "lit-lines"; 
-            mapColour: {r: number; g: number; b: number}; 
-            positiveMapColour: {r: number; g: number; b: number}; 
-            negativeMapColour: {r: number; g: number; b: number}
-        };
-        fetchColourAndRedraw(): Promise<void> ;
-        fetchDiffMapColourAndRedraw(type: 'positiveDiffColour' | 'negativeDiffColour'): Promise<void> ;
-        fetchMapRmsd(): Promise<number>;
-        fetchSuggestedLevel(): Promise<number>;
-        fetchMapCentre(): Promise<[number, number, number]>;
-        replaceMapWithMtzFile(fileUrl: RequestInfo | URL, selectedColumns: _moorhen.selectedMtzColumns): Promise<void>;
-        associateToReflectionData (selectedColumns: _moorhen.selectedMtzColumns, reflectionData: Uint8Array | ArrayBuffer): Promise<void>;
-        delete(): Promise<void> 
-        doCootContour(x: number, y: number, z: number, radius: number, contourLevel: number, style: "lines" | "lit-lines" | "solid"): Promise<void>;
-        fetchReflectionData(): Promise<_moorhen.WorkerResponse<Uint8Array>>;
-        getMap(): Promise<_moorhen.WorkerResponse>;
-        loadToCootFromMtzURL(url: RequestInfo | URL, name: string, selectedColumns: _moorhen.selectedMtzColumns, options?: RequestInit): Promise<_moorhen.Map>;
-        loadToCootFromMapURL(url: RequestInfo | URL, name: string, isDiffMap?: boolean, decompress?: boolean, options?: RequestInit): Promise<_moorhen.Map>;
-        setActive(): Promise<void>;
-        setupContourBuffers(objects: any[], keepCootColours?: boolean): void;
-        setOtherMapForColouring(molNo: number, min?: number, max?: number): void;
-        store: any;
-        isEM: boolean;
-        suggestedContourLevel: number;
-        suggestedRadius: number;
-        mapCentre: [number, number, number];
-        type: string;
-        name: string;
-        molNo: number;
-        commandCentre: React.RefObject<_moorhen.CommandCentre>;
-        glRef: React.RefObject<webGL.MGWebGL>;
-        webMGContour: boolean;
-        showOnLoad: boolean;
-        displayObjects: any;
-        isDifference: boolean;
-        hasReflectionData: boolean;
-        selectedColumns: _moorhen.selectedMtzColumns;
-        associatedReflectionFileName: string;
-        uniqueId: string;
-        otherMapForColouring: {molNo: number, min: number, max: number};
-        mapRmsd: number;
-        suggestedMapWeight: number;
-        defaultMapColour: {r: number, g: number, b: number};
-        defaultPositiveMapColour: {r: number, g: number, b: number};
-        defaultNegativeMapColour: {r: number, g: number, b: number};
     }
     module.exports.MoorhenMap = MoorhenMap
 
@@ -391,6 +136,18 @@ declare module 'moorhen' {
     ): Promise<number>;
     module.exports = loadSessionFromProtoMessage;
 
+    function loadSessionFromArrayBuffer(
+        sessionArrayBuffer: ArrayBuffer,
+        monomerLibraryPath: string,
+        molecules: _moorhen.Molecule[],
+        maps: _moorhen.Map[],
+        commandCentre: React.RefObject<_moorhen.CommandCentre>,
+        timeCapsuleRef: React.RefObject<_moorhen.TimeCapsule>,
+        glRef: React.RefObject<webGL.MGWebGL>,
+        store: any,
+        dispatch: (reduxStoreAction: any) => void,
+    ): Promise<number>;
+    module.exports = loadSessionFromArrayBuffer;
 
     function loadSessionData(
         sessionData: _moorhen.backupSession,
@@ -540,9 +297,6 @@ declare module 'moorhen' {
     function setBackgroundColor(arg0: [number, number, number, number]): any;
     module.exports = setBackgroundColor;
 
-    function setNotificationContent(arg0: JSX.Element): any;
-    module.exports = setNotificationContent;
-
     function setActiveMap(arg0: _moorhen.Map): any;
     module.exports = setActiveMap;
 
@@ -702,9 +456,6 @@ declare module 'moorhen' {
     function unFocusModal(): any;
     module.exports = unFocusModal;
     
-    function resetActivePopUps(): any;
-    module.exports = resetActivePopUps;
-    
     function resetSharedSession(): any;
     module.exports = resetSharedSession;
 }

package/types/mgWebGL.d.ts

@@ -106,6 +106,7 @@ export namespace webGL {
         initOutlineShaders(vertexShader : string, fragmentShader : string)  : void;
         initShaders(vertexShader : string, fragmentShader : string)  : void;
         initShadersTextured(vertexShader : string, fragmentShader : string)  : void;
+        initShadersDepthPeelAccum(vertexShader : string, fragmentShader : string)  : void;
         initGBufferShaders(vertexShader : string, fragmentShader : string)  : void;
         initGBufferShadersInstanced(vertexShader : string, fragmentShader : string)  : void;
         initGBufferShadersPerfectSphere(vertexShader : string, fragmentShader : string)  : void;
@@ -165,6 +166,7 @@ export namespace webGL {
         setEdgeDetectNormalScale(normalScale: number): void;
         setOccludeDiffuse(doOccludeDiffuse: boolean): void;
         setOutlinesOn(doOutline: boolean): void;
+        setDoOrderIndependentTransparency(doOutline: boolean): void;
         setSpinTestState(doSpinTest: boolean): void;
         setBlurSize(blurSize: number): void;
         setSSAORadius(radius: number): void;
@@ -190,6 +192,7 @@ export namespace webGL {
         createGBuffers(width : number,height : number) : void;
         createEdgeDetectFramebufferBuffer(width : number,height : number) : void;
         recreateOffScreeenBuffers(width: number,  height: number) : void;
+        recreateDepthPeelBuffers(width: number,  height: number) : void;
         createSimpleBlurOffScreeenBuffers() : void;
         draggableMolecule: moorhen.Molecule
         activeMolecule: moorhen.Molecule
@@ -226,6 +229,7 @@ export namespace webGL {
         gBuffersFramebufferSize : number;
         save_pixel_data: boolean;
         renderToTexture: boolean;
+        doDepthPeelPass: boolean;
         showShortCutHelp: string[];
         WEBGL2: boolean;
         doRedraw: boolean;
@@ -273,6 +277,8 @@ export namespace webGL {
         xPixelOffset: number;
         yPixelOffset: number;
         occludeDiffuse: boolean;
+        doOrderIndependentTransparency: boolean;
+        doPeel: boolean;
         doShadowDepthDebug: boolean;
         doSpin: boolean;
         doStenciling: boolean;
@@ -342,6 +348,9 @@ export namespace webGL {
         ssaoRadius: number;
         ssaoBias: number;
         offScreenFramebuffer: MGWebGLFrameBuffer;
+        depthPeelFramebuffers: MGWebGLFrameBuffer[];
+        depthPeelColorTextures: WebGLTexture[];
+        depthPeelDepthTextures: WebGLTexture[];
         offScreenFramebufferBlurX: MGWebGLFrameBuffer;
         offScreenFramebufferBlurY: MGWebGLFrameBuffer;
         offScreenFramebufferSimpleBlurX: MGWebGLFrameBuffer;
@@ -350,6 +359,8 @@ export namespace webGL {
         offScreenReady: boolean;
         offScreenRenderbufferColor: WebGLRenderbuffer;
         offScreenRenderbufferDepth: WebGLRenderbuffer;
+        depthPeelRenderbufferColor: WebGLRenderbuffer[];
+        depthPeelRenderbufferDepth: WebGLRenderbuffer[];
         offScreenTexture: WebGLTexture;
         pMatrix: Float32Array;
         pmvMatrix: Float32Array;
@@ -365,6 +376,7 @@ export namespace webGL {
         rttDepthTexture: WebGLTexture;
         screenZ: number;
         shaderProgramTextured: MGWebGLTextureQuadShader;
+        shaderProgramDepthPeelAccum: MGWebGLShaderDepthPeelAccum;
         shaderProgram: ShaderTriangles;
         shaderProgramGBuffers: ShaderGBuffersTriangles;
         shaderProgramGBuffersInstanced: ShaderGBuffersTrianglesInstanced;

package/types/moorhen.d.ts

@@ -162,10 +162,11 @@ export namespace moorhen {
         unhideAll(redraw?: boolean): Promise<void>;
         drawUnitCell(): void;
         gemmiAtomsForCid: (cid: string, omitExcludedCids?: boolean) => Promise<AtomInfo[]>;
-        mergeMolecules(otherMolecules: Molecule[], doHide?: boolean): Promise<void>;
+        mergeMolecules(otherMolecules: Molecule[], doHide?: boolean, doRedraw?: boolean): Promise<void>;
+        copyMolecule(doRedraw?: boolean): Promise<Molecule>;
         setBackgroundColour(backgroundColour: [number, number, number, number]): void;
         addDict(fileContent: string): Promise<void>;
-        addDictShim(fileContent: string): void;
+        cacheLigandDict(fileContent: string): void;
         toggleSymmetry(): Promise<void>;
         toggleBiomolecule(): void;
         getDict(newTlc: string): string;
@@ -451,6 +452,7 @@ export namespace moorhen {
         fetchColourAndRedraw(): Promise<void> ;
         fetchDiffMapColourAndRedraw(type: 'positiveDiffColour' | 'negativeDiffColour'): Promise<void> ;
         fetchMapRmsd(): Promise<number>;
+        fetchMapMean(): Promise<number>;
         fetchSuggestedLevel(): Promise<number>;
         fetchMapCentre(): Promise<[number, number, number]>;
         replaceMapWithMtzFile(fileUrl: RequestInfo | URL, selectedColumns: selectedMtzColumns): Promise<void>;
@@ -465,6 +467,7 @@ export namespace moorhen {
         setupContourBuffers(objects: any[], keepCootColours?: boolean): void;
         setOtherMapForColouring(molNo: number, min?: number, max?: number): void;
         exportAsGltf(): Promise<ArrayBuffer>;
+        static autoReadMtz(source: File, commandCentre: React.RefObject<CommandCentre>, glRef: React.RefObject<webGL.MGWebGL>, store: ToolkitStore): Promise<Map[]>;
         store: ToolkitStore;
         isEM: boolean;
         suggestedContourLevel: number;
@@ -485,6 +488,7 @@ export namespace moorhen {
         uniqueId: string;
         otherMapForColouring: {molNo: number, min: number, max: number};
         mapRmsd: number;
+        mapMean: number;
         suggestedMapWeight: number;
         defaultMapColour: {r: number, g: number, b: number};
         defaultPositiveMapColour: {r: number, g: number, b: number};
@@ -893,10 +897,10 @@ export namespace moorhen {
             userPreferencesMounted: boolean;
             appTitle: string;
             cootInitialized: boolean;
-            notificationContent: JSX.Element;
             activeMap: Map;
             theme: string;
             residueSelection: ResidueSelection;
+            isShowingTomograms: boolean;
             isAnimatingTrajectory: boolean;
             isChangingRotamers: boolean;
             isDraggingAtoms: boolean;
@@ -915,18 +919,6 @@ export namespace moorhen {
             hoveredAtom: HoveredAtom;
             cursorStyle: string;
         };
-        activePopUps: {
-            goToResiduePopUp: {
-                show: boolean;
-            };
-            matchingLigandPopUp: {
-                show: boolean;
-                refMolNo: number;
-                movingMolNo: number;
-                refLigandCid: string;
-                movingLigandCid: string;
-              }
-        };
         activeModals: {
             showModelsModal: boolean;
             showMapsModal: boolean;
@@ -974,6 +966,8 @@ export namespace moorhen {
             defaultUpdatingScores: string[];
             showScoresToast: boolean;
             moleculeUpdate: { switch: boolean, molNo: number };
+            currentScores: { rFactor: number; rFree: number; moorhenPoints: number; };
+            currentScoreDiffs: { rFactor: number; rFree: number; moorhenPoints: number; };
         };
         refinementSettings: {
             useRamaRefinementRestraints: boolean;