@teachinglab/omd 0.1.0

package/canvas/tools/toolManager.js

@@ -0,0 +1,394 @@
+export class ToolManager {
+    /**
+     * @param {OMDCanvas} canvas - Canvas instance
+     */
+    constructor(canvas) {
+        this.canvas = canvas;
+        this.tools = new Map();
+        this.activeTool = null;
+        this.previousTool = null;
+        this.isDestroyed = false;
+    }
+    
+    /**
+     * Register a tool with the manager
+     * @param {string} name - Tool name
+     * @param {Tool} tool - Tool instance
+     * @returns {boolean} True if tool was registered successfully
+     */
+    registerTool(name, tool) {
+        if (this.isDestroyed) {
+            console.warn('Cannot register tool on destroyed ToolManager');
+            return false;
+        }
+        
+        if (!name || typeof name !== 'string') {
+            console.error('Tool name must be a non-empty string');
+            return false;
+        }
+        
+        if (!tool || typeof tool.onPointerDown !== 'function') {
+            console.error('Tool must implement required methods');
+            return false;
+        }
+        
+        // Check if tool is enabled in config
+        if (!this.canvas.config.enabledTools.includes(name)) {
+            console.warn(`Tool '${name}' is not enabled in canvas configuration`);
+            return false;
+        }
+        
+        // Set tool name and canvas reference
+        tool.name = name;
+        tool.canvas = this.canvas;
+        
+        // Store tool
+        this.tools.set(name, tool);
+        
+        console.log(`Tool '${name}' registered successfully`);
+        return true;
+    }
+    
+    /**
+     * Unregister a tool
+     * @param {string} name - Tool name
+     * @returns {boolean} True if tool was unregistered
+     */
+    unregisterTool(name) {
+        const tool = this.tools.get(name);
+        if (!tool) return false;
+        
+        // Deactivate if it's the active tool
+        if (this.activeTool === tool) {
+            this.setActiveTool(null);
+        }
+        
+        // Remove from tools
+        this.tools.delete(name);
+        
+        console.log(`Tool '${name}' unregistered`);
+        return true;
+    }
+    
+    /**
+     * Set the active tool
+     * @param {string|null} toolName - Tool name to activate, or null to deactivate all
+     * @returns {boolean} True if tool was activated successfully
+     */
+    setActiveTool(toolName) {
+        // Deactivate current tool
+        if (this.activeTool) {
+            try {
+                this.activeTool.onDeactivate();
+            } catch (error) {
+                console.error('Error deactivating tool:', error);
+            }
+            this.previousTool = this.activeTool;
+        }
+        
+        // Clear active tool if null
+        if (!toolName) {
+            this.activeTool = null;
+            this.canvas.emit('toolChanged', { name: null, tool: null, previous: this.previousTool?.name });
+            return true;
+        }
+        
+        // Get new tool
+        const newTool = this.tools.get(toolName);
+        if (!newTool) {
+            console.error(`Tool '${toolName}' not found`);
+            return false;
+        }
+        
+        // Activate new tool
+        this.activeTool = newTool;
+        
+        try {
+            this.activeTool.onActivate();
+        } catch (error) {
+            console.error('Error activating tool:', error);
+            this.activeTool = null;
+            return false;
+        }
+        
+        // Update cursor if available
+        if (this.canvas.cursor && this.activeTool.getCursor) {
+            const cursorType = this.activeTool.getCursor();
+            this.canvas.cursor.setShape(cursorType);
+        }
+        
+        // Update tool config for cursor
+        if (this.canvas.cursor && this.activeTool.config) {
+            this.canvas.cursor.updateFromToolConfig(this.activeTool.config);
+        }
+        
+        // Emit tool change event
+        this.canvas.emit('toolChanged', { 
+            name: toolName, 
+            tool: newTool, 
+            previous: this.previousTool?.name 
+        });
+        
+        console.log(`Tool '${toolName}' activated`);
+        return true;
+    }
+    
+    /**
+     * Get the currently active tool
+     * @returns {Tool|null} Active tool instance
+     */
+    getActiveTool() {
+        return this.activeTool;
+    }
+    
+    /**
+     * Get tool by name
+     * @param {string} name - Tool name
+     * @returns {Tool|undefined} Tool instance
+     */
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    
+    /**
+     * Get all registered tool names
+     * @returns {Array<string>} Array of tool names
+     */
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+    
+    /**
+     * Get all registered tools
+     * @returns {Map<string, Tool>} Map of tools
+     */
+    getAllTools() {
+        return new Map(this.tools);
+    }
+    
+    /**
+     * Get metadata for all tools
+     * @returns {Array<Object>} Array of tool metadata
+     */
+    getAllToolMetadata() {
+        return Array.from(this.tools.entries()).map(([name, tool]) => ({
+            name,
+            displayName: tool.displayName || name,
+            description: tool.description || '',
+            shortcut: tool.shortcut || '',
+            category: tool.category || 'general',
+            icon: tool.icon || 'tool'
+        }));
+    }
+    
+    /**
+     * Switch to previous tool
+     * @returns {boolean} True if switched successfully
+     */
+    switchToPreviousTool() {
+        if (this.previousTool) {
+            return this.setActiveTool(this.previousTool.name);
+        }
+        return false;
+    }
+    
+    /**
+     * Temporarily switch to a tool and back
+     * @param {string} toolName - Tool to switch to temporarily
+     * @param {Function} callback - Function to execute with temporary tool
+     * @returns {Promise<any>} Result of callback
+     */
+    async withTemporaryTool(toolName, callback) {
+        const currentTool = this.activeTool?.name;
+        
+        if (!this.setActiveTool(toolName)) {
+            throw new Error(`Failed to activate temporary tool: ${toolName}`);
+        }
+        
+        try {
+            const result = await callback(this.activeTool);
+            return result;
+        } finally {
+            // Restore previous tool
+            if (currentTool) {
+                this.setActiveTool(currentTool);
+            }
+        }
+    }
+    
+    /**
+     * Update tool configuration
+     * @param {string} toolName - Tool name
+     * @param {Object} config - Configuration updates
+     * @returns {boolean} True if updated successfully
+     */
+    updateToolConfig(toolName, config) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            console.error(`Tool '${toolName}' not found`);
+            return false;
+        }
+        
+        if (tool.updateConfig) {
+            tool.updateConfig(config);
+            
+            // Update cursor if this is the active tool
+            if (this.activeTool === tool && this.canvas.cursor) {
+                this.canvas.cursor.updateFromToolConfig(tool.config);
+            }
+            
+            return true;
+        }
+        
+        console.warn(`Tool '${toolName}' does not support configuration updates`);
+        return false;
+    }
+    
+    /**
+     * Get tool configuration
+     * @param {string} toolName - Tool name
+     * @returns {Object|null} Tool configuration
+     */
+    getToolConfig(toolName) {
+        const tool = this.tools.get(toolName);
+        return tool ? tool.config || {} : null;
+    }
+    
+         /**
+      * Check if a tool is registered
+      * @param {string} toolName - Tool name
+      * @returns {boolean} True if tool is registered
+      */
+     hasTool(toolName) {
+         return this.tools.has(toolName);
+     }
+    
+    /**
+     * Check if a tool is enabled in configuration
+     * @param {string} toolName - Tool name
+     * @returns {boolean} True if tool is enabled
+     */
+    isToolEnabled(toolName) {
+        return this.canvas.config.enabledTools.includes(toolName);
+    }
+    
+    /**
+     * Get tool capabilities
+     * @param {string} toolName - Tool name
+     * @returns {Object|null} Tool capabilities
+     */
+    getToolCapabilities(toolName) {
+        const tool = this.tools.get(toolName);
+        if (!tool) return null;
+        
+        return {
+            name: tool.name,
+            displayName: tool.displayName,
+            description: tool.description,
+            shortcut: tool.shortcut,
+            category: tool.category,
+            supportsKeyboardShortcuts: typeof tool.onKeyboardShortcut === 'function',
+            supportsPressure: tool.supportsPressure || false,
+            supportsMultiTouch: tool.supportsMultiTouch || false,
+            configurable: typeof tool.updateConfig === 'function',
+            hasHelp: typeof tool.getHelpText === 'function'
+        };
+    }
+    
+    /**
+     * Handle keyboard shortcuts for tools
+     * @param {string} key - Key pressed
+     * @param {KeyboardEvent} event - Keyboard event
+     * @returns {boolean} True if shortcut was handled
+     */
+    handleKeyboardShortcut(key, event) {
+        // First, check for tool switching shortcuts
+        for (const [name, tool] of this.tools) {
+            if (tool.shortcut && tool.shortcut.toLowerCase() === key.toLowerCase()) {
+                this.setActiveTool(name);
+                return true;
+            }
+        }
+        
+        // Then, delegate to active tool
+        if (this.activeTool && this.activeTool.onKeyboardShortcut) {
+            return this.activeTool.onKeyboardShortcut(key, event);
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Get help text for all tools or specific tool
+     * @param {string} [toolName] - Optional tool name
+     * @returns {string|Object} Help text
+     */
+    getHelpText(toolName = null) {
+        if (toolName) {
+            const tool = this.tools.get(toolName);
+            if (tool && tool.getHelpText) {
+                return tool.getHelpText();
+            }
+            return `No help available for tool: ${toolName}`;
+        }
+        
+        // Return help for all tools
+        const helpTexts = {};
+        for (const [name, tool] of this.tools) {
+            if (tool.getHelpText) {
+                helpTexts[name] = tool.getHelpText();
+            }
+        }
+        return helpTexts;
+    }
+    
+    /**
+     * Get current tool manager state
+     * @returns {Object} Current state
+     */
+    getState() {
+        return {
+            activeToolName: this.activeTool?.name || null,
+            previousToolName: this.previousTool?.name || null,
+            registeredTools: this.getToolNames(),
+            enabledTools: this.canvas.config.enabledTools,
+            isDestroyed: this.isDestroyed
+        };
+    }
+    
+    /**
+     * Destroy the tool manager
+     */
+    destroy() {
+        if (this.isDestroyed) return;
+        
+        // Deactivate current tool
+        if (this.activeTool) {
+            try {
+                this.activeTool.onDeactivate();
+            } catch (error) {
+                console.error('Error deactivating tool during destroy:', error);
+            }
+        }
+        
+        // Destroy all tools if they have a destroy method
+        for (const [name, tool] of this.tools) {
+            if (tool.destroy) {
+                try {
+                    tool.destroy();
+                } catch (error) {
+                    console.error(`Error destroying tool '${name}':`, error);
+                }
+            }
+        }
+        
+        // Clear references
+        this.tools.clear();
+        this.activeTool = null;
+        this.previousTool = null;
+        this.canvas = null;
+        this.isDestroyed = true;
+        
+        console.log('ToolManager destroyed');
+    }
+}