/**
  * Construct a new "rename" dialog.
  */
 constructor(oldPath: string) {
   super({ node: Private.createRenameNode(oldPath) });
   this.addClass(FILE_DIALOG_CLASS);
   let ext = PathExt.extname(oldPath);
   let value = (this.inputNode.value = PathExt.basename(oldPath));
   this.inputNode.setSelectionRange(0, value.length - ext.length);
 }

 }).then(result => {
   if (!result.value) {
     return null;
   }
   let basePath = PathExt.dirname(oldPath);
   let newPath = PathExt.join(basePath, result.value);
   return renameFile(manager, oldPath, newPath);
 });

function diffNotebookCheckpoint(args: {readonly path: string, readonly rendermime: IRenderMimeRegistry}): Widget {
  const {path, rendermime} = args;
  let nb_dir = PathExt.dirname(path);
  let name = PathExt.basename(path, '.ipynb');
  let base = PathExt.join(nb_dir, name + '.ipynb');
  let widget = new NbdimeWidget({base, rendermime, baseLabel: 'Checkpoint'});
  widget.title.label = `Diff checkpoint: ${name}`;
  widget.title.caption = `Local: latest checkpoint\nRemote: '${path}'`;
  widget.title.iconClass = 'fa fa-clock-o jp-fa-tabIcon';
  return widget;
}

 }).then(result => {
   if (!isValidFileName(result.value)) {
     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);
 });

    execute: () => {
      let widget = tracker.currentWidget.content;

      if (!widget) {
        return;
      }

      let code = '';
      let editor = widget.editor;
      let text = editor.model.value.text;
      let path = widget.context.path;
      let extension = PathExt.extname(path);

      if (MarkdownCodeBlocks.isMarkdown(extension)) {
        // For Markdown files, run only code blocks.
        const blocks = MarkdownCodeBlocks.findMarkdownCodeBlocks(text);
        for (let block of blocks) {
          code += block.code;
        }
      } else {
        code = text;
      }

      const activate = false;
      if (code) {
        return commands.execute('console:inject', { activate, code, path });
      } else {
        return Promise.resolve(void 0);
      }
    },

  /**
   * Whether the notebook is in a git repository.
   */
  function hasGitNotebook(): boolean {
    if (!baseEnabled()) {
      return false;
    }

    let path = tracker.currentWidget!.context.path;
    let dir = PathExt.dirname(path);
    let known_git = lut_known_git[dir];
    if (known_git === undefined) {
      const inGitPromise = isNbInGit({path: dir});
      inGitPromise.then(inGit => {
        networkRetry = INITIAL_NETWORK_RETRY;
        lut_known_git[dir] = inGit;
        // Only update if false, since it is left enabled while waiting
        if (!inGit) {
          commands.notifyCommandChanged(CommandIDs.diffNotebookGit);
        }
      });
      inGitPromise.catch((reason) => {
        hasAPI = reason.status !== undefined && reason.status !== 404;
        setTimeout(() => {
          networkRetry *= 2;
          commands.notifyCommandChanged(CommandIDs.diffNotebook);
          commands.notifyCommandChanged(CommandIDs.diffNotebookCheckpoint);
          commands.notifyCommandChanged(CommandIDs.diffNotebookGit);
        }, networkRetry);
      });
      // Leave button enabled while unsure
      return true;
    }

    return known_git;
  }

 /**
  * Returns a mime type for the given file path.
  *
  * #### Notes
  * If a mime type cannot be found returns the default mime type `text/plain`, never `null`.
  */
 getMimeTypeByFilePath(path: string): string {
   if (PathExt.extname(path) === '.ipy') {
     return 'text/x-python';
   }
   let mode = Mode.findByFileName(path) || Mode.findBest('');
   return mode.mime;
 }

 /**
  * Returns a mime type for the given file path.
  *
  * #### Notes
  * If a mime type cannot be found returns the defaul mime type `text/plain`, never `null`.
  */
 getMimeTypeByFilePath(path: string): string {
   if (PathExt.extname(path) === '.ipy') {
     return 'text/x-python';
   }
   const mode = CodeMirror.findModeByFileName(path);
   return mode ? mode.mime : IEditorMimeTypeService.defaultMimeType;
 }

function diffNotebookGit(args: {readonly path: string, readonly rendermime: IRenderMimeRegistry}): Widget {
  const {path, rendermime} = args;
  let name = PathExt.basename(path, '.ipynb');
  let widget = new NbdimeWidget({base: path, rendermime});
  widget.title.label = `Diff git: ${name}`;
  widget.title.caption = `Local: git HEAD\nRemote: '${path}'`;
  widget.title.iconClass = 'fa fa-git jp-fa-tabIcon';
  return widget;
}

  /**
   * Handle the `'p-drop'` event for the widget.
   */
  private _evtDrop(event: IDragEvent): void {
    event.preventDefault();
    event.stopPropagation();
    if (event.proposedAction === 'none') {
      event.dropAction = 'none';
      return;
    }
    if (!event.mimeData.hasData(CONTENTS_MIME)) {
      return;
    }
    event.dropAction = event.proposedAction;

    let target = event.target as HTMLElement;
    while (target && target.parentElement) {
      if (target.classList.contains(DROP_TARGET_CLASS)) {
        target.classList.remove(DROP_TARGET_CLASS);
        break;
      }
      target = target.parentElement;
    }

    // Get the path based on the target node.
    let index = ArrayExt.findFirstIndex(this._crumbs, node => node === target);
    if (index === -1) {
      return;
    }

    const model = this._model;
    const path = PathExt.resolve(model.path, BREAD_CRUMB_PATHS[index]);
    const manager = model.manager;

    // Move all of the items.
    let promises: Promise<any>[] = [];
    let oldPaths = event.mimeData.getData(CONTENTS_MIME) as string[];
    for (let oldPath of oldPaths) {
      let localOldPath = manager.services.contents.localPath(oldPath);
      let name = PathExt.basename(localOldPath);
      let newPath = PathExt.join(path, name);
      promises.push(renameFile(manager, oldPath, newPath));
    }
    Promise.all(promises).catch(err => {
      showErrorMessage('Move Error', err);
    });
  }