Merge branch 'main' of github.com:wpilibsuite/systemcore-blocks-interface into pr_fix_add_tab

Author: alan412

src/App.tsx

@@ -368,6 +368,9 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
       await saveModule();
     }
     setCurrentModule(module);
+    if (module) {
+      setActiveTab(module.modulePath);
+    }
   };
 
   /** Handles toolbox settings modal close. */

src/blocks/mrc_call_python_function.ts

@@ -322,6 +322,14 @@ const CLASS_METHOD_DEF = {
             this.mrcMethodId = oldIdToNewId[this.mrcMethodId];
         }
     },
+    upgrade_002_to_003: function(this: ClassMethodDefBlock) {
+        if (this.getFieldValue('NAME') === 'init') {
+            // Remove robot parameter from init method
+            const methodBlock = this as ClassMethodDefBlock;
+            let filteredParams: Parameter[] = methodBlock.mrcParameters.filter(param => param.name !== 'robot');
+            methodBlock.mrcParameters = filteredParams;
+        }
+    },
 };
 
 /**
@@ -447,6 +455,10 @@ export const pythonFromBlock = function (
         }
     }
 
+    if (generator.getModuleType() === storageModule.ModuleType.OPMODE && block.mrcPythonMethodName === '__init__') {
+        paramString = 'robot';
+    }
+
     if (params.length != 0) {
         block.mrcParameters.forEach((param) => {
             paramString += ', ' + param.name;

src/blocks/mrc_class_method_def.ts

@@ -176,6 +176,13 @@ const EVENT_HANDLER = {
    * workspace.
    */
   mrcOnLoad: function(this: EventHandlerBlock): void {
+    this.mrcValidate();
+  },
+  /**
+   * mrcValidate checks the block, updates it, and/or adds a warning balloon if necessary.
+   * It is called from mrcOnLoad above and from Editor.makeCurrent.
+   */
+  mrcValidate: function(this: EventHandlerBlock): void {
     const warnings: string[] = [];
 
     const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);

src/blocks/mrc_event_handler.ts

@@ -174,8 +174,19 @@ const MECHANISM = {
       className: mechanismType,
     };
   },
+
+  /**
+   * mrcOnLoad is called for each MechanismBlock when the blocks are loaded in the blockly
+   * workspace.
+   */
   mrcOnLoad: function(this: MechanismBlock): void {
-    // mrcOnLoad is called for each MechanismBlock when the blocks are loaded in the blockly workspace.
+    this.mrcValidate();
+  },
+  /**
+   * mrcValidate checks the block, updates it, and/or adds a warning balloon if necessary.
+   * It is called from mrcOnLoad above and from Editor.makeCurrent.
+   */
+  mrcValidate: function(this: MechanismBlock): void {
     const warnings: string[] = [];
 
     const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);

src/blocks/mrc_mechanism.ts

@@ -61,6 +61,29 @@ export function customTokens(t: (key: string) => string): typeof Blockly.Msg {
     OPMODE_ENABLED_TOOLTIP: t('BLOCKLY.TOOLTIP.OPMODE_ENABLED'),
     OPMODE_NAME_TOOLTIP: t('BLOCKLY.TOOLTIP.OPMODE_NAME'),
     OPMODE_GROUP_TOOLTIP: t('BLOCKLY.TOOLTIP.OPMODE_GROUP'),
+    CALL: t('BLOCKLY.CALL'),
+    ROBOT_LOWER_CASE: t('BLOCKLY.ROBOT_LOWER_CASE'),
+    CREATE: t('BLOCKLY.CREATE'),
+    FIRE: t('BLOCKLY.FIRE'),
+    WARNING_CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT: t('BLOCKLY.WARNING.CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT'),
+    WARNING_CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT: t('BLOCKLY.WARNING.CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT'),
+    WARNING_CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM: t('BLOCKLY.WARNING.CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM'),
+    WARNING_CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM: t('BLOCKLY.WARNING.CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM'),
+    WARNING_CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD: t('BLOCKLY.WARNING.CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD'),
+    WARNING_CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM: t('BLOCKLY.WARNING.CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM'),
+    WARNING_CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD: t('BLOCKLY.WARNING.CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD'),
+    WARNING_CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM: t('BLOCKLY.WARNING.CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM'),
+    CALL_BUILTIN_FUNCTION_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_BUILTIN_FUNCTION'),
+    CALL_MODULE_FUNCTION_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_MODULE_FUNCTION'),
+    CALL_STATIC_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_STATIC_METHOD'),
+    CALL_CONSTRUCTOR_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_CONSTRUCTOR'),
+    CALL_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_INSTANCE_METHOD'),
+    CALL_INSTANCE_METHOD_WITHIN_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_INSTANCE_METHOD_WITHIN'),
+    FIRE_EVENT_TOOLTIP: t('BLOCKLY.TOOLTIP.FIRE_EVENT'),
+    CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_MECHANISM_COMPONENT_INSTANCE_METHOD'),
+    CALL_COMPONENT_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_COMPONENT_INSTANCE_METHOD'),
+    CALL_ROBOT_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_ROBOT_INSTANCE_METHOD'),
+    CALL_MECHANISM_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_MECHANISM_INSTANCE_METHOD'),
     MRC_CATEGORY_HARDWARE: t('BLOCKLY.CATEGORY.HARDWARE'),
     MRC_CATEGORY_ROBOT: t('BLOCKLY.CATEGORY.ROBOT'),
     MRC_CATEGORY_COMPONENTS: t('BLOCKLY.CATEGORY.COMPONENTS'),

src/blocks/tokens.ts

@@ -38,6 +38,9 @@ const EMPTY_TOOLBOX: Blockly.utils.toolbox.ToolboxDefinition = {
   contents: [],
 };
 
+const MRC_ON_LOAD = 'mrcOnLoad';
+const MRC_VALIDATE = 'mrcValidate';
+
 export class Editor {
   private static workspaceIdToEditor: { [workspaceId: string]: Editor } = {};
   private static currentEditor: Editor | null = null;
@@ -97,8 +100,8 @@ export class Editor {
         blockCreateEvent.ids.forEach(id => {
           const block = this.blocklyWorkspace.getBlockById(id);
           if (block) {
-            if ('mrcOnLoad' in block && typeof block.mrcOnLoad === "function") {
-              block.mrcOnLoad();
+            if (MRC_ON_LOAD in block && typeof block[MRC_ON_LOAD] === 'function') {
+              block[MRC_ON_LOAD]();
             }
           }
         });
@@ -129,6 +132,13 @@ export class Editor {
     // Parse modules since they might have changed.
     this.parseModules(project, modulePathToContentText);
     this.updateToolboxImpl();
+
+    // Go through all the blocks in the workspace and call their mrcValidate method.
+    this.blocklyWorkspace.getAllBlocks().forEach(block => {
+      if (MRC_VALIDATE in block && typeof block[MRC_VALIDATE] === 'function') {
+        block[MRC_VALIDATE]();
+      }
+    });
   }
 
   public abandon(): void {
@@ -158,8 +168,8 @@ export class Editor {
     for (const mechanism of this.mechanisms) {
       const moduleContent = this.modulePathToModuleContent[mechanism.modulePath];
       if (!moduleContent) {
-        console.error(this.modulePath + " editor.parseModules - modulePathToModuleContent['" +
-            mechanism.modulePath + "'] is undefined");
+        console.error(this.modulePath + ' editor.parseModules - modulePathToModuleContent["' +
+            mechanism.modulePath + '"] is undefined');
         continue;
       }
       this.mechanismClassNameToModuleContent[mechanism.className] = moduleContent;
@@ -441,7 +451,7 @@ export class Editor {
   }
 
   /**
-   * Returns the components defined in the given mechanism.
+   * Returns the regular components defined in the given mechanism.
    */
   public getComponentsFromMechanism(mechanism: storageModule.Mechanism): storageModuleContent.Component[] {
     if (this.module.modulePath === mechanism.modulePath) {
@@ -453,6 +463,19 @@ export class Editor {
     throw new Error('getComponentsFromMechanism: mechanism not found: ' + mechanism.className);
   }
 
+  /**
+   * Returns the private components defined in the given mechanism.
+   */
+  public getPrivateComponentsFromMechanism(mechanism: storageModule.Mechanism): storageModuleContent.Component[] {
+    if (this.module.modulePath === mechanism.modulePath) {
+      return this.getPrivateComponentsFromWorkspace();
+    }
+    if (mechanism.className in this.mechanismClassNameToModuleContent) {
+      return this.mechanismClassNameToModuleContent[mechanism.className].getPrivateComponents();
+    }
+    throw new Error('getPrivateComponentsFromMechanism: 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.

src/editor/editor.ts

@@ -62,6 +62,10 @@
         "DISPLAY_GROUP": "Display Group",
         "PRINT": "print",
         "NO_MECHANISM_CONTENTS": "No Mechanism Contents",
+        "CALL": "call",
+        "ROBOT": "robot",
+        "CREATE": "create",
+        "FIRE": "fire",
         "TOOLTIP":{
             "EVALUATE_BUT_IGNORE_RESULT": "Executes the connected block and ignores the result.  Allows you to call a function and ignore the return value.",
             "NONE": "Returns None.",
@@ -70,7 +74,18 @@
             "OPMODE_NAME": "The name shown on the Driver Station.  If blank will use the class name.",
             "OPMODE_GROUP": "An optional group to group OpModes on Driver Station",
             "COMPONENTS": "These components are visible in this mechanism, the robot, and all opmodes.",
-            "PRIVATE_COMPONENTS": "These components will not be visible in the robot or opmodes. They are only accessible within this mechanism."
+            "PRIVATE_COMPONENTS": "These components will not be visible in the robot or opmodes. They are only accessible within this mechanism.",
+            "CALL_BUILTIN_FUNCTION": "Calls the builtin function {{functionName}}.",
+            "CALL_MODULE_FUNCTION": "Calls the module function {{moduleName}}.{{functionName}}.",
+            "CALL_STATIC_METHOD": "Calls the static method {{className}}.{{functionName}}.",
+            "CALL_CONSTRUCTOR": "Constructs an instance of the class {{className}}.",
+            "CALL_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}}.",
+            "CALL_INSTANCE_METHOD_WITHIN": "Calls the instance method {{functionName}}.",
+            "FIRE_EVENT": "Fires the event named {{eventName}}.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}} on the component named {{componentName}} in the mechanism named {{mechanismName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}} on the component named {{componentName}}.",
+            "CALL_ROBOT_INSTANCE_METHOD": "Calls the robot method {{functionName}}.",
+            "CALL_MECHANISM_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}} on the mechanism named {{mechanismName}}."
         },
         "CATEGORY":{
             "LISTS": "Lists",
@@ -89,6 +104,16 @@
             "ADD_MECHANISM": "+ Mechanism",
             "ADD_COMPONENT": "+ Component",
             "TEST": "Test"
+        },
+        "WARNING":{
+            "CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT": "This blocks calls a method on a private component in the {{mechanismClassName}} mechanism.",
+            "CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT": "This block calls a method on a component that no longer exists.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM": "This block calls a method on a component that belongs to a mechanism that no longer exists.",
+            "CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM": "This block is not allowed to be used inside a mechanism.",
+            "CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD": "This block calls a method that no longer exists in the robot.",
+            "CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM": "This block is not allowed to be used inside a mechanism.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD": "This block calls a method that no longer exists in the mechanism.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "This block calls a method in a mechanism that no longer exists."
         }
     }   
 }

src/i18n/locales/en/translation.json

@@ -63,6 +63,10 @@
         "DISPLAY_GROUP": "Grupo a Mostrar",
         "PRINT": "imprimir",
         "NO_MECHANISM_CONTENTS": "Sin Contenido de Mecanismo",
+        "CALL": "llamar",
+        "ROBOT": "robot",
+        "CREATE": "crear",
+        "FIRE": "disparar",
         "TOOLTIP": {
             "EVALUATE_BUT_IGNORE_RESULT": "Ejecuta el bloque conectado e ignora el resultado. Te permite llamar una función e ignorar el valor de retorno.",
             "NONE": "No devuelve ninguno.",
@@ -71,7 +75,18 @@
             "OPMODE_NAME": "El nombre mostrado en la Estación del Conductor. Si está en blanco usará el nombre de la clase.",
             "OPMODE_GROUP": "Un grupo opcional para agrupar OpModes en la Estación del Conductor",
             "COMPONENTS": "Estos componentes son visibles en este mecanismo, el robot y todos los opmodes.",
-            "PRIVATE_COMPONENTS": "Estos componentes no serán visibles en el robot o en los opmodes. Solo son accesibles dentro de este mecanismo."
+            "PRIVATE_COMPONENTS": "Estos componentes no serán visibles en el robot o en los opmodes. Solo son accesibles dentro de este mecanismo.",
+            "CALL_BUILTIN_FUNCTION": "Llama a la función incorporada {{functionName}}.",
+            "CALL_MODULE_FUNCTION": "Llama a la función del módulo {{moduleName}}.{{functionName}}.",
+            "CALL_STATIC_METHOD": "Llama al método estático {{className}}.{{functionName}}.",
+            "CALL_CONSTRUCTOR": "Construye una instancia de la clase {{className}}.",
+            "CALL_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}}.",
+            "CALL_INSTANCE_METHOD_WITHIN": "Llama al método de instancia {{functionName}}.",
+            "FIRE_EVENT": "Dispara el evento llamado {{eventName}}.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}} en el componente llamado {{componentName}} en el mecanismo llamado {{mechanismName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}} en el componente llamado {{componentName}}.",
+            "CALL_ROBOT_INSTANCE_METHOD": "Llama al método robot {{functionName}}.",
+            "CALL_MECHANISM_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}} en el mecanismo llamado {{mechanismName}}."
         },
         "CATEGORY": {
             "LISTS": "Listas",
@@ -90,6 +105,16 @@
             "ADD_MECHANISM": "+ Mecanismo",
             "ADD_COMPONENT": "+ Componente",
             "TEST": "Prueba"
+        },
+        "WARNING":{
+            "CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT": "Este bloque llama a un método en un componente privado en el mecanismo {{mechanismClassName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT": "Este bloque llama a un método en un componente que ya no existe.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM": "Este bloque llama a un método de un componente que pertenece a un mecanismo que ya no existe.",
+            "CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM": "No se permite utilizar este bloque dentro de un mecanismo.",
+            "CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD": "Este bloque llama a un método que ya no existe en el robot.",
+            "CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM": "No se permite utilizar este bloque dentro de un mecanismo.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD": "Este bloque llama a un método que ya no existe en el mecanismo.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "Este bloque llama a un método en un mecanismo que ya no existe."
         }
     }
 }