TmMolStar/src/mol-theme/color.ts

/**
 * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 */

import { Color } from 'mol-util/color';
import { Location } from 'mol-model/location';
import { ColorType } from 'mol-geo/geometry/color-data';
import { CarbohydrateSymbolColorThemeProvider } from './color/carbohydrate-symbol';
import { UniformColorThemeProvider } from './color/uniform';
import { deepEqual } from 'mol-util';
import { ParamDefinition as PD } from 'mol-util/param-definition';
import { ThemeDataContext } from './theme';
import { ChainIdColorThemeProvider } from './color/chain-id';
import { CrossLinkColorThemeProvider } from './color/cross-link';
import { ElementIndexColorThemeProvider } from './color/element-index';
import { ElementSymbolColorThemeProvider } from './color/element-symbol';
import { MoleculeTypeColorThemeProvider } from './color/molecule-type';
import { PolymerIdColorThemeProvider } from './color/polymer-id';
import { PolymerIndexColorThemeProvider } from './color/polymer-index';
import { ResidueNameColorThemeProvider } from './color/residue-name';
import { SecondaryStructureColorThemeProvider } from './color/secondary-structure';
import { SequenceIdColorThemeProvider } from './color/sequence-id';
import { ShapeGroupColorThemeProvider } from './color/shape-group';
import { UnitIndexColorThemeProvider } from './color/unit-index';
import { ScaleLegend } from 'mol-util/color/scale';
import { TableLegend } from 'mol-util/color/tables';

export type LocationColor = (location: Location, isSecondary: boolean) => Color

export type ColorThemeProps = { [k: string]: any }

export { ColorTheme }
interface ColorTheme<P extends PD.Params = {}> {
    readonly factory: ColorTheme.Factory<P>
    readonly granularity: ColorType
    readonly color: LocationColor
    readonly props: Readonly<PD.Values<P>>
    readonly description?: string
    readonly legend?: Readonly<ScaleLegend | TableLegend>
}
namespace ColorTheme {
    export type Props = { [k: string]: any }
    export type Factory<P extends PD.Params> = (ctx: ThemeDataContext, props: PD.Values<P>) => ColorTheme<P>
    export const EmptyFactory = () => Empty
    const EmptyColor = Color(0xCCCCCC)
    export const Empty: ColorTheme<{}> = { factory: EmptyFactory, granularity: 'uniform', color: () => EmptyColor, props: {} }

    export function areEqual(themeA: ColorTheme, themeB: ColorTheme) {
        return themeA.factory === themeB.factory && deepEqual(themeA.props, themeB.props)
    }

    export interface Provider<P extends PD.Params> {
        readonly label: string
        readonly factory: (ctx: ThemeDataContext, props: PD.Values<P>) => ColorTheme<P>
        readonly getParams: (ctx: ThemeDataContext) => P
        readonly defaultValues: PD.Values<P>
    }
    export const EmptyProvider: Provider<{}> = { label: '', factory: EmptyFactory, getParams: () => ({}), defaultValues: {} }

    export class Registry {
        private _list: { name: string, provider: Provider<any> }[] = []
        private _map = new Map<string, Provider<any>>()

        get default() { return this._list[0]; }
        get types(): [string, string][] {
            return this._list.map(e => [e.name, e.provider.label] as [string, string]);
        }

        constructor() {
            Object.keys(BuiltInColorThemes).forEach(name => {
                const p = (BuiltInColorThemes as { [k: string]: Provider<any> })[name]
                this.add(name, p)
            })
        }

        add<P extends PD.Params>(name: string, provider: Provider<P>) {
            this._list.push({ name, provider })
            this._map.set(name, provider)
        }

        remove(name: string) {
            this._list.splice(this._list.findIndex(e => e.name === name))
            this._map.delete(name)
        }

        get<P extends PD.Params>(name: string): Provider<P> {
            return this._map.get(name) || EmptyProvider as unknown as Provider<P>
        }

        create(id: string, ctx: ThemeDataContext, props = {}) {
            const provider = this.get(id)
            return provider ? provider.factory(ctx, { ...PD.getDefaultValues(provider.getParams(ctx)), ...props }) : Empty
        }

        get list() {
            return this._list
        }
    }
}

export const BuiltInColorThemes = {
    'carbohydrate-symbol': CarbohydrateSymbolColorThemeProvider,
    'chain-id': ChainIdColorThemeProvider,
    'cross-link': CrossLinkColorThemeProvider,
    'element-index': ElementIndexColorThemeProvider,
    'element-symbol': ElementSymbolColorThemeProvider,
    'molecule-type': MoleculeTypeColorThemeProvider,
    'polymer-id': PolymerIdColorThemeProvider,
    'polymer-index': PolymerIndexColorThemeProvider,
    'residue-name': ResidueNameColorThemeProvider,
    'secondary-structure': SecondaryStructureColorThemeProvider,
    'sequence-id': SequenceIdColorThemeProvider,
    'shape-group': ShapeGroupColorThemeProvider,
    'unit-index': UnitIndexColorThemeProvider,
    'uniform': UniformColorThemeProvider,
}