Adds event support

Author: alan412

src/App.tsx

@@ -46,7 +46,7 @@ import * as clientSideStorage from './storage/client_side_storage';
 import * as CustomBlocks from './blocks/setup_custom_blocks';
 import { initialize as initializePythonBlocks } from './blocks/utils/python';
 import * as ChangeFramework from './blocks/utils/change_framework'
-import { mutatorOpenListener } from './blocks/mrc_class_method_def'
+import { mutatorOpenListener } from './blocks/mrc_param_container'
 
 const App: React.FC = () => {
   const [alertErrorMessage, setAlertErrorMessage] = React.useState('');

src/blocks/mrc_call_python_function.ts

@@ -40,16 +40,17 @@ import * as toolboxItems from '../toolbox/items';
 
 export const BLOCK_NAME = 'mrc_call_python_function';
 
-enum FunctionKind {
+export enum FunctionKind {
   MODULE = 'module',
   STATIC = 'static',
   CONSTRUCTOR = 'constructor',
   INSTANCE = 'instance',
   INSTANCE_WITHIN = 'instance_within',
-  INSTANCE_COMPONENT = 'instance_component'
+  INSTANCE_COMPONENT = 'instance_component',
+  EVENT = 'event',
 }
 
-const RETURN_TYPE_NONE = 'None';
+export const RETURN_TYPE_NONE = 'None';
 
 const FIELD_MODULE_OR_CLASS_NAME = 'MODULE_OR_CLASS';
 const FIELD_FUNCTION_NAME = 'FUNC';
@@ -318,6 +319,11 @@ const CALL_PYTHON_FUNCTION = {
           tooltip = 'Calls the instance method ' + functionName + '.';
           break;
         }
+        case FunctionKind.EVENT: {
+          const functionName = this.getFieldValue(FIELD_FUNCTION_NAME);
+          tooltip = 'Fires the event ' + functionName + '.';
+          break;
+        }
         case FunctionKind.INSTANCE_COMPONENT: {
           const className = this.mrcComponentClassName;
           const functionName = this.getFieldValue(FIELD_FUNCTION_NAME);
@@ -459,6 +465,15 @@ const CALL_PYTHON_FUNCTION = {
           }
           break;
         }
+        case FunctionKind.EVENT: {
+          const input = this.getInput('TITLE');
+          if (!input) {
+            this.appendDummyInput('TITLE')
+                .appendField('fire')
+                .appendField(createFieldNonEditableText(''), FIELD_FUNCTION_NAME);
+          }
+          break;
+        }
         case FunctionKind.INSTANCE_COMPONENT: {
           const componentNames = Editor.getComponentNames(this.workspace, this.mrcComponentClassName);
           const componentName = this.getComponentName();
@@ -586,6 +601,12 @@ export const pythonFromBlock = function(
       code = 'self.' + functionName;
       break;
     }
+    case FunctionKind.EVENT: {
+      const blocklyName = block.getFieldValue(FIELD_FUNCTION_NAME);
+      const functionName = generator.getProcedureName(blocklyName);
+      code = 'if self.events.get("' + functionName + '", None):\n' + generator.INDENT + 'self.events["' + functionName + '"]';
+      break;
+    }
     case FunctionKind.INSTANCE_COMPONENT: {
       const componentName = callPythonFunctionBlock.getComponentName();
       const functionName = callPythonFunctionBlock.mrcActualFunctionName

src/blocks/mrc_class_method_def.ts

@@ -23,20 +23,15 @@ import * as Blockly from 'blockly';
 import { MRC_STYLE_CLASS_BLOCKS } from '../themes/styles';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText'
 import { createFieldFlydown } from '../fields/field_flydown';
-import * as ChangeFramework from './utils/change_framework'
-import { getLegalName } from './utils/python';
 import { Order } from 'blockly/python';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import { renameMethodCallers, mutateMethodCallers } from './mrc_call_python_function'
 import { findConnectedBlocksOfType } from './utils/find_connected_blocks';
 import { BLOCK_NAME as MRC_GET_PARAMETER_BLOCK_NAME } from './mrc_get_parameter';
-
+import { MUTATOR_BLOCK_NAME, PARAM_CONTAINER_BLOCK_NAME, MethodMutatorArgBlock } from './mrc_param_container'
 
 export const BLOCK_NAME = 'mrc_class_method_def';
 
-export const MUTATOR_BLOCK_NAME = 'methods_mutatorarg';
-const PARAM_CONTAINER_BLOCK_NAME = 'method_param_container';
-
 export type Parameter = {
     name: string,
     type?: string,
@@ -314,133 +309,8 @@ function isMethodNameUsed(
     return false;
 }
 
-const METHOD_PARAM_CONTAINER = {
-    init: function (this: Blockly.Block) {
-        this.appendDummyInput("TITLE").appendField('Parameters');
-        this.appendStatementInput('STACK');
-        this.setStyle(MRC_STYLE_CLASS_BLOCKS);
-        this.contextMenu = false;
-    },
-};
-
-type MethodMutatorArgBlock = Blockly.Block & MethodMutatorArgMixin & Blockly.BlockSvg;
-interface MethodMutatorArgMixin extends MethodMutatorArgMixinType {
-    originalName: string,
-}
-
-type MethodMutatorArgMixinType = typeof METHODS_MUTATORARG;
-
-function setName(block: Blockly.BlockSvg) {
-    const parentBlock = ChangeFramework.getParentOfType(block, PARAM_CONTAINER_BLOCK_NAME);
-    if (parentBlock) {
-        const variableBlocks = parentBlock!.getDescendants(true)
-        const otherNames: string[] = []
-        variableBlocks?.forEach(function (variableBlock) {
-            if (variableBlock != block) {
-                otherNames.push(variableBlock.getFieldValue('NAME'));
-            }
-        });
-        const currentName = block.getFieldValue('NAME');
-        block.setFieldValue(getLegalName(currentName, otherNames), 'NAME');
-        updateMutatorFlyout(block.workspace);
-    }
-}
-
-const METHODS_MUTATORARG = {
-    init: function (this: MethodMutatorArgBlock) {
-        this.appendDummyInput()
-            .appendField(new Blockly.FieldTextInput(Blockly.Procedures.DEFAULT_ARG), 'NAME');
-        this.setPreviousStatement(true);
-        this.setNextStatement(true);
-        this.setStyle(MRC_STYLE_CLASS_BLOCKS);
-        this.originalName = '';
-        this.contextMenu = false;
-        ChangeFramework.registerCallback(MUTATOR_BLOCK_NAME, [Blockly.Events.BLOCK_MOVE, Blockly.Events.BLOCK_CHANGE], this.onBlockChanged);
-    },
-    onBlockChanged: function (block: Blockly.BlockSvg, blockEvent: Blockly.Events.BlockBase) {
-        if (blockEvent.type == Blockly.Events.BLOCK_MOVE) {
-            let blockMoveEvent = blockEvent as Blockly.Events.BlockMove;
-            if (blockMoveEvent.reason?.includes('connect')) {
-                setName(block);
-            }
-        }
-        else {
-            if (blockEvent.type == Blockly.Events.BLOCK_CHANGE) {
-                setName(block);
-            }
-        }
-    },
-}
-
-
-/**
- * Updates the procedure mutator's flyout so that the arg block is not a
- * duplicate of another arg.
- *
- * @param workspace The procedure mutator's workspace. This workspace's flyout
- *     is what is being updated.
- */
-function updateMutatorFlyout(workspace: Blockly.WorkspaceSvg) {
-    const usedNames = [];
-    const blocks = workspace.getBlocksByType(MUTATOR_BLOCK_NAME, false);
-    for (let i = 0, block; (block = blocks[i]); i++) {
-        usedNames.push(block.getFieldValue('NAME'));
-    }
-    const argValue = Blockly.Variables.generateUniqueNameFromOptions(
-        Blockly.Procedures.DEFAULT_ARG,
-        usedNames,
-    );
-    const jsonBlock = {
-        kind: 'block',
-        type: MUTATOR_BLOCK_NAME,
-        fields: {
-            NAME: argValue,
-        },
-    };
-
-    workspace.updateToolbox({ contents: [jsonBlock] });
-}
-
-
-/**
- * Listens for when a procedure mutator is opened. Then it triggers a flyout
- * update and adds a mutator change listener to the mutator workspace.
- *
- * @param e The event that triggered this listener.
- * @internal
- */
-export function mutatorOpenListener(e: Blockly.Events.Abstract) {
-    if (e.type != Blockly.Events.BUBBLE_OPEN) {
-        return;
-    }
-    const bubbleEvent = e as Blockly.Events.BubbleOpen;
-    if (
-        !(bubbleEvent.bubbleType === 'mutator' && bubbleEvent.isOpen) ||
-        !bubbleEvent.blockId
-    ) {
-        return;
-    }
-    const workspaceId = bubbleEvent.workspaceId;
-    const block = Blockly.common
-        .getWorkspaceById(workspaceId)!
-        .getBlockById(bubbleEvent.blockId) as Blockly.BlockSvg;
-
-    if (block.type !== BLOCK_NAME) {
-        return;
-    }
-    const workspace = (
-        block.getIcon(Blockly.icons.MutatorIcon.TYPE) as Blockly.icons.MutatorIcon
-    ).getWorkspace()!;
-
-    updateMutatorFlyout(workspace);
-    ChangeFramework.setup(workspace);
-}
-
-
 export const setup = function () {
     Blockly.Blocks[BLOCK_NAME] = CLASS_METHOD_DEF;
-    Blockly.Blocks[MUTATOR_BLOCK_NAME] = METHODS_MUTATORARG;
-    Blockly.Blocks[PARAM_CONTAINER_BLOCK_NAME] = METHOD_PARAM_CONTAINER;
 };
 
 export const pythonFromBlock = function (

src/blocks/mrc_event.ts

@@ -24,7 +24,9 @@ import { Order } from 'blockly/python';
 
 import { MRC_STYLE_EVENTS } from '../themes/styles'
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
-import { MUTATOR_BLOCK_NAME } from './mrc_class_method_def'
+import { MUTATOR_BLOCK_NAME, PARAM_CONTAINER_BLOCK_NAME, MethodMutatorArgBlock } from './mrc_param_container'
+import * as ChangeFramework from './utils/change_framework';
+import { BLOCK_NAME as MRC_MECHANISM_COMPONENT_HOLDER } from './mrc_mechanism_component_holder';
 
 export const BLOCK_NAME = 'mrc_event';
 export const OUTPUT_NAME = 'mrc_event';
@@ -38,10 +40,10 @@ type EventExtraState = {
   params?: Parameter[],
 }
 
-type EventBlock = Blockly.Block & EventMixin & Blockly.BlockSvg;
+export type EventBlock = Blockly.Block & EventMixin & Blockly.BlockSvg;
 
 interface EventMixin extends EventMixinType {
-  mrcParams: Parameter[],
+  mrcParameters: Parameter[],
 }
 type EventMixinType = typeof EVENT;
 
@@ -51,11 +53,12 @@ const EVENT = {
     */
   init: function (this: EventBlock): void {
     this.setStyle(MRC_STYLE_EVENTS);
-    this.appendDummyInput()
+    this.appendDummyInput("TITLE")
       .appendField(new Blockly.FieldTextInput('my_event'), 'NAME');
     this.setPreviousStatement(true, OUTPUT_NAME);
     this.setNextStatement(true, OUTPUT_NAME);
     this.setMutator(new Blockly.icons.MutatorIcon([MUTATOR_BLOCK_NAME], this));
+    ChangeFramework.registerCallback(BLOCK_NAME, [Blockly.Events.BLOCK_MOVE], this.onBlockChanged);
   },
 
   /**
@@ -65,8 +68,8 @@ const EVENT = {
     const extraState: EventExtraState = {
     };
     extraState.params = [];
-    if (this.mrcParams) {
-      this.mrcParams.forEach((arg) => {
+    if (this.mrcParameters) {
+      this.mrcParameters.forEach((arg) => {
         extraState.params!.push({
           'name': arg.name,
           'type': arg.type,
@@ -79,24 +82,117 @@ const EVENT = {
   * Applies the given state to this block.
   */
   loadExtraState: function (this: EventBlock, extraState: EventExtraState): void {
-    this.mrcParams = [];
+    this.mrcParameters = [];
 
     if (extraState.params) {
       extraState.params.forEach((arg) => {
-        this.mrcParams.push({
+        this.mrcParameters.push({
           'name': arg.name,
           'type': arg.type,
         });
       });
     }
-    this.mrcParams = extraState.params ? extraState.params : [];
+    this.mrcParameters = extraState.params ? extraState.params : [];
     this.updateBlock_();
   },
   /**
      * Update the block to reflect the newly loaded extra state.
      */
   updateBlock_: function (this: EventBlock): void {
-  }
+    const name = this.getFieldValue('NAME');
+    const input = this.getInput('TITLE');
+    if (!input) {
+      return;
+    }
+    input.removeField('NAME');
+
+    const nameField = new Blockly.FieldTextInput(name);
+    input.insertFieldAt(0, nameField, 'NAME');
+    this.setMutator(new Blockly.icons.MutatorIcon([MUTATOR_BLOCK_NAME], this));
+    // nameField.setValidator(this.mrcNameFieldValidator.bind(this, nameField));
+
+    this.mrcUpdateParams();
+  },
+  compose: function (this: EventBlock, containerBlock: any) {
+    // Parameter list.
+    this.mrcParameters = [];
+
+    let paramBlock = containerBlock.getInputTargetBlock('STACK');
+    while (paramBlock) {
+      const param: Parameter = {
+        name: paramBlock.getFieldValue('NAME'),
+        type: ''
+      }
+      if (paramBlock.originalName) {
+        // This is a mutator arg block, so we can get the original name.
+        paramBlock.originalName = param.name;
+      }
+      this.mrcParameters.push(param);
+      paramBlock =
+        paramBlock.nextConnection && paramBlock.nextConnection.targetBlock();
+    }
+    this.mrcUpdateParams();
+    //mutateMethodCallers(this.workspace, this.getFieldValue('NAME'), this.saveExtraState());
+  },
+  decompose: function (this: EventBlock, workspace: Blockly.Workspace) {
+    // This is a special sub-block that only gets created in the mutator UI.
+    // It acts as our "top block"
+    const topBlock = workspace.newBlock(PARAM_CONTAINER_BLOCK_NAME);
+    (topBlock as Blockly.BlockSvg).initSvg();
+
+    // Then we add one sub-block for each item in the list.
+    let connection = topBlock!.getInput('STACK')!.connection;
+
+    for (let i = 0; i < this.mrcParameters.length; i++) {
+      let itemBlock = workspace.newBlock(MUTATOR_BLOCK_NAME);
+      (itemBlock as Blockly.BlockSvg).initSvg();
+      itemBlock.setFieldValue(this.mrcParameters[i].name, 'NAME');
+      (itemBlock as MethodMutatorArgBlock).originalName = this.mrcParameters[i].name;
+
+      connection!.connect(itemBlock.previousConnection!);
+      connection = itemBlock.nextConnection;
+    }
+    return topBlock;
+  },
+  mrcUpdateParams: function (this: EventBlock) {
+    if (this.mrcParameters.length > 0) {
+      let input = this.getInput('TITLE');
+      if (input) {
+        this.removeParameterFields(input);
+        this.mrcParameters.forEach((param) => {
+          const paramName = 'PARAM_' + param.name;
+          const field = new Blockly.FieldTextInput(param.name);
+          field.EDITABLE = false;
+          input.appendField(field, paramName);
+        });
+      }
+    }
+  },
+  removeParameterFields: function (input: Blockly.Input) {
+    const fieldsToRemove = input.fieldRow
+      .filter(field => field.name?.startsWith('PARAM_'))
+      .map(field => field.name!);
+
+    fieldsToRemove.forEach(fieldName => {
+      input.removeField(fieldName);
+    });
+  },
+  onBlockChanged(block: Blockly.BlockSvg, blockEvent: Blockly.Events.BlockBase): void {
+      const blockBlock = block as Blockly.Block;
+  
+      if (blockEvent.type === Blockly.Events.BLOCK_MOVE) {
+        const parent = ChangeFramework.getParentOfType(block, MRC_MECHANISM_COMPONENT_HOLDER);
+        
+        if (parent) {
+              // If it is, we allow it to stay.
+              blockBlock.setWarningText(null);
+              return;
+            }
+        // If we end up here it shouldn't be allowed
+        block.unplug(true);
+        blockBlock.setWarningText('Events can only go in the events block');
+      }
+    },
 }
 
 export const setup = function () {