Let the user add event handlers to an opmode, for events defined in the robot (#175)

* In common_storage.ts, save the events declared in the module.

In mrc_event_handler.ts:
  Refactored hardcoded fields names into constants FIELD_SENDER and FIELD_EVENT_NAME.
  Added otherBlockId to EventHandlerExtraState and mrcOtherBlockId to EventHandlerMixin.
  Added onLoad method that updates event handler blocks if the event definition has been changed.
  Added functions addRobotEventHandlerBlocks and createRobotEventHandlerBlock to create blocks for the toolbox.

In editor.ts, added method getEventsFromRobot.

In hardware_category.ts, added function getRobotEventsBlocks and call it in getHardwareCategory when the current module is an opmode.

* In extended_python_generator.ts:
  Added fields hasHardware and hasEventHandler. Set these in mrcWorkspaceToCode before calling super.workspaceToCode.
  Renamed method defineClassVariables to generateInitStatements. Renamed local variable variableDefinitions to initStatements.
  Removed setHasHardware and addHardwarePort.

In mrc_components.ts, added methods getNewPort and getHardwarePorts. getHardwarePorts collects the hardware ports and is called by extended_python_generator before we start generating python for blocks. (Previous code called addHardwarePort when the mrc_component blocks was generating python, but that is too late.)

In mrc_event_handler.ts, added function getHasEventHandler. This is used to determine whether the generated __init__ method needs to call register_events.

In generator_context.ts, removed hasHardware, clear(), setHasHardware(), and getHasHardware().

In mrc_call_python_function.ts, use forEach loops where possible. Use BLOCK_NAME instead of 'mrc_call_python_function'.

Moved code that iterates through mrc_mechanism_component_holder blocks from editor.ts
to mrc_mechanism_component_holder.ts functions getComponents and getEvents.
In mrc_mechanism_component_holder.ts added function getHardwarePorts to collect ports needed for define_hardware.

Moved code that iterates through mrc_class_method_def blocks from editor.ts
to mrc_class_method_def.ts functions getMethodsForWithin, getMethodsForOutside,
and getMethodNamesAlreadyOverriddenInWorkspace.

In robot_base.py, added register_event and unregister_event methods.

In methods_category.ts, don't show blocks for robot methods register_event and unregister_event.

* Fixed typescript errors.

* In robot_base.py:
  Rename register_event and unregister_event to register_event_handler and unregister_event_handler.
  Allow multiple handlers to be registered for an event.
  Add fire_event function.

Changed python code for firing an event to call fire_event.

When determining whether a workspace has hardware or events, check whether blocks are enabled.

Author: lizlooney

server_python_scripts/blocks_base_classes/__init__.py

@@ -5,4 +5,4 @@
 from .robot_base import RobotBase
 
 __all__ = ['OpMode', 'Teleop', 'Auto', 'Test', 'Name', 'Group'
-           'Mechanism', 'RobotBase']
+           'Mechanism', 'RobotBase']

server_python_scripts/blocks_base_classes/robot_base.py

@@ -1,14 +1,39 @@
 # This is the class all robots derive from
 
+from typing import Callable
+
 class RobotBase:
     def __init__(self):
         self.hardware = []
+        # In self.event_handlers, the keys are the event names, the values are a list of handlers.
+        self.event_handlers = {}
+
+    def register_event_handler(self, event_name: str, event_handler: Callable) -> None:
+        if event_name in self.event_handlers:
+            self.event_handlers[event_name].append(event_handler)
+        else:
+            self.event_handlers[event_name] = [event_handler]
+
+    def unregister_event_handler(self, event_name: str, event_handler: Callable) -> None:
+        if event_name in self.event_handlers:
+            if event_handler in self.event_handlers[event_name]:
+                self.event_handlers[event_name].remove(event_handler)
+                if not self.event_handlers[event_name]:
+                    del self.event_handlers[event_name]
+
+    def fire_event(self, event_name: str, *args) -> None:
+        if event_name in self.event_handlers:
+            for event_handler in self.event_handlers[event_name]:
+                event_handler(*args)
+
     def start(self) -> None:
         for hardware in self.hardware:
             hardware.start()
+
     def update(self) -> None:
         for hardware in self.hardware:
             hardware.update()
+
     def stop(self) -> None:
         for hardware in self.hardware:
             hardware.stop()

src/blocks/mrc_call_python_function.ts

@@ -588,6 +588,8 @@ export const pythonFromBlock = function(
     generator.addImport(callPythonFunctionBlock.mrcImportModule);
   }
   let code;
+  let needOpenParen = true;
+  let delimiterBeforeArgs = '';
   let argStartIndex = 0;
   switch (callPythonFunctionBlock.mrcFunctionKind) {
     case FunctionKind.BUILT_IN: {
@@ -637,9 +639,9 @@ export const pythonFromBlock = function(
     }
     case FunctionKind.EVENT: {
       const eventName = block.getFieldValue(FIELD_EVENT_NAME);
-      code = 
-          'if self.events.get("' + eventName + '", None):\n' +
-          generator.INDENT + 'self.events["' + eventName + '"]';
+      code = 'self.fire_event("' + eventName + '"';
+      needOpenParen = false;
+      delimiterBeforeArgs = ', ';
       break;
     }
     case FunctionKind.INSTANCE_COMPONENT: {
@@ -671,7 +673,14 @@ export const pythonFromBlock = function(
     default:
       throw new Error('mrcFunctionKind has unexpected value: ' + callPythonFunctionBlock.mrcFunctionKind)
   }
-  code += '(' + generateCodeForArguments(callPythonFunctionBlock, generator, argStartIndex) + ')';
+  if (needOpenParen) {
+    code += '(';
+  }
+  const codeForArgs = generateCodeForArguments(callPythonFunctionBlock, generator, argStartIndex);
+  if (codeForArgs) {
+    code += delimiterBeforeArgs + codeForArgs;
+  }
+  code += ')';
   if (block.outputConnection) {
     return [code, Order.FUNCTION_CALL];
   } else {
@@ -699,22 +708,22 @@ function generateCodeForArguments(
 }
 
 function getMethodCallers(workspace: Blockly.Workspace, otherBlockId: string): Blockly.Block[] {
-  return workspace.getBlocksByType('mrc_call_python_function').filter((block) => {
+  return workspace.getBlocksByType(BLOCK_NAME).filter((block) => {
     return (block as CallPythonFunctionBlock).mrcOtherBlockId === otherBlockId;
   });
 }
 
 export function renameMethodCallers(workspace: Blockly.Workspace, otherBlockId: string, newName: string): void {
-  for (const block of getMethodCallers(workspace, otherBlockId)) {
+  getMethodCallers(workspace, otherBlockId).forEach(block => {
     (block as CallPythonFunctionBlock).renameMethodCaller(newName);
-  }
+  });
 }
 
 export function mutateMethodCallers(
     workspace: Blockly.Workspace, otherBlockId: string, methodOrEvent: commonStorage.Method | commonStorage.Event) {
   const oldRecordUndo = Blockly.Events.getRecordUndo();
 
-  for (const block of getMethodCallers(workspace, otherBlockId)) {
+  getMethodCallers(workspace, otherBlockId).forEach(block => {
     const callBlock = block as CallPythonFunctionBlock;
     // Get the extra state before changing the call block.
     const oldExtraState = callBlock.saveExtraState();
@@ -738,7 +747,7 @@ export function mutateMethodCallers(
       );
       Blockly.Events.setRecordUndo(oldRecordUndo);
     }
-  }
+  });
 }
 
 // Functions used for creating blocks for the toolbox.

src/blocks/mrc_class_method_def.ts

@@ -36,7 +36,7 @@ import { MUTATOR_BLOCK_NAME, PARAM_CONTAINER_BLOCK_NAME, MethodMutatorArgBlock }
 
 export const BLOCK_NAME = 'mrc_class_method_def';
 
-const FIELD_METHOD_NAME = 'NAME';
+export const FIELD_METHOD_NAME = 'NAME';
 
 type Parameter = {
     name: string,
@@ -347,7 +347,7 @@ function findLegalMethodName(name: string, block: ClassMethodDefBlock): string {
 function isMethodNameUsed(
     name: string, workspace: Blockly.Workspace, opt_exclude?: Blockly.Block): boolean {
     const nameLowerCase = name.toLowerCase();
-    for (const block of workspace.getBlocksByType('mrc_class_method_def')) {
+    for (const block of workspace.getBlocksByType(BLOCK_NAME)) {
         if (block === opt_exclude) {
             continue;
         }
@@ -409,7 +409,7 @@ export const pythonFromBlock = function (
     if (block.mrcPythonMethodName == '__init__') {
         let class_specific = generator.getClassSpecificForInit();
         branch = generator.INDENT + 'super().__init__(' + class_specific + ')\n' +
-            generator.defineClassVariables() + branch;
+            generator.generateInitStatements() + branch;
     }
     else if (generator.inBaseClassMethod(blocklyName)){
         // Special case for methods inherited from the based class: generate the
@@ -510,3 +510,40 @@ function createClassMethodDefBlock(
   fields[FIELD_METHOD_NAME] = functionData.functionName;
   return new toolboxItems.Block(BLOCK_NAME, extraState, fields, null);
 }
+
+// Misc
+
+export function getMethodsForWithin(
+    workspace: Blockly.Workspace,
+    methods: commonStorage.Method[]): void {
+  workspace.getBlocksByType(BLOCK_NAME).forEach(block => {
+    const method = (block as ClassMethodDefBlock).getMethodForWithin();
+    if (method) {
+      methods.push(method);
+    }
+  });
+}
+
+export function getMethodsForOutside(
+    workspace: Blockly.Workspace,
+    methods: commonStorage.Method[]): void {
+  workspace.getBlocksByType(BLOCK_NAME).forEach(block => {
+    const method = (block as ClassMethodDefBlock).getMethodForOutside();
+    if (method) {
+      methods.push(method);
+    }
+  });
+}
+
+export function getMethodNamesAlreadyOverriddenInWorkspace(
+    workspace: Blockly.Workspace,
+    methodNamesAlreadyOverridden: string[]): void {
+  workspace.getBlocksByType(BLOCK_NAME).forEach(block => {
+    const methodDefBlock = block as ClassMethodDefBlock;
+    // If the user cannot change the signature, it means the block defines a method that overrides a baseclass method.
+    // That's what we are looking for here.
+    if (!methodDefBlock.canChangeSignature()) {
+      methodNamesAlreadyOverridden.push(methodDefBlock.getMethodName());
+    }
+  });
+}

src/blocks/mrc_component.ts

@@ -39,7 +39,7 @@ export const OUTPUT_NAME = 'mrc_component';
 export const FIELD_NAME = 'NAME';
 export const FIELD_TYPE = 'TYPE';
 
-export type ConstructorArg = {
+type ConstructorArg = {
   name: string,
   type: string,
 };
@@ -146,6 +146,23 @@ const COMPONENT = {
       className: componentType,
     };
   },
+  getNewPort: function (this: ComponentBlock, i: number): string {
+    let extension = '';
+    if (i != 0) {
+      extension = '_' + (i + 1).toString();
+    }
+    return this.getFieldValue(FIELD_NAME) + extension + '_port';
+  },
+  getHardwarePorts: function (this: ComponentBlock, ports: {[key: string]: string}): void {
+    // Collect the hardware ports for this component block that are needed to generate
+    // the define_hardware method. (The key is the port, the value is the type.)
+    if (this.hideParams) {
+      for (let i = 0; i < this.mrcArgs.length; i++) {
+        const newPort = this.getNewPort(i);
+        ports[newPort] = this.mrcArgs[i].type;
+      }
+    }
+  },
 }
 
 export const setup = function () {
@@ -171,13 +188,7 @@ export const pythonFromBlock = function (
       code += ', '
     }
     if (block.hideParams) {
-      let extension = '';
-      if (i != 0) {
-        extension = '_' + (i + 1).toString();
-      }
-      const newPort = block.getFieldValue(FIELD_NAME) + extension + '_port';
-      generator.addHardwarePort(newPort, block.mrcArgs[i].type);
-      code += block.mrcArgs[i].name + ' = ' + newPort; 
+      code += block.mrcArgs[i].name + ' = ' + block.getNewPort(i);
     } else {
       code += block.mrcArgs[i].name + ' = ' + generator.valueToCode(block, fieldName, Order.NONE);
     }

src/blocks/mrc_event.ts

@@ -230,8 +230,8 @@ export const setup = function () {
 }
 
 export const pythonFromBlock = function (
-  block: EventBlock,
-  generator: ExtendedPythonGenerator) {
+    _block: EventBlock,
+    _generator: ExtendedPythonGenerator) {
   // TODO (Alan): What should this do here??
   return '';
 }