In editor.ts: (#262)

Added code to onChangeAfterLoading to handle MOVE events. If the block being moved has a mrcOnMove method, call it.

In mrc_event.ts:
Added constants INPUT_TITLE, FIELD_PARAM_PREFIX, and WARNING_ID_NOT_IN_HOLDER.
Removed call to ChangeFramework.registerCallback.
Removed onBlockChanged.
Added mrcHasWarning to EventMixin.
Added mrcOnLoad so that the block is checked when the block is loaded.
Added mrcOnMove so that the block is checked when the block is moved.

Author: lizlooney

src/blocks/mrc_event.ts

@@ -24,7 +24,6 @@ import * as Blockly from 'blockly';
 import { MRC_STYLE_EVENTS } from '../themes/styles'
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 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';
 import * as toolboxItems from '../toolbox/items';
 import * as storageModuleContent from '../storage/module_content';
@@ -33,13 +32,17 @@ import { renameMethodCallers, mutateMethodCallers } from './mrc_call_python_func
 export const BLOCK_NAME = 'mrc_event';
 export const OUTPUT_NAME = 'mrc_event';
 
+const INPUT_TITLE = 'TITLE';
 const FIELD_EVENT_NAME = 'NAME';
+const FIELD_PARAM_PREFIX = 'PARAM_';
 
 type Parameter = {
   name: string,
   type?: string,
 };
 
+const WARNING_ID_NOT_IN_HOLDER = 'not in holder';
+
 type EventExtraState = {
   eventId?: string,
   params?: Parameter[],
@@ -50,6 +53,14 @@ export type EventBlock = Blockly.Block & EventMixin & Blockly.BlockSvg;
 interface EventMixin extends EventMixinType {
   mrcEventId: string,
   mrcParameters: Parameter[],
+
+  /**
+   * mrcHasWarning is set to true if we set the warning text on the block. It is checked to avoid
+   * adding a warning if there already is one. Otherwise, if we get two move events (one for drag
+   * and one for snap), and we call setWarningText for both events, we get a detached warning
+   * balloon. See https://github.com/wpilibsuite/systemcore-blocks-interface/issues/248.
+   */
+  mrcHasWarning: boolean,
 }
 type EventMixinType = typeof EVENT;
 
@@ -59,12 +70,11 @@ const EVENT = {
    */
   init: function (this: EventBlock): void {
     this.setStyle(MRC_STYLE_EVENTS);
-    this.appendDummyInput("TITLE")
+    this.appendDummyInput(INPUT_TITLE)
       .appendField(new Blockly.FieldTextInput('my_event'), FIELD_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);
   },
 
   /**
@@ -91,6 +101,7 @@ const EVENT = {
   loadExtraState: function (this: EventBlock, extraState: EventExtraState): void {
     this.mrcEventId = extraState.eventId ? extraState.eventId : this.id;
     this.mrcParameters = [];
+    this.mrcHasWarning = false;
 
     if (extraState.params) {
       extraState.params.forEach((arg) => {
@@ -108,7 +119,7 @@ const EVENT = {
    */
   updateBlock_: function (this: EventBlock): void {
     const name = this.getFieldValue(FIELD_EVENT_NAME);
-    const input = this.getInput('TITLE');
+    const input = this.getInput(INPUT_TITLE);
     if (!input) {
       return;
     }
@@ -136,8 +147,7 @@ const EVENT = {
         paramBlock.originalName = param.name;
       }
       this.mrcParameters.push(param);
-      paramBlock =
-        paramBlock.nextConnection && paramBlock.nextConnection.targetBlock();
+      paramBlock = paramBlock.nextConnection && paramBlock.nextConnection.targetBlock();
     }
     this.mrcUpdateParams();
     mutateMethodCallers(this.workspace, this.mrcEventId, this.getEvent());
@@ -152,7 +162,7 @@ const EVENT = {
     let connection = topBlock!.getInput('STACK')!.connection;
 
     for (let i = 0; i < this.mrcParameters.length; i++) {
-      let itemBlock = workspace.newBlock(MUTATOR_BLOCK_NAME);
+      const 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;
@@ -164,11 +174,11 @@ const EVENT = {
   },
   mrcUpdateParams: function (this: EventBlock) {
     if (this.mrcParameters.length > 0) {
-      let input = this.getInput('TITLE');
+      const input = this.getInput(INPUT_TITLE);
       if (input) {
         this.removeParameterFields(input);
         this.mrcParameters.forEach((param) => {
-          const paramName = 'PARAM_' + param.name;
+          const paramName = FIELD_PARAM_PREFIX + param.name;
           const field = new Blockly.FieldTextInput(param.name);
           field.EDITABLE = false;
           input.appendField(field, paramName);
@@ -178,7 +188,7 @@ const EVENT = {
   },
   removeParameterFields: function (input: Blockly.Input) {
     const fieldsToRemove = input.fieldRow
-      .filter(field => field.name?.startsWith('PARAM_'))
+      .filter(field => field.name?.startsWith(FIELD_PARAM_PREFIX))
       .map(field => field.name!);
 
     fieldsToRemove.forEach(fieldName => {
@@ -197,21 +207,33 @@ const EVENT = {
     }
     return legalName;
   },
-  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;
+  /**
+   * mrcOnLoad is called for each EventBlock when the blocks are loaded in the blockly workspace.
+   */
+  mrcOnLoad: function(this: EventBlock): void {
+    this.checkParentIsHolder();
+  },
+  /**
+   * mrcOnLoad is called when an EventBlock is moved.
+   */
+  mrcOnMove: function(this: EventBlock): void {
+    this.checkParentIsHolder();
+  },
+  checkParentIsHolder: function(this: EventBlock): void {
+    const parentBlock = this.getParent();
+    if (parentBlock && parentBlock.type === MRC_MECHANISM_COMPONENT_HOLDER) {
+      // If the parent block is the mechanism_component_holder, the event block is allowed to stay.
+      // Remove any previous warning.
+      this.setWarningText(null, WARNING_ID_NOT_IN_HOLDER);
+      this.mrcHasWarning = false;
+    } else {
+      // Otherwise, add a warning to the block.
+      this.unplug(true);
+      if (!this.mrcHasWarning) {
+        this.setWarningText(Blockly.Msg.WARNING_EVENT_NOT_IN_HOLDER, WARNING_ID_NOT_IN_HOLDER);
+        this.getIcon(Blockly.icons.IconType.WARNING)!.setBubbleVisible(true);
+        this.mrcHasWarning = true;
       }
-      // If we end up here it shouldn't be allowed
-      block.unplug(true);
-      blockBlock.setWarningText('Events can only go in the events section of the robot or mechanism');
-      blockBlock.getIcon(Blockly.icons.IconType.WARNING)!.setBubbleVisible(true);
     }
   },
   getEvent: function (this: EventBlock): storageModuleContent.Event {

src/blocks/tokens.ts

@@ -84,6 +84,7 @@ export function customTokens(t: (key: string) => string): typeof Blockly.Msg {
     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'),
+    WARNING_EVENT_NOT_IN_HOLDER: t('BLOCKLY.WARNING.EVENT_NOT_IN_HOLDER'),
     MRC_CATEGORY_HARDWARE: t('BLOCKLY.CATEGORY.HARDWARE'),
     MRC_CATEGORY_ROBOT: t('BLOCKLY.CATEGORY.ROBOT'),
     MRC_CATEGORY_COMPONENTS: t('BLOCKLY.CATEGORY.COMPONENTS'),

src/editor/editor.ts

@@ -39,6 +39,7 @@ const EMPTY_TOOLBOX: Blockly.utils.toolbox.ToolboxInfo = {
 };
 
 const MRC_ON_LOAD = 'mrcOnLoad';
+const MRC_ON_MOVE = 'mrcOnMove';
 const MRC_VALIDATE = 'mrcValidate';
 
 export class Editor {
@@ -121,7 +122,17 @@ export class Editor {
     if (this.blocklyWorkspace.isDragging()) {
       return;
     }
-    // TODO(lizlooney): do we need to do anything here?
+
+    if (event.type === Blockly.Events.BLOCK_MOVE) {
+      const blockMoveEvent = event as Blockly.Events.BlockMove;
+      const block = this.blocklyWorkspace.getBlockById(blockMoveEvent.blockId!);
+      if (!block) {
+        return;
+      }
+      if (MRC_ON_MOVE in block && typeof block[MRC_ON_MOVE] === 'function') {
+        block[MRC_ON_MOVE]();
+      }
+    }
   }
 
   public makeCurrent(

src/i18n/locales/en/translation.json

@@ -141,7 +141,8 @@
             "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."
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "This block calls a method in a mechanism that no longer exists.",
+            "EVENT_NOT_IN_HOLDER": "This block can only go in the events section of the robot or mechanism."
         }
     }   
 }

src/i18n/locales/es/translation.json

@@ -142,7 +142,8 @@
             "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."
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "Este bloque llama a un método en un mecanismo que ya no existe.",
+            "EVENT_NOT_IN_HOLDER": "Este bloque solo puede ir en la sección de eventos del robot o mecanismo."
         }
     }
 }

src/i18n/locales/he/translation.json

@@ -141,7 +141,8 @@
       "CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD": "בלוק זה קורא למתודה שכבר לא קיימת ברובוט.",
       "CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM": "בלוק זה אינו מורשה לשימוש בתוך מנגנון.",
       "CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD": "בלוק זה קורא למתודה שכבר לא קיימת במנגנון.",
-      "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "בלוק זה קורא למתודה במנגנון שכבר לא קיים."
+      "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "בלוק זה קורא למתודה במנגנון שכבר לא קיים.",
+      "EVENT_NOT_IN_HOLDER": "בלוק זה יכול להיכנס רק לאזור האירועים של הרובוט או המנגנון."
     }
   }
 }