@fails-components/jupyter-applet-view 0.0.1-alpha.10

package/schema/plugin.json

@@ -0,0 +1,31 @@
+{
+  "jupyter.lab.shortcuts": [],
+  "title": "Applet view for Fails",
+  "description": "@fails-components/jupyter-applet-view settings.",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false,
+  "jupyter.lab.menus": {
+    "context": [
+      {
+        "type": "separator",
+        "selector": ".jp-Notebook .jp-Cell",
+        "rank": 70
+      },
+      {
+        "command": "fails-components-jupyter-applet-view:add_to_view",
+        "selector": ".jp-Notebook .jp-Cell",
+        "rank": 71
+      }
+    ]
+  },
+  "jupyter.lab.toolbars": {
+    "Cell": [
+      {
+        "name": "add_to_view",
+        "command": "fails-components-jupyter-applet-view:add_to_view",
+        "rank": 10
+      }
+    ]
+  }
+}

package/schema/toolbar.json

@@ -0,0 +1,8 @@
+{
+  "jupyter.lab.shortcuts": [],
+  "title": "Toolbar for applet view provided for Fails",
+  "description": "@fails-components/jupyter-applet-view toolbar.",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false
+}

package/src/appletview.ts

@@ -0,0 +1,395 @@
+import { JupyterFrontEnd, ILayoutRestorer } from '@jupyterlab/application';
+import { Cell } from '@jupyterlab/cells';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import {
+  INotebookTracker,
+  NotebookWidgetFactory,
+  NotebookTracker,
+  NotebookPanel
+} from '@jupyterlab/notebook';
+import { RestorablePool } from '@jupyterlab/statedb';
+import { ITranslator } from '@jupyterlab/translation';
+import {
+  addIcon,
+  moveUpIcon,
+  moveDownIcon,
+  caretUpIcon,
+  caretDownIcon,
+  deleteIcon
+} from '@jupyterlab/ui-components';
+import { ReadonlyPartialJSONObject } from '@lumino/coreutils';
+import { SplitViewNotebookWidgetFactory } from './splitviewnotebookpanel';
+import { SplitViewNotebookPanel } from './splitviewnotebookpanel';
+import { IFailsLauncherInfo } from '@fails-components/jupyter-launcher';
+import { IFailsInterceptor } from '@fails-components/jupyter-interceptor';
+
+// portions used from Jupyterlab:
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+// This code contains portions from or is inspired by Jupyter lab's notebook extension, especially the createOutputView part
+// Also a lot is taken from the cell toolbar related parts.
+export function activateAppletView(
+  app: JupyterFrontEnd,
+  docManager: IDocumentManager,
+  notebookTracker: INotebookTracker,
+  translator: ITranslator,
+  restorer: ILayoutRestorer | null,
+  failsLauncherInfo: IFailsLauncherInfo | null,
+  failsInterceptor: IFailsInterceptor | null
+): void {
+  if (app.namespace === 'JupyterLite Server') {
+    return;
+  }
+  console.log(
+    'JupyterLab extension @fails-components/jupyter-applet-view is activated!'
+  );
+  const trans = translator.load('fails_components_jupyter_applet_view');
+  const addToViewID = 'fails-components-jupyter-applet-view:add_to_view';
+  const moveViewUpID = 'fails-components-jupyter-applet-view:move_view_up';
+  const moveViewDownID = 'fails-components-jupyter-applet-view:move_view_down';
+  const moveViewAppUpID =
+    'fails-components-jupyter-applet-view:move_view_app_up';
+  const moveViewAppDownID =
+    'fails-components-jupyter-applet-view:move_view_app_down';
+  const deleteViewID = 'fails-components-jupyter-applet-view:delete_view';
+  /*const appletViewOutputs = new WidgetTracker<
+    MainAreaWidget<Private.AppletViewOutputArea>
+  >({
+    namespace: 'cloned-outputs'
+  });
+ 
+  if (restorer) {
+    void restorer.restore(appletViewOutputs, {
+      command: commandID,
+      args: widget => ({
+        path: widget.content.path,
+        indices: widget.content.indices
+      }),
+      name: widget =>
+        `${widget.content.path}:${widget.content.indices.join(':')}`,
+      when: notebookTracker.restored // After the notebook widgets (but not contents).
+    });
+  } */
+  const { commands, shell /* , serviceManager: services */ } = app;
+
+  const realFactory: NotebookWidgetFactory | undefined =
+    app.docRegistry.getWidgetFactory(
+      'Notebook'
+    ) as unknown as NotebookWidgetFactory;
+  const factoryName = 'Notebook'; //'SplitViewNotebook';
+  if (realFactory !== undefined) {
+    const factory = new SplitViewNotebookWidgetFactory({
+      name: factoryName,
+      label: trans.__('Notebook'),
+      fileTypes: ['notebook'],
+      modelName: 'notebook',
+      defaultFor: ['notebook'],
+      preferKernel: realFactory.preferKernel,
+      canStartKernel: true,
+      rendermime: realFactory.rendermime,
+      contentFactory: realFactory.contentFactory,
+      editorConfig: realFactory.editorConfig,
+      notebookConfig: realFactory.notebookConfig,
+      mimeTypeService: realFactory.mimeTypeService,
+      toolbarFactory: realFactory['_toolbarFactory'],
+      translator,
+      failsLauncherInfo:
+        failsLauncherInfo !== null ? failsLauncherInfo : undefined,
+      failsInterceptor: failsInterceptor !== null ? failsInterceptor : undefined
+    });
+    let id = 0;
+    // we need to clone the registration with the tracker from the plugin:
+    factory.widgetCreated.connect((sender, widget) => {
+      // If the notebook panel does not have an ID, assign it one.
+      widget.id = widget.id || `splitviewnotebook-${++id}`;
+      const ft = app.docRegistry.getFileType('notebook');
+      // Set up the title icon
+      widget.title.icon = ft?.icon;
+      widget.title.iconClass = ft?.iconClass ?? '';
+      widget.title.iconLabel = ft?.iconLabel ?? '';
+
+      // Notify the widget tracker if restore data needs to update.
+      const tracker = notebookTracker as NotebookTracker; // dirty hack, does only work as long we do not add anything to the model
+
+      /* widget.context.pathChanged.connect(() => {
+        void tracker.save(widget);
+      });  // may be we need this */
+      // Add the notebook panel to the tracker.
+      // void tracker.add(widget);
+      widget.context.fileChanged.connect(() => {
+        const model = widget.context.model;
+        const failsData = model.getMetadata('failsApp');
+        const currentSplitView = widget as SplitViewNotebookPanel;
+        if (currentSplitView.appletViewWidget) {
+          if (failsData) {
+            const outputarea = currentSplitView.appletViewWidget;
+            if (outputarea !== undefined) {
+              outputarea.loadData(failsData);
+            }
+          }
+        }
+      });
+      widget.context.saveState.connect((slot, savestate) => {
+        if (savestate === 'started') {
+          const currentSplitView = widget as SplitViewNotebookPanel;
+          const outputarea = currentSplitView.appletViewWidget;
+          if (outputarea !== undefined) {
+            const failsData = outputarea.saveData();
+            if (failsData) {
+              const model = widget.context.model;
+              model.setMetadata('failsApp', failsData);
+            }
+          }
+        }
+      });
+
+      // notebookTracker.inject(widget);
+      tracker.add(widget);
+      if (!notebookTracker.currentWidget) {
+        const pool = tracker['_pool'] as RestorablePool;
+        pool.current = widget;
+      }
+    });
+    // Handle state restoration.
+    // No the notebook should do this.
+    /* if (restorer) {
+      const tracker = notebookTracker as NotebookTracker;
+      void restorer.restore(tracker, {
+        command: 'docmanager:open',
+        args: panel => ({ path: panel.context.path, factory: factoryName }),
+        name: panel => panel.context.path,
+        when: services.ready
+      });
+    } */
+    // remove from registry, this is bad monkey patching
+    if (app.docRegistry['_widgetFactories']['notebook']) {
+      delete app.docRegistry['_widgetFactories']['notebook'];
+    }
+
+    app.docRegistry.addWidgetFactory(factory);
+    app.docRegistry.setDefaultWidgetFactory(
+      'notebook',
+      /* 'SplitViewNotebook'*/ 'Notebook'
+    );
+    // we have to register extensions previously added to the system, FIXME: maybe changed after decoupling from jupyter lab
+    /* const itExtension = app.docRegistry.widgetExtensions('Notebook');
+    for (const extension of itExtension) {
+      app.docRegistry.addWidgetExtension(factoryName, extension);
+    }*/
+  }
+
+  const canBeActivated = (): boolean => {
+    if (
+      notebookTracker.currentWidget === null ||
+      notebookTracker.currentWidget !== shell.currentWidget
+    ) {
+      return false;
+    }
+    const { content } = notebookTracker.currentWidget!;
+    const index = content.activeCellIndex;
+    // If there are selections that are not the active cell,
+    // this command is confusing, so disable it.
+    for (let i = 0; i < content.widgets.length; ++i) {
+      if (content.isSelected(content.widgets[i]) && i !== index) {
+        return false;
+      }
+    }
+    // If the cell is already added we deactivate as well
+    const currentSplitView =
+      notebookTracker.currentWidget as SplitViewNotebookPanel;
+    if (currentSplitView.appletViewWidget) {
+      const outputarea = currentSplitView.appletViewWidget;
+      if (outputarea !== undefined && outputarea.firstHasIndex(index)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  commands.addCommand(addToViewID, {
+    label: /* trans.__(*/ 'Add Output to first Applet view' /*)*/,
+    execute: async args => {
+      const path = args.path as string | undefined | null;
+      let index = args.index as number | undefined | null;
+      let current: NotebookPanel | undefined | null;
+      let cell: Cell | undefined;
+
+      // console.log('Add Output for path and index', path, index, args);
+      if (path && index !== undefined && index !== null) {
+        current = docManager.findWidget(
+          path,
+          'Notebook' /* may be needs adjustment later*/
+        ) as unknown as NotebookPanel;
+        if (!current) {
+          return;
+        }
+      } else {
+        current = notebookTracker.currentWidget;
+        if (!current) {
+          return;
+        }
+        cell = current.content.activeCell as Cell;
+        index = current.content.activeCellIndex;
+      }
+      // const pathid = current.context.path;
+      // console.log('debug current cell index', current, cell, index);
+      // TODO: Find area if it already exists, and add content
+      const currentSplitView = current as SplitViewNotebookPanel;
+      if (currentSplitView.appletViewWidget) {
+        const outputarea = currentSplitView.appletViewWidget;
+        if (outputarea !== undefined && !outputarea.firstHasIndex(index)) {
+          outputarea.addPart(undefined, { cell, index });
+        }
+      }
+    },
+    icon: args => (args.toolbar ? addIcon : undefined),
+    isEnabled: canBeActivated,
+    isVisible: canBeActivated
+  });
+
+  function getCurrentNotebook(
+    args: ReadonlyPartialJSONObject
+  ): NotebookPanel | undefined | null {
+    let current: NotebookPanel | undefined | null;
+    if (typeof args['notebookpath'] !== 'string') {
+      current = notebookTracker.currentWidget;
+      if (!current) {
+        return;
+      }
+    } else {
+      const path: string = args['notebookpath'];
+      current = docManager.findWidget(
+        path,
+        'Notebook' /* may be needs adjustment later*/
+      ) as unknown as NotebookPanel;
+      if (!current) {
+        return;
+      }
+    }
+    return current;
+  }
+
+  function moveWidgets(args: ReadonlyPartialJSONObject, delta: number) {
+    const current = getCurrentNotebook(args);
+    if (!current) {
+      return;
+    }
+    const currentSplitView = current as SplitViewNotebookPanel;
+    if (currentSplitView.appletViewWidget) {
+      const outputarea = currentSplitView.appletViewWidget;
+      const cellid = args.cellid as string;
+      const widgetid = args.widgetid as string;
+      const appid = outputarea.getWidgetAppId(widgetid);
+      if (typeof appid !== 'undefined') {
+        outputarea.movePart(appid, cellid, delta);
+      }
+    }
+  }
+
+  function moveWidgetsApp(args: ReadonlyPartialJSONObject, delta: number) {
+    const current = getCurrentNotebook(args);
+    if (!current) {
+      return;
+    }
+    const currentSplitView = current as SplitViewNotebookPanel;
+    if (currentSplitView.appletViewWidget) {
+      const outputarea = currentSplitView.appletViewWidget;
+      const cellid = args.cellid as string;
+      const widgetid = args.widgetid as string;
+      const appid = outputarea.getWidgetAppId(widgetid);
+      if (typeof appid !== 'undefined') {
+        outputarea.moveApp(appid, cellid, delta);
+      }
+    }
+  }
+
+  /*
+  function canMoveWidgetsApp(
+    args: ReadonlyPartialJSONObject,
+    delta: number
+  ): boolean {
+    const current = getCurrentNotebook(args);
+    if (!current) {
+      return false;
+    }
+    const currentSplitView = current as Private.SplitViewNotebookPanel;
+    if (currentSplitView.appletViewWidget) {
+      const outputarea = currentSplitView.appletViewWidget;
+      const cellid = args.cellid as string;
+      const widgetid = args.widgetid as string;
+      const appid = outputarea.getWidgetAppId(widgetid);
+      if (typeof appid !== 'undefined') {
+        return outputarea.canMoveApp(appid, cellid, delta);
+      }
+    }
+    return false;
+  }
+    */
+  commands.addCommand(moveViewUpID, {
+    label: /* trans.__(*/ 'Move view up' /*)*/,
+    execute: async args => {
+      moveWidgets(args, -1);
+    },
+    icon: args => (args.toolbar ? moveUpIcon : undefined),
+    isEnabled: () => true,
+    isVisible: () => true
+  });
+  commands.addCommand(moveViewDownID, {
+    label: /* trans.__(*/ 'Move view down' /*)*/,
+    execute: async args => {
+      moveWidgets(args, 1);
+    },
+    icon: args => (args.toolbar ? moveDownIcon : undefined),
+    isEnabled: () => true,
+    isVisible: () => true
+  });
+  commands.addCommand(moveViewAppUpID, {
+    label: /* trans.__(*/ 'Move view up to other app' /*)*/,
+    execute: async args => {
+      moveWidgetsApp(args, -1);
+    },
+    icon: args => (args.toolbar ? caretUpIcon : undefined),
+    isEnabled: () => true,
+    /* isEnabled: args => {
+      return canMoveWidgetsApp(args, -1);
+    },*/
+    isVisible: () => true
+  });
+  commands.addCommand(moveViewAppDownID, {
+    label: /* trans.__(*/ 'Move view down to other app' /*)*/,
+    execute: async args => {
+      moveWidgetsApp(args, 1);
+    },
+    icon: args => (args.toolbar ? caretDownIcon : undefined),
+    isEnabled: () => true,
+    /*isEnabled: args => {
+      return canMoveWidgetsApp(args, 1);
+    },*/
+    isVisible: () => true
+  });
+
+  commands.addCommand(deleteViewID, {
+    label: /* trans.__(*/ 'Delete view' /*)*/,
+    execute: async args => {
+      const current = getCurrentNotebook(args);
+      if (!current) {
+        return;
+      }
+      const currentSplitView = current as SplitViewNotebookPanel;
+      if (currentSplitView.appletViewWidget) {
+        const outputarea = currentSplitView.appletViewWidget;
+        const cellid = args.cellid as string;
+        const widgetid = args.widgetid as string;
+        const appid = outputarea.getWidgetAppId(widgetid);
+        if (typeof appid !== 'undefined') {
+          outputarea.deletePart(appid, cellid);
+        }
+      }
+    },
+    icon: args => (args.toolbar ? deleteIcon : undefined),
+    isEnabled: () => true,
+    isVisible: () => true
+  });
+}