Merge branch 'main' into floating-promises

Author: microbit-matt-hillsdon

src/actions/enter.ts

@@ -16,13 +16,15 @@ import {
   icons,
   FocusableTreeTraverser,
   renderManagement,
+  comments,
+  getFocusManager,
 } from 'blockly/core';
 
 import type {Block} from 'blockly/core';
 
 import * as Constants from '../constants';
 import type {Navigation} from '../navigation';
-import {Mover} from './mover';
+import {Mover, MoveType} from './mover';
 import {
   showConstrainedMovementHint,
   showHelpHint,
@@ -124,10 +126,13 @@ export class EnterAction {
     ) {
       return !workspace.isReadOnly();
     }
-    if (curNode instanceof BlockSvg) return true;
     // Returning true is sometimes incorrect for icons, but there's no API to check.
-    if (curNode instanceof icons.Icon) return true;
-    return false;
+    return (
+      curNode instanceof BlockSvg ||
+      curNode instanceof icons.Icon ||
+      curNode instanceof comments.CommentBarButton ||
+      curNode instanceof comments.RenderedWorkspaceComment
+    );
   }
 
   /**
@@ -159,9 +164,20 @@ export class EnterAction {
       // opening a bubble of some sort. We then need to wait for the bubble to
       // appear before attempting to navigate into it.
       curNode.onClick();
-      void renderManagement.finishQueuedRenders().then(() => {
-        cursor?.in();
-      });
+      // This currently only works for MutatorIcons.
+      // See icon_navigation_policy.
+      if (curNode instanceof icons.MutatorIcon) {
+        void renderManagement.finishQueuedRenders().then(() => {
+          cursor?.in();
+        });
+      }
+      return true;
+    } else if (curNode instanceof comments.CommentBarButton) {
+      curNode.performAction();
+      return true;
+    } else if (curNode instanceof comments.RenderedWorkspaceComment) {
+      curNode.setCollapsed(false);
+      getFocusManager().focusNode(curNode.getEditorFocusableNode());
       return true;
     }
     return false;
@@ -185,19 +201,28 @@ export class EnterAction {
       Events.setGroup(true);
     }
 
-    const stationaryNode = FocusableTreeTraverser.findFocusedNode(workspace);
+    // If the workspace has never had focus default the stationary node.
+    const stationaryNode =
+      FocusableTreeTraverser.findFocusedNode(workspace) ??
+      workspace.getRestoredFocusableNode(null);
     const newBlock = this.createNewBlock(workspace);
     if (!newBlock) return;
     const insertStartPoint = stationaryNode
       ? this.navigation.findInsertStartPoint(stationaryNode, newBlock)
       : null;
+
     if (workspace.getTopBlocks().includes(newBlock)) {
       this.positionNewTopLevelBlock(workspace, newBlock);
     }
 
     workspace.setResizesEnabled(true);
 
-    this.mover.startMove(workspace, newBlock, insertStartPoint);
+    this.mover.startMove(
+      workspace,
+      newBlock,
+      MoveType.Insert,
+      insertStartPoint,
+    );
 
     const isStartBlock =
       !newBlock.outputConnection &&

src/actions/move.ts

@@ -5,17 +5,21 @@
  */
 
 import {
-  BlockSvg,
   ContextMenuRegistry,
   Msg,
   ShortcutRegistry,
   utils,
   WorkspaceSvg,
   keyboardNavigationController,
   getFocusManager,
+  comments,
+  IDraggable,
+  IFocusableNode,
+  IBoundedElement,
+  ISelectable,
 } from 'blockly';
 import {Direction} from '../drag_direction';
-import {Mover} from './mover';
+import {Mover, MoveType} from './mover';
 import {getMenuItem} from '../shortcut_formatting';
 
 const KeyCodes = utils.KeyCodes;
@@ -24,7 +28,7 @@ const createSerializedKey = ShortcutRegistry.registry.createSerializedKey.bind(
 );
 
 /**
- * Actions for moving blocks with keyboard shortcuts.
+ * Actions for moving workspace elements with keyboard shortcuts.
  */
 export class MoveActions {
   constructor(private mover: Mover) {}
@@ -38,19 +42,22 @@ export class MoveActions {
       {
         name: 'start_move',
         preconditionFn: (workspace) => {
-          const startBlock = this.getCurrentBlock(workspace);
-          return !!startBlock && this.mover.canMove(workspace, startBlock);
+          const startDraggable = this.getCurrentDraggable(workspace);
+          return (
+            !!startDraggable && this.mover.canMove(workspace, startDraggable)
+          );
         },
         callback: (workspace) => {
           keyboardNavigationController.setIsActive(true);
-          const startBlock = this.getCurrentBlock(workspace);
-          // Focus the start block in case one of its fields or a shadow block
+          const startDraggable = this.getCurrentDraggable(workspace);
+          // Focus the root draggable in case one of its children
           // was focused when the move was triggered.
-          if (startBlock) {
-            getFocusManager().focusNode(startBlock);
+          if (startDraggable) {
+            getFocusManager().focusNode(startDraggable);
           }
           return (
-            !!startBlock && this.mover.startMove(workspace, startBlock, null)
+            !!startDraggable &&
+            this.mover.startMove(workspace, startDraggable, MoveType.Move, null)
           );
         },
         keyCodes: [KeyCodes.M],
@@ -162,28 +169,52 @@ export class MoveActions {
           if (!workspace || menuOpenEvent instanceof PointerEvent)
             return 'hidden';
 
-          const startBlock = this.getCurrentBlock(workspace);
-          return !!startBlock && this.mover.canMove(workspace, startBlock)
+          const startDraggable = this.getCurrentDraggable(workspace);
+          return !!startDraggable &&
+            this.mover.canMove(workspace, startDraggable)
             ? 'enabled'
             : 'disabled';
         },
         callback: (scope) => {
           const workspace = scope.block?.workspace as WorkspaceSvg | null;
           if (!workspace) return false;
-          const startBlock = this.getCurrentBlock(workspace);
+          const startDraggable = this.getCurrentDraggable(workspace);
           // Focus the start block in case one of its fields or a shadow block
           // was focused when the move was triggered.
-          if (startBlock) {
-            getFocusManager().focusNode(startBlock);
+          if (startDraggable) {
+            getFocusManager().focusNode(startDraggable);
           }
           return (
-            !!startBlock && this.mover.startMove(workspace, startBlock, null)
+            !!startDraggable &&
+            this.mover.startMove(workspace, startDraggable, MoveType.Move, null)
           );
         },
         scopeType: ContextMenuRegistry.ScopeType.BLOCK,
         id: 'move',
         weight: 8.5,
       },
+      {
+        displayText: getMenuItem(
+          Msg['MOVE_COMMENT'] ?? 'Move Comment',
+          'start_move',
+        ),
+        preconditionFn: (scope, menuOpenEvent) => {
+          const comment = scope.comment;
+          if (!comment) return 'hidden';
+
+          return this.mover.canMove(comment.workspace, comment)
+            ? 'enabled'
+            : 'disabled';
+        },
+        callback: (scope) => {
+          const comment = scope.comment;
+          if (!comment) return false;
+          this.mover.startMove(comment.workspace, comment, MoveType.Move, null);
+        },
+        scopeType: ContextMenuRegistry.ScopeType.COMMENT,
+        id: 'move_comment',
+        weight: 8.5,
+      },
     ];
 
     for (const menuItem of menuItems) {
@@ -214,16 +245,21 @@ export class MoveActions {
   }
 
   /**
-   * Get the source block for the cursor location, or undefined if no
-   * source block can be found.
+   * Get the source draggable for the cursor location, or undefined if no
+   * source draggable can be found.
    * If the cursor is on a shadow block, walks up the tree until it finds
    * a non-shadow block to drag.
    *
    * @param workspace The workspace to inspect for a cursor.
-   * @returns The source block, or undefined if no appropriate block
+   * @returns The source draggable, or undefined if no appropriate draggable
    *     could be found.
    */
-  getCurrentBlock(workspace: WorkspaceSvg): BlockSvg | undefined {
+  getCurrentDraggable(
+    workspace: WorkspaceSvg,
+  ): (IDraggable & IFocusableNode & IBoundedElement & ISelectable) | undefined {
+    const node = getFocusManager().getFocusedNode();
+    if (node instanceof comments.RenderedWorkspaceComment) return node;
+
     let block = workspace?.getCursor()?.getSourceBlock();
     if (!block) return undefined;
     while (block.isShadow()) {