Add private components to mechanism

alan412 · alan412 · commit d165af69efb8 · 2025-09-05T12:42:22.000-04:00
diff --git a/src/blocks/mrc_mechanism.ts b/src/blocks/mrc_mechanism.ts
@@ -206,7 +206,7 @@ const MECHANISM = {
 
       if (foundMechanism) {
         const components: storageModuleContent.Component[] = [];
-        components.push(...editor.getComponentsFromMechanism(foundMechanism));
+        components.push(...editor.getAllComponentsFromMechanism(foundMechanism));
 
         // If the mechanism class name has changed, update this blcok.
         if (this.getFieldValue(FIELD_TYPE) !== foundMechanism.className) {
diff --git a/src/blocks/mrc_mechanism_component_holder.ts b/src/blocks/mrc_mechanism_component_holder.ts
@@ -25,6 +25,7 @@ import { MRC_STYLE_MECHANISMS } from '../themes/styles';
 import * as ChangeFramework from './utils/change_framework';
 import { getLegalName } from './utils/python';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
+import { Editor } from '../editor/editor';
 import * as storageModule from '../storage/module';
 import * as storageModuleContent from '../storage/module_content';
 import { BLOCK_NAME as  MRC_MECHANISM_NAME } from './mrc_mechanism';
@@ -41,17 +42,20 @@ export const BLOCK_NAME = 'mrc_mechanism_component_holder';
 
 const INPUT_MECHANISMS = 'MECHANISMS';
 const INPUT_COMPONENTS = 'COMPONENTS';
+const INPUT_PRIVATE_COMPONENTS = 'PRIVATE_COMPONENTS';
 const INPUT_EVENTS = 'EVENTS';
 
 export const TOOLBOX_UPDATE_EVENT = 'toolbox-update-requested';
 
 type MechanismComponentHolderExtraState = {
   hideMechanisms?: boolean;
+  hidePrivateComponents?: boolean;
 }
 
 export type MechanismComponentHolderBlock = Blockly.Block & MechanismComponentHolderMixin;
 interface MechanismComponentHolderMixin extends MechanismComponentHolderMixinType {
   mrcHideMechanisms: boolean;
+  mrcHidePrivateComponents: boolean;
 }
 type MechanismComponentHolderMixinType = typeof MECHANISM_COMPONENT_HOLDER;
 
@@ -78,9 +82,9 @@ const MECHANISM_COMPONENT_HOLDER = {
     this.setInputsInline(false);
     this.appendStatementInput(INPUT_MECHANISMS).setCheck(MECHANISM_OUTPUT).appendField(Blockly.Msg.MECHANISMS);
     this.appendStatementInput(INPUT_COMPONENTS).setCheck(COMPONENT_OUTPUT).appendField(Blockly.Msg.COMPONENTS);
+    this.appendStatementInput(INPUT_PRIVATE_COMPONENTS).setCheck(COMPONENT_OUTPUT).appendField(Blockly.Msg.PRIVATE_COMPONENTS);
     this.appendStatementInput(INPUT_EVENTS).setCheck(EVENT_OUTPUT).appendField(Blockly.Msg.EVENTS);
 
-
     this.setOutput(false);
     this.setStyle(MRC_STYLE_MECHANISMS);
     ChangeFramework.registerCallback(MRC_COMPONENT_NAME, [Blockly.Events.BLOCK_MOVE, Blockly.Events.BLOCK_CHANGE], this.onBlockChanged);
@@ -95,30 +99,48 @@ const MECHANISM_COMPONENT_HOLDER = {
     if (this.mrcHideMechanisms == true) {
       extraState.hideMechanisms = this.mrcHideMechanisms;
     }
+    if (this.mrcHidePrivateComponents == true) {
+      extraState.hidePrivateComponents = this.mrcHidePrivateComponents;
+    }
     return extraState;
   },
   /**
   * Applies the given state to this block.
   */
   loadExtraState: function (this: MechanismComponentHolderBlock, extraState: MechanismComponentHolderExtraState): void {
     this.mrcHideMechanisms = (extraState.hideMechanisms == undefined) ? false : extraState.hideMechanisms;
+    this.mrcHidePrivateComponents = (extraState.hidePrivateComponents == undefined) ? false : extraState.hidePrivateComponents;
     this.updateBlock_();
   },
   /**
      * Update the block to reflect the newly loaded extra state.
      */
   updateBlock_: function (this: MechanismComponentHolderBlock): void {
+    // Handle mechanisms input visibility
     if (this.mrcHideMechanisms) {
       if (this.getInput(INPUT_MECHANISMS)) {
         this.removeInput(INPUT_MECHANISMS)
       }
     }
     else {
       if (this.getInput(INPUT_MECHANISMS) == null) {
-        this.appendStatementInput(INPUT_MECHANISMS).setCheck(MECHANISM_OUTPUT).appendField('Mechanisms');
+        this.appendStatementInput(INPUT_MECHANISMS).setCheck(MECHANISM_OUTPUT).appendField(Blockly.Msg.MECHANISMS);
         this.moveInputBefore(INPUT_MECHANISMS, INPUT_COMPONENTS)
       }
     }
+
+    // Handle private components input visibility
+    if (this.mrcHidePrivateComponents) {
+      if (this.getInput(INPUT_PRIVATE_COMPONENTS)) {
+        this.removeInput(INPUT_PRIVATE_COMPONENTS)
+      }
+    }
+    else {
+      if (this.getInput(INPUT_PRIVATE_COMPONENTS) == null) {
+        this.appendStatementInput(INPUT_PRIVATE_COMPONENTS).setCheck(COMPONENT_OUTPUT).appendField(Blockly.Msg.PRIVATE_COMPONENTS);
+        this.moveInputBefore(INPUT_PRIVATE_COMPONENTS, INPUT_EVENTS)
+      }
+    }
   },
   onBlockChanged: function (block: Blockly.BlockSvg, blockEvent: Blockly.Events.BlockBase) {
     if (blockEvent.type == Blockly.Events.BLOCK_MOVE) {
@@ -179,6 +201,28 @@ const MECHANISM_COMPONENT_HOLDER = {
 
     return components;
   },
+  getPrivateComponents: function (this: MechanismComponentHolderBlock): storageModuleContent.Component[] {
+    const components: storageModuleContent.Component[] = []
+
+    // Get component blocks from the PRIVATE_COMPONENTS input
+    const privateComponentsInput = this.getInput(INPUT_PRIVATE_COMPONENTS);
+    if (privateComponentsInput && privateComponentsInput.connection) {
+      // Walk through all connected component blocks.
+      let componentBlock = privateComponentsInput.connection.targetBlock();
+      while (componentBlock) {
+        if (componentBlock.type === MRC_COMPONENT_NAME) {
+          const component = (componentBlock as ComponentBlock).getComponent();
+          if (component) {
+            components.push(component);
+          }
+        }
+        // Move to the next block in the chain
+        componentBlock = componentBlock.getNextBlock();
+      }
+    }
+
+    return components;
+  },
   getEvents: function (this: MechanismComponentHolderBlock): storageModuleContent.Event[] {
     const events: storageModuleContent.Event[] = []
 
@@ -243,9 +287,11 @@ function pythonFromBlockInMechanism(block: MechanismComponentHolderBlock, genera
   code += '):\n';
 
   const components = generator.statementToCode(block, INPUT_COMPONENTS);
+  const privateComponents = generator.statementToCode(block, INPUT_PRIVATE_COMPONENTS);
 
-  if (components) {
-    code += components;
+  const body = components + privateComponents;
+  if (body) {
+    code += body;
     generator.addClassMethodDefinition('define_hardware', code);
   }
 }
@@ -272,6 +318,7 @@ export const pythonFromBlock = function (
  */
 export function hasAnyComponents(workspace: Blockly.Workspace): boolean {
   for (const block of workspace.getBlocksByType(BLOCK_NAME)) {
+    // Check regular components
     const componentsInput = block.getInput(INPUT_COMPONENTS);
     if (componentsInput && componentsInput.connection) {
       // Walk through all connected component blocks.
@@ -284,6 +331,20 @@ export function hasAnyComponents(workspace: Blockly.Workspace): boolean {
         componentBlock = componentBlock.getNextBlock();
       }
     }
+
+    // Check private components
+    const privateComponentsInput = block.getInput(INPUT_PRIVATE_COMPONENTS);
+    if (privateComponentsInput && privateComponentsInput.connection) {
+      // Walk through all connected private component blocks.
+      let componentBlock = privateComponentsInput.connection.targetBlock();
+      while (componentBlock) {
+        if (componentBlock.type === MRC_COMPONENT_NAME && componentBlock.isEnabled()) {
+          return true;
+        }
+        // Move to the next block in the chain
+        componentBlock = componentBlock.getNextBlock();
+      }
+    }
   }
   return false;
 }
@@ -305,6 +366,20 @@ export function getComponentPorts(workspace: Blockly.Workspace, ports: {[key: st
         componentBlock = componentBlock.getNextBlock();
       }
     }
+
+    // Also include private components for port collection
+    const privateComponentsInput = block.getInput(INPUT_PRIVATE_COMPONENTS);
+    if (privateComponentsInput && privateComponentsInput.connection) {
+      // Walk through all connected private component blocks.
+      let componentBlock = privateComponentsInput.connection.targetBlock();
+      while (componentBlock) {
+        if (componentBlock.type === MRC_COMPONENT_NAME && componentBlock.isEnabled()) {
+          (componentBlock as ComponentBlock).getComponentPorts(ports);
+        }
+        // Move to the next block in the chain
+        componentBlock = componentBlock.getNextBlock();
+      }
+    }
   });
 }
 
@@ -330,6 +405,25 @@ export function getComponents(
   });
 }
 
+export function getPrivateComponents(
+    workspace: Blockly.Workspace,
+    components: storageModuleContent.Component[]): void {
+  // Get the holder block and ask it for the private components.
+  workspace.getBlocksByType(BLOCK_NAME).forEach(block => {
+    const privateComponentsFromHolder: storageModuleContent.Component[] =
+      (block as MechanismComponentHolderBlock).getPrivateComponents();
+    components.push(...privateComponentsFromHolder);
+  });
+}
+
+export function getAllComponents(
+    workspace: Blockly.Workspace,
+    components: storageModuleContent.Component[]): void {
+  // Get both regular and private components for when creating a mechanism
+  getComponents(workspace, components);
+  getPrivateComponents(workspace, components);
+}
+
 export function getEvents(
     workspace: Blockly.Workspace,
     events: storageModuleContent.Event[]): void {
diff --git a/src/blocks/tokens.ts b/src/blocks/tokens.ts
@@ -38,6 +38,7 @@ export function customTokens(t: (key: string) => string): typeof Blockly.Msg {
     MECHANISMS: t('MECHANISMS'),
     OPMODES: t('OPMODES'),
     COMPONENTS: t('BLOCKLY.COMPONENTS'),
+    PRIVATE_COMPONENTS: t('BLOCKLY.PRIVATE_COMPONENTS'),
     EVENTS: t('BLOCKLY.EVENTS'),
     EVALUATE_BUT_IGNORE_RESULT: t('BLOCKLY.EVALUATE_BUT_IGNORE_RESULT'),
     EVALUATE_BUT_IGNORE_RESULT_TOOLTIP:
diff --git a/src/editor/editor.ts b/src/editor/editor.ts
@@ -273,6 +273,15 @@ export class Editor {
     return components;
   }
 
+  public getAllComponentsFromWorkspace(): storageModuleContent.Component[] {
+    const components: storageModuleContent.Component[] = [];
+    if (this.currentModule?.moduleType === storageModule.ModuleType.ROBOT ||
+        this.currentModule?.moduleType === storageModule.ModuleType.MECHANISM) {
+      mechanismComponentHolder.getAllComponents(this.blocklyWorkspace, components);
+    }
+    return components;
+  }
+
   public getMethodsForWithinFromWorkspace(): storageModuleContent.Method[] {
     const methods: storageModuleContent.Method[] = [];
     classMethodDef.getMethodsForWithin(this.blocklyWorkspace, methods);
@@ -415,6 +424,37 @@ export class Editor {
     throw new Error('getComponentsFromMechanism: mechanism not found: ' + mechanism.className);
   }
 
+  /**
+   * Returns ALL components (including private components) defined in the given mechanism.
+   * This is used when creating mechanism blocks that need all components for port parameters.
+   */
+  public getAllComponentsFromMechanism(mechanism: storageModule.Mechanism): storageModuleContent.Component[] {
+    if (this.currentModule?.modulePath === mechanism.modulePath) {
+      return this.getAllComponentsFromWorkspace();
+    }
+    if (mechanism.className in this.mechanismClassNameToModuleContent) {
+      // For saved mechanisms, we need to reconstruct all components from the blocks
+      // since only public components are saved in the module content
+      const moduleContent = this.mechanismClassNameToModuleContent[mechanism.className];
+      const blocks = moduleContent.getBlocks();
+      
+      // Create a temporary workspace to load the mechanism's blocks
+      const tempWorkspace = new Blockly.Workspace();
+      try {
+        Blockly.serialization.workspaces.load(blocks, tempWorkspace);
+        
+        // Extract all components (public and private) from the temporary workspace
+        const allComponents: storageModuleContent.Component[] = [];
+        mechanismComponentHolder.getAllComponents(tempWorkspace, allComponents);
+        
+        return allComponents;
+      } finally {
+        tempWorkspace.dispose();
+      }
+    }
+    throw new Error('getAllComponentsFromMechanism: mechanism not found: ' + mechanism.className);
+  }
+
   /**
    * Returns the events defined in the given mechanism.
    */
diff --git a/src/i18n/locales/en/translation.json b/src/i18n/locales/en/translation.json
@@ -46,6 +46,7 @@
         "PARAMETER": "parameter",
         "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "Parameters can only go in their method's block",
         "COMPONENTS": "Components",
+        "PRIVATE_COMPONENTS": "Private Components",
         "EVENTS": "Events",
         "EVALUATE_BUT_IGNORE_RESULT": "evaluate but ignore result",
         "NONE": "None",
diff --git a/src/i18n/locales/es/translation.json b/src/i18n/locales/es/translation.json
@@ -47,6 +47,7 @@
         "PARAMETER": "parámetro",
         "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "Los parámetros solo pueden ir en el bloque de su método",
         "COMPONENTS": "Componentes",
+        "PRIVATE_COMPONENTS": "Componentes Privados",
         "EVENTS": "Eventos",
         "EVALUATE_BUT_IGNORE_RESULT": "evaluar pero ignorar resultado",
         "NONE": "None",
diff --git a/src/i18n/locales/he/translation.json b/src/i18n/locales/he/translation.json
@@ -46,6 +46,7 @@
         "PARAMETER": "פרמטר",
         "PARAMETERS_CAN_ONLY_GO_IN_THEIR_METHODS_BLOCK": "פרמטרים יכולים להיכנס רק בבלוק השיטה שלהם",
         "COMPONENTS": "רכיבים",
+        "PRIVATE_COMPONENTS": "רכיבים פרטיים",
         "EVENTS": "אירועים",
         "EVALUATE_BUT_IGNORE_RESULT": "הערך אך התעלם מהתוצאה",
         "NONE": "אַף לֹא אֶחָד",
diff --git a/src/toolbox/hardware_category.ts b/src/toolbox/hardware_category.ts
@@ -77,7 +77,7 @@ function getRobotMechanismsCategory(editor: Editor): toolboxItems.Category {
     if (mechanisms.length) {
       const mechanismBlocks: toolboxItems.Block[] = [];
       mechanisms.forEach(mechanism => {
-        const components = editor.getComponentsFromMechanism(mechanism);
+        const components = editor.getAllComponentsFromMechanism(mechanism);
         mechanismBlocks.push(createMechanismBlock(mechanism, components));
       });
 
@@ -109,6 +109,24 @@ function getRobotMechanismsCategory(editor: Editor): toolboxItems.Category {
         contents: mechanismMethodBlocks,
       });
 
+      // Get the public components from the mechanism and add the blocks for calling the component functions.
+      const componentsFromMechanism = editor.getComponentsFromMechanism(mechanism);
+      if (componentsFromMechanism.length > 0) {
+        const componentBlocks: toolboxItems.ContentsType[] = [];
+        componentsFromMechanism.forEach(component => {
+          componentBlocks.push({
+            kind: 'category',
+            name: component.name,
+            contents: getInstanceComponentBlocks(component),
+          });
+        });
+        mechanismCategories.push({
+          kind: 'category',
+          name: Blockly.Msg['MRC_CATEGORY_COMPONENTS'],
+          contents: componentBlocks,
+        });
+      }
+
       mechanismCategories.push(getMechanismEventHandlersCategory(editor, mechanismInRobot));
 
       contents.push({
@@ -184,7 +202,11 @@ function getComponentsCategory(
   });
 
   // Get components from the current workspace.
-  editor.getComponentsFromWorkspace().forEach(component => {
+  const componentsToShow = moduleType === storageModule.ModuleType.MECHANISM 
+    ? editor.getAllComponentsFromWorkspace() // Show all components (including private) when editing mechanisms
+    : editor.getComponentsFromWorkspace();   // Show only regular components when editing robots
+  
+  componentsToShow.forEach(component => {
     // Get the blocks for this specific component
     contents.push({
       kind: 'category',
