Prevent multiple commands from running on MacOS

Author: Splines

src/manimShell.ts

@@ -37,6 +37,10 @@ enum ManimShellEvent {
     IPYTHON_CELL_FINISHED = 'ipythonCellFinished',
 }
 
+const MAC_OS_MULTIPLE_COMMANDS_ERROR = `On MacOS, we don't support running`
+    + ` multiple Manim commands at the same time. Please wait until the`
+    + ` current command has finished.`;
+
 /**
  * Wrapper around the IPython terminal that ManimGL uses. Ensures that commands
  * are executed at the right place and spans a new Manim session if necessary.
@@ -61,6 +65,15 @@ export class ManimShell {
      */
     private lockDuringStartup = false;
 
+    /**
+     * Whether to lock the execution of a new command while another command is
+     * currently running. On MacOS, we do lock since the IPython terminal *exits*
+     * when sending Ctrl+C instead of just interrupting the current command.
+     * See issue #16: https://github.com/bhoov/manim-notebook/issues/16
+     */
+    private shouldLockDuringCommandExecution = false;
+    private isExecutingCommand = false;
+
     /**
      * Whether to detect the end of a shell execution.
      * 
@@ -78,6 +91,11 @@ export class ManimShell {
 
     private constructor() {
         this.initiateTerminalDataReading();
+
+        // on MacOS
+        if (process.platform === "darwin") {
+            this.shouldLockDuringCommandExecution = true;
+        }
     }
 
     public static get instance(): ManimShell {
@@ -102,22 +120,36 @@ export class ManimShell {
      * @param [waitUntilFinished=false] Whether to wait until the actual command
      * has finished executing, e.g. when the whole animation has been previewed.
      */
-    public async executeCommand(command: string, startLine: number, waitUntilFinished = false) {
+    public async executeCommand(command: string, startLine: number,
+        waitUntilFinished = false, onCommandIssued?: () => void) {
         if (this.lockDuringStartup) {
             return vscode.window.showWarningMessage("Manim is currently starting. Please wait a moment.");
         }
+        if (this.shouldLockDuringCommandExecution && this.isExecutingCommand) {
+            return vscode.window.showWarningMessage(MAC_OS_MULTIPLE_COMMANDS_ERROR);
+        }
+
+        this.isExecutingCommand = true;
 
         this.lockDuringStartup = true;
         const shell = await this.retrieveOrInitActiveShell(startLine);
         this.lockDuringStartup = false;
 
         this.exec(shell, command);
+        if (onCommandIssued) {
+            onCommandIssued();
+        }
 
         if (waitUntilFinished) {
             await new Promise(resolve => {
                 this.eventEmitter.once(ManimShellEvent.IPYTHON_CELL_FINISHED, resolve);
             });
         }
+
+        this.eventEmitter.once(ManimShellEvent.IPYTHON_CELL_FINISHED, () => {
+            console.log("Finished command execution.");
+            this.isExecutingCommand = false;
+        });
     }
 
     /**
@@ -126,21 +158,34 @@ export class ManimShell {
      * @param command The command to execute in the VSCode terminal.
      * @param [waitUntilFinished=false] Whether to wait until the actual command
      * has finished executing, e.g. when the whole animation has been previewed.
+     * @param [forceExecute=false] Whether to force the execution of the command
+     * even if another command is currently running. This is only necessary when
+     * the `shouldLockDuringCommandExecution` is set to true.
      * @returns A boolean indicating whether an active shell was found or not.
      * If no active shell was found, the command was also not executed.
      */
     public async executeCommandEnsureActiveSession(
-        command: string, waitUntilFinished = false): Promise<boolean> {
+        command: string, waitUntilFinished = false, forceExecute = false): Promise<boolean> {
         if (!this.hasActiveShell()) {
             return Promise.resolve(false);
         }
+        if (this.shouldLockDuringCommandExecution && !forceExecute && this.isExecutingCommand) {
+            vscode.window.showWarningMessage(MAC_OS_MULTIPLE_COMMANDS_ERROR);
+            return Promise.resolve(true);
+        }
+
+        this.isExecutingCommand = true;
 
         this.exec(this.activeShell as Terminal, command);
         if (waitUntilFinished) {
             await new Promise(resolve => {
                 this.eventEmitter.once(ManimShellEvent.IPYTHON_CELL_FINISHED, resolve);
             });
         }
+
+        this.eventEmitter.once(ManimShellEvent.IPYTHON_CELL_FINISHED, () => {
+            this.isExecutingCommand = false;
+        });
         return Promise.resolve(true);
     }
 

src/previewCode.ts

@@ -6,21 +6,6 @@ const PREVIEW_COMMAND = `\x0C checkpoint_paste()\x1b`;
 // \x0C: is Ctrl + L
 // \x1b: https://github.com/bhoov/manim-notebook/issues/18#issuecomment-2431146809
 
-/**
- * Whether the extension is currently executing a Manim command.
- * 
- * Note that this is not capturing whether the `checkpoint_paste()` command is
- * still running. Instead, it only captures whether reading/writing to clipboard
- * is currently happening to prevent unpredictable behavior.
- * 
- * We don't need to capture the state of `checkpoint_paste()` because users
- * might actually want to preview a cell (or another one) again from the start
- * even though the animation is still running. With the new VSCode terminal
- * shell integration, it will automatically send a `Ctrl + C` to the terminal
- * when a new command is sent, so the previous command will be interrupted.
- */
-let isExecuting = false;
-
 /**
  * Interactively previews the given Manim code by means of the
  * `checkpoint_paste()` method from Manim.
@@ -37,26 +22,22 @@ let isExecuting = false;
  * @param code The code to preview (e.g. from a Manim cell or from a custom selection).
  */
 export async function previewCode(code: string, startLine: number): Promise<void> {
-    if (isExecuting) {
-        vscode.window.showInformationMessage('Please wait a few seconds, then try again.');
-        return;
-    }
-    isExecuting = true;
-
     try {
         const clipboardBuffer = await vscode.env.clipboard.readText();
         await vscode.env.clipboard.writeText(code);
 
-        await ManimShell.instance.executeCommand(PREVIEW_COMMAND, startLine);
-
-        // Restore original clipboard content
-        const timeout = vscode.workspace.getConfiguration("manim-notebook").clipboardTimeout;
-        setTimeout(async () => {
-            await vscode.env.clipboard.writeText(clipboardBuffer);
-        }, timeout);
+        await ManimShell.instance.executeCommand(
+            PREVIEW_COMMAND, startLine, true,
+            () => restoreClipboard(clipboardBuffer)
+        );
     } catch (error) {
         vscode.window.showErrorMessage(`Error: ${error}`);
-    } finally {
-        isExecuting = false;
     }
 }
+
+function restoreClipboard(clipboardBuffer: string) {
+    const timeout = vscode.workspace.getConfiguration("manim-notebook").clipboardTimeout;
+    setTimeout(async () => {
+        await vscode.env.clipboard.writeText(clipboardBuffer);
+    }, timeout);
+}

src/startStopScene.ts

@@ -108,7 +108,8 @@ export async function startScene(lineStart?: number) {
  * and the IPython terminal.
  */
 export async function exitScene() {
-    const success = await ManimShell.instance.executeCommandEnsureActiveSession("exit()");
+    const success = await ManimShell.instance.executeCommandEnsureActiveSession(
+        "exit()", false, true);
     if (success) {
         ManimShell.instance.resetActiveShell();
     } else {