import { ff } from "@humansignal/core";
|
import { destroy } from "mobx-state-tree";
|
import { FF_DEV_3391 } from "../utils/feature-flags";
|
import { guidGenerator } from "../utils/unique";
|
|
/** @type {Map<any, ToolsManager>} */
|
const INSTANCES = new Map();
|
let root = null;
|
|
class ToolsManager {
|
static getInstance({ name } = {}) {
|
if (!name) return;
|
|
if (INSTANCES.has(name)) {
|
return INSTANCES.get(name);
|
}
|
|
const instance = new ToolsManager({ name });
|
|
INSTANCES.set(name, instance);
|
return instance;
|
}
|
|
static allInstances() {
|
return Array.from(INSTANCES.values());
|
}
|
|
static setRoot(rootStore) {
|
root = rootStore;
|
}
|
|
static removeAllTools() {
|
INSTANCES.forEach((manager) => manager.removeAllTools());
|
INSTANCES.clear();
|
}
|
|
constructor({ name } = {}) {
|
this.name = name;
|
this.tools = {};
|
this._default_tool = null;
|
this._prefix = guidGenerator();
|
}
|
|
get preservedTool() {
|
return window.localStorage.getItem(`selected-tool:${this.name}`);
|
}
|
/**
|
There are some problems with working with ToolManager with interactive view all flag switched on.
|
For now, tool manager is hidden in view_all,
|
so it allows us to use root and selected annotation
|
while we are looking for the object or the control from the tool.
|
At the same time, we can use `annotation_id`
|
as an additional key to be able to get the right annotation in that view_all mode.
|
But in that case,
|
there will be a problem with the inconsistent state of tool manager for 2 different annotations in the context of the same task.
|
*/
|
get root() {
|
return root;
|
}
|
|
get obj() {
|
if (ff.isActive(FF_DEV_3391)) {
|
return root.annotationStore.selected?.names.get(this.name);
|
}
|
return root.annotationStore.names.get(this.name);
|
}
|
|
addTool(toolName, tool, removeDuplicatesNamed = null, prefix = guidGenerator()) {
|
if (tool.smart && tool.control?.smartonly) return;
|
// todo: It seems that key is used only for storing,
|
// but not for finding tools, so may be there might
|
// be an array instead of an object
|
const name = tool.toolName ?? toolName;
|
const key = `${prefix ?? this._prefix}#${name}`;
|
|
if (removeDuplicatesNamed && toolName === removeDuplicatesNamed) {
|
const findme = new RegExp(`^.*?#${name}.*$`);
|
|
if (Object.keys(this.tools).some((entry) => findme.test(entry))) {
|
console.log(
|
`Ignoring duplicate tool ${name} because it matches removeDuplicatesNamed ${removeDuplicatesNamed}`,
|
);
|
return;
|
}
|
}
|
|
this.tools[key] = tool;
|
|
if (tool.default && !this._default_tool) this._default_tool = tool;
|
|
if (this.preservedTool && tool.shouldPreserveSelectedState) {
|
if (tool.fullName === this.preservedTool && tool.setSelected) {
|
this.unselectAll();
|
this.selectTool(tool, true, true);
|
return;
|
}
|
}
|
|
if (this._default_tool && !this.hasSelected) {
|
this.selectTool(this._default_tool, true, true);
|
}
|
}
|
|
unselectAll() {
|
// when one of the tool get selected you need to unselect all
|
// other active tools
|
Object.values(this.tools).forEach((t) => {
|
if (typeof t.selected !== "undefined") t.setSelected(false);
|
});
|
|
const stage = this.obj?.stageRef;
|
|
if (stage) {
|
stage.container().style.cursor = "default";
|
}
|
}
|
|
selectTool(tool, selected, isInitial = false) {
|
const currentTool = this.findSelectedTool();
|
const newSelection = tool?.group;
|
|
// if there are no tools selected, there are no specific labels to unselect
|
// also this will skip annotation init
|
if (currentTool && newSelection === "segmentation") {
|
const toolType = tool.control.type.replace(/labels$/, "");
|
const currentLabels = tool.obj.activeStates();
|
// labels of different types; we can't create regions with different tools simultaneously, so we have to unselect them
|
const unrelatedLabels = currentLabels.filter((tag) => {
|
const type = tag.type.replace(/labels$/, "");
|
|
if (tag.type === "labels") return false;
|
if (type === toolType) return false;
|
return true;
|
});
|
|
unrelatedLabels.forEach((tag) => tag.unselectAll());
|
}
|
|
currentTool?.handleToolSwitch?.(tool);
|
currentTool?.complete?.();
|
|
if (selected) {
|
this.unselectAll();
|
tool.setSelected?.(true, isInitial);
|
} else {
|
const drawingTool = this.findDrawingTool();
|
|
this.selectTool(drawingTool ?? this._default_tool, true);
|
}
|
}
|
|
selectDefault() {
|
const tool = this.findSelectedTool();
|
|
if (this._default_tool && tool?.dynamic === true) {
|
this.unselectAll();
|
this._default_tool.setSelected(true);
|
}
|
}
|
|
allTools() {
|
return Object.values(this.tools);
|
}
|
|
addToolsFromControl(s) {
|
if (s.tools) {
|
const t = s.tools;
|
|
Object.keys(t).forEach((k) => {
|
this.addTool(k, t[k], s.removeDuplicatesNamed, s.name || s.id);
|
});
|
}
|
}
|
|
findSelectedTool() {
|
return Object.values(this.tools).find((t) => t.selected);
|
}
|
|
findDrawingTool() {
|
return Object.values(this.tools).find((t) => t.isDrawing);
|
}
|
|
event(name, ev, ...args) {
|
// if there is an active tool, dispatch there
|
const selectedTool = this.findSelectedTool();
|
|
if (selectedTool) {
|
selectedTool.event(name, ev, args);
|
return;
|
}
|
}
|
|
reload({ name } = {}) {
|
INSTANCES.delete(this.name);
|
INSTANCES.set(name, this);
|
|
this.removeAllTools();
|
|
this.name = name;
|
}
|
|
removeAllTools() {
|
Object.values(this.tools).forEach((t) => destroy(t));
|
this.tools = {};
|
this._default_tool = null;
|
}
|
|
get hasSelected() {
|
return Object.values(this.tools).some((t) => t.selected);
|
}
|
}
|
|
window.ToolManager = ToolsManager;
|
|
export default ToolsManager;
|
