Create the block for the init method when creating a new OpMode.

Author: lizlooney

src/App.tsx

@@ -57,8 +57,6 @@ import * as commonStorage from './storage/common_storage';
 import * as ChangeFramework from './blocks/utils/change_framework'
 import {mutatorOpenListener}  from './blocks/mrc_class_method_def'
 
-import {create as createOpMode} from './modules/mrc_module_opmode'
-
 
 type NewWorkspaceNameModalProps = {
   isOpen: boolean;
@@ -552,9 +550,9 @@ const App: React.FC = () => {
   };
 
   const handleNewWorkspaceNameOk = (newWorkspaceName: string) => {
-    const newWorkspacePath = commonStorage.makeModulePath(newWorkspaceName, newWorkspaceName);
+    const newWorkspacePath = commonStorage.makeWorkspacePath(newWorkspaceName);
     if (newWorkspaceNameModalPurpose === 'NewWorkspace') {
-      const workspaceContent = commonStorage.newModuleContent(commonStorage.MODULE_TYPE_WORKSPACE);
+      const workspaceContent = commonStorage.newWorkspaceContent(newWorkspaceName);
       storage.createModule(
           commonStorage.MODULE_TYPE_WORKSPACE, newWorkspacePath, workspaceContent,
           (success: boolean, errorMessage: string) => {
@@ -631,7 +629,7 @@ const App: React.FC = () => {
   const handleNewOpModeNameOk = (workspaceName: string, newOpModeName: string) => {
     const newOpModePath = commonStorage.makeModulePath(workspaceName, newOpModeName);
     if (newOpModeNameModalPurpose === 'NewOpMode') {
-      const opModeContent = commonStorage.newModuleContent(commonStorage.MODULE_TYPE_OPMODE);
+      const opModeContent = commonStorage.newOpModeContent(workspaceName, newOpModeName);
       storage.createModule(
           commonStorage.MODULE_TYPE_OPMODE, newOpModePath, opModeContent,
           (success: boolean, errorMessage: string) => {
@@ -645,13 +643,6 @@ const App: React.FC = () => {
               setAlertErrorVisible(true);
             }
           });
-      // TODO: This needs to be changed based off the type
-      if (blocklyComponent.current){
-        const blocklyWorkspace = blocklyComponent.current.getBlocklyWorkspace();
-        if(blocklyComponent){
-          createOpMode(blocklyWorkspace);        
-        }
-      }
     } else if (newOpModeNameModalPurpose === 'RenameOpMode') {
       const workspaceName = commonStorage.getWorkspaceName(currentModulePath);
       const oldOpModeName = commonStorage.getModuleName(currentModulePath);

src/editor/editor.ts

@@ -104,7 +104,6 @@ export class Editor {
 
   public loadModuleBlocks(currentModule: commonStorage.Module | null) {
     this.currentModule = currentModule;
-    extendedPythonGenerator.setCurrentModule(currentModule);
     if (currentModule) {
       this.modulePath = currentModule.modulePath;
       this.workspacePath = commonStorage.makeWorkspacePath(currentModule.workspaceName);
@@ -214,6 +213,7 @@ export class Editor {
   }
 
   private getModuleContent(): string {
+    extendedPythonGenerator.setCurrentModule(this.currentModule);
     const pythonCode = extendedPythonGenerator.workspaceToCode(this.blocklyWorkspace);
     const exportedBlocks = JSON.stringify(extendedPythonGenerator.getExportedBlocks(this.blocklyWorkspace));
     const blocksContent = JSON.stringify(Blockly.serialization.workspaces.save(this.blocklyWorkspace));

src/modules/mrc_module_opmode.ts

@@ -1,7 +1,7 @@
 import * as Blockly from 'blockly';
 import { BLOCK_NAME as MRC_CLASS_METHOD_DEF } from '../blocks/mrc_class_method_def'
 
-export function create(workspace : Blockly.Workspace){
+export function create(workspace : Blockly.Workspace, render: boolean) {
     let initBlock = workspace.newBlock(MRC_CLASS_METHOD_DEF);
     initBlock.setFieldValue('init', 'NAME');
     const extra = {
@@ -14,6 +14,8 @@ export function create(workspace : Blockly.Workspace){
     if (initBlock.loadExtraState){
         initBlock.loadExtraState(extra);
     }
-    (initBlock as Blockly.BlockSvg).initSvg();
-    (initBlock as Blockly.BlockSvg).render();
-}
+    if (render) {
+        (initBlock as Blockly.BlockSvg).initSvg();
+        (initBlock as Blockly.BlockSvg).render();
+    }
+}

src/storage/common_storage.ts

@@ -19,7 +19,11 @@
  * @author [email protected] (Liz Looney)
  */
 
+import * as Blockly from 'blockly/core';
+
 import {Block} from "../toolbox/items";
+import {create as createOpMode} from '../modules/mrc_module_opmode'
+import {extendedPythonGenerator} from '../editor/extended_python_generator';
 
 // Types, constants, and functions related to modules, regardless of where the modules are stored.
 
@@ -129,34 +133,36 @@ export function makeUploadWorkspaceName(uploadFileName: string): string {
 }
 
 /**
- * Returns the module content for a new module.
+ * Returns the module content for a new Workspace.
  */
-export function newModuleContent(moduleType: string): string {
-  let pythonCode;
-  let blocksContent;
-  let exportedBlocks;
-
-  switch (moduleType) {
-    case MODULE_TYPE_WORKSPACE:
-      pythonCode = '';
-      blocksContent = '{}';
-      exportedBlocks = '[]';
-      break;
-    case MODULE_TYPE_OPMODE:
-      // TODO: Update the python code and blocks content here to be an OpMode.
-      pythonCode = '';
-      blocksContent = '{}';
-      exportedBlocks = '[]';
-      break;
-    case MODULE_TYPE_MECHANISM:
-      pythonCode = '';
-      blocksContent = '{}';
-      exportedBlocks = '[]';
-      break;
-    default:
-      throw new Error('Unexpected module type: ' + moduleType);
-  }
+export function newWorkspaceContent(workspaceName: string): string {
+  const pythonCode = '';
+  const exportedBlocks = '[]';
+  const blocksContent = '{}';
+  return makeModuleContent(pythonCode, exportedBlocks, blocksContent);
+}
+
+/**
+ * Returns the module content for a new OpMode.
+ */
+export function newOpModeContent(workspaceName: string, opModeName: string): string {
+  const module: Module = {
+    modulePath: makeModulePath(workspaceName, opModeName),
+    moduleType: MODULE_TYPE_OPMODE,
+    workspaceName: workspaceName,
+    moduleName: opModeName,
+    dateModifiedMillis: 0,
+  };
+
+  // Create a headless blockly workspace.
+  const headlessBlocklyWorkspace = new Blockly.Workspace();
+  headlessBlocklyWorkspace.options.oneBasedIndex = false;
+  createOpMode(headlessBlocklyWorkspace, false);
 
+  extendedPythonGenerator.setCurrentModule(module);
+  const pythonCode = extendedPythonGenerator.workspaceToCode(headlessBlocklyWorkspace);
+  const exportedBlocks = JSON.stringify(extendedPythonGenerator.getExportedBlocks(headlessBlocklyWorkspace));
+  const blocksContent = JSON.stringify(Blockly.serialization.workspaces.save(headlessBlocklyWorkspace));
   return makeModuleContent(pythonCode, exportedBlocks, blocksContent);
 }