NotebookWidgetFactory add toolbarItems option (#5363) (#5370)

* NotebookWidgetFactory add toolbarItems option (#5363)

* add toolbarItems option to docregistry

* add test for docregistry/default

* make _defaultToolbarItems protected

* use _overrideToolbarItems to save from options

* options: overrideToolbarItems -> toolbarItems

packages/docregistry/src/default.ts

@@ -290,6 +290,7 @@ export abstract class ABCWidgetFactory<
     this._modelName = options.modelName || 'text';
     this._preferKernel = !!options.preferKernel;
     this._canStartKernel = !!options.canStartKernel;
+    this._overrideToolbarItems = options.toolbarItems;
   }
 
   /**
@@ -378,6 +379,11 @@ export abstract class ABCWidgetFactory<
    */
   createNew(context: DocumentRegistry.IContext<U>): T {
     let widget = this.createNewWidget(context);
+    if (this._overrideToolbarItems) {
+      this._overrideToolbarItems.forEach(({ name, widget: item }) => {
+        widget.toolbar.addItem(name, item);
+      });
+    }
     this._widgetCreated.emit(widget);
     return widget;
   }
@@ -387,6 +393,10 @@ export abstract class ABCWidgetFactory<
    */
   protected abstract createNewWidget(context: DocumentRegistry.IContext<U>): T;
 
+  /**
+   * toolbar items to be added when createNew
+   */
+  protected _overrideToolbarItems: DocumentRegistry.IToolbarItem[] | undefined;
   private _isDisposed = false;
   private _name: string;
   private _readOnly: boolean;

packages/docregistry/src/registry.ts

@@ -624,6 +624,13 @@ export class DocumentRegistry implements IDisposable {
  * The namespace for the `DocumentRegistry` class statics.
  */
 export namespace DocumentRegistry {
+  /**
+   * The item to be added to document toolbar.
+   */
+  export interface IToolbarItem {
+    name: string;
+    widget: Widget;
+  }
   /**
    * The options used to create a document registry.
    */
@@ -923,6 +930,11 @@ export namespace DocumentRegistry {
      * Whether the widgets can start a kernel when opened.
      */
     readonly canStartKernel?: boolean;
+
+    /**
+     * Array of items to be added to document toolbar.
+     */
+    readonly toolbarItems?: DocumentRegistry.IToolbarItem[];
   }
 
   /**

packages/notebook/src/default-toolbar.ts

@@ -1,6 +1,8 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
 
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+
 import { Message } from '@phosphor/messaging';
 
 import { Widget } from '@phosphor/widgets';
@@ -190,6 +192,40 @@ export namespace ToolbarItems {
       Toolbar.createKernelStatusItem(panel.session)
     );
   }
+
+  /**
+   * Get the default toolbar items for panel
+   */
+  export function getDefaultItems(
+    panel: NotebookPanel
+  ): DocumentRegistry.IToolbarItem[] {
+    return [
+      { name: 'save', widget: createSaveButton(panel) },
+      { name: 'insert', widget: createInsertButton(panel) },
+      { name: 'cut', widget: createCutButton(panel) },
+      { name: 'copy', widget: createCopyButton(panel) },
+      { name: 'paste', widget: createPasteButton(panel) },
+      { name: 'run', widget: createRunButton(panel) },
+      {
+        name: 'interrupt',
+        widget: Toolbar.createInterruptButton(panel.session)
+      },
+      {
+        name: 'restart',
+        widget: Toolbar.createRestartButton(panel.session)
+      },
+      { name: 'cellType', widget: createCellTypeItem(panel) },
+      { name: 'spacer', widget: Toolbar.createSpacerItem() },
+      {
+        name: 'kernelName',
+        widget: Toolbar.createKernelNameItem(panel.session)
+      },
+      {
+        name: 'kernelStatus',
+        widget: Toolbar.createKernelStatusItem(panel.session)
+      }
+    ];
+  }
 }
 
 /**

packages/notebook/src/widgetfactory.ts

@@ -83,7 +83,9 @@ export class NotebookWidgetFactory extends ABCWidgetFactory<
     let content = this.contentFactory.createNotebook(nbOptions);
 
     let widget = new NotebookPanel({ context, content });
-    ToolbarItems.populateDefaults(widget);
+    if (!this._overrideToolbarItems) {
+      this._overrideToolbarItems = ToolbarItems.getDefaultItems(widget);
+    }
     return widget;
   }
 

tests/test-docregistry/src/default.spec.ts

@@ -3,6 +3,8 @@
 
 import { expect } from 'chai';
 
+import { toArray } from '@phosphor/algorithm';
+
 import { UUID } from '@phosphor/coreutils';
 
 import { Widget } from '@phosphor/widgets';
@@ -174,6 +176,25 @@ describe('docregistry/default', () => {
         });
         expect(factory.canStartKernel).to.equal(true);
       });
+
+      it('should have toolbar items', () => {
+        const factory = new WidgetFactory({
+          name: 'test',
+          fileTypes: ['text'],
+          toolbarItems: [
+            {
+              name: 'foo',
+              widget: new Widget()
+            },
+            {
+              name: 'bar',
+              widget: new Widget()
+            }
+          ]
+        });
+        const widget = factory.createNew(createFileContext());
+        expect(toArray(widget.toolbar.names())).to.deep.equal(['foo', 'bar']);
+      });
     });
 
     describe('#isDisposed', () => {

tests/test-notebook/src/widgetfactory.spec.ts

@@ -15,14 +15,17 @@ import { Context } from '@jupyterlab/docregistry';
 
 import { createNotebookContext, NBTestUtils } from '@jupyterlab/testutils';
 
+import { ToolbarButton } from '@jupyterlab/apputils';
+
 const contentFactory = NBTestUtils.createNotebookPanelFactory();
 const rendermime = NBTestUtils.defaultRenderMime();
 
-function createFactory(): NotebookWidgetFactory {
+function createFactory(toolbarItems?: any[]): NotebookWidgetFactory {
   return new NotebookWidgetFactory({
     name: 'notebook',
     fileTypes: ['notebook'],
     rendermime,
+    toolbarItems,
     contentFactory,
     mimeTypeService: NBTestUtils.mimeTypeService,
     editorConfig: NBTestUtils.defaultEditorConfig
@@ -116,6 +119,17 @@ describe('@jupyterlab/notebook', () => {
         expect(items).to.contain('restart');
         expect(items).to.contain('kernelStatus');
       });
+
+      it('should populate the customized toolbar items', () => {
+        const toolbars = [
+          { name: 'foo', widget: new ToolbarButton() },
+          { name: 'bar', widget: new ToolbarButton() }
+        ];
+        const factory = createFactory(toolbars);
+        const panel = factory.createNew(context);
+        const items = toArray(panel.toolbar.names());
+        expect(items).to.deep.equal(['foo', 'bar']);
+      });
     });
   });
 });