LegendProvider

Source

index.js
import CompositeClosureHelper from 'paraviewweb/src/Common/Core/CompositeClosureHelper';
import legendShapes from 'paraviewweb/src/InfoViz/Core/LegendProvider/shapes';
import palettes from 'paraviewweb/src/Common/Misc/ColorPalettes';

// ----------------------------------------------------------------------------
// Global
// ----------------------------------------------------------------------------

function convert(item, model) {
const result = { color: item.colors };
result.shape = model.legendShapes[item.shapes];
return result;
}

export function createSortedIterator(
priorityOrder,
propertyChoices,
defaultValues
) {
const propertyKeys = Object.keys(propertyChoices);

const prioritySizes = priorityOrder.map(
(name) => propertyChoices[name].length
);
const priorityIndex = prioritySizes.map((i) => 0);

const get = () => {
const item = {};
propertyKeys.forEach((name) => {
const idx = priorityOrder.indexOf(name);
if (idx === -1) {
item[name] = defaultValues[name];
} else {
item[name] = propertyChoices[name][priorityIndex[idx]];
}
});
return item;
};

const next = () => {
let overflowIdx = 0;
priorityIndex[overflowIdx] += 1;
while (priorityIndex[overflowIdx] === prioritySizes[overflowIdx]) {
// Handle overflow
priorityIndex[overflowIdx] = 0;
if (overflowIdx < priorityIndex.length) {
overflowIdx += 1;
priorityIndex[overflowIdx] += 1;
}
}
};

return { get, next };
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------

export const STATIC = {
shapes: legendShapes,
palettes,
};

// ----------------------------------------------------------------------------
// Legend Provider
// ----------------------------------------------------------------------------

function legendProvider(publicAPI, model) {
publicAPI.addLegendEntry = (name) => {
if (model.legendEntries.indexOf(name) === -1 && name) {
model.legendEntries.push(name);
model.legendDirty = true;
}
};

publicAPI.removeLegendEntry = (name) => {
if (model.legendEntries.indexOf(name) !== -1 && name) {
model.legendEntries.splice(model.legendEntries.indexOf(name), 1);
model.legendDirty = true;
}
};
publicAPI.removeAllLegendEntry = () => {
model.legendEntries = [];
model.legendDirty = true;
};

publicAPI.assignLegend = (newPriority = null) => {
if (newPriority) {
model.legendPriorities = newPriority;
model.legendDirty = true;
}
if (model.legendDirty) {
const shapesArray = Object.keys(model.legendShapes);
model.legendDirty = false;
model.legendMapping = {};

if (model.legendPriorities && model.legendPriorities.length) {
const defaultColor = model.legendColors[0];
const defaultShape = shapesArray[0];

const iterator = createSortedIterator(
model.legendPriorities,
{ colors: model.legendColors, shapes: shapesArray },
{ colors: defaultColor, shapes: defaultShape }
);

model.legendEntries.forEach((name) => {
model.legendMapping[name] = convert(iterator.get(), model);
iterator.next();
});
} else {
model.legendEntries.forEach((name, idx) => {
model.legendMapping[name] = {
color: model.legendColors[idx % model.legendColors.length],
shape: model.legendShapes[shapesArray[idx % shapesArray.length]],
};
});
}
}
};

publicAPI.useLegendPalette = (name) => {
const colorSet = palettes[name];
if (colorSet) {
model.legendColors = [].concat(colorSet);
model.legendDirty = true;
}
};

publicAPI.updateLegendSettings = (settings) => {
[
'legendShapes',
'legendColors',
'legendEntries',
'legendPriorities',
].forEach((key) => {
if (settings[key]) {
model[key] = [].concat(settings.key);
model.legendDirty = true;
}
});
};

publicAPI.listLegendColorPalettes = () => Object.keys(palettes);

publicAPI.getLegend = (name) => {
if (model.legendDirty) {
publicAPI.assignLegend();
}
return model.legendMapping[name];
};
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
legendShapes,
legendColors: [].concat(palettes.Paired),
legendEntries: [],
legendPriorities: ['shapes', 'colors'],
legendMapping: {},
legendDirty: true,
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
Object.assign(model, DEFAULT_VALUES, initialValues);

CompositeClosureHelper.destroy(publicAPI, model);
CompositeClosureHelper.isA(publicAPI, model, 'LegendProvider');

legendProvider(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = CompositeClosureHelper.newInstance(extend);

// ----------------------------------------------------------------------------

export default Object.assign({ newInstance, extend }, STATIC);