TypeScript application.ILabShell类代码示例

    execute: args => {
      const path = (args.path as string) || '';
      const browserForPath = Private.getBrowserForPath(path, factory);

      // Check for browser not found
      if (!browserForPath) {
        return;
      }
      // Shortcut if we are using the main file browser
      if (browser === browserForPath) {
        labShell.activateById(browser.id);
        return;
      } else {
        const areas: ILabShell.Area[] = ['left', 'right'];
        for (let area of areas) {
          const it = labShell.widgets(area);
          let widget = it.next();
          while (widget) {
            if (widget.contains(browserForPath)) {
              labShell.activateById(widget.id);
              return;
            }
            widget = it.next();
          }
        }
      }
    }

/**
 * Activate the default file browser in the sidebar.
 */
function activateBrowser(
  app: JupyterFrontEnd,
  factory: IFileBrowserFactory,
  docManager: IDocumentManager,
  labShell: ILabShell,
  restorer: ILayoutRestorer,
  settingRegistry: ISettingRegistry
): void {
  const browser = factory.defaultBrowser;
  const { commands } = app;

  // Let the application restorer track the primary file browser (that is
  // automatically created) for restoration of application state (e.g. setting
  // the file browser as the current side bar widget).
  //
  // All other file browsers created by using the factory function are
  // responsible for their own restoration behavior, if any.
  restorer.add(browser, namespace);

  addCommands(app, factory, labShell, docManager);

  browser.title.iconClass = 'jp-FolderIcon jp-SideBar-tabIcon';
  browser.title.caption = 'File Browser';
  labShell.add(browser, 'left', { rank: 100 });

  // If the layout is a fresh session without saved data, open file browser.
  labShell.restored.then(layout => {
    if (layout.fresh) {
      commands.execute(CommandIDs.showBrowser, void 0);
    }
  });

  Promise.all([app.restored, browser.model.restored]).then(() => {
    function maybeCreate() {
      // Create a launcher if there are no open items.
      if (labShell.isEmpty('main')) {
        Private.createLauncher(commands, browser);
      }
    }

    // When layout is modified, create a launcher if there are no open items.
    labShell.layoutModified.connect(() => {
      maybeCreate();
    });

    let navigateToCurrentDirectory: boolean = false;

    settingRegistry
      .load('@jupyterlab/filebrowser-extension:browser')
      .then(settings => {
        settings.changed.connect(settings => {
          navigateToCurrentDirectory = settings.get(
            'navigateToCurrentDirectory'
          ).composite as boolean;
        });
        navigateToCurrentDirectory = settings.get('navigateToCurrentDirectory')
          .composite as boolean;
      });

    // Whether to automatically navigate to a document's current directory
    labShell.currentChanged.connect((_, change) => {
      if (navigateToCurrentDirectory && change.newValue) {
        const { newValue } = change;
        const context = docManager.contextForWidget(newValue);
        if (context) {
          const { path } = context;
          Private.navigateToPath(path, factory)
            .then(() => {
              labShell.currentWidget.activate();
            })
            .catch((reason: any) => {
              console.warn(
                `${CommandIDs.navigate} failed to open: ${path}`,
                reason
              );
            });
        }
      }
    });

    maybeCreate();
  });
}

    execute: (args: JSONObject) => {
      const cwd = args['cwd'] ? String(args['cwd']) : '';
      const id = `launcher-${Private.id++}`;
      const callback = (item: Widget) => {
        labShell.add(item, 'main', { ref: id });
      };
      const launcher = new Launcher({ cwd, callback, commands });

      launcher.model = model;
      launcher.title.label = 'Launcher';
      launcher.title.iconClass = 'jp-LauncherIcon';

      let main = new MainAreaWidget({ content: launcher });

      // If there are any other widgets open, remove the launcher close icon.
      main.title.closable = !!toArray(labShell.widgets('main')).length;
      main.id = id;

      labShell.add(main, 'main', { activate: args['activate'] as boolean });

      labShell.layoutModified.connect(() => {
        // If there is only a launcher open, remove the close icon.
        main.title.closable = toArray(labShell.widgets('main')).length > 1;
      }, main);

      return main;
    }

 execute: () => {
   const widget = contextMenuWidget();
   if (!widget) {
     return;
   }
   const { id } = widget;
   const otherWidgets = toArray(labShell.widgets('main')).filter(
     widget => widget.id !== id
   );
   closeWidgets(otherWidgets);
 }

 const tabAreaFor = (widget: Widget): DockLayout.ITabAreaConfig | null => {
   const { mainArea } = labShell.saveLayout();
   if (mainArea.mode !== 'multiple-document') {
     return null;
   }
   let area = mainArea.dock.main;
   if (!area) {
     return null;
   }
   return findTab(area, widget);
 };

 execute: () => {
   const widget = tracker.currentWidget;
   if (widget && !widget.isHidden) {
     labShell.collapseLeft();
   }
 }

 function maybeCreate() {
   // Create a launcher if there are no open items.
   if (labShell.isEmpty('main')) {
     Private.createLauncher(commands, browser);
   }
 }

 execute: () => {
   if (labShell && !view.isHidden) {
     labShell.collapseLeft();
   }
 }

 isEnabled: () => {
   // Ensure there are at least two widgets.
   const iterator = labShell.widgets('main');
   return !!iterator.next() && !!iterator.next();
 },

 labShell.layoutModified.connect(() => {
   // If there is only a launcher open, remove the close icon.
   main.title.closable = toArray(labShell.widgets('main')).length > 1;
 }, main);

 const callback = (item: Widget) => {
   labShell.add(item, 'main', { ref: id });
 };

 () => {
   // If there is only a launcher open, remove the close icon.
   main.title.closable = toArray(labShell.widgets('main')).length > 1;
 },