TypeScript InstanceTracker.add方法代码示例

        .then(session => {
          term.session = session;
          void tracker.add(main);
          app.shell.activateById(main.id);

          return main;
        })

/**
 * Activate the file browser factory provider.
 */
function activateFactory(app: JupyterLab, docManager: IDocumentManager, state: IStateDB): IFileBrowserFactory {
  const { commands, shell } = app;
  const tracker = new InstanceTracker<FileBrowser>({ namespace, shell });

  return {
    createFileBrowser(id: string, options: IFileBrowserFactory.IOptions = {}): FileBrowser {
      const model = new FileBrowserModel({
        manager: options.documentManager || docManager,
        state: options.state === null ? null : options.state || state
      });
      const widget = new FileBrowser({
        id, model, commands: options.commands || commands
      });
      const { registry } = docManager;

      // Add a context menu handler to the file browser's directory listing.
      let node = widget.node.getElementsByClassName('jp-DirListing-content')[0];
      node.addEventListener('contextmenu', (event: MouseEvent) => {
        event.preventDefault();
        const path = widget.pathForClick(event) || '';
        const menu = createContextMenu(path, commands, registry);
        menu.open(event.clientX, event.clientY);
      });

      // Track the newly created file browser.
      tracker.add(widget);

      return widget;
    },
    tracker
  };
}

      return promise.then(session => {
        term.session = session;
        tracker.add(main);
        shell.activateById(main.id);

        return main;
      }).catch(() => { term.dispose(); });

    execute: async args => {
      // wait for the widget to lazy load
      let Terminal: typeof WidgetModuleType.Terminal;
      try {
        Terminal = (await Private.ensureWidget()).Terminal;
      } catch (err) {
        Private.showErrorMessage(err);
      }

      const name = args['name'] as string;
      const term = new Terminal();

      term.title.icon = TERMINAL_ICON_CLASS;
      term.title.label = '...';
      let main = new MainAreaWidget({ content: term });
      app.shell.add(main);

      try {
        term.session = await (name
          ? serviceManager.terminals
              .connectTo(name)
              .catch(() => serviceManager.terminals.startNew())
          : serviceManager.terminals.startNew());

        void tracker.add(main);
        app.shell.activateById(main.id);

        return main;
      } catch {
        term.dispose();
      }
    }

 factory.widgetCreated.connect((sender, widget) => {
   Private.factoryNameProperty.set(widget, factory.name);
   // Notify the instance tracker if restore data needs to update.
   widget.context.pathChanged.connect(() => {
     void tracker.save(widget);
   });
   void tracker.add(widget);
 });

 function openInspector(): MainAreaWidget<InspectorPanel> {
   if (!inspector || inspector.isDisposed) {
     inspector = new MainAreaWidget({ content: new InspectorPanel() });
     inspector.id = 'jp-inspector';
     inspector.title.label = title;
     tracker.add(inspector);
     source = source && !source.isDisposed ? source : null;
     inspector.content.source = source;
   }
   if (!inspector.isAttached) {
     shell.add(inspector, 'main', { activate: false });
   }
   shell.activateById(inspector.id);
   return inspector;
 }

    /**
     * Create and track a new inspector.
     */
    function newInspectorPanel(): InspectorPanel {
      const inspector = new InspectorPanel();

      inspector.id = 'jp-inspector';
      inspector.title.label = 'Inspector';
      inspector.title.closable = true;
      inspector.disposed.connect(() => {
        if (manager.inspector === inspector) {
          manager.inspector = null;
        }
      });

      // Track the inspector.
      tracker.add(inspector);

      // Add the default inspector child items.
      Private.defaultInspectorItems.forEach(item => { inspector.add(item); });

      return inspector;
    }

    /**
     * Create and track a new inspector.
     */
    function newInspectorPanel(): InspectorPanel {
      const inspector = new InspectorPanel();

      inspector.id = 'jp-inspector';
      inspector.title.label = 'Inspector';
      inspector.disposed.connect(() => {
        if (manager.inspector === inspector) {
          manager.inspector = null;
        }
      });

      // Track the inspector.
      let widget = new MainAreaWidget({ content: inspector });
      tracker.add(widget);

      // Add the default inspector child items.
      Private.defaultInspectorItems.forEach(item => { inspector.add(item); });

      return inspector;
    }

      execute: () => {
        if (tracker.currentWidget) {
          shell.activateById(tracker.currentWidget.id);
          return;
        }

        const key = plugin.id;
        const when = app.restored;
        const editor = new SettingEditor({
          editorFactory, key, registry, state, when
        });

        tracker.add(editor);
        editor.id = namespace;
        editor.title.label = 'Settings';
        editor.title.iconClass = 'jp-SettingsIcon';
        editor.title.closable = true;
        shell.addToMainArea(editor);
        shell.activateById(editor.id);
      },

/**
 * Activate the file browser factory provider.
 */
function activateFactory(app: JupyterLab, serviceManager: IServiceManager, documentManager: IDocumentManager, state: IStateDB): IFileBrowserFactory {
  const { commands, shell } = app;
  const tracker = new InstanceTracker<FileBrowser>({ namespace, shell });

  return {
    createFileBrowser(id: string, options: IFileBrowserFactory.IOptions = {}): FileBrowser {
      const widget = new FileBrowser({
        commands: options.commands || commands,
        id: id,
        manager: options.documentManager || documentManager,
        model: new FileBrowserModel({
          manager: options.serviceManager || serviceManager,
          state: options.state === null ? null : options.state || state
        })
      });

      tracker.add(widget);
      return widget;
    }
  };
}