TypeScript Dialog.okButton方法代碼示例

  export async function redirect(router: IRouter, warn = false): Promise<void> {
    const form = createRedirectForm(warn);
    const dialog = new Dialog({
      title: 'Please use a different workspace.',
      body: form,
      focusNodeSelector: 'input',
      buttons: [Dialog.okButton({ label: 'Switch Workspace' })]
    });

    const result = await dialog.launch();

    dialog.dispose();
    if (!result.value) {
      return redirect(router, true);
    }

    // Navigate to a new workspace URL and abandon this session altogether.
    const workspaces = PageConfig.getOption('workspacesUrl');
    const url = URLExt.join(workspaces, result.value);

    router.navigate(url, { hard: true, silent: true });

    // This promise will never resolve because the application navigates
    // away to a new location. It only exists to satisfy the return type
    // of the `redirect` function.
    return new Promise<void>(() => undefined);
  }

 function trust(widget: Notebook): Promise<void> {
   if (!widget.model) {
     return Promise.resolve(void 0);
   }
   // Do nothing if already trusted.
   let cells = widget.model.cells;
   let trusted = true;
   for (let i = 0; i < cells.length; i++) {
     let cell = cells.get(i);
     if (!cell.trusted) {
       trusted = false;
     }
   }
   if (trusted) {
     return showDialog({
       body: 'Notebook is already trusted',
       buttons: [Dialog.okButton()]
     }).then(() => void 0);
   }
   return showDialog({
     body: TRUST_MESSAGE,
     title: 'Trust this notebook?',
     buttons: [Dialog.cancelButton(), Dialog.warnButton()]
   }).then(result => {
     if (result.button.accept) {
       for (let i = 0; i < cells.length; i++) {
         let cell = cells.get(i);
         cell.trusted = true;
       }
     }
   });
 }

  export function redirect(router: IRouter, warn = false): Promise<void> {
    const form = createRedirectForm(warn);
    const dialog = new Dialog({
      title: 'Please use a different workspace.',
      body: form,
      focusNodeSelector: 'input',
      buttons: [Dialog.okButton({ label: 'Switch Workspace' })]
    });

    return dialog.launch().then(result => {
      dialog.dispose();

      if (result.value) {
        const url = `workspaces/${result.value}`;

        // Navigate to a new workspace URL and abandon this session altogether.
        router.navigate(url, { hard: true, silent: true });

        // This promise will never resolve because the application navigates
        // away to a new location. It only exists to satisfy the return type
        // of the `redirect` function.
        return new Promise<void>(() => {
          /* no-op */
        });
      }

      return redirect(router, true);
    });
  }

export function renameDialog(
  manager: IDocumentManager,
  oldPath: string
): Promise<Contents.IModel | null> {
  return showDialog({
    title: 'Rename File',
    body: new RenameHandler(oldPath),
    focusNodeSelector: 'input',
    buttons: [Dialog.cancelButton(), Dialog.okButton({ label: 'RENAME' })]
  }).then(result => {
    if (!result.value) {
      return;
    }
    if (!isValidFileName(result.value)) {
      void showErrorMessage(
        'Rename Error',
        Error(
          `"${result.value}" is not a valid name for a file. ` +
            `Names must have nonzero length, ` +
            `and cannot include "/", "\\", or ":"`
        )
      );
      return null;
    }
    let basePath = PathExt.dirname(oldPath);
    let newPath = PathExt.join(basePath, result.value);
    return renameFile(manager, oldPath, newPath);
  });
}

  export async function redirect(
    router: IRouter,
    paths: JupyterFrontEnd.IPaths,
    workspace: string,
    warn = false
  ): Promise<void> {
    const form = createRedirectForm(warn);
    const dialog = new Dialog({
      title: 'Please use a different workspace.',
      body: form,
      focusNodeSelector: 'input',
      buttons: [Dialog.okButton({ label: 'Switch Workspace' })]
    });
    const result = await dialog.launch();

    dialog.dispose();
    if (!result.value) {
      return redirect(router, paths, workspace, true);
    }

    // Navigate to a new workspace URL and abandon this session altogether.
    const page = paths.urls.page;
    const workspaces = paths.urls.workspaces;
    const prefix = (workspace ? workspaces : page).length + workspace.length;
    const rest = router.current.request.substring(prefix);
    const url = URLExt.join(workspaces, result.value, rest);

    router.navigate(url, { hard: true, silent: true });

    // This promise will never resolve because the application navigates
    // away to a new location. It only exists to satisfy the return type
    // of the `redirect` function.
    return new Promise<void>(() => undefined);
  }

 }, () => {
   // does not exist
   return showDialog({
     title: 'Cannot open',
     body: 'File not found',
     buttons: [Dialog.okButton()]
   });
 });

 execute: () => {
   let msg = 'The quick brown fox jumped over the lazy dog';
   showDialog({
     title: 'Cool Title',
     body: msg,
     buttons: [Dialog.okButton()]
   });
 }

function showErrorMessage(title: string, error: Error): Promise<void> {
  console.error(error);
  let options = {
    title: title,
    body: error.message || `File ${title}`,
    buttons: [Dialog.okButton()],
    okText: 'DISMISS'
  };
  return showDialog(options).then(() => { /* no-op */ });
}

export function getOpenPath(contentsManager: any): Promise<string | undefined> {
  return showDialog({
    title: 'Open File',
    body: new OpenDirectWidget(),
    buttons: [Dialog.cancelButton(), Dialog.okButton({ label: 'OPEN' })],
    focusNodeSelector: 'input'
  }).then((result: any) => {
    if (result.button.label === 'OPEN') {
      return result.value;
    }
    return;
  });
}

 execute: () => {
   if (isEnabled()) {
     let context = docManager.contextForWidget(app.shell.currentWidget);
     if (context.model.readOnly) {
       return showDialog({
         title: 'Cannot Save',
         body: 'Document is read-only',
         buttons: [Dialog.okButton()]
       });
     }
     return context.save().then(() => context.createCheckpoint());
   }
 }