TypeScript Dialog.cancelButton方法代码示例

  /**
   * Allows the user to clear state if splash screen takes too long.
   */
  function recover(fn: () => void): void {
    if (dialog) {
      return;
    }

    dialog = new Dialog({
      title: 'Loading...',
      body: `The loading screen is taking a long time.
        Would you like to clear the workspace or keep waiting?`,
      buttons: [
        Dialog.cancelButton({ label: 'Keep Waiting' }),
        Dialog.warnButton({ label: 'Clear Workspace' })
      ]
    });

    dialog
      .launch()
      .then(result => {
        if (result.button.accept) {
          return fn();
        }

        dialog.dispose();
        dialog = null;

        debouncer = window.setTimeout(() => {
          recover(fn);
        }, SPLASH_RECOVER_TIMEOUT);
      })
      .catch(() => {
        /* no-op */
      });
  }

 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;
       }
     }
   });
 }

 return context.listCheckpoints().then(checkpoints => {
   if (checkpoints.length < 1) {
     return;
   }
   const lastCheckpoint = checkpoints[checkpoints.length - 1];
   if (!lastCheckpoint) {
     return;
   }
   return showDialog({
     title: 'Revert notebook to checkpoint',
     body: new RevertConfirmWidget(lastCheckpoint),
     buttons: [
       Dialog.cancelButton(),
       Dialog.warnButton({ label: 'Revert' })
     ]
   }).then(result => {
     if (context.isDisposed) {
       return;
     }
     if (result.button.accept) {
       if (context.model.readOnly) {
         return context.revert();
       }
       return context.restoreCheckpoint().then(() => context.revert());
     }
   });
 });

 execute: () => {
   showDialog({
     title: 'Quit confirmation',
     body: 'Please confirm you want to quit JupyterLab.',
     buttons: [Dialog.cancelButton(), Dialog.warnButton({ label: 'Quit' })]
   }).then(result => {
     if (result.button.accept) {
       let setting = ServerConnection.makeSettings();
       let apiURL = URLExt.join(setting.baseUrl, 'api/shutdown');
       ServerConnection.makeRequest(apiURL, { method: 'POST' }, setting)
         .then(result => {
           if (result.ok) {
             // Close this window if the shutdown request has been successful
             let body = document.createElement('div');
             body.innerHTML = `<p>You have shut down the Jupyter server. You can now close this tab.</p>
               <p>To use JupyterLab again, you will need to relaunch it.</p>`;
             showDialog({
               title: 'Server stopped',
               body: new Widget({ node: body }),
               buttons: []
             });
             window.close();
           } else {
             throw new ServerConnection.ResponseError(result);
           }
         })
         .catch(data => {
           throw new ServerConnection.NetworkError(data);
         });
     }
   });
 }

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);
  });
}

 return context.listCheckpoints().then(checkpoints => {
   if (checkpoints.length < 1) {
     return;
   }
   const lastCheckpoint = checkpoints[checkpoints.length - 1];
   if (!lastCheckpoint) {
     return;
   }
   const type = fileType(shell.currentWidget, docManager);
   return showDialog({
     title: `Revert ${type} to checkpoint`,
     body: new RevertConfirmWidget(lastCheckpoint, type),
     buttons: [
       Dialog.cancelButton(),
       Dialog.warnButton({ label: 'Revert' })
     ]
   }).then(result => {
     if (context.isDisposed) {
       return;
     }
     if (result.button.accept) {
       if (context.model.readOnly) {
         return context.revert();
       }
       return context.restoreCheckpoint().then(() => context.revert());
     }
   });
 });

 return builder.build().then(() => {
   return showDialog({
     title: 'Build Complete',
     body: 'Build successfully completed, reload page?',
     buttons: [Dialog.cancelButton(),
               Dialog.warnButton({ label: 'RELOAD' })]
   });
 }).then(result => {

export function shouldOverwrite(path: string): Promise<boolean> {
  let options = {
    title: 'Overwrite file?',
    body: `"${path}" already exists, overwrite?`,
    buttons: [Dialog.cancelButton(), Dialog.warnButton({ label: 'OVERWRITE' })]
  };
  return showDialog(options).then(result => {
    return Promise.resolve(result.button.accept);
  });
}

 execute: () => {
   showDialog({
     title: 'Shutdown All?',
     body: 'Shut down all kernels?',
     buttons: [
       Dialog.cancelButton(), Dialog.warnButton({ label: 'SHUTDOWN' })
     ]
   }).then(result => {
     if (result.button.accept) {
       return app.serviceManager.sessions.shutdownAll();
     }
   });
 }

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;
  });
}